/* Copyright (c) 2009, 2024, Oracle and/or its affiliates.

Copyright (c) 2023, 2025, GreatDB Software Co., Ltd.

This program is free software; you can redistribute it and/or modify

it under the terms of the GNU General Public License, version 2.0,

as published by the Free Software Foundation.

This program is designed to work with certain software (including

but not limited to OpenSSL) that is licensed under separate terms,

as designated in a particular file or component or in included license

documentation. The authors of MySQL hereby grant you an additional

permission to link the program and your derivative works with the

separately licensed software that they have either included with

the program or referenced in the documentation.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU General Public License, version 2.0, for more details.

You should have received a copy of the GNU General Public License

along with this program; if not, write to the Free Software

Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA */

#include "sql/binlog.h"

#include "my_config.h"

#include <errno.h>

#include <fcntl.h>

#include <limits.h>

#include <stdio.h>

#include <stdlib.h>

#include <time.h>

#include "m_string.h"

#include "map_helpers.h"

#include "my_alloc.h"

#include "my_macros.h"

#include "my_systime.h"

#include "my_thread.h"

#include "mysql/my_loglevel.h"

#include "mysql/strings/int2str.h"

#include "nulls.h"

#include "sql/check_stack.h"

#include "sql/clone_handler.h"

#include "sql/raii/thread_stage_guard.h"

#include "sql_string.h"

#include "strmake.h"

#include "template_utils.h"

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <algorithm>

#include <list>

#include <map>

#include <memory>

#include <new>

#include <queue>

#include <sstream>

#include <string>

#include "dur_prop.h"

#include "include/mysqld_errmsg.h" // ER_OUT_OF_RESOURCES_MSG

#include "mf_wcomp.h" // wild_one, wild_many

#include "mutex_lock.h" // Mutex_lock

#include "my_base.h"

#include "my_bitmap.h"

#include "my_byteorder.h"

#include "my_compiler.h"

#include "my_dbug.h"

#include "my_dir.h"

#include "my_sqlcommand.h"

#include "my_stacktrace.h" // my_safe_print_system_time

#include "my_thread_local.h"

#include "mysql/binlog/event/compression/buffer/grow_calculator.h"

#include "mysql/binlog/event/compression/compressor.h"

#include "mysql/binlog/event/compression/payload_event_buffer_istream.h"

#include "mysql/binlog/event/compression/zstd_comp.h"

#include "mysql/binlog/event/control_events.h"

#include "mysql/binlog/event/debug_vars.h"

#include "mysql/binlog/event/rows_event.h"

#include "mysql/binlog/event/statement_events.h"

#include "mysql/binlog/event/table_id.h"

#include "mysql/components/services/log_builtins.h"

#include "mysql/plugin.h"

#include "mysql/psi/mysql_file.h"

#include "mysql/service_mysql_alloc.h"

#include "mysql/strings/m_ctype.h"

#include "mysql/thread_type.h"

#include "mysqld_error.h"

#include "partition_info.h"

#include "prealloced_array.h"

#include "scope_guard.h"

#include "sql/binlog/decompressing_event_object_istream.h"

#include "sql/binlog/global.h"

#include "sql/binlog/group_commit/bgc_ticket_manager.h" // Bgc_ticket_manager

#include "sql/binlog/recovery.h" // binlog::Binlog_recovery

#include "sql/binlog/services/iterator/file_storage.h"

#include "sql/binlog_ostream.h"

#include "sql/binlog_reader.h"

#include "sql/create_field.h"

#include "sql/current_thd.h"

#include "sql/debug_sync.h" // DEBUG_SYNC

#include "sql/derror.h" // ER_THD

#include "sql/discrete_interval.h"

#include "sql/field.h"

#include "sql/handler.h"

#include "sql/item_func.h" // user_var_entry

#include "sql/key.h"

#include "sql/log.h"

#include "sql/log_event.h" // Rows_log_event

#include "sql/mysqld.h" // sync_binlog_period ...

#include "sql/mysqld_thd_manager.h" // Global_THD_manager

#include "sql/protocol.h"

#include "sql/psi_memory_key.h"

#include "sql/psi_memory_resource.h"

