#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 "map_helpers.h"

#include "my_alloc.h"

#include "my_loglevel.h"

#include "my_macros.h"

#include "my_systime.h"

#include "my_thread.h"

#include "sql/check_stack.h"

#include "sql/clone_handler.h"

#include "sql/raii/thread_stage_guard.h"

#include "sql_string.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 "libbinlogevents/include/buffer/grow_calculator.h"

#include "libbinlogevents/include/compression/compressor.h"

#include "libbinlogevents/include/compression/payload_event_buffer_istream.h"

#include "libbinlogevents/include/control_events.h"

#include "libbinlogevents/include/debug_vars.h"

#include "libbinlogevents/include/rows_event.h"

#include "libbinlogevents/include/statement_events.h"

#include "libbinlogevents/include/table_id.h"

#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/components/services/log_builtins.h"

#include "mysql/plugin.h"

#include "mysql/psi/mysql_file.h"

#include "mysql/service_mysql_alloc.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_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/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 "thr_lock.h"

#include "sql/binlog_ext.h"

#include "sql/duckdb/duckdb_config.h"

#include "sql/duckdb/duckdb_table.h"

bool duckdb_source_set_insert_only_to_binlog = false;

class Item;

using binary_log::checksum_crc32;

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")

#define MY_OFF_T_UNDEF (~(my_off_t)0UL)

#define LIMIT_UNSAFE_WARNING_ACTIVATION_TIMEOUT 50

#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;

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);

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

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 {

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) {

}

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

}

static time_t calculate_auto_purge_lower_time_bound() {

}

static bool check_auto_purge_conditions() {

}

class MYSQL_BIN_LOG::Binlog_ofile : public Basic_ostream {

public:

~Binlog_ofile() override {

DBUG_TRACE;

close();

return;

}

/**

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;

}

/**

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() {

}

/**

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

}

/**

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

}

/**

bool truncate(my_off_t offset) {

}

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; }

/**

int get_encrypted_header_size() { return m_encrypted_header_size; }

/**

my_off_t get_real_file_size() { return m_position + m_encrypted_header_size; }

/**

std::unique_ptr<Truncatable_ostream> get_pipeline_head() {

return std::move(m_pipeline_head);

}

/**

bool is_encrypted() { return m_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;

};

class Thd_backup_and_restore {

};

class binlog_cache_data {