diff options
Diffstat (limited to 'storage/rocksdb/ha_rocksdb.h')
| -rw-r--r-- | storage/rocksdb/ha_rocksdb.h | 926 |
1 files changed, 492 insertions, 434 deletions
diff --git a/storage/rocksdb/ha_rocksdb.h b/storage/rocksdb/ha_rocksdb.h index a15ae6dd443..db95a4d919a 100644 --- a/storage/rocksdb/ha_rocksdb.h +++ b/storage/rocksdb/ha_rocksdb.h @@ -16,7 +16,7 @@ #pragma once #ifdef USE_PRAGMA_INTERFACE -#pragma interface /* gcc class implementation */ +#pragma interface /* gcc class implementation */ #endif /* C++ standard header files */ @@ -26,8 +26,8 @@ #include <vector> /* MySQL header files */ -#include "./handler.h" /* handler */ -#include "./my_global.h" /* ulonglong */ +#include "./handler.h" /* handler */ +#include "./my_global.h" /* ulonglong */ #include "./sql_string.h" #include "./ut0counter.h" @@ -93,41 +93,51 @@ std::vector<Rdb_trx_info> rdb_get_all_trx_info(); - the name used to set the default column family parameter for per-cf arguments. */ -const char * const DEFAULT_CF_NAME= "default"; +const char *const DEFAULT_CF_NAME = "default"; /* This is the name of the Column Family used for storing the data dictionary. */ -const char * const DEFAULT_SYSTEM_CF_NAME= "__system__"; +const char *const DEFAULT_SYSTEM_CF_NAME = "__system__"; /* This is the name of the hidden primary key for tables with no pk. */ -const char * const HIDDEN_PK_NAME= "HIDDEN_PK_ID"; +const char *const HIDDEN_PK_NAME = "HIDDEN_PK_ID"; /* Column family name which means "put this index into its own column family". See Rdb_cf_manager::get_per_index_cf_name(). */ -const char * const PER_INDEX_CF_NAME = "$per_index_cf"; +const char *const PER_INDEX_CF_NAME = "$per_index_cf"; + +/* + Name for the background thread. +*/ +const char *const BG_THREAD_NAME = "myrocks-bg"; + +/* + Name for the drop index thread. +*/ +const char *const INDEX_THREAD_NAME = "myrocks-index"; /* Default, minimal valid, and maximum valid sampling rate values when collecting statistics about table. */ -#define RDB_DEFAULT_TBL_STATS_SAMPLE_PCT 10 -#define RDB_TBL_STATS_SAMPLE_PCT_MIN 1 -#define RDB_TBL_STATS_SAMPLE_PCT_MAX 100 +#define RDB_DEFAULT_TBL_STATS_SAMPLE_PCT 10 +#define RDB_TBL_STATS_SAMPLE_PCT_MIN 1 +#define RDB_TBL_STATS_SAMPLE_PCT_MAX 100 /* Default and maximum values for rocksdb-compaction-sequential-deletes and rocksdb-compaction-sequential-deletes-window to add basic boundary checking. */ -#define DEFAULT_COMPACTION_SEQUENTIAL_DELETES 0 -#define MAX_COMPACTION_SEQUENTIAL_DELETES 2000000 +#define DEFAULT_COMPACTION_SEQUENTIAL_DELETES 0 +#define MAX_COMPACTION_SEQUENTIAL_DELETES 2000000 -#define DEFAULT_COMPACTION_SEQUENTIAL_DELETES_WINDOW 0 -#define MAX_COMPACTION_SEQUENTIAL_DELETES_WINDOW 2000000 +#define DEFAULT_COMPACTION_SEQUENTIAL_DELETES_WINDOW 0 +#define MAX_COMPACTION_SEQUENTIAL_DELETES_WINDOW 2000000 /* Default and maximum values for various compaction and flushing related @@ -139,11 +149,11 @@ const char * const PER_INDEX_CF_NAME = "$per_index_cf"; CPU-s and derive the values from there. This however has its own set of problems and we'll choose simplicity for now. */ -#define MAX_BACKGROUND_COMPACTIONS 64 -#define MAX_BACKGROUND_FLUSHES 64 +#define MAX_BACKGROUND_COMPACTIONS 64 +#define MAX_BACKGROUND_FLUSHES 64 -#define DEFAULT_SUBCOMPACTIONS 1 -#define MAX_SUBCOMPACTIONS 64 +#define DEFAULT_SUBCOMPACTIONS 1 +#define MAX_SUBCOMPACTIONS 64 /* Defines the field sizes for serializing XID object to a string representation. @@ -167,7 +177,7 @@ const char * const PER_INDEX_CF_NAME = "$per_index_cf"; The reason behind the cast issue is the lack of unsigned int support in Java. */ -#define MAX_RATE_LIMITER_BYTES_PER_SEC static_cast<uint64_t>(LONGLONG_MAX) +#define MAX_RATE_LIMITER_BYTES_PER_SEC static_cast<uint64_t>(LONGLONG_MAX) /* Hidden PK column (for tables with no primary key) is a longlong (aka 8 bytes). @@ -179,14 +189,13 @@ const char * const PER_INDEX_CF_NAME = "$per_index_cf"; MyRocks specific error codes. NB! Please make sure that you will update HA_ERR_ROCKSDB_LAST when adding new ones. */ -#define HA_ERR_ROCKSDB_UNIQUE_NOT_SUPPORTED (HA_ERR_LAST + 1) -#define HA_ERR_ROCKSDB_PK_REQUIRED (HA_ERR_LAST + 2) -#define HA_ERR_ROCKSDB_TOO_MANY_LOCKS (HA_ERR_LAST + 3) -#define HA_ERR_ROCKSDB_LAST HA_ERR_ROCKSDB_TOO_MANY_LOCKS - -inline bool looks_like_per_index_cf_typo(const char* const name) -{ - return (name && name[0]=='$' && strcmp(name, PER_INDEX_CF_NAME)); +#define HA_ERR_ROCKSDB_UNIQUE_NOT_SUPPORTED (HA_ERR_LAST + 1) +#define HA_ERR_ROCKSDB_PK_REQUIRED (HA_ERR_LAST + 2) +#define HA_ERR_ROCKSDB_TOO_MANY_LOCKS (HA_ERR_LAST + 3) +#define HA_ERR_ROCKSDB_LAST HA_ERR_ROCKSDB_TOO_MANY_LOCKS + +inline bool looks_like_per_index_cf_typo(const char *const name) { + return (name && name[0] == '$' && strcmp(name, PER_INDEX_CF_NAME)); } /** @@ -196,21 +205,18 @@ inline bool looks_like_per_index_cf_typo(const char* const name) //TODO: join this with Rdb_tbl_def ? */ -struct Rdb_table_handler -{ - char *m_table_name; - uint m_table_name_length; - int m_ref_count; +struct Rdb_table_handler { + char *m_table_name; + uint m_table_name_length; + int m_ref_count; - my_core::THR_LOCK m_thr_lock; ///< MySQL latch needed by m_db_lock + my_core::THR_LOCK m_thr_lock; ///< MySQL latch needed by m_db_lock /* Stores cumulative table statistics */ - my_io_perf_atomic_t m_io_perf_read; - Rdb_atomic_perf_counters m_table_perf_context; + my_io_perf_atomic_t m_io_perf_read; + Rdb_atomic_perf_counters m_table_perf_context; }; - - class Rdb_key_def; class Rdb_tbl_def; class Rdb_transaction; @@ -218,38 +224,32 @@ class Rdb_transaction_impl; class Rdb_writebatch_impl; class Rdb_field_encoder; -const char *const rocksdb_hton_name= "ROCKSDB"; +const char *const rocksdb_hton_name = "ROCKSDB"; typedef struct _gl_index_id_s { uint32_t cf_id; uint32_t index_id; - bool operator==(const struct _gl_index_id_s& other) const - { + bool operator==(const struct _gl_index_id_s &other) const { return cf_id == other.cf_id && index_id == other.index_id; } - bool operator!=(const struct _gl_index_id_s& other) const - { + bool operator!=(const struct _gl_index_id_s &other) const { return cf_id != other.cf_id || index_id != other.index_id; } - bool operator<(const struct _gl_index_id_s& other) const - { + bool operator<(const struct _gl_index_id_s &other) const { return cf_id < other.cf_id || - (cf_id == other.cf_id && index_id < other.index_id); + (cf_id == other.cf_id && index_id < other.index_id); } - bool operator<=(const struct _gl_index_id_s& other) const - { + bool operator<=(const struct _gl_index_id_s &other) const { return cf_id < other.cf_id || - (cf_id == other.cf_id && index_id <= other.index_id); + (cf_id == other.cf_id && index_id <= other.index_id); } - bool operator>(const struct _gl_index_id_s& other) const - { + bool operator>(const struct _gl_index_id_s &other) const { return cf_id > other.cf_id || - (cf_id == other.cf_id && index_id > other.index_id); + (cf_id == other.cf_id && index_id > other.index_id); } - bool operator>=(const struct _gl_index_id_s& other) const - { + bool operator>=(const struct _gl_index_id_s &other) const { return cf_id > other.cf_id || - (cf_id == other.cf_id && index_id >= other.index_id); + (cf_id == other.cf_id && index_id >= other.index_id); } } GL_INDEX_ID; @@ -289,23 +289,20 @@ struct st_export_stats { ulonglong system_rows_updated; }; -} // namespace myrocks +} // namespace myrocks #include "./rdb_buff.h" /* Provide hash function for GL_INDEX_ID so we can include it in sets */ namespace std { - template <> - struct hash<myrocks::GL_INDEX_ID> - { - std::size_t operator()(const myrocks::GL_INDEX_ID& gl_index_id) const - { - const uint64_t val = ((uint64_t) gl_index_id.cf_id << 32 | - (uint64_t) gl_index_id.index_id); - return std::hash<uint64_t>()(val); - } - }; -} // namespace std +template <> struct hash<myrocks::GL_INDEX_ID> { + std::size_t operator()(const myrocks::GL_INDEX_ID &gl_index_id) const { + const uint64_t val = + ((uint64_t)gl_index_id.cf_id << 32 | (uint64_t)gl_index_id.index_id); + return std::hash<uint64_t>()(val); + } +}; +} // namespace std namespace myrocks { @@ -314,11 +311,10 @@ namespace myrocks { Class definition for ROCKSDB storage engine plugin handler */ -class ha_rocksdb: public my_core::handler -{ - my_core::THR_LOCK_DATA m_db_lock; ///< MySQL database lock +class ha_rocksdb : public my_core::handler { + my_core::THR_LOCK_DATA m_db_lock; ///< MySQL database lock - Rdb_table_handler *m_table_handler; ///< Open table handler + Rdb_table_handler *m_table_handler; ///< Open table handler /* Iterator used for range scans and for full table/index scans */ rocksdb::Iterator *m_scan_it; @@ -354,7 +350,7 @@ class ha_rocksdb: public my_core::handler */ bool m_maybe_unpack_info; - uchar *m_pk_tuple; /* Buffer for storing PK in KeyTupleFormat */ + uchar *m_pk_tuple; /* Buffer for storing PK in KeyTupleFormat */ uchar *m_pk_packed_tuple; /* Buffer for storing PK in StorageFormat */ // ^^ todo: change it to 'char*'? TODO: ^ can we join this with last_rowkey? @@ -387,6 +383,10 @@ class ha_rocksdb: public my_core::handler uchar *m_sk_packed_tuple_old; Rdb_string_writer m_sk_tails_old; + /* Buffers used for duplicate checking during unique_index_creation */ + uchar *m_dup_sk_packed_tuple; + uchar *m_dup_sk_packed_tuple_old; + /* Temporary space for packing VARCHARs (we provide it to pack_record()/pack_index_tuple() calls). @@ -448,40 +448,37 @@ class ha_rocksdb: public my_core::handler */ int m_dupp_errkey; - int create_key_defs(const TABLE* const table_arg, - Rdb_tbl_def* const tbl_def_arg, - const TABLE* const old_table_arg= nullptr, - const Rdb_tbl_def* const old_tbl_def_arg= nullptr) const - __attribute__((__nonnull__(2, 3), __warn_unused_result__)); - int secondary_index_read(const int keyno, uchar* const buf) - __attribute__((__nonnull__, __warn_unused_result__)); + int create_key_defs(const TABLE *const table_arg, + Rdb_tbl_def *const tbl_def_arg, + const TABLE *const old_table_arg = nullptr, + const Rdb_tbl_def *const old_tbl_def_arg = nullptr) const + MY_ATTRIBUTE((__nonnull__(2, 3), __warn_unused_result__)); + int secondary_index_read(const int keyno, uchar *const buf) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); void setup_iterator_for_rnd_scan(); - void setup_scan_iterator(const Rdb_key_def& kd, rocksdb::Slice* const slice) - __attribute__((__nonnull__)) - { + void setup_scan_iterator(const Rdb_key_def &kd, rocksdb::Slice *const slice) + MY_ATTRIBUTE((__nonnull__)) { setup_scan_iterator(kd, slice, false, false, 0); } - bool is_ascending(const Rdb_key_def& keydef, + bool is_ascending(const Rdb_key_def &keydef, enum ha_rkey_function find_flag) const - __attribute__((__nonnull__, __warn_unused_result__)); - void setup_scan_iterator(const Rdb_key_def& kd, - rocksdb::Slice *slice, const bool use_all_keys, - const bool is_ascending, const uint eq_cond_len) - __attribute__((__nonnull__)); + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); + void setup_scan_iterator(const Rdb_key_def &kd, rocksdb::Slice *slice, + const bool use_all_keys, const bool is_ascending, + const uint eq_cond_len) MY_ATTRIBUTE((__nonnull__)); void release_scan_iterator(void); - rocksdb::Status get_for_update(Rdb_transaction* const tx, - rocksdb::ColumnFamilyHandle* const column_family, - const rocksdb::Slice& key, - std::string* const value) const; + rocksdb::Status + get_for_update(Rdb_transaction *const tx, + rocksdb::ColumnFamilyHandle *const column_family, + const rocksdb::Slice &key, std::string *const value) const; - int get_row_by_rowid(uchar* const buf, const char* const rowid, + int get_row_by_rowid(uchar *const buf, const char *const rowid, const uint rowid_size) - __attribute__((__nonnull__, __warn_unused_result__)); - int get_row_by_rowid(uchar* const buf, const uchar* const rowid, + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); + int get_row_by_rowid(uchar *const buf, const uchar *const rowid, const uint rowid_size) - __attribute__((__nonnull__, __warn_unused_result__)) - { + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)) { return get_row_by_rowid(buf, reinterpret_cast<const char *>(rowid), rowid_size); } @@ -489,22 +486,22 @@ class ha_rocksdb: public my_core::handler void update_auto_incr_val(); void load_auto_incr_value(); longlong update_hidden_pk_val(); - int load_hidden_pk_value() __attribute__((__warn_unused_result__)); - int read_hidden_pk_id_from_rowkey(longlong* const hidden_pk_id) - __attribute__((__nonnull__, __warn_unused_result__)); + int load_hidden_pk_value() MY_ATTRIBUTE((__warn_unused_result__)); + int read_hidden_pk_id_from_rowkey(longlong *const hidden_pk_id) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); bool can_use_single_delete(const uint &index) const - __attribute__((__warn_unused_result__)); - bool skip_unique_check() const __attribute__((__warn_unused_result__)); + MY_ATTRIBUTE((__warn_unused_result__)); + bool skip_unique_check() const MY_ATTRIBUTE((__warn_unused_result__)); void set_force_skip_unique_check(bool skip) override; - bool commit_in_the_middle() __attribute__((__warn_unused_result__)); - bool do_bulk_commit(Rdb_transaction* const tx) - __attribute__((__nonnull__, __warn_unused_result__)); - bool has_hidden_pk(const TABLE* const table) const - __attribute__((__nonnull__, __warn_unused_result__)); + bool commit_in_the_middle() MY_ATTRIBUTE((__warn_unused_result__)); + bool do_bulk_commit(Rdb_transaction *const tx) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); + bool has_hidden_pk(const TABLE *const table) const + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); void update_row_stats(const operation_type &type); - void set_last_rowkey(const uchar* const old_data); + void set_last_rowkey(const uchar *const old_data); /* Array of table->s->fields elements telling how to store fields in the @@ -513,15 +510,14 @@ class ha_rocksdb: public my_core::handler Rdb_field_encoder *m_encoder_arr; /* Describes instructions on how to decode the field */ - class READ_FIELD - { - public: + class READ_FIELD { + public: /* Points to Rdb_field_encoder describing the field */ - Rdb_field_encoder* m_field_enc; + Rdb_field_encoder *m_field_enc; /* if true, decode the field, otherwise skip it */ - bool m_decode; + bool m_decode; /* Skip this many bytes before reading (or skipping) this field */ - int m_skip; + int m_skip; }; /* @@ -540,11 +536,12 @@ class ha_rocksdb: public my_core::handler */ uint m_null_bytes_in_rec; - void get_storage_type(Rdb_field_encoder* const encoder, const uint &kp); + void get_storage_type(Rdb_field_encoder *const encoder, const uint &kp); void setup_field_converters(); - int alloc_key_buffers(const TABLE* const table_arg, - const Rdb_tbl_def* const tbl_def_arg) - __attribute__((__nonnull__, __warn_unused_result__)); + int alloc_key_buffers(const TABLE *const table_arg, + const Rdb_tbl_def *const tbl_def_arg, + bool alloc_alter_buffers = false) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); void free_key_buffers(); // the buffer size should be at least 2*Rdb_key_def::INDEX_NUMBER_SIZE @@ -568,7 +565,8 @@ class ha_rocksdb: public my_core::handler public: /* - Controls whether writes include checksums. This is updated from the session variable + Controls whether writes include checksums. This is updated from the session + variable at the start of each query. */ bool m_store_row_debug_checksums; @@ -577,12 +575,11 @@ public: bool m_verify_row_debug_checksums; int m_checksums_pct; - ha_rocksdb(my_core::handlerton* const hton, - my_core::TABLE_SHARE* const table_arg); - ~ha_rocksdb() - { - int err __attribute__((__unused__)); - err= finalize_bulk_load(); + ha_rocksdb(my_core::handlerton *const hton, + my_core::TABLE_SHARE *const table_arg); + ~ha_rocksdb() { + int err MY_ATTRIBUTE((__unused__)); + err = finalize_bulk_load(); DBUG_ASSERT(err == 0); mysql_mutex_destroy(&m_bulk_load_mutex); } @@ -590,28 +587,37 @@ public: /** @brief The name that will be used for display purposes. */ - const char *table_type() const { return rocksdb_hton_name; } + const char *table_type() const override { + DBUG_ENTER_FUNC(); + + DBUG_RETURN(rocksdb_hton_name); + } /* The following is only used by SHOW KEYS: */ - const char *index_type(uint inx) { return "LSMTREE"; } + const char *index_type(uint inx) override { + DBUG_ENTER_FUNC(); + + DBUG_RETURN("LSMTREE"); + } /** @brief The file extensions. */ - const char **bas_ext() const; + const char **bas_ext() const override; /* See if this is the same base table - this should only be true for different partitions of the same table. */ - bool same_table(const ha_rocksdb& other) const; + bool same_table(const ha_rocksdb &other) const; /** @brief This is a list of flags that indicate what functionality the storage engine implements. The current table flags are documented in handler.h */ - ulonglong table_flags() const override - { + ulonglong table_flags() const override { + DBUG_ENTER_FUNC(); + /* HA_BINLOG_STMT_CAPABLE We are saying that this engine is just statement capable to have @@ -621,12 +627,11 @@ public: If we don't set it, filesort crashes, because it assumes rowids are 1..8 byte numbers */ - return HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE | - HA_REC_NOT_IN_SEQ | HA_CAN_INDEX_BLOBS | - (m_pk_can_be_decoded? HA_PRIMARY_KEY_IN_READ_INDEX : 0) | - HA_PRIMARY_KEY_REQUIRED_FOR_POSITION | - HA_NULL_IN_KEY | - HA_PARTIAL_COLUMN_READ; + DBUG_RETURN(HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE | + HA_REC_NOT_IN_SEQ | HA_CAN_INDEX_BLOBS | + (m_pk_can_be_decoded ? HA_PRIMARY_KEY_IN_READ_INDEX : 0) | + HA_PRIMARY_KEY_REQUIRED_FOR_POSITION | HA_NULL_IN_KEY | + HA_PARTIAL_COLUMN_READ); } bool init_with_fields() override; @@ -641,61 +646,62 @@ public: If all_parts is set, MySQL wants to know the flags for the combined index, up to and including 'part'. */ - ulong index_flags(uint inx, uint part, bool all_parts) const; + ulong index_flags(uint inx, uint part, bool all_parts) const override; - const key_map * keys_to_use_for_scanning() - { - return &key_map_full; + const key_map *keys_to_use_for_scanning() override { + DBUG_ENTER_FUNC(); + + DBUG_RETURN(&key_map_full); } - bool primary_key_is_clustered() - { - return true; + bool primary_key_is_clustered() override { + DBUG_ENTER_FUNC(); + + DBUG_RETURN(true); } - bool should_store_row_debug_checksums() const - { + bool should_store_row_debug_checksums() const { return m_store_row_debug_checksums && (rand() % 100 < m_checksums_pct); } - int rename_table(const char* const from, const char* const to) - __attribute__((__nonnull__, __warn_unused_result__)); + int rename_table(const char *const from, const char *const to) override + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); - int convert_record_from_storage_format(const rocksdb::Slice* const key, - const rocksdb::Slice* const value, - uchar* const buf) - __attribute__((__nonnull__, __warn_unused_result__)); + int convert_record_from_storage_format(const rocksdb::Slice *const key, + const rocksdb::Slice *const value, + uchar *const buf) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); - int convert_record_from_storage_format(const rocksdb::Slice* const key, - uchar* const buf) - __attribute__((__nonnull__, __warn_unused_result__)); + int convert_record_from_storage_format(const rocksdb::Slice *const key, + uchar *const buf) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); - void convert_record_to_storage_format(const rocksdb::Slice& pk_packed_slice, - Rdb_string_writer* const pk_unpack_info, - rocksdb::Slice* const packed_rec) - __attribute__((__nonnull__)); + void convert_record_to_storage_format(const rocksdb::Slice &pk_packed_slice, + Rdb_string_writer *const pk_unpack_info, + rocksdb::Slice *const packed_rec) + MY_ATTRIBUTE((__nonnull__)); - static const char* get_key_name(const uint index, - const TABLE* const table_arg, - const Rdb_tbl_def* const tbl_def_arg) - __attribute__((__nonnull__, __warn_unused_result__)); + static const char *get_key_name(const uint index, + const TABLE *const table_arg, + const Rdb_tbl_def *const tbl_def_arg) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); - static const char* get_key_comment(const uint index, - const TABLE* const table_arg, - const Rdb_tbl_def* const tbl_def_arg) - __attribute__((__nonnull__, __warn_unused_result__)); + static const char *get_key_comment(const uint index, + const TABLE *const table_arg, + const Rdb_tbl_def *const tbl_def_arg) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); - static bool is_hidden_pk(const uint index, const TABLE* const table_arg, - const Rdb_tbl_def* const tbl_def_arg) - __attribute__((__nonnull__, __warn_unused_result__)); + static bool is_hidden_pk(const uint index, const TABLE *const table_arg, + const Rdb_tbl_def *const tbl_def_arg) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); - static uint pk_index(const TABLE* const table_arg, - const Rdb_tbl_def* const tbl_def_arg) - __attribute__((__nonnull__, __warn_unused_result__)); + static uint pk_index(const TABLE *const table_arg, + const Rdb_tbl_def *const tbl_def_arg) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); - static bool is_pk(const uint index, const TABLE* table_arg, - const Rdb_tbl_def* tbl_def_arg) - __attribute__((__nonnull__, __warn_unused_result__)); + static bool is_pk(const uint index, const TABLE *table_arg, + const Rdb_tbl_def *tbl_def_arg) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); /** @brief unireg.cc will call max_supported_record_length(), max_supported_keys(), @@ -704,11 +710,30 @@ public: send. Return *real* limits of your storage engine here; MySQL will do min(your_limits, MySQL_limits) automatically. */ - uint max_supported_record_length() const { return HA_MAX_REC_LENGTH; } + uint max_supported_record_length() const override { + DBUG_ENTER_FUNC(); + + DBUG_RETURN(HA_MAX_REC_LENGTH); + } + + uint max_supported_keys() const override { + DBUG_ENTER_FUNC(); + + DBUG_RETURN(MAX_INDEXES); + } + + uint max_supported_key_parts() const override { + DBUG_ENTER_FUNC(); + + DBUG_RETURN(MAX_REF_PARTS); + } + + uint max_supported_key_part_length() const override { + DBUG_ENTER_FUNC(); + + DBUG_RETURN(2048); + } - uint max_supported_keys() const { return MAX_INDEXES; } - uint max_supported_key_parts() const { return MAX_REF_PARTS; } - uint max_supported_key_part_length() const { return 2048; } /** @brief unireg.cc will call this to make sure that the storage engine can handle the data it is about to send. Return *real* limits of your storage engine @@ -718,222 +743,253 @@ public: There is no need to implement ..._key_... methods if your engine doesn't support indexes. */ - uint max_supported_key_length() const { return 16*1024; /* just to return something*/ } + uint max_supported_key_length() const override { + DBUG_ENTER_FUNC(); + + DBUG_RETURN(16 * 1024); /* just to return something*/ + } /** TODO: return actual upper bound of number of records in the table. (e.g. save number of records seen on full table scan and/or use file size as upper bound) */ - ha_rows estimate_rows_upper_bound() { return HA_POS_ERROR; } + ha_rows estimate_rows_upper_bound() override { + DBUG_ENTER_FUNC(); + + DBUG_RETURN(HA_POS_ERROR); + } - /* At the moment, we're ok with default handler::index_init() implementation. */ - int index_read_map(uchar* const buf, const uchar* const key, + /* At the moment, we're ok with default handler::index_init() implementation. + */ + int index_read_map(uchar *const buf, const uchar *const key, key_part_map keypart_map, - enum ha_rkey_function find_flag); - __attribute__((__warn_unused_result__)); + enum ha_rkey_function find_flag) override + MY_ATTRIBUTE((__warn_unused_result__)); - int index_read_map_impl(uchar* const buf, const uchar* const key, + int index_read_map_impl(uchar *const buf, const uchar *const key, key_part_map keypart_map, enum ha_rkey_function find_flag, - const key_range* end_key) - __attribute__((__warn_unused_result__));; + const key_range *end_key) + MY_ATTRIBUTE((__warn_unused_result__)); - int index_read_last_map(uchar* const buf, const uchar* const key, - key_part_map keypart_map) - __attribute__((__warn_unused_result__));; + int index_read_last_map(uchar *const buf, const uchar *const key, + key_part_map keypart_map) override + MY_ATTRIBUTE((__warn_unused_result__)); - int read_range_first(const key_range* const start_key, - const key_range* const end_key, - bool eq_range, bool sorted) - __attribute__((__warn_unused_result__));; + int read_range_first(const key_range *const start_key, + const key_range *const end_key, bool eq_range, + bool sorted) override + MY_ATTRIBUTE((__warn_unused_result__)); + + virtual double scan_time() override { + DBUG_ENTER_FUNC(); + + DBUG_RETURN( + static_cast<double>((stats.records + stats.deleted) / 20.0 + 10)); + } - virtual double scan_time() { return (double) (stats.records+stats.deleted) / 20.0+10; } virtual double read_time(uint, uint, ha_rows rows) override; - int open(const char* const name, int mode, uint test_if_locked) - __attribute__((__warn_unused_result__)); - int close(void) __attribute__((__warn_unused_result__)); - - int write_row(uchar* const buf) __attribute__((__warn_unused_result__)); - int update_row(const uchar* const old_data, uchar* const new_data) - __attribute__((__warn_unused_result__)); - int delete_row(const uchar* const buf) - __attribute__((__warn_unused_result__)); - rocksdb::Status delete_or_singledelete(uint index, - Rdb_transaction* const tx, - rocksdb::ColumnFamilyHandle* const cf, - const rocksdb::Slice& key) - __attribute__((__warn_unused_result__)); - - int index_next(uchar* const buf) __attribute__((__warn_unused_result__)); - int index_next_with_direction(uchar* const buf, bool move_forward) - __attribute__((__warn_unused_result__)); - int index_prev(uchar* const buf) __attribute__((__warn_unused_result__)); - - int index_first(uchar* const buf) __attribute__((__warn_unused_result__)); - int index_last(uchar* const buf) __attribute__((__warn_unused_result__)); - - class Item* idx_cond_push(uint keyno, class Item* const idx_cond); + int open(const char *const name, int mode, uint test_if_locked) override + MY_ATTRIBUTE((__warn_unused_result__)); + int close(void) override MY_ATTRIBUTE((__warn_unused_result__)); + + int write_row(uchar *const buf) override + MY_ATTRIBUTE((__warn_unused_result__)); + int update_row(const uchar *const old_data, uchar *const new_data) override + MY_ATTRIBUTE((__warn_unused_result__)); + int delete_row(const uchar *const buf) override + MY_ATTRIBUTE((__warn_unused_result__)); + rocksdb::Status delete_or_singledelete(uint index, Rdb_transaction *const tx, + rocksdb::ColumnFamilyHandle *const cf, + const rocksdb::Slice &key) + MY_ATTRIBUTE((__warn_unused_result__)); + + int index_next(uchar *const buf) override + MY_ATTRIBUTE((__warn_unused_result__)); + int index_next_with_direction(uchar *const buf, bool move_forward) + MY_ATTRIBUTE((__warn_unused_result__)); + int index_prev(uchar *const buf) override + MY_ATTRIBUTE((__warn_unused_result__)); + + int index_first(uchar *const buf) override + MY_ATTRIBUTE((__warn_unused_result__)); + int index_last(uchar *const buf) override + MY_ATTRIBUTE((__warn_unused_result__)); + + class Item *idx_cond_push(uint keyno, class Item *const idx_cond) override; /* Default implementation from cancel_pushed_idx_cond() suits us */ private: - struct key_def_cf_info - { - rocksdb::ColumnFamilyHandle* cf_handle; + struct key_def_cf_info { + rocksdb::ColumnFamilyHandle *cf_handle; bool is_reverse_cf; bool is_auto_cf; }; - struct update_row_info - { - Rdb_transaction* tx; - const uchar* new_data; - const uchar* old_data; - rocksdb::Slice new_pk_slice; - rocksdb::Slice old_pk_slice; + struct update_row_info { + Rdb_transaction *tx; + const uchar *new_data; + const uchar *old_data; + rocksdb::Slice new_pk_slice; + rocksdb::Slice old_pk_slice; // "unpack_info" data for the new PK value Rdb_string_writer *new_pk_unpack_info; - longlong hidden_pk_id; - bool skip_unique_check; + longlong hidden_pk_id; + bool skip_unique_check; }; - int create_cfs(const TABLE* const table_arg, Rdb_tbl_def* const tbl_def_arg, - std::array<struct key_def_cf_info, MAX_INDEXES + 1>* const cfs) const; - __attribute__((__nonnull__, __warn_unused_result__)); - - int create_key_def(const TABLE* const table_arg, const uint &i, - const Rdb_tbl_def* const tbl_def_arg, - std::shared_ptr<Rdb_key_def>* const new_key_def, - const struct key_def_cf_info& cf_info) const; - __attribute__((__nonnull__, __warn_unused_result__)); - - int create_inplace_key_defs(const TABLE* const table_arg, - Rdb_tbl_def* vtbl_def_arg, - const TABLE* const old_table_arg, - const Rdb_tbl_def* const old_tbl_def_arg, - const std::array<key_def_cf_info, MAX_INDEXES + 1>& cfs) const; - __attribute__((__nonnull__, __warn_unused_result__)); - - std::unordered_map<std::string, uint> get_old_key_positions( - const TABLE* table_arg, - const Rdb_tbl_def* tbl_def_arg, - const TABLE* old_table_arg, - const Rdb_tbl_def* old_tbl_def_arg) const - __attribute__((__nonnull__)); - - int compare_key_parts(const KEY* const old_key, - const KEY* const new_key) const; - __attribute__((__nonnull__, __warn_unused_result__)); + /* + Used to check for duplicate entries during fast unique secondary index + creation. + */ + struct unique_sk_buf_info { + bool sk_buf_switch = false; + rocksdb::Slice sk_memcmp_key; + rocksdb::Slice sk_memcmp_key_old; + uchar *dup_sk_buf; + uchar *dup_sk_buf_old; + + /* + This method is meant to be called back to back during inplace creation + of unique indexes. It will switch between two buffers, which + will each store the memcmp form of secondary keys, which are then + converted to slices in sk_memcmp_key or sk_memcmp_key_old. + + Switching buffers on each iteration allows us to retain the + sk_memcmp_key_old value for duplicate comparison. + */ + inline uchar *swap_and_get_sk_buf() { + sk_buf_switch = !sk_buf_switch; + return sk_buf_switch ? dup_sk_buf : dup_sk_buf_old; + } + }; + + int create_cfs(const TABLE *const table_arg, Rdb_tbl_def *const tbl_def_arg, + std::array<struct key_def_cf_info, MAX_INDEXES + 1> *const cfs) + const MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); + + int create_key_def(const TABLE *const table_arg, const uint &i, + const Rdb_tbl_def *const tbl_def_arg, + std::shared_ptr<Rdb_key_def> *const new_key_def, + const struct key_def_cf_info &cf_info) const + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); + + int create_inplace_key_defs( + const TABLE *const table_arg, Rdb_tbl_def *vtbl_def_arg, + const TABLE *const old_table_arg, + const Rdb_tbl_def *const old_tbl_def_arg, + const std::array<key_def_cf_info, MAX_INDEXES + 1> &cfs) const + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); + + std::unordered_map<std::string, uint> + get_old_key_positions(const TABLE *table_arg, const Rdb_tbl_def *tbl_def_arg, + const TABLE *old_table_arg, + const Rdb_tbl_def *old_tbl_def_arg) const + MY_ATTRIBUTE((__nonnull__)); + + int compare_key_parts(const KEY *const old_key, + const KEY *const new_key) const; + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); int index_first_intern(uchar *buf) - __attribute__((__nonnull__, __warn_unused_result__)); + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); int index_last_intern(uchar *buf) - __attribute__((__nonnull__, __warn_unused_result__)); + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); enum icp_result check_index_cond() const; - int find_icp_matching_index_rec(const bool &move_forward, uchar* const buf) - __attribute__((__nonnull__, __warn_unused_result__)); + int find_icp_matching_index_rec(const bool &move_forward, uchar *const buf) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); void calc_updated_indexes(); - int update_write_row(const uchar* const old_data, const uchar* const new_data, + int update_write_row(const uchar *const old_data, const uchar *const new_data, const bool skip_unique_check) - __attribute__((__warn_unused_result__)); - int get_pk_for_update(struct update_row_info* const row_info); + MY_ATTRIBUTE((__warn_unused_result__)); + int get_pk_for_update(struct update_row_info *const row_info); int check_and_lock_unique_pk(const uint &key_id, - const struct update_row_info& row_info, - bool* const found, bool* const pk_changed) - __attribute__((__warn_unused_result__)); + const struct update_row_info &row_info, + bool *const found, bool *const pk_changed) + MY_ATTRIBUTE((__warn_unused_result__)); int check_and_lock_sk(const uint &key_id, - const struct update_row_info& row_info, - bool* const found) const - __attribute__((__warn_unused_result__)); - int check_uniqueness_and_lock(const struct update_row_info& row_info, - bool* const pk_changed) - __attribute__((__warn_unused_result__)); - bool over_bulk_load_threshold(int* err) - __attribute__((__warn_unused_result__)); - int bulk_load_key(Rdb_transaction* const tx, - const Rdb_key_def& kd, - const rocksdb::Slice& key, - const rocksdb::Slice& value) - __attribute__((__nonnull__, __warn_unused_result__)); - int update_pk(const Rdb_key_def& kd, - const struct update_row_info& row_info, - const bool &pk_changed) - __attribute__((__warn_unused_result__)); - int update_sk(const TABLE* const table_arg, - const Rdb_key_def& kd, - const struct update_row_info& row_info) - __attribute__((__warn_unused_result__)); - int update_indexes(const struct update_row_info& row_info, + const struct update_row_info &row_info, + bool *const found) const + MY_ATTRIBUTE((__warn_unused_result__)); + int check_uniqueness_and_lock(const struct update_row_info &row_info, + bool *const pk_changed) + MY_ATTRIBUTE((__warn_unused_result__)); + bool over_bulk_load_threshold(int *err) + MY_ATTRIBUTE((__warn_unused_result__)); + int check_duplicate_sk(const TABLE *table_arg, const Rdb_key_def &index, + const rocksdb::Slice *key, + struct unique_sk_buf_info *sk_info) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); + int bulk_load_key(Rdb_transaction *const tx, const Rdb_key_def &kd, + const rocksdb::Slice &key, const rocksdb::Slice &value) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); + int update_pk(const Rdb_key_def &kd, const struct update_row_info &row_info, + const bool &pk_changed) MY_ATTRIBUTE((__warn_unused_result__)); + int update_sk(const TABLE *const table_arg, const Rdb_key_def &kd, + const struct update_row_info &row_info) + MY_ATTRIBUTE((__warn_unused_result__)); + int update_indexes(const struct update_row_info &row_info, const bool &pk_changed) - __attribute__((__warn_unused_result__)); - - int read_key_exact(const Rdb_key_def& kd, - rocksdb::Iterator* const iter, const bool &using_full_key, - const rocksdb::Slice& key_slice) const - __attribute__((__nonnull__, __warn_unused_result__)); - int read_before_key(const Rdb_key_def& kd, - const bool &using_full_key, - const rocksdb::Slice& key_slice) - __attribute__((__nonnull__, __warn_unused_result__)); - int read_after_key(const Rdb_key_def& kd, + MY_ATTRIBUTE((__warn_unused_result__)); + + int read_key_exact(const Rdb_key_def &kd, rocksdb::Iterator *const iter, const bool &using_full_key, - const rocksdb::Slice& key_slice) - __attribute__((__nonnull__, __warn_unused_result__)); - - int position_to_correct_key(const Rdb_key_def& kd, - const enum ha_rkey_function &find_flag, - const bool &full_key_match, - const uchar* const key, - const key_part_map &keypart_map, - const rocksdb::Slice& key_slice, - bool* const move_forward) - __attribute__((__warn_unused_result__)); - - int read_row_from_primary_key(uchar* const buf) - __attribute__((__nonnull__, __warn_unused_result__)); - int read_row_from_secondary_key(uchar* const buf, - const Rdb_key_def& kd, + const rocksdb::Slice &key_slice) const + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); + int read_before_key(const Rdb_key_def &kd, const bool &using_full_key, + const rocksdb::Slice &key_slice) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); + int read_after_key(const Rdb_key_def &kd, const bool &using_full_key, + const rocksdb::Slice &key_slice) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); + + int position_to_correct_key( + const Rdb_key_def &kd, const enum ha_rkey_function &find_flag, + const bool &full_key_match, const uchar *const key, + const key_part_map &keypart_map, const rocksdb::Slice &key_slice, + bool *const move_forward) MY_ATTRIBUTE((__warn_unused_result__)); + + int read_row_from_primary_key(uchar *const buf) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); + int read_row_from_secondary_key(uchar *const buf, const Rdb_key_def &kd, bool move_forward) - __attribute__((__nonnull__, __warn_unused_result__)); - int try_keyonly_read_from_sk(uchar* buf, - const Rdb_key_def& kd, - const rocksdb::Slice& key, - const rocksdb::Slice& value, - uint rowid_size) - __attribute__((__nonnull__, __warn_unused_result__)); - - int calc_eq_cond_len(const Rdb_key_def& kd, + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); + + int calc_eq_cond_len(const Rdb_key_def &kd, const enum ha_rkey_function &find_flag, - const rocksdb::Slice& slice, + const rocksdb::Slice &slice, const int &bytes_changed_by_succ, - const key_range* const end_key, - uint* const end_key_packed_size) - __attribute__((__warn_unused_result__)); + const key_range *const end_key, + uint *const end_key_packed_size) + MY_ATTRIBUTE((__warn_unused_result__)); - Rdb_tbl_def* get_table_if_exists(const char* const tablename) - __attribute__((__nonnull__, __warn_unused_result__)); - void read_thd_vars(THD* const thd) - __attribute__((__nonnull__)); - const char* thd_rocksdb_tmpdir() - __attribute__((__nonnull__, __warn_unused_result__)); + Rdb_tbl_def *get_table_if_exists(const char *const tablename) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); + void read_thd_vars(THD *const thd) MY_ATTRIBUTE((__nonnull__)); + const char *thd_rocksdb_tmpdir() + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); - bool contains_foreign_key(THD* const thd) - __attribute__((__nonnull__, __warn_unused_result__)); + bool contains_foreign_key(THD *const thd) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); - int inplace_populate_sk(const TABLE* const table_arg, - const std::unordered_set<std::shared_ptr<Rdb_key_def>>& indexes); + int inplace_populate_sk( + TABLE *const table_arg, + const std::unordered_set<std::shared_ptr<Rdb_key_def>> &indexes) + MY_ATTRIBUTE((__nonnull__, __warn_unused_result__)); public: - int index_init(uint idx, bool sorted) __attribute__((__warn_unused_result__)); - int index_end() __attribute__((__warn_unused_result__)); + int index_init(uint idx, bool sorted) override + MY_ATTRIBUTE((__warn_unused_result__)); + int index_end() override MY_ATTRIBUTE((__warn_unused_result__)); - void unlock_row(); + void unlock_row() override; /** @brief Unlike index_init(), rnd_init() can be called two consecutive times @@ -943,107 +999,114 @@ public: cursor to the start of the table; no need to deallocate and allocate it again. This is a required method. */ - int rnd_init(bool scan) __attribute__((__warn_unused_result__)); - int rnd_end() __attribute__((__warn_unused_result__)); + int rnd_init(bool scan) override MY_ATTRIBUTE((__warn_unused_result__)); + int rnd_end() override MY_ATTRIBUTE((__warn_unused_result__)); - int rnd_next(uchar* const buf) __attribute__((__warn_unused_result__)); - int rnd_next_with_direction(uchar* const buf, bool move_forward) - __attribute__((__warn_unused_result__)); + int rnd_next(uchar *const buf) override + MY_ATTRIBUTE((__warn_unused_result__)); + int rnd_next_with_direction(uchar *const buf, bool move_forward) + MY_ATTRIBUTE((__warn_unused_result__)); - int rnd_pos(uchar* const buf, uchar* const pos) - __attribute__((__warn_unused_result__)); - void position(const uchar* const record); + int rnd_pos(uchar *const buf, uchar *const pos) override + MY_ATTRIBUTE((__warn_unused_result__)); + void position(const uchar *const record) override; int info(uint) override; /* This function will always return success, therefore no annotation related * to checking the return value. Can't change the signature because it's * required by the interface. */ - int extra(enum ha_extra_function operation); + int extra(enum ha_extra_function operation) override; - int start_stmt(THD* const thd, thr_lock_type lock_type) - __attribute__((__warn_unused_result__)); - int external_lock(THD* const thd, int lock_type) - __attribute__((__warn_unused_result__)); - int delete_all_rows(ha_rows* const nrows) __attribute__((__warn_unused_result__)); - int truncate() __attribute__((__warn_unused_result__)); + int start_stmt(THD *const thd, thr_lock_type lock_type) override + MY_ATTRIBUTE((__warn_unused_result__)); + int external_lock(THD *const thd, int lock_type) override + MY_ATTRIBUTE((__warn_unused_result__)); + int truncate() override MY_ATTRIBUTE((__warn_unused_result__)); + + int reset() override { + DBUG_ENTER_FUNC(); - int reset() override - { /* Free blob data */ m_retrieved_record.clear(); - return 0; + + DBUG_RETURN(HA_EXIT_SUCCESS); } - int check(THD* const thd, HA_CHECK_OPT* const check_opt) - __attribute__((__warn_unused_result__)); - void remove_rows(Rdb_tbl_def* const tbl); - ha_rows records_in_range(uint inx, key_range* const min_key, - key_range* const max_key) - __attribute__((__warn_unused_result__)); - int delete_table(const char* const from) __attribute__((__warn_unused_result__)); - int create(const char* const name, TABLE* const form, - HA_CREATE_INFO* const create_info) - __attribute__((__warn_unused_result__)); - bool check_if_incompatible_data(HA_CREATE_INFO* const info, - uint table_changes) - __attribute__((__warn_unused_result__)); - - THR_LOCK_DATA **store_lock(THD* const thd, THR_LOCK_DATA **to, - enum thr_lock_type lock_type) - __attribute__((__warn_unused_result__)); - - my_bool register_query_cache_table(THD* const thd, char* const table_key, + int check(THD *const thd, HA_CHECK_OPT *const check_opt) override + MY_ATTRIBUTE((__warn_unused_result__)); + void remove_rows(Rdb_tbl_def *const tbl); + ha_rows records_in_range(uint inx, key_range *const min_key, + key_range *const max_key) override + MY_ATTRIBUTE((__warn_unused_result__)); + int delete_table(const char *const from) override + MY_ATTRIBUTE((__warn_unused_result__)); + int create(const char *const name, TABLE *const form, + HA_CREATE_INFO *const create_info) override + MY_ATTRIBUTE((__warn_unused_result__)); + bool check_if_incompatible_data(HA_CREATE_INFO *const info, + uint table_changes) override + MY_ATTRIBUTE((__warn_unused_result__)); + + THR_LOCK_DATA **store_lock(THD *const thd, THR_LOCK_DATA **to, + enum thr_lock_type lock_type) override + MY_ATTRIBUTE((__warn_unused_result__)); + + my_bool register_query_cache_table(THD *const thd, char *const table_key, uint key_length, - qc_engine_callback* const engine_callback, - ulonglong* const engine_data) - { + qc_engine_callback *const engine_callback, + ulonglong *const engine_data) override { + DBUG_ENTER_FUNC(); + /* Currently, we don't support query cache */ - return FALSE; + DBUG_RETURN(FALSE); } - bool get_error_message(const int error, String* const buf) - __attribute__((__nonnull__)); + bool get_error_message(const int error, String *const buf) override + MY_ATTRIBUTE((__nonnull__)); void get_auto_increment(ulonglong offset, ulonglong increment, ulonglong nb_desired_values, - ulonglong* const first_value, - ulonglong* const nb_reserved_values); - void update_create_info(HA_CREATE_INFO* const create_info); - int optimize(THD* const thd, HA_CHECK_OPT* const check_opt) - __attribute__((__warn_unused_result__)); - int analyze(THD* const thd, HA_CHECK_OPT* const check_opt) - __attribute__((__warn_unused_result__)); - int calculate_stats(const TABLE* const table_arg, THD* const thd, - HA_CHECK_OPT* const check_opt) - __attribute__((__warn_unused_result__)); + ulonglong *const first_value, + ulonglong *const nb_reserved_values) override; + void update_create_info(HA_CREATE_INFO *const create_info) override; + int optimize(THD *const thd, HA_CHECK_OPT *const check_opt) override + MY_ATTRIBUTE((__warn_unused_result__)); + int analyze(THD *const thd, HA_CHECK_OPT *const check_opt) override + MY_ATTRIBUTE((__warn_unused_result__)); + int calculate_stats(const TABLE *const table_arg, THD *const thd, + HA_CHECK_OPT *const check_opt) + MY_ATTRIBUTE((__warn_unused_result__)); enum_alter_inplace_result check_if_supported_inplace_alter( - TABLE *altered_table, - my_core::Alter_inplace_info* const ha_alter_info) override; + TABLE *altered_table, + my_core::Alter_inplace_info *const ha_alter_info) override; - bool prepare_inplace_alter_table(TABLE* const altered_table, - my_core::Alter_inplace_info* const ha_alter_info); + bool prepare_inplace_alter_table( + TABLE *const altered_table, + my_core::Alter_inplace_info *const ha_alter_info) override; - bool inplace_alter_table(TABLE* const altered_table, - my_core::Alter_inplace_info* const ha_alter_info); + bool inplace_alter_table( + TABLE *const altered_table, + my_core::Alter_inplace_info *const ha_alter_info) override; - bool commit_inplace_alter_table(TABLE* const altered_table, - my_core::Alter_inplace_info* const ha_alter_info, - bool commit); + bool + commit_inplace_alter_table(TABLE *const altered_table, + my_core::Alter_inplace_info *const ha_alter_info, + bool commit) override; - int finalize_bulk_load() __attribute__((__warn_unused_result__)); + int finalize_bulk_load() MY_ATTRIBUTE((__warn_unused_result__)); - void set_use_read_free_rpl(const char* const whitelist); - void set_skip_unique_check_tables(const char* const whitelist); + void set_use_read_free_rpl(const char *const whitelist); + void set_skip_unique_check_tables(const char *const whitelist); - public: +public: virtual void rpl_before_delete_rows() override; virtual void rpl_after_delete_rows() override; virtual void rpl_before_update_rows() override; virtual void rpl_after_update_rows() override; virtual bool use_read_free_rpl(); - private: +private: /* Flags tracking if we are inside different replication operation */ bool m_in_rpl_delete_rows; bool m_in_rpl_update_rows; @@ -1055,16 +1118,15 @@ public: Helper class for in-place alter, for storing handler context between inplace alter calls */ -struct Rdb_inplace_alter_ctx : public my_core::inplace_alter_handler_ctx -{ +struct Rdb_inplace_alter_ctx : public my_core::inplace_alter_handler_ctx { /* The new table definition */ - Rdb_tbl_def* const m_new_tdef; + Rdb_tbl_def *const m_new_tdef; /* Stores the original key definitions */ - std::shared_ptr<Rdb_key_def>* const m_old_key_descr; + std::shared_ptr<Rdb_key_def> *const m_old_key_descr; /* Stores the new key definitions */ - std::shared_ptr<Rdb_key_def>* m_new_key_descr; + std::shared_ptr<Rdb_key_def> *m_new_key_descr; /* Stores the old number of key definitions */ const uint m_old_n_keys; @@ -1085,28 +1147,24 @@ struct Rdb_inplace_alter_ctx : public my_core::inplace_alter_handler_ctx const uint m_n_dropped_keys; Rdb_inplace_alter_ctx( - Rdb_tbl_def* new_tdef, std::shared_ptr<Rdb_key_def>* old_key_descr, - std::shared_ptr<Rdb_key_def>* new_key_descr, uint old_n_keys, + Rdb_tbl_def *new_tdef, std::shared_ptr<Rdb_key_def> *old_key_descr, + std::shared_ptr<Rdb_key_def> *new_key_descr, uint old_n_keys, uint new_n_keys, std::unordered_set<std::shared_ptr<Rdb_key_def>> added_indexes, - std::unordered_set<GL_INDEX_ID> dropped_index_ids, - uint n_added_keys, uint n_dropped_keys) : - my_core::inplace_alter_handler_ctx(), m_new_tdef(new_tdef), - m_old_key_descr(old_key_descr), m_new_key_descr(new_key_descr), - m_old_n_keys(old_n_keys), m_new_n_keys(new_n_keys), - m_added_indexes(added_indexes), - m_dropped_index_ids(dropped_index_ids), - m_n_added_keys(n_added_keys), - m_n_dropped_keys(n_dropped_keys) - { - } + std::unordered_set<GL_INDEX_ID> dropped_index_ids, uint n_added_keys, + uint n_dropped_keys) + : my_core::inplace_alter_handler_ctx(), m_new_tdef(new_tdef), + m_old_key_descr(old_key_descr), m_new_key_descr(new_key_descr), + m_old_n_keys(old_n_keys), m_new_n_keys(new_n_keys), + m_added_indexes(added_indexes), m_dropped_index_ids(dropped_index_ids), + m_n_added_keys(n_added_keys), m_n_dropped_keys(n_dropped_keys) {} - ~Rdb_inplace_alter_ctx(){} + ~Rdb_inplace_alter_ctx() {} - private: +private: /* Disable Copying */ - Rdb_inplace_alter_ctx(const Rdb_inplace_alter_ctx&); - Rdb_inplace_alter_ctx& operator=(const Rdb_inplace_alter_ctx&); + Rdb_inplace_alter_ctx(const Rdb_inplace_alter_ctx &); + Rdb_inplace_alter_ctx &operator=(const Rdb_inplace_alter_ctx &); }; -} // namespace myrocks +} // namespace myrocks |