#include "sql/query_options.h"

#include "sql/raii/sentry.h" // raii::Sentry<>

#include "sql/rpl_filter.h"

#include "sql/rpl_gtid.h"

#include "sql/rpl_handler.h" // RUN_HOOK

#include "sql/rpl_mi.h" // Master_info

#include "sql/rpl_record.h"

#include "sql/rpl_replica.h"

#include "sql/rpl_replica_commit_order_manager.h" // Commit_order_manager

#include "sql/rpl_rli.h" // Relay_log_info

#include "sql/rpl_rli_pdb.h" // Slave_worker

#include "sql/rpl_transaction_ctx.h"

#include "sql/rpl_trx_boundary_parser.h" // Transaction_boundary_parser

#include "sql/rpl_utility.h"

#include "sql/sql_backup_lock.h" // is_instance_backup_locked et al.

#include "sql/sql_base.h" // find_temporary_table

#include "sql/sql_bitmap.h"

#include "sql/sql_class.h" // THD

#include "sql/sql_const.h"

#include "sql/sql_data_change.h"

#include "sql/sql_error.h"

#include "sql/sql_lex.h"

#include "sql/sql_list.h"

#include "sql/sql_parse.h" // sqlcom_can_generate_row_events

#include "sql/sql_show.h" // append_identifier

#include "sql/system_variables.h"

#include "sql/table.h"

#include "sql/transaction_info.h"

#include "sql/xa.h"

#include "sql/xa/sql_cmd_xa.h" // Sql_cmd_xa_*

#include "sql_partition.h"

#include "string_with_len.h"

#include "thr_lock.h"

class Item;

using mysql::binlog::event::enum_binlog_checksum_alg;

using std::list;

using std::max;

using std::min;

using std::string;

#define FLAGSTR(V, F) ((V) & (F) ? #F " " : "")

#define YESNO(X) ((X) ? "yes" : "no")

/**

@defgroup Binary_Log Binary Log

@{

*/

#define MY_OFF_T_UNDEF (~(my_off_t)0UL)

#define MAX_EVENT_BUFFER_SIZE 4194304

#define MAX_EVENT_BUFFER_NUM 256

/*

Constants required for the limit unsafe warnings suppression

*/

// seconds after which the limit unsafe warnings suppression will be activated

#define LIMIT_UNSAFE_WARNING_ACTIVATION_TIMEOUT 50

// number of limit unsafe warnings after which the suppression will be activated

#define LIMIT_UNSAFE_WARNING_ACTIVATION_THRESHOLD_COUNT 50

static ulonglong limit_unsafe_suppression_start_time = 0;

static bool unsafe_warning_suppression_is_activated = false;

static int limit_unsafe_warning_count = 0;

static handlerton *binlog_hton;

bool opt_binlog_order_commits = true;

const char *log_bin_index = nullptr;

const char *log_bin_basename = nullptr;

/* Size for IO_CACHE buffer for binlog & relay log */

ulong rpl_read_size;

MYSQL_BIN_LOG mysql_bin_log(&sync_binlog_period);

static int binlog_init(void *p);

static int binlog_start_trans_and_stmt(THD *thd, Log_event *start_event);

static int binlog_close_connection(handlerton *hton, THD *thd);

static int binlog_savepoint_set(handlerton *hton, THD *thd, void *sv);

static int binlog_savepoint_rollback(handlerton *hton, THD *thd, void *sv);

static bool binlog_savepoint_rollback_can_release_mdl(handlerton *hton,

THD *thd);

static int binlog_commit(handlerton *hton, THD *thd, bool all);

static int binlog_rollback(handlerton *hton, THD *thd, bool all);

/*

This function is used to prepare a transaction. For the binary log SE.

@param hton The pointer to the binlog SE plugin.

@param thd The THD session object holding the transaction to be prepared.

@param all Preparing a transaction (i.e. true) or a statement

(i.e. false).

@return 0 if the function is successfully executed, non-zero otherwise

*/

static int binlog_prepare(handlerton *hton, THD *thd, bool all);

