|
| | ha_heap (handlerton *hton, TABLE_SHARE *table) |
| |
| | ~ha_heap () override=default |
| |
| handler * | clone (const char *name, MEM_ROOT *mem_root) override |
| |
| const char * | table_type () const override |
| | The following can be called without an open handler. More...
|
| |
| enum ha_key_alg | get_default_index_algorithm () const override |
| | Get default key algorithm for SE. More...
|
| |
| bool | is_index_algorithm_supported (enum ha_key_alg key_alg) const override |
| | Check if SE supports specific key algorithm. More...
|
| |
| enum row_type | get_real_row_type (const HA_CREATE_INFO *) const override |
| | Get real row type for the table created based on one specified by user, CREATE TABLE options and SE capabilities. More...
|
| |
| ulonglong | table_flags () const override |
| |
| ulong | index_flags (uint inx, uint, bool) const override |
| |
| uint | max_supported_keys () const override |
| |
| uint | max_supported_key_part_length (HA_CREATE_INFO *create_info) const override |
| |
| double | scan_time () override |
| |
| double | read_time (uint, uint, ha_rows rows) override |
| | The cost of reading a set of ranges from the table using an index to access it. More...
|
| |
| int | open (const char *name, int mode, uint test_if_locked, const dd::Table *table_def) override |
| |
| int | close (void) override |
| |
| void | set_keys_for_scanning (void) |
| |
| int | write_row (uchar *buf) override |
| | Write a row. More...
|
| |
| int | update_row (const uchar *old_data, uchar *new_data) override |
| | Update a single row. More...
|
| |
| int | delete_row (const uchar *buf) override |
| |
| void | get_auto_increment (ulonglong offset, ulonglong increment, ulonglong nb_desired_values, ulonglong *first_value, ulonglong *nb_reserved_values) override |
| | Reserves an interval of auto_increment values from the handler. More...
|
| |
| int | index_read_map (uchar *buf, const uchar *key, key_part_map keypart_map, enum ha_rkey_function find_flag) override |
| | Positions an index cursor to the index specified in the handle ('active_index'). More...
|
| |
| int | index_read_last_map (uchar *buf, const uchar *key, key_part_map keypart_map) override |
| | The following functions works like index_read, but it find the last row with the current key value or prefix. More...
|
| |
| int | index_read_idx_map (uchar *buf, uint index, const uchar *key, key_part_map keypart_map, enum ha_rkey_function find_flag) override |
| | Positions an index cursor to the index specified in argument. More...
|
| |
| int | index_next (uchar *buf) override |
| |
| int | index_prev (uchar *buf) override |
| |
| int | index_first (uchar *buf) override |
| |
| int | index_last (uchar *buf) override |
| |
| int | rnd_init (bool scan) override |
| | rnd_init() can be called two times without rnd_end() in between (it only makes sense if scan=1). More...
|
| |
| int | rnd_next (uchar *buf) override |
| |
| int | rnd_pos (uchar *buf, uchar *pos) override |
| |
| void | position (const uchar *record) override |
| |
| int | info (uint) override |
| | General method to gather info from handler. More...
|
| |
| int | extra (enum ha_extra_function operation) override |
| | Storage engine specific implementation of ha_extra() More...
|
| |
| int | reset () override |
| | Reset state of file to after 'open'. More...
|
| |
| int | external_lock (THD *thd, int lock_type) override |
| | Is not invoked for non-transactional temporary tables. More...
|
| |
| int | delete_all_rows (void) override |
| | Delete all rows in a table. More...
|
| |
| int | disable_indexes (uint mode) override |
| | Disable indexes for a while. More...
|
| |
| int | enable_indexes (uint mode) override |
| | Enable indexes again. More...
|
| |
| int | indexes_are_disabled (void) override |
| | Check if indexes are disabled. More...
|
| |
| ha_rows | records_in_range (uint inx, key_range *min_key, key_range *max_key) override |
| | Find number of records in a range. More...
|
| |
| int | delete_table (const char *from, const dd::Table *table_def) override |
| | Delete a table. More...
|
| |
| void | drop_table (const char *name) override |
| |
| int | rename_table (const char *from, const char *to, const dd::Table *from_table_def, dd::Table *to_table_def) override |
| | Default rename_table() and delete_table() rename/delete files with a given name and extensions from handlerton::file_extensions. More...
|
| |
| int | create (const char *name, TABLE *form, HA_CREATE_INFO *create_info, dd::Table *table_def) override |
| | Create table (implementation). More...
|
| |
| void | update_create_info (HA_CREATE_INFO *create_info) override |
| | Update create info as part of ALTER TABLE. More...
|
| |
| THR_LOCK_DATA ** | store_lock (THD *thd, THR_LOCK_DATA **to, enum thr_lock_type lock_type) override |
| | Is not invoked for non-transactional temporary tables. More...
|
| |
| int | cmp_ref (const uchar *ref1, const uchar *ref2) const override |
| | Compare two positions. More...
|
| |
| bool | check_if_incompatible_data (HA_CREATE_INFO *info, uint table_changes) override |
| | Part of old, deprecated in-place ALTER API. More...
|
| |
 Public Member Functions inherited from handler |
