MySQL 8.4.3
Source Code Documentation
log_event.h
Go to the documentation of this file.
1/* Copyright (c) 2000, 2024, Oracle and/or its affiliates.
2
3 This program is free software; you can redistribute it and/or modify
4 it under the terms of the GNU General Public License, version 2.0,
5 as published by the Free Software Foundation.
6
7 This program is designed to work with certain software (including
8 but not limited to OpenSSL) that is licensed under separate terms,
9 as designated in a particular file or component or in included license
10 documentation. The authors of MySQL hereby grant you an additional
11 permission to link the program and your derivative works with the
12 separately licensed software that they have either included with
13 the program or referenced in the documentation.
14
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License, version 2.0, for more details.
19
20 You should have received a copy of the GNU General Public License
21 along with this program; if not, write to the Free Software
22 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */
23
24/**
25 @file sql/log_event.h
26
27 @brief Binary log event definitions. This includes generic code
28 common to all types of log events, as well as specific code for each
29 type of log event.
30
31 @addtogroup Replication
32 @{
33*/
34
35#ifndef _log_event_h
36#define _log_event_h
37
38#include <atomic>
39#include <cstdint>
40#include <functional>
41#include <list>
42#include <map>
43#include <set>
44#include <string>
45#include <string_view>
46
47#include "m_string.h" // native_strncasecmp
48#include "my_bitmap.h" // MY_BITMAP
49#include "my_checksum.h" // ha_checksum
50#include "my_dbug.h"
51#include "my_inttypes.h"
52#include "my_psi_config.h"
53#include "my_sharedlib.h"
54#include "my_sys.h"
55#include "my_thread_local.h"
62#include "mysql/gtid/uuid.h"
65#include "mysql_com.h" // SERVER_VERSION_LENGTH
66#include "partition_info.h"
67#include "sql/query_options.h" // OPTION_AUTO_IS_NULL
68#include "sql/rpl_gtid.h" // enum_gtid_type
69#include "sql/rpl_utility.h" // Hash_slave_rows
70#include "sql/sql_const.h"
71#include "sql/thr_malloc.h"
72#include "sql_string.h"
73#include "string_with_len.h"
74#include "strmake.h"
75#include "typelib.h" // TYPELIB
76
77namespace mysql::binlog::event {
78class Table_id;
79} // namespace mysql::binlog::event
80
81class THD;
82struct CHARSET_INFO;
83
84enum class enum_row_image_type;
85class Basic_ostream;
86
87#ifdef MYSQL_SERVER
88#include <stdio.h>
89
90#include "my_compiler.h"
91#include "sql/changestreams/misc/replicated_columns_view.h" // ReplicatedColumnsView
92#include "sql/key.h"
93#include "sql/rpl_filter.h" // rpl_filter
94#include "sql/table.h"
95#include "sql/xa.h"
96#endif
97
98#ifndef MYSQL_SERVER
99#include "sql/rpl_tblmap.h" // table_mapping
100#endif
101
102#include <limits.h>
103#include <stdint.h>
104#include <string.h>
105#include <sys/types.h>
106#include <time.h>
107
108#ifdef HAVE_PSI_STAGE_INTERFACE
110#endif
111
112#ifndef MYSQL_SERVER
114#endif
115
119
120#if defined(MYSQL_SERVER)
121using ColumnViewPtr = std::unique_ptr<cs::util::ReplicatedColumnsView>;
122#endif
123
124using sql_mode_t = uint64_t;
126
128#if defined(MYSQL_SERVER)
129int ignored_error_code(int err_code);
130#endif
131#define PREFIX_SQL_LOAD "SQL_LOAD-"
132
133/**
134 Maximum length of the name of a temporary file
135 PREFIX LENGTH - 9
136 UUID - UUID_LENGTH
137 SEPARATORS - 2
138 SERVER ID - 10 (range of server ID 1 to (2^32)-1 = 4,294,967,295)
139 FILE ID - 10 (uint)
140 EXTENSION - 7 (Assuming that the extension is always less than 7
141 characters)
142*/
143#define TEMP_FILE_MAX_LEN UUID_LENGTH + 38
144
145/**
146 Either assert or return an error.
147
148 In debug build, the condition will be checked, but in non-debug
149 builds, the error code given will be returned instead.
150
151 @param COND Condition to check
152 @param ERRNO Error number to return in non-debug builds
153*/
154#ifdef NDEBUG
155#define ASSERT_OR_RETURN_ERROR(COND, ERRNO) \
156 do { \
157 if (!(COND)) return ERRNO; \
158 } while (0)
159#else
160#define ASSERT_OR_RETURN_ERROR(COND, ERRNO) assert(COND)
161#endif
162
163#define LOG_EVENT_OFFSET 4
164
165#define NUM_LOAD_DELIM_STRS 5
166
167/*****************************************************************************
168
169 MySQL Binary Log
170
171 This log consists of events. Each event has a fixed-length header,
172 possibly followed by a variable length data body.
173
174 The data body consists of an optional fixed length segment (post-header)
175 and an optional variable length segment.
176
177 See the #defines below for the format specifics.
178
179 The events which really update data are Query_log_event,
180 Execute_load_query_log_event and old Load_log_event and
181 Execute_load_log_event events (Execute_load_query is used together with
182 Begin_load_query and Append_block events to replicate LOAD DATA INFILE.
183 Create_file/Append_block/Execute_load (which includes Load_log_event)
184 were used to replicate LOAD DATA before the 5.0.3).
185
186 ****************************************************************************/
187
188#define MAX_LOG_EVENT_HEADER \
189 ( /* in order of Query_log_event::write */ \
190 (LOG_EVENT_HEADER_LEN + /* write_header */ \
191 mysql::binlog::event::Binary_log_event::QUERY_HEADER_LEN + /* write_data \
192 */ \
193 mysql::binlog::event::Binary_log_event:: \
194 EXECUTE_LOAD_QUERY_EXTRA_HEADER_LEN) + /*write_post_header_for_derived \
195 */ \
196 MAX_SIZE_LOG_EVENT_STATUS + /* status */ \
197 NAME_LEN + \
198 1)
199
200/* slave event post-header (this event is never written) */
202#define SL_MASTER_PORT_OFFSET 8
203#define SL_MASTER_POS_OFFSET 0
204#define SL_MASTER_HOST_OFFSET 10
205
206/* Intvar event post-header */
208/* Intvar event data */
209#define I_TYPE_OFFSET 0
210#define I_VAL_OFFSET 1
212/* 4 bytes which all binlogs should begin with */
213#define BINLOG_MAGIC "\xfe\x62\x69\x6e"
214#define BINLOG_MAGIC_SIZE 4
215
216/**
217 @addtogroup group_cs_binglog_event_header_flags Binlog Event Header Flags
218 @ingroup group_cs
219 @{
220*/
221
222/*
223 The 2 flags below were useless :
224 - the first one was never set
225 - the second one was set in all Rotate events on the master, but not used for
226 anything useful.
227 So they are now removed and their place may later be reused for other
228 flags. Then one must remember that Rotate events in 4.x have
229 LOG_EVENT_FORCED_ROTATE_F set, so one should not rely on the value of the
230 replacing flag when reading a Rotate event.
231 I keep the defines here just to remember what they were.
232
233 #define LOG_EVENT_TIME_F 0x1
234 #define LOG_EVENT_FORCED_ROTATE_F 0x2
235*/
236
237/**
238 @def LOG_EVENT_THREAD_SPECIFIC_F
239
240 If the query depends on the thread (for example: TEMPORARY TABLE).
241 Currently this is used by mysqlbinlog to know it must print
242 SET @@PSEUDO_THREAD_ID=xx; before the query (it would not hurt to print it
243 for every query but this would be slow).
244*/
245#define LOG_EVENT_THREAD_SPECIFIC_F 0x4
246
247/**
248 @def LOG_EVENT_SUPPRESS_USE_F
249
250 Suppress the generation of 'USE' statements before the actual
251 statement. This flag should be set for any events that does not need
252 the current database set to function correctly. Most notable cases
253 are 'CREATE DATABASE' and 'DROP DATABASE'.
254
255 This flags should only be used in exceptional circumstances, since
256 it introduce a significant change in behaviour regarding the
257 replication logic together with the flags --binlog-do-db and
258 --replicated-do-db.
259 */
260#define LOG_EVENT_SUPPRESS_USE_F 0x8
261
262/*
263 Note: this is a place holder for the flag
264 LOG_EVENT_UPDATE_TABLE_MAP_VERSION_F (0x10), which is not used any
265 more, please do not reused this value for other flags.
266 */
267
268/**
269 @def LOG_EVENT_ARTIFICIAL_F
270
271 Artificial events are created arbitrarily and not written to binary
272 log
273
274 These events should not update the master log position when slave
275 SQL thread executes them.
276*/
277#define LOG_EVENT_ARTIFICIAL_F 0x20
278
279/**
280 @def LOG_EVENT_RELAY_LOG_F
281
282 Events with this flag set are created by slave IO thread and written
283 to relay log
284*/
285#define LOG_EVENT_RELAY_LOG_F 0x40
286
287/**
288 @def LOG_EVENT_IGNORABLE_F
289
290 For an event, 'e', carrying a type code, that a slave,
291 's', does not recognize, 's' will check 'e' for
292 LOG_EVENT_IGNORABLE_F, and if the flag is set, then 'e'
293 is ignored. Otherwise, 's' acknowledges that it has
294 found an unknown event in the relay log.
295*/
296#define LOG_EVENT_IGNORABLE_F 0x80
297
298/**
299 @def LOG_EVENT_NO_FILTER_F
300
301 Events with this flag are not filtered (e.g. on the current
302 database) and are always written to the binary log regardless of
303 filters.
304*/
305#define LOG_EVENT_NO_FILTER_F 0x100
306
307/**
308 MTS: group of events can be marked to force its execution
309 in isolation from any other Workers.
310 So it's a marker for Coordinator to memorize and perform necessary
311 operations in order to guarantee no interference from other Workers.
312 The flag can be set ON only for an event that terminates its group.
313 Typically that is done for a transaction that contains
314 a query accessing more than OVER_MAX_DBS_IN_EVENT_MTS databases.
315*/
316#define LOG_EVENT_MTS_ISOLATE_F 0x200
317
318/** @}*/
319
320/**
321 @def OPTIONS_WRITTEN_TO_BIN_LOG
322
323 OPTIONS_WRITTEN_TO_BIN_LOG are the bits of thd->options which must
324 be written to the binlog. OPTIONS_WRITTEN_TO_BIN_LOG could be
325 written into the Format_description_log_event, so that if later we
326 don't want to replicate a variable we did replicate, or the
327 contrary, it's doable. But it should not be too hard to decide once
328 for all of what we replicate and what we don't, among the fixed 32
329 bits of thd->options.
330
331 I (Guilhem) have read through every option's usage, and it looks
332 like OPTION_AUTO_IS_NULL and OPTION_NO_FOREIGN_KEYS are the only
333 ones which alter how the query modifies the table. It's good to
334 replicate OPTION_RELAXED_UNIQUE_CHECKS too because otherwise, the
335 slave may insert data slower than the master, in InnoDB.
336 OPTION_BIG_SELECTS is not needed (the slave thread runs with
337 max_join_size=HA_POS_ERROR) and OPTION_BIG_TABLES is not needed
338 either, as the manual says (because a too big in-memory temp table
339 is automatically written to disk).
340*/
341#define OPTIONS_WRITTEN_TO_BIN_LOG \
342 (OPTION_AUTO_IS_NULL | OPTION_NO_FOREIGN_KEY_CHECKS | \
343 OPTION_RELAXED_UNIQUE_CHECKS | OPTION_NOT_AUTOCOMMIT)
345/* Shouldn't be defined before */
346#define EXPECTED_OPTIONS \
347 ((1ULL << 14) | (1ULL << 26) | (1ULL << 27) | (1ULL << 19))
348
349#if OPTIONS_WRITTEN_TO_BIN_LOG != EXPECTED_OPTIONS
350#error OPTIONS_WRITTEN_TO_BIN_LOG must NOT change their values!
351#endif
352#undef EXPECTED_OPTIONS /* You shouldn't use this one */
353
354/**
355 Maximum value of binlog logical timestamp.
356*/
357const int64 SEQ_MAX_TIMESTAMP = LLONG_MAX;
358
359/**
360 This method is used to extract the partition_id
361 from a partitioned table.
362
363 @param part_info an object of class partition_info it will be used
364 to call the methods responsible for returning the
365 value of partition_id
366
367 @retval The return value is the partition_id.
368
369*/
370int get_rpl_part_id(partition_info *part_info);
371
372#ifdef MYSQL_SERVER
373class Item;
374class Protocol;
376class Slave_worker;
377class sql_exchange;
378template <class T>
379class List;
380#endif
381
382class Relay_log_info;
383class Gtid_log_event;
384
385#ifndef MYSQL_SERVER
386enum enum_base64_output_mode {
387 BASE64_OUTPUT_NEVER = 0,
388 BASE64_OUTPUT_AUTO = 1,
389 BASE64_OUTPUT_UNSPEC = 2,
390 BASE64_OUTPUT_DECODE_ROWS = 3,
391 /* insert new output modes here */
392 BASE64_OUTPUT_MODE_COUNT
393};
394
395/*
396 A structure for mysqlbinlog to know how to print events
397
398 This structure is passed to the event's print() methods,
399
400 There are two types of settings stored here:
401 1. Last db, flags2, sql_mode etc comes from the last printed event.
402 They are stored so that only the necessary USE and SET commands
403 are printed.
404 2. Other information on how to print the events, e.g. short_form,
405 hexdump_from. These are not dependent on the last event.
406*/
407struct PRINT_EVENT_INFO {
408 /*
409 Settings for database, sql_mode etc that comes from the last event
410 that was printed. We cache these so that we don't have to print
411 them if they are unchanged.
412 */
413 // TODO: have the last catalog here ??
414 char db[FN_REFLEN + 1]; // TODO: make this a LEX_STRING when thd->db is
415 bool flags2_inited;
416 uint32 flags2;
417 bool sql_mode_inited;
418 sql_mode_t sql_mode; /* must be same as THD.variables.sql_mode */
419 ulong auto_increment_increment, auto_increment_offset;
420 bool charset_inited;
421 char charset[6]; // 3 variables, each of them storable in 2 bytes
422 char time_zone_str[MAX_TIME_ZONE_NAME_LENGTH];
423 uint lc_time_names_number;
424 uint charset_database_number;
425 uint default_collation_for_utf8mb4_number;
426 uint8_t sql_require_primary_key;
428 bool thread_id_printed;
429 uint8_t default_table_encryption;
430
431 PRINT_EVENT_INFO();
432
433 ~PRINT_EVENT_INFO() {
434 close_cached_file(&head_cache);
435 close_cached_file(&body_cache);
436 close_cached_file(&footer_cache);
437 }
438 bool init_ok() /* tells if construction was successful */
439 {
440 return my_b_inited(&head_cache) && my_b_inited(&body_cache) &&
441 my_b_inited(&footer_cache);
442 }
443
444 /* Settings on how to print the events */
445 // True if the --short-form flag was specified
446 bool short_form;
447 // The X in --base64-output=X
448 enum_base64_output_mode base64_output_mode;
449 // True if the --skip-gtids flag was specified.
450 bool skip_gtids;
451
452 /*
453 This is set whenever a Format_description_event is printed.
454 Later, when an event is printed in base64, this flag is tested: if
455 no Format_description_event has been seen, it is unsafe to print
456 the base64 event, so an error message is generated.
457 */
458 bool printed_fd_event;
459 my_off_t hexdump_from;
460 uint8 common_header_len;
461 char delimiter[16];
462
463 uint verbose;
464 table_mapping m_table_map;
465 table_mapping m_table_map_ignored;
466
467 /*
468 These three caches are used by the row-based replication events to
469 collect the header information and the main body of the events
470 making up a statement and in footer section any verbose related details
471 or comments related to the statement.
472 */
473 IO_CACHE head_cache;
474 IO_CACHE body_cache;
475 IO_CACHE footer_cache;
476 /* Indicate if the body cache has unflushed events */
477 bool have_unflushed_events;
478
479 /*
480 True if an event was skipped while printing the events of
481 a transaction and no COMMIT statement or XID event was ever
482 output (ie, was filtered out as well). This can be triggered
483 by the --database option of mysqlbinlog.
484
485 False, otherwise.
486 */
487 bool skipped_event_in_transaction;
488
489 bool print_table_metadata;
490
491 /**
492 True if --require_row_format is passed.
493 If true
494 It prints at start SET @@session.require_row_format = 1
495 It omits the SET @@session.pseudo_thread_id printed on Query events
496 */
497 bool require_row_format;
498
499 /**
500 The version of the last server that sent the transaction
501 */
502 uint32_t immediate_server_version;
503};
504#endif
505
506/*
507 A specific to the database-scheduled MTS type.
510 const char *name[MAX_DBS_IN_EVENT_MTS]{nullptr};
511 int num{0};
512
513 Mts_db_names() = default;
514
515 void reset_and_dispose() {
516 for (int i = 0; i < MAX_DBS_IN_EVENT_MTS; i++) {
517 free(const_cast<char *>(name[i]));
518 name[i] = nullptr;
519 }
520 num = 0;
521 }
522};
523
524/**
525 @class Log_event
526
527 This is the abstract base class for binary log events.
528
529 @section Log_event_binary_format Binary Format
530
531 The format of the event is described @ref Binary_log_event_format "here".
532
533 @subsection Log_event_format_of_atomic_primitives Format of Atomic Primitives
534
535 - All numbers, whether they are 16-, 24-, 32-, or 64-bit numbers,
536 are stored in little endian, i.e., the least significant byte first,
537 unless otherwise specified.
539*/
540class Log_event {
541 public:
542 /**
543 Enumeration of what kinds of skipping (and non-skipping) that can
544 occur when the slave executes an event.
545
546 @see shall_skip
547 @see do_shall_skip
548 */
549 enum enum_skip_reason {
550 /**
551 Don't skip event.
552 */
554
555 /**
556 Skip event by ignoring it.
557
558 This means that the slave skip counter will not be changed.
559 */
561
562 /**
563 Skip event and decrease skip counter.
564 */
566 };
568 protected:
571 /*
572 If possible the event should use a non-transactional cache before
573 being flushed to the binary log. This means that it must be flushed
574 right after its correspondent statement is completed.
575 */
577 /*
578 The event should use a transactional cache before being flushed to
579 the binary log. This means that it must be flushed upon commit or
580 rollback.
581 */
583 /*
584 The event must be written directly to the binary log without going
585 through any cache.
586 */
588 /*
589 If there is a need for different types, introduce them before this.
590 */
592 };
596 /*
597 The event must be written to a cache and upon commit or rollback
598 written to the binary log.
599 */
601 /*
602 The event must be written to an empty cache and immediately written
603 to the binary log without waiting for any other event.
604 */
606 /*
607 If there is a need for different types, introduce them before this.
608 */
610 };
611
612 /**
613 Writes the common header of this event to the given memory buffer.
614
615 This does not update the checksum.
616
617 @note This has the following form:
618
619 +---------+---------+---------+------------+-----------+-------+
620 |timestamp|type code|server_id|event_length|end_log_pos|flags |
621 |4 bytes |1 byte |4 bytes |4 bytes |4 bytes |2 bytes|
622 +---------+---------+---------+------------+-----------+-------+
623
624 @param buf Memory buffer to write to. This must be at least
625 LOG_EVENT_HEADER_LEN bytes long.
626
627 @return The number of bytes written, i.e., always
628 LOG_EVENT_HEADER_LEN.
629 */
631 /**
632 Writes the common-header of this event to the given output stream and
633 updates the checksum.
634
635 @param ostream The event will be written to this output stream.
636
637 @param data_length The length of the post-header section plus the
638 length of the data section; i.e., the length of the event minus
639 the common-header and the checksum.
640 */
641 bool write_header(Basic_ostream *ostream, size_t data_length);
642 bool write_footer(Basic_ostream *ostream);
643 bool need_checksum();
644
645 public:
646 /*
647 A temp buffer for read_log_event; it is later analysed according to the
648 event's type, and its content is distributed in the event-specific fields.
649 */
650 char *temp_buf;
651
652 /*
653 This variable determines whether the event is responsible for deallocating
654 the memory pointed by temp_buf. When set to true temp_buf is deallocated
655 and when it is set to false just make temp_buf point to NULL.
656 */
659 /* The number of seconds the query took to run on the master. */
660 ulong exec_time;
661
662 /*
663 The master's server id (is preserved in the relay log; used to
664 prevent from infinite loops in circular replication).
665 */
667
668 /**
669 A storage to cache the global system variable's value.
670 Handling of a separate event will be governed its member.
671 */
672 ulong rbr_exec_mode;
673
674 /**
675 Defines the type of the cache, if any, where the event will be
676 stored before being flushed to disk.
677 */
679
680 /**
681 Defines when information, i.e. event or cache, will be flushed
682 to disk.
683 */
685 /**
686 Placeholder for event checksum while writing to binlog.
687 */
689 /**
690 Index in @c rli->gaq array to indicate a group that this event is
691 purging. The index is set by Coordinator to a group terminator
692 event is checked by Worker at the event execution. The indexed
693 data represent the Worker progress status.
694 */
695 ulong mts_group_idx;
696
697 /**
698 The Log_event_header class contains the variable present
699 in the common header
700 */
702
703 /**
704 The Log_event_footer class contains the variable present
705 in the common footer. Currently, footer contains only the checksum_alg.
706 */
708 /**
709 MTS: associating the event with either an assigned Worker or Coordinator.
710 Additionally the member serves to tag deferred (IRU) events to avoid
711 the event regular time destruction.
712 */
714
715 /**
716 A copy of the main rli value stored into event to pass to MTS worker rli
717 */
720#ifdef MYSQL_SERVER
721 THD *thd;
722 /**
723 Partition info associate with event to deliver to MTS event applier
724 */
726
729 enum_event_cache_type cache_type_arg,
730 enum_event_logging_type logging_type_arg);
731 Log_event(THD *thd_arg, uint16 flags_arg,
732 enum_event_cache_type cache_type_arg,
733 enum_event_logging_type logging_type_arg,
736 /*
737 init_show_field_list() prepares the column names and types for the
738 output of SHOW BINLOG EVENTS; it is used only by SHOW BINLOG
739 EVENTS.
740 */
741 static void init_show_field_list(mem_root_deque<Item *> *field_list);
742
743 int net_send(Protocol *protocol, const char *log_name, my_off_t pos);
744
745 /**
746 Stores a string representation of this event in the Protocol.
747 This is used by SHOW BINLOG EVENTS.
748
749 @retval 0 success
750 @retval nonzero error
751 */
752 virtual int pack_info(Protocol *protocol);
753
754 virtual const char *get_db();
755#else // ifdef MYSQL_SERVER
756 /* print*() functions are used by mysqlbinlog */
757 virtual void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const = 0;
758 void print_timestamp(IO_CACHE *file, time_t *ts) const;
759 void print_header(IO_CACHE *file, PRINT_EVENT_INFO *print_event_info,
760 bool is_more) const;
761 void print_base64(IO_CACHE *file, PRINT_EVENT_INFO *print_event_info,
762 bool is_more) const;
763#endif // ifdef MYSQL_SERVER ... else
764
765 void *operator new(size_t size);
766
767 static void operator delete(void *ptr, size_t) { my_free(ptr); }
769 /* Placement version of the above operators */
770 static void *operator new(size_t, void *ptr) { return ptr; }
771 static void operator delete(void *, void *) {}
772 /**
773 Write the given buffer to the given output stream, updating the
774 checksum if checksums are enabled.
775
776 @param ostream The output stream to write to.
777 @param buf The buffer to write.
778 @param data_length The number of bytes to write.
779
780 @retval false Success.
781 @retval true Error.
782 */
783 bool wrapper_my_b_safe_write(Basic_ostream *ostream, const uchar *buf,
784 size_t data_length);
786#ifdef MYSQL_SERVER
787 virtual bool write(Basic_ostream *ostream) {
788 return (write_header(ostream, get_data_size()) ||
789 write_data_header(ostream) || write_data_body(ostream) ||
790 write_footer(ostream));
791 }
792
793 time_t get_time();
795 virtual bool write_data_header(Basic_ostream *) { return false; }
796 virtual bool write_data_body(Basic_ostream *) { return false; }
797#endif
798
800 return common_header->type_code;
801 }
802
803 /**
804 Return true if the event has to be logged using SBR for DMLs.
805 */
806 virtual bool is_sbr_logging_format() const { return false; }
807 /**
808 Return true if the event has to be logged using RBR for DMLs.
809 */
810 virtual bool is_rbr_logging_format() const { return false; }
811
812 /*
813 is_valid is event specific sanity checks to determine that the
814 object is correctly initialized.
815 */
816 bool is_valid();
817 void set_artificial_event() {
819 /*
820 Artificial events are automatically generated and do not exist
821 in master's binary log, so log_pos should be set to 0.
822 */
826 bool is_artificial_event() const {
828 }
829 bool is_relay_log_event() const {
831 }
832 bool is_ignorable_event() const {
834 }
835 bool is_no_filter_event() const {
837 }
838 inline bool is_using_trans_cache() const {
840 }
841 inline bool is_using_stmt_cache() const {
843 }
844 inline bool is_using_immediate_logging() const {
846 }
847
848 /*
849 For the events being decoded in BAPI, common_header should
850 point to the header object which is contained within the class
851 Binary_log_event.
852 */
855
856 /**
857 Allow thread to CLAIM or DISCLAIM the ownership of this object
858 depends on the parameter value passed
859
860 @param claim
861 True - claim ownership of the memory
862 False - disclaim ownership of the memory
863 */
864 virtual void claim_memory_ownership([[maybe_unused]] bool claim) {}
866 virtual ~Log_event() { free_temp_buf(); }
867 void register_temp_buf(char *buf, bool free_in_destructor = true) {
868 m_free_temp_buf_in_destructor = free_in_destructor;
870 }
871 void free_temp_buf() {
872 if (temp_buf) {
874 temp_buf = nullptr;
875 }
876 }
877 /*
878 Get event length for simple events. For complicated events the length
879 is calculated during write()
880 */
881 virtual size_t get_data_size() { return 0; }
882 /**
883 Returns the human readable name of the given event type.
884 */
886 /// Get the name of an event type, or "Unknown" if out of range.
887 /// @param type The type as an int
888 /// @retval name of an event type, if it is one
889 /// @retval "Unknown" if the value is out of range
890 static const char *get_type_str(uint type);
891 /**
892 Returns the human readable name of this event's type.
893 */
894 const char *get_type_str() const;
895 /* Return start of query time or current time */
896
897#if defined(MYSQL_SERVER)
898 /**
899 Is called from get_mts_execution_mode() to
900
901 @return true if the event needs applying with synchronization
902 against Workers, otherwise
903 false
904
905 @note There are incompatile combinations such as referred further events
906 are wrapped with BEGIN/COMMIT. Such cases should be identified
907 by the caller and treats correspondingly.
908
909 todo: to mts-support Old master Load-data related events
910 */
912 switch (get_type_code()) {
918 return true;
919 default:
920 return false;
921 }
922 }
923
924 private:
925 /*
926 possible decisions by get_mts_execution_mode().
927 The execution mode can be PARALLEL or not (thereby sequential
928 unless impossible at all). When it's sequential it further breaks into
929 ASYNChronous and SYNChronous.
930 */
932 /*
933 Event is run by a Worker.
934 */
936 /*
937 Event is run by Coordinator.
938 */
940 /*
941 Event is run by Coordinator and requires synchronization with Workers.
942 */
944 /*
945 Event can't be executed neither by Workers nor Coordinator.
946 */
948 };
949
950 /**
951 MTS Coordinator finds out a way how to execute the current event.
952
953 Besides the parallelizable case, some events have to be applied by
954 Coordinator concurrently with Workers and some to require synchronization
955 with Workers (@c see wait_for_workers_to_finish) before to apply them.
956
957 @param mts_in_group the being group parsing status, true
958 means inside the group
959
960 @retval EVENT_EXEC_PARALLEL if event is executed by a Worker
961 @retval EVENT_EXEC_ASYNC if event is executed by Coordinator
962 @retval EVENT_EXEC_SYNC if event is executed by Coordinator
963 with synchronization against the Workers
964 */
965 enum enum_mts_event_exec_mode get_mts_execution_mode(bool mts_in_group) {
966 /*
967 Slave workers are unable to handle Format_description_log_event,
968 Rotate_log_event and Previous_gtids_log_event correctly.
969 However, when a transaction spans multiple relay logs, these
970 events occur in the middle of a transaction. The way we handle
971 this is by marking the events as 'ASYNC', meaning that the
972 coordinator thread will handle the events without stopping the
973 worker threads.
974
975 @todo Refactor this: make Log_event::get_slave_worker handle
976 transaction boundaries in a more robust way, so that it is able
977 to process Format_description_log_event, Rotate_log_event, and
978 Previous_gtids_log_event. Then, when these events occur in the
979 middle of a transaction, make them part of the transaction so
980 that the worker that handles the transaction handles these
981 events too. /Sven
982 */
983 if (
984 /*
985 When a Format_description_log_event occurs in the middle of
986 a transaction, it either has the slave's server_id, or has
987 end_log_pos==0.
988
989 @todo This does not work when master and slave have the same
990 server_id and replicate-same-server-id is enabled, since
991 events that are not in the middle of a transaction will be
992 executed in ASYNC mode in that case.
993 */
995 ((server_id == (uint32)::server_id) ||
996 (common_header->log_pos == 0))) ||
997 /*
998 All Previous_gtids_log_events in the relay log are generated
999 by the slave. They don't have any meaning to the applier, so
1000 they can always be ignored by the applier. So we can process
1001 them asynchronously by the coordinator. It is also important
1002 to not feed them to workers because that confuses
1003 get_slave_worker.
1004 */
1006 /*
1007 Rotate_log_event can occur in the middle of a transaction.
1008 When this happens, either it is a Rotate event generated on
1009 the slave which has the slave's server_id, or it is a Rotate
1010 event that originates from a master but has end_log_pos==0.
1011 */
1013 ((server_id == (uint32)::server_id) ||
1014 (common_header->log_pos == 0 && mts_in_group))))
1015 return EVENT_EXEC_ASYNC;
1016 else if (is_mts_sequential_exec())
1017 return EVENT_EXEC_SYNC;
1018 else
1019 return EVENT_EXEC_PARALLEL;
1020 }
1021
1022 /**
1023 @return index in [0, M] range to indicate
1024 to be assigned worker;
1025 M is the max index of the worker pool.
1026 */
1028
1029 /*
1030 Group of events can be marked to force its execution
1031 in isolation from any other Workers.
1032 Typically that is done for a transaction that contains
1033 a query accessing more than OVER_MAX_DBS_IN_EVENT_MTS databases.
1034 Factually that's a sequential mode where a Worker remains to
1035 be the applier.
1036 */
1037 virtual void set_mts_isolate_group() {
1038 assert(ends_group() ||
1042 }
1043
1044 public:
1045 /**
1046 The method fills in pointers to event's database name c-strings
1047 to a supplied array.
1048 In other than Query-log-event case the returned array contains
1049 just one item.
1050 @param[out] arg pointer to a struct containing char* array
1051 pointers to be filled in and the number
1052 of filled instances.
1053 @param rpl_filter pointer to a replication filter.
1054
1055 @return number of the filled instances indicating how many
1056 databases the event accesses.
1057 */
1058 virtual uint8 get_mts_dbs(Mts_db_names *arg,
1059 Rpl_filter *rpl_filter [[maybe_unused]]) {
1060 arg->name[0] = get_db();
1061
1062 return arg->num = mts_number_dbs();
1063 }
1064
1065 /**
1066 @return true if events carries partitioning data (database names).
1067 */
1068 bool contains_partition_info(bool);
1069
1070 /*
1071 @return the number of updated by the event databases.
1072
1073 @note In other than Query-log-event case that's one.
1074 */
1075 virtual uint8 mts_number_dbs() { return 1; }
1076
1077 /**
1078 @return true if the terminal event of a group is marked to
1079 execute in isolation from other Workers,
1080 false otherwise
1081 */
1082 bool is_mts_group_isolated() {
1084 }
1085
1086 /**
1087 Events of a certain type can start or end a group of events treated
1088 transactionally wrt binlog.
1089
1090 Public access is required by implementation of recovery + skip.
1091
1092 @return true if the event starts a group (transaction)
1093 false otherwise
1095#endif
1096 virtual bool starts_group() const { return false; }
1097 /**
1098 @return true if the event ends a group (transaction)
1099 false otherwise
1100 */
1101 virtual bool ends_group() const { return false; }
1102#ifdef MYSQL_SERVER
1103 /**
1104 Apply the event to the database.
1105
1106 This function represents the public interface for applying an
1107 event.
1108
1109 @see do_apply_event
1110 */
1111 int apply_event(Relay_log_info *rli);
1112
1113 /**
1114 Apply the GTID event in curr_group_data to the database.
1115
1116 @param rli Pointer to coordinato's relay log info.
1117
1118 @retval 0 success
1119 @retval 1 error
1120 */
1121 inline int apply_gtid_event(Relay_log_info *rli);
1122
1123 /**
1124 Update the relay log position.
1125
1126 This function represents the public interface for "stepping over"
1127 the event and will update the relay log information.
1128
1129 @see do_update_pos
1130 */
1131 int update_pos(Relay_log_info *rli) { return do_update_pos(rli); }
1132
1133 /**
1134 Decide if the event shall be skipped, and the reason for skipping
1135 it.
1136
1137 @see do_shall_skip
1138 */
1140 DBUG_TRACE;
1142 DBUG_PRINT("info", ("skip reason=%d=%s", ret,
1143 ret == EVENT_SKIP_NOT ? "NOT"
1144 : ret == EVENT_SKIP_IGNORE ? "IGNORE"
1145 : "COUNT"));
1146 return ret;
1147 }
1148
1149 /**
1150 Primitive to apply an event to the database.
1151
1152 This is where the change to the database is made.
1153
1154 @note The primitive is protected instead of private, since there
1155 is a hierarchy of actions to be performed in some cases.
1156
1157 @see Format_description_log_event::do_apply_event()
1158
1159 @param rli Pointer to relay log info structure
1160
1161 @retval 0 Event applied successfully
1162 @retval errno Error code if event application failed
1163 */
1164 virtual int do_apply_event(Relay_log_info const *rli [[maybe_unused]]) {
1165 return 0; /* Default implementation does nothing */
1166 }
1167
1168 virtual int do_apply_event_worker(Slave_worker *w);
1169
1170 protected:
1171 /**
1172 Helper function to ignore an event w.r.t. the slave skip counter.
1173
1174 This function can be used inside do_shall_skip() for functions
1175 that cannot end a group. If the slave skip counter is 1 when
1176 seeing such an event, the event shall be ignored, the counter
1177 left intact, and processing continue with the next event.
1178
1179 A typical usage is:
1180 @code
1181 enum_skip_reason do_shall_skip(Relay_log_info *rli) {
1182 return continue_group(rli);
1183 }
1184 @endcode
1185
1186 @return Skip reason
1187 */
1189
1190 /**
1191 Advance relay log coordinates.
1192
1193 This function is called to advance the relay log coordinates to
1194 just after the event. It is essential that both the relay log
1195 coordinate and the group log position is updated correctly, since
1196 this function is used also for skipping events.
1197
1198 Normally, each implementation of do_update_pos() shall:
1199
1200 - Update the event position to refer to the position just after
1201 the event.
1202
1203 - Update the group log position to refer to the position just
1204 after the event <em>if the event is last in a group</em>
1205
1206 @param rli Pointer to relay log info structure
1207
1208 @retval 0 Coordinates changed successfully
1209 @retval errno Error code if advancing failed (usually just
1210 1). Observe that handler errors are returned by the
1211 do_apply_event() function, and not by this one.
1212 */
1213 virtual int do_update_pos(Relay_log_info *rli);
1214
1215 /**
1216 Decide if this event shall be skipped or not and the reason for
1217 skipping it.
1218
1219 The default implementation decide that the event shall be skipped
1220 if either:
1221
1222 - the server id of the event is the same as the server id of the
1223 server and <code>rli->replicate_same_server_id</code> is true,
1224 or
1225
1226 - if <code>rli->slave_skip_counter</code> is greater than zero.
1227
1228 @see do_apply_event
1229 @see do_update_pos
1230
1231 @retval Log_event::EVENT_SKIP_NOT
1232 The event shall not be skipped and should be applied.
1233
1234 @retval Log_event::EVENT_SKIP_IGNORE
1235 The event shall be skipped by just ignoring it, i.e., the slave
1236 skip counter shall not be changed. This happends if, for example,
1237 the originating server id of the event is the same as the server
1238 id of the slave.
1239
1240 @retval Log_event::EVENT_SKIP_COUNT
1241 The event shall be skipped because the slave skip counter was
1242 non-zero. The caller shall decrease the counter by one.
1243 */
1245#endif
1246};
1247
1248/*
1249 One class for each type of event.
1250 Two constructors for each class:
1251 - one to create the event for logging (when the server acts as a master),
1252 called after an update to the database is done,
1253 which accepts parameters like the query, the database, the options for LOAD
1254 DATA INFILE...
1255 - one to create the event from a packet (when the server acts as a slave),
1256 called before reproducing the update, which accepts parameters (like a
1257 buffer). Used to read from the master, from the relay log, and in
1258 mysqlbinlog. This constructor must be format-tolerant.
1259*/
1260
1261/**
1262 A Query event is written to the binary log whenever the database is
1263 modified on the master, unless row based logging is used.
1264
1265 Query_log_event is created for logging, and is called after an update to the
1266 database is done. It is used when the server acts as the master.
1267
1268 Virtual inheritance is required here to handle the diamond problem in
1269 the class @c Execute_load_query_log_event.
1270 The diamond structure is explained in @c Excecute_load_query_log_event
1271
1272 @internal
1273 The inheritance structure is as follows:
1274
1275 Binary_log_event
1276 ^
1277 |
1278 |
1279 Query_event Log_event
1280 \ /
1281 <<virtual>>\ /
1282 \ /
1283 Query_log_event
1284 @endinternal
1285*/
1287 public Log_event {
1288 protected:
1290
1291 public:
1292 // disable copy-move semantics
1293 Query_log_event(Query_log_event &&) noexcept = delete;
1294 Query_log_event &operator=(Query_log_event &&) noexcept = delete;
1295 Query_log_event(const Query_log_event &) = delete;
1296 Query_log_event &operator=(const Query_log_event &) = delete;
1297
1298 /*
1299 For events created by Query_log_event::do_apply_event (and
1300 Load_log_event::do_apply_event()) we need the *original* thread
1301 id, to be able to log the event with the original (=master's)
1302 thread id (fix for BUG#1686).
1303 */
1305
1306 /**
1307 True if this is a ROLLBACK event injected by the mts coordinator to finish a
1308 group corresponding to a partial transaction in the relay log.
1309 False otherwise and by default, as it must be explicitly set to true by the
1310 coordinator.
1311 */
1312 bool rollback_injected_by_coord = false;
1313
1314 /**
1315 The flag indicates whether the DDL query has been (already)
1316 committed or not. It's initialized as OFF at the event instantiation,
1317 flips ON when the DDL transaction has been committed with
1318 all its possible extra statement due to replication or GTID.
1319
1320 The flag status is also checked in few places to catch uncommitted
1321 transactions which can normally happen due to filtering out. In
1322 such a case the commit is deferred to @c Log_event::do_update_pos().
1323 */
1324 bool has_ddl_committed;
1325
1326#ifdef MYSQL_SERVER
1327
1328 /**
1329 Instructs the applier to skip temporary tables handling.
1330 */
1332
1336
1339 }
1340
1341 Query_log_event(THD *thd_arg, const char *query_arg, size_t query_length,
1342 bool using_trans, bool immediate, bool suppress_use,
1343 int error, bool ignore_command = false);
1344 const char *get_db() override { return db; }
1345
1346 /**
1347 @param[out] arg pointer to a struct containing char* array
1348 pointers be filled in and the number of
1349 filled instances.
1350 In case the number exceeds MAX_DBS_IN_EVENT_MTS,
1351 the overfill is indicated with assigning the number to
1352 OVER_MAX_DBS_IN_EVENT_MTS.
1353 @param rpl_filter pointer to a replication filter.
1354
1355 @return number of databases in the array or OVER_MAX_DBS_IN_EVENT_MTS.
1356 */
1359 // the empty string db name is special to indicate sequential applying
1360 mts_accessed_db_names[0][0] = 0;
1361 } else {
1362 for (uchar i = 0; i < mts_accessed_dbs; i++) {
1363 const char *db_name = mts_accessed_db_names[i];
1364
1365 // Only default database is rewritten.
1366 if (!rpl_filter->is_rewrite_empty() && !strcmp(get_db(), db_name)) {
1367 size_t dummy_len;
1368 const char *db_filtered =
1369 rpl_filter->get_rewrite_db(db_name, &dummy_len);
1370 // db_name != db_filtered means that db_name is rewritten.
1371 if (strcmp(db_name, db_filtered)) db_name = db_filtered;
1372 }
1373 arg->name[i] = db_name;
1374 }
1375 }
1376 return arg->num = mts_accessed_dbs;
1377 }
1378
1381
1382 uchar mts_number_dbs() override { return mts_accessed_dbs; }
1383
1384 int pack_info(Protocol *protocol) override;
1385#else
1386 void print_query_header(IO_CACHE *file,
1387 PRINT_EVENT_INFO *print_event_info) const;
1388 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
1389 static bool rewrite_db_in_buffer(
1390 char **buf, ulong *event_len,
1392#endif
1393
1395
1397 const char *buf,
1400 ~Query_log_event() override {
1402 }
1403
1404 void claim_memory_ownership(bool claim) override;
1405
1406#ifdef MYSQL_SERVER
1407 bool write(Basic_ostream *ostream) override;
1408 virtual bool write_post_header_for_derived(Basic_ostream *) { return false; }
1409#endif
1410
1411 /*
1412 Returns number of bytes additionally written to post header by derived
1413 events (so far it is only Execute_load_query event).
1414 */
1415 virtual ulong get_post_header_size_for_derived() { return 0; }
1416 /* Writes derived event-specific part of post header. */
1417
1418 public: /* !!! Public in this patch to allow old usage */
1419#if defined(MYSQL_SERVER)
1421 int do_apply_event(Relay_log_info const *rli) override;
1422 int do_update_pos(Relay_log_info *rli) override;
1423
1424 int do_apply_event(Relay_log_info const *rli, const char *query_arg,
1425 size_t q_len_arg);
1426#endif /* MYSQL_SERVER */
1427 /*
1428 If true, the event always be applied by slave SQL thread or be printed by
1429 mysqlbinlog
1430 */
1431 bool is_trans_keyword() const {
1432 /*
1433 Before the patch for bug#50407, The 'SAVEPOINT and ROLLBACK TO'
1434 queries input by user was written into log events directly.
1435 So the keywords can be written in both upper case and lower case
1436 together, strncasecmp is used to check both cases. they also could be
1437 binlogged with comments in the front of these keywords. for examples:
1438 / * bla bla * / SAVEPOINT a;
1439 / * bla bla * / ROLLBACK TO a;
1440 but we don't handle these cases and after the patch, both quiries are
1441 binlogged in upper case with no comments.
1442 */
1443 return !strncmp(query, "BEGIN", q_len) ||
1444 !strncmp(query, "COMMIT", q_len) ||
1445 !native_strncasecmp(query, "SAVEPOINT", 9) ||
1446 !native_strncasecmp(query, "ROLLBACK", 8) ||
1447 !native_strncasecmp(query, STRING_WITH_LEN("XA START")) ||
1449 !native_strncasecmp(query, STRING_WITH_LEN("XA PREPARE")) ||
1450 !native_strncasecmp(query, STRING_WITH_LEN("XA COMMIT")) ||
1451 !native_strncasecmp(query, STRING_WITH_LEN("XA ROLLBACK"));
1452 }
1453
1454 /**
1455 When a query log event contains a non-transaction control statement, we
1456 assume that it is changing database content (DML) and was logged using
1457 binlog_format=statement.
1458
1459 @return True the event represents a statement that was logged using SBR
1460 that can change database content.
1461 False for transaction control statements.
1462 */
1463 bool is_sbr_logging_format() const override { return !is_trans_keyword(); }
1464
1465 /**
1466 Notice, DDL queries are logged without BEGIN/COMMIT parentheses
1467 and identification of such single-query group
1468 occurs within logics of @c get_slave_worker().
1470
1471 bool starts_group() const override {
1472 return !strncmp(query, "BEGIN", q_len) ||
1473 !strncmp(query, STRING_WITH_LEN("XA START"));
1475
1476 bool ends_group() const override {
1477 return !strncmp(query, "COMMIT", q_len) ||
1478 (!native_strncasecmp(query, STRING_WITH_LEN("ROLLBACK")) &&
1479 native_strncasecmp(query, STRING_WITH_LEN("ROLLBACK TO "))) ||
1480 !strncmp(query, STRING_WITH_LEN("XA ROLLBACK"));
1481 }
1482 static size_t get_query(
1483 const char *buf, size_t length,
1485 const char **query_arg);
1486
1487 bool is_query_prefix_match(const char *pattern, uint p_len) {
1488 return !strncmp(query, pattern, p_len);
1489 }
1490
1491 /** Whether or not the statement represented by this event requires
1492 `Q_SQL_REQUIRE_PRIMARY_KEY` to be logged along aside. */
1493 bool need_sql_require_primary_key{false};
1494
1495 /** Whether or not the statement represented by this event requires
1496 `Q_DEFAULT_TABLE_ENCRYPTION` to be logged along aside. */
1498};
1499
1500/**
1501 @class Format_description_log_event
1502
1503 For binlog version 4.
1504 This event is saved by threads which read it, as they need it for future
1505 use (to decode the ordinary events).
1506 This is the subclass of Format_description_event
1507
1508 @internal
1509 The inheritance structure in the current design for the classes is
1510 as follows:
1511
1512 Binary_log_event
1513 ^
1514 |
1515 |
1516 Format_description_event Log_event
1517 \ /
1518 \ /
1519 \ /
1520 Format_description_log_event
1521 @endinternal
1522 @section Format_description_log_event_binary_format Binary Format
1524
1527 public Log_event {
1528 public:
1529 /*
1530 MTS Workers and Coordinator share the event and that affects its
1531 destruction. Instantiation is always done by Coordinator/SQL thread.
1532 Workers are allowed to destroy only "obsolete" instances, those
1533 that are not actual for Coordinator anymore but needed to Workers
1534 that are processing queued events depending on the old instance.
1535 The counter of a new FD is incremented by Coordinator or Worker at
1536 time of {Relay_log_info,Slave_worker}::set_rli_description_event()
1537 execution.
1538 In the same methods the counter of the "old" FD event is decremented
1539 and when it drops to zero the old FD is deleted.
1540 The latest read from relay-log event is to be
1541 destroyed by Coordinator/SQL thread at its thread exit.
1542 Notice the counter is processed even in the single-thread mode where
1543 decrement and increment are done by the single SQL thread.
1544 */
1545 std::atomic<int32> atomic_usage_counter{0};
1546
1549 const char *buf,
1550 const mysql::binlog::event::Format_description_event *description_event);
1551#ifdef MYSQL_SERVER
1552 bool write(Basic_ostream *ostream) override;
1553 int pack_info(Protocol *protocol) override;
1554#else
1555 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
1556#endif
1557
1558 size_t get_data_size() override {
1559 /*
1560 The vector of post-header lengths is considered as part of the
1561 post-header, because in a given version it never changes (contrary to the
1562 query in a Query_log_event).
1563 */
1566 }
1567
1568 void claim_memory_ownership(bool claim) override;
1569
1570 protected:
1571#if defined(MYSQL_SERVER)
1572 int do_apply_event(Relay_log_info const *rli) override;
1573 int do_update_pos(Relay_log_info *rli) override;
1575#endif
1576};
1577
1578/**
1579 @class Intvar_log_event
1580
1581 The class derives from the class Intvar_event in Binlog API,
1582 defined in the header binlog_event.h. An Intvar_log_event is
1583 created just before a Query_log_event, if the query uses one
1584 of the variables LAST_INSERT_ID or INSERT_ID. This class is used
1585 by the slave for applying the event.
1586
1587 @internal
1588 The inheritance structure in the current design for the classes is
1589 as follows:
1590
1591 Binary_log_event
1592 ^
1593 |
1594 |
1595 Intvar_event Log_event
1596 \ /
1597 \ /
1598 \ /
1599 Intvar_log_event
1600 @endinternal
1601*/
1603 public Log_event {
1604 public:
1605 // disable copy-move semantics
1606 Intvar_log_event(Intvar_log_event &&) noexcept = delete;
1607 Intvar_log_event &operator=(Intvar_log_event &&) noexcept = delete;
1608 Intvar_log_event(const Intvar_log_event &) = delete;
1609 Intvar_log_event &operator=(const Intvar_log_event &) = delete;
1611#ifdef MYSQL_SERVER
1612 Intvar_log_event(THD *thd_arg, uchar type_arg, ulonglong val_arg,
1613 enum_event_cache_type cache_type_arg,
1614 enum_event_logging_type logging_type_arg)
1615 : mysql::binlog::event::Intvar_event(type_arg, val_arg),
1616 Log_event(thd_arg, 0, cache_type_arg, logging_type_arg, header(),
1617 footer()) {
1619 }
1620 int pack_info(Protocol *protocol) override;
1621#else
1622 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
1623#endif
1624
1626 const char *buf,
1627 const mysql::binlog::event::Format_description_event *description_event);
1628 ~Intvar_log_event() override = default;
1629
1630 void claim_memory_ownership(bool claim) override;
1631
1632 size_t get_data_size() override {
1633 return 9; /* sizeof(type) + sizeof(val) */
1634 ;
1635 }
1636#ifdef MYSQL_SERVER
1637 bool write(Basic_ostream *ostream) override;
1638#endif
1639
1640 bool is_sbr_logging_format() const override { return true; }
1641
1642 private:
1643#if defined(MYSQL_SERVER)
1644 int do_apply_event(Relay_log_info const *rli) override;
1645 int do_update_pos(Relay_log_info *rli) override;
1647#endif
1648};
1649
1650/**
1651 @class Rand_log_event
1652
1653 Logs random seed used by the next RAND(), and by PASSWORD() in 4.1.0.
1654 4.1.1 does not need it (it's repeatable again) so this event needn't be
1655 written in 4.1.1 for PASSWORD() (but the fact that it is written is just a
1656 waste, it does not cause bugs).
1657
1658 The state of the random number generation consists of 128 bits,
1659 which are stored internally as two 64-bit numbers.
1660
1661 @internal
1662 The inheritance structure in the current design for the classes is
1663 as follows:
1664 Binary_log_event
1665 ^
1666 |
1667 |
1668 Rand_event Log_event
1669 \ /
1670 \ /
1671 \ /
1672 Rand_log_event
1673 @endinternal
1674*/
1676 public Log_event {
1677 public:
1678 // disable copy-move semantics
1679 Rand_log_event(Rand_log_event &&) noexcept = delete;
1680 Rand_log_event &operator=(Rand_log_event &&) noexcept = delete;
1681 Rand_log_event(const Rand_log_event &) = delete;
1682 Rand_log_event &operator=(const Rand_log_event &) = delete;
1684#ifdef MYSQL_SERVER
1685 Rand_log_event(THD *thd_arg, ulonglong seed1_arg, ulonglong seed2_arg,
1686 enum_event_cache_type cache_type_arg,
1687 enum_event_logging_type logging_type_arg)
1688 : mysql::binlog::event::Rand_event(seed1_arg, seed2_arg),
1689 Log_event(thd_arg, 0, cache_type_arg, logging_type_arg, header(),
1690 footer()) {
1692 }
1693 int pack_info(Protocol *protocol) override;
1694#else
1695 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
1696#endif
1697
1699 const char *buf,
1700 const mysql::binlog::event::Format_description_event *description_event);
1701 ~Rand_log_event() override = default;
1702
1703 void claim_memory_ownership(bool claim) override;
1704
1705 size_t get_data_size() override { return 16; /* sizeof(ulonglong) * 2*/ }
1706#ifdef MYSQL_SERVER
1707 bool write(Basic_ostream *ostream) override;
1708#endif
1709
1710 bool is_sbr_logging_format() const override { return true; }
1711
1712 private:
1713#if defined(MYSQL_SERVER)
1714 int do_apply_event(Relay_log_info const *rli) override;
1715 int do_update_pos(Relay_log_info *rli) override;
1717#endif
1718};
1719
1720/**
1721 @class Xid_log_event
1722
1723 This is the subclass of Xid_event defined in libbinlogevent,
1724 An XID event is generated for a commit of a transaction that modifies one or
1725 more tables of an XA-capable storage engine
1726 Logs xid of the transaction-to-be-committed in the 2pc protocol.
1727 Has no meaning in replication, slaves ignore it
1728 The inheritance structure in the current design for the classes is
1729 as follows
1730
1731 @internal
1732 The inheritance structure in the current design for the classes is
1733 as follows:
1734 Binary_log_event
1735 ^
1736 |
1737 |
1738 Xid_event Log_event
1739 \ /
1740 \ /
1741 \ /
1742 Xid_log_event
1743 @endinternal
1744*/
1745#ifndef MYSQL_SERVER
1746typedef ulonglong my_xid; // this line is the same as in handler.h
1747#endif
1748
1749class Xid_apply_log_event : public Log_event {
1750 protected:
1751#ifdef MYSQL_SERVER
1752 Xid_apply_log_event(THD *thd_arg,
1756 Log_event::EVENT_NORMAL_LOGGING, header_arg, footer_arg) {}
1757#endif
1760 : Log_event(header_arg, footer_arg) {}
1761 ~Xid_apply_log_event() override = default;
1762 bool ends_group() const override { return true; }
1763#if defined(MYSQL_SERVER)
1765 int do_apply_event(Relay_log_info const *rli) override;
1766 int do_apply_event_worker(Slave_worker *rli) override;
1767 virtual bool do_commit(THD *thd_arg) = 0;
1768#endif
1770
1772 public Xid_apply_log_event {
1773 public:
1774 // disable copy-move semantics
1775 Xid_log_event(Xid_log_event &&) noexcept = delete;
1776 Xid_log_event &operator=(Xid_log_event &&) noexcept = delete;
1777 Xid_log_event(const Xid_log_event &) = delete;
1778 Xid_log_event &operator=(const Xid_log_event &) = delete;
1780#ifdef MYSQL_SERVER
1781 Xid_log_event(THD *thd_arg, my_xid x)
1782 : mysql::binlog::event::Xid_event(x),
1783 Xid_apply_log_event(thd_arg, header(), footer()) {
1785 }
1786 int pack_info(Protocol *protocol) override;
1787#else
1788 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
1789#endif
1790
1792 const char *buf,
1793 const mysql::binlog::event::Format_description_event *description_event);
1794 ~Xid_log_event() override = default;
1795
1796 void claim_memory_ownership(bool claim) override;
1797
1798 size_t get_data_size() override { return sizeof(xid); }
1799#ifdef MYSQL_SERVER
1800 bool write(Basic_ostream *ostream) override;
1801#endif
1802 private:
1803#if defined(MYSQL_SERVER)
1804 bool do_commit(THD *thd_arg) override;
1805#endif
1806};
1807
1808/**
1809 @class XA_prepare_log_event
1810
1811 Similar to Xid_log_event except that
1812 - it is specific to XA transaction
1813 - it carries out the prepare logics rather than the final committing
1814 when @c one_phase member is off.
1815 From the groupping perspective the event finalizes the current "prepare" group
1816 started with XA START Query-log-event.
1817 When @c one_phase is false Commit of Rollback for XA transaction are
1818 logged separately to the prepare-group events so being a groups of
1819 their own.
1821
1823 public Xid_apply_log_event {
1824 private:
1825 /* Total size of buffers to hold serialized members of XID struct */
1826 static const int xid_bufs_size = 12;
1827
1828 public:
1829#ifdef MYSQL_SERVER
1830 XA_prepare_log_event(THD *thd_arg, XID *xid_arg, bool one_phase_arg = false)
1831 : mysql::binlog::event::XA_prepare_event((void *)xid_arg, one_phase_arg),
1833#endif
1835 const char *buf,
1836 const mysql::binlog::event::Format_description_event *description_event)
1837 : mysql::binlog::event::XA_prepare_event(buf, description_event),
1839 DBUG_TRACE;
1840 xid = nullptr;
1841 return;
1842 }
1845 }
1846 size_t get_data_size() override {
1847 return xid_bufs_size + my_xid.gtrid_length + my_xid.bqual_length;
1848 }
1849
1850 void claim_memory_ownership(bool claim) override;
1851
1852#ifdef MYSQL_SERVER
1853 bool write(Basic_ostream *ostream) override;
1854#else
1855 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
1856#endif
1857#if defined(MYSQL_SERVER)
1858 int pack_info(Protocol *protocol) override;
1859 bool do_commit(THD *thd) override;
1860#endif
1861};
1862
1863/**
1864 @class User_var_log_event
1865
1866 Every time a query uses the value of a user variable, a User_var_log_event is
1867 written before the Query_log_event, to set the user variable.
1868
1869 @internal
1870 The inheritance structure in the current design for the classes is
1871 as follows:
1872 Binary_log_event
1873 ^
1874 |
1875 |
1876 User_var_event Log_event
1877 \ /
1878 \ /
1879 \ /
1880 User_var_log_event
1881 @endinternal
1882*/
1884 public Log_event {
1885 public:
1886 // disable copy-move semantics
1888 User_var_log_event &operator=(User_var_log_event &&) noexcept = delete;
1889 User_var_log_event(const User_var_log_event &) = delete;
1890 User_var_log_event &operator=(const User_var_log_event &) = delete;
1892#ifdef MYSQL_SERVER
1895 User_var_log_event(THD *thd_arg, const char *name_arg, uint name_len_arg,
1896 char *val_arg, ulong val_len_arg, Item_result type_arg,
1897 uint charset_number_arg, uchar flags_arg,
1898 enum_event_cache_type cache_type_arg,
1899 enum_event_logging_type logging_type_arg)
1900 : mysql::binlog::event::User_var_event(name_arg, name_len_arg, val_arg,
1901 val_len_arg, type_arg,
1902 charset_number_arg, flags_arg),
1903 Log_event(thd_arg, 0, cache_type_arg, logging_type_arg, header(),
1904 footer()),
1905 deferred(false) {
1906 common_header->set_is_valid(name != nullptr);
1907 }
1908 int pack_info(Protocol *protocol) override;
1909#else
1910 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
1911#endif
1912
1914 const char *buf,
1915 const mysql::binlog::event::Format_description_event *description_event);
1916 ~User_var_log_event() override = default;
1917
1918 void claim_memory_ownership(bool claim) override;
1919
1920#ifdef MYSQL_SERVER
1921 bool write(Basic_ostream *ostream) override;
1922 /*
1923 Getter and setter for deferred User-event.
1924 Returns true if the event is not applied directly
1925 and which case the applier adjusts execution path.
1926 */
1927 bool is_deferred() { return deferred; }
1928 /*
1929 In case of the deferred applying the variable instance is flagged
1930 and the parsing time query id is stored to be used at applying time.
1931 */
1932 void set_deferred(query_id_t qid) {
1933 deferred = true;
1934 query_id = qid;
1935 }
1936#endif
1937
1938 bool is_sbr_logging_format() const override { return true; }
1939
1940 private:
1941#if defined(MYSQL_SERVER)
1942 int do_apply_event(Relay_log_info const *rli) override;
1943 int do_update_pos(Relay_log_info *rli) override;
1945#endif
1946};
1947
1948/**
1949 @class Stop_log_event
1951*/
1953 public Log_event {
1954 public:
1955 // disable copy-move semantics
1956 Stop_log_event(Stop_log_event &&) noexcept = delete;
1957 Stop_log_event &operator=(Stop_log_event &&) noexcept = delete;
1958 Stop_log_event(const Stop_log_event &) = delete;
1959 Stop_log_event &operator=(const Stop_log_event &) = delete;
1961#ifdef MYSQL_SERVER
1966 }
1967
1968#else
1969 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
1970#endif
1971
1973 const char *buf,
1974 const mysql::binlog::event::Format_description_event *description_event)
1975 : mysql::binlog::event::Stop_event(buf, description_event),
1976 Log_event(header(), footer()) {
1977 DBUG_TRACE;
1978 return;
1981 ~Stop_log_event() override = default;
1984 }
1985
1986 void claim_memory_ownership(bool claim) override;
1987
1988 private:
1989#if defined(MYSQL_SERVER)
1990 int do_update_pos(Relay_log_info *rli) override;
1992 /*
1993 Events from ourself should be skipped, but they should not
1994 decrease the slave skip counter.
1995 */
1996 if (this->server_id == ::server_id)
1998 else
2000 }
2001#endif
2002};
2003
2004/**
2005 @class Rotate_log_event
2006
2007 This will be deprecated when we move to using sequence ids.
2008 This class is a subclass of Rotate_event, defined in binlogevent, and is used
2009 by the slave for updating the position in the relay log.
2010
2011 It is used by the master inorder to write the rotate event in the binary log.
2012
2013 @internal
2014 The inheritance structure in the current design for the classes is
2015 as follows:
2016
2017 Binary_log_event
2018 ^
2019 |
2020 |
2021 Rotate_event Log_event
2022 \ /
2023 \ /
2024 \ /
2025 Rotate_log_event
2026 @endinternal
2027*/
2029 public Log_event {
2030 public:
2031 // disable copy-move semantics
2032 Rotate_log_event(Rotate_log_event &&) noexcept = delete;
2033 Rotate_log_event &operator=(Rotate_log_event &&) noexcept = delete;
2034 Rotate_log_event(const Rotate_log_event &) = delete;
2035 Rotate_log_event &operator=(const Rotate_log_event &) = delete;
2036
2037#ifdef MYSQL_SERVER
2038 Rotate_log_event(const char *new_log_ident_arg, size_t ident_len_arg,
2039 ulonglong pos_arg, uint flags);
2040 int pack_info(Protocol *protocol) override;
2041#else
2042 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
2043#endif
2044
2046 const char *buf,
2048 ~Rotate_log_event() override = default;
2049 size_t get_data_size() override {
2050 return ident_len +
2052 }
2053
2054 void claim_memory_ownership(bool claim) override;
2055
2056#ifdef MYSQL_SERVER
2057 bool write(Basic_ostream *ostream) override;
2058#endif
2059
2060 private:
2061#if defined(MYSQL_SERVER)
2062 int do_update_pos(Relay_log_info *rli) override;
2064#endif
2065};
2066
2067/**
2068 @class Append_block_log_event
2069
2070 This event is created to contain the file data. One LOAD_DATA_INFILE
2071 can have 0 or more instances of this event written to the binary log
2072 depending on the size of the file.
2073
2074 @internal
2075 The inheritance structure is as follows
2076
2077 Binary_log_event
2078 ^
2079 |
2080 |
2081 B_l:A_B_E Log_event
2082 \ /
2083 \ /
2084 <<vir>>\ /
2085 \ /
2086 Append_block_log_event
2087 B_l: Namespace Binary_log
2088 A_B_E: class Append_block_event
2089 @endinternal
2091*/
2094 public Log_event {
2095 public:
2096 // disable copy-move semantics
2097 Append_block_log_event(Append_block_log_event &&) noexcept = delete;
2099 delete;
2101 Append_block_log_event &operator=(const Append_block_log_event &) = delete;
2102
2103#ifdef MYSQL_SERVER
2104 Append_block_log_event(THD *thd, const char *db_arg, uchar *block_arg,
2105 uint block_len_arg, bool using_trans);
2106 int pack_info(Protocol *protocol) override;
2107 virtual int get_create_or_append() const;
2108#else
2109 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
2110#endif
2111
2113 const char *buf,
2114 const mysql::binlog::event::Format_description_event *description_event);
2115 ~Append_block_log_event() override = default;
2116
2117 void claim_memory_ownership(bool claim) override;
2118
2119 size_t get_data_size() override {
2120 return block_len +
2122 }
2123#ifdef MYSQL_SERVER
2124 bool write(Basic_ostream *ostream) override;
2125 const char *get_db() override { return db; }
2126#endif
2127
2128 bool is_sbr_logging_format() const override { return true; }
2129
2130 private:
2131#if defined(MYSQL_SERVER)
2132 int do_apply_event(Relay_log_info const *rli) override;
2133#endif
2134};
2135
2136/**
2137 @class Delete_file_log_event
2138
2139 Delete_file_log_event is created when the LOAD_DATA query fails on the
2140 master for some reason, and the slave should be notified to abort the
2141 load. The event is required since the master starts writing the loaded
2142 block into the binary log before the statement ends. In case of error,
2143 the slave should abort, and delete any temporary file created while
2144 applying the (NEW_)LOAD_EVENT.
2145
2146 @internal
2147 The inheritance structure is as follows
2148
2149 Binary_log_event
2150 ^
2151 |
2152 |
2153 B_l:D_F_E Log_event
2154 \ /
2155 \ /
2156 \ /
2157 \ /
2158 Delete_file_log_event
2159
2160 B_l: Namespace Binary_log
2161 D_F_E: class Delete_file_event
2162 @endinternal
2164*/
2166 public Log_event {
2167 public:
2168 // disable copy-move semantics
2170 Delete_file_log_event &operator=(Delete_file_log_event &&) noexcept = delete;
2172 Delete_file_log_event &operator=(const Delete_file_log_event &) = delete;
2173
2174#ifdef MYSQL_SERVER
2175 Delete_file_log_event(THD *thd, const char *db_arg, bool using_trans);
2176 int pack_info(Protocol *protocol) override;
2177#else
2178 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
2179 void print(FILE *file, PRINT_EVENT_INFO *print_event_info, bool enable_local);
2180#endif
2181
2183 const char *buf,
2184 const mysql::binlog::event::Format_description_event *description_event);
2185 ~Delete_file_log_event() override = default;
2186
2187 void claim_memory_ownership(bool claim) override;
2188
2189 size_t get_data_size() override {
2191 }
2192#ifdef MYSQL_SERVER
2193 bool write(Basic_ostream *ostream) override;
2194 const char *get_db() override { return db; }
2195#endif
2196
2197 bool is_sbr_logging_format() const override { return true; }
2198
2199 private:
2200#if defined(MYSQL_SERVER)
2201 int do_apply_event(Relay_log_info const *rli) override;
2202#endif
2203};
2204
2205/**
2206 @class Begin_load_query_log_event
2207
2208 Event for the first block of file to be loaded, its only difference from
2209 Append_block event is that this event creates or truncates existing file
2210 before writing data.
2211
2212 @internal
2213 The inheritance structure is as follows
2214
2215 Binary_log_event
2216 ^
2217 |
2218 |
2219 |
2220 Log_event B_l:A_B_E
2221 ^ /\
2222 | / \
2223 | <<vir>>/ \ <<vir>>
2224 | / \
2225 | / \
2226 | / \
2227 Append_block_log_event B_l:B_L_Q_E
2228 \ /
2229 \ /
2230 \ /
2231 \ /
2232 \ /
2233 Begin_load_query_log_event
2234
2235 B_l: Namespace Binary_log
2236 A_B_E: class Append_block_event
2237 B_L_Q_E: Begin_load_query_event
2238 @endinternal
2239
2240 @section Begin_load_query_log_event_binary_format Binary Format
2241*/
2243 : public Append_block_log_event,
2245 public:
2246 // disable copy-move semantics
2249 Begin_load_query_log_event &&) noexcept = delete;
2252 delete;
2253
2254#ifdef MYSQL_SERVER
2255 Begin_load_query_log_event(THD *thd_arg, const char *db_arg, uchar *block_arg,
2256 uint block_len_arg, bool using_trans);
2258 int get_create_or_append() const override;
2259#endif
2261 const char *buf,
2262 const mysql::binlog::event::Format_description_event *description_event);
2263 ~Begin_load_query_log_event() override = default;
2264
2265 void claim_memory_ownership(bool claim) override;
2266
2267 private:
2268#if defined(MYSQL_SERVER)
2270#endif
2271};
2272
2273/**
2274 @class Execute_load_query_log_event
2275
2276 Event responsible for LOAD DATA execution, it similar to Query_log_event
2277 but before executing the query it substitutes original filename in LOAD DATA
2278 query with name of temporary file.
2279
2280 @internal
2281 The inheritance structure is as follows:
2282
2283 Binary_log_event
2284 ^
2285 |
2286 |
2287 |
2288 Log_event B_l:Query_event
2289 ^ /\
2290 | / \
2291 | <<vir>>/ \ <<vir>>
2292 | / \
2293 | / \
2294 | / \
2295 Query_log_event B_l:E_L_Q_E
2296 \ /
2297 \ /
2298 \ /
2299 \ /
2300 \ /
2301 Execute_load_query_log_event
2302
2303 B_l: Namespace Binary_log
2304 E_L_Q_E: class Execute_load_query
2305 @endinternal
2306
2307 @section Execute_load_query_log_event_binary_format Binary Format
2308*/
2310 : public Query_log_event,
2312 public:
2313#ifdef MYSQL_SERVER
2315 THD *thd, const char *query_arg, ulong query_length,
2316 uint fn_pos_start_arg, uint fn_pos_end_arg,
2318 bool using_trans, bool immediate, bool suppress_use, int errcode);
2319 int pack_info(Protocol *protocol) override;
2320#else
2321 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
2322 /* Prints the query as LOAD DATA LOCAL and with rewritten filename */
2323 void print(FILE *file, PRINT_EVENT_INFO *print_event_info,
2324 const char *local_fname) const;
2325#endif
2327 const char *buf,
2328 const mysql::binlog::event::Format_description_event *description_event);
2329 ~Execute_load_query_log_event() override = default;
2330
2331 ulong get_post_header_size_for_derived() override;
2332#ifdef MYSQL_SERVER
2333 bool write_post_header_for_derived(Basic_ostream *ostream) override;
2334#endif
2335
2336 bool is_sbr_logging_format() const override { return true; }
2337
2338 void claim_memory_ownership(bool claim) override;
2339
2340 private:
2341#if defined(MYSQL_SERVER)
2342 int do_apply_event(Relay_log_info const *rli) override;
2343#endif
2344};
2346#if defined MYSQL_SERVER
2348 public:
2349 Load_query_generator(THD *thd_arg, const sql_exchange *ex, const char *db_arg,
2350 const char *table_name_arg, bool is_concurrent_arg,
2351 bool replace, bool ignore);
2352
2353 const String *generate(size_t *fn_start, size_t *fn_end);
2355 private:
2356 const size_t BUF_SIZE = 2048;
2357 String str;
2358 char *buf[2048];
2362 const char *db;
2363 const char *table_name;
2364 const char *fname;
2367 bool has_replace;
2368 bool has_ignore;
2369};
2370#endif
2371#ifndef MYSQL_SERVER
2372/**
2373 @class Unknown_log_event
2374
2375*/
2376class Unknown_log_event : public mysql::binlog::event::Unknown_event,
2377 public Log_event {
2378 public:
2379 // disable copy-move semantics
2380 Unknown_log_event(Unknown_log_event &&) noexcept = delete;
2381 Unknown_log_event &operator=(Unknown_log_event &&) noexcept = delete;
2382 Unknown_log_event(const Unknown_log_event &) = delete;
2383 Unknown_log_event &operator=(const Unknown_log_event &) = delete;
2384
2385 /**
2386 Even if this is an unknown event, we still pass description_event to
2387 Log_event's ctor, this way we can extract maximum information from the
2388 event's header (the unique ID for example).
2389 */
2390 Unknown_log_event(
2391 const char *buf,
2392 const mysql::binlog::event::Format_description_event *description_event)
2393 : mysql::binlog::event::Unknown_event(buf, description_event),
2394 Log_event(header(), footer()) {
2395 DBUG_TRACE;
2396 if (!is_valid()) return;
2397 common_header->set_is_valid(true);
2398 return;
2399 }
2400
2401 ~Unknown_log_event() override = default;
2402 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
2405 }
2406};
2407#endif
2408char *str_to_hex(char *to, const char *from, size_t len);
2409
2410/**
2411 @class Table_map_log_event
2412
2413 Table_map_log_event which maps a table definition to a number.
2414
2415 @internal
2416 The inheritance structure in the current design for the classes is
2417 as follows:
2418
2419 Binary_log_event
2420 ^
2421 |
2422 |
2423 Table_map_event Log_event
2424 \ /
2425 \ /
2426 \ /
2427 Table_map_log_event
2428 @endinternal
2429*/
2431 public Log_event {
2432 public:
2433 // disable copy-move semantics
2435 Table_map_log_event &operator=(Table_map_log_event &&) noexcept = delete;
2436 Table_map_log_event(const Table_map_log_event &) = delete;
2437 Table_map_log_event &operator=(const Table_map_log_event &) = delete;
2439 /** Constants */
2441
2442 /**
2443 Enumeration of the errors that can be returned.
2446 ERR_OPEN_FAILURE = -1, /**< Failure to open table */
2447 ERR_OK = 0, /**< No error */
2448 ERR_TABLE_LIMIT_EXCEEDED = 1, /**< No more room for tables */
2449 ERR_OUT_OF_MEM = 2, /**< Out of memory */
2450 ERR_BAD_TABLE_DEF = 3, /**< Table definition does not match */
2451 ERR_RBR_TO_SBR = 4 /**< daisy-chanining RBR to SBR not allowed */
2453
2454 enum enum_flag {
2455 /**
2456 Nothing here right now, but the flags support is there in
2457 preparation for changes that are coming. Need to add a
2458 constant to make it compile under HP-UX: aCC does not like
2459 empty enumerations.
2462 };
2463
2464 /** Special constants representing sets of flags */
2465 enum {
2467 TM_BIT_LEN_EXACT_F = (1U << 0),
2468 TM_REFERRED_FK_DB_F = (1U << 1),
2469 /**
2470 Table has generated invisible primary key. MySQL generates primary key
2471 while creating a table if sql_generate_invisible_primary_key is "ON" and
2472 table is PK-less.
2474 TM_GENERATED_INVISIBLE_PK_F = (1U << 2)
2476
2477 flag_set get_flags(flag_set flag) const { return m_flags & flag; }
2478
2479#ifdef MYSQL_SERVER
2480 Table_map_log_event(THD *thd_arg, TABLE *tbl,
2482 bool using_trans);
2483#endif
2485 const char *buf,
2486 const mysql::binlog::event::Format_description_event *description_event);
2487
2488 void claim_memory_ownership(bool claim) override;
2489
2490 ~Table_map_log_event() override;
2491
2492#ifndef MYSQL_SERVER
2493 table_def *create_table_def() {
2494 assert(m_colcnt > 0);
2497 }
2498 static bool rewrite_db_in_buffer(
2499 char **buf, ulong *event_len,
2501#endif
2505 const char *get_table_name() const { return m_tblnam.c_str(); }
2506 const char *get_db_name() const { return m_dbnam.c_str(); }
2507
2508 size_t get_data_size() override { return m_data_size; }
2509#ifdef MYSQL_SERVER
2510 virtual int save_field_metadata();
2511 bool write_data_header(Basic_ostream *ostream) override;
2512 bool write_data_body(Basic_ostream *ostream) override;
2513 const char *get_db() override { return m_dbnam.c_str(); }
2514 uint8 mts_number_dbs() override {
2516 }
2517 /**
2518 @param[out] arg pointer to a struct containing char* array
2519 pointers be filled in and the number of filled instances.
2520 @param rpl_filter pointer to a replication filter.
2521
2522 @return number of databases in the array: either one or
2523 OVER_MAX_DBS_IN_EVENT_MTS, when the Table map event reports
2524 foreign keys constraint.
2525 */
2527 const char *db_name = get_db();
2528
2530 size_t dummy_len;
2531 const char *db_filtered = rpl_filter->get_rewrite_db(db_name, &dummy_len);
2532 // db_name != db_filtered means that db_name is rewritten.
2533 if (strcmp(db_name, db_filtered)) db_name = db_filtered;
2534 }
2535
2536 if (!get_flags(TM_REFERRED_FK_DB_F)) arg->name[0] = db_name;
2537
2538 return arg->num = mts_number_dbs();
2539 }
2540
2541#endif
2542
2543#if defined(MYSQL_SERVER)
2544 int pack_info(Protocol *protocol) override;
2545#endif
2546
2547#ifndef MYSQL_SERVER
2548 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
2549
2550 /**
2551 Print column metadata. Its format looks like:
2552 # Columns(colume_name type, colume_name type, ...)
2553 if colume_name field is not logged into table_map_log_event, then
2554 only type is printed.
2555
2556 @param[out] file the place where colume metadata is printed
2557 @param[in] fields The metadata extracted from optional metadata fields
2558 */
2559 void print_columns(IO_CACHE *file,
2560 const Optional_metadata_fields &fields) const;
2561 /**
2562 Print primary information. Its format looks like:
2563 # Primary Key(colume_name, column_name(prifix), ...)
2564 if colume_name field is not logged into table_map_log_event, then
2565 colume index is printed.
2566
2567 @param[out] file the place where primary key is printed
2568 @param[in] fields The metadata extracted from optional metadata fields
2569 */
2570 void print_primary_key(IO_CACHE *file,
2571 const Optional_metadata_fields &fields) const;
2572#endif
2573
2575
2576 bool is_rbr_logging_format() const override { return true; }
2577
2578 private:
2579#if defined(MYSQL_SERVER)
2580 int do_apply_event(Relay_log_info const *rli) override;
2581 int do_update_pos(Relay_log_info *rli) override;
2583#endif
2585#ifdef MYSQL_SERVER
2586 TABLE *m_table;
2588 // Metadata fields buffer
2590
2591 /**
2592 Wrapper around `TABLE *m_table` that abstracts the table field set iteration
2593 logic, since it is not mandatory that all table fields are to be
2594 replicated. For details, @see ReplicatedColumnsView class documentation.
2595
2596 A smart pointer is used here as the developer might want to instantiate the
2597 view using different classes in runtime depending on the given context.
2598 As of now the column view is only used on outbound scenarios
2599 */
2601
2602 /**
2603 Capture the optional metadata fields which should be logged into
2604 table_map_log_event and serialize them into m_metadata_buf.
2605 */
2606 void init_metadata_fields();
2607 bool init_signedness_field();
2608 /**
2609 Capture and serialize character sets. Character sets for
2610 character columns (TEXT etc) and character sets for ENUM and SET
2611 columns are stored in different metadata fields. The reason is
2612 that TEXT character sets are included even when
2613 binlog_row_metadata=MINIMAL, whereas ENUM and SET character sets
2614 are included only when binlog_row_metadata=FULL.
2615
2616 @param include_type Predicate to determine if a given Field object
2617 is to be included in the metadata field.
2618
2619 @param default_charset_type Type code when storing in "default
2620 charset" format. (See comment above Table_maps_log_event in
2621 mysql/binlog/event/rows_event.h)
2622
2623 @param column_charset_type Type code when storing in "column
2624 charset" format. (See comment above Table_maps_log_event in
2625 mysql/binlog/event/rows_event.h)
2626 */
2627 bool init_charset_field(std::function<bool(const Field *)> include_type,
2628 Optional_metadata_field_type default_charset_type,
2629 Optional_metadata_field_type column_charset_type);
2636#endif
2637
2638#ifndef MYSQL_SERVER
2639 class Charset_iterator;
2640 class Default_charset_iterator;
2641 class Column_charset_iterator;
2642#endif
2643};
2644
2645#ifdef HAVE_PSI_STAGE_INTERFACE
2646/*
2647 Helper class for PSI context while applying a Rows_log_event.
2648 */
2650 private:
2653
2654 /**
2655 A cached pointer to this stage PSI_stage_progress.
2656 */
2658
2659 /**
2660 Counter that is unconditionally incremented on each row that is processed.
2661 This is helpful in case estimation is needed after started processing
2662 a Rows_log_event.
2663 */
2666 public:
2668
2669 void set_progress(PSI_stage_progress *progress) { m_progress = progress; }
2670
2671 /**
2672 If instrumentation is enabled this member function SHALL return true.
2673 @return true if instrumentation is enabled for the given stage, false
2674 otherwise.
2675 */
2676 bool is_enabled() { return m_progress != nullptr; }
2677
2678 /**
2679 This member function shall update the progress and reestimate the remaining
2680 work needed. This MUST be called after setting n_rows_applied correctly
2681 by calling inc_n_rows_applied beforehand.
2682
2683 Cursor, begin and end are used in case estimation is needed.
2684
2685 @param cursor Pointer to where we are in the buffer of rows to be processed.
2686 @param begin Pointer to the beginning of the rows buffer.
2687 @param end Pointer to the end of the rows buffer.
2688 */
2689 void update_work_estimated_and_completed(const uchar *cursor,
2690 const uchar *begin,
2691 const uchar *end) {
2692 if (!is_enabled()) return;
2693
2695
2696 /* Estimate if need be. */
2697 if (estimated == 0) {
2698 assert(cursor > begin);
2699 const ulonglong avg_row_change_size = (cursor - begin) / m_n_rows_applied;
2700 estimated = (end - begin) / avg_row_change_size;
2702 }
2703
2704 /* reset estimated if done more work than estimated */
2705 if (m_n_rows_applied > estimated)
2708 }
2709
2710 /**
2711 Resets this object.
2712 */
2713 void end_work() {
2714 m_progress = nullptr;
2715 m_n_rows_applied = 0;
2716 }
2717
2718 /**
2719 Updates the counter of processed rows.
2720 @param delta the amount of increment to be done.
2721 */
2722 void inc_n_rows_applied(ulonglong delta) { m_n_rows_applied += delta; }
2723
2724 /**
2725 Gets the value of the counter of rows that have been processed.
2726 @return the value of the counter of rows processed so far.
2727 */
2729};
2730#endif
2731
2732/**
2733 @class Rows_log_event
2734
2735 Common base class for all row-containing log events.
2736
2737 RESPONSIBILITIES
2738
2739 Encode the common parts of all events containing rows, which are:
2740 - Write data header and data body to an IO_CACHE.
2741
2742 Virtual inheritance is required here to handle the diamond problem in
2743 the class Write_rows_log_event, Update_rows_log_event and
2744 Delete_rows_log_event.
2745 The diamond structure is explained in @c Write_rows_log_event,
2746 @c Update_rows_log_event,
2747 @c Delete_rows_log_event
2748
2749 @internal
2750 The inheritance structure in the current design for the classes is
2751 as follows:
2752
2753 Binary_log_event
2754 ^
2755 |
2756 |
2757 Rows_event Log_event
2758 \ /
2759 <<vir>>\ /
2760 \ /
2761 Rows_log_event
2762 @endinternal
2764*/
2766 public Log_event {
2767#ifdef HAVE_PSI_STAGE_INTERFACE
2768 protected:
2770#endif
2771
2772 public:
2773 // disable copy-move semantics
2774 Rows_log_event(Rows_log_event &&) noexcept = delete;
2775 Rows_log_event &operator=(Rows_log_event &&) noexcept = delete;
2776 Rows_log_event(const Rows_log_event &) = delete;
2777 Rows_log_event &operator=(const Rows_log_event &) = delete;
2778
2787 };
2788
2789 /**
2790 Enumeration of the errors that can be returned.
2793 ERR_OPEN_FAILURE = -1, /**< Failure to open table */
2794 ERR_OK = 0, /**< No error */
2795 ERR_TABLE_LIMIT_EXCEEDED = 1, /**< No more room for tables */
2796 ERR_OUT_OF_MEM = 2, /**< Out of memory */
2797 ERR_BAD_TABLE_DEF = 3, /**< Table definition does not match */
2798 ERR_RBR_TO_SBR = 4 /**< daisy-chanining RBR to SBR not allowed */
2799 };
2801 /* Special constants representing sets of flags */
2802 enum { RLE_NO_FLAGS = 0U };
2803
2806 void set_flags(flag_set flags_arg) { m_flags |= flags_arg; }
2807 void clear_flags(flag_set flags_arg) { m_flags &= ~flags_arg; }
2808 flag_set get_flags(flag_set flags_arg) const { return m_flags & flags_arg; }
2811 get_general_type_code() = 0; /* General rows op type, no version */
2812
2813#if defined(MYSQL_SERVER)
2814 int pack_info(Protocol *protocol) override;
2815#endif
2816
2817#ifndef MYSQL_SERVER
2818 void print_verbose(IO_CACHE *file, PRINT_EVENT_INFO *print_event_info);
2819 size_t print_verbose_one_row(IO_CACHE *file, table_def *td,
2820 PRINT_EVENT_INFO *print_event_info,
2821 MY_BITMAP *cols_bitmap, const uchar *ptr,
2822 const uchar *prefix,
2823 enum_row_image_type row_image_type);
2824#endif
2826#ifdef MYSQL_SERVER
2827 int add_row_data(uchar *data, size_t length) {
2828 return do_add_row_data(data, length);
2829 }
2830#endif
2831
2832 /* Member functions to implement superclass interface */
2833 size_t get_data_size() override;
2835 MY_BITMAP const *get_cols() const { return &m_cols; }
2836 MY_BITMAP const *get_cols_ai() const { return &m_cols_ai; }
2838 return m_table_id;
2839 }
2840
2841#if defined(MYSQL_SERVER)
2842 /**
2843 Compares the table's read/write_set with the columns included in
2844 this event's before-image and/or after-image. Each subclass
2845 (Write/Update/Delete) implements this function by comparing on the
2846 image(s) pertinent to the subclass.
2847
2848 @param[in] table The table to compare this events bitmaps
2849 against.
2850
2851 @retval true if sets match
2852 @retval false otherwise (following bitmap_cmp return logic).
2853 */
2854 virtual bool read_write_bitmaps_cmp(const TABLE *table) const = 0;
2855#endif
2856
2857#ifdef MYSQL_SERVER
2858 bool write_data_header(Basic_ostream *ostream) override;
2859 bool write_data_body(Basic_ostream *ostream) override;
2860 const char *get_db() override { return m_table->s->db.str; }
2861#endif
2862
2863 uint m_row_count; /* The number of rows added to the event */
2864
2865 protected:
2866 /*
2867 The constructors are protected since you're supposed to inherit
2868 this class, not create instances of this class.
2869 */
2870#ifdef MYSQL_SERVER
2872 MY_BITMAP const *cols, bool is_transactional,
2874 const unsigned char *extra_row_ndb_info);
2875#endif
2877 const char *row_data,
2878 const mysql::binlog::event::Format_description_event *description_event);
2879
2880#ifndef MYSQL_SERVER
2881 void print_helper(FILE *, PRINT_EVENT_INFO *) const;
2882#endif
2883
2884#ifdef MYSQL_SERVER
2885 virtual int do_add_row_data(uchar *data, size_t length);
2886#endif
2888#ifdef MYSQL_SERVER
2889 TABLE *m_table; /* The table the rows belong to */
2890#endif
2891 MY_BITMAP m_cols; /* Bitmap denoting columns available */
2892 /**
2893 Bitmap denoting columns available in the image as they appear in the table
2894 setup. On some setups, the number and order of columns may differ from
2895 master to slave so, a bitmap for local available columns is computed using
2896 `ReplicatedColumnsView` utility class.
2897 */
2899#ifdef MYSQL_SERVER
2900 /**
2901 Hash table that will hold the entries for while using HASH_SCAN
2902 algorithm to search and update/delete rows.
2903 */
2905
2906 /**
2907 The algorithm to use while searching for rows using the before
2908 image.
2909 */
2911#endif
2912 /**
2913 Bitmap for columns available in the after image, if present. These
2914 fields are only available for Update_rows events. Observe that the
2915 width of both the before image COLS vector and the after image
2916 COLS vector is the same: the number of columns of the table on the
2917 master.
2918 */
2920 /**
2921 Bitmap denoting columns available in the after-image as they appear in the
2922 table setup. On some setups, the number and order of columns may differ from
2923 master to slave so, a bitmap for local available columns is computed using
2924 `ReplicatedColumnsView` utility class.
2925 */
2928 /* Bit buffers in the same memory as the class */
2929 uint32 m_bitbuf[128 / (sizeof(uint32) * 8)];
2930 uint32 m_bitbuf_ai[128 / (sizeof(uint32) * 8)];
2931
2932 /*
2933 is_valid depends on the value of m_rows_buf, so while changing the value
2934 of m_rows_buf check if is_valid also needs to be modified
2936 uchar *m_rows_buf; /* The rows in packed format */
2937 uchar *m_rows_cur; /* One-after the end of the data */
2938 uchar *m_rows_end; /* One-after the end of the allocated space */
2939
2940 /* helper functions */
2942#if defined(MYSQL_SERVER)
2943 const uchar *m_curr_row; /* Start of the row being processed */
2944 const uchar *m_curr_row_end; /* One-after the end of the current row */
2945 uchar *m_key; /* Buffer to keep key value during searches */
2947 KEY *m_key_info; /* Points to description of index #m_key_index */
2948 class Key_compare {
2949 public:
2950 /**
2951 @param ki Where to find KEY description
2952 @note m_distinct_keys is instantiated when Rows_log_event is constructed;
2953 it stores a Key_compare object internally. However at that moment, the
2954 index (KEY*) to use for comparisons, is not yet known. So, at
2955 instantiation, we indicate the Key_compare the place where it can
2956 find the KEY* when needed (this place is Rows_log_event::m_key_info),
2957 Key_compare remembers the place in member m_key_info.
2958 Before we need to do comparisons - i.e. before we need to insert
2959 elements, we update Rows_log_event::m_key_info once for all.
2961 Key_compare(KEY **ki = nullptr) : m_key_info(ki) {}
2962 bool operator()(uchar *k1, uchar *k2) const {
2963 return key_cmp2((*m_key_info)->key_part, k1, (*m_key_info)->key_length,
2964 k2, (*m_key_info)->key_length) < 0;
2965 }
2967 private:
2970 std::set<uchar *, Key_compare> m_distinct_keys;
2971 std::set<uchar *, Key_compare>::iterator m_itr;
2972 /**
2973 A spare buffer which will be used when saving the distinct keys
2974 for doing an index scan with HASH_SCAN search algorithm.
2975 */
2977
2978 /**
2979 Unpack the current row image from the event into m_table->record[0].
2980
2981 @param rli The applier context.
2982
2983 @param cols The bitmap of columns included in the update.
2984
2985 @param is_after_image Should be true if this is an after-image,
2986 false if it is a before-image.
2987
2988 @param only_seek unpack_row()
2989
2990 @retval 0 Success
2991
2992 @retval ER_* On error, it is guaranteed that the error has been
2993 reported through my_error, and the corresponding ER_* code is
2994 returned. Currently the error codes are: EE_OUTOFMEMORY,
2995 ER_REPLICA_CORRUPT_EVENT, or various JSON errors when applying JSON
2996 diffs (ER_COULD_NOT_APPLY_JSON_DIFF, ER_INVALID_JSON_BINARY_DATA,
2997 and maybe others).
2998 */
2999 int unpack_current_row(const Relay_log_info *const rli, MY_BITMAP const *cols,
3000 bool is_after_image, bool only_seek = false);
3001 /**
3002 Updates the generated columns of the `TABLE` object referenced by
3003 `m_table`, that have an active bit in the parameter bitset
3004 `fields_to_update`.
3005
3006 @param fields_to_update A bitset where the bit at the index of
3007 generated columns to update must be set to `1`
3008
3009 @return 0 if the operation terminated successfully, 1 otherwise.
3010 */
3011 int update_generated_columns(MY_BITMAP const &fields_to_update);
3012 /*
3013 This member function is called when deciding the algorithm to be used to
3014 find the rows to be updated on the slave during row based replication.
3015 This this functions sets the m_rows_lookup_algorithm and also the
3016 m_key_index with the key index to be used if the algorithm is dependent on
3017 an index.
3018 TODO(Bug#31173056): Remove SUPPRESS_UBSAN_CLANG10
3019 */
3021
3022 /*
3023 Encapsulates the operations to be done before applying
3024 row event for update and delete.
3025 */
3027
3028 /*
3029 Encapsulates the operations to be done after applying
3030 row event for update and delete.
3031 */
3033
3034 /**
3035 Helper function to check whether there is an auto increment
3036 column on the table where the event is to be applied.
3037 GIPKs when not present in the source table are also considered a
3038 auto inc column in a extra column.
3039
3040 @param rli the relay log object associated to the replicated table
3041
3042 @return true if there is an autoincrement field on the extra
3043 columns, false otherwise.
3044 */
3045 bool is_auto_inc_in_extra_columns(const Relay_log_info *const rli);
3046
3047 /**
3048 Helper function to check whether the storage engine error
3049 allows for the transaction to be retried or not.
3050
3051 @param error Storage engine error
3052 @retval true if the error is retryable.
3053 @retval false if the error is non-retryable.
3054 */
3056#endif
3057
3058 bool is_rbr_logging_format() const override { return true; }
3059
3060 private:
3061#if defined(MYSQL_SERVER)
3062
3063 /**
3064 Wrapper around `TABLE *m_table` that abstracts the table field set iteration
3065 logic, since it is not mandatory that all table fields are to be
3066 replicated. For details, @see ReplicatedColumnsView class documentation.
3067
3068 A smart pointer is used here as the developer might want to instantiate the
3069 view using different classes in runtime depending on the given context.
3070 */
3072
3073 int do_apply_event(Relay_log_info const *rli) override;
3074 int do_update_pos(Relay_log_info *rli) override;
3076
3077 /*
3078 Primitive to prepare for a sequence of row executions.
3079
3080 DESCRIPTION
3081
3082 Before doing a sequence of do_prepare_row() and do_exec_row()
3083 calls, this member function should be called to prepare for the
3084 entire sequence. Typically, this member function will allocate
3085 space for any buffers that are needed for the two member
3086 functions mentioned above.
3087
3088 RETURN VALUE
3089
3090 The member function will return 0 if all went OK, or a non-zero
3091 error code otherwise.
3092 */
3093 virtual int do_before_row_operations(const Relay_log_info *const log) = 0;
3094
3095 /*
3096 Primitive to clean up after a sequence of row executions.
3097
3098 DESCRIPTION
3099
3100 After doing a sequence of do_prepare_row() and do_exec_row(),
3101 this member function should be called to clean up and release
3102 any allocated buffers.
3103
3104 The error argument, if non-zero, indicates an error which happened during
3105 row processing before this function was called. In this case, even if
3106 function is successful, it should return the error code given in the
3107 argument.
3108 */
3109 virtual int do_after_row_operations(const Relay_log_info *const log,
3110 int error) = 0;
3111
3112 /*
3113 Primitive to do the actual execution necessary for a row.
3114
3115 DESCRIPTION
3116 The member function will do the actual execution needed to handle a row.
3117 The row is located at m_curr_row. When the function returns,
3118 m_curr_row_end should point at the next row (one byte after the end
3119 of the current row).
3120
3121 RETURN VALUE
3122 0 if execution succeeded, 1 if execution failed.
3124 */
3125 virtual int do_exec_row(const Relay_log_info *const rli) = 0;
3126
3127 /**
3128 Private member function called while handling idempotent errors.
3129
3130 @param rli Pointer to relay log info structure.
3131 @param [in,out] err the error to handle. If it is listed as
3132 idempotent/ignored related error, then it is cleared.
3133 @returns true if the slave should stop executing rows.
3134 */
3136
3137 /**
3138 Private member function called after updating/deleting a row. It
3139 performs some assertions and more importantly, it updates
3140 m_curr_row so that the next row is processed during the row
3141 execution main loop (@c Rows_log_event::do_apply_event()).
3142
3143 @param rli Pointer to relay log info structure.
3144 @param err the current error code.
3145 */
3146 void do_post_row_operations(Relay_log_info const *rli, int err);
3147
3148 /**
3149 Commodity wrapper around do_exec_row(), that deals with resetting
3150 the thd reference in the table.
3151 */
3152 int do_apply_row(Relay_log_info const *rli);
3153
3154 /**
3155 Implementation of the index scan and update algorithm. It uses
3156 PK, UK or regular Key to search for the record to update. When
3157 found it updates it.
3158 */
3160
3161 /**
3162 Implementation of the hash_scan and update algorithm. It collects
3163 rows positions in a hashtable until the last row is
3164 unpacked. Then it scans the table to update and when a record in
3165 the table matches the one in the hashtable, the update/delete is
3166 performed.
3167 */
3169
3170 /**
3171 Implementation of the legacy table_scan and update algorithm. For
3172 each unpacked row it scans the storage engine table for a
3173 match. When a match is found, the update/delete operations are
3174 performed.
3175 */
3177
3178 /**
3179 Seek past the after-image of an update event, in case a row was processed
3180 without reading the after-image.
3181
3182 An update event may process a row without reading the after-image,
3183 e.g. in case of ignored or idempotent errors. To ensure that the
3184 read position for the next row is correct, we need to seek past
3185 the after-image.
3186
3187 @param rli The applier context
3188
3189 @param curr_bi_start The read position of the beginning of the
3190 before-image. (The function compares this with m_curr_row to know
3191 if the after-image has been read or not.)
3192
3193 @retval 0 Success
3194 @retval ER_* Error code returned by unpack_current_row
3195 */
3197 [[maybe_unused]],
3198 const uchar *curr_bi_start
3199 [[maybe_unused]]) {
3200 return 0;
3201 }
3202
3203 /**
3204 Initializes scanning of rows. Opens an index and initializes an iterator
3205 over a list of distinct keys (m_distinct_keys) if it is a HASH_SCAN
3206 over an index or the table if its a HASH_SCAN over the table.
3207 */
3208 int open_record_scan();
3209
3210 /**
3211 Does the cleanup
3212 - closes the index if opened by open_record_scan
3213 - closes the table if opened for scanning.
3214 */
3215 int close_record_scan();
3216
3217 /**
3218 Fetches next row. If it is a HASH_SCAN over an index, it populates
3219 table->record[0] with the next row corresponding to the index. If
3220 the indexes are in non-contigous ranges it fetches record corresponding
3221 to the key value in the next range.
3222
3223 @param first_read signifying if this is the first time we are reading a row
3224 over an index.
3225 @return error code when there are no more records to be fetched or some
3226 other error occurred,
3227 - 0 otherwise.
3228 */
3229 int next_record_scan(bool first_read);
3230
3231 /**
3232 Populates the m_distinct_keys with unique keys to be modified
3233 during HASH_SCAN over keys.
3234 @returns 0 success, or the error code.
3235 */
3237
3238 /**
3239 Populates the m_hash when using HASH_SCAN. Thence, it:
3240 - unpacks the before image (BI)
3241 - saves the positions
3242 - saves the positions into the hash map, using the
3243 BI checksum as key
3244 - unpacks the after image (AI) if needed, so that
3245 m_curr_row_end gets updated correctly.
3246
3247 @param rli The reference to the relay log info object.
3248 @returns 0 on success. Otherwise, the error code.
3249 */
3250 int do_hash_row(Relay_log_info const *rli);
3251
3252 /**
3253 This member function scans the table and applies the changes
3254 that had been previously hashed. As such, m_hash MUST be filled
3255 by do_hash_row before calling this member function.
3256
3257 @param rli The reference to the relay log info object.
3258 @returns 0 on success. Otherwise, the error code.
3259 */
3260 int do_scan_and_update(Relay_log_info const *rli);
3261#endif /* defined(MYSQL_SERVER) */
3262
3263 friend class Old_rows_log_event;
3264
3265 /**
3266 This bitmap is used as a backup for the write set while we calculate
3267 the values for any hidden generated columns (functional indexes). In order
3268 to calculate the values, the columns must be marked in the write set. After
3269 the values are calculated, we set the write set back to its original value.
3270 */
3272};
3273
3274/**
3275 @class Write_rows_log_event
3276
3277 Log row insertions and updates. The event contain several
3278 insert/update rows for a table. Note that each event contains only
3279 rows for one table.
3280
3281 @internal
3282 The inheritance structure is as follows
3283
3284 Binary_log_event
3285 ^
3286 |
3287 |
3288 |
3289 Log_event B_l:Rows_event
3290 ^ /\
3291 | / \
3292 | <<vir>>/ \ <<vir>>
3293 | / \
3294 | / \
3295 | / \
3296 Rows_log_event B_l:W_R_E
3297 \ /
3298 \ /
3299 \ /
3300 \ /
3301 \ /
3302 \/
3303 Write_rows_log_event
3304
3305 B_l: Namespace Binary_log
3306 W_R_E: class Write_rows_event
3307 @endinternal
3309*/
3312 public:
3313 enum {
3314 /* Support interface to THD::binlog_prepare_pending_rows_event */
3316 };
3317
3318#if defined(MYSQL_SERVER)
3320 const mysql::binlog::event::Table_id &table_id,
3321 bool is_transactional,
3322 const unsigned char *extra_row_ndb_info);
3323#endif
3325 const char *buf,
3326 const mysql::binlog::event::Format_description_event *description_event);
3327#if defined(MYSQL_SERVER)
3329 bool is_transactional,
3330 const uchar *before_record
3331 [[maybe_unused]],
3332 const uchar *after_record);
3333 bool read_write_bitmaps_cmp(const TABLE *table) const override {
3334 return bitmap_cmp(get_cols(), table->write_set);
3335 }
3336#endif
3337
3338 void claim_memory_ownership(bool claim) override;
3339
3340 protected:
3341 int write_row(const Relay_log_info *const, const bool);
3343 private:
3346 }
3347
3348#ifndef MYSQL_SERVER
3349 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
3350#endif
3351
3352#if defined(MYSQL_SERVER)
3353 int do_before_row_operations(const Relay_log_info *const) override;
3354 int do_after_row_operations(const Relay_log_info *const, int) override;
3355 int do_exec_row(const Relay_log_info *const) override;
3356#endif
3357};
3358
3359/**
3360 @class Update_rows_log_event
3361
3362 Log row updates with a before image. The event contain several
3363 update rows for a table. Note that each event contains only rows for
3364 one table.
3365
3366 Also note that the row data consists of pairs of row data: one row
3367 for the old data and one row for the new data.
3368
3369 @internal
3370 The inheritance structure is as follows
3371
3372 Binary_log_event
3373 ^
3374 |
3375 |
3376 |
3377 Log_event B_l:Rows_event
3378 ^ /\
3379 | / \
3380 | <<vir>>/ \ <<vir>>
3381 | / \
3382 | / \
3383 | / \
3384 Rows_log_event B_l:U_R_E
3385 \ /
3386 \ /
3387 \ /
3388 \ /
3389 \ /
3390 \/
3391 Update_rows_log_event
3392
3393
3394 B_l: Namespace Binary_log
3395 U_R_E: class Update_rows_event
3396 @eninternal
3398*/
3401 public:
3402 enum {
3403 /* Support interface to THD::binlog_prepare_pending_rows_event */
3405 };
3407#ifdef MYSQL_SERVER
3409 const mysql::binlog::event::Table_id &table_id,
3410 MY_BITMAP const *cols_bi, MY_BITMAP const *cols_ai,
3411 bool is_transactional,
3412 const unsigned char *extra_row_ndb_info);
3413
3415 const mysql::binlog::event::Table_id &table_id,
3416 bool is_transactional,
3417 const unsigned char *extra_row_ndb_info);
3418
3419 void init(MY_BITMAP const *cols);
3420#endif
3421
3422 ~Update_rows_log_event() override;
3423
3425 const char *buf,
3426 const mysql::binlog::event::Format_description_event *description_event);
3427
3428#ifdef MYSQL_SERVER
3430 bool is_transactional,
3431 const uchar *before_record,
3432 const uchar *after_record);
3433 bool read_write_bitmaps_cmp(const TABLE *table) const override {
3434 return (bitmap_cmp(get_cols(), table->read_set) &&
3435 bitmap_cmp(get_cols_ai(), table->write_set));
3436 }
3437#endif
3438
3439 void claim_memory_ownership(bool claim) override;
3441 protected:
3444 }
3445
3446#ifndef MYSQL_SERVER
3447 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
3448#endif
3449
3450#if defined(MYSQL_SERVER)
3451 int do_before_row_operations(const Relay_log_info *const) override;
3452 int do_after_row_operations(const Relay_log_info *const, int) override;
3453 int do_exec_row(const Relay_log_info *const) override;
3454
3456 const uchar *curr_bi_start) override;
3457
3458 private:
3459 /**
3460 Auxiliary function used in the (THD*, ...) constructor to
3461 determine the type code based on configuration options.
3462
3463 @param thd_arg The THD object for the session.
3464
3465 @return One of PARTIAL_UPDATE_ROWS_EVENT, or UPDATE_ROWS_EVENT.
3466 */
3468 const THD *thd_arg);
3469#endif /* defined(MYSQL_SERVER) */
3470};
3471
3472/**
3473 @class Delete_rows_log_event
3474
3475 Log row deletions. The event contain several delete rows for a
3476 table. Note that each event contains only rows for one table.
3477
3478 RESPONSIBILITIES
3479
3480 - Act as a container for rows that has been deleted on the master
3481 and should be deleted on the slave.
3482
3483 COLLABORATION
3484
3485 Row_writer
3486 Create the event and add rows to the event.
3487 Row_reader
3488 Extract the rows from the event.
3489
3490 @internal
3491 The inheritance structure is as follows
3492
3493 Binary_log_event
3494 ^
3495 |
3496 |
3497 |
3498 Log_event B_l:Rows_event
3499 ^ /\
3500 | / \
3501 | <<vir>>/ \ <<vir>>
3502 | / \
3503 | / \
3504 | / \
3505 Rows_log_event B_l:D_R_E
3506 \ /
3507 \ /
3508 \ /
3509 \ /
3510 \ /
3511 \/
3512 Delete_rows_log_event
3513
3514 B_l: Namespace Binary_log
3515 D_R_E: class Delete_rows_event
3516 @endinternal
3518*/
3521 public:
3522 enum {
3523 /* Support interface to THD::binlog_prepare_pending_rows_event */
3525 };
3526
3527#ifdef MYSQL_SERVER
3529 bool is_transactional,
3530 const unsigned char *extra_row_ndb_info);
3531#endif
3533 const char *buf,
3534 const mysql::binlog::event::Format_description_event *description_event);
3535#ifdef MYSQL_SERVER
3537 bool is_transactional,
3538 const uchar *before_record,
3539 const uchar *after_record
3540 [[maybe_unused]]);
3541 bool read_write_bitmaps_cmp(const TABLE *table) const override {
3542 return bitmap_cmp(get_cols(), table->read_set);
3543 }
3544#endif
3545
3546 void claim_memory_ownership(bool claim) override;
3548 protected:
3551 }
3552
3553#ifndef MYSQL_SERVER
3554 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
3555#endif
3556
3557#if defined(MYSQL_SERVER)
3558 int do_before_row_operations(const Relay_log_info *const) override;
3559 int do_after_row_operations(const Relay_log_info *const, int) override;
3560 int do_exec_row(const Relay_log_info *const) override;
3561#endif
3562};
3563
3564/**
3565 @class Incident_log_event
3566
3567 Class representing an incident, an occurrence out of the ordinary,
3568 that happened on the master.
3569
3570 The event is used to inform the slave that something out of the
3571 ordinary happened on the master that might cause the database to be
3572 in an inconsistent state.
3573
3574 It's the derived class of Incident_event
3575
3576 @internal
3577 The inheritance structure is as follows
3578
3579 Binary_log_event
3580 ^
3581 |
3582 |
3583 B_l:Incident_event Log_event
3584 \ /
3585 \ /
3586 \ /
3587 \ /
3588 Incident_log_event
3589
3590 B_l: Namespace Binary_log
3591 @endinternal
3593*/
3595 public Log_event {
3596 public:
3597 // disable copy-move semantics
3599 Incident_log_event &operator=(Incident_log_event &&) noexcept = delete;
3600 Incident_log_event(const Incident_log_event &) = delete;
3601 Incident_log_event &operator=(const Incident_log_event &) = delete;
3603#ifdef MYSQL_SERVER
3604 Incident_log_event(THD *thd_arg, enum_incident incident_arg,
3605 std::string_view msg)
3606 : mysql::binlog::event::Incident_event(incident_arg),
3609 DBUG_TRACE;
3610 DBUG_PRINT("enter", ("incident: %d", incident_arg));
3611 common_header->set_is_valid(incident_arg > INCIDENT_NONE &&
3612 incident_arg < INCIDENT_COUNT);
3613 assert(message == nullptr && message_length == 0);
3615 msg.length() + 1, MYF(MY_WME)))) {
3616 // The allocation failed. Mark this binlog event as invalid.
3618 return;
3619 }
3620 strmake(message, msg.data(), msg.length());
3621 message_length = msg.length();
3622 return;
3623 }
3624#endif
3625
3626#ifdef MYSQL_SERVER
3627 int pack_info(Protocol *) override;
3628#endif
3629
3631 const char *buf,
3632 const mysql::binlog::event::Format_description_event *description_event);
3633
3634 ~Incident_log_event() override;
3635
3636 void claim_memory_ownership(bool claim) override;
3637
3638#ifndef MYSQL_SERVER
3639 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
3640#endif
3641
3642#if defined(MYSQL_SERVER)
3643 int do_apply_event(Relay_log_info const *rli) override;
3644 bool write_data_header(Basic_ostream *ostream) override;
3645 bool write_data_body(Basic_ostream *ostream) override;
3646#endif
3647
3648 size_t get_data_size() override {
3652
3653 bool ends_group() const override { return true; }
3654
3655 private:
3656 const char *description() const;
3657};
3658
3659/**
3660 @class Ignorable_log_event
3661
3662 Base class for ignorable log events is Ignorable_event.
3663 Events deriving from this class can be safely ignored
3664 by slaves that cannot recognize them.
3665
3666 Its the derived class of Ignorable_event
3667
3668 @internal
3669 The inheritance structure is as follows
3670
3671 Binary_log_event
3672 ^
3673 |
3674 |
3675 B_l:Ignorable_event Log_event
3676 \ /
3677 <<virtual>>\ /
3678 \ /
3679 Ignorable_log_event
3680
3681 B_l: Namespace Binary_log
3682 @endinternal
3683*/
3686 public Log_event {
3687 public:
3688 // disable copy-move semantics
3690 Ignorable_log_event &operator=(Ignorable_log_event &&) noexcept = delete;
3691 Ignorable_log_event(const Ignorable_log_event &) = delete;
3692 Ignorable_log_event &operator=(const Ignorable_log_event &) = delete;
3694#ifdef MYSQL_SERVER
3695 Ignorable_log_event(THD *thd_arg)
3698 DBUG_TRACE;
3700 return;
3701 }
3702#endif
3703
3705 const char *buf,
3707 ~Ignorable_log_event() override;
3708
3709 void claim_memory_ownership(bool claim) override;
3710
3711#ifdef MYSQL_SERVER
3712 int pack_info(Protocol *) override;
3713#endif
3714
3715#ifndef MYSQL_SERVER
3716 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
3717#endif
3718
3719 size_t get_data_size() override {
3721 }
3722};
3723
3724/**
3725 @class Rows_query_log_event
3726 It is used to record the original query for the rows
3727 events in RBR.
3728 It is the subclass of Ignorable_log_event and Rows_query_event
3729
3730 @internal
3731 The inheritance structure in the current design for the classes is
3732 as follows:
3733 Binary_log_event
3734 ^
3735 |
3736 |
3737 |
3738 Log_event B_l:Ignorable_event
3739 ^ /\
3740 | / \
3741 | <<vir>>/ \ <<vir>>
3742 | / \
3743 | / \
3744 | / \
3745 Ignorable_log_event B_l:Rows_query_event
3746 \ /
3747 \ /
3748 \ /
3749 \ /
3750 \ /
3751 \/
3752 Rows_query_log_event
3753
3754 B_l : namespace namespace mysql::binlog::event
3755 @endinternal
3756*/
3759 public:
3760#ifdef MYSQL_SERVER
3761 Rows_query_log_event(THD *thd_arg, const char *query, size_t query_len)
3762 : Ignorable_log_event(thd_arg) {
3763 DBUG_TRACE;
3765 if (!(m_rows_query =
3767 query_len + 1, MYF(MY_WME))))
3768 return;
3769 snprintf(m_rows_query, query_len + 1, "%s", query);
3770 DBUG_PRINT("enter", ("%s", m_rows_query));
3771 return;
3772 }
3773#endif
3774
3775#ifdef MYSQL_SERVER
3776 int pack_info(Protocol *) override;
3777 int do_apply_event(Relay_log_info const *rli) override;
3778 bool write_data_body(Basic_ostream *ostream) override;
3779#endif
3780
3782 const char *buf,
3784
3785 void claim_memory_ownership(bool claim) override;
3786
3787 ~Rows_query_log_event() override {
3789 m_rows_query = nullptr;
3790 }
3791#ifndef MYSQL_SERVER
3792 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
3793#endif
3794 size_t get_data_size() override {
3796 strlen(m_rows_query);
3797 }
3799
3800static inline bool copy_event_cache_to_file_and_reinit(IO_CACHE *cache,
3801 FILE *file,
3802 bool flush_stream) {
3803 return my_b_copy_to_file(cache, file) ||
3804 (flush_stream ? (fflush(file) || ferror(file)) : 0) ||
3805 reinit_io_cache(cache, WRITE_CACHE, 0, false, true);
3806}
3807
3808#ifdef MYSQL_SERVER
3809/*****************************************************************************
3810
3811 Heartbeat Log Event class
3812
3813 The class is not logged to a binary log, and is not applied on to the slave.
3814 The decoding of the event on the slave side is done by its superclass,
3815 mysql::binlog::event::Heartbeat_event.
3817 ****************************************************************************/
3819 public Log_event {
3820 public:
3822 const char *buf,
3823 const mysql::binlog::event::Format_description_event *description_event);
3825
3827 public Log_event {
3828 public:
3830 const char *buf,
3831 const mysql::binlog::event::Format_description_event *description_event);
3832};
3833/**
3834 The function is called by slave applier in case there are
3835 active table filtering rules to force gathering events associated
3836 with Query-log-event into an array to execute
3837 them once the fate of the Query is determined for execution.
3838*/
3840#endif
3841
3842int append_query_string(const THD *thd, const CHARSET_INFO *csinfo,
3843 String const *from, String *to);
3845
3848 public Log_event {
3849 public:
3850#ifdef MYSQL_SERVER
3851
3852 class Applier_context {
3853 private:
3854 // context for the applier (to remove if we remove the DATABASE scheduler)
3857 public:
3858 Applier_context() = default;
3859 virtual ~Applier_context() { reset(); }
3863
3864 Transaction_payload_log_event(THD *thd_arg, const char *payload,
3865 uint64_t payload_size,
3866 uint16_t compression_type,
3867 uint64_t uncompressed_size)
3868 : Transaction_payload_event(payload, payload_size, compression_type,
3869 uncompressed_size),
3870 Log_event(thd_arg, 0 /* flags */, Log_event::EVENT_TRANSACTIONAL_CACHE,
3872
3873 Transaction_payload_log_event(THD *thd_arg, const char *payload,
3874 uint64_t payload_size)
3876 thd_arg, payload, payload_size,
3877 mysql::binlog::event::compression::type::NONE, payload_size) {}
3878
3880 : Transaction_payload_log_event(thd_arg, nullptr, (uint64_t)0) {}
3881#endif
3882
3884 const char *buf,
3887
3888 ~Transaction_payload_log_event() override = default;
3889
3890 void claim_memory_ownership(bool claim) override;
3891
3892#ifndef MYSQL_SERVER
3893 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
3894#endif
3895
3896 size_t get_event_length() { return LOG_EVENT_HEADER_LEN + get_data_size(); }
3897 size_t get_data_size() override;
3898
3899#if defined(MYSQL_SERVER)
3900 private:
3902
3903 public:
3904 int do_apply_event(Relay_log_info const *rli) override;
3905 bool apply_payload_event(Relay_log_info const *rli, const uchar *event_buf);
3907 int pack_info(Protocol *protocol) override;
3908 bool ends_group() const override;
3909 bool write(Basic_ostream *ostream) override;
3911 void set_mts_dbs(Mts_db_names &arg);
3912 uint8 mts_number_dbs() override;
3913#endif
3914};
3915
3916/**
3917 @class Gtid_log_event
3918
3919 This is a subclass if Gtid_event and Log_event. It contains
3920 per-transaction fields, including the GTID and logical timestamps
3921 used by MTS.
3922
3923 @internal
3924 The inheritance structure is as follows
3925
3926 Binary_log_event
3927 ^
3928 |
3929 |
3930 B_l:Gtid_event Log_event
3931 \ /
3932 \ /
3933 \ /
3934 \ /
3935 Gtid_log_event
3936
3937 B_l: Namespace Binary_log
3938 @endinternal
3939*/
3941 public Log_event {
3942 public:
3943 // disable copy-move semantics
3944 Gtid_log_event(Gtid_log_event &&) noexcept = delete;
3945 Gtid_log_event &operator=(Gtid_log_event &&) noexcept = delete;
3946 Gtid_log_event(const Gtid_log_event &) = delete;
3947 Gtid_log_event &operator=(const Gtid_log_event &) = delete;
3948
3949#ifdef MYSQL_SERVER
3950 /**
3951 Create a new event using the GTID owned by the given thread.
3952 */
3953 Gtid_log_event(THD *thd_arg, bool using_trans, int64 last_committed_arg,
3954 int64 sequence_number_arg, bool may_have_sbr_stmts_arg,
3955 ulonglong original_commit_timestamp_arg,
3956 ulonglong immediate_commit_timestamp_arg,
3957 uint32_t original_server_version_arg,
3958 uint32_t immediate_server_version_arg);
3959
3960 /**
3961 Create a new event using the GTID from the given Gtid_specification
3962 without a THD object.
3963 */
3964 Gtid_log_event(uint32 server_id_arg, bool using_trans,
3965 int64 last_committed_arg, int64 sequence_number_arg,
3966 bool may_have_sbr_stmts_arg,
3967 ulonglong original_commit_timestamp_arg,
3968 ulonglong immediate_commit_timestamp_arg,
3969 const Gtid_specification spec_arg,
3970 uint32_t original_server_version_arg,
3971 uint32_t immediate_server_version_arg);
3972#endif
3973
3974#ifdef MYSQL_SERVER
3975 int pack_info(Protocol *) override;
3976#endif
3978 const char *buffer,
3980
3981 ~Gtid_log_event() override = default;
3982
3983 void claim_memory_ownership(bool claim) override;
3984
3986
3987 size_t get_data_size() override {
3988 if (is_tagged()) {
3989 auto size_calculated = Encoder_type::get_size(*this);
3990 DBUG_EXECUTE_IF("add_unknown_ignorable_fields_to_gtid_log_event",
3991 { size_calculated += 2; });
3992 return size_calculated;
3993 }
3994 DBUG_EXECUTE_IF("do_not_write_rpl_timestamps", return POST_HEADER_LENGTH;);
3998 }
3999
4000 /// @brief Clears tsid and spec
4001 void clear_gtid_and_spec();
4002
4003 /// @brief Updates parent tsid and gtid info structure
4005
4006 size_t get_event_length() { return LOG_EVENT_HEADER_LEN + get_data_size(); }
4007
4008 /// Used internally by both print() and pack_info().
4009 size_t to_string(char *buf) const;
4010
4011 private:
4012#ifdef MYSQL_SERVER
4013 /**
4014 Writes the post-header to the given output stream.
4015
4016 This is an auxiliary function typically used by the write() member
4017 function.
4018
4019 @param ostream The output stream to write to.
4020
4021 @retval true Error.
4022 @retval false Success.
4023 */
4024 bool write_data_header(Basic_ostream *ostream) override;
4025 bool write_data_body(Basic_ostream *ostream) override;
4026 /**
4027 Writes the post-header to the given memory buffer.
4028
4029 This is an auxiliary function used by write_to_memory.
4030
4031 @param[in,out] buffer Buffer to which the post-header will be written.
4032
4033 @return The number of bytes written, i.e., always
4034 Gtid_log_event::POST_HEADER_LENGTH.
4035 */
4037
4038 /**
4039 Writes the body to the given memory buffer.
4040
4041 This is an auxiliary function used by write_to_memory.
4042
4043 @param [in,out] buff Buffer to which the data will be written.
4044
4045 @return The number of bytes written, i.e.,
4046 If the transaction did not originated on this server
4047 Gtid_event::IMMEDIATE_COMMIT_TIMESTAMP_LENGTH.
4048 else
4049 FULL_COMMIT_TIMESTAMP_LENGTH.
4050 */
4052
4053 /// @copydoc write_body_to_memory
4054 /// @details Version for tagged Gtid log event
4056
4057#endif
4058
4059 public:
4060#ifndef MYSQL_SERVER
4061 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
4062#endif
4063
4064#if defined(MYSQL_SERVER)
4065 int do_apply_event(Relay_log_info const *rli) override;
4066 int do_update_pos(Relay_log_info *rli) override;
4068#endif
4069
4070 /**
4071 Return the gtid type for this Gtid_log_event: this can be
4072 either ANONYMOUS_GTID, AUTOMATIC_GTID, or ASSIGNED_GTID.
4073 */
4074 enum_gtid_type get_type() const { return spec.type; }
4075
4076 /**
4077 Return the TSID for this GTID. The TSID is shared with the
4078 Log_event so it should not be modified.
4079 */
4080 const Tsid &get_tsid() const { return tsid; }
4081 /**
4082 Return the SIDNO relative to the global tsid_map for this GTID.
4083
4084 This requires a lookup and possibly even update of global_tsid_map,
4085 hence global_tsid_lock must be held. If global_tsid_lock is not
4086 held, the caller must pass need_lock=true. If there is an error
4087 (e.g. out of memory) while updating global_tsid_map, this function
4088 returns a negative number.
4089
4090 @param need_lock If true, the read lock on global_tsid_lock is
4091 acquired and released inside this function; if false, the read
4092 lock or write lock must be held prior to calling this function.
4093 @retval SIDNO if successful
4094 @retval negative if adding TSID to global_tsid_map causes an error.
4095 */
4096 rpl_sidno get_sidno(bool need_lock);
4097
4098 /**
4099 Return the SIDNO relative to the given Tsid_map for this GTID.
4100
4101 This assumes that the Tsid_map is local to the thread, and thus
4102 does not use locks.
4103
4104 @param tsid_map The tsid_map to use.
4105 @retval SIDNO if successful.
4106 @retval negative if adding TSID to tsid_map causes an error.
4107 */
4108 rpl_sidno get_sidno(Tsid_map *tsid_map) { return tsid_map->add_tsid(tsid); }
4109 /// Return the GNO for this GTID.
4110 rpl_gno get_gno() const override { return spec.gtid.gno; }
4112 /// string holding the text "SET @@GLOBAL.GTID_NEXT = '"
4113 static const char *SET_STRING_PREFIX;
4114
4115 private:
4116 /// Length of SET_STRING_PREFIX
4117 static const size_t SET_STRING_PREFIX_LENGTH = 26;
4118 /// The maximal length of the entire "SET ..." query.
4119 static const size_t MAX_SET_STRING_LENGTH = SET_STRING_PREFIX_LENGTH +
4122
4123 private:
4124 /**
4125 Internal representation of the GTID. The SIDNO will be
4126 uninitialized (value -1) until the first call to get_sidno(bool).
4127 */
4129 /// TSID for this GTID.
4130 Tsid tsid;
4131
4132 public:
4133 /**
4134 Set the transaction length information based on binlog cache size.
4135
4136 Note that is_checksum_enabled and event_counter are optional parameters.
4137 When not specified, the function will assume that no checksum will be used
4138 and the informed cache_size is the final transaction size without
4139 considering the GTID event size.
4140
4141 The high level formula that will be used by the function is:
4142
4143 trx_length = cache_size +
4144 cache_checksum_active * cache_events * CRC32_payload +
4145 gtid_length +
4146 cache_checksum_active * CRC32_payload; // For the GTID.
4147
4148 @param cache_size The size of the binlog cache in bytes.
4149 @param is_checksum_enabled If checksum will be added to events on flush.
4150 @param event_counter The amount of events in the cache.
4151 */
4153 bool is_checksum_enabled = false,
4154 int event_counter = 0);
4155
4156 /// @copydoc set_trx_length_by_cache_size
4157 /// @detail tagged version of event
4159 bool is_checksum_enabled = false,
4160 int event_counter = 0);
4161};
4162
4163/**
4164 @class Previous_gtids_log_event
4165
4166 This is the subclass of Previous_gtids_event and Log_event
4167 It is used to record the gtid_executed in the last binary log file,
4168 for ex after flush logs, or at the starting of the binary log file
4169
4170 @internal
4171 The inheritance structure is as follows
4172
4173 Binary_log_event
4174 ^
4175 |
4176 |
4177B_l:Previous_gtids_event Log_event
4178 \ /
4179 \ /
4180 \ /
4181 \ /
4182 Previous_gtids_log_event
4183
4184 B_l: Namespace Binary_log
4185 @endinternal
4186*/
4189 public Log_event {
4190 public:
4191 // disable copy-move semantics
4194 delete;
4197 delete;
4198
4199#ifdef MYSQL_SERVER
4201#endif
4202
4203#ifdef MYSQL_SERVER
4204 int pack_info(Protocol *) override;
4205#endif
4206
4208 const char *buf,
4209 const mysql::binlog::event::Format_description_event *description_event);
4210 ~Previous_gtids_log_event() override = default;
4211
4212 size_t get_data_size() override { return buf_size; }
4213
4214 void claim_memory_ownership(bool claim) override;
4215
4216#ifndef MYSQL_SERVER
4217 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
4218#endif
4219#ifdef MYSQL_SERVER
4220 bool write(Basic_ostream *ostream) override {
4221#ifndef NDEBUG
4222 if (DBUG_EVALUATE_IF("skip_writing_previous_gtids_log_event", 1, 0) &&
4223 /*
4224 The skip_writing_previous_gtids_log_event debug point was designed
4225 for skipping the writing of the previous_gtids_log_event on binlog
4226 files only.
4227 */
4228 !is_relay_log_event()) {
4229 DBUG_PRINT("info",
4230 ("skip writing Previous_gtids_log_event because of"
4231 "debug option 'skip_writing_previous_gtids_log_event'"));
4232 return false;
4233 }
4234
4235 if (DBUG_EVALUATE_IF("write_partial_previous_gtids_log_event", 1, 0) &&
4236 /*
4237 The write_partial_previous_gtids_log_event debug point was designed
4238 for writing a partial previous_gtids_log_event on binlog files only.
4239 */
4240 !is_relay_log_event()) {
4241 DBUG_PRINT("info",
4242 ("writing partial Previous_gtids_log_event because of"
4243 "debug option 'write_partial_previous_gtids_log_event'"));
4244 return (Log_event::write_header(ostream, get_data_size()) ||
4246 }
4247#endif
4248
4249 return (Log_event::write_header(ostream, get_data_size()) ||
4250 Log_event::write_data_header(ostream) || write_data_body(ostream) ||
4251 Log_event::write_footer(ostream));
4252 }
4253 bool write_data_body(Basic_ostream *ostream) override;
4254#endif
4256 /// Return the encoded buffer, or NULL on error.
4257 const uchar *get_buf() { return buf; }
4258 /**
4259 Return the formatted string, or NULL on error.
4260 The string is allocated using my_malloc and it is the
4261 responsibility of the caller to free it.
4262 */
4263 char *get_str(size_t *length,
4265 /// Add all GTIDs from this event to the given Gtid_set.
4266 int add_to_set(Gtid_set *gtid_set) const;
4267 /*
4268 Previous Gtid Log events should always be skipped
4269 there is nothing to apply there, whether it is
4270 relay log's (generated on Slave) or it is binary log's
4271 (generated on Master, copied to slave as relay log).
4272 Also, we should not increment slave_skip_counter
4273 for this event, hence return EVENT_SKIP_IGNORE.
4275#if defined(MYSQL_SERVER)
4277 {
4278 return EVENT_SKIP_IGNORE;
4280
4281 int do_apply_event(Relay_log_info const *) override { return 0; }
4282 int do_update_pos(Relay_log_info *rli) override;
4283#endif
4284};
4285
4286/**
4287 @class Transaction_context_log_event
4288
4289 This is the subclass of Transaction_context_event and Log_event
4290 This class encodes the transaction_context_log_event.
4291
4292 @internal
4293 The inheritance structure is as follows
4294
4295 Binary_log_event
4296 ^
4297 |
4298 |
4299B_l:Transaction_context_event Log_event
4300 \ /
4301 \ /
4302 \ /
4303 \ /
4304 Transaction_context_log_event
4305
4306 B_l: Namespace Binary_log
4307 @endinternal
4308*/
4311 public Log_event {
4312 private:
4313 /// The Tsid_map to use for creating the Gtid_set.
4315 /// A gtid_set which is used to store the transaction set used for
4316 /// conflict detection.
4318
4319#ifdef MYSQL_SERVER
4320 bool write_data_header(Basic_ostream *ostream) override;
4321
4322 bool write_data_body(Basic_ostream *ostream) override;
4323
4325
4326 bool write_data_set(Basic_ostream *ostream, std::list<const char *> *set);
4327#endif
4328
4330
4331 static int get_data_set_size(std::list<const char *> *set);
4332
4333 size_t to_string(char *buf, ulong len) const;
4334
4335 public:
4336#ifdef MYSQL_SERVER
4337
4338 Transaction_context_log_event(const char *server_uuid_arg, bool using_trans,
4339 my_thread_id thread_id_arg,
4340 bool is_gtid_specified);
4341
4342#endif
4343
4345 const char *buffer,
4347
4349
4350 void claim_memory_ownership(bool claim) override;
4351
4352 size_t get_data_size() override;
4353
4354 size_t get_event_length();
4355
4356#ifdef MYSQL_SERVER
4357 int pack_info(Protocol *protocol) override;
4358#endif
4359
4360#ifndef MYSQL_SERVER
4361 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
4362#endif
4364#if defined(MYSQL_SERVER)
4365 int do_apply_event(Relay_log_info const *) override { return 0; }
4366 int do_update_pos(Relay_log_info *rli) override;
4367#endif
4368
4369 /**
4370 Add a hash which identifies a inserted/updated/deleted row on the
4371 ongoing transaction.
4372
4373 @param[in] hash row identifier
4374 */
4375 void add_write_set(const char *hash);
4376
4377 /**
4378 Return a pointer to write-set list.
4379 */
4380 std::list<const char *> *get_write_set() { return &write_set; }
4381
4382 /**
4383 Add a hash which identifies a read row on the ongoing transaction.
4384
4385 @param[in] hash row identifier
4386 */
4387 void add_read_set(const char *hash);
4388
4389 /**
4390 Return a pointer to read-set list.
4391 */
4392 std::list<const char *> *get_read_set() { return &read_set; }
4393
4394 /**
4395 Read snapshot version from encoded buffers.
4396 Cannot be executed during data read from file (event constructor),
4397 since its required locks will collide with the server gtid state
4398 initialization procedure.
4399 */
4400 bool read_snapshot_version();
4401
4402 /**
4403 Return the transaction snapshot timestamp.
4404 */
4406
4407 /**
4408 Return the server uuid.
4409 */
4410 const char *get_server_uuid() { return server_uuid; }
4411
4412 /**
4413 Return the id of the committing thread.
4414 */
4415 my_thread_id get_thread_id() const {
4416 return static_cast<my_thread_id>(thread_id);
4417 }
4418
4419 /**
4420 Return true if transaction has GTID fully specified, false otherwise.
4421 */
4422 bool is_gtid_specified() const { return gtid_specified; }
4423};
4424
4425/**
4426 @class View_change_log_event
4427
4428 This is the subclass of View_change_log_event and Log_event
4429 This class created the view_change_log_event which is used as a marker in
4430 case a new node joins or leaves the group.
4431
4432 @internal
4433 The inheritance structure is as follows
4434
4435 Binary_log_event
4436 ^
4437 |
4438 |
4439B_l: View_change_event Log_event
4440 \ /
4441 \ /
4442 \ /
4443 \ /
4444 View_change_log_event
4445
4446 B_l: Namespace Binary_log
4447 @endinternal
4449
4451 public Log_event {
4452 private:
4453 size_t to_string(char *buf, ulong len) const;
4454
4455#ifdef MYSQL_SERVER
4456 bool write_data_header(Basic_ostream *ostream) override;
4457
4458 bool write_data_body(Basic_ostream *ostream) override;
4459
4460 bool write_data_map(Basic_ostream *ostream,
4461 std::map<std::string, std::string> *map);
4462#endif
4463
4464 size_t get_size_data_map(std::map<std::string, std::string> *map);
4465
4466 public:
4467 // disable copy-move semantics
4469 View_change_log_event &operator=(View_change_log_event &&) noexcept = delete;
4471 View_change_log_event &operator=(const View_change_log_event &) = delete;
4472
4473 View_change_log_event(const char *view_id);
4474
4476 const char *buffer,
4477 const mysql::binlog::event::Format_description_event *descr_event);
4478
4479 ~View_change_log_event() override;
4480
4481 void claim_memory_ownership(bool claim) override;
4482
4483 size_t get_data_size() override;
4484
4485#ifdef MYSQL_SERVER
4486 int pack_info(Protocol *protocol) override;
4487#endif
4488
4489#ifndef MYSQL_SERVER
4490 void print(FILE *file, PRINT_EVENT_INFO *print_event_info) const override;
4491#endif
4492
4493#if defined(MYSQL_SERVER)
4494 int do_apply_event(Relay_log_info const *rli) override;
4495 int do_update_pos(Relay_log_info *rli) override;
4496#endif
4497
4498 /**
4499 Returns the view id.
4500 */
4501 char *get_view_id() { return view_id; }
4502
4503 /**
4504 Sets the certification info in the event
4505
4506 @note size is calculated on this method as the size of the data
4507 might render the log even invalid. Also due to its size doing it
4508 here avoid looping over the data multiple times.
4509
4510 @param[in] info certification info to be written
4511 @param[out] event_size the event size after this operation
4512 */
4513 void set_certification_info(std::map<std::string, std::string> *info,
4514 size_t *event_size);
4515
4516 /**
4517 Returns the certification info
4518 */
4519 std::map<std::string, std::string> *get_certification_info() {
4520 return &certification_info;
4521 }
4522
4523 /**
4524 Set the certification sequence number
4525
4526 @param number the sequence number
4527 */
4528 void set_seq_number(rpl_gno number) { seq_number = number; }
4529
4530 /**
4531 Returns the certification sequence number
4532 */
4533 rpl_gno get_seq_number() { return seq_number; }
4535
4536inline bool is_any_gtid_event(const Log_event *evt) {
4538 evt->get_type_code()));
4539}
4540
4541/**
4542 Check if the given event is a session control event, one of
4543 `User_var_event`, `Intvar_event` or `Rand_event`.
4544
4545 @param evt The event to check.
4546
4547 @return true if the given event is of type `User_var_event`,
4548 `Intvar_event` or `Rand_event`, false otherwise.
4549 */
4550inline bool is_session_control_event(Log_event *evt) {
4554}
4555
4556/**
4557 The function checks the argument event properties to deduce whether
4558 it represents an atomic DDL.
4559
4560 @param evt a reference to Log_event
4561 @return true when the DDL properties are found,
4562 false otherwise
4563*/
4564inline bool is_atomic_ddl_event(Log_event const *evt) {
4565 return evt != nullptr &&
4567 static_cast<Query_log_event const *>(evt)->ddl_xid !=
4569}
4570
4571/**
4572 The function lists all DDL instances that are supported
4573 for crash-recovery (WL9175).
4574 todo: the supported feature list is supposed to grow. Once
4575 a feature has been readied for 2pc through WL7743,9536(7141/7016) etc
4576 it needs registering in the function.
4577
4578 @param thd an Query-log-event creator thread handle
4579 @param using_trans
4580 The caller must specify the value according to the following
4581 rules:
4582 @c true when
4583 - on master the current statement is not processing
4584 a table in SE which does not support atomic DDL
4585 - on slave the relay-log repository is transactional.
4586 @c false otherwise.
4587 @return true when the being created (master) or handled (slave) event
4588 is 2pc-capable, @c false otherwise.
4589*/
4590bool is_atomic_ddl(THD *thd, bool using_trans);
4591
4592#ifdef MYSQL_SERVER
4593/**
4594 Serialize an binary event to the given output stream. It is more general
4595 than call ev->write() directly. The caller will not be affected if any
4596 change happens in serialization process. For example, serializing the
4597 event in different format.
4599template <class EVENT>
4600bool binary_event_serialize(EVENT *ev, Basic_ostream *ostream) {
4601 return ev->write(ostream);
4602}
4603
4604/*
4605 This is an utility function that adds a quoted identifier into the a buffer.
4606 This also escapes any existence of the quote string inside the identifier.
4607 */
4608size_t my_strmov_quoted_identifier(THD *thd, char *buffer,
4609 const char *identifier, size_t length);
4610#else
4611size_t my_strmov_quoted_identifier(char *buffer, const char *identifier);
4612#endif
4614 const char *identifier,
4615 size_t length);
4616
4617/**
4618 Read an integer in net_field_length format, guarding against read out of
4619 bounds and advancing the position.
4620
4621 @param[in,out] packet Pointer to buffer to read from. On successful
4622 return, the buffer position will be incremented to point to the next
4623 byte after what was read.
4624
4625 @param[in,out] max_length Pointer to the number of bytes in the
4626 buffer. If the function would need to look at more than *max_length
4627 bytes in order to decode the number, the function will do nothing
4628 and return true.
4629
4630 @param[out] out Pointer where the value will be stored.
4631
4632 @retval false Success.
4633 @retval true Failure, i.e., reached end of buffer.
4634*/
4635template <typename T>
4636bool net_field_length_checked(const uchar **packet, size_t *max_length, T *out);
4637
4638/**
4639 Extract basic info about an event: type, query, is it ignorable
4640
4641 @param log_event the event to extract info from
4642 @return a pair first param is true if an error occurred, false otherwise
4643 second param is the event info
4644 */
4645std::pair<bool, mysql::binlog::event::Log_event_basic_info>
4647
4648/**
4649 Extract basic info about an event: type, query, is it ignorable
4650
4651 @param buf The event info buffer
4652 @param length The length of the buffer
4653 @param fd_event The Format description event associated
4654 @return a pair first param is true if an error occurred, false otherwise
4655 second param is the event info
4656 */
4657std::pair<bool, mysql::binlog::event::Log_event_basic_info>
4659 const char *buf, size_t length,
4661
4662/**
4663 @} (end of group Replication)
4664*/
4665
4666#endif /* _log_event_h */
Kerberos Client Authentication nullptr
Definition: auth_kerberos_client_plugin.cc:251
int64 query_id_t
Definition: binlog.h:72
Contains the classes representing events occurring in the replication stream.
#define LOG_EVENT_HEADER_LEN
Definition: binlog_event.h:443
This event is created to contain the file data.
Definition: log_event.h:2092
bool write(Basic_ostream *ostream) override
Definition: log_event.cc:7009
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:7036
virtual int get_create_or_append() const
Definition: log_event.cc:7059
bool is_sbr_logging_format() const override
Return true if the event has to be logged using SBR for DMLs.
Definition: log_event.h:2126
size_t get_data_size() override
Definition: log_event.h:2117
int pack_info(Protocol *protocol) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:7046
~Append_block_log_event() override=default
const char * get_db() override
Definition: log_event.h:2123
Append_block_log_event(Append_block_log_event &&) noexcept=delete
int do_apply_event(Relay_log_info const *rli) override
Primitive to apply an event to the database.
Definition: log_event.cc:7089
The abstract class for basic output streams which provides write operation.
Definition: basic_ostream.h:37
Event for the first block of file to be loaded, its only difference from Append_block event is that t...
Definition: log_event.h:2242
enum_skip_reason do_shall_skip(Relay_log_info *rli) override
Decide if this event shall be skipped or not and the reason for skipping it.
Definition: log_event.cc:7310
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:7300
~Begin_load_query_log_event() override=default
Begin_load_query_log_event(THD *thd)
Begin_load_query_log_event(Begin_load_query_log_event &&) noexcept=delete
int get_create_or_append() const override
Definition: log_event.cc:7306
Delete_file_log_event is created when the LOAD_DATA query fails on the master for some reason,...
Definition: log_event.h:2164
Delete_file_log_event(const Delete_file_log_event &)=delete
int do_apply_event(Relay_log_info const *rli) override
Primitive to apply an event to the database.
Definition: log_event.cc:7250
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:7228
size_t get_data_size() override
Definition: log_event.h:2187
~Delete_file_log_event() override=default
bool is_sbr_logging_format() const override
Return true if the event has to be logged using SBR for DMLs.
Definition: log_event.h:2195
bool write(Basic_ostream *ostream) override
Definition: log_event.cc:7205
const char * get_db() override
Definition: log_event.h:2192
Delete_file_log_event(Delete_file_log_event &&) noexcept=delete
int pack_info(Protocol *protocol) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:7238
Log row deletions.
Definition: log_event.h:3518
bool read_write_bitmaps_cmp(const TABLE *table) const override
Compares the table's read/write_set with the columns included in this event's before-image and/or aft...
Definition: log_event.h:3539
static bool binlog_row_logging_function(THD *thd, TABLE *table, bool is_transactional, const uchar *before_record, const uchar *after_record)
Definition: log_event.cc:12392
int do_after_row_operations(const Relay_log_info *const, int) override
Definition: log_event.cc:12445
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:12412
Delete_rows_log_event(THD *, TABLE *, const mysql::binlog::event::Table_id &, bool is_transactional, const unsigned char *extra_row_ndb_info)
Definition: log_event.cc:12381
mysql::binlog::event::Log_event_type get_general_type_code() override
Definition: log_event.h:3547
int do_exec_row(const Relay_log_info *const) override
Definition: log_event.cc:12452
@ TYPE_CODE
Definition: log_event.h:3522
int do_before_row_operations(const Relay_log_info *const) override
Definition: log_event.cc:12419
Event responsible for LOAD DATA execution, it similar to Query_log_event but before executing the que...
Definition: log_event.h:2309
int do_apply_event(Relay_log_info const *rli) override
Primitive to apply an event to the database.
Definition: log_event.cc:7464
bool is_sbr_logging_format() const override
When a query log event contains a non-transaction control statement, we assume that it is changing da...
Definition: log_event.h:2334
bool write_post_header_for_derived(Basic_ostream *ostream) override
Definition: log_event.cc:7374
int pack_info(Protocol *protocol) override
This (which is used only for SHOW BINLOG EVENTS) could be updated to print SET @session_var=.
Definition: log_event.cc:7433
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:7368
ulong get_post_header_size_for_derived() override
Definition: log_event.cc:7364
Execute_load_query_log_event(THD *thd, const char *query_arg, ulong query_length, uint fn_pos_start_arg, uint fn_pos_end_arg, mysql::binlog::event::enum_load_dup_handling dup_handling_arg, bool using_trans, bool immediate, bool suppress_use, int errcode)
Definition: log_event.cc:7323
~Execute_load_query_log_event() override=default
Definition: field.h:575
For binlog version 4.
Definition: log_event.h:1525
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:5324
std::atomic< int32 > atomic_usage_counter
Definition: log_event.h:1543
int pack_info(Protocol *protocol) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:5330
enum_skip_reason do_shall_skip(Relay_log_info *rli) override
Decide if this event shall be skipped or not and the reason for skipping it.
Definition: log_event.cc:5503
size_t get_data_size() override
Definition: log_event.h:1556
bool write(Basic_ostream *ostream) override
Definition: log_event.cc:5340
int do_update_pos(Relay_log_info *rli) override
Advance relay log coordinates.
Definition: log_event.cc:5474
int do_apply_event(Relay_log_info const *rli) override
Primitive to apply an event to the database.
Definition: log_event.cc:5423
Format_description_log_event()
Format_description_log_event 1st ctor.
Definition: log_event.cc:5215
This is a subclass if Gtid_event and Log_event.
Definition: log_event.h:3939
void set_trx_length_by_cache_size_tagged(ulonglong cache_size, bool is_checksum_enabled=false, int event_counter=0)
Set the transaction length information based on binlog cache size.
Definition: log_event.cc:13490
rpl_gno get_gno() const override
Return the GNO for this GTID.
Definition: log_event.h:4108
rpl_sidno get_sidno(bool need_lock)
Return the SIDNO relative to the global tsid_map for this GTID.
Definition: log_event.cc:13521
~Gtid_log_event() override=default
bool write_data_header(Basic_ostream *ostream) override
Writes the post-header to the given output stream.
Definition: log_event.cc:13204
Gtid_log_event(Gtid_log_event &&) noexcept=delete
size_t get_event_length()
Definition: log_event.h:4004
int do_update_pos(Relay_log_info *rli) override
Advance relay log coordinates.
Definition: log_event.cc:13471
enum_gtid_type get_type() const
Return the gtid type for this Gtid_log_event: this can be either ANONYMOUS_GTID, AUTOMATIC_GTID,...
Definition: log_event.h:4072
uint32 write_body_to_memory(uchar *buff)
Writes the body to the given memory buffer.
Definition: log_event.cc:13241
Gtid_log_event(const Gtid_log_event &)=delete
uint32 write_tagged_event_body_to_memory(uchar *buffer)
Writes the body to the given memory buffer.
Definition: log_event.cc:13214
int do_apply_event(Relay_log_info const *rli) override
Primitive to apply an event to the database.
Definition: log_event.cc:13315
uint32 write_post_header_to_memory(uchar *buffer)
Writes the post-header to the given memory buffer.
Definition: log_event.cc:13149
static const size_t SET_STRING_PREFIX_LENGTH
Length of SET_STRING_PREFIX.
Definition: log_event.h:4115
Tsid tsid
TSID for this GTID.
Definition: log_event.h:4128
const Tsid & get_tsid() const
Return the TSID for this GTID.
Definition: log_event.h:4078
bool write_data_body(Basic_ostream *ostream) override
Definition: log_event.cc:13306
void set_trx_length_by_cache_size(ulonglong cache_size, bool is_checksum_enabled=false, int event_counter=0)
Set the transaction length information based on binlog cache size.
Definition: log_event.cc:13500
static const size_t MAX_SET_STRING_LENGTH
The maximal length of the entire "SET ..." query.
Definition: log_event.h:4117
void update_parent_gtid_info()
Updates parent tsid and gtid info structure.
Definition: log_event.cc:12974
static const char * SET_STRING_PREFIX
string holding the text "SET @@GLOBAL.GTID_NEXT = '"
Definition: log_event.h:4111
void clear_gtid_and_spec()
Clears tsid and spec.
Definition: log_event.cc:12980
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:13064
Gtid_specification spec
Internal representation of the GTID.
Definition: log_event.h:4126
int pack_info(Protocol *) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:13045
size_t get_data_size() override
Definition: log_event.h:3985
size_t to_string(char *buf) const
Used internally by both print() and pack_info().
Definition: log_event.cc:13053
enum_skip_reason do_shall_skip(Relay_log_info *rli) override
Decide if this event shall be skipped or not and the reason for skipping it.
Definition: log_event.cc:13485
Represents a set of GTIDs.
Definition: rpl_gtid.h:1556
Definition: rpl_utility.h:109
Definition: log_event.h:3825
Heartbeat_log_event_v2(const char *buf, const mysql::binlog::event::Format_description_event *description_event)
Definition: log_event.cc:14387
Definition: log_event.h:3817
Heartbeat_log_event(const char *buf, const mysql::binlog::event::Format_description_event *description_event)
Definition: log_event.cc:14380
Base class for ignorable log events is Ignorable_event.
Definition: log_event.h:3684
int pack_info(Protocol *) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:12789
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:12782
size_t get_data_size() override
Definition: log_event.h:3717
Ignorable_log_event(Ignorable_log_event &&) noexcept=delete
~Ignorable_log_event() override
Ignorable_log_event(const Ignorable_log_event &)=delete
Class representing an incident, an occurrence out of the ordinary, that happened on the master.
Definition: log_event.h:3593
Incident_log_event(const Incident_log_event &)=delete
bool write_data_header(Basic_ostream *ostream) override
Definition: log_event.cc:12734
size_t get_data_size() override
Definition: log_event.h:3646
bool write_data_body(Basic_ostream *ostream) override
Definition: log_event.cc:12760
~Incident_log_event() override
Definition: log_event.cc:12648
int do_apply_event(Relay_log_info const *rli) override
Primitive to apply an event to the database.
Definition: log_event.cc:12694
int pack_info(Protocol *) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:12667
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:12661
const char * description() const
Definition: log_event.cc:12652
bool ends_group() const override
Definition: log_event.h:3651
Incident_log_event(Incident_log_event &&) noexcept=delete
The class derives from the class Intvar_event in Binlog API, defined in the header binlog_event....
Definition: log_event.h:1601
bool write(Basic_ostream *ostream) override
Definition: log_event.cc:5820
~Intvar_log_event() override=default
Intvar_log_event(Intvar_log_event &&) noexcept=delete
size_t get_data_size() override
Definition: log_event.h:1630
enum_skip_reason do_shall_skip(Relay_log_info *rli) override
Decide if this event shall be skipped or not and the reason for skipping it.
Definition: log_event.cc:5899
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:5830
Intvar_log_event(const Intvar_log_event &)=delete
int pack_info(Protocol *protocol) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:5795
bool is_sbr_logging_format() const override
Return true if the event has to be logged using SBR for DMLs.
Definition: log_event.h:1638
int do_apply_event(Relay_log_info const *rli) override
Primitive to apply an event to the database.
Definition: log_event.cc:5874
int do_update_pos(Relay_log_info *rli) override
Advance relay log coordinates.
Definition: log_event.cc:5894
Base class that is used to represent any kind of expression in a relational query.
Definition: item.h:936
Definition: key.h:113
Definition: sql_list.h:467
Definition: log_event.h:2345
bool has_replace
Definition: log_event.h:2365
const size_t BUF_SIZE
Definition: log_event.h:2354
const char * table_name
Definition: log_event.h:2361
const char * fname
Definition: log_event.h:2362
const sql_exchange * sql_ex
Definition: log_event.h:2359
THD * thd
Definition: log_event.h:2358
bool has_ignore
Definition: log_event.h:2366
String str
Definition: log_event.h:2355
const char * db
Definition: log_event.h:2360
bool is_concurrent
Definition: log_event.h:2364
const String * generate(size_t *fn_start, size_t *fn_end)
Definition: log_event.cc:7573
Load_query_generator(THD *thd_arg, const sql_exchange *ex, const char *db_arg, const char *table_name_arg, bool is_concurrent_arg, bool replace, bool ignore)
Definition: log_event.cc:7556
This is the abstract base class for binary log events.
Definition: log_event.h:538
bool write_header(Basic_ostream *ostream, size_t data_length)
Writes the common-header of this event to the given output stream and updates the checksum.
Definition: log_event.cc:1254
ulong mts_group_idx
Index in rli->gaq array to indicate a group that this event is purging.
Definition: log_event.h:693
bool is_mts_sequential_exec()
Is called from get_mts_execution_mode() to.
Definition: log_event.h:909
bool is_using_stmt_cache() const
Definition: log_event.h:839
enum_skip_reason continue_group(Relay_log_info *rli)
Helper function to ignore an event w.r.t.
Definition: log_event.cc:2442
bool is_no_filter_event() const
Definition: log_event.h:833
int apply_event(Relay_log_info *rli)
Apply the event to the database.
Definition: log_event.cc:3043
virtual int do_apply_event(Relay_log_info const *rli)
Primitive to apply an event to the database.
Definition: log_event.h:1162
virtual const char * get_db()
Definition: log_event.cc:1057
enum_event_cache_type event_cache_type
Defines the type of the cache, if any, where the event will be stored before being flushed to disk.
Definition: log_event.h:676
int net_send(Protocol *protocol, const char *log_name, my_off_t pos)
Only called by SHOW BINLOG EVENTS.
Definition: log_event.cc:1062
uint32 write_header_to_memory(uchar *buf)
Writes the common header of this event to the given memory buffer.
Definition: log_event.cc:1215
virtual mysql::binlog::event::Log_event_type get_type_code() const
Definition: log_event.h:797
virtual bool starts_group() const
Events of a certain type can start or end a group of events treated transactionally wrt binlog.
Definition: log_event.h:1094
uint32 server_id
Definition: log_event.h:664
enum_mts_event_exec_mode
Definition: log_event.h:929
@ EVENT_EXEC_PARALLEL
Definition: log_event.h:933
@ EVENT_EXEC_SYNC
Definition: log_event.h:941
@ EVENT_EXEC_CAN_NOT
Definition: log_event.h:945
@ EVENT_EXEC_ASYNC
Definition: log_event.h:937
enum_skip_reason shall_skip(Relay_log_info *rli)
Decide if the event shall be skipped, and the reason for skipping it.
Definition: log_event.h:1137
bool is_valid()
Definition: log_event.cc:1307
virtual uint8 get_mts_dbs(Mts_db_names *arg, Rpl_filter *rpl_filter)
The method fills in pointers to event's database name c-strings to a supplied array.
Definition: log_event.h:1056
ha_checksum crc
Placeholder for event checksum while writing to binlog.
Definition: log_event.h:686
virtual size_t get_data_size()
Definition: log_event.h:879
bool wrapper_my_b_safe_write(Basic_ostream *ostream, const uchar *buf, size_t data_length)
Write the given buffer to the given output stream, updating the checksum if checksums are enabled.
Definition: log_event.cc:1193
enum_event_cache_type
Definition: log_event.h:567
@ EVENT_CACHE_COUNT
Definition: log_event.h:589
@ EVENT_INVALID_CACHE
Definition: log_event.h:568
@ EVENT_NO_CACHE
Definition: log_event.h:585
@ EVENT_STMT_CACHE
Definition: log_event.h:574
@ EVENT_TRANSACTIONAL_CACHE
Definition: log_event.h:580
enum_skip_reason
Enumeration of what kinds of skipping (and non-skipping) that can occur when the slave executes an ev...
Definition: log_event.h:547
@ EVENT_SKIP_IGNORE
Skip event by ignoring it.
Definition: log_event.h:558
@ EVENT_SKIP_COUNT
Skip event and decrease skip counter.
Definition: log_event.h:563
@ EVENT_SKIP_NOT
Don't skip event.
Definition: log_event.h:551
bool m_free_temp_buf_in_destructor
Definition: log_event.h:655
bool contains_partition_info(bool)
Definition: log_event.cc:2462
bool is_relay_log_event() const
Definition: log_event.h:827
bool is_ignorable_event() const
Definition: log_event.h:830
ulonglong future_event_relay_log_pos
A copy of the main rli value stored into event to pass to MTS worker rli.
Definition: log_event.h:716
int update_pos(Relay_log_info *rli)
Update the relay log position.
Definition: log_event.h:1129
virtual int do_apply_event_worker(Slave_worker *w)
Definition: log_event.cc:981
void set_artificial_event()
Definition: log_event.h:815
const char * get_type_str() const
Returns the human readable name of this event's type.
Definition: log_event.cc:897
time_t get_time()
Prints a "session_var=value" string.
Definition: log_event.cc:874
bool write_footer(Basic_ostream *ostream)
Definition: log_event.cc:1202
Relay_log_info * worker
MTS: associating the event with either an assigned Worker or Coordinator.
Definition: log_event.h:711
bool is_using_trans_cache() const
Definition: log_event.h:836
enum enum_mts_event_exec_mode get_mts_execution_mode(bool mts_in_group)
MTS Coordinator finds out a way how to execute the current event.
Definition: log_event.h:963
virtual enum_skip_reason do_shall_skip(Relay_log_info *rli)
Decide if this event shall be skipped or not and the reason for skipping it.
Definition: log_event.cc:1003
db_worker_hash_entry * mts_assigned_partitions[MAX_DBS_IN_EVENT_MTS]
Partition info associate with event to deliver to MTS event applier.
Definition: log_event.h:723
virtual bool write(Basic_ostream *ostream)
Definition: log_event.h:785
ulong rbr_exec_mode
A storage to cache the global system variable's value.
Definition: log_event.h:670
mysql::binlog::event::Log_event_header * common_header
The Log_event_header class contains the variable present in the common header.
Definition: log_event.h:699
virtual void set_mts_isolate_group()
Definition: log_event.h:1035
THD * thd
Definition: log_event.h:719
int apply_gtid_event(Relay_log_info *rli)
Apply the GTID event in curr_group_data to the database.
Definition: log_event.cc:2999
mysql::binlog::event::Log_event_footer * common_footer
The Log_event_footer class contains the variable present in the common footer.
Definition: log_event.h:705
virtual bool write_data_body(Basic_ostream *)
Definition: log_event.h:794
Log_event(mysql::binlog::event::Log_event_header *header, mysql::binlog::event::Log_event_footer *footer, enum_event_cache_type cache_type_arg, enum_event_logging_type logging_type_arg)
This minimal constructor is for when you are not even sure that there is a valid THD.
Definition: log_event.cc:933
void register_temp_buf(char *buf, bool free_in_destructor=true)
Definition: log_event.h:865
virtual uint8 mts_number_dbs()
Definition: log_event.h:1073
void free_temp_buf()
Definition: log_event.h:869
bool is_mts_group_isolated()
Definition: log_event.h:1080
ulong exec_time
Definition: log_event.h:658
virtual bool is_rbr_logging_format() const
Return true if the event has to be logged using RBR for DMLs.
Definition: log_event.h:808
virtual ~Log_event()
Definition: log_event.h:864
enum_event_logging_type event_logging_type
Defines when information, i.e.
Definition: log_event.h:682
enum_event_logging_type
Definition: log_event.h:592
@ EVENT_NORMAL_LOGGING
Definition: log_event.h:598
@ EVENT_IMMEDIATE_LOGGING
Definition: log_event.h:603
@ EVENT_INVALID_LOGGING
Definition: log_event.h:593
@ EVENT_CACHE_LOGGING_COUNT
Definition: log_event.h:607
char * temp_buf
Definition: log_event.h:648
virtual bool is_sbr_logging_format() const
Return true if the event has to be logged using SBR for DMLs.
Definition: log_event.h:804
virtual int pack_info(Protocol *protocol)
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:1052
bool is_using_immediate_logging() const
Definition: log_event.h:842
void set_relay_log_event()
Definition: log_event.h:823
virtual bool write_data_header(Basic_ostream *)
Definition: log_event.h:793
static void init_show_field_list(mem_root_deque< Item * > *field_list)
init_show_field_list() prepares the column names and types for the output of SHOW BINLOG EVENTS; it i...
Definition: log_event.cc:1085
bool is_artificial_event() const
Definition: log_event.h:824
virtual int do_update_pos(Relay_log_info *rli)
Advance relay log coordinates.
Definition: log_event.cc:995
virtual bool ends_group() const
Definition: log_event.h:1099
bool need_checksum()
A decider of whether to trigger checksum computation or not.
Definition: log_event.cc:1114
virtual void claim_memory_ownership(bool claim)
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.h:862
Slave_worker * get_slave_worker(Relay_log_info *rli)
The method maps the event to a Worker and return a pointer to it.
Definition: log_event.cc:2590
This is the subclass of Previous_gtids_event and Log_event It is used to record the gtid_executed in ...
Definition: log_event.h:4187
bool write_data_body(Basic_ostream *ostream) override
Definition: log_event.cc:13623
Previous_gtids_log_event(Previous_gtids_log_event &&) noexcept=delete
int do_update_pos(Relay_log_info *rli) override
Advance relay log coordinates.
Definition: log_event.cc:13630
char * get_str(size_t *length, const Gtid_set::String_format *string_format) const
Return the formatted string, or NULL on error.
Definition: log_event.cc:13604
int pack_info(Protocol *) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:13567
int do_apply_event(Relay_log_info const *) override
Primitive to apply an event to the database.
Definition: log_event.h:4279
int add_to_set(Gtid_set *gtid_set) const
Add all GTIDs from this event to the given Gtid_set.
Definition: log_event.cc:13593
size_t get_data_size() override
Definition: log_event.h:4210
enum_skip_reason do_shall_skip(Relay_log_info *) override
Decide if this event shall be skipped or not and the reason for skipping it.
Definition: log_event.h:4274
bool write(Basic_ostream *ostream) override
Definition: log_event.h:4218
~Previous_gtids_log_event() override=default
const uchar * get_buf()
Return the encoded buffer, or NULL on error.
Definition: log_event.h:4255
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:13541
Definition: protocol.h:33
A Query event is written to the binary log whenever the database is modified on the master,...
Definition: log_event.h:1285
int do_update_pos(Relay_log_info *rli) override
Advance relay log coordinates.
Definition: log_event.cc:5096
bool need_sql_require_primary_key
Whether or not the statement represented by this event requires Q_SQL_REQUIRE_PRIMARY_KEY to be logge...
Definition: log_event.h:1491
bool is_sbr_logging_format() const override
When a query log event contains a non-transaction control statement, we assume that it is changing da...
Definition: log_event.h:1461
Query_log_event(const Query_log_event &)=delete
bool is_trans_keyword() const
Definition: log_event.h:1429
mysql::binlog::event::Log_event_header::Byte * data_buf
Definition: log_event.h:1287
bool m_skip_temp_tables_handling_by_worker
Instructs the applier to skip temporary tables handling.
Definition: log_event.h:1329
static size_t get_query(const char *buf, size_t length, const mysql::binlog::event::Format_description_event *fd_event, const char **query_arg)
Return the query string pointer (and its size) from a Query log event using only the event buffer (we...
Definition: log_event.cc:5146
Query_log_event()
The simplest constructor that could possibly work.
Definition: log_event.cc:3630
enum_skip_reason do_shall_skip(Relay_log_info *rli) override
Decide if this event shall be skipped or not and the reason for skipping it.
Definition: log_event.cc:5110
virtual ulong get_post_header_size_for_derived()
Definition: log_event.h:1413
bool starts_group() const override
Notice, DDL queries are logged without BEGIN/COMMIT parentheses and identification of such single-que...
Definition: log_event.h:1469
uchar mts_number_dbs() override
Definition: log_event.h:1380
my_thread_id slave_proxy_id
Definition: log_event.h:1302
void set_skip_temp_tables_handling_by_worker()
Definition: log_event.h:1331
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:5199
bool has_ddl_committed
The flag indicates whether the DDL query has been (already) committed or not.
Definition: log_event.h:1322
int do_apply_event(Relay_log_info const *rli) override
Primitive to apply an event to the database.
Definition: log_event.cc:4376
~Query_log_event() override
Definition: log_event.h:1398
void attach_temp_tables_worker(THD *, const Relay_log_info *)
Associating slave Worker thread to a subset of temporary tables.
Definition: log_event.cc:4353
bool write(Basic_ostream *ostream) override
Query_log_event::write().
Definition: log_event.cc:3337
bool rollback_injected_by_coord
True if this is a ROLLBACK event injected by the mts coordinator to finish a group corresponding to a...
Definition: log_event.h:1310
bool is_query_prefix_match(const char *pattern, uint p_len)
Definition: log_event.h:1485
uint8 get_mts_dbs(Mts_db_names *arg, Rpl_filter *rpl_filter) override
Definition: log_event.h:1355
bool needs_default_table_encryption
Whether or not the statement represented by this event requires Q_DEFAULT_TABLE_ENCRYPTION to be logg...
Definition: log_event.h:1495
const char * get_db() override
Definition: log_event.h:1342
int pack_info(Protocol *protocol) override
This (which is used only for SHOW BINLOG EVENTS) could be updated to print SET @session_var=.
Definition: log_event.cc:3286
bool ends_group() const override
Definition: log_event.h:1474
bool is_skip_temp_tables_handling_by_worker()
Definition: log_event.h:1335
virtual bool write_post_header_for_derived(Basic_ostream *)
Definition: log_event.h:1406
void detach_temp_tables_worker(THD *, const Relay_log_info *)
Dissociating slave Worker thread from its thd->temporary_tables to possibly update the involved entri...
Definition: log_event.cc:4367
Logs random seed used by the next RAND(), and by PASSWORD() in 4.1.0.
Definition: log_event.h:1674
bool write(Basic_ostream *ostream) override
Definition: log_event.cc:5940
bool is_sbr_logging_format() const override
Return true if the event has to be logged using SBR for DMLs.
Definition: log_event.h:1708
~Rand_log_event() override=default
size_t get_data_size() override
Definition: log_event.h:1703
Rand_log_event(const Rand_log_event &)=delete
Rand_log_event(Rand_log_event &&) noexcept=delete
enum_skip_reason do_shall_skip(Relay_log_info *rli) override
Decide if this event shall be skipped or not and the reason for skipping it.
Definition: log_event.cc:5985
int do_apply_event(Relay_log_info const *rli) override
Primitive to apply an event to the database.
Definition: log_event.cc:5966
int pack_info(Protocol *protocol) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:5916
int do_update_pos(Relay_log_info *rli) override
Advance relay log coordinates.
Definition: log_event.cc:5980
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:5934
Definition: rpl_rli.h:203
This will be deprecated when we move to using sequence ids.
Definition: log_event.h:2027
int do_update_pos(Relay_log_info *rli) override
Advance relay log coordinates.
Definition: log_event.cc:5628
int pack_info(Protocol *protocol) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:5516
enum_skip_reason do_shall_skip(Relay_log_info *rli) override
Decide if this event shall be skipped or not and the reason for skipping it.
Definition: log_event.cc:5771
~Rotate_log_event() override=default
Rotate_log_event(Rotate_log_event &&) noexcept=delete
Rotate_log_event(const Rotate_log_event &)=delete
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:5589
bool write(Basic_ostream *ostream) override
Definition: log_event.cc:5599
size_t get_data_size() override
Definition: log_event.h:2047
Definition: log_event.h:2647
bool is_enabled()
If instrumentation is enabled this member function SHALL return true.
Definition: log_event.h:2674
Rows_applier_psi_stage & operator=(const Rows_applier_psi_stage &rhs)
void inc_n_rows_applied(ulonglong delta)
Updates the counter of processed rows.
Definition: log_event.h:2720
ulonglong m_n_rows_applied
Counter that is unconditionally incremented on each row that is processed.
Definition: log_event.h:2662
ulonglong get_n_rows_applied()
Gets the value of the counter of rows that have been processed.
Definition: log_event.h:2726
Rows_applier_psi_stage()
Definition: log_event.h:2665
void update_work_estimated_and_completed(const uchar *cursor, const uchar *begin, const uchar *end)
This member function shall update the progress and reestimate the remaining work needed.
Definition: log_event.h:2687
void set_progress(PSI_stage_progress *progress)
Definition: log_event.h:2667
void end_work()
Resets this object.
Definition: log_event.h:2711
PSI_stage_progress * m_progress
A cached pointer to this stage PSI_stage_progress.
Definition: log_event.h:2655
Definition: log_event.h:2946
KEY ** m_key_info
Definition: log_event.h:2966
Key_compare(KEY **ki=nullptr)
Definition: log_event.h:2959
bool operator()(uchar *k1, uchar *k2) const
Definition: log_event.h:2960
Common base class for all row-containing log events.
Definition: log_event.h:2764
MY_BITMAP write_set_backup
This bitmap is used as a backup for the write set while we calculate the values for any hidden genera...
Definition: log_event.h:3269
uint32 m_bitbuf[128/(sizeof(uint32) *8)]
Definition: log_event.h:2927
uchar * m_rows_end
Definition: log_event.h:2936
int close_record_scan()
Does the cleanup.
Definition: log_event.cc:8833
virtual mysql::binlog::event::Log_event_type get_general_type_code()=0
int handle_idempotent_and_ignored_errors(Relay_log_info const *rli, int *err)
Private member function called while handling idempotent errors.
Definition: log_event.cc:8778
bool write_data_header(Basic_ostream *ostream) override
Definition: log_event.cc:10362
virtual int do_before_row_operations(const Relay_log_info *const log)=0
uchar * m_rows_buf
Definition: log_event.h:2934
uint m_rows_lookup_algorithm
The algorithm to use while searching for rows using the before image.
Definition: log_event.h:2908
TABLE * m_table
Definition: log_event.h:2887
ColumnViewPtr m_column_view
Wrapper around TABLE *m_table that abstracts the table field set iteration logic, since it is not man...
Definition: log_event.h:3069
bool is_rbr_logging_format() const override
Return true if the event has to be logged using RBR for DMLs.
Definition: log_event.h:3056
int do_hash_row(Relay_log_info const *rli)
Populates the m_hash when using HASH_SCAN.
Definition: log_event.cc:9215
Hash_slave_rows m_hash
Hash table that will hold the entries for while using HASH_SCAN algorithm to search and update/delete...
Definition: log_event.h:2902
uchar * m_distinct_key_spare_buf
A spare buffer which will be used when saving the distinct keys for doing an index scan with HASH_SCA...
Definition: log_event.h:2974
int do_hash_scan_and_update(Relay_log_info const *rli)
Implementation of the hash_scan and update algorithm.
Definition: log_event.cc:9458
int add_row_data(uchar *data, size_t length)
Definition: log_event.h:2825
void decide_row_lookup_algorithm_and_key() SUPPRESS_UBSAN_CLANG10
Definition: log_event.cc:8387
uint m_key_index
Definition: log_event.h:2944
int do_apply_row(Relay_log_info const *rli)
Commodity wrapper around do_exec_row(), that deals with resetting the thd reference in the table.
Definition: log_event.cc:8808
int row_operations_scan_and_key_setup()
Definition: log_event.cc:8484
MY_BITMAP const * get_cols_ai() const
Definition: log_event.h:2834
enum_skip_reason do_shall_skip(Relay_log_info *rli) override
Decide if this event shall be skipped or not and the reason for skipping it.
Definition: log_event.cc:10224
Rows_log_event(const Rows_log_event &)=delete
MY_BITMAP m_local_cols_ai
Bitmap denoting columns available in the after-image as they appear in the table setup.
Definition: log_event.h:2924
uchar * m_key
Definition: log_event.h:2943
int do_index_scan_and_update(Relay_log_info const *rli)
Implementation of the index scan and update algorithm.
Definition: log_event.cc:8984
int do_scan_and_update(Relay_log_info const *rli)
This member function scans the table and applies the changes that had been previously hashed.
Definition: log_event.cc:9283
virtual int do_add_row_data(uchar *data, size_t length)
Definition: log_event.cc:8120
@ RLE_NO_FLAGS
Definition: log_event.h:2800
Rows_applier_psi_stage m_psi_progress
Definition: log_event.h:2767
static bool is_trx_retryable_upon_engine_error(int error)
Helper function to check whether the storage engine error allows for the transaction to be retried or...
Definition: log_event.cc:8575
size_t get_data_size() override
Definition: log_event.cc:8087
const char * get_db() override
Definition: log_event.h:2858
uint16 flag_set
Definition: log_event.h:2777
row_lookup_mode
Definition: log_event.h:2779
@ ROW_LOOKUP_INDEX_SCAN
Definition: log_event.h:2782
@ ROW_LOOKUP_UNDEFINED
Definition: log_event.h:2780
@ ROW_LOOKUP_NOT_NEEDED
Definition: log_event.h:2781
@ ROW_LOOKUP_TABLE_SCAN
Definition: log_event.h:2783
@ ROW_LOOKUP_HASH_SCAN
Definition: log_event.h:2784
virtual bool read_write_bitmaps_cmp(const TABLE *table) const =0
Compares the table's read/write_set with the columns included in this event's before-image and/or aft...
virtual int skip_after_image_for_update_event(const Relay_log_info *rli, const uchar *curr_bi_start)
Seek past the after-image of an update event, in case a row was processed without reading the after-i...
Definition: log_event.h:3194
bool is_auto_inc_in_extra_columns(const Relay_log_info *const rli)
Helper function to check whether there is an auto increment column on the table where the event is to...
Definition: log_event.cc:8557
uchar * m_rows_cur
Definition: log_event.h:2935
const mysql::binlog::event::Table_id & get_table_id() const
Definition: log_event.h:2835
uint m_row_count
Definition: log_event.h:2861
int do_apply_event(Relay_log_info const *rli) override
Primitive to apply an event to the database.
Definition: log_event.cc:9562
int next_record_scan(bool first_read)
Fetches next row.
Definition: log_event.cc:8846
int pack_info(Protocol *protocol) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:10468
int do_table_scan_and_update(Relay_log_info const *rli)
Implementation of the legacy table_scan and update algorithm.
Definition: log_event.cc:9479
MY_BITMAP m_local_cols
Bitmap denoting columns available in the image as they appear in the table setup.
Definition: log_event.h:2896
int open_record_scan()
Initializes scanning of rows.
Definition: log_event.cc:8908
void clear_flags(flag_set flags_arg)
Definition: log_event.h:2805
virtual int do_exec_row(const Relay_log_info *const rli)=0
std::set< uchar *, Key_compare >::iterator m_itr
Definition: log_event.h:2969
enum_error
Enumeration of the errors that can be returned.
Definition: log_event.h:2790
@ ERR_TABLE_LIMIT_EXCEEDED
No more room for tables.
Definition: log_event.h:2793
@ ERR_BAD_TABLE_DEF
Table definition does not match.
Definition: log_event.h:2795
@ ERR_OPEN_FAILURE
Failure to open table.
Definition: log_event.h:2791
@ ERR_RBR_TO_SBR
daisy-chanining RBR to SBR not allowed
Definition: log_event.h:2796
@ ERR_OUT_OF_MEM
Out of memory.
Definition: log_event.h:2794
@ ERR_OK
No error.
Definition: log_event.h:2792
int row_operations_scan_and_key_teardown(int error)
Definition: log_event.cc:8527
int update_generated_columns(MY_BITMAP const &fields_to_update)
Updates the generated columns of the TABLE object referenced by m_table, that have an active bit in t...
Definition: log_event.cc:8064
virtual int do_after_row_operations(const Relay_log_info *const log, int error)=0
MY_BITMAP const * get_cols() const
Definition: log_event.h:2833
std::set< uchar *, Key_compare > m_distinct_keys
Definition: log_event.h:2968
void do_post_row_operations(Relay_log_info const *rli, int err)
Private member function called after updating/deleting a row.
Definition: log_event.cc:8690
Rows_log_event(Rows_log_event &&) noexcept=delete
const uchar * m_curr_row
Definition: log_event.h:2941
MY_BITMAP m_cols_ai
Bitmap for columns available in the after image, if present.
Definition: log_event.h:2917
int add_key_to_distinct_keyset()
Populates the m_distinct_keys with unique keys to be modified during HASH_SCAN over keys.
Definition: log_event.cc:8964
KEY * m_key_info
Definition: log_event.h:2945
int unpack_current_row(const Relay_log_info *const rli, MY_BITMAP const *cols, bool is_after_image, bool only_seek=false)
Unpack the current row image from the event into m_table->record[0].
Definition: log_event.cc:7971
int do_update_pos(Relay_log_info *rli) override
The method either increments the relay log position or commits the current statement and increments t...
Definition: log_event.cc:10330
~Rows_log_event() override
Definition: log_event.cc:7951
void set_flags(flag_set flags_arg)
Definition: log_event.h:2804
friend class Old_rows_log_event
Definition: log_event.h:3261
const uchar * m_curr_row_end
Definition: log_event.h:2942
bool write_data_body(Basic_ostream *ostream) override
Definition: log_event.cc:10435
uint32 m_bitbuf_ai[128/(sizeof(uint32) *8)]
Definition: log_event.h:2928
MY_BITMAP m_cols
Definition: log_event.h:2889
It is used to record the original query for the rows events in RBR.
Definition: log_event.h:3756
size_t get_data_size() override
Definition: log_event.h:3792
~Rows_query_log_event() override
Definition: log_event.h:3785
int do_apply_event(Relay_log_info const *rli) override
Primitive to apply an event to the database.
Definition: log_event.cc:12878
bool write_data_body(Basic_ostream *ostream) override
Definition: log_event.cc:12868
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:12819
int pack_info(Protocol *) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:12826
Rows_query_log_event(THD *thd_arg, const char *query, size_t query_len)
Definition: log_event.h:3759
Rpl_filter.
Definition: rpl_filter.h:214
const char * get_rewrite_db(const char *db, size_t *new_len)
Definition: rpl_filter.cc:1176
bool is_rewrite_empty()
Definition: rpl_filter.cc:571
Mix-in to handle the message logging and reporting for relay log info and master log info structures.
Definition: rpl_reporting.h:54
Definition: rpl_rli_pdb.h:498
Definition: log_event.h:1951
mysql::binlog::event::Log_event_type get_type_code() const override
Definition: log_event.h:1980
Stop_log_event()
Definition: log_event.h:1960
~Stop_log_event() override=default
Stop_log_event(const Stop_log_event &)=delete
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:6930
enum_skip_reason do_shall_skip(Relay_log_info *) override
Decide if this event shall be skipped or not and the reason for skipping it.
Definition: log_event.h:1989
int do_update_pos(Relay_log_info *rli) override
Advance relay log coordinates.
Definition: log_event.cc:6950
String class wrapper with a preallocated buffer of size buff_sz.
Definition: sql_string.h:681
Using this class is fraught with peril, and you need to be very careful when doing so.
Definition: sql_string.h:167
For each client connection we create a separate thread with THD serving as a thread/connection descri...
Definition: sql_lexer_thd.h:36
Table_map_log_event which maps a table definition to a number.
Definition: log_event.h:2429
@ TM_GENERATED_INVISIBLE_PK_F
Table has generated invisible primary key.
Definition: log_event.h:2472
@ TM_BIT_LEN_EXACT_F
Definition: log_event.h:2465
@ TM_NO_FLAGS
Definition: log_event.h:2464
@ TM_REFERRED_FK_DB_F
Definition: log_event.h:2466
Table_map_log_event(Table_map_log_event &&) noexcept=delete
enum_skip_reason do_shall_skip(Relay_log_info *rli) override
Decide if this event shall be skipped or not and the reason for skipping it.
Definition: log_event.cc:10986
int do_apply_event(Relay_log_info const *rli) override
Primitive to apply an event to the database.
Definition: log_event.cc:10859
@ TYPE_CODE
Definition: log_event.h:2438
Table_map_log_event(const Table_map_log_event &)=delete
uint8 mts_number_dbs() override
Definition: log_event.h:2512
int do_update_pos(Relay_log_info *rli) override
Advance relay log coordinates.
Definition: log_event.cc:10995
const char * get_db_name() const
Definition: log_event.h:2504
virtual int save_field_metadata()
Save the field metadata based on the real_type of the field.
Definition: log_event.cc:10556
bool init_set_str_value_field()
Definition: log_event.cc:11302
flag_set get_flags(flag_set flag) const
Definition: log_event.h:2475
~Table_map_log_event() override
bool init_geometry_type_field()
Definition: log_event.cc:11350
bool init_charset_field(std::function< bool(const Field *)> include_type, Optional_metadata_field_type default_charset_type, Optional_metadata_field_type column_charset_type)
Capture and serialize character sets.
Definition: log_event.cc:11196
bool init_primary_key_field()
Definition: log_event.cc:11367
enum_flag
Definition: log_event.h:2452
@ ENUM_FLAG_COUNT
Nothing here right now, but the flags support is there in preparation for changes that are coming.
Definition: log_event.h:2459
bool is_rbr_logging_format() const override
Return true if the event has to be logged using RBR for DMLs.
Definition: log_event.h:2574
const mysql::binlog::event::Table_id & get_table_id() const
Definition: log_event.h:2500
bool init_column_visibility_field()
Definition: log_event.cc:11415
const char * get_table_name() const
Definition: log_event.h:2503
uint8 get_mts_dbs(Mts_db_names *arg, Rpl_filter *rpl_filter) override
Definition: log_event.h:2524
bool write_data_header(Basic_ostream *ostream) override
Definition: log_event.cc:11000
bool write_data_body(Basic_ostream *ostream) override
Definition: log_event.cc:11014
bool init_enum_str_value_field()
Definition: log_event.cc:11329
bool init_column_name_field()
Definition: log_event.cc:11290
ColumnViewPtr m_column_view
Wrapper around TABLE *m_table that abstracts the table field set iteration logic, since it is not man...
Definition: log_event.h:2598
const char * get_db() override
Definition: log_event.h:2511
size_t get_data_size() override
Definition: log_event.h:2506
int pack_info(Protocol *protocol) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:11447
TABLE * m_table
Definition: log_event.h:2584
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:10740
void init_metadata_fields()
Capture the optional metadata fields which should be logged into table_map_log_event and serialize th...
Definition: log_event.cc:11142
enum_error
Enumeration of the errors that can be returned.
Definition: log_event.h:2443
@ ERR_OK
No error.
Definition: log_event.h:2445
@ ERR_TABLE_LIMIT_EXCEEDED
No more room for tables.
Definition: log_event.h:2446
@ ERR_OPEN_FAILURE
Failure to open table.
Definition: log_event.h:2444
@ ERR_OUT_OF_MEM
Out of memory.
Definition: log_event.h:2447
@ ERR_BAD_TABLE_DEF
Table definition does not match.
Definition: log_event.h:2448
@ ERR_RBR_TO_SBR
daisy-chanining RBR to SBR not allowed
Definition: log_event.h:2449
bool has_generated_invisible_primary_key() const
Definition: log_event.cc:10736
StringBuffer< 1024 > m_metadata_buf
Definition: log_event.h:2587
bool init_signedness_field()
Definition: log_event.cc:11165
This is the subclass of Transaction_context_event and Log_event This class encodes the transaction_co...
Definition: log_event.h:4309
static int get_data_set_size(std::list< const char * > *set)
Definition: log_event.cc:13865
void add_write_set(const char *hash)
Add a hash which identifies a inserted/updated/deleted row on the ongoing transaction.
Definition: log_event.cc:13877
my_thread_id get_thread_id() const
Return the id of the committing thread.
Definition: log_event.h:4413
Transaction_context_log_event(const char *server_uuid_arg, bool using_trans, my_thread_id thread_id_arg, bool is_gtid_specified)
Definition: log_event.cc:13639
void add_read_set(const char *hash)
Add a hash which identifies a read row on the ongoing transaction.
Definition: log_event.cc:13882
int do_update_pos(Relay_log_info *rli) override
Advance relay log coordinates.
Definition: log_event.cc:13757
Gtid_set * get_snapshot_version()
Return the transaction snapshot timestamp.
Definition: log_event.h:4403
size_t get_data_size() override
Definition: log_event.cc:13764
int do_apply_event(Relay_log_info const *) override
Primitive to apply an event to the database.
Definition: log_event.h:4363
int pack_info(Protocol *protocol) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:13732
bool read_snapshot_version()
Read snapshot version from encoded buffers.
Definition: log_event.cc:13845
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:13724
Gtid_set * snapshot_version
A gtid_set which is used to store the transaction set used for conflict detection.
Definition: log_event.h:4315
size_t get_event_length()
Definition: log_event.cc:13776
Tsid_map * tsid_map
The Tsid_map to use for creating the Gtid_set.
Definition: log_event.h:4312
std::list< const char * > * get_read_set()
Return a pointer to read-set list.
Definition: log_event.h:4390
size_t get_snapshot_version_size()
Definition: log_event.cc:13859
bool write_data_header(Basic_ostream *ostream) override
Definition: log_event.cc:13781
bool is_gtid_specified() const
Return true if transaction has GTID fully specified, false otherwise.
Definition: log_event.h:4420
~Transaction_context_log_event() override
Definition: log_event.cc:13707
bool write_data_set(Basic_ostream *ostream, std::list< const char * > *set)
Definition: log_event.cc:13825
std::list< const char * > * get_write_set()
Return a pointer to write-set list.
Definition: log_event.h:4378
bool write_data_body(Basic_ostream *ostream) override
Definition: log_event.cc:13797
size_t to_string(char *buf, ulong len) const
Definition: log_event.cc:13718
const char * get_server_uuid()
Return the server uuid.
Definition: log_event.h:4408
bool write_snapshot_version(Basic_ostream *ostream)
Definition: log_event.cc:13809
Mts_db_names & get_mts_db_names()
Definition: log_event.h:3859
Mts_db_names m_mts_db_names
Definition: log_event.h:3853
void reset()
Definition: log_event.h:3858
virtual ~Applier_context()
Definition: log_event.h:3857
Definition: log_event.h:3846
size_t get_event_length()
Definition: log_event.h:3894
void set_mts_dbs(Mts_db_names &arg)
Definition: log_event.cc:14130
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:14109
uint8 get_mts_dbs(Mts_db_names *arg, Rpl_filter *rpl_filter) override
The method fills in pointers to event's database name c-strings to a supplied array.
Definition: log_event.cc:14115
bool apply_payload_event(Relay_log_info const *rli, const uchar *event_buf)
Definition: log_event.cc:14201
enum_skip_reason do_shall_skip(Relay_log_info *rli) override
Decide if this event shall be skipped or not and the reason for skipping it.
Definition: log_event.cc:14287
bool ends_group() const override
Definition: log_event.cc:14334
bool write(Basic_ostream *ostream) override
Definition: log_event.cc:14292
~Transaction_payload_log_event() override=default
int pack_info(Protocol *protocol) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:14324
size_t get_data_size() override
Definition: log_event.cc:14101
Transaction_payload_log_event(THD *thd_arg, const char *payload, uint64_t payload_size, uint16_t compression_type, uint64_t uncompressed_size)
Definition: log_event.h:3862
Applier_context m_applier_ctx
Definition: log_event.h:3899
uint8 mts_number_dbs() override
Definition: log_event.cc:14146
int do_apply_event(Relay_log_info const *rli) override
Primitive to apply an event to the database.
Definition: log_event.cc:14150
Represents a bidirectional map between TSID and SIDNO.
Definition: rpl_gtid.h:749
rpl_sidno add_tsid(const Tsid &tsid)
Add the given TSID to this map if it does not already exist.
Definition: rpl_gtid_tsid_map.cc:61
Log row updates with a before image.
Definition: log_event.h:3398
int do_exec_row(const Relay_log_info *const) override
Definition: log_event.cc:12590
static mysql::binlog::event::Log_event_type get_update_rows_event_type(const THD *thd_arg)
Auxiliary function used in the (THD*, ...) constructor to determine the type code based on configurat...
Definition: log_event.cc:12477
static bool binlog_row_logging_function(THD *thd, TABLE *table, bool is_transactional, const uchar *before_record, const uchar *after_record)
Definition: log_event.cc:12505
bool read_write_bitmaps_cmp(const TABLE *table) const override
Compares the table's read/write_set with the columns included in this event's before-image and/or aft...
Definition: log_event.h:3431
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:12550
int do_after_row_operations(const Relay_log_info *const, int) override
Definition: log_event.cc:12583
@ TYPE_CODE
Definition: log_event.h:3402
Update_rows_log_event(THD *, TABLE *, const mysql::binlog::event::Table_id &table_id, MY_BITMAP const *cols_bi, MY_BITMAP const *cols_ai, bool is_transactional, const unsigned char *extra_row_ndb_info)
int do_before_row_operations(const Relay_log_info *const) override
Definition: log_event.cc:12557
mysql::binlog::event::Log_event_type get_general_type_code() override
Definition: log_event.h:3440
~Update_rows_log_event() override
Definition: log_event.cc:12528
int skip_after_image_for_update_event(const Relay_log_info *rli, const uchar *curr_bi_start) override
Seek past the after-image of an update event, in case a row was processed without reading the after-i...
Definition: log_event.cc:9157
void init(MY_BITMAP const *cols)
Definition: log_event.cc:12512
Every time a query uses the value of a user variable, a User_var_log_event is written before the Quer...
Definition: log_event.h:1882
~User_var_log_event() override=default
bool is_sbr_logging_format() const override
Return true if the event has to be logged using SBR for DMLs.
Definition: log_event.h:1936
bool is_deferred()
Definition: log_event.h:1925
int do_update_pos(Relay_log_info *rli) override
Advance relay log coordinates.
Definition: log_event.cc:6878
query_id_t query_id
Definition: log_event.h:1892
void set_deferred(query_id_t qid)
Definition: log_event.h:1930
int pack_info(Protocol *protocol) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:6499
int do_apply_event(Relay_log_info const *rli) override
Primitive to apply an event to the database.
Definition: log_event.cc:6768
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:6897
User_var_log_event(const User_var_log_event &)=delete
User_var_log_event(User_var_log_event &&) noexcept=delete
enum_skip_reason do_shall_skip(Relay_log_info *rli) override
Decide if this event shall be skipped or not and the reason for skipping it.
Definition: log_event.cc:6883
bool deferred
Definition: log_event.h:1891
bool write(Basic_ostream *ostream) override
Definition: log_event.cc:6597
This is the subclass of View_change_log_event and Log_event This class created the view_change_log_ev...
Definition: log_event.h:4449
std::map< std::string, std::string > * get_certification_info()
Returns the certification info.
Definition: log_event.h:4517
int do_update_pos(Relay_log_info *rli) override
Advance relay log coordinates.
Definition: log_event.cc:14022
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:13949
bool write_data_body(Basic_ostream *ostream) override
Definition: log_event.cc:14039
void set_seq_number(rpl_gno number)
Set the certification sequence number.
Definition: log_event.h:4526
char * get_view_id()
Returns the view id.
Definition: log_event.h:4499
size_t get_size_data_map(std::map< std::string, std::string > *map)
Definition: log_event.cc:13930
int pack_info(Protocol *protocol) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:13955
size_t get_data_size() override
Definition: log_event.cc:13921
bool write_data_header(Basic_ostream *ostream) override
Definition: log_event.cc:14028
int do_apply_event(Relay_log_info const *rli) override
Primitive to apply an event to the database.
Definition: log_event.cc:13981
rpl_gno get_seq_number()
Returns the certification sequence number.
Definition: log_event.h:4531
bool write_data_map(Basic_ostream *ostream, std::map< std::string, std::string > *map)
Definition: log_event.cc:14047
void set_certification_info(std::map< std::string, std::string > *info, size_t *event_size)
Sets the certification info in the event.
Definition: log_event.cc:14083
View_change_log_event(const View_change_log_event &)=delete
size_t to_string(char *buf, ulong len) const
Definition: log_event.cc:13944
Log row insertions and updates.
Definition: log_event.h:3309
int do_before_row_operations(const Relay_log_info *const) override
Definition: log_event.cc:11920
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:12367
mysql::binlog::event::Log_event_type get_general_type_code() override
Definition: log_event.h:3342
Write_rows_log_event(THD *, TABLE *, const mysql::binlog::event::Table_id &table_id, bool is_transactional, const unsigned char *extra_row_ndb_info)
Definition: log_event.cc:11890
bool read_write_bitmaps_cmp(const TABLE *table) const override
Compares the table's read/write_set with the columns included in this event's before-image and/or aft...
Definition: log_event.h:3331
int do_exec_row(const Relay_log_info *const) override
Definition: log_event.cc:12344
int write_row(const Relay_log_info *const, const bool)
Write the current row into event's table.
Definition: log_event.cc:12109
@ TYPE_CODE
Definition: log_event.h:3313
int do_after_row_operations(const Relay_log_info *const, int) override
Definition: log_event.cc:12028
static bool binlog_row_logging_function(THD *thd, TABLE *table, bool is_transactional, const uchar *before_record, const uchar *after_record)
Definition: log_event.cc:11900
Similar to Xid_log_event except that.
Definition: log_event.h:1821
static const int xid_bufs_size
Definition: log_event.h:1824
bool do_commit(THD *thd) override
Differs from Xid_log_event::do_commit in that it carries out XA prepare (not the commit).
Definition: log_event.cc:6455
XA_prepare_log_event(THD *thd_arg, XID *xid_arg, bool one_phase_arg=false)
Definition: log_event.h:1828
size_t get_data_size() override
Definition: log_event.h:1844
bool write(Basic_ostream *ostream) override
Definition: log_event.cc:6393
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:6421
int pack_info(Protocol *protocol) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:6379
mysql::binlog::event::Log_event_type get_type_code() const override
Definition: log_event.h:1841
Definition: log_event.h:1747
enum_skip_reason do_shall_skip(Relay_log_info *rli) override
Decide if this event shall be skipped or not and the reason for skipping it.
Definition: log_event.cc:6365
bool ends_group() const override
Definition: log_event.h:1760
Xid_apply_log_event(THD *thd_arg, mysql::binlog::event::Log_event_header *header_arg, mysql::binlog::event::Log_event_footer *footer_arg)
Definition: log_event.h:1750
virtual bool do_commit(THD *thd_arg)=0
int do_apply_event_worker(Slave_worker *rli) override
Worker commits Xid transaction and in case of its transactional info table marks the current group as...
Definition: log_event.cc:6120
~Xid_apply_log_event() override=default
int do_apply_event(Relay_log_info const *rli) override
Primitive to apply an event to the database.
Definition: log_event.cc:6193
This is the subclass of Xid_event defined in libbinlogevent, An XID event is generated for a commit o...
Definition: log_event.h:1770
~Xid_log_event() override=default
bool write(Basic_ostream *ostream) override
Definition: log_event.cc:6046
Xid_log_event(const Xid_log_event &)=delete
int pack_info(Protocol *protocol) override
Stores a string representation of this event in the Protocol.
Definition: log_event.cc:6023
size_t get_data_size() override
Definition: log_event.h:1796
bool do_commit(THD *thd_arg) override
The methods combines few commit actions to make it usable as in the single- so multi- threaded case.
Definition: log_event.cc:6079
void claim_memory_ownership(bool claim) override
Allow thread to CLAIM or DISCLAIM the ownership of this object depends on the parameter value passed.
Definition: log_event.cc:6040
Xid_log_event(Xid_log_event &&) noexcept=delete
A (partial) implementation of std::deque allocating its blocks on a MEM_ROOT.
Definition: mem_root_deque.h:111
This event is created to contain the file data.
Definition: load_data_events.h:274
const char * db
'db' is filled when the event is created in mysql_load() (the event needs to have a 'db' member to be...
Definition: load_data_events.h:311
unsigned int block_len
Definition: load_data_events.h:298
Event for the first block of file to be loaded, its only difference from Append_block event is that t...
Definition: load_data_events.h:358
@ APPEND_BLOCK_HEADER_LEN
Definition: binlog_event.h:882
@ IGNORABLE_HEADER_LEN
Definition: binlog_event.h:896
@ FORMAT_DESCRIPTION_HEADER_LEN
Definition: binlog_event.h:886
@ INCIDENT_HEADER_LEN
Definition: binlog_event.h:894
@ DELETE_FILE_HEADER_LEN
Definition: binlog_event.h:883
@ ROTATE_HEADER_LEN
Definition: binlog_event.h:880
const Log_event_header * header() const
Return a const pointer to the header of the log event.
Definition: binlog_event.h:959
Binary_log_event & operator=(const Binary_log_event &)=default
const Log_event_footer * footer() const
Return a const pointer to the footer of the log event.
Definition: binlog_event.h:967
DELETE_FILE_EVENT occurs when the LOAD DATA failed on the master.
Definition: load_data_events.h:202
const char * db
Definition: load_data_events.h:215
Log row deletions.
Definition: rows_event.h:1134
Event responsible for LOAD DATA execution, it similar to Query_event but before executing the query i...
Definition: load_data_events.h:119
For binlog version 4.
Definition: control_events.h:239
GTID stands for Global Transaction IDentifier It is composed of two parts:
Definition: control_events.h:1016
int get_server_version_length() const
We only store the immediate_server_version if both server versions are the same.
Definition: control_events.h:1236
int get_commit_timestamp_length() const
Definition: control_events.h:1226
int get_commit_group_ticket_length() const
Returns the length of the packed commit_group_ticket field.
Definition: control_events.cpp:620
bool is_tagged() const
Checks whether this Gtid log event contains a tag.
Definition: control_events.cpp:650
unsigned long long get_trx_length() const
Definition: control_events.h:1315
static const int POST_HEADER_LENGTH
Total length of post header.
Definition: control_events.h:1254
Replication event to ensure to replica that source is alive.
Definition: control_events.h:1669
Replication event to ensure to replica that source is alive.
Definition: control_events.h:1743
Base class for ignorable log events.
Definition: control_events.h:674
Class representing an incident, an occurrence out of the ordinary, that happened on the master.
Definition: control_events.h:440
char * message
Definition: control_events.h:491
Incident_event(enum_incident incident_arg)
This will create an Incident_event with an empty message and set the type_code as INCIDENT_EVENT in t...
Definition: control_events.h:461
size_t message_length
Definition: control_events.h:492
enum_incident
Enumeration of the incidents that can occur for the server.
Definition: control_events.h:445
@ INCIDENT_NONE
No incident.
Definition: control_events.h:447
@ INCIDENT_COUNT
Shall be last event of the enumeration.
Definition: control_events.h:451
An Intvar_event will be created just before a Query_event, if the query uses one of the variables LAS...
Definition: statement_events.h:921
Intvar_event(const char *buf, const Format_description_event *fde)
Constructor receives a packet from the MySQL master or the binary log and decodes it to create an Int...
Definition: statement_events.cpp:483
The Common-Header always has the same form and length within one version of MySQL.
Definition: binlog_event.h:685
unsigned long long log_pos
Definition: binlog_event.h:716
unsigned char Byte
The following type definition is to be used whenever data is placed and manipulated in a common buffe...
Definition: binlog_event.h:731
Log_event_type type_code
Event type extracted from the header.
Definition: binlog_event.h:701
void set_is_valid(bool is_valid)
Set if the event object shall be considered valid or not.
Definition: binlog_event.h:765
uint16_t flags
Definition: binlog_event.h:724
Definition: control_events.h:1380
size_t buf_size
Definition: control_events.h:1408
const unsigned char * buf
Definition: control_events.h:1409
A Query_event is created for each query that modifies the database, unless the query is logged row-ba...
Definition: statement_events.h:451
const char * db
Definition: statement_events.h:535
const char * query
Definition: statement_events.h:534
unsigned char mts_accessed_dbs
Definition: statement_events.h:640
char mts_accessed_db_names[MAX_DBS_IN_EVENT_MTS][NAME_LEN]
Definition: statement_events.h:641
size_t q_len
Definition: statement_events.h:587
Logs random seed used by the next RAND(), and by PASSWORD() in 4.1.0.
Definition: statement_events.h:1033
Rand_event(unsigned long long seed1_arg, unsigned long long seed2_arg)
Definition: statement_events.h:1043
When a binary log file exceeds a size limit, a ROTATE_EVENT is written at the end of the file that po...
Definition: control_events.h:116
unsigned int flags
Definition: control_events.h:120
size_t ident_len
Definition: control_events.h:119
Common base class for all row-containing binary log events.
Definition: rows_event.h:880
Table_id m_table_id
Actual event type.
Definition: rows_event.h:952
enum_flag get_flags() const
Definition: rows_event.h:1032
uint16_t m_flags
Definition: rows_event.h:953
Rows query event type, which is a subclass of the Ignorable_event, to record the original query for t...
Definition: rows_event.h:1170
char * m_rows_query
Definition: rows_event.h:1198
A stop event is written to the log files under these circumstances:
Definition: control_events.h:379
Stop_event()
It is the minimal constructor, and all it will do is set the type_code as STOP_EVENT in the header ob...
Definition: control_events.h:385
Each table share has a table id, it is mainly used for row based replication.
Definition: table_id.h:42
In row-based mode, every row operation event is preceded by a Table_map_event which maps a table defi...
Definition: rows_event.h:525
unsigned char * m_coltype
Definition: rows_event.h:684
std::string m_tblnam
Definition: rows_event.h:681
uint16_t flag_set
Definition: rows_event.h:534
unsigned char * m_null_bits
field metadata
Definition: rows_event.h:691
Optional_metadata_field_type
DEFAULT_CHARSET and COLUMN_CHARSET don't appear together, and ENUM_AND_SET_DEFAULT_CHARSET and ENUM_A...
Definition: rows_event.h:548
unsigned long m_colcnt
Definition: rows_event.h:683
unsigned char * m_field_metadata
Definition: rows_event.h:690
unsigned long m_field_metadata_size
The size of field metadata buffer set by calling save_field_metadata()
Definition: rows_event.h:689
size_t m_data_size
Definition: rows_event.h:676
std::string m_dbnam
event data size
Definition: rows_event.h:679
flag_set m_flags
Definition: rows_event.h:674
Table_id m_table_id
Event post header contents.
Definition: rows_event.h:673
This class is used to combine the information of the ongoing transaction including the write set and ...
Definition: control_events.h:1468
bool gtid_specified
Definition: control_events.h:1504
uint32_t thread_id
Definition: control_events.h:1503
std::list< const char * > read_set
Definition: control_events.h:1508
const char * server_uuid
Definition: control_events.h:1502
std::list< const char * > write_set
Definition: control_events.h:1507
Event that encloses all the events of a transaction.
Definition: control_events.h:735
Transaction_payload_event(const Transaction_payload_event &)=delete
An unknown event should never occur.
Definition: binlog_event.h:997
Log row updates with a before image.
Definition: rows_event.h:1115
Written every time a statement uses a user variable; precedes other events for the statement.
Definition: statement_events.h:804
const char * name
Definition: statement_events.h:853
User_var_event(const char *name_arg, unsigned int name_len_arg, char *val_arg, unsigned long val_len_arg, Value_type type_arg, unsigned int charset_number_arg, unsigned char flags_arg)
This constructor will initialize the instance variables and the type_code, it will be used only by th...
Definition: statement_events.h:820
This class is used to add view change markers in the binary log when a member of the group enters or ...
Definition: control_events.h:1568
long long int seq_number
Definition: control_events.h:1622
std::map< std::string, std::string > certification_info
Definition: control_events.h:1624
char view_id[ENCODED_VIEW_ID_MAX_LEN]
Definition: control_events.h:1620
Log row insertions.
Definition: rows_event.h:1097
An XA_prepare event is generated for a XA prepared transaction.
Definition: control_events.h:588
XA_prepare_event(void *xid_arg, bool oph_arg)
The minimal constructor of XA_prepare_event, it initializes the instance variable xid and set the typ...
Definition: control_events.h:617
void * xid
Definition: control_events.h:608
An XID event is generated for a commit of a transaction that modifies one or more tables of an XA-cap...
Definition: control_events.h:523
Xid_event(uint64_t xid_arg)
The minimal constructor of Xid_event, it initializes the instance variable xid and set the type_code ...
Definition: control_events.h:530
uint64_t xid
Definition: control_events.h:540
Represents Transaction Source Identifier which is composed of source UUID and transaction tag.
Definition: tsid.h:47
static std::size_t get_size(const T &arg)
Definition: serializer_impl.hpp:70
Definition: partition_info.h:209
Used to hold information about file and file structure in exchange via non-DB file (....
Definition: sql_exchange.h:79
A table definition from the master.
Definition: rpl_utility.h:248
Maps table id's (integers) to table pointers.
Definition: rpl_tblmap.h:51
static char buf[MAX_BUF]
Definition: conf_to_src.cc:73
Contains the classes representing events operating in the replication stream properties.
#define U
Definition: ctype-tis620.cc:74
uint64_t sql_mode_t
Definition: dd_event.h:39
#define MAX_DBS_IN_EVENT_MTS
The maximum number of updated databases that a status of Query-log-event can carry.
Definition: binlog_event.h:117
#define MAX_TIME_ZONE_NAME_LENGTH
Maximum length of time zone name that we support (Time zone name is char(64) in db).
Definition: binlog_event.h:130
#define OVER_MAX_DBS_IN_EVENT_MTS
When the actual number of databases exceeds MAX_DBS_IN_EVENT_MTS the value of OVER_MAX_DBS_IN_EVENT_M...
Definition: binlog_event.h:124
void close_cached_file(IO_CACHE *cache)
Definition: mf_cache.cc:87
bool my_b_inited(const IO_CACHE *info)
Definition: my_sys.h:495
#define MY_WME
Definition: my_sys.h:128
int my_b_copy_to_file(IO_CACHE *cache, FILE *file)
Definition: mf_iocache2.cc:72
bool reinit_io_cache(IO_CACHE *info, enum cache_type type, my_off_t seek_offset, bool use_async_io, bool clear_cache)
Definition: mf_iocache.cc:328
@ WRITE_CACHE
Definition: my_sys.h:290
std::pair< bool, mysql::binlog::event::Log_event_basic_info > extract_log_event_basic_info(Log_event *log_event)
Extract basic info about an event: type, query, is it ignorable.
Definition: log_event.cc:14447
size_t my_strmov_quoted_identifier(THD *thd, char *buffer, const char *identifier, size_t length)
Definition: log_event.cc:14407
bool is_atomic_ddl_event(Log_event const *evt)
The function checks the argument event properties to deduce whether it represents an atomic DDL.
Definition: log_event.h:4562
char * str_to_hex(char *to, const char *from, size_t len)
Transforms a string into "" or its expression in 0x... form.
Definition: log_event.cc:800
bool binary_event_serialize(EVENT *ev, Basic_ostream *ostream)
Serialize an binary event to the given output stream.
Definition: log_event.h:4598
bool net_field_length_checked(const uchar **packet, size_t *max_length, T *out)
Read an integer in net_field_length format, guarding against read out of bounds and advancing the pos...
Definition: log_event.cc:760
TYPELIB binlog_checksum_typelib
Definition: log_event.cc:220
bool is_atomic_ddl(THD *thd, bool using_trans)
The function lists all DDL instances that are supported for crash-recovery (WL9175).
Definition: log_event.cc:3703
int ignored_error_code(int err_code)
Ignore error code specified on command line.
Definition: log_event.cc:606
MYSQL_PLUGIN_IMPORT char server_version[SERVER_VERSION_LENGTH]
Definition: log_event.h:125
std::unique_ptr< cs::util::ReplicatedColumnsView > ColumnViewPtr
Definition: log_event.h:121
bool is_any_gtid_event(const Log_event *evt)
Definition: log_event.h:4534
size_t my_strmov_quoted_identifier_helper(int q, char *buffer, const char *identifier, size_t length)
Definition: log_event.cc:14420
bool is_session_control_event(Log_event *evt)
Check if the given event is a session control event, one of User_var_event, Intvar_event or Rand_even...
Definition: log_event.h:4548
PSI_memory_key key_memory_Rows_query_log_event_rows_query
Definition: log_event.cc:195
const int64 SEQ_MAX_TIMESTAMP
Maximum value of binlog logical timestamp.
Definition: log_event.h:355
MYSQL_PLUGIN_IMPORT ulong server_id
Definition: log_event.h:118
static bool copy_event_cache_to_file_and_reinit(IO_CACHE *cache, FILE *file, bool flush_stream)
Definition: log_event.h:3798
PSI_memory_key key_memory_Incident_log_event_message
Definition: log_event.cc:194
bool slave_execute_deferred_events(THD *thd)
The function is called by slave applier in case there are active table filtering rules to force gathe...
Definition: log_event.cc:6005
int append_query_string(const THD *thd, const CHARSET_INFO *csinfo, String const *from, String *to)
Append a version of the 'from' string suitable for use in a query to the 'to' string.
Definition: log_event.cc:818
int get_rpl_part_id(partition_info *part_info)
This method is used to extract the partition_id from a partitioned table.
Definition: log_event.cc:7726
#define LOG_EVENT_RELAY_LOG_F
Events with this flag set are created by slave IO thread and written to relay log.
Definition: log_event.h:283
#define LOG_EVENT_NO_FILTER_F
Events with this flag are not filtered (e.g.
Definition: log_event.h:303
#define LOG_EVENT_IGNORABLE_F
For an event, 'e', carrying a type code, that a slave, 's', does not recognize, 's' will check 'e' fo...
Definition: log_event.h:294
#define LOG_EVENT_ARTIFICIAL_F
Artificial events are created arbitrarily and not written to binary log.
Definition: log_event.h:275
#define LOG_EVENT_MTS_ISOLATE_F
MTS: group of events can be marked to force its execution in isolation from any other Workers.
Definition: log_event.h:314
unsigned int PSI_memory_key
Instrumented memory key.
Definition: psi_memory_bits.h:49
#define mysql_stage_set_work_completed(P1, P2)
Definition: mysql_stage.h:115
#define mysql_stage_get_work_estimated(P1)
Definition: mysql_stage.h:143
#define mysql_stage_set_work_estimated(P1, P2)
Definition: mysql_stage.h:140
static int flag
Definition: hp_test1.cc:40
int key_cmp2(KEY_PART_INFO *key_part, const uchar *key1, uint key1_length, const uchar *key2, uint key2_length)
Compare two given keys.
Definition: key.cc:505
#define free(A)
Definition: lexyy.cc:915
LOAD DATA INFILE is not written to the binary log like other statements.
static int native_strncasecmp(const char *s1, const char *s2, size_t n)
Definition: m_string.h:216
static bool bitmap_cmp(const MY_BITMAP *map1, const MY_BITMAP *map2)
Quite unlike other C comparison functions ending with 'cmp', e.g.
Definition: my_bitmap.h:108
Abstraction functions over zlib/intrinsics.
std::uint32_t ha_checksum
Definition: my_checksum.h:106
Header for compiler-dependent features.
#define SUPPRESS_UBSAN_CLANG10
Definition: my_compiler.h:129
#define DBUG_EXECUTE_IF(keyword, a1)
Definition: my_dbug.h:171
#define DBUG_PRINT(keyword, arglist)
Definition: my_dbug.h:181
#define DBUG_EVALUATE_IF(keyword, a1, a2)
Definition: my_dbug.h:179
#define DBUG_TRACE
Definition: my_dbug.h:146
Some integer typedefs for easier portability.
unsigned long long int ulonglong
Definition: my_inttypes.h:56
uint8_t uint8
Definition: my_inttypes.h:63
ulonglong my_off_t
Definition: my_inttypes.h:72
unsigned char uchar
Definition: my_inttypes.h:52
int64_t int64
Definition: my_inttypes.h:68
#define MYF(v)
Definition: my_inttypes.h:97
uint16_t uint16
Definition: my_inttypes.h:65
uint32_t uint32
Definition: my_inttypes.h:67
#define FN_REFLEN
Definition: my_io.h:83
void * my_malloc(PSI_memory_key key, size_t size, int flags)
Allocates size bytes of memory.
Definition: my_memory.cc:57
void my_free(void *ptr)
Frees the memory pointed by the ptr.
Definition: my_memory.cc:81
Defines various enable/disable and HAVE_ macros related to the performance schema instrumentation sys...
Functions related to handling of plugins and other dynamically loaded libraries.
#define MYSQL_PLUGIN_IMPORT
Definition: my_sharedlib.h:71
Common header for many mysys elements.
static my_thread_id thread_id
Definition: my_thr_init.cc:63
uint32 my_thread_id
Definition: my_thread_local.h:34
static char * query
Definition: myisam_ftdump.cc:47
Common definition between mysql server & client.
unsigned int net_length_size(unsigned long long num)
#define SERVER_VERSION_LENGTH
Definition: mysql_com.h:74
Instrumentation helpers for stages.
static void print_header(MYSQL_RES *result)
Definition: mysqladmin.cc:1280
bool short_form
static uint verbose
Definition: mysqlcheck.cc:66
static bool replace
Definition: mysqlimport.cc:70
static bool ignore
Definition: mysqlimport.cc:70
static const char * sql_mode
Definition: mysqlslap.cc:199
const char * delimiter
Definition: mysqlslap.cc:160
static PFS_engine_table_share_proxy table
Definition: pfs.cc:61
Definition: pfs.cc:38
Definition: buf0block_hint.cc:30
const std::string charset("charset")
const std::string FILE("FILE")
Definition: os0file.h:89
bool length(const dd::Spatial_reference_system *srs, const Geometry *g1, double *length, bool *null) noexcept
Computes the length of linestrings and multilinestrings.
Definition: length.cc:76
bool is_valid(const dd::Spatial_reference_system *srs, const Geometry *g, const char *func_name, bool *is_valid) noexcept
Decides if a geometry is valid.
Definition: is_valid.cc:95
static Value err()
Create a Value object that represents an error condition.
Definition: json_binary.cc:927
void print(trx_t *trx, dict_index_t *index, std::ostream &out, ref_t ref, bool fatal)
Print information about the given LOB.
Definition: lob0impl.cc:1331
The namespace contains classes representing events that can occur in a replication stream.
Definition: binlog_event.cpp:36
Log_event_type
Enumeration type for the different types of log events.
Definition: binlog_event.h:286
@ INCIDENT_EVENT
Something out of the ordinary happened on the master.
Definition: binlog_event.h:330
@ FORMAT_DESCRIPTION_EVENT
Definition: binlog_event.h:312
@ EXECUTE_LOAD_QUERY_EVENT
Definition: binlog_event.h:315
@ ROWS_QUERY_LOG_EVENT
Definition: binlog_event.h:345
@ WRITE_ROWS_EVENT
Version 2 of the Row events.
Definition: binlog_event.h:348
@ DELETE_ROWS_EVENT
Definition: binlog_event.h:350
@ XA_PREPARE_LOG_EVENT
Definition: binlog_event.h:362
@ QUERY_EVENT
Definition: binlog_event.h:300
@ UNKNOWN_EVENT
Every time you add a type, you have to.
Definition: binlog_event.h:294
@ PREVIOUS_GTIDS_LOG_EVENT
Definition: binlog_event.h:355
@ UPDATE_ROWS_EVENT
Definition: binlog_event.h:349
@ RAND_EVENT
Definition: binlog_event.h:310
@ TABLE_MAP_EVENT
Definition: binlog_event.h:317
@ STOP_EVENT
Definition: binlog_event.h:301
@ INTVAR_EVENT
Definition: binlog_event.h:303
@ USER_VAR_EVENT
Definition: binlog_event.h:311
@ ROTATE_EVENT
Definition: binlog_event.h:302
@ SLAVE_EVENT
Definition: binlog_event.h:305
const uint64_t INVALID_XID
The following constant represents the maximum of MYSQL_XID domain.
Definition: statement_events.h:49
enum_load_dup_handling
Elements of this enum describe how LOAD DATA handles duplicates.
Definition: load_data_events.h:64
constexpr auto tsid_max_length
Maximum TSID text length (without null character)
Definition: tsid.h:41
HARNESS_EXPORT std::string string_format(const char *format,...)
Definition: utilities.cc:64
Definition: instrumented_condition_variable.h:32
const char * begin(const char *const c)
Definition: base64.h:44
size_t size(const char *const c)
Definition: base64.h:46
mutable_buffer buffer(void *p, size_t n) noexcept
Definition: buffer.h:418
Cursor end()
A past-the-end Cursor.
Definition: rules_table_service.cc:192
const char * db_name
Definition: rules_table_service.cc:55
std::set< Key, Compare, ut::allocator< Key > > set
Specialization of set which uses ut_allocator.
Definition: ut0new.h:2883
std::map< Key, Value, Compare, ut::allocator< std::pair< const Key, Value > > > map
Specialization of map which uses ut_allocator.
Definition: ut0new.h:2893
Performance schema instrumentation interface.
required string type
Definition: replication_group_member_actions.proto:34
required string event
Definition: replication_group_member_actions.proto:32
Contains the classes representing events which are used for row based replication.
Rpl_filter * rpl_filter
mysql::gtid::gno_t rpl_gno
GNO, the second (numeric) component of a GTID, is an alias of mysql::gtid::gno_t.
Definition: rpl_gtid.h:112
const int MAX_GNO_TEXT_LENGTH
The length of MAX_GNO when printed in decimal.
Definition: rpl_gtid.h:286
enum_gtid_type
Enumeration of different types of values for Gtid_specification, i.e, the different internal states t...
Definition: rpl_gtid.h:3868
cs::index::rpl_sidno rpl_sidno
Type of SIDNO (source ID number, first component of GTID)
Definition: rpl_gtid.h:108
mysql::gtid::Tsid Tsid
Definition: rpl_gtid_state.cc:56
enum_row_image_type
Definition: rpl_record.h:40
ulonglong my_xid
Definition: handler.h:1235
File containing constants that can be used throughout the server.
Our own string classes, used pervasively throughout the executor.
Contains the classes representing statement events occurring in the replication stream.
#define STRING_WITH_LEN(X)
Definition: string_with_len.h:29
char * strmake(char *dst, const char *src, size_t length)
Definition: strmake.cc:42
Definition: m_ctype.h:423
Class Gtid_set::String_format defines the separators used by Gtid_set::to_string.
Definition: rpl_gtid.h:1889
This struct represents a specification of a GTID for a statement to be executed: either "AUTOMATIC",...
Definition: rpl_gtid.h:3985
enum_gtid_type type
The type of this GTID.
Definition: rpl_gtid.h:3998
Gtid gtid
The GTID: { SIDNO, GNO } if type == GTID; { 0, 0 } if type == AUTOMATIC or ANONYMOUS.
Definition: rpl_gtid.h:4004
rpl_gno gno
GNO of this Gtid.
Definition: rpl_gtid.h:1106
Definition: my_sys.h:346
const char * str
Definition: mysql_lex_string.h:41
Definition: my_bitmap.h:43
Definition: log_event.h:507
const char * name[MAX_DBS_IN_EVENT_MTS]
Definition: log_event.h:508
int num
Definition: log_event.h:509
Mts_db_names()=default
void reset_and_dispose()
Definition: log_event.h:513
Interface for an instrumented stage progress.
Definition: psi_stage_bits.h:63
LEX_CSTRING db
Definition: table.h:779
Definition: table.h:1406
TABLE_SHARE * s
Definition: table.h:1407
Definition: typelib.h:35
Legends running throughout the module:
Definition: rpl_rli_pdb.h:74
static bool is_any_gtid_event(const Log_event_type &type)
Helps to identify any GTID event - returns true for GTID_LOG_EVENT, GTID_TAGGED_LOG_EVENT and ANONYMO...
Definition: binlog_event.h:399
struct xid_t is binary compatible with the XID structure as in the X/Open CAE Specification,...
Definition: xa.h:83
Include file for Sun RPC to compile out of the box.
Item_result
Type of the user defined function return slot and arguments.
Definition: udf_registration_types.h:39
Definition: dtoa.cc:588
synode_no q[FIFO_SIZE]
Definition: xcom_base.cc:4086
static uint64_t cache_size
Definition: xcom_cache.cc:362