/*

This function is used to mark an X/Open XA distributed transaction as

being prepared in the server transaction coordinator.

Is a no-op function, added to the handler API to workaround warnings that

are triggered for SEs participating in a transaction that requires this

callback but such callback is not available.

@param hton The pointer to the binlog SE plugin.

@param thd The THD session object holding the transaction to be updated.

@return 0 if the function is successfully executed, non-zero otherwise

*/

static int binlog_set_prepared_in_tc(handlerton *hton, THD *thd);

static void exec_binlog_error_action_abort(const char *err_string);

static void binlog_prepare_row_images(const THD *thd, TABLE *table);

static bool is_loggable_xa_prepare(THD *thd);

namespace {

/**

Finishes the transaction in the engines. If the `commit_low` flag is set,

will commit in the engines, otherwise, if the underlying statement is an

`XA ROLLBACK`, it will rollback in the engines.

@param thd The THD session object holding the transaction to finalize.

@param all Finalizing a transaction (i.e. true) or a statement

(i.e. false).

@param run_after_commit In the case of a commit being issued, whether or

not to run the `after_commit` hook.

*/

void finish_transaction_in_engines(THD *thd, bool all, bool run_after_commit);

} // namespace

bool normalize_binlog_name(char *to, const char *from, bool is_relay_log) {

DBUG_TRACE;

bool error = false;

char buff[FN_REFLEN];

char *ptr = const_cast<char *>(from);

char *opt_name = is_relay_log ? opt_relay_logname : opt_bin_logname;

assert(from);

/* opt_name is not null and not empty and from is a relative path */

if (opt_name && opt_name[0] && from && !test_if_hard_path(from)) {

// take the path from opt_name

// take the filename from from

char log_dirpart[FN_REFLEN], log_dirname[FN_REFLEN];

size_t log_dirpart_len, log_dirname_len;

dirname_part(log_dirpart, opt_name, &log_dirpart_len);

dirname_part(log_dirname, from, &log_dirname_len);

/* log may be empty => relay-log or log-bin did not

hold paths, just filename pattern */

if (log_dirpart_len > 0) {

/* create the new path name */

if (fn_format(buff, from + log_dirname_len, log_dirpart, "",

MYF(MY_UNPACK_FILENAME | MY_SAFE_PATH)) == nullptr) {

error = true;

goto end;

}

ptr = buff;

}

}

assert(ptr);

if (ptr) {

size_t length = strlen(ptr);

// Strips the CR+LF at the end of log name and \0-terminates it.

if (length && ptr[length - 1] == '\n') {

ptr[length - 1] = 0;

length--;

if (length && ptr[length - 1] == '\r') {

ptr[length - 1] = 0;

length--;

}

}

if (!length) {

error = true;

goto end;

}

strmake(to, ptr, length);

}

end:

return error;

}

static int binlog_start_consistent_snapshot(handlerton *hton, THD *thd);

static int binlog_clone_consistent_snapshot(handlerton *hton, THD *thd,

THD *from_thd);

ulonglong binlog_space_limit;

// The last published global binlog position

static char binlog_global_snapshot_file[FN_REFLEN];

static ulonglong binlog_global_snapshot_position;

// Binlog position variables for SHOW STATUS

static char binlog_snapshot_file[FN_REFLEN];

static ulonglong binlog_snapshot_position;

static std::string binlog_snapshot_gtid_executed;

static SHOW_VAR binlog_status_vars_detail[] = {

{"snapshot_file", (char *)&binlog_snapshot_file, SHOW_CHAR,

SHOW_SCOPE_GLOBAL},

{"snapshot_position", (char *)&binlog_snapshot_position, SHOW_LONGLONG,

SHOW_SCOPE_GLOBAL},

{NullS, NullS, SHOW_LONG, SHOW_SCOPE_GLOBAL}};

/**

@brief Checks whether purge conditions are met to be able to run purge

for binary log files.

This function checks whether the binary log is open, if the instance

is not locked for backup.

@param log The reference to the binary log.

@return std::pair<bool, int> the first element states whether there is a

purge condition violation. The second element states what is the associated

error code, if any.

*/

static std::pair<bool, int> check_purge_conditions(const MYSQL_BIN_LOG &log) {

// is the binary log open?

if (!log.is_open()) {

return std::make_pair(true, 0);

}

// go ahead, validations checked successfully

return std::make_pair(false, 0);

}