| void | unbind_psi () |
| |
| void | rebind_psi () |
| |
| void | start_psi_batch_mode () |
| | Put the handler in 'batch' mode when collecting table io instrumented events. More...
|
| |
| void | end_psi_batch_mode () |
| | End a batch started with start_psi_batch_mode. More...
|
| |
| bool | end_psi_batch_mode_if_started () |
| | If a PSI batch was started, turn if off. More...
|
| |
| | handler (handlerton *ht_arg, TABLE_SHARE *share_arg) |
| |
| virtual | ~handler (void) |
| |
| virtual std::string | explain_extra () const |
| | Return extra handler specific text for EXPLAIN. More...
|
| |
| void | init () |
| | This is called after create to allow us to set up cached variables. More...
|
| |
| void | ha_set_record_buffer (Record_buffer *buffer) |
| | Set a record buffer that the storage engine can use for multi-row reads. More...
|
| |
| Record_buffer * | ha_get_record_buffer () const |
| | Get the record buffer that was set with ha_set_record_buffer(). More...
|
| |
| bool | ha_is_record_buffer_wanted (ha_rows *const max_rows) const |
| | Does this handler want to get a Record_buffer for multi-row reads via the ha_set_record_buffer() function? And if so, what is the maximum number of records to allocate space for in the buffer? More...
|
| |
| int | ha_open (TABLE *table, const char *name, int mode, int test_if_locked, const dd::Table *table_def) |
| |
| int | ha_close (void) |
| | Close handler. More...
|
| |
| int | ha_index_init (uint idx, bool sorted) |
| | Initialize use of index. More...
|
| |
| int | ha_index_end () |
| | End use of index. More...
|
| |
| int | ha_rnd_init (bool scan) |
| | Initialize table for random read or scan. More...
|
| |
| int | ha_rnd_end () |
| | End use of random access. More...
|
| |
| int | ha_rnd_next (uchar *buf) |
| | Read next row via random scan. More...
|
| |
| int | ha_rnd_pos (uchar *buf, uchar *pos) |
| | Read row via random scan from position. More...
|
| |
| int | ha_index_read_map (uchar *buf, const uchar *key, key_part_map keypart_map, enum ha_rkey_function find_flag) |
| | Read [part of] row via [part of] index. More...
|
| |
| int | ha_index_read_last_map (uchar *buf, const uchar *key, key_part_map keypart_map) |
| |
| int | ha_index_read_idx_map (uchar *buf, uint index, const uchar *key, key_part_map keypart_map, enum ha_rkey_function find_flag) |
| | Initializes an index and read it. More...
|
| |
| int | ha_index_next (uchar *buf) |
| | Reads the next row via index. More...
|
| |
| int | ha_index_prev (uchar *buf) |
| | Reads the previous row via index. More...
|
| |
| int | ha_index_first (uchar *buf) |
| | Reads the first row via index. More...
|
| |
| int | ha_index_last (uchar *buf) |
| | Reads the last row via index. More...
|
| |
| int | ha_index_next_same (uchar *buf, const uchar *key, uint keylen) |
| | Reads the next same row via index. More...
|
| |
| int | ha_reset () |
| | Check handler usage and reset state of file to after 'open'. More...
|
| |
| int | ha_index_or_rnd_end () |
| |
| Table_flags | ha_table_flags () const |
| | The cached_table_flags is set at ha_open and ha_external_lock. More...
|
| |
| int | ha_external_lock (THD *thd, int lock_type) |
| | These functions represent the public interface to users of the handler class, hence they are not virtual. More...
|
| |
| int | ha_write_row (uchar *buf) |
| |
| int | ha_update_row (const uchar *old_data, uchar *new_data) |
| | Update the current row. More...
|
| |
| int | ha_delete_row (const uchar *buf) |
| |
| void | ha_release_auto_increment () |
| |
| int | ha_check_for_upgrade (HA_CHECK_OPT *check_opt) |
| |
| int | ha_check (THD *thd, HA_CHECK_OPT *check_opt) |
| | to be actually called to get 'check()' functionality More...
|
| |
| int | ha_repair (THD *thd, HA_CHECK_OPT *check_opt) |
| | Repair table: public interface. More...
|
| |
| void | ha_start_bulk_insert (ha_rows rows) |
| | Start bulk insert. More...
|
| |
| int | ha_end_bulk_insert () |
| | End bulk insert. More...
|
| |
| int | ha_bulk_update_row (const uchar *old_data, uchar *new_data, uint *dup_key_found) |
| | Bulk update row: public interface. More...
|
| |
| int | ha_delete_all_rows () |
| | Delete all rows: public interface. More...
|
| |
| int | ha_truncate (dd::Table *table_def) |
| | Truncate table: public interface. More...
|
| |
| int | ha_optimize (THD *thd, HA_CHECK_OPT *check_opt) |
| | Optimize table: public interface. More...
|
| |
| int | ha_analyze (THD *thd, HA_CHECK_OPT *check_opt) |
| | Analyze table: public interface. More...
|
| |
| bool | ha_check_and_repair (THD *thd) |
| | Check and repair table: public interface. More...
|
| |
| int | ha_disable_indexes (uint mode) |
| | Disable indexes: public interface. More...
|
| |
| int | ha_enable_indexes (uint mode) |
| | Enable indexes: public interface. More...
|
| |
| int | ha_discard_or_import_tablespace (bool discard, dd::Table *table_def) |
| | Discard or import tablespace: public interface. More...
|
| |
| int | ha_rename_table (const char *from, const char *to, const dd::Table *from_table_def, dd::Table *to_table_def) |
| | Rename table: public interface. More...
|
| |
| int | ha_delete_table (const char *name, const dd::Table *table_def) |
| | Delete table: public interface. More...
|
| |
| void | ha_drop_table (const char *name) |
| | Drop table in the engine: public interface. More...
|
| |
| int | ha_create (const char *name, TABLE *form, HA_CREATE_INFO *info, dd::Table *table_def) |
| | Create a table in the engine: public interface. More...
|
| |
| int | ha_load_table (const TABLE &table, bool *skip_metadata_update) |
| | Loads a table into its defined secondary storage engine: public interface. More...
|
| |
| int | ha_unload_table (const char *db_name, const char *table_name, bool error_if_not_loaded) |
| | Unloads a table from its defined secondary storage engine: public interface. More...
|
| |
| virtual int | parallel_scan_init (void *&scan_ctx, size_t *num_threads, bool use_reserved_threads, size_t max_desired_threads) |
| | Initializes a parallel scan. More...
|
| |
| virtual int | parallel_scan (void *scan_ctx, void **thread_ctxs, Load_init_cbk init_fn, Load_cbk load_fn, Load_end_cbk end_fn) |
| | Run the parallel read of data. More...
|
| |
| virtual void | parallel_scan_end (void *scan_ctx) |
| | End of the parallel scan. More...
|
| |
| virtual bool | bulk_load_check (THD *thd) const |
| | Check if the table is ready for bulk load. More...
|
| |
| virtual size_t | bulk_load_available_memory (THD *thd) const |
| | Get the total memory available for bulk load in SE. More...
|
| |
| virtual void * | bulk_load_begin (THD *thd, size_t data_size, size_t memory, size_t num_threads) |
| | Begin parallel bulk data load to the table. More...
|
| |
| virtual int | bulk_load_execute (THD *thd, void *load_ctx, size_t thread_idx, const Rows_mysql &rows, Bulk_load::Stat_callbacks &wait_cbk) |
| | Execute bulk load operation. More...
|
| |
| virtual int | bulk_load_end (THD *thd, void *load_ctx, bool is_error) |
| | End bulk load operation. More...
|
| |
| bool | ha_get_se_private_data (dd::Table *dd_table, bool reset) |
| | Submit a dd::Table object representing a core DD table having hardcoded data to be filled in by the DDSE. More...
|
| |
| void | adjust_next_insert_id_after_explicit_value (ulonglong nr) |
| |
| int | update_auto_increment () |
| |
| virtual void | print_error (int error, myf errflag) |
| | Print error that we got from handler function. More...
|
| |
| virtual bool | get_error_message (int error, String *buf) |
| | Return an error message specific to this handler. More...
|
| |
| uint | get_dup_key (int error) |
| |
| virtual bool | get_foreign_dup_key (char *child_table_name, uint child_table_name_len, char *child_key_name, uint child_key_name_len) |
| | Retrieves the names of the table and the key for which there was a duplicate entry in the case of HA_ERR_FOREIGN_DUPLICATE_KEY. More...
|
| |
| virtual void | change_table_ptr (TABLE *table_arg, TABLE_SHARE *share) |
| | Change the internal TABLE_SHARE pointer. More...
|
| |
| const TABLE_SHARE * | get_table_share () const |
| |
| virtual double | index_only_read_time (uint keynr, double records) |
| | Calculate cost of 'index only' scan for given index and number of records. More...
|
| |
| virtual Cost_estimate | table_scan_cost () |
| | Cost estimate for doing a complete table scan. More...
|
| |
| virtual Cost_estimate | index_scan_cost (uint index, double ranges, double rows) |
| | Cost estimate for reading a number of ranges from an index. More...
|
| |
| virtual Cost_estimate | read_cost (uint index, double ranges, double rows) |
| | Cost estimate for reading a set of ranges from the table using an index to access it. More...
|
| |
| virtual double | page_read_cost (uint index, double reads) |
| | Cost estimate for doing a number of non-sequentially accesses against the storage engine. More...
|
| |
| virtual double | worst_seek_times (double reads) |
| | Provide an upper cost-limit of doing a specified number of seek-and-read key lookups. More...
|
| |
| virtual longlong | get_memory_buffer_size () const |
| | Return an estimate on the amount of memory the storage engine will use for caching data in memory. More...
|
| |
| double | table_in_memory_estimate () const |
| | Return an estimate of how much of the table that is currently stored in main memory. More...
|
| |
| double | index_in_memory_estimate (uint keyno) const |
| | Return an estimate of how much of the index that is currently stored in main memory. More...
|
| |
| int | ha_sample_init (void *&scan_ctx, double sampling_percentage, int sampling_seed, enum_sampling_method sampling_method, const bool tablesample) |
| | Initialize sampling. More...
|
| |
| int | ha_sample_next (void *scan_ctx, uchar *buf) |
| | Get the next record for sampling. More...
|
| |
| int | ha_sample_end (void *scan_ctx) |
| | End sampling. More...
|
| |
| virtual 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) |
| | Get cost and other information about MRR scan over a known list of ranges. More...
|
| |
| virtual ha_rows | multi_range_read_info (uint keyno, uint n_ranges, uint keys, uint *bufsz, uint *flags, Cost_estimate *cost) |
| | Get cost and other information about MRR scan over some sequence of ranges. More...
|
| |
| virtual int | multi_range_read_init (RANGE_SEQ_IF *seq, void *seq_init_param, uint n_ranges, uint mode, HANDLER_BUFFER *buf) |
| | Initialize the MRR scan. More...
|
| |
| int | ha_multi_range_read_next (char **range_info) |
| |
| int | ha_read_range_first (const key_range *start_key, const key_range *end_key, bool eq_range, bool sorted) |
| |
| int | ha_read_range_next () |
| |
| bool | has_transactions () |
| |
| virtual uint | extra_rec_buf_length () const |
| |
| virtual bool | is_ignorable_error (int error) |
| | Determine whether an error can be ignored or not. More...
|
| |
| virtual bool | is_fatal_error (int error) |
| | Determine whether an error is fatal or not. More...
|
| |
| int | ha_records (ha_rows *num_rows) |
| | Wrapper function to call records() in storage engine. More...
|
| |
| int | ha_records (ha_rows *num_rows, uint index) |
| | Wrapper function to call records_from_index() in storage engine. More...
|
| |
| virtual ha_rows | estimate_rows_upper_bound () |
| | Return upper bound of current number of records in the table (max. More...
|
| |
| virtual void | column_bitmaps_signal () |
| | Signal that the table->read_set and table->write_set table maps changed The handler is allowed to set additional bits in the above map in this call. More...
|
| |
| uint | get_index (void) const |
| |
| virtual bool | start_bulk_update () |
| |
| virtual bool | start_bulk_delete () |
| |
| virtual int | exec_bulk_update (uint *dup_key_found) |
| | After this call all outstanding updates must be performed. More...
|
| |
| virtual void | end_bulk_update () |
| | Perform any needed clean-up, no outstanding updates are there at the moment. More...
|
| |
| virtual int | end_bulk_delete () |
| | Execute all outstanding deletes and close down the bulk delete. More...
|
| |
| void | set_end_range (const key_range *range, enum_range_scan_direction direction) |
| | Set the end position for a range scan. More...
|
| |
| int | compare_key (key_range *range) |
| | Compare if found key (in row) is over max-value. More...
|
| |
| int | compare_key_icp (const key_range *range) const |
| |
| int | compare_key_in_buffer (const uchar *buf) const |
| | Check if the key in the given buffer (which is not necessarily TABLE::record[0]) is within range. More...
|
| |
| virtual int | ft_init () |
| |
| virtual FT_INFO * | ft_init_ext (uint flags, uint inx, String *key) |
| |
| virtual FT_INFO * | ft_init_ext_with_hints (uint inx, String *key, Ft_hints *hints) |
| |
| int | ha_ft_read (uchar *buf) |
| |
| int | ha_read_first_row (uchar *buf, uint primary_key) |
| | Read first row (only) from a table. More...
|
| |
| virtual int | rnd_pos_by_record (uchar *record) |
| | This function only works for handlers having HA_PRIMARY_KEY_REQUIRED_FOR_POSITION set. More...
|
| |
| virtual uint32 | calculate_key_hash_value (Field **field_array) |
| |
| int | ha_extra (enum ha_extra_function operation) |
| | Request storage engine to do an extra operation: enable,disable or run some functionality. More...
|
| |
| virtual int | extra_opt (enum ha_extra_function operation, ulong cache_size) |
| |
| virtual const handlerton * | hton_supporting_engine_pushdown () |
| | Get the handlerton of the storage engine if the SE is capable of pushing down some of the AccessPath functionality. More...
|
| |
| virtual bool | start_read_removal (void) |
| | Start read (before write) removal on the current table. More...
|
| |
| virtual ha_rows | end_read_removal (void) |
| | End read (before write) removal and return the number of rows really written. More...
|
| |
| virtual bool | was_semi_consistent_read () |
| |
| virtual void | try_semi_consistent_read (bool) |
| | Tell the engine whether it should avoid unnecessary lock waits. More...
|
| |
| virtual void | unlock_row () |
| | Unlock last accessed row. More...
|
| |
| virtual int | start_stmt (THD *thd, thr_lock_type lock_type) |
| | Start a statement when table is locked. More...
|
| |
| void | set_next_insert_id (ulonglong id) |
| |
| void | restore_auto_increment (ulonglong prev_insert_id) |
| |
| virtual int | assign_to_keycache (THD *, HA_CHECK_OPT *) |
| |
| virtual int | preload_keys (THD *, HA_CHECK_OPT *) |
| |
| virtual void | append_create_info (String *packet) |
| |
| virtual void | init_table_handle_for_HANDLER () |
| |
| uint | max_record_length () const |
| |
| uint | max_keys () const |
| |
| uint | max_key_parts () const |
| |
| uint | max_key_length () const |
| |
| uint | max_key_part_length (HA_CREATE_INFO *create_info) const |
| |
| virtual uint | max_supported_record_length () const |
| |
| virtual uint | max_supported_key_parts () const |
| |
| virtual uint | max_supported_key_length () const |
| |
| virtual uint | min_record_length (uint options) const |
| |
| virtual bool | low_byte_first () const |
| |
| virtual ha_checksum | checksum () const |
| |
| virtual bool | is_crashed () const |
| | Check if the table is crashed. More...
|
| |
| virtual bool | auto_repair () const |
| | Check if the table can be automatically repaired. More...
|
| |
| virtual uint | lock_count (void) const |
| | Get number of lock objects returned in store_lock. More...
|
| |
| virtual bool | primary_key_is_clustered () const |
| | Check if the primary key is clustered or not. More...
|
| |
| virtual const Item * | cond_push (const Item *cond) |
| | Push condition down to the table handler. More...
|
| |
| virtual Item * | idx_cond_push (uint keyno, Item *idx_cond) |
| | Push down an index condition to the handler. More...
|
| |
| virtual void | cancel_pushed_idx_cond () |
| | Reset information about pushed index conditions. More...
|
| |
| virtual uint | number_of_pushed_joins () const |
| | Reports number of tables included in pushed join which this handler instance is part of. More...
|
| |
| virtual const TABLE * | member_of_pushed_join () const |
| | If this handler instance is part of a pushed join sequence returned TABLE instance being root of the pushed query? More...
|
| |
| virtual const TABLE * | parent_of_pushed_join () const |
| | If this handler instance is a child in a pushed join sequence returned TABLE instance being my parent? More...
|
| |
| virtual table_map | tables_in_pushed_join () const |
| |
| int | ha_index_read_pushed (uchar *buf, const uchar *key, key_part_map keypart_map) |
| |
| int | ha_index_next_pushed (uchar *buf) |
| |
| virtual enum_alter_inplace_result | check_if_supported_inplace_alter (TABLE *altered_table, Alter_inplace_info *ha_alter_info) |
| | Check if a storage engine supports a particular alter table in-place. More...
|
| |
| bool | ha_prepare_inplace_alter_table (TABLE *altered_table, Alter_inplace_info *ha_alter_info, const dd::Table *old_table_def, dd::Table *new_table_def) |
| | Public functions wrapping the actual handler call. More...
|
| |
| bool | ha_inplace_alter_table (TABLE *altered_table, Alter_inplace_info *ha_alter_info, const dd::Table *old_table_def, dd::Table *new_table_def) |
| | Public function wrapping the actual handler call. More...
|
| |
| bool | ha_commit_inplace_alter_table (TABLE *altered_table, Alter_inplace_info *ha_alter_info, bool commit, const dd::Table *old_table_def, dd::Table *new_table_def) |
| | Public function wrapping the actual handler call. More...
|
| |
| void | ha_notify_table_changed (Alter_inplace_info *ha_alter_info) |
| | Public function wrapping the actual handler call. More...
|
| |
| virtual void | use_hidden_primary_key () |
| | use_hidden_primary_key() is called in case of an update/delete when (table_flags() and HA_PRIMARY_KEY_REQUIRED_FOR_DELETE) is defined but we don't have a primary key More...
|
| |
| virtual int | bulk_update_row (const uchar *old_data, uchar *new_data, uint *dup_key_found) |
| | This method is similar to update_row, however the handler doesn't need to execute the updates at this point in time. More...
|
| |
| virtual int | truncate (dd::Table *table_def) |
| | Quickly remove all rows from a table. More...
|
| |
| virtual int | optimize (THD *, HA_CHECK_OPT *) |
| |
| virtual int | analyze (THD *, HA_CHECK_OPT *) |
| |
| virtual bool | check_and_repair (THD *thd) |
| | Check and repair the table if necessary. More...
|
| |
| virtual int | discard_or_import_tablespace (bool discard, dd::Table *table_def) |
| | Discard or import tablespace. More...
|
| |
| virtual bool | get_se_private_data (dd::Table *dd_table, bool reset) |
| |
| virtual int | get_extra_columns_and_keys (const HA_CREATE_INFO *create_info, const List< Create_field > *create_list, const KEY *key_info, uint key_count, dd::Table *table_obj) |
| | Adjust definition of table to be created by adding implicit columns and indexes necessary for the storage engine. More...
|
| |
| virtual bool | set_ha_share_ref (Handler_share **arg_ha_share) |
| |
| void | set_ha_table (TABLE *table_arg) |
| |
| int | get_lock_type () const |
| |
| virtual Partition_handler * | get_partition_handler () |
| |
| bool | ha_upgrade_table (THD *thd, const char *dbname, const char *table_name, dd::Table *dd_table, TABLE *table_arg) |
| | Set se_private_id and se_private_data during upgrade. More...
|
| |
| void | ha_set_primary_handler (handler *primary_handler) |
| | Store a pointer to the handler of the primary table that corresponds to the secondary table in this handler. More...
|
| |
| handler * | ha_get_primary_handler () const |
| | Get a pointer to a handler for the table in the primary storage engine, if this handler is for a table in a secondary storage engine. More...
|
| |
| void | ha_mv_key_capacity (uint *num_keys, size_t *keys_length) const |
| | Return max limits for a single set of multi-valued keys. More...
|
| |
| virtual void | set_external_table_offload_error (const char *) |
| | Propagates the secondary storage engine offload failure reason for a query to the external engine when the offloaded query fails in the secondary storage engine. More...
|
| |
| virtual void | external_table_offload_error () const |
| | Identifies and throws the propagated external engine query offload or exec failure reason given by the external engine handler. More...
|
| |
|
| Public Types inherited from handler |
| enum | enum_range_scan_direction { RANGE_SCAN_ASC
, RANGE_SCAN_DESC
} |
| |
| enum | { NONE = 0
, INDEX
, RND
, SAMPLING
} |
| |
| typedef ulonglong | Table_flags |
| |
| using | Load_init_cbk = std::function< bool(void *cookie, ulong ncols, ulong row_len, const ulong *col_offsets, const ulong *null_byte_offsets, const ulong *null_bitmasks)> |
| | This callback is called by each parallel load thread at the beginning of the parallel load for the adapter scan. More...
|
| |
| using | Load_cbk = std::function< bool(void *cookie, uint nrows, void *rowdata, uint64_t partition_id)> |
| | This callback is called by each parallel load thread when processing of rows is required for the adapter scan. More...
|
| |
| using | Load_end_cbk = std::function< void(void *cookie)> |
| | This callback is called by each parallel load thread when processing of rows has ended for the adapter scan. More...
|
| |
| typedef void(* | my_gcolumn_template_callback_t) (const TABLE *, void *) |
| | Callback function that will be called by my_prepare_gcolumn_template once the table has been opened. More...
|
| |
| Static Public Member Functions inherited from handler |
| static bool | my_prepare_gcolumn_template (THD *thd, const char *db_name, const char *table_name, my_gcolumn_template_callback_t myc, void *ib_table) |
| | Callback to allow InnoDB to prepare a template for generated column processing. More...
|
| |
| static bool | my_eval_gcolumn_expr_with_open (THD *thd, const char *db_name, const char *table_name, const MY_BITMAP *const fields, uchar *record, const char **mv_data_ptr, ulong *mv_length) |
| | Callback for generated columns processing. More...
|
| |
| static bool | my_eval_gcolumn_expr (THD *thd, TABLE *table, const MY_BITMAP *const fields, uchar *record, const char **mv_data_ptr, ulong *mv_length) |
| | Callback for computing generated column values. More...
|
| |
| Public Attributes inherited from handler |
| handlerton * | ht |
| |
| uchar * | ref |
| | Pointer to current row. More...
|
| |
| uchar * | dup_ref |
| | Pointer to duplicate row. More...
|
| |
| ha_statistics | stats |
| |
| range_seq_t | mrr_iter |
| |
| RANGE_SEQ_IF | mrr_funcs |
| |
| HANDLER_BUFFER * | multi_range_buffer |
| |
| uint | ranges_in_seq |
| |
| bool | mrr_is_output_sorted |
| |
| bool | mrr_have_range |
| |
| KEY_MULTI_RANGE | mrr_cur_range |
| |
| key_range * | end_range |
| | End value for a range scan. More...
|
| |
| bool | m_virt_gcol_in_end_range = false |
| | Flag which tells if end_range contains a virtual generated column. More...
|
| |
| uint | errkey |
| |
| uint | key_used_on_scan |
| |
| uint | active_index |
| |
| uint | ref_length |
| | Length of ref (1-8 or the clustered key length) More...
|
| |
| FT_INFO * | ft_handler |
| |
| enum handler:: { ... } | inited |
| |
| bool | implicit_emptied |
| |
| const Item * | pushed_cond |
| |
| Item * | pushed_idx_cond |
| |
| uint | pushed_idx_cond_keyno |
| |
| ulonglong | next_insert_id |
| | next_insert_id is the next value which should be inserted into the auto_increment column: in a inserting-multi-row statement (like INSERT SELECT), for the first row where the autoinc value is not specified by the statement, get_auto_increment() called and asked to generate a value, next_insert_id is set to the next value, then for all other rows next_insert_id is used (and increased each time) without calling get_auto_increment(). More...
|
| |
| ulonglong | insert_id_for_cur_row |
| | insert id for the current row (autogenerated; if not autogenerated, it's 0). More...
|
| |
| Discrete_interval | auto_inc_interval_for_cur_row |
| | Interval returned by get_auto_increment() and being consumed by the inserter. More...
|
| |
| uint | auto_inc_intervals_count |
| | Number of reserved auto-increment intervals. More...
|
| |
| PSI_table * | m_psi |
| | Instrumented table associated with this handler. More...
|
| |
| std::mt19937 * | m_random_number_engine {nullptr} |
| |
| double | m_sampling_percentage |
| |
| Protected Member Functions inherited from handler |
| virtual int | multi_range_read_next (char **range_info) |
| | Get next record in MRR scan. More...
|
| |
| virtual int | records (ha_rows *num_rows) |
| | Number of rows in table. More...
|
| |
| virtual int | records_from_index (ha_rows *num_rows, uint index) |
| | Number of rows in table counted using the secondary index chosen by optimizer. More...
|
| |
| virtual int | index_next_same (uchar *buf, const uchar *key, uint keylen) |
| |
| virtual int | read_range_first (const key_range *start_key, const key_range *end_key, bool eq_range_arg, bool sorted) |
| | Read first row between two ranges. More...
|
| |
| virtual int | read_range_next () |
| | Read next row between two endpoints. More...
|
| |
| virtual int | ft_read (uchar *) |
| |
| virtual int | index_read_pushed (uchar *, const uchar *, key_part_map) |
| |
| virtual int | index_next_pushed (uchar *) |
| |
| virtual bool | prepare_inplace_alter_table (TABLE *altered_table, Alter_inplace_info *ha_alter_info, const dd::Table *old_table_def, dd::Table *new_table_def) |
| | Allows the storage engine to update internal structures with concurrent writes blocked. More...
|
| |
| virtual bool | inplace_alter_table (TABLE *altered_table, Alter_inplace_info *ha_alter_info, const dd::Table *old_table_def, dd::Table *new_table_def) |
| | Alter the table structure in-place with operations specified using HA_ALTER_FLAGS and Alter_inplace_info. More...
|
| |
| virtual bool | commit_inplace_alter_table (TABLE *altered_table, Alter_inplace_info *ha_alter_info, bool commit, const dd::Table *old_table_def, dd::Table *new_table_def) |
| | Commit or rollback the changes made during prepare_inplace_alter_table() and inplace_alter_table() inside the storage engine. More...
|
| |
| virtual void | notify_table_changed (Alter_inplace_info *ha_alter_info) |
| | Notify the storage engine that the table definition has been updated. More...
|
| |
| void | ha_statistic_increment (ulonglong System_status_var::*offset) const |
| |
| THD * | ha_thd () const |
| |
| PSI_table_share * | ha_table_share_psi (const TABLE_SHARE *share) const |
| | Acquire the instrumented table information from a table share. More...
|
| |
| virtual int | index_read (uchar *buf, const uchar *key, uint key_len, enum ha_rkey_function find_flag) |
| |
| virtual int | index_read_last (uchar *buf, const uchar *key, uint key_len) |
| |
| Handler_share * | get_ha_share_ptr () |
| | Get an initialized ha_share. More...
|
| |
| void | set_ha_share_ptr (Handler_share *arg_ha_share) |
| | Set ha_share to be used by all instances of the same table/partition. More...
|
| |
| void | lock_shared_ha_data () |
| | Take a lock for protecting shared handler data. More...
|
| |
| void | unlock_shared_ha_data () |
| | Release lock for protecting ha_share. More...
|
| |
| Protected Attributes inherited from handler |
| TABLE_SHARE * | table_share |
| |
| TABLE * | table |
| |
| Table_flags | cached_table_flags {0} |
| |
| ha_rows | estimation_rows_to_insert |
| |
| KEY_PART_INFO * | range_key_part |
| |
| bool | eq_range |
| |
| bool | in_range_check_pushed_down |
| |
1.9.2