diff options
Diffstat (limited to '')
| -rw-r--r-- | storage/mroonga/ha_mroonga.hpp | 1309 |
1 files changed, 1309 insertions, 0 deletions
diff --git a/storage/mroonga/ha_mroonga.hpp b/storage/mroonga/ha_mroonga.hpp new file mode 100644 index 00000000..66767899 --- /dev/null +++ b/storage/mroonga/ha_mroonga.hpp @@ -0,0 +1,1309 @@ +/* -*- c-basic-offset: 2; indent-tabs-mode: nil -*- */ +/* + Copyright(C) 2010 Tetsuro IKEDA + Copyright(C) 2010-2013 Kentoku SHIBA + Copyright(C) 2011-2013 Kouhei Sutou <kou@clear-code.com> + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library 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 + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA +*/ + +#ifndef HA_MROONGA_HPP_ +#define HA_MROONGA_HPP_ + +#ifdef USE_PRAGMA_INTERFACE +#pragma interface +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#include <groonga.h> +#include "mrn_mysql_compat.h" +#include <mrn_operations.hpp> +#include <mrn_database.hpp> + +#if __cplusplus >= 201402 +# define mrn_override override +#else +# define mrn_override +#endif + +#if (MYSQL_VERSION_ID >= 50514 && MYSQL_VERSION_ID < 50600) +# define MRN_HANDLER_HAVE_FINAL_ADD_INDEX 1 +#endif + +#if (MYSQL_VERSION_ID >= 50603) || defined(MRN_MARIADB_P) +# define MRN_HANDLER_HAVE_HA_RND_NEXT 1 +# define MRN_HANDLER_HAVE_HA_RND_POS 1 +# define MRN_HANDLER_HAVE_HA_INDEX_READ_MAP 1 +# define MRN_HANDLER_HAVE_HA_INDEX_READ_IDX_MAP 1 +# define MRN_HANDLER_HAVE_HA_INDEX_NEXT 1 +# define MRN_HANDLER_HAVE_HA_INDEX_PREV 1 +# define MRN_HANDLER_HAVE_HA_INDEX_FIRST 1 +# define MRN_HANDLER_HAVE_HA_INDEX_LAST 1 +# define MRN_HANDLER_HAVE_HA_INDEX_NEXT_SAME 1 +#endif + +#if (MYSQL_VERSION_ID >= 50604) || defined(MRN_MARIADB_P) +# define MRN_HANDLER_HAVE_HA_CLOSE 1 +# define MRN_HANDLER_HAVE_MULTI_RANGE_READ 1 +#endif + +#if (MYSQL_VERSION_ID >= 50607) +# define MRN_HANDLER_HAVE_CHECK_IF_SUPPORTED_INPLACE_ALTER 1 +# define MRN_HANDLER_HAVE_HA_PREPARE_INPLACE_ALTER_TABLE 1 +# define MRN_HANDLER_HAVE_HA_INPLACE_ALTER_TABLE 1 +# define MRN_HANDLER_HAVE_HA_COMMIT_INPLACE_ALTER_TABLE 1 +# define MRN_SUPPORT_FOREIGN_KEYS 1 +#endif + +#ifndef MRN_MARIADB_P +# define MRN_HANDLER_HAVE_INDEX_READ_LAST_MAP +# if MYSQL_VERSION_ID >= 50611 +# define MRN_HANDLER_HAVE_HA_INDEX_READ_LAST_MAP +# endif +#endif + +#ifdef MRN_MARIADB_P +# define MRN_HANDLER_HAVE_MULTI_RANGE_READ_INFO_KEY_PARTS +#endif + +#if MYSQL_VERSION_ID < 50600 +# define MRN_HANDLER_HAVE_GET_TABLESPACE_NAME +#endif + +#if MYSQL_VERSION_ID >= 50607 +# define MRN_HANDLER_HAVE_SET_HA_SHARE_REF +#endif + +#if MYSQL_VERSION_ID >= 50706 && !defined(MRN_MARIADB_P) +# define MRN_BIG_TABLES +#elif defined(BIG_TABLES) +# define MRN_BIG_TABLES +#endif + +#ifdef MRN_BIG_TABLES +# define MRN_HA_ROWS_FORMAT "llu" +#else +# define MRN_HA_ROWS_FORMAT "lu" +#endif + +#ifdef MRN_MARIADB_P +# define MRN_NEED_FREE_STRING_MEMALLOC_PLUGIN_VAR +#endif + +#ifdef MRN_MARIADB_P +# define MRN_HAVE_HA_EXTRA_DETACH_CHILD +# define MRN_HAVE_HA_EXTRA_PREPARE_FOR_FORCED_CLOSE +#endif + +#if (!defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 80002) +#define MRN_HAVE_HA_EXTRA_SKIP_SERIALIZABLE_DD_VIEW +#define MRN_HAVE_HA_EXTRA_BEGIN_ALTER_COPY +#define MRN_HAVE_HA_EXTRA_END_ALTER_COPY +#define MRN_HAVE_HA_EXTRA_NO_AUTOINC_LOCKING +#endif + +#if MYSQL_VERSION_ID >= 50607 && \ + (!defined(MRN_MARIADB_P) || MYSQL_VERSION_ID < 100008) +# define MRN_HAVE_HA_EXTRA_EXPORT +#endif + +#if MYSQL_VERSION_ID >= 50617 && !defined(MRN_MARIADB_P) +# define MRN_HAVE_HA_EXTRA_SECONDARY_SORT_ROWID +#endif + +#if MYSQL_VERSION_ID >= 50604 && !defined(MRN_MARIADB_P) +# define MRN_TIMESTAMP_USE_TIMEVAL +#elif defined(MRN_MARIADB_P) +# define MRN_TIMESTAMP_USE_MY_TIME_T +#else +# define MRN_TIMESTAMP_USE_LONG +#endif + +#if MYSQL_VERSION_ID < 50600 && !defined(MRN_MARIADB_P) +# define MRN_FIELD_STORE_TIME_NEED_TYPE +#endif + +#if MYSQL_VERSION_ID < 50706 || defined(MRN_MARIADB_P) +# define MRN_HAVE_TL_WRITE_DELAYED +#endif + +#if MYSQL_VERSION_ID >= 50706 && !defined(MRN_MARIADB_P) +# define MRN_HAVE_TL_WRITE_CONCURRENT_DEFAULT +#endif + +#ifdef MRN_MARIADB_P +# define MRN_HANDLER_AUTO_REPAIR_HAVE_ERROR +#endif + +#if MYSQL_VERSION_ID >= 50604 +# define MRN_JOIN_TAB_HAVE_CONDITION +#endif + +#if MYSQL_VERSION_ID < 50600 +# define MRN_RBR_UPDATE_NEED_ALL_COLUMNS +#endif + +#if MYSQL_VERSION_ID >= 50500 +# define MRN_ROW_BASED_CHECK_IS_METHOD +#endif + +#if MYSQL_VERSION_ID >= 50600 +# define MRN_HAVE_HA_REBIND_PSI +#endif + +#if MYSQL_VERSION_ID >= 50612 && !defined(MRN_MARIADB_P) +# define MRN_HAVE_POINT_XY +#endif + +#if (defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 100000) +# define MRN_HANDLER_START_BULK_INSERT_HAS_FLAGS +#endif + +#if (defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 100010) +# define MRN_HAVE_TDC_LOCK_TABLE_SHARE +# if MYSQL_VERSION_ID >= 100100 +# define MRN_TABLE_SHARE_TDC_IS_POINTER +# endif +#endif + +#ifdef MRN_MARIADB_P +# if MYSQL_VERSION_ID >= 50542 && MYSQL_VERSION_ID < 100000 +# define MRN_SUPPORT_THDVAR_SET +# elif MYSQL_VERSION_ID >= 100017 +# define MRN_SUPPORT_THDVAR_SET +# endif +#else +# define MRN_SUPPORT_THDVAR_SET +#endif + +#ifdef MRN_MARIADB_P +# if MYSQL_VERSION_ID < 100000 +# define MRN_SUPPORT_PARTITION +# endif +#else +# define MRN_SUPPORT_PARTITION +#endif + +#if MYSQL_VERSION_ID >= 50706 && !defined(MRN_MARIADB_P) +# define MRN_FLUSH_LOGS_HAVE_BINLOG_GROUP_FLUSH +#endif + +#if MYSQL_VERSION_ID < 50706 || defined(MRN_MARIADB_P) +# define MRN_HAVE_HTON_ALTER_TABLE_FLAGS +#endif + +#if MYSQL_VERSION_ID >= 50706 +# define MRN_FOREIGN_KEY_USE_CONST_STRING +#endif + +#if MYSQL_VERSION_ID < 50706 || defined(MRN_MARIADB_P) +# define MRN_HANDLER_IS_FATAL_ERROR_HAVE_FLAGS +#endif + +#if MYSQL_VERSION_ID < 50706 || defined(MRN_MARIADB_P) +# define MRN_HANDLER_HAVE_RESET_AUTO_INCREMENT +#endif + +#if (!defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 50709) || \ + (defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 100203) +# define MRN_ALTER_INPLACE_INFO_ALTER_STORED_COLUMN_TYPE \ + ALTER_STORED_COLUMN_TYPE +# define MRN_ALTER_INPLACE_INFO_ALTER_STORED_COLUMN_ORDER \ + ALTER_STORED_COLUMN_ORDER +#else +# define MRN_ALTER_INPLACE_INFO_ALTER_STORED_COLUMN_TYPE \ + Alter_inplace_info::ALTER_COLUMN_TYPE +# define MRN_ALTER_INPLACE_INFO_ALTER_STORED_COLUMN_ORDER \ + Alter_inplace_info::ALTER_COLUMN_ORDER +#endif + +#if MYSQL_VERSION_ID >= 50700 && !defined(MRN_MARIADB_P) +# define MRN_HANDLER_RECORDS_RETURN_ERROR +#endif + +#if MYSQL_VERSION_ID < 80002 || defined(MRN_MARIADB_P) +# define MRN_HANDLER_HAVE_KEYS_TO_USE_FOR_SCANNING +#endif + +#if (!defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 80002) +# define MRN_ST_MYSQL_PLUGIN_HAVE_CHECK_UNINSTALL +#endif + +#if (!defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 80002) +# define MRN_HANDLER_OPEN_HAVE_TABLE_DEFINITION +# define MRN_HANDLER_CREATE_HAVE_TABLE_DEFINITION +#endif + +#if (!defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 80002) +# define MRN_HANDLERTON_CREATE_HAVE_PARTITIONED +#endif + +#if defined(HAVE_PSI_INTERFACE) && \ + (MYSQL_VERSION_ID < 80002 || defined(MRN_MARIADB_P)) +# define MRN_HAVE_PSI_SERVER +#endif + +class ha_mroonga; + +/* structs */ +struct st_mrn_ft_info +{ + struct _ft_vft *please; +#ifdef HA_CAN_FULLTEXT_EXT + struct _ft_vft_ext *could_you; +#endif + grn_ctx *ctx; + grn_encoding encoding; + grn_obj *table; + grn_obj *result; + grn_obj *score_column; + grn_obj key; + grn_obj score; + uint active_index; + KEY *key_info; + KEY *primary_key_info; + grn_obj *cursor; + grn_obj *id_accessor; + grn_obj *key_accessor; + ha_mroonga *mroonga; +}; + +#ifdef MRN_SUPPORT_CUSTOM_OPTIONS +struct ha_field_option_struct +{ + const char *groonga_type; + const char *flags; +}; + +struct ha_index_option_struct +{ + const char *tokenizer; + const char *normalizer; + const char *token_filters; + const char *flags; +}; +#endif + +/* handler class */ +class ha_mroonga: public handler +{ +public: + handler *wrap_handler; + bool is_clone; + ha_mroonga *parent_for_clone; + MEM_ROOT *mem_root_for_clone; + grn_obj key_buffer; + grn_id record_id; + grn_id *key_id; + grn_id *del_key_id; + MY_BITMAP multiple_column_key_bitmap; + +private: + THR_LOCK_DATA thr_lock_data; + + // for wrapper mode (TODO: need to be confirmed) + uint wrap_ft_init_count; + MRN_SHARE *share; + KEY *wrap_key_info; + KEY *base_key_info; + key_part_map pk_keypart_map; + MEM_ROOT mem_root; + /// for create table and alter table + mutable bool analyzed_for_create; + mutable TABLE table_for_create; + mutable MRN_SHARE share_for_create; + mutable TABLE_SHARE table_share_for_create; + mutable MEM_ROOT mem_root_for_create; + mutable handler *wrap_handler_for_create; +#ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX + handler_add_index *hnd_add_index; +#endif +#ifdef MRN_HANDLER_HAVE_CHECK_IF_SUPPORTED_INPLACE_ALTER + alter_table_operations alter_handler_flags; + KEY *alter_key_info_buffer; + uint alter_key_count; + uint alter_index_drop_count; + KEY *alter_index_drop_buffer; + uint alter_index_add_count; + uint *alter_index_add_buffer; + TABLE *wrap_altered_table; + KEY *wrap_altered_table_key_info; + TABLE_SHARE *wrap_altered_table_share; + KEY *wrap_altered_table_share_key_info; +#else + KEY *wrap_alter_key_info; +#endif + int mrn_lock_type; + + // for groonga objects + grn_ctx ctx_entity_; + grn_ctx *ctx; + grn_obj *grn_table; + grn_obj **grn_columns; + grn_obj **grn_column_ranges; + grn_obj **grn_index_tables; + grn_obj **grn_index_columns; + + // buffers + grn_obj encoded_key_buffer; + grn_obj old_value_buffer; + grn_obj new_value_buffer; + grn_obj top_left_point; + grn_obj bottom_right_point; + grn_obj source_point; + double top_left_longitude_in_degree; + double bottom_right_longitude_in_degree; + double bottom_right_latitude_in_degree; + double top_left_latitude_in_degree; + + // for search + grn_obj *grn_source_column_geo; + grn_obj *cursor_geo; + grn_table_cursor *cursor; + grn_table_cursor *index_table_cursor; + grn_obj *empty_value_records; + grn_table_cursor *empty_value_records_cursor; + grn_obj *sorted_result; + grn_obj *matched_record_keys; + String *blob_buffers; + + // for error report + uint dup_key; + + // for optimization + bool count_skip; + bool fast_order_limit; + bool fast_order_limit_with_index; + + // for context + bool ignoring_duplicated_key; + bool inserting_with_update; + bool fulltext_searching; + bool ignoring_no_key_columns; + bool replacing_; + uint written_by_row_based_binlog; + + // for ft in where clause test + Item_func_match *current_ft_item; + + mrn::Operations *operations_; + +public: + ha_mroonga(handlerton *hton, TABLE_SHARE *share_arg); + ~ha_mroonga(); + const char *table_type() const; // required + const char *index_type(uint inx) mrn_override; + const char **bas_ext() const; // required + + ulonglong table_flags() const mrn_override; // required + ulong index_flags(uint idx, uint part, bool all_parts) const mrn_override; // required + + // required + int create(const char *name, TABLE *form, HA_CREATE_INFO *info +#ifdef MRN_HANDLER_CREATE_HAVE_TABLE_DEFINITION + , + dd::Table *table_def +#endif + ) mrn_override; + // required + int open(const char *name, int mode, uint open_options +#ifdef MRN_HANDLER_OPEN_HAVE_TABLE_DEFINITION + , + const dd::Table *table_def +#endif + ) mrn_override; +#ifndef MRN_HANDLER_HAVE_HA_CLOSE + int close(); // required +#endif + int info(uint flag) mrn_override; // required + + uint lock_count() const mrn_override; + THR_LOCK_DATA **store_lock(THD *thd, // required + THR_LOCK_DATA **to, + enum thr_lock_type lock_type) mrn_override; + int external_lock(THD *thd, int lock_type) mrn_override; + + int rnd_init(bool scan) mrn_override; // required + int rnd_end() mrn_override; +#ifndef MRN_HANDLER_HAVE_HA_RND_NEXT + int rnd_next(uchar *buf); // required +#endif +#ifndef MRN_HANDLER_HAVE_HA_RND_POS + int rnd_pos(uchar *buf, uchar *pos); // required +#endif + void position(const uchar *record) mrn_override; // required + int extra(enum ha_extra_function operation) mrn_override; + int extra_opt(enum ha_extra_function operation, ulong cache_size) mrn_override; + + int delete_table(const char *name) mrn_override; + int write_row(const uchar *buf) mrn_override; + int update_row(const uchar *old_data, const uchar *new_data) mrn_override; + int delete_row(const uchar *buf) mrn_override; + + uint max_supported_record_length() const mrn_override; + uint max_supported_keys() const mrn_override; + uint max_supported_key_parts() const mrn_override; + uint max_supported_key_length() const mrn_override; + uint max_supported_key_part_length() const mrn_override; + + ha_rows records_in_range(uint inx, const key_range *min_key, + const key_range *max_key, page_range *pages) mrn_override; + int index_init(uint idx, bool sorted) mrn_override; + int index_end() mrn_override; +#ifndef MRN_HANDLER_HAVE_HA_INDEX_READ_MAP + int index_read_map(uchar * buf, const uchar * key, + key_part_map keypart_map, + enum ha_rkey_function find_flag); +#endif +#ifdef MRN_HANDLER_HAVE_INDEX_READ_LAST_MAP + int index_read_last_map(uchar *buf, const uchar *key, + key_part_map keypart_map); +#endif +#ifndef MRN_HANDLER_HAVE_HA_INDEX_NEXT + int index_next(uchar *buf); +#endif +#ifndef MRN_HANDLER_HAVE_HA_INDEX_PREV + int index_prev(uchar *buf); +#endif +#ifndef MRN_HANDLER_HAVE_HA_INDEX_FIRST + int index_first(uchar *buf); +#endif +#ifndef MRN_HANDLER_HAVE_HA_INDEX_LAST + int index_last(uchar *buf); +#endif + int index_next_same(uchar *buf, const uchar *key, uint keylen) mrn_override; + + int ft_init() mrn_override; + FT_INFO *ft_init_ext(uint flags, uint inx, String *key) mrn_override; + int ft_read(uchar *buf) mrn_override; + + const Item *cond_push(const Item *cond) mrn_override; + void cond_pop() mrn_override; + + bool get_error_message(int error, String *buf) mrn_override; + + int reset() mrn_override; + + handler *clone(const char *name, MEM_ROOT *mem_root) mrn_override; + uint8 table_cache_type() mrn_override; +#ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ + ha_rows multi_range_read_info_const(uint keyno, RANGE_SEQ_IF *seq, + void *seq_init_param, + uint n_ranges, uint *bufsz, + uint *flags, Cost_estimate *cost) mrn_override; + ha_rows multi_range_read_info(uint keyno, uint n_ranges, uint keys, +#ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ_INFO_KEY_PARTS + uint key_parts, +#endif + uint *bufsz, uint *flags, Cost_estimate *cost) mrn_override; + int multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param, + uint n_ranges, uint mode, + HANDLER_BUFFER *buf) mrn_override; + int multi_range_read_next(range_id_t *range_info) mrn_override; +#else // MRN_HANDLER_HAVE_MULTI_RANGE_READ + int read_multi_range_first(KEY_MULTI_RANGE **found_range_p, + KEY_MULTI_RANGE *ranges, + uint range_count, + bool sorted, + HANDLER_BUFFER *buffer); + int read_multi_range_next(KEY_MULTI_RANGE **found_range_p); +#endif // MRN_HANDLER_HAVE_MULTI_RANGE_READ +#ifdef MRN_HANDLER_START_BULK_INSERT_HAS_FLAGS + void start_bulk_insert(ha_rows rows, uint flags) mrn_override; +#else + void start_bulk_insert(ha_rows rows); +#endif + int end_bulk_insert() mrn_override; + int delete_all_rows() mrn_override; + int truncate() mrn_override; + double scan_time() mrn_override; + double read_time(uint index, uint ranges, ha_rows rows) mrn_override; +#ifdef MRN_HANDLER_HAVE_KEYS_TO_USE_FOR_SCANNING + const key_map *keys_to_use_for_scanning() mrn_override; +#endif + ha_rows estimate_rows_upper_bound() mrn_override; + void update_create_info(HA_CREATE_INFO* create_info) mrn_override; + int rename_table(const char *from, const char *to) mrn_override; + bool is_crashed() const mrn_override; + bool auto_repair(int error) const mrn_override; + bool auto_repair() const; + int disable_indexes(uint mode) mrn_override; + int enable_indexes(uint mode) mrn_override; + int check(THD* thd, HA_CHECK_OPT* check_opt) mrn_override; + int repair(THD* thd, HA_CHECK_OPT* check_opt) mrn_override; + bool check_and_repair(THD *thd) mrn_override; + int analyze(THD* thd, HA_CHECK_OPT* check_opt) mrn_override; + int optimize(THD* thd, HA_CHECK_OPT* check_opt) mrn_override; + bool is_fatal_error(int error_num, uint flags=0) mrn_override; + bool check_if_incompatible_data(HA_CREATE_INFO *create_info, + uint table_changes) mrn_override; +#ifdef MRN_HANDLER_HAVE_CHECK_IF_SUPPORTED_INPLACE_ALTER + enum_alter_inplace_result + check_if_supported_inplace_alter(TABLE *altered_table, + Alter_inplace_info *ha_alter_info) mrn_override; +#else + alter_table_operations alter_table_flags(alter_table_operations flags); +# ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX + int add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys, + handler_add_index **add); + int final_add_index(handler_add_index *add, bool commit); +# else + int add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys); +# endif + int prepare_drop_index(TABLE *table_arg, uint *key_num, uint num_of_keys); + int final_drop_index(TABLE *table_arg); +#endif + int update_auto_increment(); + void set_next_insert_id(ulonglong id); + void get_auto_increment(ulonglong offset, ulonglong increment, ulonglong nb_desired_values, + ulonglong *first_value, ulonglong *nb_reserved_values) mrn_override; + void restore_auto_increment(ulonglong prev_insert_id) mrn_override; + void release_auto_increment() mrn_override; + int check_for_upgrade(HA_CHECK_OPT *check_opt) mrn_override; +#ifdef MRN_HANDLER_HAVE_RESET_AUTO_INCREMENT + int reset_auto_increment(ulonglong value) mrn_override; +#endif + bool was_semi_consistent_read() mrn_override; + void try_semi_consistent_read(bool yes) mrn_override; + void unlock_row() mrn_override; + int start_stmt(THD *thd, thr_lock_type lock_type) mrn_override; + +protected: +#ifdef MRN_HANDLER_RECORDS_RETURN_ERROR + int records(ha_rows *num_rows); +#else + ha_rows records() mrn_override; +#endif +#ifdef MRN_HANDLER_HAVE_HA_RND_NEXT + int rnd_next(uchar *buf) mrn_override; +#endif +#ifdef MRN_HANDLER_HAVE_HA_RND_POS + int rnd_pos(uchar *buf, uchar *pos) mrn_override; +#endif +#ifdef MRN_HANDLER_HAVE_HA_INDEX_READ_MAP + int index_read_map(uchar *buf, const uchar *key, + key_part_map keypart_map, + enum ha_rkey_function find_flag) mrn_override; +#endif +#ifdef MRN_HANDLER_HAVE_HA_INDEX_NEXT + int index_next(uchar *buf) mrn_override; +#endif +#ifdef MRN_HANDLER_HAVE_HA_INDEX_PREV + int index_prev(uchar *buf) mrn_override; +#endif +#ifdef MRN_HANDLER_HAVE_HA_INDEX_FIRST + int index_first(uchar *buf) mrn_override; +#endif +#ifdef MRN_HANDLER_HAVE_HA_INDEX_LAST + int index_last(uchar *buf) mrn_override; +#endif + void change_table_ptr(TABLE *table_arg, TABLE_SHARE *share_arg) mrn_override; + bool is_fk_defined_on_table_or_index(uint index) mrn_override; + char *get_foreign_key_create_info() mrn_override; +#ifdef MRN_HANDLER_HAVE_GET_TABLESPACE_NAME + char *get_tablespace_name(THD *thd, char *name, uint name_len); +#endif + bool can_switch_engines() mrn_override; + int get_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list) mrn_override; + int get_parent_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list) mrn_override; + uint referenced_by_foreign_key() mrn_override; + void init_table_handle_for_HANDLER() mrn_override; + void free_foreign_key_create_info(char* str) mrn_override; +#ifdef MRN_HAVE_HA_REBIND_PSI + void unbind_psi() mrn_override; + void rebind_psi() mrn_override; +#endif + my_bool register_query_cache_table(THD *thd, + const char *table_key, + uint key_length, + qc_engine_callback *engine_callback, + ulonglong *engine_data) mrn_override; +#ifdef MRN_HANDLER_HAVE_CHECK_IF_SUPPORTED_INPLACE_ALTER + bool prepare_inplace_alter_table(TABLE *altered_table, + Alter_inplace_info *ha_alter_info) mrn_override; + bool inplace_alter_table(TABLE *altered_table, + Alter_inplace_info *ha_alter_info) mrn_override; + bool commit_inplace_alter_table(TABLE *altered_table, + Alter_inplace_info *ha_alter_info, + bool commit) mrn_override; +#endif + +private: + void mkdir_p(const char *directory); + ulonglong file_size(const char *path); + + bool have_unique_index(); + + bool is_foreign_key_field(const char *table_name, + const char *field_name); + + void push_warning_unsupported_spatial_index_search(enum ha_rkey_function flag); + void clear_cursor(); + void clear_cursor_geo(); + void clear_empty_value_records(); + void clear_search_result(); + void clear_search_result_geo(); + void clear_indexes(); + int add_wrap_hton(const char *path, handlerton *wrap_handlerton); + void remove_related_files(const char *base_path); + void remove_grn_obj_force(const char *name); + int drop_index(MRN_SHARE *target_share, uint key_index); + int drop_indexes_normal(const char *table_name, grn_obj *table); + int drop_indexes_multiple(const char *table_name, grn_obj *table, + const char *index_table_name_separator); + int drop_indexes(const char *table_name); + bool find_column_flags(Field *field, MRN_SHARE *mrn_share, int i, + grn_obj_flags *column_flags); + grn_obj *find_column_type(Field *field, MRN_SHARE *mrn_share, int i, + int error_code); + grn_obj *find_tokenizer(KEY *key, MRN_SHARE *mrn_share, int i); + grn_obj *find_tokenizer(const char *name, int name_length); + bool have_custom_normalizer(KEY *key) const; + grn_obj *find_normalizer(KEY *key); + grn_obj *find_normalizer(KEY *key, const char *name); + bool find_index_column_flags(KEY *key, grn_column_flags *index_column_flags); + bool find_token_filters(KEY *key, grn_obj *token_filters); + bool find_token_filters_put(grn_obj *token_filters, + const char *token_filter_name, + int token_filter_name_length); + bool find_token_filters_fill(grn_obj *token_filters, + const char *token_filter_names, + int token_filter_name_length); + int wrapper_get_record(uchar *buf, const uchar *key); + int wrapper_get_next_geo_record(uchar *buf); + int storage_get_next_record(uchar *buf); + void geo_store_rectangle(const uchar *rectangle); + int generic_geo_open_cursor(const uchar *key, enum ha_rkey_function find_flag); + +#ifdef MRN_HANDLER_HAVE_HA_CLOSE + int close() mrn_override; +#endif + bool is_dry_write(); + bool is_enable_optimization(); + bool should_normalize(Field *field) const; + void check_count_skip(key_part_map target_key_part_map); + bool is_grn_zero_column_value(grn_obj *column, grn_obj *value); + bool is_primary_key_field(Field *field) const; + void check_fast_order_limit(grn_table_sort_key **sort_keys, int *n_sort_keys, + longlong *limit); + + long long int get_grn_time_from_timestamp_field(Field_timestamp *field); + + int generic_store_bulk_fixed_size_string(Field *field, grn_obj *buf); + int generic_store_bulk_variable_size_string(Field *field, grn_obj *buf); + int generic_store_bulk_integer(Field *field, grn_obj *buf); + int generic_store_bulk_unsigned_integer(Field *field, grn_obj *buf); + int generic_store_bulk_float(Field *field, grn_obj *buf); + int generic_store_bulk_timestamp(Field *field, grn_obj *buf); + int generic_store_bulk_date(Field *field, grn_obj *buf); + int generic_store_bulk_time(Field *field, grn_obj *buf); + int generic_store_bulk_datetime(Field *field, grn_obj *buf); + int generic_store_bulk_year(Field *field, grn_obj *buf); + int generic_store_bulk_new_date(Field *field, grn_obj *buf); +#ifdef MRN_HAVE_MYSQL_TYPE_DATETIME2 + int generic_store_bulk_datetime2(Field *field, grn_obj *buf); +#endif +#ifdef MRN_HAVE_MYSQL_TYPE_TIME2 + int generic_store_bulk_time2(Field *field, grn_obj *buf); +#endif + int generic_store_bulk_new_decimal(Field *field, grn_obj *buf); + int generic_store_bulk_blob(Field *field, grn_obj *buf); + int generic_store_bulk_geometry(Field *field, grn_obj *buf); +#ifdef MRN_HAVE_MYSQL_TYPE_JSON + int generic_store_bulk_json(Field *field, grn_obj *buf); +#endif + int generic_store_bulk(Field *field, grn_obj *buf); + + void storage_store_field_string(Field *field, + const char *value, uint value_length); + void storage_store_field_integer(Field *field, + const char *value, uint value_length); + void storage_store_field_unsigned_integer(Field *field, + const char *value, + uint value_length); + void storage_store_field_float(Field *field, + const char *value, uint value_length); + void storage_store_field_timestamp(Field *field, + const char *value, uint value_length); + void storage_store_field_date(Field *field, + const char *value, uint value_length); + void storage_store_field_time(Field *field, + const char *value, uint value_length); + void storage_store_field_datetime(Field *field, + const char *value, uint value_length); + void storage_store_field_year(Field *field, + const char *value, uint value_length); + void storage_store_field_new_date(Field *field, + const char *value, uint value_length); +#ifdef MRN_HAVE_MYSQL_TYPE_DATETIME2 + void storage_store_field_datetime2(Field *field, + const char *value, uint value_length); +#endif +#ifdef MRN_HAVE_MYSQL_TYPE_TIME2 + void storage_store_field_time2(Field *field, + const char *value, uint value_length); +#endif + void storage_store_field_blob(Field *field, + const char *value, uint value_length); + void storage_store_field_geometry(Field *field, + const char *value, uint value_length); +#ifdef MRN_HAVE_MYSQL_TYPE_JSON + void storage_store_field_json(Field *field, + const char *value, uint value_length); +#endif + void storage_store_field(Field *field, const char *value, uint value_length); + void storage_store_field_column(Field *field, bool is_primary_key, + int nth_column, grn_id record_id); + void storage_store_fields(uchar *buf, grn_id record_id); + void storage_store_fields_for_prep_update(const uchar *old_data, + const uchar *new_data, + grn_id record_id); + void storage_store_fields_by_index(uchar *buf); + + int storage_encode_key_normalize_min_sort_chars(Field *field, + uchar *buf, + uint size); + int storage_encode_key_fixed_size_string(Field *field, const uchar *key, + uchar *buf, uint *size); + int storage_encode_key_variable_size_string(Field *field, const uchar *key, + uchar *buf, uint *size); + int storage_encode_key_timestamp(Field *field, const uchar *key, + uchar *buf, uint *size); + int storage_encode_key_time(Field *field, const uchar *key, + uchar *buf, uint *size); + int storage_encode_key_year(Field *field, const uchar *key, + uchar *buf, uint *size); + int storage_encode_key_datetime(Field *field, const uchar *key, + uchar *buf, uint *size); +#ifdef MRN_HAVE_MYSQL_TYPE_TIMESTAMP2 + int storage_encode_key_timestamp2(Field *field, const uchar *key, + uchar *buf, uint *size); +#endif +#ifdef MRN_HAVE_MYSQL_TYPE_DATETIME2 + int storage_encode_key_datetime2(Field *field, bool is_null, const uchar *key, + uchar *buf, uint *size); +#endif +#ifdef MRN_HAVE_MYSQL_TYPE_TIME2 + int storage_encode_key_time2(Field *field, const uchar *key, + uchar *buf, uint *size); +#endif + int storage_encode_key_enum(Field *field, const uchar *key, + uchar *buf, uint *size); + int storage_encode_key_set(Field *field, const uchar *key, + uchar *buf, uint *size); + int storage_encode_key(Field *field, const uchar *key, uchar *buf, uint *size); + int storage_encode_multiple_column_key(KEY *key_info, + const uchar *key, uint key_length, + uchar *buffer, uint *encoded_length); + int storage_encode_multiple_column_key_range(KEY *key_info, + const uchar *start, + uint start_size, + const uchar *end, + uint end_size, + uchar *min_buffer, + uint *min_encoded_size, + uchar *max_buffer, + uint *max_encoded_size); + int storage_encode_multiple_column_key_range(KEY *key_info, + const key_range *start, + const key_range *end, + uchar *min_buffer, + uint *min_encoded_size, + uchar *max_buffer, + uint *max_encoded_size); + + void set_pk_bitmap(); + int create_share_for_create() const; + int wrapper_create(const char *name, TABLE *table, + HA_CREATE_INFO *info, MRN_SHARE *tmp_share); + int storage_create(const char *name, TABLE *table, + HA_CREATE_INFO *info, MRN_SHARE *tmp_share); + int wrapper_create_index_fulltext_validate(KEY *key_info); + int wrapper_create_index_fulltext(const char *grn_table_name, + int i, + KEY *key_info, + grn_obj **index_tables, + grn_obj **index_columns, + MRN_SHARE *tmp_share); + int wrapper_create_index_geo(const char *grn_table_name, + int i, + KEY *key_info, + grn_obj **index_tables, + grn_obj **index_columns, + MRN_SHARE *tmp_share); + int wrapper_create_index(const char *name, TABLE *table, MRN_SHARE *tmp_share); + int storage_create_validate_pseudo_column(TABLE *table); +#ifdef MRN_SUPPORT_FOREIGN_KEYS + bool storage_create_foreign_key(TABLE *table, const char *grn_table_name, + Field *field, grn_obj *table_obj, int &error); +#endif + int storage_create_validate_index(TABLE *table); + int storage_create_index_table(TABLE *table, const char *grn_table_name, + grn_obj *grn_table, MRN_SHARE *tmp_share, + KEY *key_info, grn_obj **index_tables, + uint i); + int storage_create_index(TABLE *table, const char *grn_table_name, + grn_obj *grn_table, MRN_SHARE *tmp_share, + KEY *key_info, grn_obj **index_tables, + grn_obj **index_columns, uint i); + int storage_create_indexes(TABLE *table, const char *grn_table_name, + grn_obj *grn_table, MRN_SHARE *tmp_share); + int close_databases(); + int ensure_database_open(const char *name, mrn::Database **db=NULL); + int ensure_database_remove(const char *name); + int wrapper_delete_table(const char *name, handlerton *wrap_handlerton, + const char *table_name); + int generic_delete_table(const char *name, const char *table_name); + int wrapper_open(const char *name, int mode, uint open_options); + int wrapper_open_indexes(const char *name); + int storage_reindex(); + int storage_open(const char *name, int mode, uint open_options); + int open_table(const char *name); + int storage_open_columns(void); + void storage_close_columns(void); + int storage_open_indexes(const char *name); + void wrapper_overwrite_index_bits(); + int wrapper_close(); + int storage_close(); + int generic_extra(enum ha_extra_function operation); + int wrapper_extra(enum ha_extra_function operation); + int storage_extra(enum ha_extra_function operation); + int wrapper_extra_opt(enum ha_extra_function operation, ulong cache_size); + int storage_extra_opt(enum ha_extra_function operation, ulong cache_size); + int generic_reset(); + int wrapper_reset(); + int storage_reset(); + uint wrapper_lock_count() const; + uint storage_lock_count() const; + THR_LOCK_DATA **wrapper_store_lock(THD *thd, THR_LOCK_DATA **to, + enum thr_lock_type lock_type); + THR_LOCK_DATA **storage_store_lock(THD *thd, THR_LOCK_DATA **to, + enum thr_lock_type lock_type); + int wrapper_external_lock(THD *thd, int lock_type); + int storage_external_lock(THD *thd, int lock_type); +#ifdef MRN_HANDLER_START_BULK_INSERT_HAS_FLAGS + void wrapper_start_bulk_insert(ha_rows rows, uint flags); + void storage_start_bulk_insert(ha_rows rows, uint flags); +#else + void wrapper_start_bulk_insert(ha_rows rows); + void storage_start_bulk_insert(ha_rows rows); +#endif + int wrapper_end_bulk_insert(); + int storage_end_bulk_insert(); + bool wrapper_is_target_index(KEY *key_info); + bool wrapper_have_target_index(); + int wrapper_write_row(const uchar *buf); + int wrapper_write_row_index(const uchar *buf); + int storage_write_row(const uchar *buf); + int storage_write_row_multiple_column_index(const uchar *buf, + grn_id record_id, + KEY *key_info, + grn_obj *index_column); + int storage_write_row_multiple_column_indexes(const uchar *buf, grn_id record_id); + int storage_write_row_unique_index(const uchar *buf, + KEY *key_info, + grn_obj *index_table, + grn_obj *index_column, + grn_id *key_id); + int storage_write_row_unique_indexes(const uchar *buf); + int wrapper_get_record_id(uchar *data, grn_id *record_id, + const char *context); + int wrapper_update_row(const uchar *old_data, const uchar *new_data); + int wrapper_update_row_index(const uchar *old_data, + const uchar *new_data); + int storage_update_row(const uchar *old_data, const uchar *new_data); + int storage_update_row_index(const uchar *old_data, + const uchar *new_data); + int storage_update_row_unique_indexes(const uchar *new_data); + int wrapper_delete_row(const uchar *buf); + int wrapper_delete_row_index(const uchar *buf); + int storage_delete_row(const uchar *buf); + int storage_delete_row_index(const uchar *buf); + int storage_delete_row_unique_index(grn_obj *index_table, grn_id del_key_id); + int storage_delete_row_unique_indexes(); + int storage_prepare_delete_row_unique_index(const uchar *buf, + grn_id record_id, + KEY *key_info, + grn_obj *index_table, + grn_obj *index_column, + grn_id *del_key_id); + int storage_prepare_delete_row_unique_indexes(const uchar *buf, + grn_id record_id); + uint wrapper_max_supported_record_length() const; + uint storage_max_supported_record_length() const; + uint wrapper_max_supported_keys() const; + uint storage_max_supported_keys() const; + uint wrapper_max_supported_key_parts() const; + uint storage_max_supported_key_parts() const; + uint wrapper_max_supported_key_length() const; + uint storage_max_supported_key_length() const; + uint wrapper_max_supported_key_part_length() const; + uint storage_max_supported_key_part_length() const; + ulonglong wrapper_table_flags() const; + ulonglong storage_table_flags() const; + ulong wrapper_index_flags(uint idx, uint part, bool all_parts) const; + ulong storage_index_flags(uint idx, uint part, bool all_parts) const; + int wrapper_info(uint flag); + int storage_info(uint flag); + void storage_info_variable(); + void storage_info_variable_records(); + void storage_info_variable_data_file_length(); +#ifdef MRN_HANDLER_RECORDS_RETURN_ERROR + int wrapper_records(ha_rows *num_rows); + int storage_records(ha_rows *num_rows); +#else + ha_rows wrapper_records(); + ha_rows storage_records(); +#endif + int wrapper_rnd_init(bool scan); + int storage_rnd_init(bool scan); + int wrapper_rnd_end(); + int storage_rnd_end(); + int wrapper_rnd_next(uchar *buf); + int storage_rnd_next(uchar *buf); + int wrapper_rnd_pos(uchar *buf, uchar *pos); + int storage_rnd_pos(uchar *buf, uchar *pos); + void wrapper_position(const uchar *record); + void storage_position(const uchar *record); + ha_rows wrapper_records_in_range(uint key_nr, const key_range *range_min, + const key_range *range_max, + page_range *pages); + ha_rows storage_records_in_range(uint key_nr, const key_range *range_min, + const key_range *range_max, + page_range *pages); + ha_rows generic_records_in_range_geo(uint key_nr, const key_range *range_min, + const key_range *range_max); + int wrapper_index_init(uint idx, bool sorted); + int storage_index_init(uint idx, bool sorted); + int wrapper_index_end(); + int storage_index_end(); + int wrapper_index_read_map(uchar *buf, const uchar *key, + key_part_map keypart_map, + enum ha_rkey_function find_flag); + int storage_index_read_map(uchar *buf, const uchar *key, + key_part_map keypart_map, + enum ha_rkey_function find_flag); +#ifdef MRN_HANDLER_HAVE_INDEX_READ_LAST_MAP + int wrapper_index_read_last_map(uchar *buf, const uchar *key, + key_part_map keypart_map); + int storage_index_read_last_map(uchar *buf, const uchar *key, + key_part_map keypart_map); +#endif + int wrapper_index_next(uchar *buf); + int storage_index_next(uchar *buf); + int wrapper_index_prev(uchar *buf); + int storage_index_prev(uchar *buf); + int wrapper_index_first(uchar *buf); + int storage_index_first(uchar *buf); + int wrapper_index_last(uchar *buf); + int storage_index_last(uchar *buf); + int wrapper_index_next_same(uchar *buf, const uchar *key, uint keylen); + int storage_index_next_same(uchar *buf, const uchar *key, uint keylen); + int generic_ft_init(); + int wrapper_ft_init(); + int storage_ft_init(); + FT_INFO *wrapper_ft_init_ext(uint flags, uint key_nr, String *key); + FT_INFO *storage_ft_init_ext(uint flags, uint key_nr, String *key); + void generic_ft_init_ext_add_conditions_fast_order_limit( + struct st_mrn_ft_info *info, grn_obj *expression); + grn_rc generic_ft_init_ext_prepare_expression_in_boolean_mode( + struct st_mrn_ft_info *info, + String *key, + grn_obj *index_column, + grn_obj *match_columns, + grn_obj *expression); + grn_rc generic_ft_init_ext_prepare_expression_in_normal_mode( + struct st_mrn_ft_info *info, + String *key, + grn_obj *index_column, + grn_obj *match_columns, + grn_obj *expression); + struct st_mrn_ft_info *generic_ft_init_ext_select(uint flags, + uint key_nr, + String *key); + FT_INFO *generic_ft_init_ext(uint flags, uint key_nr, String *key); + int wrapper_ft_read(uchar *buf); + int storage_ft_read(uchar *buf); + const Item *wrapper_cond_push(const Item *cond); + const Item *storage_cond_push(const Item *cond); + void wrapper_cond_pop(); + void storage_cond_pop(); + bool wrapper_get_error_message(int error, String *buf); + bool storage_get_error_message(int error, String *buf); + handler *wrapper_clone(const char *name, MEM_ROOT *mem_root); + handler *storage_clone(const char *name, MEM_ROOT *mem_root); + uint8 wrapper_table_cache_type(); + uint8 storage_table_cache_type(); +#ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ + ha_rows wrapper_multi_range_read_info_const(uint keyno, + RANGE_SEQ_IF *seq, + void *seq_init_param, + uint n_ranges, + uint *bufsz, + uint *flags, + Cost_estimate *cost); + ha_rows storage_multi_range_read_info_const(uint keyno, + RANGE_SEQ_IF *seq, + void *seq_init_param, + uint n_ranges, + uint *bufsz, + uint *flags, + Cost_estimate *cost); + ha_rows wrapper_multi_range_read_info(uint keyno, uint n_ranges, uint keys, +#ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ_INFO_KEY_PARTS + uint key_parts, +#endif + uint *bufsz, uint *flags, + Cost_estimate *cost); + ha_rows storage_multi_range_read_info(uint keyno, uint n_ranges, uint keys, +#ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ_INFO_KEY_PARTS + uint key_parts, +#endif + uint *bufsz, uint *flags, + Cost_estimate *cost); + int wrapper_multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param, + uint n_ranges, uint mode, + HANDLER_BUFFER *buf); + int storage_multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param, + uint n_ranges, uint mode, + HANDLER_BUFFER *buf); + int wrapper_multi_range_read_next(range_id_t *range_info); + int storage_multi_range_read_next(range_id_t *range_info); +#else // MRN_HANDLER_HAVE_MULTI_RANGE_READ + int wrapper_read_multi_range_first(KEY_MULTI_RANGE **found_range_p, + KEY_MULTI_RANGE *ranges, + uint range_count, + bool sorted, + HANDLER_BUFFER *buffer); + int storage_read_multi_range_first(KEY_MULTI_RANGE **found_range_p, + KEY_MULTI_RANGE *ranges, + uint range_count, + bool sorted, + HANDLER_BUFFER *buffer); + int wrapper_read_multi_range_next(KEY_MULTI_RANGE **found_range_p); + int storage_read_multi_range_next(KEY_MULTI_RANGE **found_range_p); +#endif // MRN_HANDLER_HAVE_MULTI_RANGE_READ + int generic_delete_all_rows(grn_obj *target_grn_table, + const char *function_name); + int wrapper_delete_all_rows(); + int storage_delete_all_rows(); + int wrapper_truncate(); + int wrapper_truncate_index(); + int storage_truncate(); + int storage_truncate_index(); + double wrapper_scan_time(); + double storage_scan_time(); + double wrapper_read_time(uint index, uint ranges, ha_rows rows); + double storage_read_time(uint index, uint ranges, ha_rows rows); +#ifdef MRN_HANDLER_HAVE_KEYS_TO_USE_FOR_SCANNING + const key_map *wrapper_keys_to_use_for_scanning(); + const key_map *storage_keys_to_use_for_scanning(); +#endif + ha_rows wrapper_estimate_rows_upper_bound(); + ha_rows storage_estimate_rows_upper_bound(); + void wrapper_update_create_info(HA_CREATE_INFO* create_info); + void storage_update_create_info(HA_CREATE_INFO* create_info); + int wrapper_rename_table(const char *from, const char *to, + MRN_SHARE *tmp_share, + const char *from_table_name, + const char *to_table_name); + int wrapper_rename_index(const char *from, const char *to, + MRN_SHARE *tmp_share, + const char *from_table_name, + const char *to_table_name); + int storage_rename_table(const char *from, const char *to, + MRN_SHARE *tmp_share, + const char *from_table_name, + const char *to_table_name); +#ifdef MRN_SUPPORT_FOREIGN_KEYS + int storage_rename_foreign_key(MRN_SHARE *tmp_share, + const char *from_table_name, + const char *to_table_name); +#endif + bool wrapper_is_crashed() const; + bool storage_is_crashed() const; + bool wrapper_auto_repair(int error) const; + bool storage_auto_repair(int error) const; + int generic_disable_index(int i, KEY *key_info); + int wrapper_disable_indexes_mroonga(uint mode); + int wrapper_disable_indexes(uint mode); + int storage_disable_indexes(uint mode); + int wrapper_enable_indexes_mroonga(uint mode); + int wrapper_enable_indexes(uint mode); + int storage_enable_indexes(uint mode); + int wrapper_check(THD* thd, HA_CHECK_OPT* check_opt); + int storage_check(THD* thd, HA_CHECK_OPT* check_opt); + int wrapper_fill_indexes(THD *thd, KEY *key_info, + grn_obj **index_columns, uint n_keys); + int wrapper_recreate_indexes(THD *thd); + int storage_recreate_indexes(THD *thd); + int wrapper_repair(THD* thd, HA_CHECK_OPT* check_opt); + int storage_repair(THD* thd, HA_CHECK_OPT* check_opt); + bool wrapper_check_and_repair(THD *thd); + bool storage_check_and_repair(THD *thd); + int wrapper_analyze(THD* thd, HA_CHECK_OPT* check_opt); + int storage_analyze(THD* thd, HA_CHECK_OPT* check_opt); + int wrapper_optimize(THD* thd, HA_CHECK_OPT* check_opt); + int storage_optimize(THD* thd, HA_CHECK_OPT* check_opt); + bool wrapper_is_fatal_error(int error_num, uint flags); + bool storage_is_fatal_error(int error_num, uint flags); + bool wrapper_is_comment_changed(TABLE *table1, TABLE *table2); + bool wrapper_check_if_incompatible_data(HA_CREATE_INFO *create_info, + uint table_changes); + bool storage_check_if_incompatible_data(HA_CREATE_INFO *create_info, + uint table_changes); + int storage_add_index_multiple_columns(KEY *key_info, uint num_of_keys, + grn_obj **index_tables, + grn_obj **index_columns, + bool skip_unique_key); +#ifdef MRN_HANDLER_HAVE_CHECK_IF_SUPPORTED_INPLACE_ALTER + enum_alter_inplace_result + wrapper_check_if_supported_inplace_alter(TABLE *altered_table, + Alter_inplace_info *ha_alter_info); + enum_alter_inplace_result + storage_check_if_supported_inplace_alter(TABLE *altered_table, + Alter_inplace_info *ha_alter_info); + bool wrapper_prepare_inplace_alter_table(TABLE *altered_table, + Alter_inplace_info *ha_alter_info); + bool storage_prepare_inplace_alter_table(TABLE *altered_table, + Alter_inplace_info *ha_alter_info); + bool wrapper_inplace_alter_table(TABLE *altered_table, + Alter_inplace_info *ha_alter_info); + bool storage_inplace_alter_table_add_index(TABLE *altered_table, + Alter_inplace_info *ha_alter_info); + bool storage_inplace_alter_table_drop_index(TABLE *altered_table, + Alter_inplace_info *ha_alter_info); + bool storage_inplace_alter_table_add_column(TABLE *altered_table, + Alter_inplace_info *ha_alter_info); + bool storage_inplace_alter_table_drop_column(TABLE *altered_table, + Alter_inplace_info *ha_alter_info); + bool storage_inplace_alter_table_rename_column(TABLE *altered_table, + Alter_inplace_info *ha_alter_info); + bool storage_inplace_alter_table(TABLE *altered_table, + Alter_inplace_info *ha_alter_info); + bool wrapper_commit_inplace_alter_table(TABLE *altered_table, + Alter_inplace_info *ha_alter_info, + bool commit); + bool storage_commit_inplace_alter_table(TABLE *altered_table, + Alter_inplace_info *ha_alter_info, + bool commit); +#else + alter_table_operations wrapper_alter_table_flags(alter_table_operations flags); + alter_table_operations storage_alter_table_flags(alter_table_operations flags); +# ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX + int wrapper_add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys, + handler_add_index **add); + int storage_add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys, + handler_add_index **add); +# else + int wrapper_add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys); + int storage_add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys); +# endif +# ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX + int wrapper_final_add_index(handler_add_index *add, bool commit); + int storage_final_add_index(handler_add_index *add, bool commit); +# endif + int wrapper_prepare_drop_index(TABLE *table_arg, uint *key_num, + uint num_of_keys); + int storage_prepare_drop_index(TABLE *table_arg, uint *key_num, + uint num_of_keys); + int wrapper_final_drop_index(TABLE *table_arg); + int storage_final_drop_index(TABLE *table_arg); +#endif + int wrapper_update_auto_increment(); + int storage_update_auto_increment(); + void wrapper_set_next_insert_id(ulonglong id); + void storage_set_next_insert_id(ulonglong id); + void wrapper_get_auto_increment(ulonglong offset, ulonglong increment, + ulonglong nb_desired_values, + ulonglong *first_value, + ulonglong *nb_reserved_values); + void storage_get_auto_increment(ulonglong offset, ulonglong increment, + ulonglong nb_desired_values, + ulonglong *first_value, + ulonglong *nb_reserved_values); + void wrapper_restore_auto_increment(ulonglong prev_insert_id); + void storage_restore_auto_increment(ulonglong prev_insert_id); + void wrapper_release_auto_increment(); + void storage_release_auto_increment(); + int wrapper_check_for_upgrade(HA_CHECK_OPT *check_opt); + int storage_check_for_upgrade(HA_CHECK_OPT *check_opt); +#ifdef MRN_HANDLER_HAVE_RESET_AUTO_INCREMENT + int wrapper_reset_auto_increment(ulonglong value); + int storage_reset_auto_increment(ulonglong value); +#endif + bool wrapper_was_semi_consistent_read(); + bool storage_was_semi_consistent_read(); + void wrapper_try_semi_consistent_read(bool yes); + void storage_try_semi_consistent_read(bool yes); + void wrapper_unlock_row(); + void storage_unlock_row(); + int wrapper_start_stmt(THD *thd, thr_lock_type lock_type); + int storage_start_stmt(THD *thd, thr_lock_type lock_type); + void wrapper_change_table_ptr(TABLE *table_arg, TABLE_SHARE *share_arg); + void storage_change_table_ptr(TABLE *table_arg, TABLE_SHARE *share_arg); + bool wrapper_is_fk_defined_on_table_or_index(uint index); + bool storage_is_fk_defined_on_table_or_index(uint index); + char *wrapper_get_foreign_key_create_info(); + char *storage_get_foreign_key_create_info(); +#ifdef MRN_HANDLER_HAVE_GET_TABLESPACE_NAME + char *wrapper_get_tablespace_name(THD *thd, char *name, uint name_len); + char *storage_get_tablespace_name(THD *thd, char *name, uint name_len); +#endif + bool wrapper_can_switch_engines(); + bool storage_can_switch_engines(); + int wrapper_get_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list); + int storage_get_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list); + int wrapper_get_parent_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list); + int storage_get_parent_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list); + uint wrapper_referenced_by_foreign_key(); + uint storage_referenced_by_foreign_key(); + void wrapper_init_table_handle_for_HANDLER(); + void storage_init_table_handle_for_HANDLER(); + void wrapper_free_foreign_key_create_info(char* str); + void storage_free_foreign_key_create_info(char* str); + void wrapper_set_keys_in_use(); + void storage_set_keys_in_use(); +#ifdef MRN_RBR_UPDATE_NEED_ALL_COLUMNS + bool check_written_by_row_based_binlog(); +#endif +#ifdef MRN_HAVE_HA_REBIND_PSI + void wrapper_unbind_psi(); + void storage_unbind_psi(); + void wrapper_rebind(); + void storage_rebind(); +#endif + my_bool wrapper_register_query_cache_table(THD *thd, + const char *table_key, + uint key_length, + qc_engine_callback + *engine_callback, + ulonglong *engine_data); + my_bool storage_register_query_cache_table(THD *thd, + const char *table_key, + uint key_length, + qc_engine_callback + *engine_callback, + ulonglong *engine_data); +}; + +#ifdef __cplusplus +} +#endif + +#endif /* HA_MROONGA_HPP_ */ |