/**

@brief This function abstracts the calculation of the binary log files

retention lower bound. It is just a function that makes it easier

to handle the fact that there are two mutually exclusive variables

that control the purge period and one of them is deprecated.

NOTE: This function and part of the purge validation functions should

really move to a retention policy class that abstracts the

retention policy altogether and its controls. Perhaps we

can do that once a refactoring is done to also include

retention based on storage space occupied. Then we can use

the same retention abstraction for binary and relay logs

and possibly extend the options to retain (binary) log files

not only based on time, but also on space used.

@return time_t the time after which log files are considered expired.

*/

static time_t calculate_auto_purge_lower_time_bound() {

if (DBUG_EVALUATE_IF("expire_logs_always", true, false)) return time(nullptr);

int64 expiration_time = 0;

int64 current_time = time(nullptr);

if (binlog_expire_logs_seconds > 0)

expiration_time = current_time - binlog_expire_logs_seconds;

// check for possible overflow conditions (4 bytes time_t)

if (expiration_time < std::numeric_limits<time_t>::min())

expiration_time = std::numeric_limits<time_t>::min();

// This function should only be called if binlog_expire_logs_seconds

// is greater than 0

assert(binlog_expire_logs_seconds > 0);

return static_cast<time_t>(expiration_time);

}

/**

@brief Checks if automatic purge conditions are met and therefore the

purge is allowed to be done. If not met returns true. Otherwise, false.

@return false if the check is successful. True otherwise.

*/

static bool check_auto_purge_conditions() {

// purge is disabled

if (!opt_binlog_expire_logs_auto_purge) return true;

// no retention window configured

if (binlog_expire_logs_seconds == 0) return true;

// go ahead, validations checked successfully

return false;

}

/**

Logical binlog file which wraps and hides the detail of lower layer storage

implementation. Binlog code just use this class to control real storage

*/

