diff options
Diffstat (limited to 'storage/spider/ha_spider.h')
-rw-r--r-- | storage/spider/ha_spider.h | 1254 |
1 files changed, 1254 insertions, 0 deletions
diff --git a/storage/spider/ha_spider.h b/storage/spider/ha_spider.h new file mode 100644 index 00000000..5bc58397 --- /dev/null +++ b/storage/spider/ha_spider.h @@ -0,0 +1,1254 @@ +/* Copyright (C) 2008-2019 Kentoku Shiba + Copyright (C) 2019 MariaDB corp + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; version 2 of the License. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA */ + +#ifdef USE_PRAGMA_INTERFACE +#pragma interface +#endif + +#define SPIDER_CONNECT_INFO_MAX_LEN 64 +#define SPIDER_CONNECT_INFO_PATH_MAX_LEN FN_REFLEN +#define SPIDER_LONGLONG_LEN 20 +#define SPIDER_MAX_KEY_LENGTH 16384 + +#define SPIDER_SET_CONNS_PARAM(param_name, param_val, conns, link_statuses, conn_link_idx, link_count, link_status) \ + for ( \ + roop_count = spider_conn_link_idx_next(link_statuses, \ + conn_link_idx, -1, link_count, link_status); \ + roop_count < link_count; \ + roop_count = spider_conn_link_idx_next(link_statuses, \ + conn_link_idx, roop_count, link_count, link_status) \ + ) { \ + if (conns[roop_count]) \ + conns[roop_count]->param_name = param_val; \ + } + +class ha_spider; +struct st_spider_ft_info +{ + struct _ft_vft *please; + st_spider_ft_info *next; + ha_spider *file; + uint target; + bool used_in_where; + float score; + uint flags; + uint inx; + String *key; +}; + +class ha_spider final : public handler +{ +public: + SPIDER_SHARE *share; + ulonglong spider_thread_id; + ulonglong trx_conn_adjustment; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + ulonglong trx_hs_r_conn_adjustment; + ulonglong trx_hs_w_conn_adjustment; +#endif + uint mem_calc_id; + const char *mem_calc_func_name; + const char *mem_calc_file_name; + ulong mem_calc_line_no; + uint sql_kinds; + uint *sql_kind; + ulonglong *connection_ids; + uint conn_kinds; + uint *conn_kind; + char *conn_keys_first_ptr; + char **conn_keys; + SPIDER_CONN **conns; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + char **hs_r_conn_keys; + SPIDER_CONN **hs_r_conns; + ulonglong *hs_r_conn_ages; + char **hs_w_conn_keys; + SPIDER_CONN **hs_w_conns; + ulonglong *hs_w_conn_ages; +#endif + /* for active-standby mode */ + uint *conn_link_idx; + uchar *conn_can_fo; + void **quick_targets; + int *need_mons; + query_id_t search_link_query_id; + int search_link_idx; + int result_link_idx; + SPIDER_RESULT_LIST result_list; + spider_string *blob_buff; + SPIDER_POSITION *pushed_pos; + SPIDER_POSITION pushed_pos_buf; +#ifdef WITH_PARTITION_STORAGE_ENGINE + bool pt_handler_share_owner = FALSE; + SPIDER_PARTITION_HANDLER_SHARE *partition_handler_share; +#endif + bool wide_handler_owner = FALSE; + SPIDER_WIDE_HANDLER *wide_handler = NULL; + +#ifdef HA_CAN_BULK_ACCESS + int pre_direct_init_result; + bool is_bulk_access_clone; + bool synced_from_clone_source; + bool bulk_access_started; + bool bulk_access_executing; + bool bulk_access_pre_called; + SPIDER_BULK_ACCESS_LINK *bulk_access_link_first; + SPIDER_BULK_ACCESS_LINK *bulk_access_link_current; + SPIDER_BULK_ACCESS_LINK *bulk_access_link_exec_tgt; +/* + bool init_ha_mem_root; + MEM_ROOT ha_mem_root; +*/ +#endif + bool is_clone; + ha_spider *pt_clone_source_handler; + ha_spider *pt_clone_last_searcher; + bool use_index_merge; + + bool init_index_handler; + bool init_rnd_handler; + + bool da_status; + bool use_spatial_index; + +#ifdef SPIDER_HAS_GROUP_BY_HANDLER + uint idx_for_direct_join; + bool use_fields; + spider_fields *fields; + SPIDER_LINK_IDX_CHAIN *link_idx_chain; + SPIDER_LINK_IDX_CHAIN *result_link_idx_chain; +#endif + + /* for mrr */ + bool mrr_with_cnt; + uint multi_range_cnt; + uint multi_range_hit_point; +#ifdef HA_MRR_USE_DEFAULT_IMPL + int multi_range_num; + bool have_second_range; + KEY_MULTI_RANGE mrr_second_range; + spider_string *mrr_key_buff; +#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 + range_id_t *multi_range_keys; +#else + char **multi_range_keys; +#endif +#else + KEY_MULTI_RANGE *multi_range_ranges; +#endif + + char *append_tblnm_alias; + uint append_tblnm_alias_length; + + ha_spider *next; + + bool dml_inited; + bool rnd_scan_and_first; + bool use_pre_call; + bool use_pre_action; + bool pre_bitmap_checked; + bool bulk_insert; +#ifdef HANDLER_HAS_NEED_INFO_FOR_AUTO_INC + bool info_auto_called; +#endif +#ifdef HANDLER_HAS_CAN_USE_FOR_AUTO_INC_INIT + bool auto_inc_temporary; +#endif + int bulk_size; + int direct_dup_insert; + int store_error_num; + uint dup_key_idx; + int select_column_mode; + bool pk_update; + bool force_auto_increment; + int bka_mode; + int error_mode; + ulonglong store_last_insert_id; + + ulonglong *db_request_id; + uchar *db_request_phase; + uchar *m_handler_opened; + uint *m_handler_id; + char **m_handler_cid; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + uchar *r_handler_opened; + uint *r_handler_id; + uint *r_handler_index; + uchar *w_handler_opened; + uint *w_handler_id; + uint *w_handler_index; +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS + uchar *do_hs_direct_update; + uint32 **hs_r_ret_fields; + uint32 **hs_w_ret_fields; + size_t *hs_r_ret_fields_num; + size_t *hs_w_ret_fields_num; + uchar *tmp_column_bitmap; +#endif +#endif +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS + bool do_direct_update; +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + bool maybe_do_hs_direct_update; +#endif + uint direct_update_kinds; +#endif + spider_index_rnd_init prev_index_rnd_init; +#ifdef HANDLER_HAS_DIRECT_AGGREGATE + SPIDER_ITEM_HLD *direct_aggregate_item_first; + SPIDER_ITEM_HLD *direct_aggregate_item_current; +#endif + ha_rows table_rows; +#ifdef HA_HAS_CHECKSUM_EXTENDED + ha_checksum checksum_val; + bool checksum_null; + uint action_flags; +#endif + + /* for fulltext search */ + bool ft_init_and_first; + uint ft_init_idx; + uint ft_count; + bool ft_init_without_index_init; + st_spider_ft_info *ft_first; + st_spider_ft_info *ft_current; + + /* for dbton */ + spider_db_handler **dbton_handler; + + /* for direct limit offset */ + longlong direct_select_offset; + longlong direct_current_offset; + longlong direct_select_limit; + + ha_spider(); + ha_spider( + handlerton *hton, + TABLE_SHARE *table_arg + ); + virtual ~ha_spider(); + handler *clone( + const char *name, + MEM_ROOT *mem_root + ); + const char **bas_ext() const; + int open( + const char* name, + int mode, + uint test_if_locked + ); + int close(); + int check_access_kind_for_connection( + THD *thd, + bool write_request + ); + void check_access_kind( + THD *thd + ); +#ifdef HA_CAN_BULK_ACCESS + int additional_lock( + THD *thd, + enum thr_lock_type lock_type + ); +#endif + THR_LOCK_DATA **store_lock( + THD *thd, + THR_LOCK_DATA **to, + enum thr_lock_type lock_type + ); + int external_lock( + THD *thd, + int lock_type + ); + int start_stmt( + THD *thd, + thr_lock_type lock_type + ); + int reset(); + int extra( + enum ha_extra_function operation + ); + int index_init( + uint idx, + bool sorted + ); +#ifdef HA_CAN_BULK_ACCESS + int pre_index_init( + uint idx, + bool sorted + ); +#endif + int index_end(); +#ifdef HA_CAN_BULK_ACCESS + int pre_index_end(); +#endif + 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 + ); + 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 read_range_first( + const key_range *start_key, + const key_range *end_key, + bool eq_range, + bool sorted + ); + int read_range_next(); + void reset_no_where_cond(); + bool check_no_where_cond(); +#ifdef HA_MRR_USE_DEFAULT_IMPL +#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 + 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 + ); + ha_rows multi_range_read_info( + uint keyno, + uint n_ranges, + uint keys, + uint key_parts, + uint *bufsz, + uint *flags, + Cost_estimate *cost + ); +#else + 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_VECT *cost + ); + ha_rows multi_range_read_info( + uint keyno, + uint n_ranges, + uint keys, + uint key_parts, + uint *bufsz, + uint *flags, + COST_VECT *cost + ); +#endif + int multi_range_read_init( + RANGE_SEQ_IF *seq, + void *seq_init_param, + uint n_ranges, + uint mode, + HANDLER_BUFFER *buf + ); +#if defined(MARIADB_BASE_VERSION) && MYSQL_VERSION_ID >= 100000 + int multi_range_read_next( + range_id_t *range_info + ); + int multi_range_read_next_first( + range_id_t *range_info + ); + int multi_range_read_next_next( + range_id_t *range_info + ); +#else + int multi_range_read_next( + char **range_info + ); + int multi_range_read_next_first( + char **range_info + ); + int multi_range_read_next_next( + char **range_info + ); +#endif +#else + 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 + int rnd_init( + bool scan + ); +#ifdef HA_CAN_BULK_ACCESS + int pre_rnd_init( + bool scan + ); +#endif + int rnd_end(); +#ifdef HA_CAN_BULK_ACCESS + int pre_rnd_end(); +#endif + int rnd_next( + uchar *buf + ); + void position( + const uchar *record + ); + int rnd_pos( + uchar *buf, + uchar *pos + ); + int cmp_ref( + const uchar *ref1, + const uchar *ref2 + ); + int ft_init(); + void ft_end(); + FT_INFO *ft_init_ext( + uint flags, + uint inx, + String *key + ); + int ft_read( + uchar *buf + ); + int pre_index_read_map( + const uchar *key, + key_part_map keypart_map, + enum ha_rkey_function find_flag, + bool use_parallel + ); + int pre_index_first(bool use_parallel); + int pre_index_last(bool use_parallel); + int pre_index_read_last_map( + const uchar *key, + key_part_map keypart_map, + bool use_parallel + ); +#ifdef HA_MRR_USE_DEFAULT_IMPL + int pre_multi_range_read_next( + bool use_parallel + ); +#else + int pre_read_multi_range_first( + KEY_MULTI_RANGE **found_range_p, + KEY_MULTI_RANGE *ranges, + uint range_count, + bool sorted, + HANDLER_BUFFER *buffer, + bool use_parallel + ); +#endif + int pre_read_range_first( + const key_range *start_key, + const key_range *end_key, + bool eq_range, + bool sorted, + bool use_parallel + ); + int pre_ft_read(bool use_parallel); + int pre_rnd_next(bool use_parallel); + int info( + uint flag + ); + ha_rows records_in_range( + uint inx, + const key_range *start_key, + const key_range *end_key, + page_range *pages + ); + int check_crd(); + int pre_records(); + ha_rows records(); +#ifdef HA_HAS_CHECKSUM_EXTENDED + int pre_calculate_checksum(); + int calculate_checksum(); +#endif + const char *table_type() const; + ulonglong table_flags() const; + ulong table_flags_for_partition(); + const char *index_type( + uint key_number + ); + ulong index_flags( + uint idx, + uint part, + bool all_parts + ) const; + uint max_supported_record_length() const; + uint max_supported_keys() const; + uint max_supported_key_parts() const; + uint max_supported_key_length() const; + uint max_supported_key_part_length() const; + uint8 table_cache_type(); +#ifdef HANDLER_HAS_NEED_INFO_FOR_AUTO_INC + bool need_info_for_auto_inc(); +#endif +#ifdef HANDLER_HAS_CAN_USE_FOR_AUTO_INC_INIT + bool can_use_for_auto_inc_init(); +#endif + int update_auto_increment(); + void get_auto_increment( + ulonglong offset, + ulonglong increment, + ulonglong nb_desired_values, + ulonglong *first_value, + ulonglong *nb_reserved_values + ); + int reset_auto_increment( + ulonglong value + ); + void release_auto_increment(); +#ifdef SPIDER_HANDLER_START_BULK_INSERT_HAS_FLAGS + void start_bulk_insert( + ha_rows rows, + uint flags + ); +#else + void start_bulk_insert( + ha_rows rows + ); +#endif + int end_bulk_insert(); + int write_row( + const uchar *buf + ); +#ifdef HA_CAN_BULK_ACCESS + int pre_write_row( + uchar *buf + ); +#endif +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS + void direct_update_init( + THD *thd, + bool hs_request + ); +#endif + bool start_bulk_update(); + int exec_bulk_update( + ha_rows *dup_key_found + ); + int end_bulk_update(); +#ifdef SPIDER_UPDATE_ROW_HAS_CONST_NEW_DATA + int bulk_update_row( + const uchar *old_data, + const uchar *new_data, + ha_rows *dup_key_found + ); + int update_row( + const uchar *old_data, + const uchar *new_data + ); +#else + int bulk_update_row( + const uchar *old_data, + uchar *new_data, + ha_rows *dup_key_found + ); + int update_row( + const uchar *old_data, + uchar *new_data + ); +#endif +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS + bool check_direct_update_sql_part( + st_select_lex *select_lex, + longlong select_limit, + longlong offset_limit + ); +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS +#ifdef SPIDER_MDEV_16246 + inline int direct_update_rows_init( + List<Item> *update_fields + ) { + return direct_update_rows_init(update_fields, 2, NULL, 0, FALSE, NULL); + } + int direct_update_rows_init( + List<Item> *update_fields, + uint mode, + KEY_MULTI_RANGE *ranges, + uint range_count, + bool sorted, + uchar *new_data + ); +#else + inline int direct_update_rows_init() + { + return direct_update_rows_init(2, NULL, 0, FALSE, NULL); + } + int direct_update_rows_init( + uint mode, + KEY_MULTI_RANGE *ranges, + uint range_count, + bool sorted, + uchar *new_data + ); +#endif +#else +#ifdef SPIDER_MDEV_16246 + int direct_update_rows_init( + List<Item> *update_fields + ); +#else + int direct_update_rows_init(); +#endif +#endif +#ifdef HA_CAN_BULK_ACCESS +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS +#ifdef SPIDER_MDEV_16246 + inline int pre_direct_update_rows_init( + List<Item> *update_fields + ) { + return pre_direct_update_rows_init(update_fields, 2, NULL, 0, FALSE, NULL); + } + int pre_direct_update_rows_init( + List<Item> *update_fields, + uint mode, + KEY_MULTI_RANGE *ranges, + uint range_count, + bool sorted, + uchar *new_data + ); +#else + inline int pre_direct_update_rows_init() + { + return pre_direct_update_rows_init(2, NULL, 0, FALSE, NULL); + } + int pre_direct_update_rows_init( + uint mode, + KEY_MULTI_RANGE *ranges, + uint range_count, + bool sorted, + uchar *new_data + ); +#endif +#else +#ifdef SPIDER_MDEV_16246 + int pre_direct_update_rows_init( + List<Item> *update_fields + ); +#else + int pre_direct_update_rows_init(); +#endif +#endif +#endif +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS + inline int direct_update_rows(ha_rows *update_rows, ha_rows *found_rows) + { + return direct_update_rows(NULL, 0, FALSE, NULL, update_rows, found_rows); + } + int direct_update_rows( + KEY_MULTI_RANGE *ranges, + uint range_count, + bool sorted, + uchar *new_data, + ha_rows *update_rows, + ha_rows *found_row + ); +#else + int direct_update_rows( + ha_rows *update_rows, + ha_rows *found_row + ); +#endif +#ifdef HA_CAN_BULK_ACCESS +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS + inline int pre_direct_update_rows() + { + ha_rows update_rows; + ha_rows found_rows; + + return pre_direct_update_rows(NULL, 0, FALSE, NULL, &update_rows, + &found_rows); + } + int pre_direct_update_rows( + KEY_MULTI_RANGE *ranges, + uint range_count, + bool sorted, + uchar *new_data, + ha_rows *update_rows, + ha_rows *found_row + ); +#else + int pre_direct_update_rows(); +#endif +#endif +#endif + bool start_bulk_delete(); + int end_bulk_delete(); + int delete_row( + const uchar *buf + ); +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS + bool check_direct_delete_sql_part( + st_select_lex *select_lex, + longlong select_limit, + longlong offset_limit + ); +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS + inline int direct_delete_rows_init() + { + return direct_delete_rows_init(2, NULL, 0, FALSE); + } + int direct_delete_rows_init( + uint mode, + KEY_MULTI_RANGE *ranges, + uint range_count, + bool sorted + ); +#else + int direct_delete_rows_init(); +#endif +#ifdef HA_CAN_BULK_ACCESS +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS + inline int pre_direct_delete_rows_init() + { + return pre_direct_delete_rows_init(2, NULL, 0, FALSE); + } + int pre_direct_delete_rows_init( + uint mode, + KEY_MULTI_RANGE *ranges, + uint range_count, + bool sorted + ); +#else + int pre_direct_delete_rows_init(); +#endif +#endif +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS + inline int direct_delete_rows(ha_rows *delete_rows) + { + return direct_delete_rows(NULL, 0, FALSE, delete_rows); + } + int direct_delete_rows( + KEY_MULTI_RANGE *ranges, + uint range_count, + bool sorted, + ha_rows *delete_rows + ); +#else + int direct_delete_rows( + ha_rows *delete_rows + ); +#endif +#ifdef HA_CAN_BULK_ACCESS +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS_WITH_HS + inline int pre_direct_delete_rows() + { + ha_rows delete_rows; + + return pre_direct_delete_rows(NULL, 0, FALSE, &delete_rows); + } + int pre_direct_delete_rows( + KEY_MULTI_RANGE *ranges, + uint range_count, + bool sorted, + ha_rows *delete_rows + ); +#else + int pre_direct_delete_rows(); +#endif +#endif +#endif + int delete_all_rows(); + int truncate(); + double scan_time(); + double read_time( + uint index, + uint ranges, + ha_rows rows + ); +#ifdef HA_CAN_BULK_ACCESS + void bulk_req_exec(); +#endif + const key_map *keys_to_use_for_scanning(); + ha_rows estimate_rows_upper_bound(); + void print_error( + int error, + myf errflag + ); + bool get_error_message( + int error, + String *buf + ); + int create( + const char *name, + TABLE *form, + HA_CREATE_INFO *info + ); + void update_create_info( + HA_CREATE_INFO* create_info + ); + int rename_table( + const char *from, + const char *to + ); + int delete_table( + const char *name + ); + bool is_crashed() const; +#ifdef SPIDER_HANDLER_AUTO_REPAIR_HAS_ERROR + bool auto_repair(int error) const; +#else + bool auto_repair() const; +#endif + int disable_indexes( + uint mode + ); + int enable_indexes( + uint mode + ); + int check( + THD* thd, + HA_CHECK_OPT* check_opt + ); + int repair( + THD* thd, + HA_CHECK_OPT* check_opt + ); + bool check_and_repair( + THD *thd + ); + int analyze( + THD* thd, + HA_CHECK_OPT* check_opt + ); + int optimize( + THD* thd, + HA_CHECK_OPT* check_opt + ); + bool is_fatal_error( + int error_num, + uint flags + ); + Field *field_exchange( + Field *field + ); + const COND *cond_push( + const COND* cond + ); + void cond_pop(); + int info_push( + uint info_type, + void *info + ); +#ifdef HANDLER_HAS_DIRECT_AGGREGATE + void return_record_by_parent(); +#endif + TABLE *get_table(); + void set_ft_discard_bitmap(); + void set_searched_bitmap(); + void set_clone_searched_bitmap(); + void set_searched_bitmap_from_item_list(); + void set_select_column_mode(); +#ifdef WITH_PARTITION_STORAGE_ENGINE + void check_select_column(bool rnd); +#endif + bool check_and_start_bulk_update( + spider_bulk_upd_start bulk_upd_start + ); + int check_and_end_bulk_update( + spider_bulk_upd_start bulk_upd_start + ); + uint check_partitioned(); + void check_direct_order_limit(); + void check_distinct_key_query(); + bool is_sole_projection_field( + uint16 field_index + ); + int check_ha_range_eof(); + int drop_tmp_tables(); + bool handler_opened( + int link_idx, + uint tgt_conn_kind + ); + void set_handler_opened( + int link_idx + ); + void clear_handler_opened( + int link_idx, + uint tgt_conn_kind + ); + int close_opened_handler( + int link_idx, + bool release_conn + ); + int index_handler_init(); + int rnd_handler_init(); + void set_error_mode(); + void backup_error_status(); + int check_error_mode( + int error_num + ); + int check_error_mode_eof( + int error_num + ); + int index_read_map_internal( + uchar *buf, + const uchar *key, + key_part_map keypart_map, + enum ha_rkey_function find_flag + ); + int index_read_last_map_internal( + uchar *buf, + const uchar *key, + key_part_map keypart_map + ); + int index_first_internal(uchar *buf); + int index_last_internal(uchar *buf); + int read_range_first_internal( + uchar *buf, + const key_range *start_key, + const key_range *end_key, + bool eq_range, + bool sorted + ); +#ifdef HA_MRR_USE_DEFAULT_IMPL +#else + int read_multi_range_first_internal( + uchar *buf, + KEY_MULTI_RANGE **found_range_p, + KEY_MULTI_RANGE *ranges, + uint range_count, + bool sorted, + HANDLER_BUFFER *buffer + ); +#endif + int ft_read_internal(uchar *buf); + int rnd_next_internal(uchar *buf); + void check_pre_call( + bool use_parallel + ); +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS + void check_insert_dup_update_pushdown(); +#endif +#ifdef HA_CAN_BULK_ACCESS + SPIDER_BULK_ACCESS_LINK *create_bulk_access_link(); + void delete_bulk_access_link( + SPIDER_BULK_ACCESS_LINK *bulk_access_link + ); + int sync_from_clone_source( + ha_spider *spider + ); +#endif + void sync_from_clone_source_base( + ha_spider *spider + ); + void set_first_link_idx(); + void reset_first_link_idx(); + int reset_sql_sql( + ulong sql_type + ); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + int reset_hs_sql( + ulong sql_type + ); + int reset_hs_keys( + ulong sql_type + ); + int reset_hs_upds( + ulong sql_type + ); + int reset_hs_strs( + ulong sql_type + ); + int reset_hs_strs_pos( + ulong sql_type + ); + int push_back_hs_upds( + SPIDER_HS_STRING_REF &info + ); +#endif + int append_tmp_table_and_sql_for_bka( + const key_range *start_key + ); + int reuse_tmp_table_and_sql_for_bka(); + int append_union_table_and_sql_for_bka( + const key_range *start_key + ); + int reuse_union_table_and_sql_for_bka(); + int append_insert_sql_part(); + int append_update_sql_part(); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS + int append_increment_update_set_sql_part(); +#endif +#endif + int append_update_set_sql_part(); +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS + int append_direct_update_set_sql_part(); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + int append_direct_update_set_hs_part(); +#endif +#endif +#ifdef HANDLER_HAS_DIRECT_UPDATE_ROWS + int append_dup_update_pushdown_sql_part( + const char *alias, + uint alias_length + ); + int append_update_columns_sql_part( + const char *alias, + uint alias_length + ); + int check_update_columns_sql_part(); +#endif + int append_delete_sql_part(); + int append_select_sql_part( + ulong sql_type + ); + int append_table_select_sql_part( + ulong sql_type + ); + int append_key_select_sql_part( + ulong sql_type, + uint idx + ); + int append_minimum_select_sql_part( + ulong sql_type + ); + int append_from_sql_part( + ulong sql_type + ); + int append_hint_after_table_sql_part( + ulong sql_type + ); + void set_where_pos_sql( + ulong sql_type + ); + void set_where_to_pos_sql( + ulong sql_type + ); + int check_item_type_sql( + Item *item + ); + int append_values_connector_sql_part( + ulong sql_type + ); + int append_values_terminator_sql_part( + ulong sql_type + ); + int append_union_table_connector_sql_part( + ulong sql_type + ); + int append_union_table_terminator_sql_part( + ulong sql_type + ); + int append_key_column_values_sql_part( + const key_range *start_key, + ulong sql_type + ); + int append_key_column_values_with_name_sql_part( + const key_range *start_key, + ulong sql_type + ); + int append_key_where_sql_part( + const key_range *start_key, + const key_range *end_key, + ulong sql_type + ); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + int append_key_where_hs_part( + const key_range *start_key, + const key_range *end_key, + ulong sql_type + ); +#endif + int append_match_where_sql_part( + ulong sql_type + ); + int append_condition_sql_part( + const char *alias, + uint alias_length, + ulong sql_type, + bool test_flg + ); +#ifdef HANDLER_HAS_DIRECT_AGGREGATE + int append_sum_select_sql_part( + ulong sql_type, + const char *alias, + uint alias_length + ); +#endif + int append_match_select_sql_part( + ulong sql_type, + const char *alias, + uint alias_length + ); + void set_order_pos_sql( + ulong sql_type + ); + void set_order_to_pos_sql( + ulong sql_type + ); +#ifdef HANDLER_HAS_DIRECT_AGGREGATE + int append_group_by_sql_part( + const char *alias, + uint alias_length, + ulong sql_type + ); +#endif + int append_key_order_for_merge_with_alias_sql_part( + const char *alias, + uint alias_length, + ulong sql_type + ); + int append_key_order_for_direct_order_limit_with_alias_sql_part( + const char *alias, + uint alias_length, + ulong sql_type + ); + int append_key_order_with_alias_sql_part( + const char *alias, + uint alias_length, + ulong sql_type + ); + int append_limit_sql_part( + longlong offset, + longlong limit, + ulong sql_type + ); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + int append_limit_hs_part( + longlong offset, + longlong limit, + ulong sql_type + ); +#endif + int reappend_limit_sql_part( + longlong offset, + longlong limit, + ulong sql_type + ); + int append_insert_terminator_sql_part( + ulong sql_type + ); + int append_insert_values_sql_part( + ulong sql_type + ); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + int append_insert_values_hs_part( + ulong sql_type + ); +#endif + int append_into_sql_part( + ulong sql_type + ); + void set_insert_to_pos_sql( + ulong sql_type + ); + bool is_bulk_insert_exec_period( + bool bulk_end + ); + int append_select_lock_sql_part( + ulong sql_type + ); + int append_union_all_start_sql_part( + ulong sql_type + ); + int append_union_all_sql_part( + ulong sql_type + ); + int append_union_all_end_sql_part( + ulong sql_type + ); + int append_multi_range_cnt_sql_part( + ulong sql_type, + uint multi_range_cnt, + bool with_comma + ); + int append_multi_range_cnt_with_name_sql_part( + ulong sql_type, + uint multi_range_cnt + ); + int append_delete_all_rows_sql_part( + ulong sql_type + ); + int append_update_sql( + const TABLE *table, + my_ptrdiff_t ptr_diff, + bool bulk + ); + int append_delete_sql( + const TABLE *table, + my_ptrdiff_t ptr_diff, + bool bulk + ); + bool sql_is_filled_up( + ulong sql_type + ); + bool sql_is_empty( + ulong sql_type + ); + bool support_multi_split_read_sql(); + bool support_bulk_update_sql(); + int bulk_tmp_table_insert(); + int bulk_tmp_table_end_bulk_insert(); + int bulk_tmp_table_rnd_init(); + int bulk_tmp_table_rnd_next(); + int bulk_tmp_table_rnd_end(); + int mk_bulk_tmp_table_and_bulk_start(); + void rm_bulk_tmp_table(); + bool bulk_tmp_table_created(); + int print_item_type( + Item *item, + spider_string *str, + const char *alias, + uint alias_length + ); + bool support_use_handler_sql( + int use_handler + ); +#if defined(HS_HAS_SQLCOM) && defined(HAVE_HANDLERSOCKET) + bool support_bulk_access_hs() const; +#endif + int init_union_table_name_pos_sql(); + int set_union_table_name_pos_sql(); + int append_lock_tables_list(); + int lock_tables(); + int dml_init(); +#ifdef HA_CAN_BULK_ACCESS + int bulk_access_begin( + void *info + ); + int bulk_access_current( + void *info + ); + void bulk_access_end(); +#endif +}; |