Skip to content

Commit

Permalink
Added "override" to ha_heap.h, ha_myisam.h, ha_myisammrg.h and ha_seq…
Browse files Browse the repository at this point in the history 
…uence.h

Added override to a few functions in ha_partition.h
  • Loading branch information
@montywi @spetrunia
montywi authored and spetrunia committed Feb 3, 2023
1 parent d645025 commit c1512b1
Show file tree
Hide file tree
Showing 6 changed files with 207 additions and 197 deletions.
2 changes: 1 addition & 1 deletion sql/json_table.cc
View file
Expand Up @@ -246,7 +246,7 @@ class ha_json_table: public handler
int open(const char *name, int mode, uint test_if_locked) override
{ return 0; }
int close(void) override { return 0; }
void update_optimizer_costs(OPTIMIZER_COSTS *costs)
void update_optimizer_costs(OPTIMIZER_COSTS *costs) override
{
memcpy(costs, &heap_optimizer_costs, sizeof(*costs));
}
Expand Down
4 changes: 2 additions & 2 deletions sql/rowid_filter.h
View file
Expand Up @@ -265,7 +265,7 @@ class Range_rowid_filter: public Rowid_filter

~Range_rowid_filter();

bool build() { return fill(); }
bool build() override { return fill(); }

bool check(char *elem) override
{
Expand Down Expand Up @@ -374,7 +374,7 @@ class Rowid_filter_sorted_array: public Rowid_filter_container
uint elements() override { return refpos_container.elements(); }

void sort (int (*cmp) (void *ctxt, const void *el1, const void *el2),
void *cmp_arg)
void *cmp_arg) override
{
return refpos_container.sort(cmp, cmp_arg);
}
Expand Down
100 changes: 51 additions & 49 deletions storage/heap/ha_heap.h
View file
Expand Up @@ -37,87 +37,89 @@ class ha_heap final : public handler
public:
ha_heap(handlerton *hton, TABLE_SHARE *table);
~ha_heap() {}
handler *clone(const char *name, MEM_ROOT *mem_root);
const char *index_type(uint inx)
handler *clone(const char *name, MEM_ROOT *mem_root) override;
const char *index_type(uint inx) override
{
return ((table_share->key_info[inx].algorithm == HA_KEY_ALG_BTREE) ?
"BTREE" : "HASH");
}
/* Rows also use a fixed-size format */
enum row_type get_row_type() const { return ROW_TYPE_FIXED; }
ulonglong table_flags() const
enum row_type get_row_type() const override { return ROW_TYPE_FIXED; }
ulonglong table_flags() const override
{
return (HA_FAST_KEY_READ | HA_NO_BLOBS | HA_NULL_IN_KEY |
HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE |
HA_CAN_SQL_HANDLER | HA_CAN_ONLINE_BACKUPS |
HA_REC_NOT_IN_SEQ | HA_CAN_INSERT_DELAYED | HA_NO_TRANSACTIONS |
HA_HAS_RECORDS | HA_STATS_RECORDS_IS_EXACT | HA_CAN_HASH_KEYS);
}
ulong index_flags(uint inx, uint part, bool all_parts) const
ulong index_flags(uint inx, uint part, bool all_parts) const override
{
return ((table_share->key_info[inx].algorithm == HA_KEY_ALG_BTREE) ?
HA_READ_NEXT | HA_READ_PREV | HA_READ_ORDER | HA_READ_RANGE :
HA_ONLY_WHOLE_INDEX | HA_KEY_SCAN_NOT_ROR);
}
const key_map *keys_to_use_for_scanning() { return &btree_keys; }
uint max_supported_keys() const { return MAX_KEY; }
uint max_supported_key_part_length() const { return MAX_KEY_LENGTH; }
const key_map *keys_to_use_for_scanning() override { return &btree_keys; }
uint max_supported_keys() const override { return MAX_KEY; }
uint max_supported_key_part_length() const override { return MAX_KEY_LENGTH; }
IO_AND_CPU_COST scan_time() override;
IO_AND_CPU_COST keyread_time(uint index, ulong ranges, ha_rows rows,
ulonglong blocks) override;
IO_AND_CPU_COST rnd_pos_time(ha_rows rows) override;
/* 0 for avg_io_cost ensures that there are no read-block calculations */