class MYSQL_BIN_LOG::Binlog_ofile : public Basic_ostream {

public:

~Binlog_ofile() override {

DBUG_TRACE;

close();

return;

}

/**

Opens the binlog file. It opens the lower layer storage.

@param[in] log_file_key The PSI_file_key for this stream

@param[in] binlog_name The file to be opened

@param[in] flags The flags used by IO_CACHE.

@param[in] existing True if opening the file, false if creating a new one.

@retval false Success

@retval true Error

*/

bool open(

#ifdef HAVE_PSI_INTERFACE

PSI_file_key log_file_key,

#endif

const char *binlog_name, myf flags, bool existing = false) {

DBUG_TRACE;

assert(m_pipeline_head == nullptr);

#ifndef NDEBUG

{

#ifndef HAVE_PSI_INTERFACE

PSI_file_key log_file_key = PSI_NOT_INSTRUMENTED;

#endif

MY_STAT info;

if (!mysql_file_stat(log_file_key, binlog_name, &info, MYF(0))) {

assert(existing == !(my_errno() == ENOENT));

set_my_errno(0);

}

}

#endif

std::unique_ptr<IO_CACHE_ostream> file_ostream(new IO_CACHE_ostream);

if (file_ostream->open(log_file_key, binlog_name, flags)) return true;

m_pipeline_head = std::move(file_ostream);

/* Setup encryption for new files if needed */

if (!existing && rpl_encryption.is_enabled()) {

std::unique_ptr<Binlog_encryption_ostream> encrypted_ostream(

new Binlog_encryption_ostream());

if (encrypted_ostream->open(std::move(m_pipeline_head))) return true;

m_encrypted_header_size = encrypted_ostream->get_header_size();

m_pipeline_head = std::move(encrypted_ostream);

}

return false;

}

/**

Opens an existing binlog file. It opens the lower layer storage reusing the

existing file password if needed.

@param[in] log_file_key The PSI_file_key for this stream

@param[in] binlog_name The file to be opened

@param[in] flags The flags used by IO_CACHE.

@retval std::unique_ptr A Binlog_ofile object pointer.

@retval nullptr Error.

*/

static std::unique_ptr<Binlog_ofile> open_existing(

#ifdef HAVE_PSI_INTERFACE

PSI_file_key log_file_key,

#endif

const char *binlog_name, myf flags) {

DBUG_TRACE;

std::unique_ptr<Rpl_encryption_header> header;

unsigned char magic[BINLOG_MAGIC_SIZE];

/* Open a simple istream to read the magic from the file */

IO_CACHE_istream istream;

if (istream.open(key_file_binlog, key_file_binlog_cache, binlog_name,

MYF(MY_WME | MY_DONT_CHECK_FILESIZE), rpl_read_size))

return nullptr;

if (istream.read(magic, BINLOG_MAGIC_SIZE) != BINLOG_MAGIC_SIZE)

return nullptr;

assert(Rpl_encryption_header::ENCRYPTION_MAGIC_SIZE == BINLOG_MAGIC_SIZE);

/* Identify the file type by the magic to get the encryption header */

if (memcmp(magic, Rpl_encryption_header::ENCRYPTION_MAGIC,

BINLOG_MAGIC_SIZE) == 0) {

header = Rpl_encryption_header::get_header(&istream);

if (header == nullptr) return nullptr;

} else if (memcmp(magic, BINLOG_MAGIC, BINLOG_MAGIC_SIZE) != 0) {

return nullptr;

}

/* Open the binlog_ofile */

std::unique_ptr<Binlog_ofile> ret_ofile(new Binlog_ofile);

if (ret_ofile->open(

#ifdef HAVE_PSI_INTERFACE

log_file_key,

#endif

binlog_name, flags, true)) {

return nullptr;

}

if (header != nullptr) {

/* Add the encryption stream on top of IO_CACHE */

std::unique_ptr<Binlog_encryption_ostream> encrypted_ostream(

new Binlog_encryption_ostream);

ret_ofile->m_encrypted_header_size = header->get_header_size();

encrypted_ostream->open(std::move(ret_ofile->m_pipeline_head),

std::move(header));

ret_ofile->m_pipeline_head = std::move(encrypted_ostream);

ret_ofile->set_encrypted();

}

return ret_ofile;

}

void close() {

m_pipeline_head.reset(nullptr);

m_position = 0;

m_encrypted_header_size = 0;

}

/**

Writes data into storage and maintains binlog position.

@param[in] buffer the data will be written

@param[in] length the length of the data

@retval false Success

@retval true Error

*/

bool write(const unsigned char *buffer, my_off_t length) override {

assert(m_pipeline_head != nullptr);

if (m_pipeline_head->write(buffer, length)) return true;

m_position += length;

return false;

}

/**

Updates some bytes in the binlog file. If is only used for clearing

LOG_EVENT_BINLOG_IN_USE_F.

@param[in] buffer the data will be written

@param[in] length the length of the data

@param[in] offset the offset of the bytes will be updated

@retval false Success

@retval true Error

*/

bool update(const unsigned char *buffer, my_off_t length, my_off_t offset) {

assert(m_pipeline_head != nullptr);

return m_pipeline_head->seek(offset) ||

m_pipeline_head->write(buffer, length);

}

/**

Truncates some data at the end of the binlog file.

@param[in] offset where the binlog file will be truncated to.

@retval false Success

@retval true Error

*/

bool truncate(my_off_t offset) {

assert(m_pipeline_head != nullptr);

if (m_pipeline_head->truncate(offset)) return true;

m_position = offset;

return false;

}

bool flush() { return m_pipeline_head->flush(); }

bool sync() { return m_pipeline_head->sync(); }

bool flush_and_sync() { return flush() || sync(); }

my_off_t position() { return m_position; }

bool is_empty() { return position() == 0; }

bool is_open() { return m_pipeline_head != nullptr; }

/**

Returns the encrypted header size of the binary log file.

@retval 0 The file is not encrypted.

@retval >0 The encryption header size.

*/

int get_encrypted_header_size() { return m_encrypted_header_size; }

/**

Returns the real file size.

While position() returns the "file size" from the plain binary log events

stream point of view, this function considers the encryption header when it

exists.

@return The real file size considering the encryption header.

*/

my_off_t get_real_file_size() { return m_position + m_encrypted_header_size; }

/**

Get the pipeline head.

@retval Returns the pipeline head or nullptr.

*/

std::unique_ptr<Truncatable_ostream> get_pipeline_head() {

return std::move(m_pipeline_head);

}

/**

Check if the log file is encrypted.

@retval True if the log file is encrypted.

@retval False if the log file is not encrypted.

*/

bool is_encrypted() { return m_encrypted; }

/**

Set that the log file is encrypted.

*/

void set_encrypted() { m_encrypted = true; }

private:

my_off_t m_position = 0;

int m_encrypted_header_size = 0;

std::unique_ptr<Truncatable_ostream> m_pipeline_head;

bool m_encrypted = false;

};

