Added "override" to ha_heap.h, ha_myisam.h, ha_myisammrg.h and ha_sequence.h

Added override to a few functions in ha_partition.h

sql/json_table.cc

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

sql/rowid_filter.h

@@ -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
   {
@@ -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);
   }

storage/heap/ha_heap.h

@@ -37,15 +37,15 @@ 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 |
@@ -53,71 +53,73 @@ class ha_heap final : public handler
             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);
 };

storage/myisam/ha_myisam.h

@@ -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)
@@ -95,73 +96,70 @@ 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,
@@ -169,14 +167,20 @@ class ha_myisam final : public handler
                                       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);

storage/myisammrg/ha_myisammrg.h

@@ -82,8 +82,8 @@ class ha_myisammrg final : public handler
 
   ha_myisammrg(handlerton *hton, TABLE_SHARE *table_arg);
   ~ha_myisammrg();
-  const char *index_type(uint key_number);
-  ulonglong table_flags() const
+  const char *index_type(uint key_number) override;
+  ulonglong table_flags() const override
   {
     return (HA_REC_NOT_IN_SEQ | HA_AUTO_PART_KEY | HA_NO_TRANSACTIONS |
             HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE |
@@ -93,15 +93,16 @@ class ha_myisammrg final : public handler
             HA_NO_COPY_ON_ALTER |
             HA_DUPLICATE_POS | HA_CAN_MULTISTEP_MERGE);
   }
-  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_FULLTEXT) ?
             0 : HA_READ_NEXT | HA_READ_PREV | HA_READ_RANGE |
             HA_READ_ORDER | HA_KEYREAD_ONLY);
   }
-  uint max_supported_keys()          const { return MI_MAX_KEY; }
-  uint max_supported_key_length()    const { return HA_MAX_KEY_LENGTH; }
-  uint max_supported_key_part_length() const { return HA_MAX_KEY_LENGTH; }
+  uint max_supported_keys()          const override { return MI_MAX_KEY; }
+  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; }
   IO_AND_CPU_COST scan_time() override
   {
     IO_AND_CPU_COST cost;
@@ -113,58 +114,60 @@ class ha_myisammrg final : public handler
   IO_AND_CPU_COST rnd_pos_time(ha_rows rows) override;
   IO_AND_CPU_COST keyread_time(uint index, ulong ranges, ha_rows rows,
                                 ulonglong blocks) override;
-  int open(const char *name, int mode, uint test_if_locked);
-  int add_children_list(void);
-  int attach_children(void);
-  int detach_children(void);
-  virtual handler *clone(const char *name, MEM_ROOT *mem_root);
-  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);
+  int open(const char *name, int mode, uint test_if_locked) override;
+  handler *clone(const char *name, MEM_ROOT *mem_root) 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_read_last_map(uchar *buf, const uchar *key, key_part_map keypart_map);
-  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);
-  int rnd_init(bool scan);
-  int rnd_next(uchar *buf);
-  int rnd_pos(uchar * buf, uchar *pos);
-  void position(const uchar *record);
+                         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_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 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;
   ha_rows records_in_range(uint inx, const key_range *start_key,
-                           const key_range *end_key, page_range *pages);
-  int delete_all_rows();
-  int info(uint);
-  int reset(void);
-  int extra(enum ha_extra_function operation);
-  int extra_opt(enum ha_extra_function operation, ulong cache_size);
-  int external_lock(THD *thd, int lock_type);
-  uint lock_count(void) const;
-  int create_mrg(const char *name, HA_CREATE_INFO *create_info);
-  int create(const char *name, TABLE *form, HA_CREATE_INFO *create_info);
+                           const key_range *end_key, page_range *pages) override;
+  int delete_all_rows() override;
+  int info(uint) override;
+  int reset(void) override;
+  int extra(enum ha_extra_function operation) override;
+  int extra_opt(enum ha_extra_function operation, ulong cache_size) override;
+  int external_lock(THD *thd, int lock_type) override;
+  uint lock_count(void) const 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);
-  void update_create_info(HA_CREATE_INFO *create_info);
-  void append_create_info(String *packet);
-  MYRG_INFO *myrg_info() { return file; }
-  TABLE *table_ptr() { return table; }
+			     enum thr_lock_type lock_type) override;
+  void update_create_info(HA_CREATE_INFO *create_info) override;
+  void append_create_info(String *packet) override;
   enum_alter_inplace_result check_if_supported_inplace_alter(TABLE *,
-                                                Alter_inplace_info *);
+                                                Alter_inplace_info *) override;
   bool inplace_alter_table(TABLE *altered_table,
-                           Alter_inplace_info *ha_alter_info);
-  int check(THD* thd, HA_CHECK_OPT* check_opt);
-  ha_rows records();
-  virtual uint count_query_cache_dependant_tables(uint8 *tables_type);
+                           Alter_inplace_info *ha_alter_info) override;
+  int check(THD* thd, HA_CHECK_OPT* check_opt) override;
+  ha_rows records() override;
+  virtual uint count_query_cache_dependant_tables(uint8 *tables_type) override;
   virtual my_bool
     register_query_cache_dependant_tables(THD *thd,
                                           Query_cache *cache,
                                           Query_cache_block_table **block,
-                                          uint *n);
-  virtual void set_lock_type(enum thr_lock_type lock);
+                                          uint *n) override;
+  virtual void set_lock_type(enum thr_lock_type lock) override;
+
+  /* Internal interface functions, not part of the normal handler interface */
+  int add_children_list(void);
+  int attach_children(void);
+  int detach_children(void);
+  int create_mrg(const char *name, HA_CREATE_INFO *create_info);
+  MYRG_INFO *myrg_info() { return file; }
+  TABLE *table_ptr()  { return table; }
 };