int open(const char *name, int mode, uint test_if_locked);
int close(void);
void set_keys_for_scanning(void);
int write_row(const uchar * buf);
int update_row(const uchar * old_data, const uchar * new_data);
int delete_row(const uchar * buf);
virtual void get_auto_increment(ulonglong offset, ulonglong increment,
ulonglong nb_desired_values,
ulonglong *first_value,
ulonglong *nb_reserved_values);
int open(const char *name, int mode, uint test_if_locked) override;
int close(void) override;
int write_row(const uchar * buf) override;
int update_row(const uchar * old_data, const uchar * new_data) override;
int delete_row(const uchar * buf) override;
void get_auto_increment(ulonglong offset, ulonglong increment,
ulonglong nb_desired_values,
ulonglong *first_value,
ulonglong *nb_reserved_values) override;
int index_read_map(uchar * buf, const uchar * key, key_part_map keypart_map,
enum ha_rkey_function find_flag);
int index_read_last_map(uchar *buf, const uchar *key, key_part_map keypart_map);
enum ha_rkey_function find_flag) override;
int index_read_last_map(uchar *buf, const uchar *key, key_part_map keypart_map)
override;
int index_read_idx_map(uchar * buf, uint index, const uchar * key,
key_part_map keypart_map,
enum ha_rkey_function find_flag);
int index_next(uchar * buf);
int index_prev(uchar * buf);
int index_first(uchar * buf);
int index_last(uchar * buf);
int rnd_init(bool scan);
int rnd_next(uchar *buf);
int rnd_pos(uchar * buf, uchar *pos);
void position(const uchar *record);
int can_continue_handler_scan();
int info(uint);
int extra(enum ha_extra_function operation);
int reset();
int external_lock(THD *thd, int lock_type);
int delete_all_rows(void);
int reset_auto_increment(ulonglong value);
int disable_indexes(uint mode);
int enable_indexes(uint mode);
int indexes_are_disabled(void);
enum ha_rkey_function find_flag) override;
int index_next(uchar * buf) override;
int index_prev(uchar * buf) override;
int index_first(uchar * buf) override;
int index_last(uchar * buf) override;
int rnd_init(bool scan) override;
int rnd_next(uchar *buf) override;
int rnd_pos(uchar * buf, uchar *pos) override;
void position(const uchar *record) override;
int can_continue_handler_scan() override;
int info(uint) override;
int extra(enum ha_extra_function operation) override;
int reset() override;
int external_lock(THD *thd, int lock_type) override;
int delete_all_rows(void) override;
int reset_auto_increment(ulonglong value) override;
int disable_indexes(uint mode) override;
int enable_indexes(uint mode) override;
int indexes_are_disabled(void) override;
ha_rows records_in_range(uint inx, const key_range *start_key,
const key_range *end_key, page_range *pages);
int delete_table(const char *from);
void drop_table(const char *name);
int rename_table(const char * from, const char * to);
int create(const char *name, TABLE *form, HA_CREATE_INFO *create_info);
void update_create_info(HA_CREATE_INFO *create_info);
const key_range *end_key, page_range *pages) override;
int delete_table(const char *from) override;
void drop_table(const char *name) override;
int rename_table(const char * from, const char * to) override;
int create(const char *name, TABLE *form, HA_CREATE_INFO *create_info) override;
void update_create_info(HA_CREATE_INFO *create_info) override;

THR_LOCK_DATA **store_lock(THD *thd, THR_LOCK_DATA **to,
enum thr_lock_type lock_type);
int cmp_ref(const uchar *ref1, const uchar *ref2)
enum thr_lock_type lock_type) override;
int cmp_ref(const uchar *ref1, const uchar *ref2) override
{
return memcmp(ref1, ref2, sizeof(HEAP_PTR));
}
bool check_if_incompatible_data(HA_CREATE_INFO *info, uint table_changes);
int find_unique_row(uchar *record, uint unique_idx);
bool check_if_incompatible_data(HA_CREATE_INFO *info, uint table_changes)
override;
int find_unique_row(uchar *record, uint unique_idx) override;
private:
void update_key_stats();
void set_keys_for_scanning(void);
};
156 changes: 80 additions & 76 deletions storage/myisam/ha_myisam.h
View file
Expand Up @@ -54,34 +54,35 @@ class ha_myisam final : public handler
public:
ha_myisam(handlerton *hton, TABLE_SHARE *table_arg);
~ha_myisam() {}
handler *clone(const char *name, MEM_ROOT *mem_root);
const char *index_type(uint key_number);
ulonglong table_flags() const { return int_table_flags; }
int index_init(uint idx, bool sorted);
int index_end();
int rnd_end();