/**

Helper class to switch to a new thread and then go back to the previous one,

when the object is destroyed using RAII.

This class is used to temporarily switch to another session (THD

structure). It will set up thread specific "globals" correctly

so that the POSIX thread looks exactly like the session attached to.

However, PSI_thread info is not touched as it is required to show

the actual physical view in PFS instrumentation i.e., it should

depict as the real thread doing the work instead of thread it switched

to.

On destruction, the original session (which is supplied to the

constructor) will be re-attached automatically. For example, with

this code, the value of @c current_thd will be the same before and

after execution of the code.

@code

{

for (int i = 0 ; i < count ; ++i)

{

// here we are attached to current_thd

// [...]

Thd_backup_and_restore switch_thd(current_thd, other_thd[i]);

// [...]

// here we are attached to other_thd[i]

// [...]

}

// here we are attached to current_thd

}

@endcode

@warning The class is not designed to be inherited from.

*/

class Thd_backup_and_restore {

public:

/**

Try to attach the POSIX thread to a session.

@param[in] backup_thd The thd to restore to when object is destructed.

@param[in] new_thd The thd to attach to.

*/

Thd_backup_and_restore(THD *backup_thd, THD *new_thd)

: m_backup_thd(backup_thd),

m_new_thd(new_thd),

m_new_thd_old_real_id(new_thd->real_id),

m_new_thd_old_thread_stack(new_thd->thread_stack) {

assert(m_backup_thd != nullptr && m_new_thd != nullptr);

// Reset the state of the current thd.

m_backup_thd->restore_globals();

m_new_thd->thread_stack = m_backup_thd->thread_stack;

m_new_thd->store_globals();

#ifdef HAVE_PSI_THREAD_INTERFACE

PSI_THREAD_CALL(set_mem_cnt_THD)(m_new_thd, &m_backup_cnt_thd);

#endif

}

/**

Restores to previous thd.

*/

~Thd_backup_and_restore() {

/*

Restore the global variables of the thd we previously attached to,

to its original state. In other words, detach the m_new_thd.

*/

m_new_thd->restore_globals();

m_new_thd->real_id = m_new_thd_old_real_id;

m_new_thd->thread_stack = m_new_thd_old_thread_stack;

// Reset the global variables to the original state.

m_backup_thd->store_globals();

#ifdef HAVE_PSI_THREAD_INTERFACE

PSI_THREAD_CALL(set_mem_cnt_THD)(m_backup_cnt_thd, &m_dummy_cnt_thd);

#endif

}

private:

THD *m_backup_thd;

THD *m_new_thd;

THD *m_backup_cnt_thd;

THD *m_dummy_cnt_thd;

my_thread_t m_new_thd_old_real_id;

const char *m_new_thd_old_thread_stack;

};

/**

Caches for non-transactional and transactional data before writing

it to the binary log.

@todo All the access functions for the flags suggest that the

encapsuling is not done correctly, so try to move any logic that

requires access to the flags into the cache.

*/

