/* Copyright (c) 2020, 2024, Oracle and/or its affiliates. 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 */ #ifndef RPL_SYS_TABLE_ACCESS_INCLUDED #define RPL_SYS_TABLE_ACCESS_INCLUDED #include "sql/field.h" #include "sql/sql_class.h" #include "sql/table.h" #include "thr_lock.h" class Json_wrapper; class THD; struct CHARSET_INFO; struct TABLE; /** @class Rpl_sys_table_access The class is used to simplify table data access. It creates new thread/session context (THD) and open table on class object creation, and destroys thread and closes all open thread tables on class object destruction. */ class Rpl_sys_table_access { public: /** Construction. @param[in] schema_name Database where the table resides @param[in] table_name Table to be opened @param[in] max_num_field Maximum number of fields */ Rpl_sys_table_access(const std::string &schema_name, const std::string &table_name, uint max_num_field); /** Destruction. All opened tables with the open_tables are closed during destruction if not already done in deinit(). */ ~Rpl_sys_table_access(); /** Creates new thread/session context (THD) and open's table on class object creation. @param[in] lock_type How to lock the table @retval true if there is error @retval false if there is no error */ bool open(enum thr_lock_type lock_type); /** All opened tables with the open_tables are closed and removes THD created in close(). @param[in] error State that there was a error on the table operations @param[in] ignore_global_read_lock State that the global_read_lock must be ignored @retval true if there is error @retval false if there is no error */ bool close(bool error, bool ignore_global_read_lock = false); /** Get TABLE object created for the table access purposes. @return TABLE pointer. */ TABLE *get_table(); /** Set error. */ void set_error() { m_error = true; } /** Verify if error is set. @retval true if there is error @retval false if there is no error */ bool get_error() { return m_error; } /** Stores provided string to table's field. @param[in] field Field class object @param[in] fld The std::string value to be saved. @param[in] cs Charset info @retval true Error @retval false Success */ bool store_field(Field *field, std::string fld, CHARSET_INFO *cs = &my_charset_bin); /** Stores provided integer to table's field. @param[in] field Field class object @param[in] fld The long long value to be saved. @param[in] unsigned_val If value is unsigned. @retval true Error @retval false Success */ bool store_field(Field *field, long long fld, bool unsigned_val = true); /** Stores provided Json to table's field. @param[in] field Field class object @param[in] wrapper The Json_wrapper class object value @retval true Error @retval false Success */ bool store_field(Field *field, const Json_wrapper &wrapper); /** Retrieves string field from provided table's field. @param[in] field Field class object @param[in] fld The std::string value to be retrieved. @param[in] cs Charset info @retval true Error @retval false Success */ bool get_field(Field *field, std::string &fld, CHARSET_INFO *cs = &my_charset_bin); /** Retrieves long long integer field from provided table's field. @param[in] field Field class object @param[in] fld The uint value to be retrieved. @retval true Error @retval false Success */ bool get_field(Field *field, uint &fld); /** Retrieves Json field from provided table's field. @param[in] field Field class object @param[in] wrapper The retrieved field would be saved in Json_wrapper format. @retval true Error @retval false Success */ bool get_field(Field *field, Json_wrapper &wrapper); std::string get_field_error_msg(std::string field_name) const; static void handler_write_row_func(Rpl_sys_table_access &table_op, bool &err_val, std::string &err_msg, uint table_index = 0, key_part_map keypart_map = HA_WHOLE_KEY); static void handler_delete_row_func(Rpl_sys_table_access &table_op, bool &err_val, std::string &err_msg, uint table_index = 0, key_part_map keypart_map = HA_WHOLE_KEY); template static void for_each_in_tuple(std::tuple &tuple, F func, std::index_sequence) { using tuple_list = int[255]; (void)tuple_list{0, ((void)func(Is, std::get(tuple)), 0)...}; } template static void for_each_in_tuple(std::tuple &tuple, F func) { for_each_in_tuple(tuple, func, std::make_index_sequence()); } template static void for_each_in_tuple(const std::tuple &tuple, F func, std::index_sequence) { using tuple_list = int[255]; (void)tuple_list{0, ((void)func(Is, std::get(tuple)), 0)...}; } template static void for_each_in_tuple(const std::tuple &tuple, F func) { for_each_in_tuple(tuple, func, std::make_index_sequence()); } /** Delete all rows on `m_schema_name.m_table_name`. @retval true if there is error @retval false if there is no error */ bool delete_all_rows(); /** Return the version stored on `m_schema_version_name.m_table_version_name` for the `m_schema_name.m_table_name` table. @retval 0 if there is error @retval >0 if there is no error */ ulonglong get_version(); /** Increment the version stored on `m_schema_version_name.m_table_version_name` for the `m_schema_name.m_table_name` table. @retval true if there is error @retval false if there is no error */ bool increment_version(); /** Update the version stored on `m_schema_version_name.m_table_version_name` for the `m_schema_name.m_table_name` table. @param[in] version the version value @retval true if there is error @retval false if there is no error */ bool update_version(ulonglong version); /** Delete the version stored on `m_schema_version_name.m_table_version_name` for the `m_schema_name.m_table_name` table. @retval true if there is error @retval false if there is no error */ bool delete_version(); /** Get database name of table accessed. @return database name. */ std::string get_db_name() { return m_schema_name; } /** Get table name of table accessed. @return table name. */ std::string get_table_name() { return m_table_name; } private: /* THD created for TableAccess object purpose. */ THD *m_thd{nullptr}; /* THD associated with the calling thread. */ THD *m_current_thd{nullptr}; /* The variable determine if table is opened or closed successfully. */ bool m_error{false}; /* Table_ref object */ Table_ref *m_table_list{nullptr}; enum thr_lock_type m_lock_type; std::string m_schema_name; std::string m_table_name; uint m_max_num_field; const std::string m_schema_version_name{"mysql"}; const std::string m_table_version_name{ "replication_group_configuration_version"}; const uint m_table_data_index = 0; const uint m_table_version_index = 1; const uint m_table_list_size = 2; }; #endif /* RPL_SYS_TABLE_ACCESS_INCLUDED */