storage/sequence/sequence.cc

@@ -64,52 +64,53 @@ class ha_seq final : public handler
   Sequence_share *seqs;
   ha_seq(handlerton *hton, TABLE_SHARE *table_arg)
     : handler(hton, table_arg), seqs(0) { }
-  ulonglong table_flags() const
+  ulonglong table_flags() const override
   { return HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE; }
 
   /* open/close/locking */
   int create(const char *name, TABLE *table_arg,
-             HA_CREATE_INFO *create_info)
+             HA_CREATE_INFO *create_info) override
   { return HA_ERR_WRONG_COMMAND; }
 
-  int open(const char *name, int mode, uint test_if_locked);
-  int close(void);
-  int delete_table(const char *name)
+  int open(const char *name, int mode, uint test_if_locked) override;
+  int close(void) override;
+  int delete_table(const char *name) override
   {
     return 0;
   }
-  THR_LOCK_DATA **store_lock(THD *, THR_LOCK_DATA **, enum thr_lock_type);
+  THR_LOCK_DATA **store_lock(THD *, THR_LOCK_DATA **, enum thr_lock_type)
+    override;
 
   /* table scan */
-  int rnd_init(bool scan);
-  int rnd_next(unsigned char *buf);
-  void position(const uchar *record);
-  int rnd_pos(uchar *buf, uchar *pos);
-  int info(uint flag);
+  int rnd_init(bool scan) override;
+  int rnd_next(unsigned char *buf) override;
+  void position(const uchar *record) override;
+  int rnd_pos(uchar *buf, uchar *pos) override;
+  int info(uint flag) override;
   IO_AND_CPU_COST keyread_time(uint index, ulong ranges, ha_rows rows,
                                ulonglong blocks) override
   {
     /* Avoids assert in total_cost() and makes DBUG_PRINT more consistent */
     return {0,0};
   }
-  IO_AND_CPU_COST scan_time()
+  IO_AND_CPU_COST scan_time() override
   {
     /* Avoids assert in total_cost() and makes DBUG_PRINT more consistent */
     return {0, 0};
   }
   /* indexes */
-  ulong index_flags(uint inx, uint part, bool all_parts) const
+  ulong index_flags(uint inx, uint part, bool all_parts) const override
   { return HA_READ_NEXT | HA_READ_PREV | HA_READ_ORDER |
            HA_READ_RANGE | HA_KEYREAD_ONLY; }
-  uint max_supported_keys() const { return 1; }
+  uint max_supported_keys() const override { return 1; }
   int index_read_map(uchar *buf, 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);
+                     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;
   ha_rows records_in_range(uint inx, const key_range *start_key,
-                           const key_range *end_key, page_range *pages);
+                           const key_range *end_key, page_range *pages) override;
 
 private:
   void set(uchar *buf);