class binlog_cache_data {

public:

binlog_cache_data(class binlog_cache_mngr &cache_mngr, bool trx_cache_arg,

ulong *ptr_binlog_cache_use_arg,

ulong *ptr_binlog_cache_disk_use_arg)

: m_cache_mngr(cache_mngr),

m_pending(nullptr),

ptr_binlog_cache_use(ptr_binlog_cache_use_arg),

ptr_binlog_cache_disk_use(ptr_binlog_cache_disk_use_arg) {

flags.transactional = trx_cache_arg;

}

bool open(my_off_t cache_size, my_off_t max_cache_size) {

return m_cache.open(cache_size, max_cache_size);

}

Binlog_cache_storage *get_cache() { return &m_cache; }

int finalize(THD *thd, Log_event *end_event);

int finalize(THD *thd, Log_event *end_event, XID_STATE *xs);

int flush(THD *thd, my_off_t *bytes, bool *wrote_xid,

bool parallelization_barrier);

int write_event(Log_event *event);

void set_event_counter(size_t event_counter) {

m_event_counter = event_counter;

}

size_t get_event_counter() const { return m_event_counter; }

size_t get_compressed_size() const { return m_compressed_size; }

size_t get_decompressed_size() const { return m_decompressed_size; }

mysql::binlog::event::compression::type get_compression_type() const {

return m_compression_type;

}

void set_compressed_size(size_t s) { m_compressed_size = s; }

void set_decompressed_size(size_t s) { m_decompressed_size = s; }

void set_compression_type(mysql::binlog::event::compression::type t) {

m_compression_type = t;

}

virtual ~binlog_cache_data() {

assert(is_binlog_empty());

m_cache.close();

}

bool is_binlog_empty() const {

DBUG_PRINT("debug", ("%s_cache - pending: 0x%llx, bytes: %llu",

(flags.transactional ? "trx" : "stmt"),

(ulonglong)pending(), (ulonglong)m_cache.length()));

return pending() == nullptr && m_cache.is_empty();

}

bool is_finalized() const { return flags.finalized; }

Rows_log_event *pending() const { return m_pending; }

void set_pending(Rows_log_event *const pending) { m_pending = pending; }

/// @see handle_deferred_cache_write_incident

void set_incident(

std::string_view incident_message =

"Non-transactional changes were not written to the binlog.");

/// @see handle_deferred_cache_write_incident

bool has_incident(void) const;

bool has_xid() const {

// There should only be an XID event if we are transactional

assert((flags.transactional && flags.with_xid) || !flags.with_xid);

return flags.with_xid;

}

bool is_trx_cache() const { return flags.transactional; }

my_off_t get_byte_position() const { return m_cache.length(); }

void cache_state_checkpoint(my_off_t pos_to_checkpoint) {

// We only need to store the cache state for pos > 0

if (pos_to_checkpoint) {

cache_state state;

state.with_rbr = flags.with_rbr;

state.with_sbr = flags.with_sbr;

state.with_start = flags.with_start;

state.with_end = flags.with_end;

state.with_content = flags.with_content;

state.event_counter = m_event_counter;

cache_state_map[pos_to_checkpoint] = state;

}

}

void cache_state_rollback(my_off_t pos_to_rollback) {

if (pos_to_rollback) {

std::map<my_off_t, cache_state>::iterator it;

it = cache_state_map.find(pos_to_rollback);

if (it != cache_state_map.end()) {

flags.with_rbr = it->second.with_rbr;

flags.with_sbr = it->second.with_sbr;

flags.with_start = it->second.with_start;

flags.with_end = it->second.with_end;

flags.with_content = it->second.with_content;

m_event_counter = it->second.event_counter;

} else

assert(it == cache_state_map.end());

}

// Rolling back to pos == 0 means cleaning up the cache.

else {

flags.with_rbr = false;

flags.with_sbr = false;

flags.with_start = false;

flags.with_end = false;

flags.with_content = false;

m_event_counter = 0;

}

}

/**

Reset the cache to unused state when the transaction is finished. It

drops all data in the cache and clears the flags of the transaction state.

*/

virtual void reset() {

compute_statistics();

remove_pending_event();

if (m_cache.reset()) {

LogErr(WARNING_LEVEL, ER_BINLOG_CANT_RESIZE_CACHE);

}

flags.with_xid = false;

flags.with_external_xid = false;

flags.immediate = false;

flags.finalized = false;

flags.with_sbr = false;

flags.with_rbr = false;

flags.with_start = false;

flags.with_end = false;

flags.with_content = false;

/*

The truncate function calls reinit_io_cache that calls my_b_flush_io_cache

which may increase disk_writes. This breaks the disk_writes use by the

binary log which aims to compute the ratio between in-memory cache usage

and disk cache usage. To avoid this undesirable behavior, we reset the

variable after truncating the cache.

*/

cache_state_map.clear();

m_event_counter = 0;

m_compressed_size = 0;

m_decompressed_size = 0;

m_compression_type = mysql::binlog::event::compression::NONE;

assert(is_binlog_empty());

}

/**

Returns information about the cache content with respect to

the binlog_format of the events.

This will be used to set a flag on GTID_LOG_EVENT stating that the

transaction may have SBR statements or not, but the binlog dump

will show this flag as "rbr_only" when it is not set. That's why

an empty transaction should return true below, or else an empty

transaction would be assumed as "rbr_only" even not having RBR

events.

When dumping a binary log content using mysqlbinlog client program,

for any transaction assumed as "rbr_only" it will be printed a

statement changing the transaction isolation level to READ COMMITTED.

It doesn't make sense to have an empty transaction "requiring" this

isolation level change.

@return true The cache have SBR events or is empty.

@return false The cache contains a transaction with no SBR events.

*/

bool may_have_sbr_stmts() { return flags.with_sbr || !flags.with_rbr; }

/**

Check if the binlog cache contains an empty transaction, which has

two binlog events "BEGIN" and "COMMIT".

@return true The binlog cache contains an empty transaction.

@return false Otherwise.

*/

bool has_empty_transaction() {

/*

The empty transaction has two events in trx/stmt binlog cache

and no changes: one is a transaction start and other is a transaction

end (there should be no SBR changing content and no RBR events).

*/

if (flags.with_start && // Has transaction start statement

flags.with_end && // Has transaction end statement

!flags.with_content) // Has no other content than START/END

{

assert(m_event_counter == 2); // Two events in the cache only

assert(!flags.with_sbr); // No statements changing content

assert(!flags.with_rbr); // No rows changing content

assert(!flags.immediate); // Not a DDL

assert(!flags.with_xid); // Not a XID trx and not an atomic DDL Query

return true;

}

return false;

}

/**

Check if the binlog cache is empty or contains an empty transaction,

which has two binlog events "BEGIN" and "COMMIT".

@return true The binlog cache is empty or contains an empty transaction.

@return false Otherwise.

*/

bool is_empty_or_has_empty_transaction() {

return is_binlog_empty() || has_empty_transaction();

}

protected:

/*

This structure should have all cache variables/flags that should be restored

when a ROLLBACK TO SAVEPOINT statement be executed.

*/

struct cache_state {

bool with_sbr;

bool with_rbr;

bool with_start;

bool with_end;

bool with_content;

size_t event_counter;

};

/*

For every SAVEPOINT used, we will store a cache_state for the current

binlog cache position. So, if a ROLLBACK TO SAVEPOINT is used, we can

restore the cache_state values after truncating the binlog cache.

*/

std::map<my_off_t, cache_state> cache_state_map;

/*

In order to compute the transaction size (because of possible extra checksum

bytes), we need to keep track of how many events are in the binlog cache.

*/

size_t m_event_counter = 0;

size_t m_compressed_size = 0;

size_t m_decompressed_size = 0;

mysql::binlog::event::compression::type m_compression_type =

mysql::binlog::event::compression::type::NONE;

/*

It truncates the cache to a certain position. This includes deleting the

pending event. It corresponds to rollback statement or rollback to

a savepoint. It doesn't change transaction state.

*/

void truncate(my_off_t pos) {

DBUG_PRINT("info", ("truncating to position %lu", (ulong)pos));

remove_pending_event();

// TODO: check the return value.

(void)m_cache.truncate(pos);

}

/**

Flush pending event to the cache buffer.

*/

int flush_pending_event(THD *thd) {

if (m_pending) {

m_pending->set_flags(Rows_log_event::STMT_END_F);

if (int error = write_event(m_pending)) return error;

thd->clear_binlog_table_maps();

}

return 0;

}

/**

Remove the pending event.

*/

int remove_pending_event() {

delete m_pending;

m_pending = nullptr;

return 0;

}

struct Flags {

/*