ulong index_flags(uint inx, uint part, bool all_parts) const;
uint max_supported_keys() const { return MI_MAX_KEY; }
uint max_supported_key_parts() const { return HA_MAX_KEY_SEG; }
uint max_supported_key_length() const { return HA_MAX_KEY_LENGTH; }
uint max_supported_key_part_length() const { return HA_MAX_KEY_LENGTH; }
void change_table_ptr(TABLE *table_arg, TABLE_SHARE *share);
int open(const char *name, int mode, uint test_if_locked);
int close(void);
int write_row(const uchar * buf);
int update_row(const uchar * old_data, const uchar * new_data);
int delete_row(const uchar * buf);
handler *clone(const char *name, MEM_ROOT *mem_root) override;
const char *index_type(uint key_number) override;
ulonglong table_flags() const override { return int_table_flags; }
int index_init(uint idx, bool sorted) override;
int index_end() override;
int rnd_end() override;

ulong index_flags(uint inx, uint part, bool all_parts) const override;
uint max_supported_keys() const override { return MI_MAX_KEY; }
uint max_supported_key_parts() const override { return HA_MAX_KEY_SEG; }
uint max_supported_key_length() const override { return HA_MAX_KEY_LENGTH; }
uint max_supported_key_part_length() const override
{ return HA_MAX_KEY_LENGTH; }
void change_table_ptr(TABLE *table_arg, TABLE_SHARE *share) override;
int open(const char *name, int mode, uint test_if_locked) override;
int close(void) override;
int write_row(const uchar * buf) override;
int update_row(const uchar * old_data, const uchar * new_data) override;
int delete_row(const uchar * buf) override;
int index_read_map(uchar *buf, const uchar *key, key_part_map keypart_map,
enum ha_rkey_function find_flag);
enum ha_rkey_function find_flag) override;
int index_read_idx_map(uchar *buf, uint index, const uchar *key,
key_part_map keypart_map,
enum ha_rkey_function find_flag);
int index_next(uchar * buf);
int index_prev(uchar * buf);
int index_first(uchar * buf);
int index_last(uchar * buf);
int index_next_same(uchar *buf, const uchar *key, uint keylen);
enum ha_rkey_function find_flag) override;
int index_next(uchar * buf) override;
int index_prev(uchar * buf) override;
int index_first(uchar * buf) override;
int index_last(uchar * buf) override;
int index_next_same(uchar *buf, const uchar *key, uint keylen) override;
int ft_init() override
{
if (!ft_handler)
Expand All @@ -95,88 +96,91 @@ class ha_myisam final : public handler
(uchar *)key->ptr(), key->length(), key->charset(),
table->record[0]);
}
int ft_read(uchar *buf);
int rnd_init(bool scan);
int rnd_next(uchar *buf);
int rnd_pos(uchar * buf, uchar *pos);
int remember_rnd_pos();
int restart_rnd_next(uchar *buf);
void position(const uchar *record);
int ft_read(uchar *buf) override;
int rnd_init(bool scan) override;
int rnd_next(uchar *buf) override;
int rnd_pos(uchar * buf, uchar *pos) override;
int remember_rnd_pos() override;
int restart_rnd_next(uchar *buf) override;
void position(const uchar *record) override;
IO_AND_CPU_COST rnd_pos_time(ha_rows rows) override;
int info(uint);
int extra(enum ha_extra_function operation);
int extra_opt(enum ha_extra_function operation, ulong cache_size);
int reset(void);
int external_lock(THD *thd, int lock_type);
int delete_all_rows(void);
int reset_auto_increment(ulonglong value);
int disable_indexes(uint mode);
int enable_indexes(uint mode);
int indexes_are_disabled(void);
void start_bulk_insert(ha_rows rows, uint flags);
int end_bulk_insert();
int info(uint) override;
int extra(enum ha_extra_function operation) override;
int extra_opt(enum ha_extra_function operation, ulong cache_size) override;
int reset(void) override;
int external_lock(THD *thd, int lock_type) override;
int delete_all_rows(void) override;
int reset_auto_increment(ulonglong value) override;
int disable_indexes(uint mode) override;
int enable_indexes(uint mode) override;
int indexes_are_disabled(void) override;
void start_bulk_insert(ha_rows rows, uint flags) override;
int end_bulk_insert() override;
ha_rows records_in_range(uint inx, const key_range *min_key,
const key_range *max_key, page_range *pages);
void update_create_info(HA_CREATE_INFO *create_info);
int create(const char *name, TABLE *form, HA_CREATE_INFO *create_info);
const key_range *max_key, page_range *pages) override;
void update_create_info(HA_CREATE_INFO *create_info) override;
int create(const char *name, TABLE *form, HA_CREATE_INFO *create_info) override;
THR_LOCK_DATA **store_lock(THD *thd, THR_LOCK_DATA **to,
enum thr_lock_type lock_type);
virtual void get_auto_increment(ulonglong offset, ulonglong increment,
ulonglong nb_desired_values,
ulonglong *first_value,
ulonglong *nb_reserved_values);
int rename_table(const char * from, const char * to);
int delete_table(const char *name);
int check_for_upgrade(HA_CHECK_OPT *check_opt);
int check(THD* thd, HA_CHECK_OPT* check_opt);
int analyze(THD* thd,HA_CHECK_OPT* check_opt);
int repair(THD* thd, HA_CHECK_OPT* check_opt);
bool check_and_repair(THD *thd);
bool is_crashed() const;
bool auto_repair(int error) const
enum thr_lock_type lock_type) override;
void get_auto_increment(ulonglong offset, ulonglong increment,
ulonglong nb_desired_values,
ulonglong *first_value,
ulonglong *nb_reserved_values) override;
int rename_table(const char * from, const char * to) override;
int delete_table(const char *name) override;
int check_for_upgrade(HA_CHECK_OPT *check_opt) override;
int check(THD* thd, HA_CHECK_OPT* check_opt) override;
int analyze(THD* thd,HA_CHECK_OPT* check_opt) override;
int repair(THD* thd, HA_CHECK_OPT* check_opt) override;
bool check_and_repair(THD *thd) override;
bool is_crashed() const override;
bool auto_repair(int error) const override
{
return (myisam_recover_options != HA_RECOVER_OFF &&
error == HA_ERR_CRASHED_ON_USAGE);
}
int optimize(THD* thd, HA_CHECK_OPT* check_opt);
int assign_to_keycache(THD* thd, HA_CHECK_OPT* check_opt);
int preload_keys(THD* thd, HA_CHECK_OPT* check_opt);
int optimize(THD* thd, HA_CHECK_OPT* check_opt) override;
int assign_to_keycache(THD* thd, HA_CHECK_OPT* check_opt) override;
int preload_keys(THD* thd, HA_CHECK_OPT* check_opt) override;
enum_alter_inplace_result check_if_supported_inplace_alter(TABLE *new_table,
Alter_inplace_info *alter_info);
bool check_if_incompatible_data(HA_CREATE_INFO *info, uint table_changes);
Alter_inplace_info *alter_info)
override;
bool check_if_incompatible_data(HA_CREATE_INFO *info, uint table_changes)
override;
#ifdef HAVE_QUERY_CACHE
my_bool register_query_cache_table(THD *thd, const char *table_key,
uint key_length,
qc_engine_callback
*engine_callback,
ulonglong *engine_data);
ulonglong *engine_data) override;
#endif
MI_INFO *file_ptr(void)
{
return file;
}
public:
/**
* Multi Range Read interface
*/
int multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param,
uint n_ranges, uint mode, HANDLER_BUFFER *buf);
int multi_range_read_next(range_id_t *range_info);
uint n_ranges, uint mode, HANDLER_BUFFER *buf) override;
int multi_range_read_next(range_id_t *range_info) override;
ha_rows multi_range_read_info_const(uint keyno, RANGE_SEQ_IF *seq,
void *seq_init_param,
uint n_ranges, uint *bufsz,
uint *flags, ha_rows limit,
Cost_estimate *cost) override;
ha_rows multi_range_read_info(uint keyno, uint n_ranges, uint keys,
uint key_parts, uint *bufsz,
uint *flags, Cost_estimate *cost);
int multi_range_read_explain_info(uint mrr_mode, char *str, size_t size);
uint *flags, Cost_estimate *cost) override;
int multi_range_read_explain_info(uint mrr_mode, char *str, size_t size) override;

/* Index condition pushdown implementation */
Item *idx_cond_push(uint keyno, Item* idx_cond) override;
bool rowid_filter_push(Rowid_filter* rowid_filter) override;
void rowid_filter_changed() override;

/* Used by myisammrg */
MI_INFO *file_ptr(void)
{
return file;
}

private:
DsMrr_impl ds_mrr;
friend check_result_t index_cond_func_myisam(void *arg);
Expand Down

0 comments on commit c1512b1

Please sign in to comment.