1 /* -*- c-basic-offset: 2; indent-tabs-mode: nil -*- */ 2 /* 3 Copyright(C) 2010 Tetsuro IKEDA 4 Copyright(C) 2010-2013 Kentoku SHIBA 5 Copyright(C) 2011-2013 Kouhei Sutou <kou@clear-code.com> 6 7 This library is free software; you can redistribute it and/or 8 modify it under the terms of the GNU Lesser General Public 9 License as published by the Free Software Foundation; either 10 version 2.1 of the License, or (at your option) any later version. 11 12 This library is distributed in the hope that it will be useful, 13 but WITHOUT ANY WARRANTY; without even the implied warranty of 14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 15 Lesser General Public License for more details. 16 17 You should have received a copy of the GNU Lesser General Public 18 License along with this library; if not, write to the Free Software 19 Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1335 USA 20 */ 21 22 #ifndef HA_MROONGA_HPP_ 23 #define HA_MROONGA_HPP_ 24 25 #ifdef USE_PRAGMA_INTERFACE 26 #pragma interface 27 #endif 28 29 #ifdef __cplusplus 30 extern "C" { 31 #endif 32 33 #include <groonga.h> 34 #include "mrn_mysql_compat.h" 35 #include <mrn_operations.hpp> 36 #include <mrn_database.hpp> 37 38 #if __cplusplus >= 201402 39 # define mrn_override override 40 #else 41 # define mrn_override 42 #endif 43 44 #if (MYSQL_VERSION_ID >= 50514 && MYSQL_VERSION_ID < 50600) 45 # define MRN_HANDLER_HAVE_FINAL_ADD_INDEX 1 46 #endif 47 48 #if (MYSQL_VERSION_ID >= 50603) || defined(MRN_MARIADB_P) 49 # define MRN_HANDLER_HAVE_HA_RND_NEXT 1 50 # define MRN_HANDLER_HAVE_HA_RND_POS 1 51 # define MRN_HANDLER_HAVE_HA_INDEX_READ_MAP 1 52 # define MRN_HANDLER_HAVE_HA_INDEX_READ_IDX_MAP 1 53 # define MRN_HANDLER_HAVE_HA_INDEX_NEXT 1 54 # define MRN_HANDLER_HAVE_HA_INDEX_PREV 1 55 # define MRN_HANDLER_HAVE_HA_INDEX_FIRST 1 56 # define MRN_HANDLER_HAVE_HA_INDEX_LAST 1 57 # define MRN_HANDLER_HAVE_HA_INDEX_NEXT_SAME 1 58 #endif 59 60 #if (MYSQL_VERSION_ID >= 50604) || defined(MRN_MARIADB_P) 61 # define MRN_HANDLER_HAVE_HA_CLOSE 1 62 # define MRN_HANDLER_HAVE_MULTI_RANGE_READ 1 63 #endif 64 65 #if (MYSQL_VERSION_ID >= 50607) 66 # define MRN_HANDLER_HAVE_CHECK_IF_SUPPORTED_INPLACE_ALTER 1 67 # define MRN_HANDLER_HAVE_HA_PREPARE_INPLACE_ALTER_TABLE 1 68 # define MRN_HANDLER_HAVE_HA_INPLACE_ALTER_TABLE 1 69 # define MRN_HANDLER_HAVE_HA_COMMIT_INPLACE_ALTER_TABLE 1 70 # define MRN_SUPPORT_FOREIGN_KEYS 1 71 #endif 72 73 #ifndef MRN_MARIADB_P 74 # define MRN_HANDLER_HAVE_INDEX_READ_LAST_MAP 75 # if MYSQL_VERSION_ID >= 50611 76 # define MRN_HANDLER_HAVE_HA_INDEX_READ_LAST_MAP 77 # endif 78 #endif 79 80 #ifdef MRN_MARIADB_P 81 # define MRN_HANDLER_HAVE_MULTI_RANGE_READ_INFO_KEY_PARTS 82 #endif 83 84 #if MYSQL_VERSION_ID < 50600 85 # define MRN_HANDLER_HAVE_GET_TABLESPACE_NAME 86 #endif 87 88 #if MYSQL_VERSION_ID >= 50607 89 # define MRN_HANDLER_HAVE_SET_HA_SHARE_REF 90 #endif 91 92 #if MYSQL_VERSION_ID >= 50706 && !defined(MRN_MARIADB_P) 93 # define MRN_BIG_TABLES 94 #elif defined(BIG_TABLES) 95 # define MRN_BIG_TABLES 96 #endif 97 98 #ifdef MRN_BIG_TABLES 99 # define MRN_HA_ROWS_FORMAT "llu" 100 #else 101 # define MRN_HA_ROWS_FORMAT "lu" 102 #endif 103 104 #ifdef MRN_MARIADB_P 105 # define MRN_NEED_FREE_STRING_MEMALLOC_PLUGIN_VAR 106 #endif 107 108 #ifdef MRN_MARIADB_P 109 # define MRN_HAVE_HA_EXTRA_DETACH_CHILD 110 # define MRN_HAVE_HA_EXTRA_PREPARE_FOR_FORCED_CLOSE 111 #endif 112 113 #if (!defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 80002) 114 #define MRN_HAVE_HA_EXTRA_SKIP_SERIALIZABLE_DD_VIEW 115 #define MRN_HAVE_HA_EXTRA_BEGIN_ALTER_COPY 116 #define MRN_HAVE_HA_EXTRA_END_ALTER_COPY 117 #define MRN_HAVE_HA_EXTRA_NO_AUTOINC_LOCKING 118 #endif 119 120 #if MYSQL_VERSION_ID >= 50607 && \ 121 (!defined(MRN_MARIADB_P) || MYSQL_VERSION_ID < 100008) 122 # define MRN_HAVE_HA_EXTRA_EXPORT 123 #endif 124 125 #if MYSQL_VERSION_ID >= 50617 && !defined(MRN_MARIADB_P) 126 # define MRN_HAVE_HA_EXTRA_SECONDARY_SORT_ROWID 127 #endif 128 129 #if MYSQL_VERSION_ID >= 50604 && !defined(MRN_MARIADB_P) 130 # define MRN_TIMESTAMP_USE_TIMEVAL 131 #elif defined(MRN_MARIADB_P) 132 # define MRN_TIMESTAMP_USE_MY_TIME_T 133 #else 134 # define MRN_TIMESTAMP_USE_LONG 135 #endif 136 137 #if MYSQL_VERSION_ID < 50600 && !defined(MRN_MARIADB_P) 138 # define MRN_FIELD_STORE_TIME_NEED_TYPE 139 #endif 140 141 #if MYSQL_VERSION_ID < 50706 || defined(MRN_MARIADB_P) 142 # define MRN_HAVE_TL_WRITE_DELAYED 143 #endif 144 145 #if MYSQL_VERSION_ID >= 50706 && !defined(MRN_MARIADB_P) 146 # define MRN_HAVE_TL_WRITE_CONCURRENT_DEFAULT 147 #endif 148 149 #ifdef MRN_MARIADB_P 150 # define MRN_HANDLER_AUTO_REPAIR_HAVE_ERROR 151 #endif 152 153 #if MYSQL_VERSION_ID >= 50604 154 # define MRN_JOIN_TAB_HAVE_CONDITION 155 #endif 156 157 #if MYSQL_VERSION_ID < 50600 158 # define MRN_RBR_UPDATE_NEED_ALL_COLUMNS 159 #endif 160 161 #if MYSQL_VERSION_ID >= 50500 162 # define MRN_ROW_BASED_CHECK_IS_METHOD 163 #endif 164 165 #if MYSQL_VERSION_ID >= 50600 166 # define MRN_HAVE_HA_REBIND_PSI 167 #endif 168 169 #if MYSQL_VERSION_ID >= 50612 && !defined(MRN_MARIADB_P) 170 # define MRN_HAVE_POINT_XY 171 #endif 172 173 #if (defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 100000) 174 # define MRN_HANDLER_START_BULK_INSERT_HAS_FLAGS 175 #endif 176 177 #if (defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 100010) 178 # define MRN_HAVE_TDC_LOCK_TABLE_SHARE 179 # if MYSQL_VERSION_ID >= 100100 180 # define MRN_TABLE_SHARE_TDC_IS_POINTER 181 # endif 182 #endif 183 184 #ifdef MRN_MARIADB_P 185 # if MYSQL_VERSION_ID >= 50542 && MYSQL_VERSION_ID < 100000 186 # define MRN_SUPPORT_THDVAR_SET 187 # elif MYSQL_VERSION_ID >= 100017 188 # define MRN_SUPPORT_THDVAR_SET 189 # endif 190 #else 191 # define MRN_SUPPORT_THDVAR_SET 192 #endif 193 194 #ifdef MRN_MARIADB_P 195 # if MYSQL_VERSION_ID < 100000 196 # define MRN_SUPPORT_PARTITION 197 # endif 198 #else 199 # define MRN_SUPPORT_PARTITION 200 #endif 201 202 #if MYSQL_VERSION_ID >= 50706 && !defined(MRN_MARIADB_P) 203 # define MRN_FLUSH_LOGS_HAVE_BINLOG_GROUP_FLUSH 204 #endif 205 206 #if MYSQL_VERSION_ID < 50706 || defined(MRN_MARIADB_P) 207 # define MRN_HAVE_HTON_ALTER_TABLE_FLAGS 208 #endif 209 210 #if MYSQL_VERSION_ID >= 50706 211 # define MRN_FOREIGN_KEY_USE_CONST_STRING 212 #endif 213 214 #if MYSQL_VERSION_ID < 50706 || defined(MRN_MARIADB_P) 215 # define MRN_HANDLER_IS_FATAL_ERROR_HAVE_FLAGS 216 #endif 217 218 #if MYSQL_VERSION_ID < 50706 || defined(MRN_MARIADB_P) 219 # define MRN_HANDLER_HAVE_RESET_AUTO_INCREMENT 220 #endif 221 222 #if (!defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 50709) || \ 223 (defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 100203) 224 # define MRN_ALTER_INPLACE_INFO_ALTER_STORED_COLUMN_TYPE \ 225 ALTER_STORED_COLUMN_TYPE 226 # define MRN_ALTER_INPLACE_INFO_ALTER_STORED_COLUMN_ORDER \ 227 ALTER_STORED_COLUMN_ORDER 228 #else 229 # define MRN_ALTER_INPLACE_INFO_ALTER_STORED_COLUMN_TYPE \ 230 Alter_inplace_info::ALTER_COLUMN_TYPE 231 # define MRN_ALTER_INPLACE_INFO_ALTER_STORED_COLUMN_ORDER \ 232 Alter_inplace_info::ALTER_COLUMN_ORDER 233 #endif 234 235 #if MYSQL_VERSION_ID >= 50700 && !defined(MRN_MARIADB_P) 236 # define MRN_HANDLER_RECORDS_RETURN_ERROR 237 #endif 238 239 #if MYSQL_VERSION_ID < 80002 || defined(MRN_MARIADB_P) 240 # define MRN_HANDLER_HAVE_KEYS_TO_USE_FOR_SCANNING 241 #endif 242 243 #if (!defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 80002) 244 # define MRN_ST_MYSQL_PLUGIN_HAVE_CHECK_UNINSTALL 245 #endif 246 247 #if (!defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 80002) 248 # define MRN_HANDLER_OPEN_HAVE_TABLE_DEFINITION 249 # define MRN_HANDLER_CREATE_HAVE_TABLE_DEFINITION 250 #endif 251 252 #if (!defined(MRN_MARIADB_P) && MYSQL_VERSION_ID >= 80002) 253 # define MRN_HANDLERTON_CREATE_HAVE_PARTITIONED 254 #endif 255 256 #if defined(HAVE_PSI_INTERFACE) && \ 257 (MYSQL_VERSION_ID < 80002 || defined(MRN_MARIADB_P)) 258 # define MRN_HAVE_PSI_SERVER 259 #endif 260 261 class ha_mroonga; 262 263 /* structs */ 264 struct st_mrn_ft_info 265 { 266 struct _ft_vft *please; 267 #ifdef HA_CAN_FULLTEXT_EXT 268 struct _ft_vft_ext *could_you; 269 #endif 270 grn_ctx *ctx; 271 grn_encoding encoding; 272 grn_obj *table; 273 grn_obj *result; 274 grn_obj *score_column; 275 grn_obj key; 276 grn_obj score; 277 uint active_index; 278 KEY *key_info; 279 KEY *primary_key_info; 280 grn_obj *cursor; 281 grn_obj *id_accessor; 282 grn_obj *key_accessor; 283 ha_mroonga *mroonga; 284 }; 285 286 #ifdef MRN_SUPPORT_CUSTOM_OPTIONS 287 struct ha_field_option_struct 288 { 289 const char *groonga_type; 290 const char *flags; 291 }; 292 293 struct ha_index_option_struct 294 { 295 const char *tokenizer; 296 const char *normalizer; 297 const char *token_filters; 298 const char *flags; 299 }; 300 #endif 301 302 /* handler class */ 303 class ha_mroonga: public handler 304 { 305 public: 306 handler *wrap_handler; 307 bool is_clone; 308 ha_mroonga *parent_for_clone; 309 MEM_ROOT *mem_root_for_clone; 310 grn_obj key_buffer; 311 grn_id record_id; 312 grn_id *key_id; 313 grn_id *del_key_id; 314 MY_BITMAP multiple_column_key_bitmap; 315 316 private: 317 THR_LOCK_DATA thr_lock_data; 318 319 // for wrapper mode (TODO: need to be confirmed) 320 uint wrap_ft_init_count; 321 MRN_SHARE *share; 322 KEY *wrap_key_info; 323 KEY *base_key_info; 324 key_part_map pk_keypart_map; 325 MEM_ROOT mem_root; 326 /// for create table and alter table 327 mutable bool analyzed_for_create; 328 mutable TABLE table_for_create; 329 mutable MRN_SHARE share_for_create; 330 mutable TABLE_SHARE table_share_for_create; 331 mutable MEM_ROOT mem_root_for_create; 332 mutable handler *wrap_handler_for_create; 333 #ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX 334 handler_add_index *hnd_add_index; 335 #endif 336 #ifdef MRN_HANDLER_HAVE_CHECK_IF_SUPPORTED_INPLACE_ALTER 337 alter_table_operations alter_handler_flags; 338 KEY *alter_key_info_buffer; 339 uint alter_key_count; 340 uint alter_index_drop_count; 341 KEY *alter_index_drop_buffer; 342 uint alter_index_add_count; 343 uint *alter_index_add_buffer; 344 TABLE *wrap_altered_table; 345 KEY *wrap_altered_table_key_info; 346 TABLE_SHARE *wrap_altered_table_share; 347 KEY *wrap_altered_table_share_key_info; 348 #else 349 KEY *wrap_alter_key_info; 350 #endif 351 int mrn_lock_type; 352 353 // for groonga objects 354 grn_ctx ctx_entity_; 355 grn_ctx *ctx; 356 grn_obj *grn_table; 357 grn_obj **grn_columns; 358 grn_obj **grn_column_ranges; 359 grn_obj **grn_index_tables; 360 grn_obj **grn_index_columns; 361 362 // buffers 363 grn_obj encoded_key_buffer; 364 grn_obj old_value_buffer; 365 grn_obj new_value_buffer; 366 grn_obj top_left_point; 367 grn_obj bottom_right_point; 368 grn_obj source_point; 369 double top_left_longitude_in_degree; 370 double bottom_right_longitude_in_degree; 371 double bottom_right_latitude_in_degree; 372 double top_left_latitude_in_degree; 373 374 // for search 375 grn_obj *grn_source_column_geo; 376 grn_obj *cursor_geo; 377 grn_table_cursor *cursor; 378 grn_table_cursor *index_table_cursor; 379 grn_obj *empty_value_records; 380 grn_table_cursor *empty_value_records_cursor; 381 grn_obj *sorted_result; 382 grn_obj *matched_record_keys; 383 String *blob_buffers; 384 385 // for error report 386 uint dup_key; 387 388 // for optimization 389 bool count_skip; 390 bool fast_order_limit; 391 bool fast_order_limit_with_index; 392 393 // for context 394 bool ignoring_duplicated_key; 395 bool inserting_with_update; 396 bool fulltext_searching; 397 bool ignoring_no_key_columns; 398 bool replacing_; 399 uint written_by_row_based_binlog; 400 401 // for ft in where clause test 402 Item_func_match *current_ft_item; 403 404 mrn::Operations *operations_; 405 406 public: 407 ha_mroonga(handlerton *hton, TABLE_SHARE *share_arg); 408 ~ha_mroonga(); 409 const char *table_type() const; // required 410 const char *index_type(uint inx) mrn_override; 411 const char **bas_ext() const; // required 412 413 ulonglong table_flags() const mrn_override; // required 414 ulong index_flags(uint idx, uint part, bool all_parts) const mrn_override; // required 415 416 // required 417 int create(const char *name, TABLE *form, HA_CREATE_INFO *info 418 #ifdef MRN_HANDLER_CREATE_HAVE_TABLE_DEFINITION 419 , 420 dd::Table *table_def 421 #endif 422 ) mrn_override; 423 // required 424 int open(const char *name, int mode, uint open_options 425 #ifdef MRN_HANDLER_OPEN_HAVE_TABLE_DEFINITION 426 , 427 const dd::Table *table_def 428 #endif 429 ) mrn_override; 430 #ifndef MRN_HANDLER_HAVE_HA_CLOSE 431 int close(); // required 432 #endif 433 int info(uint flag) mrn_override; // required 434 435 uint lock_count() const mrn_override; 436 THR_LOCK_DATA **store_lock(THD *thd, // required 437 THR_LOCK_DATA **to, 438 enum thr_lock_type lock_type) mrn_override; 439 int external_lock(THD *thd, int lock_type) mrn_override; 440 441 int rnd_init(bool scan) mrn_override; // required 442 int rnd_end() mrn_override; 443 #ifndef MRN_HANDLER_HAVE_HA_RND_NEXT 444 int rnd_next(uchar *buf); // required 445 #endif 446 #ifndef MRN_HANDLER_HAVE_HA_RND_POS 447 int rnd_pos(uchar *buf, uchar *pos); // required 448 #endif 449 void position(const uchar *record) mrn_override; // required 450 int extra(enum ha_extra_function operation) mrn_override; 451 int extra_opt(enum ha_extra_function operation, ulong cache_size) mrn_override; 452 453 int delete_table(const char *name) mrn_override; 454 int write_row(const uchar *buf) mrn_override; 455 int update_row(const uchar *old_data, const uchar *new_data) mrn_override; 456 int delete_row(const uchar *buf) mrn_override; 457 458 uint max_supported_record_length() const mrn_override; 459 uint max_supported_keys() const mrn_override; 460 uint max_supported_key_parts() const mrn_override; 461 uint max_supported_key_length() const mrn_override; 462 uint max_supported_key_part_length() const mrn_override; 463 464 ha_rows records_in_range(uint inx, const key_range *min_key, 465 const key_range *max_key, page_range *pages) mrn_override; 466 int index_init(uint idx, bool sorted) mrn_override; 467 int index_end() mrn_override; 468 #ifndef MRN_HANDLER_HAVE_HA_INDEX_READ_MAP 469 int index_read_map(uchar * buf, const uchar * key, 470 key_part_map keypart_map, 471 enum ha_rkey_function find_flag); 472 #endif 473 #ifdef MRN_HANDLER_HAVE_INDEX_READ_LAST_MAP 474 int index_read_last_map(uchar *buf, const uchar *key, 475 key_part_map keypart_map); 476 #endif 477 #ifndef MRN_HANDLER_HAVE_HA_INDEX_NEXT 478 int index_next(uchar *buf); 479 #endif 480 #ifndef MRN_HANDLER_HAVE_HA_INDEX_PREV 481 int index_prev(uchar *buf); 482 #endif 483 #ifndef MRN_HANDLER_HAVE_HA_INDEX_FIRST 484 int index_first(uchar *buf); 485 #endif 486 #ifndef MRN_HANDLER_HAVE_HA_INDEX_LAST 487 int index_last(uchar *buf); 488 #endif 489 int index_next_same(uchar *buf, const uchar *key, uint keylen) mrn_override; 490 491 int ft_init() mrn_override; 492 FT_INFO *ft_init_ext(uint flags, uint inx, String *key) mrn_override; 493 int ft_read(uchar *buf) mrn_override; 494 495 const Item *cond_push(const Item *cond) mrn_override; 496 void cond_pop() mrn_override; 497 498 bool get_error_message(int error, String *buf) mrn_override; 499 500 int reset() mrn_override; 501 502 handler *clone(const char *name, MEM_ROOT *mem_root) mrn_override; 503 uint8 table_cache_type() mrn_override; 504 #ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ 505 ha_rows multi_range_read_info_const(uint keyno, RANGE_SEQ_IF *seq, 506 void *seq_init_param, 507 uint n_ranges, uint *bufsz, 508 uint *flags, Cost_estimate *cost) mrn_override; 509 ha_rows multi_range_read_info(uint keyno, uint n_ranges, uint keys, 510 #ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ_INFO_KEY_PARTS 511 uint key_parts, 512 #endif 513 uint *bufsz, uint *flags, Cost_estimate *cost) mrn_override; 514 int multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param, 515 uint n_ranges, uint mode, 516 HANDLER_BUFFER *buf) mrn_override; 517 int multi_range_read_next(range_id_t *range_info) mrn_override; 518 #else // MRN_HANDLER_HAVE_MULTI_RANGE_READ 519 int read_multi_range_first(KEY_MULTI_RANGE **found_range_p, 520 KEY_MULTI_RANGE *ranges, 521 uint range_count, 522 bool sorted, 523 HANDLER_BUFFER *buffer); 524 int read_multi_range_next(KEY_MULTI_RANGE **found_range_p); 525 #endif // MRN_HANDLER_HAVE_MULTI_RANGE_READ 526 #ifdef MRN_HANDLER_START_BULK_INSERT_HAS_FLAGS 527 void start_bulk_insert(ha_rows rows, uint flags) mrn_override; 528 #else 529 void start_bulk_insert(ha_rows rows); 530 #endif 531 int end_bulk_insert() mrn_override; 532 int delete_all_rows() mrn_override; 533 int truncate() mrn_override; 534 double scan_time() mrn_override; 535 double read_time(uint index, uint ranges, ha_rows rows) mrn_override; 536 #ifdef MRN_HANDLER_HAVE_KEYS_TO_USE_FOR_SCANNING 537 const key_map *keys_to_use_for_scanning() mrn_override; 538 #endif 539 ha_rows estimate_rows_upper_bound() mrn_override; 540 void update_create_info(HA_CREATE_INFO* create_info) mrn_override; 541 int rename_table(const char *from, const char *to) mrn_override; 542 bool is_crashed() const mrn_override; 543 bool auto_repair(int error) const mrn_override; 544 bool auto_repair() const; 545 int disable_indexes(uint mode) mrn_override; 546 int enable_indexes(uint mode) mrn_override; 547 int check(THD* thd, HA_CHECK_OPT* check_opt) mrn_override; 548 int repair(THD* thd, HA_CHECK_OPT* check_opt) mrn_override; 549 bool check_and_repair(THD *thd) mrn_override; 550 int analyze(THD* thd, HA_CHECK_OPT* check_opt) mrn_override; 551 int optimize(THD* thd, HA_CHECK_OPT* check_opt) mrn_override; 552 bool is_fatal_error(int error_num, uint flags=0) mrn_override; 553 bool check_if_incompatible_data(HA_CREATE_INFO *create_info, 554 uint table_changes) mrn_override; 555 #ifdef MRN_HANDLER_HAVE_CHECK_IF_SUPPORTED_INPLACE_ALTER 556 enum_alter_inplace_result 557 check_if_supported_inplace_alter(TABLE *altered_table, 558 Alter_inplace_info *ha_alter_info) mrn_override; 559 #else 560 alter_table_operations alter_table_flags(alter_table_operations flags); 561 # ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX 562 int add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys, 563 handler_add_index **add); 564 int final_add_index(handler_add_index *add, bool commit); 565 # else 566 int add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys); 567 # endif 568 int prepare_drop_index(TABLE *table_arg, uint *key_num, uint num_of_keys); 569 int final_drop_index(TABLE *table_arg); 570 #endif 571 int update_auto_increment(); 572 void set_next_insert_id(ulonglong id); 573 void get_auto_increment(ulonglong offset, ulonglong increment, ulonglong nb_desired_values, 574 ulonglong *first_value, ulonglong *nb_reserved_values) mrn_override; 575 void restore_auto_increment(ulonglong prev_insert_id) mrn_override; 576 void release_auto_increment() mrn_override; 577 int check_for_upgrade(HA_CHECK_OPT *check_opt) mrn_override; 578 #ifdef MRN_HANDLER_HAVE_RESET_AUTO_INCREMENT 579 int reset_auto_increment(ulonglong value) mrn_override; 580 #endif 581 bool was_semi_consistent_read() mrn_override; 582 void try_semi_consistent_read(bool yes) mrn_override; 583 void unlock_row() mrn_override; 584 int start_stmt(THD *thd, thr_lock_type lock_type) mrn_override; 585 586 protected: 587 #ifdef MRN_HANDLER_RECORDS_RETURN_ERROR 588 int records(ha_rows *num_rows); 589 #else 590 ha_rows records() mrn_override; 591 #endif 592 #ifdef MRN_HANDLER_HAVE_HA_RND_NEXT 593 int rnd_next(uchar *buf) mrn_override; 594 #endif 595 #ifdef MRN_HANDLER_HAVE_HA_RND_POS 596 int rnd_pos(uchar *buf, uchar *pos) mrn_override; 597 #endif 598 #ifdef MRN_HANDLER_HAVE_HA_INDEX_READ_MAP 599 int index_read_map(uchar *buf, const uchar *key, 600 key_part_map keypart_map, 601 enum ha_rkey_function find_flag) mrn_override; 602 #endif 603 #ifdef MRN_HANDLER_HAVE_HA_INDEX_NEXT 604 int index_next(uchar *buf) mrn_override; 605 #endif 606 #ifdef MRN_HANDLER_HAVE_HA_INDEX_PREV 607 int index_prev(uchar *buf) mrn_override; 608 #endif 609 #ifdef MRN_HANDLER_HAVE_HA_INDEX_FIRST 610 int index_first(uchar *buf) mrn_override; 611 #endif 612 #ifdef MRN_HANDLER_HAVE_HA_INDEX_LAST 613 int index_last(uchar *buf) mrn_override; 614 #endif 615 void change_table_ptr(TABLE *table_arg, TABLE_SHARE *share_arg) mrn_override; 616 bool is_fk_defined_on_table_or_index(uint index) mrn_override; 617 char *get_foreign_key_create_info() mrn_override; 618 #ifdef MRN_HANDLER_HAVE_GET_TABLESPACE_NAME 619 char *get_tablespace_name(THD *thd, char *name, uint name_len); 620 #endif 621 bool can_switch_engines() mrn_override; 622 int get_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list) mrn_override; 623 int get_parent_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list) mrn_override; 624 uint referenced_by_foreign_key() mrn_override; 625 void init_table_handle_for_HANDLER() mrn_override; 626 void free_foreign_key_create_info(char* str) mrn_override; 627 #ifdef MRN_HAVE_HA_REBIND_PSI 628 void unbind_psi() mrn_override; 629 void rebind_psi() mrn_override; 630 #endif 631 my_bool register_query_cache_table(THD *thd, 632 const char *table_key, 633 uint key_length, 634 qc_engine_callback *engine_callback, 635 ulonglong *engine_data) mrn_override; 636 #ifdef MRN_HANDLER_HAVE_CHECK_IF_SUPPORTED_INPLACE_ALTER 637 bool prepare_inplace_alter_table(TABLE *altered_table, 638 Alter_inplace_info *ha_alter_info) mrn_override; 639 bool inplace_alter_table(TABLE *altered_table, 640 Alter_inplace_info *ha_alter_info) mrn_override; 641 bool commit_inplace_alter_table(TABLE *altered_table, 642 Alter_inplace_info *ha_alter_info, 643 bool commit) mrn_override; 644 #endif 645 646 private: 647 void mkdir_p(const char *directory); 648 ulonglong file_size(const char *path); 649 650 bool have_unique_index(); 651 652 bool is_foreign_key_field(const char *table_name, 653 const char *field_name); 654 655 void push_warning_unsupported_spatial_index_search(enum ha_rkey_function flag); 656 void clear_cursor(); 657 void clear_cursor_geo(); 658 void clear_empty_value_records(); 659 void clear_search_result(); 660 void clear_search_result_geo(); 661 void clear_indexes(); 662 int add_wrap_hton(const char *path, handlerton *wrap_handlerton); 663 void remove_related_files(const char *base_path); 664 void remove_grn_obj_force(const char *name); 665 int drop_index(MRN_SHARE *target_share, uint key_index); 666 int drop_indexes_normal(const char *table_name, grn_obj *table); 667 int drop_indexes_multiple(const char *table_name, grn_obj *table, 668 const char *index_table_name_separator); 669 int drop_indexes(const char *table_name); 670 bool find_column_flags(Field *field, MRN_SHARE *mrn_share, int i, 671 grn_obj_flags *column_flags); 672 grn_obj *find_column_type(Field *field, MRN_SHARE *mrn_share, int i, 673 int error_code); 674 grn_obj *find_tokenizer(KEY *key, MRN_SHARE *mrn_share, int i); 675 grn_obj *find_tokenizer(const char *name, int name_length); 676 bool have_custom_normalizer(KEY *key) const; 677 grn_obj *find_normalizer(KEY *key); 678 grn_obj *find_normalizer(KEY *key, const char *name); 679 bool find_index_column_flags(KEY *key, grn_column_flags *index_column_flags); 680 bool find_token_filters(KEY *key, grn_obj *token_filters); 681 bool find_token_filters_put(grn_obj *token_filters, 682 const char *token_filter_name, 683 int token_filter_name_length); 684 bool find_token_filters_fill(grn_obj *token_filters, 685 const char *token_filter_names, 686 int token_filter_name_length); 687 int wrapper_get_record(uchar *buf, const uchar *key); 688 int wrapper_get_next_geo_record(uchar *buf); 689 int storage_get_next_record(uchar *buf); 690 void geo_store_rectangle(const uchar *rectangle); 691 int generic_geo_open_cursor(const uchar *key, enum ha_rkey_function find_flag); 692 693 #ifdef MRN_HANDLER_HAVE_HA_CLOSE 694 int close() mrn_override; 695 #endif 696 bool is_dry_write(); 697 bool is_enable_optimization(); 698 bool should_normalize(Field *field) const; 699 void check_count_skip(key_part_map target_key_part_map); 700 bool is_grn_zero_column_value(grn_obj *column, grn_obj *value); 701 bool is_primary_key_field(Field *field) const; 702 void check_fast_order_limit(grn_table_sort_key **sort_keys, int *n_sort_keys, 703 longlong *limit); 704 705 long long int get_grn_time_from_timestamp_field(Field_timestamp *field); 706 707 int generic_store_bulk_fixed_size_string(Field *field, grn_obj *buf); 708 int generic_store_bulk_variable_size_string(Field *field, grn_obj *buf); 709 int generic_store_bulk_integer(Field *field, grn_obj *buf); 710 int generic_store_bulk_unsigned_integer(Field *field, grn_obj *buf); 711 int generic_store_bulk_float(Field *field, grn_obj *buf); 712 int generic_store_bulk_timestamp(Field *field, grn_obj *buf); 713 int generic_store_bulk_date(Field *field, grn_obj *buf); 714 int generic_store_bulk_time(Field *field, grn_obj *buf); 715 int generic_store_bulk_datetime(Field *field, grn_obj *buf); 716 int generic_store_bulk_year(Field *field, grn_obj *buf); 717 int generic_store_bulk_new_date(Field *field, grn_obj *buf); 718 #ifdef MRN_HAVE_MYSQL_TYPE_DATETIME2 719 int generic_store_bulk_datetime2(Field *field, grn_obj *buf); 720 #endif 721 #ifdef MRN_HAVE_MYSQL_TYPE_TIME2 722 int generic_store_bulk_time2(Field *field, grn_obj *buf); 723 #endif 724 int generic_store_bulk_new_decimal(Field *field, grn_obj *buf); 725 int generic_store_bulk_blob(Field *field, grn_obj *buf); 726 int generic_store_bulk_geometry(Field *field, grn_obj *buf); 727 #ifdef MRN_HAVE_MYSQL_TYPE_JSON 728 int generic_store_bulk_json(Field *field, grn_obj *buf); 729 #endif 730 int generic_store_bulk(Field *field, grn_obj *buf); 731 732 void storage_store_field_string(Field *field, 733 const char *value, uint value_length); 734 void storage_store_field_integer(Field *field, 735 const char *value, uint value_length); 736 void storage_store_field_unsigned_integer(Field *field, 737 const char *value, 738 uint value_length); 739 void storage_store_field_float(Field *field, 740 const char *value, uint value_length); 741 void storage_store_field_timestamp(Field *field, 742 const char *value, uint value_length); 743 void storage_store_field_date(Field *field, 744 const char *value, uint value_length); 745 void storage_store_field_time(Field *field, 746 const char *value, uint value_length); 747 void storage_store_field_datetime(Field *field, 748 const char *value, uint value_length); 749 void storage_store_field_year(Field *field, 750 const char *value, uint value_length); 751 void storage_store_field_new_date(Field *field, 752 const char *value, uint value_length); 753 #ifdef MRN_HAVE_MYSQL_TYPE_DATETIME2 754 void storage_store_field_datetime2(Field *field, 755 const char *value, uint value_length); 756 #endif 757 #ifdef MRN_HAVE_MYSQL_TYPE_TIME2 758 void storage_store_field_time2(Field *field, 759 const char *value, uint value_length); 760 #endif 761 void storage_store_field_blob(Field *field, 762 const char *value, uint value_length); 763 void storage_store_field_geometry(Field *field, 764 const char *value, uint value_length); 765 #ifdef MRN_HAVE_MYSQL_TYPE_JSON 766 void storage_store_field_json(Field *field, 767 const char *value, uint value_length); 768 #endif 769 void storage_store_field(Field *field, const char *value, uint value_length); 770 void storage_store_field_column(Field *field, bool is_primary_key, 771 int nth_column, grn_id record_id); 772 void storage_store_fields(uchar *buf, grn_id record_id); 773 void storage_store_fields_for_prep_update(const uchar *old_data, 774 const uchar *new_data, 775 grn_id record_id); 776 void storage_store_fields_by_index(uchar *buf); 777 778 int storage_encode_key_normalize_min_sort_chars(Field *field, 779 uchar *buf, 780 uint size); 781 int storage_encode_key_fixed_size_string(Field *field, const uchar *key, 782 uchar *buf, uint *size); 783 int storage_encode_key_variable_size_string(Field *field, const uchar *key, 784 uchar *buf, uint *size); 785 int storage_encode_key_timestamp(Field *field, const uchar *key, 786 uchar *buf, uint *size); 787 int storage_encode_key_time(Field *field, const uchar *key, 788 uchar *buf, uint *size); 789 int storage_encode_key_year(Field *field, const uchar *key, 790 uchar *buf, uint *size); 791 int storage_encode_key_datetime(Field *field, const uchar *key, 792 uchar *buf, uint *size); 793 #ifdef MRN_HAVE_MYSQL_TYPE_TIMESTAMP2 794 int storage_encode_key_timestamp2(Field *field, const uchar *key, 795 uchar *buf, uint *size); 796 #endif 797 #ifdef MRN_HAVE_MYSQL_TYPE_DATETIME2 798 int storage_encode_key_datetime2(Field *field, bool is_null, const uchar *key, 799 uchar *buf, uint *size); 800 #endif 801 #ifdef MRN_HAVE_MYSQL_TYPE_TIME2 802 int storage_encode_key_time2(Field *field, const uchar *key, 803 uchar *buf, uint *size); 804 #endif 805 int storage_encode_key_enum(Field *field, const uchar *key, 806 uchar *buf, uint *size); 807 int storage_encode_key_set(Field *field, const uchar *key, 808 uchar *buf, uint *size); 809 int storage_encode_key(Field *field, const uchar *key, uchar *buf, uint *size); 810 int storage_encode_multiple_column_key(KEY *key_info, 811 const uchar *key, uint key_length, 812 uchar *buffer, uint *encoded_length); 813 int storage_encode_multiple_column_key_range(KEY *key_info, 814 const uchar *start, 815 uint start_size, 816 const uchar *end, 817 uint end_size, 818 uchar *min_buffer, 819 uint *min_encoded_size, 820 uchar *max_buffer, 821 uint *max_encoded_size); 822 int storage_encode_multiple_column_key_range(KEY *key_info, 823 const key_range *start, 824 const key_range *end, 825 uchar *min_buffer, 826 uint *min_encoded_size, 827 uchar *max_buffer, 828 uint *max_encoded_size); 829 830 void set_pk_bitmap(); 831 int create_share_for_create() const; 832 int wrapper_create(const char *name, TABLE *table, 833 HA_CREATE_INFO *info, MRN_SHARE *tmp_share); 834 int storage_create(const char *name, TABLE *table, 835 HA_CREATE_INFO *info, MRN_SHARE *tmp_share); 836 int wrapper_create_index_fulltext_validate(KEY *key_info); 837 int wrapper_create_index_fulltext(const char *grn_table_name, 838 int i, 839 KEY *key_info, 840 grn_obj **index_tables, 841 grn_obj **index_columns, 842 MRN_SHARE *tmp_share); 843 int wrapper_create_index_geo(const char *grn_table_name, 844 int i, 845 KEY *key_info, 846 grn_obj **index_tables, 847 grn_obj **index_columns, 848 MRN_SHARE *tmp_share); 849 int wrapper_create_index(const char *name, TABLE *table, MRN_SHARE *tmp_share); 850 int storage_create_validate_pseudo_column(TABLE *table); 851 #ifdef MRN_SUPPORT_FOREIGN_KEYS 852 bool storage_create_foreign_key(TABLE *table, const char *grn_table_name, 853 Field *field, grn_obj *table_obj, int &error); 854 #endif 855 int storage_create_validate_index(TABLE *table); 856 int storage_create_index_table(TABLE *table, const char *grn_table_name, 857 grn_obj *grn_table, MRN_SHARE *tmp_share, 858 KEY *key_info, grn_obj **index_tables, 859 uint i); 860 int storage_create_index(TABLE *table, const char *grn_table_name, 861 grn_obj *grn_table, MRN_SHARE *tmp_share, 862 KEY *key_info, grn_obj **index_tables, 863 grn_obj **index_columns, uint i); 864 int storage_create_indexes(TABLE *table, const char *grn_table_name, 865 grn_obj *grn_table, MRN_SHARE *tmp_share); 866 int close_databases(); 867 int ensure_database_open(const char *name, mrn::Database **db=NULL); 868 int ensure_database_remove(const char *name); 869 int wrapper_delete_table(const char *name, handlerton *wrap_handlerton, 870 const char *table_name); 871 int generic_delete_table(const char *name, const char *table_name); 872 int wrapper_open(const char *name, int mode, uint open_options); 873 int wrapper_open_indexes(const char *name); 874 int storage_reindex(); 875 int storage_open(const char *name, int mode, uint open_options); 876 int open_table(const char *name); 877 int storage_open_columns(void); 878 void storage_close_columns(void); 879 int storage_open_indexes(const char *name); 880 void wrapper_overwrite_index_bits(); 881 int wrapper_close(); 882 int storage_close(); 883 int generic_extra(enum ha_extra_function operation); 884 int wrapper_extra(enum ha_extra_function operation); 885 int storage_extra(enum ha_extra_function operation); 886 int wrapper_extra_opt(enum ha_extra_function operation, ulong cache_size); 887 int storage_extra_opt(enum ha_extra_function operation, ulong cache_size); 888 int generic_reset(); 889 int wrapper_reset(); 890 int storage_reset(); 891 uint wrapper_lock_count() const; 892 uint storage_lock_count() const; 893 THR_LOCK_DATA **wrapper_store_lock(THD *thd, THR_LOCK_DATA **to, 894 enum thr_lock_type lock_type); 895 THR_LOCK_DATA **storage_store_lock(THD *thd, THR_LOCK_DATA **to, 896 enum thr_lock_type lock_type); 897 int wrapper_external_lock(THD *thd, int lock_type); 898 int storage_external_lock(THD *thd, int lock_type); 899 #ifdef MRN_HANDLER_START_BULK_INSERT_HAS_FLAGS 900 void wrapper_start_bulk_insert(ha_rows rows, uint flags); 901 void storage_start_bulk_insert(ha_rows rows, uint flags); 902 #else 903 void wrapper_start_bulk_insert(ha_rows rows); 904 void storage_start_bulk_insert(ha_rows rows); 905 #endif 906 int wrapper_end_bulk_insert(); 907 int storage_end_bulk_insert(); 908 bool wrapper_is_target_index(KEY *key_info); 909 bool wrapper_have_target_index(); 910 int wrapper_write_row(const uchar *buf); 911 int wrapper_write_row_index(const uchar *buf); 912 int storage_write_row(const uchar *buf); 913 int storage_write_row_multiple_column_index(const uchar *buf, 914 grn_id record_id, 915 KEY *key_info, 916 grn_obj *index_column); 917 int storage_write_row_multiple_column_indexes(const uchar *buf, grn_id record_id); 918 int storage_write_row_unique_index(const uchar *buf, 919 KEY *key_info, 920 grn_obj *index_table, 921 grn_obj *index_column, 922 grn_id *key_id); 923 int storage_write_row_unique_indexes(const uchar *buf); 924 int wrapper_get_record_id(uchar *data, grn_id *record_id, 925 const char *context); 926 int wrapper_update_row(const uchar *old_data, const uchar *new_data); 927 int wrapper_update_row_index(const uchar *old_data, 928 const uchar *new_data); 929 int storage_update_row(const uchar *old_data, const uchar *new_data); 930 int storage_update_row_index(const uchar *old_data, 931 const uchar *new_data); 932 int storage_update_row_unique_indexes(const uchar *new_data); 933 int wrapper_delete_row(const uchar *buf); 934 int wrapper_delete_row_index(const uchar *buf); 935 int storage_delete_row(const uchar *buf); 936 int storage_delete_row_index(const uchar *buf); 937 int storage_delete_row_unique_index(grn_obj *index_table, grn_id del_key_id); 938 int storage_delete_row_unique_indexes(); 939 int storage_prepare_delete_row_unique_index(const uchar *buf, 940 grn_id record_id, 941 KEY *key_info, 942 grn_obj *index_table, 943 grn_obj *index_column, 944 grn_id *del_key_id); 945 int storage_prepare_delete_row_unique_indexes(const uchar *buf, 946 grn_id record_id); 947 uint wrapper_max_supported_record_length() const; 948 uint storage_max_supported_record_length() const; 949 uint wrapper_max_supported_keys() const; 950 uint storage_max_supported_keys() const; 951 uint wrapper_max_supported_key_parts() const; 952 uint storage_max_supported_key_parts() const; 953 uint wrapper_max_supported_key_length() const; 954 uint storage_max_supported_key_length() const; 955 uint wrapper_max_supported_key_part_length() const; 956 uint storage_max_supported_key_part_length() const; 957 ulonglong wrapper_table_flags() const; 958 ulonglong storage_table_flags() const; 959 ulong wrapper_index_flags(uint idx, uint part, bool all_parts) const; 960 ulong storage_index_flags(uint idx, uint part, bool all_parts) const; 961 int wrapper_info(uint flag); 962 int storage_info(uint flag); 963 void storage_info_variable(); 964 void storage_info_variable_records(); 965 void storage_info_variable_data_file_length(); 966 #ifdef MRN_HANDLER_RECORDS_RETURN_ERROR 967 int wrapper_records(ha_rows *num_rows); 968 int storage_records(ha_rows *num_rows); 969 #else 970 ha_rows wrapper_records(); 971 ha_rows storage_records(); 972 #endif 973 int wrapper_rnd_init(bool scan); 974 int storage_rnd_init(bool scan); 975 int wrapper_rnd_end(); 976 int storage_rnd_end(); 977 int wrapper_rnd_next(uchar *buf); 978 int storage_rnd_next(uchar *buf); 979 int wrapper_rnd_pos(uchar *buf, uchar *pos); 980 int storage_rnd_pos(uchar *buf, uchar *pos); 981 void wrapper_position(const uchar *record); 982 void storage_position(const uchar *record); 983 ha_rows wrapper_records_in_range(uint key_nr, const key_range *range_min, 984 const key_range *range_max, 985 page_range *pages); 986 ha_rows storage_records_in_range(uint key_nr, const key_range *range_min, 987 const key_range *range_max, 988 page_range *pages); 989 ha_rows generic_records_in_range_geo(uint key_nr, const key_range *range_min, 990 const key_range *range_max); 991 int wrapper_index_init(uint idx, bool sorted); 992 int storage_index_init(uint idx, bool sorted); 993 int wrapper_index_end(); 994 int storage_index_end(); 995 int wrapper_index_read_map(uchar *buf, const uchar *key, 996 key_part_map keypart_map, 997 enum ha_rkey_function find_flag); 998 int storage_index_read_map(uchar *buf, const uchar *key, 999 key_part_map keypart_map, 1000 enum ha_rkey_function find_flag); 1001 #ifdef MRN_HANDLER_HAVE_INDEX_READ_LAST_MAP 1002 int wrapper_index_read_last_map(uchar *buf, const uchar *key, 1003 key_part_map keypart_map); 1004 int storage_index_read_last_map(uchar *buf, const uchar *key, 1005 key_part_map keypart_map); 1006 #endif 1007 int wrapper_index_next(uchar *buf); 1008 int storage_index_next(uchar *buf); 1009 int wrapper_index_prev(uchar *buf); 1010 int storage_index_prev(uchar *buf); 1011 int wrapper_index_first(uchar *buf); 1012 int storage_index_first(uchar *buf); 1013 int wrapper_index_last(uchar *buf); 1014 int storage_index_last(uchar *buf); 1015 int wrapper_index_next_same(uchar *buf, const uchar *key, uint keylen); 1016 int storage_index_next_same(uchar *buf, const uchar *key, uint keylen); 1017 int generic_ft_init(); 1018 int wrapper_ft_init(); 1019 int storage_ft_init(); 1020 FT_INFO *wrapper_ft_init_ext(uint flags, uint key_nr, String *key); 1021 FT_INFO *storage_ft_init_ext(uint flags, uint key_nr, String *key); 1022 void generic_ft_init_ext_add_conditions_fast_order_limit( 1023 struct st_mrn_ft_info *info, grn_obj *expression); 1024 grn_rc generic_ft_init_ext_prepare_expression_in_boolean_mode( 1025 struct st_mrn_ft_info *info, 1026 String *key, 1027 grn_obj *index_column, 1028 grn_obj *match_columns, 1029 grn_obj *expression); 1030 grn_rc generic_ft_init_ext_prepare_expression_in_normal_mode( 1031 struct st_mrn_ft_info *info, 1032 String *key, 1033 grn_obj *index_column, 1034 grn_obj *match_columns, 1035 grn_obj *expression); 1036 struct st_mrn_ft_info *generic_ft_init_ext_select(uint flags, 1037 uint key_nr, 1038 String *key); 1039 FT_INFO *generic_ft_init_ext(uint flags, uint key_nr, String *key); 1040 int wrapper_ft_read(uchar *buf); 1041 int storage_ft_read(uchar *buf); 1042 const Item *wrapper_cond_push(const Item *cond); 1043 const Item *storage_cond_push(const Item *cond); 1044 void wrapper_cond_pop(); 1045 void storage_cond_pop(); 1046 bool wrapper_get_error_message(int error, String *buf); 1047 bool storage_get_error_message(int error, String *buf); 1048 handler *wrapper_clone(const char *name, MEM_ROOT *mem_root); 1049 handler *storage_clone(const char *name, MEM_ROOT *mem_root); 1050 uint8 wrapper_table_cache_type(); 1051 uint8 storage_table_cache_type(); 1052 #ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ 1053 ha_rows wrapper_multi_range_read_info_const(uint keyno, 1054 RANGE_SEQ_IF *seq, 1055 void *seq_init_param, 1056 uint n_ranges, 1057 uint *bufsz, 1058 uint *flags, 1059 Cost_estimate *cost); 1060 ha_rows storage_multi_range_read_info_const(uint keyno, 1061 RANGE_SEQ_IF *seq, 1062 void *seq_init_param, 1063 uint n_ranges, 1064 uint *bufsz, 1065 uint *flags, 1066 Cost_estimate *cost); 1067 ha_rows wrapper_multi_range_read_info(uint keyno, uint n_ranges, uint keys, 1068 #ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ_INFO_KEY_PARTS 1069 uint key_parts, 1070 #endif 1071 uint *bufsz, uint *flags, 1072 Cost_estimate *cost); 1073 ha_rows storage_multi_range_read_info(uint keyno, uint n_ranges, uint keys, 1074 #ifdef MRN_HANDLER_HAVE_MULTI_RANGE_READ_INFO_KEY_PARTS 1075 uint key_parts, 1076 #endif 1077 uint *bufsz, uint *flags, 1078 Cost_estimate *cost); 1079 int wrapper_multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param, 1080 uint n_ranges, uint mode, 1081 HANDLER_BUFFER *buf); 1082 int storage_multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param, 1083 uint n_ranges, uint mode, 1084 HANDLER_BUFFER *buf); 1085 int wrapper_multi_range_read_next(range_id_t *range_info); 1086 int storage_multi_range_read_next(range_id_t *range_info); 1087 #else // MRN_HANDLER_HAVE_MULTI_RANGE_READ 1088 int wrapper_read_multi_range_first(KEY_MULTI_RANGE **found_range_p, 1089 KEY_MULTI_RANGE *ranges, 1090 uint range_count, 1091 bool sorted, 1092 HANDLER_BUFFER *buffer); 1093 int storage_read_multi_range_first(KEY_MULTI_RANGE **found_range_p, 1094 KEY_MULTI_RANGE *ranges, 1095 uint range_count, 1096 bool sorted, 1097 HANDLER_BUFFER *buffer); 1098 int wrapper_read_multi_range_next(KEY_MULTI_RANGE **found_range_p); 1099 int storage_read_multi_range_next(KEY_MULTI_RANGE **found_range_p); 1100 #endif // MRN_HANDLER_HAVE_MULTI_RANGE_READ 1101 int generic_delete_all_rows(grn_obj *target_grn_table, 1102 const char *function_name); 1103 int wrapper_delete_all_rows(); 1104 int storage_delete_all_rows(); 1105 int wrapper_truncate(); 1106 int wrapper_truncate_index(); 1107 int storage_truncate(); 1108 int storage_truncate_index(); 1109 double wrapper_scan_time(); 1110 double storage_scan_time(); 1111 double wrapper_read_time(uint index, uint ranges, ha_rows rows); 1112 double storage_read_time(uint index, uint ranges, ha_rows rows); 1113 #ifdef MRN_HANDLER_HAVE_KEYS_TO_USE_FOR_SCANNING 1114 const key_map *wrapper_keys_to_use_for_scanning(); 1115 const key_map *storage_keys_to_use_for_scanning(); 1116 #endif 1117 ha_rows wrapper_estimate_rows_upper_bound(); 1118 ha_rows storage_estimate_rows_upper_bound(); 1119 void wrapper_update_create_info(HA_CREATE_INFO* create_info); 1120 void storage_update_create_info(HA_CREATE_INFO* create_info); 1121 int wrapper_rename_table(const char *from, const char *to, 1122 MRN_SHARE *tmp_share, 1123 const char *from_table_name, 1124 const char *to_table_name); 1125 int wrapper_rename_index(const char *from, const char *to, 1126 MRN_SHARE *tmp_share, 1127 const char *from_table_name, 1128 const char *to_table_name); 1129 int storage_rename_table(const char *from, const char *to, 1130 MRN_SHARE *tmp_share, 1131 const char *from_table_name, 1132 const char *to_table_name); 1133 #ifdef MRN_SUPPORT_FOREIGN_KEYS 1134 int storage_rename_foreign_key(MRN_SHARE *tmp_share, 1135 const char *from_table_name, 1136 const char *to_table_name); 1137 #endif 1138 bool wrapper_is_crashed() const; 1139 bool storage_is_crashed() const; 1140 bool wrapper_auto_repair(int error) const; 1141 bool storage_auto_repair(int error) const; 1142 int generic_disable_index(int i, KEY *key_info); 1143 int wrapper_disable_indexes_mroonga(uint mode); 1144 int wrapper_disable_indexes(uint mode); 1145 int storage_disable_indexes(uint mode); 1146 int wrapper_enable_indexes_mroonga(uint mode); 1147 int wrapper_enable_indexes(uint mode); 1148 int storage_enable_indexes(uint mode); 1149 int wrapper_check(THD* thd, HA_CHECK_OPT* check_opt); 1150 int storage_check(THD* thd, HA_CHECK_OPT* check_opt); 1151 int wrapper_fill_indexes(THD *thd, KEY *key_info, 1152 grn_obj **index_columns, uint n_keys); 1153 int wrapper_recreate_indexes(THD *thd); 1154 int storage_recreate_indexes(THD *thd); 1155 int wrapper_repair(THD* thd, HA_CHECK_OPT* check_opt); 1156 int storage_repair(THD* thd, HA_CHECK_OPT* check_opt); 1157 bool wrapper_check_and_repair(THD *thd); 1158 bool storage_check_and_repair(THD *thd); 1159 int wrapper_analyze(THD* thd, HA_CHECK_OPT* check_opt); 1160 int storage_analyze(THD* thd, HA_CHECK_OPT* check_opt); 1161 int wrapper_optimize(THD* thd, HA_CHECK_OPT* check_opt); 1162 int storage_optimize(THD* thd, HA_CHECK_OPT* check_opt); 1163 bool wrapper_is_fatal_error(int error_num, uint flags); 1164 bool storage_is_fatal_error(int error_num, uint flags); 1165 bool wrapper_is_comment_changed(TABLE *table1, TABLE *table2); 1166 bool wrapper_check_if_incompatible_data(HA_CREATE_INFO *create_info, 1167 uint table_changes); 1168 bool storage_check_if_incompatible_data(HA_CREATE_INFO *create_info, 1169 uint table_changes); 1170 int storage_add_index_multiple_columns(KEY *key_info, uint num_of_keys, 1171 grn_obj **index_tables, 1172 grn_obj **index_columns, 1173 bool skip_unique_key); 1174 #ifdef MRN_HANDLER_HAVE_CHECK_IF_SUPPORTED_INPLACE_ALTER 1175 enum_alter_inplace_result 1176 wrapper_check_if_supported_inplace_alter(TABLE *altered_table, 1177 Alter_inplace_info *ha_alter_info); 1178 enum_alter_inplace_result 1179 storage_check_if_supported_inplace_alter(TABLE *altered_table, 1180 Alter_inplace_info *ha_alter_info); 1181 bool wrapper_prepare_inplace_alter_table(TABLE *altered_table, 1182 Alter_inplace_info *ha_alter_info); 1183 bool storage_prepare_inplace_alter_table(TABLE *altered_table, 1184 Alter_inplace_info *ha_alter_info); 1185 bool wrapper_inplace_alter_table(TABLE *altered_table, 1186 Alter_inplace_info *ha_alter_info); 1187 bool storage_inplace_alter_table_add_index(TABLE *altered_table, 1188 Alter_inplace_info *ha_alter_info); 1189 bool storage_inplace_alter_table_drop_index(TABLE *altered_table, 1190 Alter_inplace_info *ha_alter_info); 1191 bool storage_inplace_alter_table_add_column(TABLE *altered_table, 1192 Alter_inplace_info *ha_alter_info); 1193 bool storage_inplace_alter_table_drop_column(TABLE *altered_table, 1194 Alter_inplace_info *ha_alter_info); 1195 bool storage_inplace_alter_table_rename_column(TABLE *altered_table, 1196 Alter_inplace_info *ha_alter_info); 1197 bool storage_inplace_alter_table(TABLE *altered_table, 1198 Alter_inplace_info *ha_alter_info); 1199 bool wrapper_commit_inplace_alter_table(TABLE *altered_table, 1200 Alter_inplace_info *ha_alter_info, 1201 bool commit); 1202 bool storage_commit_inplace_alter_table(TABLE *altered_table, 1203 Alter_inplace_info *ha_alter_info, 1204 bool commit); 1205 #else 1206 alter_table_operations wrapper_alter_table_flags(alter_table_operations flags); 1207 alter_table_operations storage_alter_table_flags(alter_table_operations flags); 1208 # ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX 1209 int wrapper_add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys, 1210 handler_add_index **add); 1211 int storage_add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys, 1212 handler_add_index **add); 1213 # else 1214 int wrapper_add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys); 1215 int storage_add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys); 1216 # endif 1217 # ifdef MRN_HANDLER_HAVE_FINAL_ADD_INDEX 1218 int wrapper_final_add_index(handler_add_index *add, bool commit); 1219 int storage_final_add_index(handler_add_index *add, bool commit); 1220 # endif 1221 int wrapper_prepare_drop_index(TABLE *table_arg, uint *key_num, 1222 uint num_of_keys); 1223 int storage_prepare_drop_index(TABLE *table_arg, uint *key_num, 1224 uint num_of_keys); 1225 int wrapper_final_drop_index(TABLE *table_arg); 1226 int storage_final_drop_index(TABLE *table_arg); 1227 #endif 1228 int wrapper_update_auto_increment(); 1229 int storage_update_auto_increment(); 1230 void wrapper_set_next_insert_id(ulonglong id); 1231 void storage_set_next_insert_id(ulonglong id); 1232 void wrapper_get_auto_increment(ulonglong offset, ulonglong increment, 1233 ulonglong nb_desired_values, 1234 ulonglong *first_value, 1235 ulonglong *nb_reserved_values); 1236 void storage_get_auto_increment(ulonglong offset, ulonglong increment, 1237 ulonglong nb_desired_values, 1238 ulonglong *first_value, 1239 ulonglong *nb_reserved_values); 1240 void wrapper_restore_auto_increment(ulonglong prev_insert_id); 1241 void storage_restore_auto_increment(ulonglong prev_insert_id); 1242 void wrapper_release_auto_increment(); 1243 void storage_release_auto_increment(); 1244 int wrapper_check_for_upgrade(HA_CHECK_OPT *check_opt); 1245 int storage_check_for_upgrade(HA_CHECK_OPT *check_opt); 1246 #ifdef MRN_HANDLER_HAVE_RESET_AUTO_INCREMENT 1247 int wrapper_reset_auto_increment(ulonglong value); 1248 int storage_reset_auto_increment(ulonglong value); 1249 #endif 1250 bool wrapper_was_semi_consistent_read(); 1251 bool storage_was_semi_consistent_read(); 1252 void wrapper_try_semi_consistent_read(bool yes); 1253 void storage_try_semi_consistent_read(bool yes); 1254 void wrapper_unlock_row(); 1255 void storage_unlock_row(); 1256 int wrapper_start_stmt(THD *thd, thr_lock_type lock_type); 1257 int storage_start_stmt(THD *thd, thr_lock_type lock_type); 1258 void wrapper_change_table_ptr(TABLE *table_arg, TABLE_SHARE *share_arg); 1259 void storage_change_table_ptr(TABLE *table_arg, TABLE_SHARE *share_arg); 1260 bool wrapper_is_fk_defined_on_table_or_index(uint index); 1261 bool storage_is_fk_defined_on_table_or_index(uint index); 1262 char *wrapper_get_foreign_key_create_info(); 1263 char *storage_get_foreign_key_create_info(); 1264 #ifdef MRN_HANDLER_HAVE_GET_TABLESPACE_NAME 1265 char *wrapper_get_tablespace_name(THD *thd, char *name, uint name_len); 1266 char *storage_get_tablespace_name(THD *thd, char *name, uint name_len); 1267 #endif 1268 bool wrapper_can_switch_engines(); 1269 bool storage_can_switch_engines(); 1270 int wrapper_get_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list); 1271 int storage_get_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list); 1272 int wrapper_get_parent_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list); 1273 int storage_get_parent_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list); 1274 uint wrapper_referenced_by_foreign_key(); 1275 uint storage_referenced_by_foreign_key(); 1276 void wrapper_init_table_handle_for_HANDLER(); 1277 void storage_init_table_handle_for_HANDLER(); 1278 void wrapper_free_foreign_key_create_info(char* str); 1279 void storage_free_foreign_key_create_info(char* str); 1280 void wrapper_set_keys_in_use(); 1281 void storage_set_keys_in_use(); 1282 #ifdef MRN_RBR_UPDATE_NEED_ALL_COLUMNS 1283 bool check_written_by_row_based_binlog(); 1284 #endif 1285 #ifdef MRN_HAVE_HA_REBIND_PSI 1286 void wrapper_unbind_psi(); 1287 void storage_unbind_psi(); 1288 void wrapper_rebind(); 1289 void storage_rebind(); 1290 #endif 1291 my_bool wrapper_register_query_cache_table(THD *thd, 1292 const char *table_key, 1293 uint key_length, 1294 qc_engine_callback 1295 *engine_callback, 1296 ulonglong *engine_data); 1297 my_bool storage_register_query_cache_table(THD *thd, 1298 const char *table_key, 1299 uint key_length, 1300 qc_engine_callback 1301 *engine_callback, 1302 ulonglong *engine_data); 1303 }; 1304 1305 #ifdef __cplusplus 1306 } 1307 #endif 1308 1309 #endif /* HA_MROONGA_HPP_ */ 1310