handler.h

Go to the documentation of this file.

#ifndef HANDLER_INCLUDED
#define HANDLER_INCLUDED
 
/*
   Copyright (c) 2000, 2021, Oracle and/or its affiliates.
 
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License, version 2.0,
   as published by the Free Software Foundation.
 
   This program is also distributed with certain software (including
   but not limited to OpenSSL) that is licensed under separate terms,
   as designated in a particular file or component or in included license
   documentation.  The authors of MySQL hereby grant you an additional
   permission to link the program and your derivative works with the
   separately licensed software that they have included with MySQL.
 
   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, version 2.0, 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 St, Fifth Floor, Boston, MA 02110-1301  USA
*/
 
/* Definitions for parameters to do with handler-routines */
 
#include <fcntl.h>
#include <float.h>
#include <string.h>
#include <sys/types.h>
#include <time.h>
#include <algorithm>
#include <bitset>
#include <functional>
#include <map>
#include <random>  // std::mt19937
#include <set>
#include <string>
 
#include <mysql/components/services/page_track_service.h>
#include "ft_global.h"  // ft_hints
#include "lex_string.h"
#include "m_ctype.h"
#include "map_helpers.h"
#include "my_alloc.h"
#include "my_base.h"
#include "my_bitmap.h"
#include "my_checksum.h"  // ha_checksum
#include "my_compiler.h"
#include "my_dbug.h"
#include "my_double2ulonglong.h"
#include "my_inttypes.h"
#include "my_io.h"
#include "my_sys.h"
#include "my_table_map.h"
#include "my_thread_local.h"  // my_errno
#include "mysql/components/services/psi_table_bits.h"
#include "nullable.h"          // Nullable
#include "sql/dd/object_id.h"  // dd::Object_id
#include "sql/dd/string_type.h"
#include "sql/dd/types/object_table.h"  // dd::Object_table
#include "sql/discrete_interval.h"      // Discrete_interval
#include "sql/key.h"
#include "sql/sql_const.h"       // SHOW_COMP_OPTION
#include "sql/sql_list.h"        // SQL_I_List
#include "sql/sql_plugin_ref.h"  // plugin_ref
#include "thr_lock.h"            // thr_lock_type
#include "typelib.h"
 
class Alter_info;
class Create_field;
class Field;
class Item;
class JOIN;
class Json_dom;
class Partition_handler;
class Plugin_table;
class Plugin_tablespace;
class Record_buffer;
class SE_cost_constants;  // see opt_costconstants.h
class String;
class THD;
class handler;
class partition_info;
struct System_status_var;
 
namespace dd {
class Properties;
}  // namespace dd
struct AccessPath;
struct JoinHypergraph;
struct KEY_CACHE;
struct LEX;
struct MY_BITMAP;
struct SAVEPOINT;
struct TABLE;
struct TABLE_LIST;
struct TABLE_SHARE;
struct Tablespace_options;
struct handlerton;
 
typedef struct xid_t XID;
typedef struct st_xarecover_txn XA_recover_txn;
struct MDL_key;
 
namespace dd {
enum class enum_column_types;
class Table;
class Tablespace;
}  // namespace dd
 
/** Id for identifying Table SDIs */
constexpr const uint32 SDI_TYPE_TABLE = 1;
 
/** Id for identifying Tablespace SDIs */
constexpr const uint32 SDI_TYPE_TABLESPACE = 2;
 
/** Key to identify a dictionary object */
struct sdi_key_t {
  /** Type of Object, For ex: column, index, etc */
  uint32 type;
 
  /** Object id which should be unique in tablespsace */
  uint64 id;
};
 
using sdi_container = std::vector<sdi_key_t>;
struct sdi_vector_t {
  sdi_container m_vec;
};
 
typedef bool (*qc_engine_callback)(THD *thd, const char *table_key,
                                   uint key_length, ulonglong *engine_data);
 
typedef bool(stat_print_fn)(THD *thd, const char *type, size_t type_len,
                            const char *file, size_t file_len,
                            const char *status, size_t status_len);
 
class ha_statistics;
class ha_tablespace_statistics;
 
namespace AQP {
class Table_access;
}  // namespace AQP
class Unique_on_insert;
 
extern ulong savepoint_alloc_size;
 
/// Maps from slot to plugin. May return NULL if plugin has been unloaded.
st_plugin_int *hton2plugin(uint slot);
/// Returns the size of the array holding pointers to plugins.
size_t num_hton2plugins();
 
/**
  For unit testing.
  Insert plugin into arbitrary slot in array.
  Remove plugin from arbitrary slot in array.
*/
st_plugin_int *insert_hton2plugin(uint slot, st_plugin_int *plugin);
st_plugin_int *remove_hton2plugin(uint slot);
 
extern const char *ha_row_type[];
extern const char *tx_isolation_names[];
extern const char *binlog_format_names[];
extern TYPELIB tx_isolation_typelib;
extern ulong total_ha_2pc;
 
// the following is for checking tables
 
#define HA_ADMIN_ALREADY_DONE 1
#define HA_ADMIN_OK 0
#define HA_ADMIN_NOT_IMPLEMENTED -1
#define HA_ADMIN_FAILED -2
#define HA_ADMIN_CORRUPT -3
#define HA_ADMIN_INTERNAL_ERROR -4
#define HA_ADMIN_INVALID -5
#define HA_ADMIN_REJECT -6
#define HA_ADMIN_TRY_ALTER -7
#define HA_ADMIN_WRONG_CHECKSUM -8
#define HA_ADMIN_NOT_BASE_TABLE -9
#define HA_ADMIN_NEEDS_UPGRADE -10
#define HA_ADMIN_NEEDS_ALTER -11
#define HA_ADMIN_NEEDS_CHECK -12
#define HA_ADMIN_STATS_UPD_ERR -13
/** User needs to dump and re-create table to fix pre 5.0 decimal types */
#define HA_ADMIN_NEEDS_DUMP_UPGRADE -14
 
/**
   Return values for check_if_supported_inplace_alter().
 
   @see check_if_supported_inplace_alter() for description of
   the individual values.
*/
enum enum_alter_inplace_result {
  HA_ALTER_ERROR,
  HA_ALTER_INPLACE_NOT_SUPPORTED,
  HA_ALTER_INPLACE_EXCLUSIVE_LOCK,
  HA_ALTER_INPLACE_SHARED_LOCK_AFTER_PREPARE,
  HA_ALTER_INPLACE_SHARED_LOCK,
  HA_ALTER_INPLACE_NO_LOCK_AFTER_PREPARE,
  HA_ALTER_INPLACE_NO_LOCK,
  HA_ALTER_INPLACE_INSTANT
};
 
/* Bits in table_flags() to show what database can do */
 
#define HA_NO_TRANSACTIONS (1 << 0)     /* Doesn't support transactions */
#define HA_PARTIAL_COLUMN_READ (1 << 1) /* read may not return all columns */
/*
  Used to avoid scanning full tables on an index. If this flag is set then
  the handler always has a primary key (hidden if not defined) and this
  index is used for scanning rather than a full table scan in all
  situations. No separate data/index file.
*/
#define HA_TABLE_SCAN_ON_INDEX (1 << 2)
 
/// Not in use.
#define HA_UNUSED3 (1 << 3)
 
/*
  Can the storage engine handle spatial data.
  Used to check that no spatial attributes are declared unless
  the storage engine is capable of handling it.
*/
#define HA_CAN_GEOMETRY (1 << 4)
/*
  Reading keys in random order is as fast as reading keys in sort order
  (Used by filesort to decide if we should sort key + data or key +
  pointer-to-row.)
*/
#define HA_FAST_KEY_READ (1 << 5)
/*
  Set the following flag if we on delete should force all key to be read
  and on update read all keys that changes
*/
#define HA_REQUIRES_KEY_COLUMNS_FOR_DELETE (1 << 6)
/*
  Is NULL values allowed in indexes.
  If this is not allowed then it is not possible to use an index on a
  NULLable field.
*/
#define HA_NULL_IN_KEY (1 << 7)
/*
  Tells that we can the position for the conflicting duplicate key
  record is stored in table->file->dupp_ref. (insert uses rnd_pos() on
  this to find the duplicated row)
*/
#define HA_DUPLICATE_POS (1 << 8)
#define HA_NO_BLOBS (1 << 9) /* Doesn't support blobs */
/*
  Is the storage engine capable of defining an index of a prefix on
  a BLOB attribute.
*/
#define HA_CAN_INDEX_BLOBS (1 << 10)
/*
  Auto increment fields can be part of a multi-part key. For second part
  auto-increment keys, the auto_incrementing is done in handler.cc
*/
#define HA_AUTO_PART_KEY (1 << 11)
/*
  Can't define a table without primary key (and cannot handle a table
  with hidden primary key)
*/
#define HA_REQUIRE_PRIMARY_KEY (1 << 12)
/*
  Does the counter of records after the info call specify an exact
  value or not. If it does this flag is set.
*/
#define HA_STATS_RECORDS_IS_EXACT (1 << 13)
/// Not in use.
#define HA_UNUSED14 (1 << 14)
/*
  This parameter is set when the handler will also return the primary key
  when doing read-only-key on another index, i.e., if we get the primary
  key columns for free when we do an index read (usually, it also implies
  that HA_PRIMARY_KEY_REQUIRED_FOR_POSITION flag is set).
*/
#define HA_PRIMARY_KEY_IN_READ_INDEX (1 << 15)
/*
  If HA_PRIMARY_KEY_REQUIRED_FOR_POSITION is set, it means that to position()
  uses a primary key given by the record argument.
  Without primary key, we can't call position().
  If not set, the position is returned as the current rows position
  regardless of what argument is given.
*/
#define HA_PRIMARY_KEY_REQUIRED_FOR_POSITION (1 << 16)
#define HA_CAN_RTREEKEYS (1 << 17)
/// Not in use.
#define HA_UNUSED18
/*
  The following is we need to a primary key to delete (and update) a row.
  If there is no primary key, all columns needs to be read on update and delete
*/
#define HA_PRIMARY_KEY_REQUIRED_FOR_DELETE (1 << 19)
/*
  Indexes on prefixes of character fields are not allowed.
*/
#define HA_NO_PREFIX_CHAR_KEYS (1 << 20)
/*
  Does the storage engine support fulltext indexes.
*/
#define HA_CAN_FULLTEXT (1 << 21)
/*
  Can the HANDLER interface in the MySQL API be used towards this
  storage engine.
*/
#define HA_CAN_SQL_HANDLER (1 << 22)
/*
  Set if the storage engine does not support auto increment fields.
*/
#define HA_NO_AUTO_INCREMENT (1 << 23)
/*
  Supports CHECKSUM option in CREATE TABLE (MyISAM feature).
*/
#define HA_HAS_CHECKSUM (1 << 24)
/*
  Table data are stored in separate files (for lower_case_table_names).
  Should file names always be in lower case (used by engines that map
  table names to file names.
*/
#define HA_FILE_BASED (1 << 26)
#define HA_NO_VARCHAR (1 << 27)
/*
  Is the storage engine capable of handling bit fields.
*/
#define HA_CAN_BIT_FIELD (1 << 28)
#define HA_ANY_INDEX_MAY_BE_UNIQUE (1 << 30)
#define HA_NO_COPY_ON_ALTER (1LL << 31)
#define HA_COUNT_ROWS_INSTANT (1LL << 32) /* records() gives exact count*/
/* Has it's own method of binlog logging */
#define HA_HAS_OWN_BINLOGGING (1LL << 33)
/*
  Engine is capable of row-format and statement-format logging,
  respectively
*/
#define HA_BINLOG_ROW_CAPABLE (1LL << 34)
#define HA_BINLOG_STMT_CAPABLE (1LL << 35)
/*
    When a multiple key conflict happens in a REPLACE command mysql
    expects the conflicts to be reported in the ascending order of
    key names.
 
    For e.g.
 
    CREATE TABLE t1 (a INT, UNIQUE (a), b INT NOT NULL, UNIQUE (b), c INT NOT
                     NULL, INDEX(c));
 
    REPLACE INTO t1 VALUES (1,1,1),(2,2,2),(2,1,3);
 
    MySQL expects the conflict with 'a' to be reported before the conflict with
    'b'.
 
    If the underlying storage engine does not report the conflicting keys in
    ascending order, it causes unexpected errors when the REPLACE command is
    executed.
 
    This flag helps the underlying SE to inform the server that the keys are not
    ordered.
*/
#define HA_DUPLICATE_KEY_NOT_IN_ORDER (1LL << 36)
/*
  Engine supports REPAIR TABLE. Used by CHECK TABLE FOR UPGRADE if an
  incompatible table is detected. If this flag is set, CHECK TABLE FOR UPGRADE
  will report ER_TABLE_NEEDS_UPGRADE, otherwise ER_TABLE_NEED_REBUILD.
*/
#define HA_CAN_REPAIR (1LL << 37)
 
/*
  Set of all binlog flags. Currently only contain the capabilities
  flags.
 */
#define HA_BINLOG_FLAGS (HA_BINLOG_ROW_CAPABLE | HA_BINLOG_STMT_CAPABLE)
 
/**
  The handler supports read before write removal optimization
 
  Read before write removal may be used for storage engines which support
  write without previous read of the row to be updated. Handler returning
  this flag must implement start_read_removal() and end_read_removal().
  The handler may return "fake" rows constructed from the key of the row
  asked for. This is used to optimize UPDATE and DELETE by reducing the
  number of round-trips between handler and storage engine.
 
  Example:
  UPDATE a=1 WHERE pk IN (@<keys@>)
 
  @verbatim
  mysql_update()
  {
    if (<conditions for starting read removal>)
      start_read_removal()
      -> handler returns true if read removal supported for this table/query
 
    while(read_record("pk=<key>"))
      -> handler returns fake row with column "pk" set to <key>
 
      ha_update_row()
      -> handler sends write "a=1" for row with "pk=<key>"
 
    end_read_removal()
    -> handler returns the number of rows actually written
  }
  @endverbatim
 
  @note This optimization in combination with batching may be used to
        remove even more round-trips.
*/
#define HA_READ_BEFORE_WRITE_REMOVAL (1LL << 38)
 
/*
  Engine supports extended fulltext API
 */
#define HA_CAN_FULLTEXT_EXT (1LL << 39)
 
/*
  Storage engine doesn't synchronize result set with expected table contents.
  Used by replication slave to check if it is possible to retrieve rows from
  the table when deciding whether to do a full table scan, index scan or hash
  scan while applying a row event.
 */
#define HA_READ_OUT_OF_SYNC (1LL << 40)
 
/*
  Storage engine supports table export using the
  FLUSH TABLE <table_list> FOR EXPORT statement.
 */
#define HA_CAN_EXPORT (1LL << 41)
 
/*
  The handler don't want accesses to this table to
  be const-table optimized
*/
#define HA_BLOCK_CONST_TABLE (1LL << 42)
 
/*
  Handler supports FULLTEXT hints
*/
#define HA_CAN_FULLTEXT_HINTS (1LL << 43)
 
/**
  Storage engine doesn't support LOCK TABLE ... READ LOCAL locks
  but doesn't want to use handler::store_lock() API for upgrading
  them to LOCK TABLE ... READ locks, for example, because it doesn't
  use THR_LOCK locks at all.
*/
#define HA_NO_READ_LOCAL_LOCK (1LL << 44)
 
/**
  A storage engine is compatible with the attachable transaction requirements
  means that
 
    - either SE detects the fact that THD::ha_data was reset and starts a new
      attachable transaction, closes attachable transaction on close_connection
      and resumes regular (outer) transaction when THD::ha_data is restored;
 
    - or SE completely ignores THD::ha_data and close_connection like MyISAM
      does.
*/
#define HA_ATTACHABLE_TRX_COMPATIBLE (1LL << 45)
 
/**
  Handler supports Generated Columns
*/
#define HA_GENERATED_COLUMNS (1LL << 46)
 
/**
  Supports index on virtual generated column
*/
#define HA_CAN_INDEX_VIRTUAL_GENERATED_COLUMN (1LL << 47)
 
/**
  Supports descending indexes
*/
#define HA_DESCENDING_INDEX (1LL << 48)
 
/**
  Supports partial update of BLOB columns.
*/
#define HA_BLOB_PARTIAL_UPDATE (1LL << 49)
 
/**
  If this isn't defined, only columns/indexes with Cartesian coordinate systems
  (projected SRS or SRID 0) is supported. Columns/indexes without SRID
  restriction is also supported if this isn't defined.
*/
#define HA_SUPPORTS_GEOGRAPHIC_GEOMETRY_COLUMN (1LL << 50)
 
/**
  Handler supports expressions as DEFAULT for a column.
*/
#define HA_SUPPORTS_DEFAULT_EXPRESSION (1LL << 51)
 
/**
  Handlers with this flag set do not support UPDATE operations.
*/
#define HA_UPDATE_NOT_SUPPORTED (1LL << 52)
 
/**
  Handlers with this flag set do not support DELETE operations.
*/
#define HA_DELETE_NOT_SUPPORTED (1LL << 53)
 
/**
  The storage engine does not support using indexes for access. Indexes can only
  be used for estimating cost.
*/
#define HA_NO_INDEX_ACCESS (1LL << 54)
 
/**
  Supports multi-valued index
*/
#define HA_MULTI_VALUED_KEY_SUPPORT (1LL << 55)
 
/*
  Bits in index_flags(index_number) for what you can do with index.
  If you do not implement indexes, just return zero here.
*/
/*
  Does the index support read next, this is assumed in the server
  code and never checked so all indexes must support this.
  Note that the handler can be used even if it doesn't have any index.
*/
#define HA_READ_NEXT 1 /* TODO really use this flag */
/*
  Can the index be used to scan backwards (supports ::index_prev).
*/
#define HA_READ_PREV 2
/*
  Can the index deliver its record in index order. Typically true for
  all ordered indexes and not true for hash indexes. Used to set keymap
  part_of_sortkey.
  This keymap is only used to find indexes usable for resolving an ORDER BY
  in the query. Thus in most cases index_read will work just fine without
  order in result production. When this flag is set it is however safe to
  order all output started by index_read since most engines do this. With
  read_multi_range calls there is a specific flag setting order or not
  order so in those cases ordering of index output can be avoided.
*/
#define HA_READ_ORDER 4
/*
  Specify whether index can handle ranges, typically true for all
  ordered indexes and not true for hash indexes.
  Used by optimiser to check if ranges (as key >= 5) can be optimised
  by index.
*/
#define HA_READ_RANGE 8
/*
  Can't use part key searches. This is typically true for hash indexes
  and typically not true for ordered indexes.
*/
#define HA_ONLY_WHOLE_INDEX 16
/*
  Does the storage engine support index-only scans on this index.
  Enables use of HA_EXTRA_KEYREAD and HA_EXTRA_NO_KEYREAD
  Used to set Key_map keys_for_keyread and to check in optimiser for
  index-only scans.  When doing a read under HA_EXTRA_KEYREAD the handler
  only have to fill in the columns the key covers. If
  HA_PRIMARY_KEY_IN_READ_INDEX is set then also the PRIMARY KEY columns
  must be updated in the row.
*/
#define HA_KEYREAD_ONLY 64
/*
  Index scan will not return records in rowid order. Not guaranteed to be
  set for unordered (e.g. HASH) indexes.
*/
#define HA_KEY_SCAN_NOT_ROR 128
#define HA_DO_INDEX_COND_PUSHDOWN 256 /* Supports Index Condition Pushdown */
 
/* operations for disable/enable indexes */
#define HA_KEY_SWITCH_NONUNIQ 0
#define HA_KEY_SWITCH_ALL 1
#define HA_KEY_SWITCH_NONUNIQ_SAVE 2
#define HA_KEY_SWITCH_ALL_SAVE 3
 
/*
  Use this instead of 0 as the initial value for the slot number of
  handlerton, so that we can distinguish uninitialized slot number
  from slot 0.
*/
#define HA_SLOT_UNDEF ((uint)-1)
 
/*
  Parameters for open() (in register form->filestat)
  HA_GET_INFO does an implicit HA_ABORT_IF_LOCKED
*/
 
#define HA_OPEN_KEYFILE 1
#define HA_OPEN_RNDFILE 2
#define HA_GET_INDEX 4
#define HA_GET_INFO 8   /* do a handler::info() after open */
#define HA_READ_ONLY 16 /* File opened as readonly */
/* Try readonly if can't open with read and write */
#define HA_TRY_READ_ONLY 32
#define HA_WAIT_IF_LOCKED 64   /* Wait if locked on open */
#define HA_ABORT_IF_LOCKED 128 /* skip if locked on open.*/
#define HA_BLOCK_LOCK 256      /* unlock when reading some records */
#define HA_OPEN_TEMPORARY 512
 
/* Some key definitions */
#define HA_KEY_NULL_LENGTH 1
#define HA_KEY_BLOB_LENGTH 2
 
#define HA_LEX_CREATE_TMP_TABLE 1
#define HA_LEX_CREATE_IF_NOT_EXISTS 2
#define HA_LEX_CREATE_TABLE_LIKE 4
#define HA_LEX_CREATE_INTERNAL_TMP_TABLE 8
#define HA_MAX_REC_LENGTH 65535U
 
/**
  Options for the START TRANSACTION statement.
 
  Note that READ ONLY and READ WRITE are logically mutually exclusive.
  This is enforced by the parser and depended upon by trans_begin().
 
  We need two flags instead of one in order to differentiate between
  situation when no READ WRITE/ONLY clause were given and thus transaction
  is implicitly READ WRITE and the case when READ WRITE clause was used
  explicitly.
*/
 
// WITH CONSISTENT SNAPSHOT option
static const uint MYSQL_START_TRANS_OPT_WITH_CONS_SNAPSHOT = 1;
// READ ONLY option
static const uint MYSQL_START_TRANS_OPT_READ_ONLY = 2;
// READ WRITE option
static const uint MYSQL_START_TRANS_OPT_READ_WRITE = 4;
// HIGH PRIORITY option
static const uint MYSQL_START_TRANS_OPT_HIGH_PRIORITY = 8;
 
enum legacy_db_type {
  DB_TYPE_UNKNOWN = 0,
  DB_TYPE_DIAB_ISAM = 1,
  DB_TYPE_HASH,
  DB_TYPE_MISAM,
  DB_TYPE_PISAM,
  DB_TYPE_RMS_ISAM,
  DB_TYPE_HEAP,
  DB_TYPE_ISAM,
  DB_TYPE_MRG_ISAM,
  DB_TYPE_MYISAM,
  DB_TYPE_MRG_MYISAM,
  DB_TYPE_BERKELEY_DB,
  DB_TYPE_INNODB,
  DB_TYPE_GEMINI,
  DB_TYPE_NDBCLUSTER,
  DB_TYPE_EXAMPLE_DB,
  DB_TYPE_ARCHIVE_DB,
  DB_TYPE_CSV_DB,
  DB_TYPE_FEDERATED_DB,
  DB_TYPE_BLACKHOLE_DB,
  DB_TYPE_PARTITION_DB,  // No longer used.
  DB_TYPE_BINLOG,
  DB_TYPE_SOLID,
  DB_TYPE_PBXT,
  DB_TYPE_TABLE_FUNCTION,
  DB_TYPE_MEMCACHE,
  DB_TYPE_FALCON,
  DB_TYPE_MARIA,
  /** Performance schema engine. */
  DB_TYPE_PERFORMANCE_SCHEMA,
  DB_TYPE_TEMPTABLE,
  DB_TYPE_FIRST_DYNAMIC = 42,
  DB_TYPE_DEFAULT = 127  // Must be last
};
 
enum row_type : int {
  ROW_TYPE_NOT_USED = -1,
  ROW_TYPE_DEFAULT,
  ROW_TYPE_FIXED,
  ROW_TYPE_DYNAMIC,
  ROW_TYPE_COMPRESSED,
  ROW_TYPE_REDUNDANT,
  ROW_TYPE_COMPACT,
  /** Unused. Reserved for future versions. */
  ROW_TYPE_PAGED
};
 
enum enum_binlog_func {
  BFN_RESET_LOGS = 1,
  BFN_RESET_SLAVE = 2,
  BFN_BINLOG_WAIT = 3,
  BFN_BINLOG_END = 4,
  BFN_BINLOG_PURGE_FILE = 5
};
 
enum enum_binlog_command {
  LOGCOM_CREATE_TABLE,
  LOGCOM_ALTER_TABLE,
  LOGCOM_RENAME_TABLE,
  LOGCOM_DROP_TABLE,
  LOGCOM_CREATE_DB,
  LOGCOM_ALTER_DB,
  LOGCOM_DROP_DB,
};
 
enum class enum_sampling_method { SYSTEM, NONE };
 
/* Bits in used_fields */
#define HA_CREATE_USED_AUTO (1L << 0)
#define HA_CREATE_USED_RAID (1L << 1)  // RAID is no longer availble
#define HA_CREATE_USED_UNION (1L << 2)
#define HA_CREATE_USED_INSERT_METHOD (1L << 3)
#define HA_CREATE_USED_MIN_ROWS (1L << 4)
#define HA_CREATE_USED_MAX_ROWS (1L << 5)
#define HA_CREATE_USED_AVG_ROW_LENGTH (1L << 6)
#define HA_CREATE_USED_PACK_KEYS (1L << 7)
#define HA_CREATE_USED_CHARSET (1L << 8)
#define HA_CREATE_USED_DEFAULT_CHARSET (1L << 9)
#define HA_CREATE_USED_DATADIR (1L << 10)
#define HA_CREATE_USED_INDEXDIR (1L << 11)
#define HA_CREATE_USED_ENGINE (1L << 12)
#define HA_CREATE_USED_CHECKSUM (1L << 13)
#define HA_CREATE_USED_DELAY_KEY_WRITE (1L << 14)
#define HA_CREATE_USED_ROW_FORMAT (1L << 15)
#define HA_CREATE_USED_COMMENT (1L << 16)
#define HA_CREATE_USED_PASSWORD (1L << 17)
#define HA_CREATE_USED_CONNECTION (1L << 18)
#define HA_CREATE_USED_KEY_BLOCK_SIZE (1L << 19)
/** Unused. Reserved for future versions. */
#define HA_CREATE_USED_TRANSACTIONAL (1L << 20)
/** Unused. Reserved for future versions. */
#define HA_CREATE_USED_PAGE_CHECKSUM (1L << 21)
/** This is set whenever STATS_PERSISTENT=0|1|default has been
specified in CREATE/ALTER TABLE. See also HA_OPTION_STATS_PERSISTENT in
include/my_base.h. It is possible to distinguish whether
STATS_PERSISTENT=default has been specified or no STATS_PERSISTENT= is
given at all. */
#define HA_CREATE_USED_STATS_PERSISTENT (1L << 22)
/**
   This is set whenever STATS_AUTO_RECALC=0|1|default has been
   specified in CREATE/ALTER TABLE. See enum_stats_auto_recalc.
   It is possible to distinguish whether STATS_AUTO_RECALC=default
   has been specified or no STATS_AUTO_RECALC= is given at all.
*/
#define HA_CREATE_USED_STATS_AUTO_RECALC (1L << 23)
/**
   This is set whenever STATS_SAMPLE_PAGES=N|default has been
   specified in CREATE/ALTER TABLE. It is possible to distinguish whether
   STATS_SAMPLE_PAGES=default has been specified or no STATS_SAMPLE_PAGES= is
   given at all.
*/
#define HA_CREATE_USED_STATS_SAMPLE_PAGES (1L << 24)
 
/**
   This is set whenever a 'TABLESPACE=...' phrase is used on CREATE TABLE
*/
#define HA_CREATE_USED_TABLESPACE (1L << 25)
 
/** COMPRESSION="zlib|lz4|none" used during table create. */
#define HA_CREATE_USED_COMPRESS (1L << 26)
 
/** ENCRYPTION="Y" used during table create. */
#define HA_CREATE_USED_ENCRYPT (1L << 27)
 
/**
  CREATE|ALTER SCHEMA|DATABASE|TABLE has an explicit COLLATE clause.
 
  Implies HA_CREATE_USED_DEFAULT_CHARSET.
*/
#define HA_CREATE_USED_DEFAULT_COLLATE (1L << 28)
 
/** SECONDARY_ENGINE used during table create. */
#define HA_CREATE_USED_SECONDARY_ENGINE (1L << 29)
 
/**
  CREATE|ALTER SCHEMA|DATABASE has an explicit ENCRYPTION clause.
 
  Implies HA_CREATE_USED_DEFAULT_ENCRYPTION.
*/
#define HA_CREATE_USED_DEFAULT_ENCRYPTION (1L << 30)
 
/**
  This option is used to convey that the create table should not
  commit the operation and keep the transaction started.
*/
constexpr const uint64_t HA_CREATE_USED_START_TRANSACTION{1ULL << 31};
 
constexpr const uint64_t HA_CREATE_USED_ENGINE_ATTRIBUTE{1ULL << 32};
constexpr const uint64_t HA_CREATE_USED_SECONDARY_ENGINE_ATTRIBUTE{1ULL << 33};
 
/**
  ALTER SCHEMA|DATABASE has an explicit READ_ONLY clause.
 
  Implies HA_CREATE_USED_READ_ONLY.
*/
constexpr const uint64_t HA_CREATE_USED_READ_ONLY{1ULL << 34};
 
/**
  These flags convey that the options AUTOEXTEND_SIZE has been
  specified in the CREATE TABLE statement
*/
constexpr const uint64_t HA_CREATE_USED_AUTOEXTEND_SIZE{1ULL << 35};
 
/*
  End of bits used in used_fields
*/
 
/*
  Structure to hold list of database_name.table_name.
  This is used at both mysqld and storage engine layer.
*/
struct st_handler_tablename {
  const char *db;
  const char *tablename;
};
 
#define MAXGTRIDSIZE 64
#define MAXBQUALSIZE 64
 
#define COMPATIBLE_DATA_YES 0
#define COMPATIBLE_DATA_NO 1
 
/*
  These structures are used to pass information from a set of SQL commands
  on add/drop/change tablespace definitions to the proper hton.
*/
#define UNDEF_NODEGROUP 65535
 
// FUTURE: Combine these two enums into one enum class
enum ts_command_type {
  TS_CMD_NOT_DEFINED = -1,
  CREATE_TABLESPACE = 0,
  ALTER_TABLESPACE = 1,
  CREATE_LOGFILE_GROUP = 2,
  ALTER_LOGFILE_GROUP = 3,
  DROP_TABLESPACE = 4,
  DROP_LOGFILE_GROUP = 5,
  CHANGE_FILE_TABLESPACE = 6,
  ALTER_ACCESS_MODE_TABLESPACE = 7,
  CREATE_UNDO_TABLESPACE = 8,
  ALTER_UNDO_TABLESPACE = 9,
  DROP_UNDO_TABLESPACE = 10
};
 
enum ts_alter_tablespace_type {
  TS_ALTER_TABLESPACE_TYPE_NOT_DEFINED = -1,
  ALTER_TABLESPACE_ADD_FILE = 1,
  ALTER_TABLESPACE_DROP_FILE = 2,
  ALTER_TABLESPACE_RENAME = 3,
  ALTER_TABLESPACE_OPTIONS = 4,
  ALTER_UNDO_TABLESPACE_SET_ACTIVE = 5,
  ALTER_UNDO_TABLESPACE_SET_INACTIVE = 6
};
 
/**
  Legacy struct for passing tablespace information to SEs.
 
  FUTURE: Pass all info through dd objects
 */
class st_alter_tablespace {
 public:
  const char *tablespace_name = nullptr;
  const char *logfile_group_name = nullptr;
  ts_command_type ts_cmd_type = TS_CMD_NOT_DEFINED;
  enum ts_alter_tablespace_type ts_alter_tablespace_type =
      TS_ALTER_TABLESPACE_TYPE_NOT_DEFINED;
  const char *data_file_name = nullptr;
  const char *undo_file_name = nullptr;
  ulonglong extent_size = 1024 * 1024;           // Default 1 MByte
  ulonglong undo_buffer_size = 8 * 1024 * 1024;  // Default 8 MByte
  ulonglong redo_buffer_size = 8 * 1024 * 1024;  // Default 8 MByte
  ulonglong initial_size = 128 * 1024 * 1024;    // Default 128 MByte
  Mysql::Nullable<ulonglong> autoextend_size;    // No autoextension as default
  ulonglong max_size = 0;         // Max size == initial size => no extension
  ulonglong file_block_size = 0;  // 0=default or must be a valid Page Size
  uint nodegroup_id = UNDEF_NODEGROUP;
  bool wait_until_completed = true;
  const char *ts_comment = nullptr;
  const char *encryption = nullptr;
 
  bool is_tablespace_command() {
    return ts_cmd_type == CREATE_TABLESPACE ||
           ts_cmd_type == ALTER_TABLESPACE || ts_cmd_type == DROP_TABLESPACE ||
           ts_cmd_type == CHANGE_FILE_TABLESPACE ||
           ts_cmd_type == ALTER_ACCESS_MODE_TABLESPACE;
  }
 
  /**
    Proper constructor even for all-public class simplifies initialization and
    allows members to be const.
 
    FUTURE: With constructor all members can be made const, and do not need
    default initializers.
 
    @param tablespace name of tabelspace (nullptr for logfile group statements)
    @param logfile_group name of logfile group or nullptr
    @param cmd main statement type
    @param alter_tablespace_cmd subcommand type for ALTER TABLESPACE
    @param datafile tablespace file for CREATE and ALTER ... ADD ...
    @param undofile only applies to logfile group statements. nullptr otherwise.
    @param opts options provided by parser
  */
  st_alter_tablespace(const char *tablespace, const char *logfile_group,
                      ts_command_type cmd,
                      enum ts_alter_tablespace_type alter_tablespace_cmd,
                      const char *datafile, const char *undofile,
                      const Tablespace_options &opts);
};
 
/*
  Make sure that the order of schema_tables and enum_schema_tables are the same.
*/
enum enum_schema_tables : int {
  SCH_FIRST = 0,
  SCH_COLUMN_PRIVILEGES = SCH_FIRST,
  SCH_ENGINES,
  SCH_OPEN_TABLES,
  SCH_OPTIMIZER_TRACE,
  SCH_PLUGINS,
  SCH_PROCESSLIST,
  SCH_PROFILES,
  SCH_SCHEMA_PRIVILEGES,
  SCH_TABLESPACES,
  SCH_TABLE_PRIVILEGES,
  SCH_USER_PRIVILEGES,
  SCH_TMP_TABLE_COLUMNS,
  SCH_TMP_TABLE_KEYS,
  SCH_LAST = SCH_TMP_TABLE_KEYS
};
 
enum ha_stat_type { HA_ENGINE_STATUS, HA_ENGINE_LOGS, HA_ENGINE_MUTEX };
enum ha_notification_type : int { HA_NOTIFY_PRE_EVENT, HA_NOTIFY_POST_EVENT };
 
/** Clone start operation mode */
enum Ha_clone_mode {
  /** Start a new clone operation */
  HA_CLONE_MODE_START,
 
  /** Re-start a clone operation after failure */
  HA_CLONE_MODE_RESTART,
 
  /** Add a new task to a running clone operation */
  HA_CLONE_MODE_ADD_TASK,
 
  /** Get version for transfer data format */
  HA_CLONE_MODE_VERSION,
 
  /** Max value for clone mode */
  HA_CLONE_MODE_MAX
};
 
/** Clone operation types. */
enum Ha_clone_type : size_t {
  /** Caller must block all write operation to the SE. */
  HA_CLONE_BLOCKING,
 
  /** For transactional SE, archive redo to support concurrent dml */
  HA_CLONE_REDO,
 
  /** For transactional SE, track page changes to support concurrent dml */
  HA_CLONE_PAGE,
 
  /** For transactional SE, use both page tracking and redo to optimize
  clone with concurrent dml. Currently supported by Innodb. */
  HA_CLONE_HYBRID,
 
  /** SE supports multiple threads for clone */
  HA_CLONE_MULTI_TASK,
 
  /** SE supports restarting clone after network failure */
  HA_CLONE_RESTART,
 
  /** Maximum value of clone type */
  HA_CLONE_TYPE_MAX
};
 
using Ha_clone_flagset = std::bitset<HA_CLONE_TYPE_MAX>;
 
void set_externally_disabled_storage_engine_names(const char *);
bool ha_is_externally_disabled(const handlerton &);
 
/** File reference for clone */
struct Ha_clone_file {
  /** File reference type */
  enum {
    /** File handle */
    FILE_HANDLE,
 
    /** File descriptor */
    FILE_DESC
 
  } type;
 
  /** File reference */
  union {
    /** File descriptor */
    int file_desc;
 
    /** File handle for windows */
    void *file_handle;
  };
};
 
/* Abstract callback interface to stream data back to the caller. */
class Ha_clone_cbk {
 protected:
  /** Constructor to initialize members. */
  Ha_clone_cbk()
      : m_hton(),
        m_loc_idx(),
        m_client_buff_size(),
        m_data_desc(),
        m_desc_len(),
        m_src_name(),
        m_dest_name(),
        m_state_estimate(),
        m_flag() {}
 
 public:
  /** Callback providing data from current position of a
  file descriptor of specific length.
  @param[in]  from_file  source file to read from
  @param[in]  len        data length
  @return error code */
  virtual int file_cbk(Ha_clone_file from_file, uint len) = 0;
 
  /** Callback providing data in buffer of specific length.
  @param[in]  from_buffer  source buffer to read from
  @param[in]  len          data length
  @return error code */
  virtual int buffer_cbk(uchar *from_buffer, uint len) = 0;
 
  /** Callback providing a file descriptor to write data starting
  from current position.
  @param[in]  to_file  destination file to write data
  @return error code */
  virtual int apply_file_cbk(Ha_clone_file to_file) = 0;
 
  /** Callback to get data in buffer.
  @param[out]  to_buffer  data buffer
  @param[out]  len        data length
  @return error code */
  virtual int apply_buffer_cbk(uchar *&to_buffer, uint &len) = 0;
 
  /** virtual destructor. */
  virtual ~Ha_clone_cbk() = default;
 
  /** Set current storage engine handlerton.
  @param[in]  hton  SE handlerton */
  void set_hton(handlerton *hton) { m_hton = hton; }
 
  /** Get current storage engine handlerton.
  @return SE handlerton */
  handlerton *get_hton() { return (m_hton); }
 
  /** Set caller's transfer buffer size. SE can adjust the data chunk size
  based on this parameter.
  @param[in]  size  buffer size in bytes */
  void set_client_buffer_size(uint size) { m_client_buff_size = size; }
 
  /** Get caller's transfer buffer size.
  @return buffer size in bytes */
  uint get_client_buffer_size() { return (m_client_buff_size); }
 
  /** Set current SE index.
  @param[in]  idx  SE index in locator array */
  void set_loc_index(uint idx) { m_loc_idx = idx; }
 
  /** Get current SE index.
  @return SE index in locator array */
  uint get_loc_index() { return (m_loc_idx); }
 
  /** Set data descriptor. SE specific descriptor for the
  data transferred by the callbacks.
  @param[in]  desc  serialized data descriptor
  @param[in]  len   length of the descriptor byte stream  */
  void set_data_desc(const uchar *desc, uint len) {
    m_data_desc = desc;
    m_desc_len = len;
  }
 
  /** Get data descriptor. SE specific descriptor for the
  data transferred by the callbacks.
  @param[out]  lenp  length of the descriptor byte stream
  @return pointer to the serialized data descriptor */
  const uchar *get_data_desc(uint *lenp) {
    if (lenp != nullptr) {
      *lenp = m_desc_len;
    }
 
    return (m_data_desc);
  }
 
  /** Get SE source file name. Used for debug printing and error message.
  @return null terminated string for source file name */
  const char *get_source_name() { return (m_src_name); }
 
  /** Set SE source file name.
  @param[in]   name  null terminated string for source file name */
  void set_source_name(const char *name) { m_src_name = name; }
 
  /** Get SE destination file name. Used for debug printing and error message.
  @return null terminated string for destination file name */
  const char *get_dest_name() { return (m_dest_name); }
 
  /** Set SE destination file name.
  @param[in]   name  null terminated string for destination file name */
  void set_dest_name(const char *name) { m_dest_name = name; }
 
  /** Clear all flags set by SE */
  void clear_flags() { m_flag = 0; }
 
  /** Mark that ACK is needed for the data transfer before returning
  from callback. Set by SE. */
  void set_ack() { m_flag |= HA_CLONE_ACK; }
 
  /** Check if ACK is needed for the data transfer
  @return true if ACK is needed */
  bool is_ack_needed() const { return (m_flag & HA_CLONE_ACK); }
 
  /** Mark that the file descriptor is opened for read/write
  with OS buffer cache. For O_DIRECT, the flag is not set. */
  void set_os_buffer_cache() { m_flag |= HA_CLONE_FILE_CACHE; }
 
  /** Check if the file descriptor is opened for read/write with OS
  buffer cache. Currently clone avoids using zero copy (sendfile on linux),
  if SE is using O_DIRECT. This improves data copy performance.
  @return true if O_DIRECT is not used */
  bool is_os_buffer_cache() const { return (m_flag & HA_CLONE_FILE_CACHE); }
 
  /** Mark that the file can be transferred with zero copy. */
  void set_zero_copy() { m_flag |= HA_CLONE_ZERO_COPY; }
 
  /** Check if zero copy optimization is suggested. */
  bool is_zero_copy() const { return (m_flag & HA_CLONE_ZERO_COPY); }
 
  /** Mark that data needs secure transfer. */
  void set_secure() { m_flag |= HA_CLONE_SECURE; }
 
  /** Check if data needs secure transfer. */
  bool is_secure() const { return (m_flag & HA_CLONE_SECURE); }
 
  /** Set state information and notify state change.
  @param[in]    estimate        estimated bytes for current state. */
  void mark_state_change(uint64_t estimate) {
    m_flag |= HA_CLONE_STATE_CHANGE;
    m_state_estimate = estimate;
  }
 
  /** Check if SE notified state change. */
  bool is_state_change(uint64_t &estimate) {
    estimate = m_state_estimate;
    return (m_flag & HA_CLONE_STATE_CHANGE);
  }
 
 private:
  /** Handlerton for the SE */
  handlerton *m_hton;
 
  /** SE index in caller's locator array */
  uint m_loc_idx;
 
  /** Caller's transfer buffer size. */
  uint m_client_buff_size;
 
  /** SE's Serialized data descriptor */
  const uchar *m_data_desc;
 
  /** SE's Serialized descriptor length. */
  uint m_desc_len;
 
  /** Current source file name */
  const char *m_src_name;
 
  /** Current destination file name */
  const char *m_dest_name;
 
  /** Estimated bytes to be transferred. */
  uint64_t m_state_estimate;
 
  /** Flag storing data related options */
  int m_flag;
 
  /** Acknowledgement is needed for the data transfer. */
  const int HA_CLONE_ACK = 0x01;
 
  /** Data file is opened for read/write with OS buffer cache. */
  const int HA_CLONE_FILE_CACHE = 0x02;
 
  /** Data file can be transferred with zero copy. */
  const int HA_CLONE_ZERO_COPY = 0x04;
 
  /** Data needs to be transferred securely over SSL connection. */
  const int HA_CLONE_SECURE = 0x08;
 
  /** State change notification by SE. */
  const int HA_CLONE_STATE_CHANGE = 0x10;
};
 
/**
  Column type description for foreign key columns compatibility check.
 
  Contains subset of information from dd::Column class. It is inconvenient
  to use dd::Column class directly for such checks because it requires valid
  dd::Table object and in some cases we want to produce Ha_fk_column_type
  right from column description in Create_field format.
*/
struct Ha_fk_column_type {
  dd::enum_column_types type;
  /*
    Note that both dd::Column::char_length() and length here are really
    in bytes.
  */
  size_t char_length;
  const CHARSET_INFO *field_charset;
  size_t elements_count;
  uint numeric_scale;
  bool is_unsigned;
};
 
/* handlerton methods */
 
/**
  close_connection is only called if
  thd->ha_data[xxx_hton.slot] is non-zero, so even if you don't need
  this storage area - set it to something, so that MySQL would know
  this storage engine was accessed in this connection
*/
typedef int (*close_connection_t)(handlerton *hton, THD *thd);
 
/** Terminate connection/statement notification. */
typedef void (*kill_connection_t)(handlerton *hton, THD *thd);
 
/**
  Shut down all storage engine background tasks that might access
  the data dictionary, before the main shutdown.
*/
typedef void (*pre_dd_shutdown_t)(handlerton *hton);
 
/**
  sv points to a storage area, that was earlier passed
  to the savepoint_set call
*/
typedef int (*savepoint_rollback_t)(handlerton *hton, THD *thd, void *sv);
 
/**
  sv points to an uninitialized storage area of requested size
  (see savepoint_offset description)
*/
typedef int (*savepoint_set_t)(handlerton *hton, THD *thd, void *sv);
 
/**
  Check if storage engine allows to release metadata locks which were
  acquired after the savepoint if rollback to savepoint is done.
  @return true  - If it is safe to release MDL locks.
          false - If it is not.
*/
typedef bool (*savepoint_rollback_can_release_mdl_t)(handlerton *hton,
                                                     THD *thd);
 
typedef int (*savepoint_release_t)(handlerton *hton, THD *thd, void *sv);
 
/**
  'all' is true if it's a real commit, that makes persistent changes
  'all' is false if it's not in fact a commit but an end of the
  statement that is part of the transaction.
  NOTE 'all' is also false in auto-commit mode where 'end of statement'
  and 'real commit' mean the same event.
*/
typedef int (*commit_t)(handlerton *hton, THD *thd, bool all);
 
typedef int (*rollback_t)(handlerton *hton, THD *thd, bool all);
 
typedef int (*prepare_t)(handlerton *hton, THD *thd, bool all);
 
typedef int (*recover_t)(handlerton *hton, XA_recover_txn *xid_list, uint len,
                         MEM_ROOT *mem_root);
 
/** X/Open XA distributed transaction status codes */
enum xa_status_code {
  /**
    normal execution
  */
  XA_OK = 0,
 
  /**
    asynchronous operation already outstanding
  */
  XAER_ASYNC = -2,
 
  /**
    a resource manager error  occurred in the transaction branch
  */
  XAER_RMERR = -3,
 
  /**
    the XID is not valid
  */
  XAER_NOTA = -4,
 
  /**
    invalid arguments were given
  */
  XAER_INVAL = -5,
 
  /**
    routine invoked in an improper context
  */
  XAER_PROTO = -6,
 
  /**
    resource manager unavailable
  */
  XAER_RMFAIL = -7,
 
  /**
    the XID already exists
  */
  XAER_DUPID = -8,
 
  /**
    resource manager doing work outside transaction
  */
  XAER_OUTSIDE = -9
};
 
typedef xa_status_code (*commit_by_xid_t)(handlerton *hton, XID *xid);
 
typedef xa_status_code (*rollback_by_xid_t)(handlerton *hton, XID *xid);
 
/**
  Create handler object for the table in the storage engine.
 
  @param hton         Handlerton object for the storage engine.
  @param table        TABLE_SHARE for the table, can be NULL if caller
                      didn't perform full-blown open of table definition.
  @param partitioned  Indicates whether table is partitioned.
  @param mem_root     Memory root to be used for allocating handler
                      object.
*/
typedef handler *(*create_t)(handlerton *hton, TABLE_SHARE *table,
                             bool partitioned, MEM_ROOT *mem_root);
 
typedef void (*drop_database_t)(handlerton *hton, char *path);
 
typedef int (*panic_t)(handlerton *hton, enum ha_panic_function flag);
 
typedef int (*start_consistent_snapshot_t)(handlerton *hton, THD *thd);
 
/**
  Flush the log(s) of storage engine(s).
 
  @param hton Handlerton of storage engine.
  @param binlog_group_flush true if we got invoked by binlog group
    commit during flush stage, false in other cases.
  @retval false Succeed
  @retval true Error
*/
typedef bool (*flush_logs_t)(handlerton *hton, bool binlog_group_flush);
 
typedef bool (*show_status_t)(handlerton *hton, THD *thd, stat_print_fn *print,
                              enum ha_stat_type stat);
 
/**
  The flag values are defined in sql_partition.h.
  If this function is set, then it implies that the handler supports
  partitioned tables.
  If this function exists, then handler::get_partition_handler must also be
  implemented.
*/
typedef uint (*partition_flags_t)();
 
/**
  SE specific validation of the tablespace name.
 
  This function will ask the relevant SE whether the submitted tablespace
  name is valid.
 
  @param ts_cmd             Purpose of usage - is this tablespace DDL?
  @param tablespace_name    Name of the tablespace.
 
  @return Tablespace name validity.
    @retval Whether the tablespace name is valid.
*/
typedef bool (*is_valid_tablespace_name_t)(ts_command_type ts_cmd,
                                           const char *tablespace_name);
 
/**
  Get the tablespace name from the SE for the given schema and table.
 
  @param       thd              Thread context.
  @param       db_name          Name of the relevant schema.
  @param       table_name       Name of the relevant table.
  @param [out] tablespace_name  Name of the tablespace containing the table.
 
  @return Operation status.
    @retval == 0  Success.
    @retval != 0  Error (handler error code returned).
*/
typedef int (*get_tablespace_t)(THD *thd, LEX_CSTRING db_name,
                                LEX_CSTRING table_name,
                                LEX_CSTRING *tablespace_name);
 
/**
  Create/drop or alter tablespace in the storage engine.
 
  @param          hton        Hadlerton of the SE.
  @param          thd         Thread context.
  @param          ts_info     Description of tablespace and specific
                              operation on it.
  @param          old_ts_def  dd::Tablespace object describing old version
                              of tablespace.
  @param [in,out] new_ts_def  dd::Tablespace object describing new version
                              of tablespace. Engines which support atomic DDL
                              can adjust this object. The updated information
                              will be saved to the data-dictionary.
 
  @return Operation status.
    @retval == 0  Success.
    @retval != 0  Error (handler error code returned).
*/
typedef int (*alter_tablespace_t)(handlerton *hton, THD *thd,
                                  st_alter_tablespace *ts_info,
                                  const dd::Tablespace *old_ts_def,
                                  dd::Tablespace *new_ts_def);
 
/**
  SE interface for getting tablespace extension.
  @return Extension of tablespace datafile name.
*/
typedef const char *(*get_tablespace_filename_ext_t)();
 
/**
  Get the tablespace data from SE and insert it into Data dictionary
 
  @param    thd         Thread context
 
  @return Operation status.
  @retval == 0  Success.
  @retval != 0  Error (handler error code returned)
*/
typedef int (*upgrade_tablespace_t)(THD *thd);
 
/**
  Get the tablespace data from SE and insert it into Data dictionary
 
  @param[in]  tablespace     tablespace object
 
  @return Operation status.
  @retval == 0  Success.
  @retval != 0  Error (handler error code returned)
*/
typedef bool (*upgrade_space_version_t)(dd::Tablespace *tablespace);
 
/**
  Finish upgrade process inside storage engines.
  This includes resetting flags to indicate upgrade process
  and cleanup after upgrade.
 
  @param    thd      Thread context
  @param failed_upgrade True if the upgrade failed.
 
  @return Operation status.
  @retval == 0  Success.
  @retval != 0  Error (handler error code returned)
*/
typedef int (*finish_upgrade_t)(THD *thd, bool failed_upgrade);
 
/**
  Upgrade logs after the checkpoint from where upgrade
  process can only roll forward.
 
  @param    thd      Thread context
 
  @return Operation status.
  @retval == 0  Success.
  @retval != 0  Error (handler error code returned)
*/
typedef int (*upgrade_logs_t)(THD *thd);
 
enum class Tablespace_type {
  SPACE_TYPE_DICTIONARY,
  SPACE_TYPE_SYSTEM,
  SPACE_TYPE_UNDO,
  SPACE_TYPE_TEMPORARY,
  SPACE_TYPE_SHARED,
  SPACE_TYPE_IMPLICIT
};
 
/**
  Get the tablespace type from the SE.
 
  @param[in]  space          tablespace object
  @param[out] space_type     type of space
 
  @return Operation status.
  @retval false on success and true for failure.
*/
typedef bool (*get_tablespace_type_t)(const dd::Tablespace &space,
                                      Tablespace_type *space_type);
 
/**
  Get the tablespace type given the name, from the SE.
 
  @param[in]  tablespace_name tablespace name
  @param[out] space_type      type of space
 
  @return Operation status.
  @retval false on success and true for failure.
*/
typedef bool (*get_tablespace_type_by_name_t)(const char *tablespace_name,
                                              Tablespace_type *space_type);
 
typedef int (*fill_is_table_t)(handlerton *hton, THD *thd, TABLE_LIST *tables,
                               class Item *cond, enum enum_schema_tables);
 
typedef int (*binlog_func_t)(handlerton *hton, THD *thd, enum_binlog_func fn,
                             void *arg);
 
typedef void (*binlog_log_query_t)(handlerton *hton, THD *thd,
                                   enum_binlog_command binlog_command,
                                   const char *query, uint query_length,
                                   const char *db, const char *table_name);
 
typedef void (*acl_notify_t)(THD *thd,
                             const class Acl_change_notification *notice);
 
typedef int (*discover_t)(handlerton *hton, THD *thd, const char *db,
                          const char *name, uchar **frmblob, size_t *frmlen);
 
typedef int (*find_files_t)(handlerton *hton, THD *thd, const char *db,
                            const char *path, const char *wild, bool dir,
                            List<LEX_STRING> *files);
 
typedef int (*table_exists_in_engine_t)(handlerton *hton, THD *thd,
                                        const char *db, const char *name);
 
/**
  Check if the given db.tablename is a system table for this SE.
 
  @param db                         Database name to check.
  @param table_name                 table name to check.
  @param is_sql_layer_system_table  if the supplied db.table_name is a SQL
                                    layer system table.
 
  @see example_is_supported_system_table in ha_example.cc
 
  is_sql_layer_system_table is supplied to make more efficient
  checks possible for SEs that support all SQL layer tables.
 
  This interface is optional, so every SE need not implement it.
*/
typedef bool (*is_supported_system_table_t)(const char *db,
                                            const char *table_name,
                                            bool is_sql_layer_system_table);
 
/**
  Create SDI in a tablespace. This API should be used when upgrading
  a tablespace with no SDI or after invoking sdi_drop().
  @param[in]  tablespace     tablespace object
  @retval     false          success
  @retval     true           failure
*/
typedef bool (*sdi_create_t)(dd::Tablespace *tablespace);
 
/**
  Drop SDI in a tablespace. This API should be used only when
  SDI is corrupted.
  @param[in]  tablespace  tablespace object
  @retval     false       success
  @retval     true        failure
*/
typedef bool (*sdi_drop_t)(dd::Tablespace *tablespace);
 
/**
  Get the SDI keys in a tablespace into vector.
  @param[in]      tablespace  tablespace object
  @param[in,out]  vector      vector of SDI Keys
  @retval         false       success
  @retval         true        failure
*/
typedef bool (*sdi_get_keys_t)(const dd::Tablespace &tablespace,
                               sdi_vector_t &vector);
 
/**
  Retrieve SDI for a given SDI key.
 
  Since the caller of this api will not know the SDI length, SDI retrieval
  should be done in the following way.
 
  i.   Allocate initial memory of some size (Lets say 64KB)
  ii.  Pass the allocated memory to the below api.
  iii. If passed buffer is sufficient, sdi_get_by_id() copies the sdi
       to the buffer passed and returns success, else sdi_len is modified
       with the actual length of the SDI (and returns false on failure).
       For genuine errors, sdi_len is returned as UINT64_MAX
  iv.  If sdi_len != UINT64_MAX, retry the call after allocating the memory
       of sdi_len
  v.   Free the memory after using SDI (responsibility of caller)
 
  @param[in]      tablespace  tablespace object
  @param[in]      sdi_key     SDI key to uniquely identify SDI obj
  @param[in,out]  sdi         SDI retrieved from tablespace
                              A non-null pointer must be passed in
  @param[in,out]  sdi_len     in: length of the memory allocated
                              out: actual length of SDI
  @retval         false       success
  @retval         true        failure
*/
typedef bool (*sdi_get_t)(const dd::Tablespace &tablespace,
                          const sdi_key_t *sdi_key, void *sdi, uint64 *sdi_len);
 
/**
  Insert/Update SDI for a given SDI key.
  @param[in]  hton        handlerton object
  @param[in]  tablespace  tablespace object
  @param[in]  table       table object
  @param[in]  sdi_key     SDI key to uniquely identify SDI obj
  @param[in]  sdi         SDI to write into the tablespace
  @param[in]  sdi_len     length of SDI BLOB returned
  @retval     false       success
  @retval     true        failure, my_error() should be called
                          by SE
*/
typedef bool (*sdi_set_t)(handlerton *hton, const dd::Tablespace &tablespace,
                          const dd::Table *table, const sdi_key_t *sdi_key,
                          const void *sdi, uint64 sdi_len);
 
/**
  Delete SDI for a given SDI key.
  @param[in]  tablespace  tablespace object
  @param[in]  table       table object
  @param[in]  sdi_key     SDI key to uniquely identify SDI obj
  @retval     false       success
  @retval     true        failure, my_error() should be called
                          by SE
*/
typedef bool (*sdi_delete_t)(const dd::Tablespace &tablespace,
                             const dd::Table *table, const sdi_key_t *sdi_key);
 
/**
  Check if the DDSE is started in a way that leaves thd DD being read only.
 
  @retval true    The data dictionary can only be read.
  @retval false   The data dictionary can be read and written.
 */
typedef bool (*is_dict_readonly_t)();
 
/**
  Drop all temporary tables which have been left from previous server
  run belonging to this SE. Used on server start-up.
 
  @param[in]      hton   Handlerton for storage engine.
  @param[in]      thd    Thread context.
  @param[in,out]  files  List of files in directories for temporary files
                         which match tmp_file_prefix and thus can belong to
                         temporary tables (but not necessarily in this SE).
                         It is recommended to remove file from the list if
                         SE recognizes it as belonging to temporary table
                         in this SE and deletes it.
*/
typedef bool (*rm_tmp_tables_t)(handlerton *hton, THD *thd,
                                List<LEX_STRING> *files);
 
/**
  Retrieve cost constants to be used for this storage engine.
 
  A storage engine that wants to provide its own cost constants to
  be used in the optimizer cost model, should implement this function.
  The server will call this function to get a cost constant object
  that will be used for tables stored in this storage engine instead
  of using the default cost constants.
 
  Life cycle for the cost constant object: The storage engine must
  allocate the cost constant object on the heap. After the function
  returns, the server takes over the ownership of this object.
  The server will eventually delete the object by calling delete.
 
  @note In the initial version the storage_category parameter will
  not be used. The only valid value this will have is DEFAULT_STORAGE_CLASS
  (see declaration in opt_costconstants.h).
 
  @param storage_category the storage type that the cost constants will
                          be used for
 
  @return a pointer to the cost constant object, if NULL is returned
          the default cost constants will be used
*/
typedef SE_cost_constants *(*get_cost_constants_t)(uint storage_category);
 
/**
  @param[in,out]  thd          pointer to THD
  @param[in]      new_trx_arg  pointer to replacement transaction
  @param[out]     ptr_trx_arg  double pointer to being replaced transaction
 
  Associated with THD engine's native transaction is replaced
  with @c new_trx_arg. The old value is returned through a buffer if non-null
  pointer is provided with @c ptr_trx_arg.
  The method is adapted by XA start and XA prepare handlers to
  handle XA transaction that is logged as two parts by slave applier.
 
  This interface concerns engines that are aware of XA transaction.
*/
typedef void (*replace_native_transaction_in_thd_t)(THD *thd, void *new_trx_arg,
                                                    void **ptr_trx_arg);
 
/** Mode for initializing the data dictionary. */
enum dict_init_mode_t {
  DICT_INIT_CREATE_FILES,      ///< Create all required SE files
  DICT_INIT_CHECK_FILES,       ///< Verify existence of expected files
  DICT_INIT_UPGRADE_57_FILES,  ///< Used for upgrade from mysql-5.7
  DICT_INIT_IGNORE_FILES       ///< Don't care about files at all
};
 
/**
  Initialize the SE for being used to store the DD tables. Create
  the required files according to the dict_init_mode. Create strings
  representing the required DDSE tables, i.e., tables that the DDSE
  expects to exist in the DD, and add them to the appropriate out
  parameter.
 
  @note There are two variants of this function type, one is to be
  used by the DDSE, and has a different type of output parameters
  because the SQL layer needs more information about the DDSE tables
  in order to support upgrade.
 
  @param dict_init_mode         How to initialize files
  @param version                Target DD version if a new
                                server is being installed.
                                0 if restarting an existing
                                server.
  @param [out] DDSE_tables      List of SQL DDL statements
                                for creating DD tables that
                                are needed by the DDSE.
  @param [out] DDSE_tablespaces List of meta data for predefined
                                tablespaces created by the DDSE.
 
  @retval true                  An error occurred.
  @retval false                 Success - no errors.
 */
 
typedef bool (*dict_init_t)(dict_init_mode_t dict_init_mode, uint version,
                            List<const Plugin_table> *DDSE_tables,
                            List<const Plugin_tablespace> *DDSE_tablespaces);
 
typedef bool (*ddse_dict_init_t)(
    dict_init_mode_t dict_init_mode, uint version,
    List<const dd::Object_table> *DDSE_tables,
    List<const Plugin_tablespace> *DDSE_tablespaces);
 
/**
  Initialize the set of hard coded DD table ids.
*/
typedef void (*dict_register_dd_table_id_t)(dd::Object_id hard_coded_tables);
 
/**
  Invalidate an entry in the local dictionary cache.
 
  Needed during bootstrap to make sure the contents in the DDSE
  dictionary cache is in sync with the global DD.
 
  @param   schema_name    Schema name.
  @param   table_name     Table name.
 */
 
typedef void (*dict_cache_reset_t)(const char *schema_name,
                                   const char *table_name);
 
/**
  Invalidate all table and tablespace entries in the local dictionary cache.
 
  Needed for recovery during server restart.
 */
 
typedef void (*dict_cache_reset_tables_and_tablespaces_t)();
 
/** Mode for data dictionary recovery. */
enum dict_recovery_mode_t {
  DICT_RECOVERY_INITIALIZE_SERVER,       ///< First start of a new server
  DICT_RECOVERY_INITIALIZE_TABLESPACES,  ///< First start, create tablespaces
  DICT_RECOVERY_RESTART_SERVER           ///< Restart of an existing server
};
 
/**
  Do recovery in the DDSE as part of initializing the data dictionary.
  The dict_recovery_mode indicates what kind of recovery should be
  done.
 
  @param dict_recovery_mode   How to do recovery
  @param version              Target DD version if a new
                              server is being installed.
                              Actual DD version if restarting
                              an existing server.
 
  @retval true                An error occurred.
  @retval false               Success - no errors.
 */
 
typedef bool (*dict_recover_t)(dict_recovery_mode_t dict_recovery_mode,
                               uint version);
 
/**
  Get the server version id stored in the header of the
  dictionary tablespace.
 
  @param [out] version  Version number from the DD
                        tablespace header.
 
  @retval Operation outcome, false if no error, otherwise true.
*/
typedef bool (*dict_get_server_version_t)(uint *version);
 
/**
  Store the current server version number into the
  header of the dictionary tablespace.
 
  @retval Operation outcome, false if no error, otherwise true.
*/
typedef bool (*dict_set_server_version_t)();
 
/**
  Notify/get permission from storage engine before acquisition or after
  release of exclusive metadata lock on object represented by key.
 
  @param thd                Thread context.
  @param mdl_key            MDL key identifying object on which exclusive
                            lock is to be acquired/was released.
  @param notification_type  Indicates whether this is pre-acquire or
                            post-release notification.
  @param victimized        'true' if locking failed as we were selected
                            as a victim in order to avoid possible deadlocks.
 
  @note Notification is done only for objects from TABLESPACE, SCHEMA,
        TABLE, FUNCTION, PROCEDURE, TRIGGER and EVENT namespaces.
 
  @note Problems during notification are to be reported as warnings, MDL
        subsystem will report generic error if pre-acquire notification
        fails/SE refuses lock acquisition.
  @note Return value is ignored/error is not reported in case of
        post-release notification.
 
  @note In some cases post-release notification might happen even if
        there were no prior pre-acquire notification. For example,
        when SE was loaded after exclusive lock acquisition, or when
        we need notify SEs which permitted lock acquisition that it
        didn't happen because one of SEs didn't allow it (in such case
        we will do post-release notification for all SEs for simplicity).
 
  @return False - if notification was successful/lock can be acquired,
          True - if it has failed/lock should not be acquired.
*/
typedef bool (*notify_exclusive_mdl_t)(THD *thd, const MDL_key *mdl_key,
                                       ha_notification_type notification_type,
                                       bool *victimized);
 
/**
  Notify/get permission from storage engine before or after execution of
  ALTER TABLE operation on the table identified by the MDL key.
 
  @param thd                Thread context.
  @param mdl_key            MDL key identifying table which is going to be
                            or was ALTERed.
  @param notification_type  Indicates whether this is pre-ALTER TABLE or
                            post-ALTER TABLE notification.
 
  @note This hook is necessary because for ALTER TABLE upgrade to X
        metadata lock happens fairly late during the execution process,
        so it can be expensive to abort ALTER TABLE operation at this
        stage by returning failure from notify_exclusive_mdl() hook.
 
  @note This hook follows the same error reporting convention as
        @see notify_exclusive_mdl().
 
  @note Similarly to notify_exclusive_mdl() in some cases post-ALTER
        notification might happen even if there were no prior pre-ALTER
        notification.
 
  @note Post-ALTER notification can happen before post-release notification
        for exclusive metadata lock acquired by this ALTER TABLE.
 
  @return False - if notification was successful/ALTER TABLE can proceed.
          True - if it has failed/ALTER TABLE should be aborted.
*/
typedef bool (*notify_alter_table_t)(THD *thd, const MDL_key *mdl_key,
                                     ha_notification_type notification_type);
 
/**
  @brief
  Initiate master key rotation
 
  @returns false on success,
           true on failure
*/
typedef bool (*rotate_encryption_master_key_t)(void);
 
/**
  @brief
  Enable or Disable SE write ahead logging.
 
  @param[in] thd    server thread handle
  @param[in] enable enable/disable redo logging
 
  @return true iff failed.
*/
typedef bool (*redo_log_set_state_t)(THD *thd, bool enable);
 
/**
  @brief
  Retrieve ha_statistics from SE.
 
  @param db_name                  Name of schema
  @param table_name               Name of table
  @param se_private_id            SE private id of the table.
  @param ts_se_private_data       Tablespace SE private data.
  @param tbl_se_private_data      Table SE private data.
  @param flags                    Type of statistics to retrieve.
  @param[out] stats               Contains statistics read from SE.
 
  @note Handlers that implement this callback/API should adhere
        to servers expectation that, the implementation would invoke
        my_error() before returning 'true'/failure from this function.
 
  @returns false on success,
           true on failure
*/
typedef bool (*get_table_statistics_t)(
    const char *db_name, const char *table_name, dd::Object_id se_private_id,
    const dd::Properties &ts_se_private_data,
    const dd::Properties &tbl_se_private_data, uint flags,
    ha_statistics *stats);
 
/**
  @brief
  Retrieve index column cardinality from SE.
 
  @param db_name                  Name of schema
  @param table_name               Name of table
  @param index_name               Name of index
  @param index_ordinal_position   Position of index.
  @param column_ordinal_position  Position of column in index.
  @param se_private_id            SE private id of the table.
  @param[out] cardinality         cardinality being returned by SE.
 
  @note Handlers that implement this callback/API should adhere
        to servers expectation that, the implementation would invoke
        my_error() before returning 'true'/failure from this function.
 
  @returns false on success,
           true on failure
*/
typedef bool (*get_index_column_cardinality_t)(
    const char *db_name, const char *table_name, const char *index_name,
    uint index_ordinal_position, uint column_ordinal_position,
    dd::Object_id se_private_id, ulonglong *cardinality);
 
/**
  Retrieve ha_tablespace_statistics from SE.
 
  @param tablespace_name          Tablespace_name
  @param file_name                Tablespace file name.
  @param ts_se_private_data       Tablespace SE private data.
  @param[out] stats               Contains tablespace
                                  statistics read from SE.
 
  @note Handlers that implement this callback/API should adhere
        to servers expectation that, the implementation would invoke
        my_error() before returning 'true'/failure from this function.
 
  @returns false on success, true on failure
*/
typedef bool (*get_tablespace_statistics_t)(
    const char *tablespace_name, const char *file_name,
    const dd::Properties &ts_se_private_data, ha_tablespace_statistics *stats);
 
/* Database physical clone interfaces */
 
/** Get capability flags for clone operation
@param[out]     flags   capability flag */
using Clone_capability_t = void (*)(Ha_clone_flagset &flags);
 
/** Begin copy from source database
@param[in]      hton    handlerton for SE
@param[in]      thd     server thread handle
@param[in,out]  loc     locator
@param[in,out]  loc_len locator length
@param[out]     task_id task identifier
@param[in]      type    clone type
@param[in]      mode    mode for starting clone
@return error code */
using Clone_begin_t = int (*)(handlerton *hton, THD *thd, const uchar *&loc,
                              uint &loc_len, uint &task_id, Ha_clone_type type,
                              Ha_clone_mode mode);
 
/** Copy data from source database in chunks via callback
@param[in]      hton    handlerton for SE
@param[in]      thd     server thread handle
@param[in]      loc     locator
@param[in]      loc_len locator length in bytes
@param[in]      task_id task identifier
@param[in]      cbk     callback interface for sending data
@return error code */
using Clone_copy_t = int (*)(handlerton *hton, THD *thd, const uchar *loc,
                             uint loc_len, uint task_id, Ha_clone_cbk *cbk);
 
/** Acknowledge data transfer to source database
@param[in]      hton    handlerton for SE
@param[in]      thd     server thread handle
@param[in]      loc     locator
@param[in]      loc_len locator length in bytes
@param[in]      task_id task identifier
@param[in]      in_err  inform any error occurred
@param[in]      cbk     callback interface
@return error code */
using Clone_ack_t = int (*)(handlerton *hton, THD *thd, const uchar *loc,
                            uint loc_len, uint task_id, int in_err,
                            Ha_clone_cbk *cbk);
 
/** End copy from source database
@param[in]      hton    handlerton for SE
@param[in]      thd     server thread handle
@param[in]      loc     locator
@param[in]      loc_len locator length in bytes
@param[in]      task_id task identifier
@param[in]      in_err  error code when ending after error
@return error code */
using Clone_end_t = int (*)(handlerton *hton, THD *thd, const uchar *loc,
                            uint loc_len, uint task_id, int in_err);
 
/** Begin apply to destination database
@param[in]      hton            handlerton for SE
@param[in]      thd             server thread handle
@param[in,out]  loc             locator
@param[in,out]  loc_len         locator length
@param[in]      task_id         task identifier
@param[in]      mode            mode for starting clone
@param[in]      data_dir        target data directory
@return error code */
using Clone_apply_begin_t = int (*)(handlerton *hton, THD *thd,
                                    const uchar *&loc, uint &loc_len,
                                    uint &task_id, Ha_clone_mode mode,
                                    const char *data_dir);
 
/** Apply data to destination database in chunks via callback
@param[in]      hton    handlerton for SE
@param[in]      thd     server thread handle
@param[in]      loc     locator
@param[in]      loc_len locator length in bytes
@param[in]      task_id task identifier
@param[in]      in_err  inform any error occurred
@param[in]      cbk     callback interface for receiving data
@return error code */
using Clone_apply_t = int (*)(handlerton *hton, THD *thd, const uchar *loc,
                              uint loc_len, uint task_id, int in_err,
                              Ha_clone_cbk *cbk);
 
/** End apply to destination database
@param[in]      hton    handlerton for SE
@param[in]      thd     server thread handle
@param[in]      loc     locator
@param[in]      loc_len locator length in bytes
@param[in]      task_id task identifier
@param[in]      in_err  error code when ending after error
@return error code */
using Clone_apply_end_t = int (*)(handlerton *hton, THD *thd, const uchar *loc,
                                  uint loc_len, uint task_id, int in_err);
 
struct Clone_interface_t {
  /* Get clone capabilities of an SE */
  Clone_capability_t clone_capability;
 
  /* Interfaces to copy data. */
  Clone_begin_t clone_begin;
  Clone_copy_t clone_copy;
  Clone_ack_t clone_ack;
  Clone_end_t clone_end;
 
  /* Interfaces to apply data. */
  Clone_apply_begin_t clone_apply_begin;
  Clone_apply_t clone_apply;
  Clone_apply_end_t clone_apply_end;
};
 
/**
  Perform post-commit/rollback cleanup after DDL statement (e.g. in
  case of DROP TABLES really remove table files from disk).
 
  @note This hook will be invoked after DDL commit or rollback only
        for storage engines supporting atomic DDL.
 
  @note Problems during execution of this method should be reported to
        error log and as warnings/notes to user. Since this method is
        called after successful commit of the statement we can't fail
        statement with error.
*/
typedef void (*post_ddl_t)(THD *thd);
 
/**
  Perform SE-specific cleanup after recovery of transactions.
 
  @note Particularly SEs supporting atomic DDL can use this call
        to perform post-DDL actions for DDL statements which were
        committed or rolled back during recovery stage.
*/
typedef void (*post_recover_t)(void);
 
/**
  Lock a handlerton (resource) log to collect log information.
*/
 
typedef bool (*lock_hton_log_t)(handlerton *hton);
 
/**
  Unlock a handlerton (resource) log after collecting log information.
*/
 
typedef bool (*unlock_hton_log_t)(handlerton *hton);
 
/**
  Collect a handlerton (resource) log information.
*/
 
typedef bool (*collect_hton_log_info_t)(handlerton *hton, Json_dom *json);
 
/**
  Check SE considers types of child and parent columns in foreign key
  to be compatible.
 
  @param  child_column_type   Child column type description.
  @param  parent_column_type  Parent column type description.
  @param  check_charsets      Indicates whether we need to check
                              that charsets of string columns
                              match. Which is true in most cases.
 
  @returns True if types are compatible, False if not.
*/
 
typedef bool (*check_fk_column_compat_t)(
    const Ha_fk_column_type *child_column_type,
    const Ha_fk_column_type *parent_column_type, bool check_charsets);
 
typedef bool (*is_reserved_db_name_t)(handlerton *hton, const char *name);
 
/**
  Prepare the secondary engine for executing a statement. This function is
  called right after the secondary engine TABLE objects have been opened by
  open_secondary_engine_tables(), before the statement is optimized and
  executed. Secondary engines will typically create a context object in this
  function, which they can use to store state that is needed during the
  optimization and execution phases.
 
  @param thd  thread context
  @param lex  the statement to execute
  @return true on error, false on success
*/
using prepare_secondary_engine_t = bool (*)(THD *thd, LEX *lex);
 
/**
  Optimize a statement for execution on a secondary storage engine. This
  function is called when the optimization of a statement has completed, just
  before the statement is executed. Secondary engines can use this function to
  apply engine-specific optimizations to the execution plan. They can also
  reject executing the query by raising an error, in which case the query will
  be reprepared and executed by the primary storage engine.
 
  @param thd  thread context
  @param lex  the statement being optimized
  @return true on error, false on success
*/
using optimize_secondary_engine_t = bool (*)(THD *thd, LEX *lex);
 
/**
  Compares the cost of two join plans in the secondary storage engine. The cost
  of the current candidate is compared with the cost of the best plan seen so
  far.
 
  @param thd thread context
  @param join the candidate plan to evaluate
  @param optimizer_cost the cost estimate calculated by the optimizer
  @param[out] use_best_so_far true if the optimizer should stop searching for
                      a better plan and use the best plan it has seen so far
  @param[out] cheaper true if the candidate is the best plan seen so far for
                      this JOIN (must be true if it is the first plan seen),
                      false otherwise
  @param[out] secondary_engine_cost the cost estimated by the secondary engine
 
  @return false on success, or true if an error has been raised
*/
using compare_secondary_engine_cost_t = bool (*)(THD *thd, const JOIN &join,
                                                 double optimizer_cost,
                                                 bool *use_best_so_far,
                                                 bool *cheaper,
                                                 double *secondary_engine_cost);
 
/**
  Evaluates the cost of executing the given access path in this secondary
  storage engine, and potentially modifies the cost estimates that are in the
  access path. This function is only called from the hypergraph join optimizer.
 
  The function is called on every access path that the join optimizer might
  compare to an alternative access path. This includes both paths that represent
  complete execution plans and paths that represent partial plans. It is not
  guaranteed to be called on every child path. For example, if GROUP BY is done
  by sorting first and then aggregating the sorted results, the function will
  only be called on the aggregation path, and not on the sort path, because only
  the aggregation path will be compared to other paths.
 
  The secondary engine is allowed to modify the estimates in the access path to
  better match the costs of the access path in the secondary engine. It can
  change any of the following AccessPath members:
 
  - init_once_cost
  - init_cost
  - cost
  - cost_before_filter
  - num_output_rows
  - num_output_rows_before_filter
  - secondary_engine_data
 
  Any other members should be left unchanged. The AccessPath must be in an
  internally consistent state when the function returns, and satisfy invariants
  expected by the hypergraph join optimizer, such as:
 
  - init_cost <= cost_before_filter <= cost
  - num_output_rows <= num_output_rows_before_filter
 
  The secondary engine can also reject an access path altogether, by returning
  true, in which case the join optimizer will not use that path in the final
  plan. Since the secondary engine can reject any partial or complete plan, it
  is possible that the join optimizer does not find any valid plan that is
  accepted. In this case, the join optimizer will raise an error.
 
  If the secondary encounters an error when evaluating the cost of the path, it
  can signal an error by calling my_error() and return true, in which case the
  join optimizer will not suggest any plan for the query.
 
  @param thd The thread context.
  @param hypergraph The hypergraph that represents the search space.
  @param[in,out] access_path The AccessPath to evaluate.
 
  @retval false on success.
  @retval true if the plan is to be rejected, or if an error was raised.
*/
using secondary_engine_modify_access_path_cost_t = bool (*)(
    THD *thd, const JoinHypergraph &hypergraph, AccessPath *access_path);
 
// Capabilities (bit flags) for secondary engines.
using SecondaryEngineFlags = uint64_t;
enum class SecondaryEngineFlag : SecondaryEngineFlags {
  SUPPORTS_HASH_JOIN = 0,
  SUPPORTS_NESTED_LOOP_JOIN = 1,
 
  // If this flag is set, aggregation (GROUP BY and DISTINCT) do not require
  // ordered inputs and create unordered outputs. This is typically the case
  // if they are implemented using hash-based techniques.
  AGGREGATION_IS_UNORDERED = 2
};
 
/// Creates an empty bitmap of access path types. This is the base
/// case for the function template with the same name below.
inline constexpr SecondaryEngineFlags MakeSecondaryEngineFlags() { return 0; }
 
/// Creates a bitmap representing a set of access path types.
template <typename... Args>
constexpr SecondaryEngineFlags MakeSecondaryEngineFlags(
    SecondaryEngineFlag flag1, Args... rest) {
  return (uint64_t{1} << static_cast<int>(flag1)) |
         MakeSecondaryEngineFlags(rest...);
}
 
// FIXME: Temporary workaround to enable storage engine plugins to use the
// before_commit hook. Remove after WL#11320 has been completed.
typedef void (*se_before_commit_t)(void *arg);
 
// FIXME: Temporary workaround to enable storage engine plugins to use the
// after_commit hook. Remove after WL#11320 has been completed.
typedef void (*se_after_commit_t)(void *arg);
 
// FIXME: Temporary workaround to enable storage engine plugins to use the
// before_rollback hook. Remove after WL#11320 has been completed.
typedef void (*se_before_rollback_t)(void *arg);
 
/*
  Page Tracking : interfaces to handlerton functions which starts/stops page
  tracking, and purges/fetches page tracking information.
*/
 
/**
  Start page tracking.
 
  @param[out]    start_id      SE specific sequence number [LSN for InnoDB]
  indicating when the tracking was started
 
  @return Operation status.
    @retval 0 Success
    @retval other ER_* mysql error. Get error details from THD.
*/
using page_track_start_t = int (*)(uint64_t *start_id);
 
/**
  Stop page tracking.
 
  @param[out]    stop_id      SE specific sequence number [LSN for InnoDB]
  indicating when the tracking was stopped
 
  @return Operation status.
    @retval 0 Success
    @retval other ER_* mysql error. Get error details from THD.
*/
using page_track_stop_t = int (*)(uint64_t *stop_id);
 
/**
  Purge page tracking data.
 
  @param[in,out] purge_id     SE specific sequence number [LSN for InnoDB]
  initially indicating till where the data needs to be purged and finally
  updated to until where it was actually purged
 
  @return Operation status.
    @retval 0 Success
    @retval other ER_* mysql error. Get error details from THD.
*/
using page_track_purge_t = int (*)(uint64_t *purge_id);
 
/**
  Fetch tracked pages.
 
  @param[in]     cbk_func     callback function return page IDs
  @param[in]     cbk_ctx      caller's context for callback
  @param[in,out] start_id     SE specific sequence number [LSN for InnoDB] from
  where the pages tracked would be returned.
  @note The range might get expanded and the actual start_id used for the
  querying will be updated.
  @param[in,out] stop_id      SE specific sequence number [LSN for InnoDB]
  until where the pages tracked would be returned.
  @note The range might get expanded and the actual stop_id used for the
  querying will be updated.
  @param[out]    buffer       allocated buffer to copy page IDs
  @param[in]     buffer_len   length of buffer in bytes
 
  @return Operation status.
    @retval 0 Success
    @retval other ER_* mysql error. Get error details from THD.
*/
using page_track_get_page_ids_t = int (*)(Page_Track_Callback cbk_func,
                                          void *cbk_ctx, uint64_t *start_id,
                                          uint64_t *stop_id,
                                          unsigned char *buffer,
                                          size_t buffer_len);
 
/**
  Fetch approximate number of tracked pages in the given range.
 
  @param[in,out] start_id     SE specific sequence number [LSN for InnoDB] from
  where the pages tracked would be returned.
  @note the range might get expanded and the actual start_id used for the
  querying will be updated.
  @param[in,out] stop_id      SE specific sequence number [LSN for InnoDB]
  until where the pages tracked would be returned.
  @note the range might get expanded and the actual stop_id used for the
  querying will be updated.
  @param[out]    num_pages    number of pages tracked
 
  @return Operation status.
    @retval 0 Success
    @retval other ER_* mysql error. Get error details from THD.
*/
using page_track_get_num_page_ids_t = int (*)(uint64_t *start_id,
                                              uint64_t *stop_id,
                                              uint64_t *num_pages);
 
/** Fetch the status of the page tracking system.
@param[out]     status  vector of a pair of (ID, bool) where ID is the
start/stop point and bool is true if the ID is a start point else false */
using page_track_get_status_t =
    void (*)(std::vector<std::pair<uint64_t, bool>> &status);
 
/** Page track interface */
struct Page_track_t {
  page_track_start_t start;
  page_track_stop_t stop;
  page_track_purge_t purge;
  page_track_get_page_ids_t get_page_ids;
  page_track_get_num_page_ids_t get_num_page_ids;
  page_track_get_status_t get_status;
};
 
/**
  handlerton is a singleton structure - one instance per storage engine -
  to provide access to storage engine functionality that works on the
  "global" level (unlike handler class that works on a per-table basis).
 
  usually handlerton instance is defined statically in ha_xxx.cc as
 
  static handlerton { ... } xxx_hton;
 
  savepoint_*, prepare, recover, and *_by_xid pointers can be 0.
*/
struct handlerton {
  /**
    Historical marker for if the engine is available or not.
  */
  SHOW_COMP_OPTION state;
 
  /**
    Historical number used for frm file to determine the correct storage engine.
    This is going away and new engines will just use "name" for this.
  */
  enum legacy_db_type db_type;
  /**
    Each storage engine has it's own memory area (actually a pointer)
    in the thd, for storing per-connection information.
    It is accessed as
 
      thd->ha_data[xxx_hton.slot]
 
     slot number is initialized by MySQL after xxx_init() is called.
   */
  uint slot;
  /**
    To store per-savepoint data storage engine is provided with an area
    of a requested size (0 is ok here).
    savepoint_offset must be initialized statically to the size of
    the needed memory to store per-savepoint information.
    After xxx_init it is changed to be an offset to savepoint storage
    area and need not be used by storage engine.
    see binlog_hton and binlog_savepoint_set/rollback for an example.
   */
  uint savepoint_offset;
 
  /* handlerton methods */
 
  close_connection_t close_connection;
  kill_connection_t kill_connection;
  pre_dd_shutdown_t pre_dd_shutdown;
  savepoint_set_t savepoint_set;
  savepoint_rollback_t savepoint_rollback;
  savepoint_rollback_can_release_mdl_t savepoint_rollback_can_release_mdl;
  savepoint_release_t savepoint_release;
  commit_t commit;
  rollback_t rollback;
  prepare_t prepare;
  recover_t recover;
  commit_by_xid_t commit_by_xid;
  rollback_by_xid_t rollback_by_xid;
  create_t create;
  drop_database_t drop_database;
  panic_t panic;
  start_consistent_snapshot_t start_consistent_snapshot;
  flush_logs_t flush_logs;
  show_status_t show_status;
  partition_flags_t partition_flags;
  is_valid_tablespace_name_t is_valid_tablespace_name;
  get_tablespace_t get_tablespace;
  alter_tablespace_t alter_tablespace;
  get_tablespace_filename_ext_t get_tablespace_filename_ext;
  upgrade_tablespace_t upgrade_tablespace;
  upgrade_space_version_t upgrade_space_version;
  get_tablespace_type_t get_tablespace_type;
  get_tablespace_type_by_name_t get_tablespace_type_by_name;
  upgrade_logs_t upgrade_logs;
  finish_upgrade_t finish_upgrade;
  fill_is_table_t fill_is_table;
  dict_init_t dict_init;
  ddse_dict_init_t ddse_dict_init;
  dict_register_dd_table_id_t dict_register_dd_table_id;
  dict_cache_reset_t dict_cache_reset;
  dict_cache_reset_tables_and_tablespaces_t
      dict_cache_reset_tables_and_tablespaces;
  dict_recover_t dict_recover;
  dict_get_server_version_t dict_get_server_version;
  dict_set_server_version_t dict_set_server_version;
  is_reserved_db_name_t is_reserved_db_name;
 
  /** Global handler flags. */
  uint32 flags{0};
 
  /*
    Those handlerton functions below are properly initialized at handler
    init.
  */
 
  binlog_func_t binlog_func;
  binlog_log_query_t binlog_log_query;
  acl_notify_t acl_notify;
  discover_t discover;
  find_files_t find_files;
  table_exists_in_engine_t table_exists_in_engine;
  is_supported_system_table_t is_supported_system_table;
 
  /*
    APIs for retrieving Serialized Dictionary Information by tablespace id
  */
 
  sdi_create_t sdi_create;
  sdi_drop_t sdi_drop;
  sdi_get_keys_t sdi_get_keys;
  sdi_get_t sdi_get;
  sdi_set_t sdi_set;
  sdi_delete_t sdi_delete;
 
  /**
    Null-ended array of file extentions that exist for the storage engine.
    Used by frm_error() and the default handler::rename_table and delete_table
    methods in handler.cc.
 
    For engines that have two file name extentions (separate meta/index file
    and data file), the order of elements is relevant. First element of engine
    file name extentions array should be meta/index file extention. Second
    element - data file extention. This order is assumed by
    prepare_for_repair() when REPAIR TABLE ... USE_FRM is issued.
 
    For engines that don't have files, file_extensions is NULL.
 
    Currently, the following alternatives are used:
      - file_extensions == NULL;
      - file_extensions[0] != NULL, file_extensions[1] == NULL;
      - file_extensions[0] != NULL, file_extensions[1] != NULL,
        file_extensions[2] == NULL;
  */
  const char **file_extensions;
 
  is_dict_readonly_t is_dict_readonly;
  rm_tmp_tables_t rm_tmp_tables;
  get_cost_constants_t get_cost_constants;
  replace_native_transaction_in_thd_t replace_native_transaction_in_thd;
  notify_exclusive_mdl_t notify_exclusive_mdl;
  notify_alter_table_t notify_alter_table;
  rotate_encryption_master_key_t rotate_encryption_master_key;
  redo_log_set_state_t redo_log_set_state;
 
  get_table_statistics_t get_table_statistics;
  get_index_column_cardinality_t get_index_column_cardinality;
  get_tablespace_statistics_t get_tablespace_statistics;
 
  post_ddl_t post_ddl;
  post_recover_t post_recover;
 
  /** Clone data transfer interfaces */
  Clone_interface_t clone_interface;
 
  /** Flag for Engine License. */
  uint32 license;
  /** Location for engines to keep personal structures. */
  void *data;
 
  /*
    Log_resource functions that must be supported by storage engines
    with relevant log information to be collected.
  */
  lock_hton_log_t lock_hton_log;
  unlock_hton_log_t unlock_hton_log;
  collect_hton_log_info_t collect_hton_log_info;
 
  /** Flags describing details of foreign key support by storage engine. */
  uint32 foreign_keys_flags;
 
  check_fk_column_compat_t check_fk_column_compat;
 
  /**
    Suffix for auto-generated foreign key names for tables using this storage
    engine. If such suffix is specified by SE then its generated foreign key
    names follow (table name)(SE-specific FK name suffix)(FK number) pattern.
    Length of such suffix should not exceed MAX_FK_NAME_SUFFIX_LENGTH bytes.
    If no suffix is specified then FK_NAME_DEFAULT_SUFFIX is used as
    default.
  */
  LEX_CSTRING fk_name_suffix;
 
  /**
    Pointer to a function that prepares a secondary engine for executing a
    statement.
 
    @see prepare_secondary_engine_t for function signature.
  */
  prepare_secondary_engine_t prepare_secondary_engine;
 
  /**
    Pointer to a function that optimizes the current statement for
    execution on the secondary storage engine represented by this
    handlerton.
 
    @see optimize_secondary_engine_t for function signature.
  */
  optimize_secondary_engine_t optimize_secondary_engine;
 
  /**
    Pointer to a function that estimates the cost of executing a join in a
    secondary storage engine.
 
    @see compare_secondary_engine_cost_t for function signature.
  */
  compare_secondary_engine_cost_t compare_secondary_engine_cost;
 
  /// Bitmap which contains the supported join types and other flags
  /// for a secondary storage engine when used with the hypergraph join
  /// optimizer. If it is empty, it means that the secondary engine
  /// does not support the hypergraph join optimizer.
  SecondaryEngineFlags secondary_engine_flags;
 
  /// Pointer to a function that evaluates the cost of executing an access path
  /// in a secondary storage engine.
  ///
  /// @see secondary_engine_modify_access_path_cost_t for function signature.
  secondary_engine_modify_access_path_cost_t
      secondary_engine_modify_access_path_cost;
 
  se_before_commit_t se_before_commit;
  se_after_commit_t se_after_commit;
  se_before_rollback_t se_before_rollback;
 
  /** Page tracking interface */
  Page_track_t page_track;
};
 
/* Possible flags of a handlerton (there can be 32 of them) */
#define HTON_NO_FLAGS 0
#define HTON_CLOSE_CURSORS_AT_COMMIT (1 << 0)
#define HTON_ALTER_NOT_SUPPORTED (1 << 1)  // Engine does not support alter
#define HTON_CAN_RECREATE (1 << 2)         // Delete all is used fro truncate
#define HTON_HIDDEN (1 << 3)               // Engine does not appear in lists
/*
  Bit 4 was occupied by BDB-specific HTON_FLUSH_AFTER_RENAME flag and is no
  longer used.
*/
#define HTON_NOT_USER_SELECTABLE (1 << 5)
#define HTON_TEMPORARY_NOT_SUPPORTED \
  (1 << 6)  // Having temporary tables not supported
#define HTON_SUPPORT_LOG_TABLES (1 << 7)  // Engine supports log tables
#define HTON_NO_PARTITION (1 << 8)        // You can not partition these tables
 
/*
  This flag should be set when deciding that the engine does not allow row based
  binary logging (RBL) optimizations.
 
  Currently, setting this flag, means that table's read/write_set will be left
  untouched when logging changes to tables in this engine. In practice this
  means that the server will not mess around with table->write_set and/or
  table->read_set when using RBL and deciding whether to log full or minimal
  rows.
 
  It's valuable for instance for virtual tables, eg: Performance Schema which
  have no meaning for replication.
*/
#define HTON_NO_BINLOG_ROW_OPT (1 << 9)
 
/**
  Engine supports extended keys. The flag allows to
  use 'extended key' feature if the engine is able to
  do it (has primary key values in the secondary key).
  Note that handler flag HA_PRIMARY_KEY_IN_READ_INDEX is
  actually partial case of HTON_SUPPORTS_EXTENDED_KEYS.
*/
 
#define HTON_SUPPORTS_EXTENDED_KEYS (1 << 10)
 
// Engine support foreign key constraint.
 
#define HTON_SUPPORTS_FOREIGN_KEYS (1 << 11)
 
/**
  Engine supports atomic DDL. That is rollback of transaction for DDL
  statement will also rollback all changes in SE, commit of transaction
  of DDL statement will make it durable.
*/
 
#define HTON_SUPPORTS_ATOMIC_DDL (1 << 12)
 
/* Engine supports packed keys. */
#define HTON_SUPPORTS_PACKED_KEYS (1 << 13)
 
/** Engine is a secondary storage engine. */
#define HTON_IS_SECONDARY_ENGINE (1 << 14)
 
/** Engine supports secondary storage engines. */
#define HTON_SUPPORTS_SECONDARY_ENGINE (1 << 15)
 
/** Engine supports table or tablespace encryption . */
#define HTON_SUPPORTS_TABLE_ENCRYPTION (1 << 16)
 
constexpr const decltype(handlerton::flags) HTON_SUPPORTS_ENGINE_ATTRIBUTE{
    1 << 17};
 
inline bool ddl_is_atomic(const handlerton *hton) {
  return (hton->flags & HTON_SUPPORTS_ATOMIC_DDL) != 0;
}
 
/* Bits for handlerton::foreign_keys_flags bitmap. */
 
/**
  Engine supports both unique and non-unique parent keys for
  foreign keys which contain full foreign key as its prefix.
 
  Storage engines which support foreign keys but do not have
  this flag set are assumed to support only parent keys which
  are primary/unique and contain exactly the same columns as
  the foreign key, possibly, in different order.
*/
 
static const uint32 HTON_FKS_WITH_PREFIX_PARENT_KEYS = (1 << 0);
 
/**
  Storage engine supports hash keys as supporting keys for foreign
  keys. Hash key should contain all foreign key columns and only
  them (altough in any order).
 
  Storage engines which support foreign keys but do not have this
  flag set are assumed to not allow hash keys as supporting keys.
*/
 
static const uint32 HTON_FKS_WITH_SUPPORTING_HASH_KEYS = (1 << 1);
 
/**
  Storage engine supports non-hash keys which have common prefix
  with the foreign key as supporting keys for it. If there are
  several such keys, one which shares biggest prefix with FK is
  chosen.
 
  Storage engines which support foreign keys but do not have this
  flag set are assumed to require that supporting key contains full
  foreign key as its prefix.
*/
 
static const uint32 HTON_FKS_WITH_ANY_PREFIX_SUPPORTING_KEYS = (1 << 2);
 
/**
  Storage engine does not support using the same key for both parent
  and supporting key, but requires the two to be different.
*/
 
static const uint32 HTON_FKS_NEED_DIFFERENT_PARENT_AND_SUPPORTING_KEYS =
    (1 << 3);
 
/**
  Engine takes into account hidden part of key (coming from primary key)
  when determines if it can serve as parent key for a foreign key.
 
  Implies HTON_FKS_WITH_PREFIX_PARENT_KEYS and is related to
  HTON_SUPPORTS_EXTENDED_KEYS.
*/
 
static const uint32 HTON_FKS_WITH_EXTENDED_PARENT_KEYS = (1 << 4);
 
/**
  Maximum possible length of SE-specific suffixes for auto-generated
  foreign key names.
*/
static const size_t MAX_FK_NAME_SUFFIX_LENGTH = 16;
 
/**
  Suffix for auto-generated foreign key names for tables in SE's which
  don't specify own suffix. I.e. for foreign keys on tables in such
  SE's generated names follow (table name)FK_NAME_DEFAULT_SUFFIX(FK number)
  pattern.
*/
static const LEX_CSTRING FK_NAME_DEFAULT_SUFFIX = {STRING_WITH_LEN("_fk_")};
 
enum enum_tx_isolation : int {
  ISO_READ_UNCOMMITTED,
  ISO_READ_COMMITTED,
  ISO_REPEATABLE_READ,
  ISO_SERIALIZABLE
};
 
enum enum_stats_auto_recalc : int {
  HA_STATS_AUTO_RECALC_DEFAULT = 0,
  HA_STATS_AUTO_RECALC_ON,
  HA_STATS_AUTO_RECALC_OFF
};
 
/* struct to hold information about the table that should be created */
struct HA_CREATE_INFO {
  const CHARSET_INFO *table_charset{nullptr};
  const CHARSET_INFO *default_table_charset{nullptr};
  bool schema_read_only{false};
  LEX_STRING connect_string{nullptr, 0};
  const char *password{nullptr};
  const char *tablespace{nullptr};
  LEX_STRING comment{nullptr, 0};
 
  /**
  Algorithm (and possible options) to be used for InnoDB's transparent
  page compression. If this attribute is set then it is hint to the
  storage engine to try and compress the data using the specified algorithm
  where possible. Note: this value is interpreted by the storage engine only.
  and ignored by the Server layer. */
 
  LEX_STRING compress{nullptr, 0};
 
  /**
  This attibute is used for InnoDB's transparent page encryption.
  If this attribute is set then it is hint to the storage engine to encrypt
  the data. Note: this value is interpreted by the storage engine only.
  and ignored by the Server layer. */
 
  LEX_STRING encrypt_type{nullptr, 0};
 
  /**
   * Secondary engine of the table.
   * Is nullptr if no secondary engine defined.
   */
  LEX_CSTRING secondary_engine{nullptr, 0};
 
  const char *data_file_name{nullptr};
  const char *index_file_name{nullptr};
  const char *alias{nullptr};
  ulonglong max_rows{0};
  ulonglong min_rows{0};
  ulonglong auto_increment_value{0};
  ulong table_options{0};
  ulong avg_row_length{0};
  uint64_t used_fields{0};
  // Can only be 1,2,4,8 or 16, but use uint32_t since that how it is
  // represented in InnoDB
  std::uint32_t key_block_size{0};
  uint stats_sample_pages{0}; /* number of pages to sample during
                           stats estimation, if used, otherwise 0. */
  enum_stats_auto_recalc stats_auto_recalc{HA_STATS_AUTO_RECALC_DEFAULT};
  SQL_I_List<TABLE_LIST> merge_list;
  handlerton *db_type{nullptr};
  /**
    Row type of the table definition.
 
    Defaults to ROW_TYPE_DEFAULT for all non-ALTER statements.
    For ALTER TABLE defaults to ROW_TYPE_NOT_USED (means "keep the current").
 
    Can be changed either explicitly by the parser.
    If nothing specified inherits the value of the original table (if present).
  */
  enum row_type row_type = ROW_TYPE_DEFAULT;
  uint null_bits{0}; /* NULL bits at start of record */
  uint options{0};   /* OR of HA_CREATE_ options */
  uint merge_insert_method{0};
  ha_storage_media storage_media{HA_SM_DEFAULT}; /* DEFAULT, DISK or MEMORY */
 
  /*
    A flag to indicate if this table should be marked as a hidden table in
    the data dictionary. One use case is to mark the temporary tables
    created by ALTER to be marked as hidden.
  */
  bool m_hidden{false};
 
  /*
    A flag to indicate if this table should be created but not committed at
    the end of statement.
  */
  bool m_transactional_ddl{false};
 
  LEX_CSTRING engine_attribute = NULL_CSTR;
  LEX_CSTRING secondary_engine_attribute = NULL_CSTR;
 
  ulonglong m_implicit_tablespace_autoextend_size{0};
 
  bool m_implicit_tablespace_autoextend_size_change{true};
 
  /**
    Fill HA_CREATE_INFO to be used by ALTER as well as upgrade code.
    This function separates code from mysql_prepare_alter_table() to be
    used by upgrade code as well to reduce code duplication.
    For ALTER code path, this lets new create options override the old
    ones.
 
    @param[in]  share        TABLE_SHARE object
    @param[in]  used_fields  If a given create option is not flagged, old
                             value be copied from the TABLE_SHARE.
  */
 
  void init_create_options_from_share(const TABLE_SHARE *share,
                                      uint64_t used_fields);
};
 
/**
  Structure describing changes to an index to be caused by ALTER TABLE.
*/
 
struct KEY_PAIR {
  /**
    Pointer to KEY object describing old version of index in
    TABLE::key_info array for TABLE instance representing old
    version of table.
  */
  KEY *old_key;
  /**
    Pointer to KEY object describing new version of index in
    Alter_inplace_info::key_info_buffer array.
  */
  KEY *new_key;
};
 
/**
  In-place alter handler context.
 
  This is a superclass intended to be subclassed by individual handlers
  in order to store handler unique context between in-place alter API calls.
 
  The handler is responsible for creating the object. This can be done
  as early as during check_if_supported_inplace_alter().
 
  The SQL layer is responsible for destroying the object.
 
  @see Alter_inplace_info
*/
 
class inplace_alter_handler_ctx {
 public:
  inplace_alter_handler_ctx() = default;
 
  virtual void set_shared_data(
      const inplace_alter_handler_ctx *ctx MY_ATTRIBUTE((unused))) {}
  virtual ~inplace_alter_handler_ctx() = default;
};
 
/**
  Class describing changes to be done by ALTER TABLE.
  Instance of this class is passed to storage engine in order
  to determine if this ALTER TABLE can be done using in-place
  algorithm. It is also used for executing the ALTER TABLE
  using in-place algorithm.
*/
 
class Alter_inplace_info {
 public:
  /**
     Bits to show in detail what operations the storage engine is
     to execute.
 
     All these operations are supported as in-place operations by the
     SQL layer. This means that operations that by their nature must
     be performed by copying the table to a temporary table, will not
     have their own flags here (e.g. ALTER TABLE FORCE, ALTER TABLE
     ENGINE).
 
     We generally try to specify handler flags only if there are real
     changes. But in cases when it is cumbersome to determine if some
     attribute has really changed we might choose to set flag
     pessimistically, for example, relying on parser output only.
  */
  typedef ulonglong HA_ALTER_FLAGS;
 
  // Add non-unique, non-primary index
  static const HA_ALTER_FLAGS ADD_INDEX = 1ULL << 0;
 
  // Drop non-unique, non-primary index
  static const HA_ALTER_FLAGS DROP_INDEX = 1ULL << 1;
 
  // Add unique, non-primary index
  static const HA_ALTER_FLAGS ADD_UNIQUE_INDEX = 1ULL << 2;
 
  // Drop unique, non-primary index
  static const HA_ALTER_FLAGS DROP_UNIQUE_INDEX = 1ULL << 3;
 
  // Add primary index
  static const HA_ALTER_FLAGS ADD_PK_INDEX = 1ULL << 4;
 
  // Drop primary index
  static const HA_ALTER_FLAGS DROP_PK_INDEX = 1ULL << 5;
 
  // Add column
 
  // Virtual generated column
  static const HA_ALTER_FLAGS ADD_VIRTUAL_COLUMN = 1ULL << 6;
  // Stored base (non-generated) column
  static const HA_ALTER_FLAGS ADD_STORED_BASE_COLUMN = 1ULL << 7;
  // Stored generated column
  static const HA_ALTER_FLAGS ADD_STORED_GENERATED_COLUMN = 1ULL << 8;
  // Add generic column (convience constant).
  static const HA_ALTER_FLAGS ADD_COLUMN =
      ADD_VIRTUAL_COLUMN | ADD_STORED_BASE_COLUMN | ADD_STORED_GENERATED_COLUMN;
 
  // Drop column
  static const HA_ALTER_FLAGS DROP_VIRTUAL_COLUMN = 1ULL << 9;
  static const HA_ALTER_FLAGS DROP_STORED_COLUMN = 1ULL << 10;
  static const HA_ALTER_FLAGS DROP_COLUMN =
      DROP_VIRTUAL_COLUMN | DROP_STORED_COLUMN;
 
  // Rename column
  static const HA_ALTER_FLAGS ALTER_COLUMN_NAME = 1ULL << 11;
 
  // Change column datatype
  static const HA_ALTER_FLAGS ALTER_VIRTUAL_COLUMN_TYPE = 1ULL << 12;
  static const HA_ALTER_FLAGS ALTER_STORED_COLUMN_TYPE = 1ULL << 13;
 
  /**
    Change column datatype in such way that new type has compatible
    packed representation with old type, so it is theoretically
    possible to perform change by only updating data dictionary
    without changing table rows.
  */
  static const HA_ALTER_FLAGS ALTER_COLUMN_EQUAL_PACK_LENGTH = 1ULL << 14;
 
  /// A virtual column has changed its position
  static const HA_ALTER_FLAGS ALTER_VIRTUAL_COLUMN_ORDER = 1ULL << 15;
 
  /// A stored column has changed its position (disregarding virtual columns)
  static const HA_ALTER_FLAGS ALTER_STORED_COLUMN_ORDER = 1ULL << 16;
 
  // Change column from NOT NULL to NULL
  static const HA_ALTER_FLAGS ALTER_COLUMN_NULLABLE = 1ULL << 17;
 
  // Change column from NULL to NOT NULL
  static const HA_ALTER_FLAGS ALTER_COLUMN_NOT_NULLABLE = 1ULL << 18;
 
  // Set or remove default column value
  static const HA_ALTER_FLAGS ALTER_COLUMN_DEFAULT = 1ULL << 19;
 
  // Change column generation expression
  static const HA_ALTER_FLAGS ALTER_VIRTUAL_GCOL_EXPR = 1ULL << 20;
  static const HA_ALTER_FLAGS ALTER_STORED_GCOL_EXPR = 1ULL << 21;
 
  // Add foreign key
  static const HA_ALTER_FLAGS ADD_FOREIGN_KEY = 1ULL << 22;
 
  // Drop foreign key
  static const HA_ALTER_FLAGS DROP_FOREIGN_KEY = 1ULL << 23;
 
  // table_options changed, see HA_CREATE_INFO::used_fields for details.
  static const HA_ALTER_FLAGS CHANGE_CREATE_OPTION = 1ULL << 24;
 
  // Table is renamed
  static const HA_ALTER_FLAGS ALTER_RENAME = 1ULL << 25;
 
  // Change the storage type of column
  static const HA_ALTER_FLAGS ALTER_COLUMN_STORAGE_TYPE = 1ULL << 26;
 
  // Change the column format of column
  static const HA_ALTER_FLAGS ALTER_COLUMN_COLUMN_FORMAT = 1ULL << 27;
 
  // Add partition
  static const HA_ALTER_FLAGS ADD_PARTITION = 1ULL << 28;
 
  // Drop partition
  static const HA_ALTER_FLAGS DROP_PARTITION = 1ULL << 29;
 
  // Changing partition options
  static const HA_ALTER_FLAGS ALTER_PARTITION = 1ULL << 30;
 
  // Coalesce partition
  static const HA_ALTER_FLAGS COALESCE_PARTITION = 1ULL << 31;
 
  // Reorganize partition ... into
  static const HA_ALTER_FLAGS REORGANIZE_PARTITION = 1ULL << 32;
 
  // Reorganize partition
  static const HA_ALTER_FLAGS ALTER_TABLE_REORG = 1ULL << 33;
 
  // Remove partitioning
  static const HA_ALTER_FLAGS ALTER_REMOVE_PARTITIONING = 1ULL << 34;
 
  // Partition operation with ALL keyword
  static const HA_ALTER_FLAGS ALTER_ALL_PARTITION = 1ULL << 35;
 
  /**
    Rename index. Note that we set this flag only if there are no other
    changes to the index being renamed. Also for simplicity we don't
    detect renaming of indexes which is done by dropping index and then
    re-creating index with identical definition under different name.
  */
  static const HA_ALTER_FLAGS RENAME_INDEX = 1ULL << 36;
 
  /**
    Recreate the table for ALTER TABLE FORCE, ALTER TABLE ENGINE
    and OPTIMIZE TABLE operations.
  */
  static const HA_ALTER_FLAGS RECREATE_TABLE = 1ULL << 37;
 
  // Add spatial index
  static const HA_ALTER_FLAGS ADD_SPATIAL_INDEX = 1ULL << 38;
 
  // Alter index comment
  static const HA_ALTER_FLAGS ALTER_INDEX_COMMENT = 1ULL << 39;
 
  // New/changed virtual generated column require validation
  static const HA_ALTER_FLAGS VALIDATE_VIRTUAL_COLUMN = 1ULL << 40;
 
  /**
    Change index option in a way which is likely not to require index
    recreation. For example, change COMMENT or KEY::is_algorithm_explicit
    flag (without change of index algorithm itself).
  */
  static const HA_ALTER_FLAGS CHANGE_INDEX_OPTION = 1LL << 41;
 
  // Rebuild partition
  static const HA_ALTER_FLAGS ALTER_REBUILD_PARTITION = 1ULL << 42;
 
  /**
    Change in index length such that it does not require index rebuild.
    For example, change in index length due to column expansion like
    varchar(X) changed to varchar(X + N).
  */
  static const HA_ALTER_FLAGS ALTER_COLUMN_INDEX_LENGTH = 1ULL << 43;
 
  /**
    Change to one of columns on which virtual generated column depends,
    so its values require re-evaluation.
  */
  static const HA_ALTER_FLAGS VIRTUAL_GCOL_REEVAL = 1ULL << 44;
 
  /**
    Change to one of columns on which stored generated column depends,
    so its values require re-evaluation.
  */
  static const HA_ALTER_FLAGS STORED_GCOL_REEVAL = 1ULL << 45;
 
  // Add check constraint.
  static const HA_ALTER_FLAGS ADD_CHECK_CONSTRAINT = 1ULL << 46;
 
  // Drop check constraint.
  static const HA_ALTER_FLAGS DROP_CHECK_CONSTRAINT = 1ULL << 47;
 
  // Suspend check constraint.
  static const HA_ALTER_FLAGS SUSPEND_CHECK_CONSTRAINT = 1ULL << 48;
 
  // Alter column visibility.
  static const HA_ALTER_FLAGS ALTER_COLUMN_VISIBILITY = 1ULL << 49;
 
  /**
    Create options (like MAX_ROWS) for the new version of table.
 
    @note The referenced instance of HA_CREATE_INFO object was already
          used to create new .FRM file for table being altered. So it
          has been processed by mysql_prepare_create_table() already.
          For example, this means that it has HA_OPTION_PACK_RECORD
          flag in HA_CREATE_INFO::table_options member correctly set.
  */
  HA_CREATE_INFO *create_info;
 
  /**
    Alter options, fields and keys for the new version of table.
 
    @note The referenced instance of Alter_info object was already
          used to create new .FRM file for table being altered. So it
          has been processed by mysql_prepare_create_table() already.
          In particular, this means that in Create_field objects for
          fields which were present in some form in the old version
          of table, Create_field::field member points to corresponding
          Field instance for old version of table.
  */
  Alter_info *alter_info;
 
  /**
    Indicates whether operation should fail if table is non-empty.
    Storage engines should not suggest/allow execution of such operations
    using INSTANT algorithm since check whether table is empty done from
    SQL-layer is not "instant". Also SEs might choose different algorithm for
    ALTER TABLE execution knowing that it will be allowed to proceed only if
    table is empty.
 
    Unlike for Alter_table_ctx::error_if_not_empty, we use bool for this flag
    and not bitmap, since SEs are really interested in the fact that ALTER
    will fail if table is not empty and not in exact reason behind this fact,
    and because we want to avoid extra dependency between Alter_table_ctx and
    Alter_inplace_info.
  */
  bool error_if_not_empty;
 
  /**
    Array of KEYs for new version of table - including KEYs to be added.
 
    @note Currently this array is produced as result of
          mysql_prepare_create_table() call.
          This means that it follows different convention for
          KEY_PART_INFO::fieldnr values than objects in TABLE::key_info
          array.
 
    @todo This is mainly due to the fact that we need to keep compatibility
          with removed handler::add_index() call. We plan to switch to
          TABLE::key_info numbering later.
 
    KEYs are sorted - see sort_keys().
  */
  KEY *key_info_buffer;
 
  /** Size of key_info_buffer array. */
  uint key_count;
 
  /** Size of index_drop_buffer array. */
  uint index_drop_count;
 
  /**
     Array of pointers to KEYs to be dropped belonging to the TABLE instance
     for the old version of the table.
  */
  KEY **index_drop_buffer;
 
  /** Size of index_add_buffer array. */
  uint index_add_count;
 
  /**
     Array of indexes into key_info_buffer for KEYs to be added,
     sorted in increasing order.
  */
  uint *index_add_buffer;
 
  /** Size of index_rename_buffer array. */
  uint index_rename_count;
 
  /** Size of index_rename_buffer array. */
  uint index_altered_visibility_count;
 
  /**
    Array of KEY_PAIR objects describing indexes being renamed.
    For each index renamed it contains object with KEY_PAIR::old_key
    pointing to KEY object belonging to the TABLE instance for old
    version of table representing old version of index and with
    KEY_PAIR::new_key pointing to KEY object for new version of
    index in key_info_buffer member.
  */
  KEY_PAIR *index_rename_buffer;
  KEY_PAIR *index_altered_visibility_buffer;
 
  /** Number of virtual columns to be added. */
  uint virtual_column_add_count;
 
  /** number of virtual columns to be dropped. */
  uint virtual_column_drop_count;
 
  /**
     Context information to allow handlers to keep context between in-place
     alter API calls.
 
     @see inplace_alter_handler_ctx for information about object lifecycle.
  */
  inplace_alter_handler_ctx *handler_ctx;
 
  /**
    If the table uses several handlers, like ha_partition uses one handler
    per partition, this contains a Null terminated array of ctx pointers
    that should all be committed together.
    Or NULL if only handler_ctx should be committed.
    Set to NULL if the low level handler::commit_inplace_alter_table uses it,
    to signal to the main handler that everything was committed as atomically.
 
    @see inplace_alter_handler_ctx for information about object lifecycle.
  */
  inplace_alter_handler_ctx **group_commit_ctx;
 
  /**
     Flags describing in detail which operations the storage engine is to
     execute.
  */
  HA_ALTER_FLAGS handler_flags;
 
  /**
     Partition_info taking into account the partition changes to be performed.
     Contains all partitions which are present in the old version of the table
     with partitions to be dropped or changed marked as such + all partitions
     to be added in the new version of table marked as such.
  */
  partition_info *modified_part_info;
 
  /** true for online operation (LOCK=NONE) */
  bool online;
 
  /**
    Can be set by handler along with handler_ctx. The difference is that
    this flag can be used to store SE-specific in-place ALTER context in cases
    when constructing full-blown inplace_alter_handler_ctx descendant is
    inconvenient.
  */
  uint handler_trivial_ctx;
 
  /**
     Can be set by handler to describe why a given operation cannot be done
     in-place (HA_ALTER_INPLACE_NOT_SUPPORTED) or why it cannot be done
     online (HA_ALTER_INPLACE_NO_LOCK or HA_ALTER_INPLACE_NO_LOCK_AFTER_PREPARE)
     If set, it will be used with ER_ALTER_OPERATION_NOT_SUPPORTED_REASON if
     results from handler::check_if_supported_inplace_alter() doesn't match
     requirements set by user. If not set, the more generic
     ER_ALTER_OPERATION_NOT_SUPPORTED will be used.
 
     Please set to a properly localized string, for example using
     my_get_err_msg(), so that the error message as a whole is localized.
  */
  const char *unsupported_reason;
 
  Alter_inplace_info(HA_CREATE_INFO *create_info_arg,
                     Alter_info *alter_info_arg, bool error_if_not_empty_arg,
                     KEY *key_info_arg, uint key_count_arg,
                     partition_info *modified_part_info_arg)
      : create_info(create_info_arg),
        alter_info(alter_info_arg),
        error_if_not_empty(error_if_not_empty_arg),
        key_info_buffer(key_info_arg),
        key_count(key_count_arg),
        index_drop_count(0),
        index_drop_buffer(nullptr),
        index_add_count(0),
        index_add_buffer(nullptr),
        index_rename_count(0),
        index_altered_visibility_count(0),
        index_rename_buffer(nullptr),
        virtual_column_add_count(0),
        virtual_column_drop_count(0),
        handler_ctx(nullptr),
        group_commit_ctx(nullptr),
        handler_flags(0),
        modified_part_info(modified_part_info_arg),
        online(false),
        handler_trivial_ctx(0),
        unsupported_reason(nullptr) {}
 
  ~Alter_inplace_info() { destroy(handler_ctx); }
 
  /**
    Used after check_if_supported_inplace_alter() to report
    error if the result does not match the LOCK/ALGORITHM
    requirements set by the user.
 
    @param not_supported  Part of statement that was not supported.
    @param try_instead    Suggestion as to what the user should
                          replace not_supported with.
  */
  void report_unsupported_error(const char *not_supported,
                                const char *try_instead);
 
  /** Add old and new version of key to array of indexes to be renamed. */
  void add_renamed_key(KEY *old_key, KEY *new_key) {
    KEY_PAIR *key_pair = index_rename_buffer + index_rename_count++;
    key_pair->old_key = old_key;
    key_pair->new_key = new_key;
    DBUG_PRINT("info",
               ("index renamed: '%s' to '%s'", old_key->name, new_key->name));
  }
 
  void add_altered_index_visibility(KEY *old_key, KEY *new_key) {
    KEY_PAIR *key_pair =
        index_altered_visibility_buffer + index_altered_visibility_count++;
    key_pair->old_key = old_key;
    key_pair->new_key = new_key;
    DBUG_PRINT("info", ("index had visibility altered: %i to %i",
                        old_key->is_visible, new_key->is_visible));
  }
 
  /**
    Add old and new version of modified key to arrays of indexes to
    be dropped and added (correspondingly).
  */
  void add_modified_key(KEY *old_key, KEY *new_key) {
    index_drop_buffer[index_drop_count++] = old_key;
    index_add_buffer[index_add_count++] = (uint)(new_key - key_info_buffer);
    DBUG_PRINT("info", ("index changed: '%s'", old_key->name));
  }
 
  /** Drop key to array of indexes to be dropped. */
  void add_dropped_key(KEY *old_key) {
    index_drop_buffer[index_drop_count++] = old_key;
    DBUG_PRINT("info", ("index dropped: '%s'", old_key->name));
  }
 
  /** Add key to array of indexes to be added. */
  void add_added_key(KEY *new_key) {
    index_add_buffer[index_add_count++] = (uint)(new_key - key_info_buffer);
    DBUG_PRINT("info", ("index added: '%s'", new_key->name));
  }
};
 
struct HA_CHECK_OPT {
  uint flags{0};     /* isam layer flags (e.g. for myisamchk) */
  uint sql_flags{0}; /* sql layer flags - for something myisamchk cannot do */
  KEY_CACHE *key_cache; /* new key cache when changing key cache */
};
 
/*
  This is a buffer area that the handler can use to store rows.
  'end_of_used_area' should be kept updated after calls to
  read-functions so that other parts of the code can use the
  remaining area (until next read calls is issued).
*/
 
struct HANDLER_BUFFER {
  uchar *buffer;           /* Buffer one can start using */
  uchar *buffer_end;       /* End of buffer */
  uchar *end_of_used_area; /* End of area that was used by handler */
};
 
typedef void *range_seq_t;
 
struct RANGE_SEQ_IF {
  /*
    Initialize the traversal of range sequence
 
    SYNOPSIS
      init()
        init_params  The seq_init_param parameter
        n_ranges     The number of ranges obtained
        flags        A combination of HA_MRR_SINGLE_POINT, HA_MRR_FIXED_KEY
 
    RETURN
      An opaque value to be used as RANGE_SEQ_IF::next() parameter
  */
  range_seq_t (*init)(void *init_params, uint n_ranges, uint flags);
 
  /*
    Get the next range in the range sequence
 
    SYNOPSIS
      next()
        seq    The value returned by RANGE_SEQ_IF::init()
        range  OUT Information about the next range
 
    RETURN
      0 - Ok, the range structure filled with info about the next range
      1 - No more ranges
  */
  uint (*next)(range_seq_t seq, KEY_MULTI_RANGE *range);
 
  /*
    Check whether range_info orders to skip the next record
 
    SYNOPSIS
      skip_record()
        seq         The value returned by RANGE_SEQ_IF::init()
        range_info  Information about the next range
                    (Ignored if MRR_NO_ASSOCIATION is set)
        rowid       Rowid of the record to be checked (ignored if set to 0)
 
    RETURN
      1 - Record with this range_info and/or this rowid shall be filtered
          out from the stream of records returned by ha_multi_range_read_next()
      0 - The record shall be left in the stream
  */
  bool (*skip_record)(range_seq_t seq, char *range_info, uchar *rowid);
};
 
/**
  Used to store optimizer cost estimates.
 
  The class consists of PODs only: default operator=, copy constructor
  and destructor are used.
 */
class Cost_estimate {
 private:
  double io_cost;      ///< cost of I/O operations
  double cpu_cost;     ///< cost of CPU operations
  double import_cost;  ///< cost of remote operations
  double mem_cost;     ///< memory used (bytes)
 
 public:
  Cost_estimate() : io_cost(0), cpu_cost(0), import_cost(0), mem_cost(0) {}
 
  /// Returns sum of time-consuming costs, i.e., not counting memory cost
  double total_cost() const { return io_cost + cpu_cost + import_cost; }
  double get_io_cost() const { return io_cost; }
  double get_cpu_cost() const { return cpu_cost; }
  double get_import_cost() const { return import_cost; }
  double get_mem_cost() const { return mem_cost; }
 
  /**
    Whether or not all costs in the object are zero
 
    @return true if all costs are zero, false otherwise
  */
  bool is_zero() const {
    return !(io_cost || cpu_cost || import_cost || mem_cost);
  }
  /**
    Whether or not the total cost is the maximal double
 
    @return true if total cost is the maximal double, false otherwise
  */
  bool is_max_cost() const { return io_cost == DBL_MAX; }
  /// Reset all costs to zero
  void reset() { io_cost = cpu_cost = import_cost = mem_cost = 0; }
  /// Set current cost to the maximal double
  void set_max_cost() {
    reset();
    io_cost = DBL_MAX;
  }
 
  /// Multiply io, cpu and import costs by parameter
  void multiply(double m) {
    assert(!is_max_cost());
 
    io_cost *= m;
    cpu_cost *= m;
    import_cost *= m;
    /* Don't multiply mem_cost */
  }
 
  Cost_estimate &operator+=(const Cost_estimate &other) {
    assert(!is_max_cost() && !other.is_max_cost());
 
    io_cost += other.io_cost;
    cpu_cost += other.cpu_cost;
    import_cost += other.import_cost;
    mem_cost += other.mem_cost;
 
    return *this;
  }
 
  Cost_estimate operator+(const Cost_estimate &other) {
    Cost_estimate result = *this;
    result += other;
 
    return result;
  }
 
  Cost_estimate operator-(const Cost_estimate &other) {
    Cost_estimate result;
 
    assert(!other.is_max_cost());
 
    result.io_cost = io_cost - other.io_cost;
    result.cpu_cost = cpu_cost - other.cpu_cost;
    result.import_cost = import_cost - other.import_cost;
    result.mem_cost = mem_cost - other.mem_cost;
    return result;
  }
 
  bool operator>(const Cost_estimate &other) const {
    return total_cost() > other.total_cost() ? true : false;
  }
 
  bool operator<(const Cost_estimate &other) const {
    return other > *this ? true : false;
  }
 
  /// Add to IO cost
  void add_io(double add_io_cost) {
    assert(!is_max_cost());
    io_cost += add_io_cost;
  }
 
  /// Add to CPU cost
  void add_cpu(double add_cpu_cost) {
    assert(!is_max_cost());
    cpu_cost += add_cpu_cost;
  }
 
  /// Add to import cost
  void add_import(double add_import_cost) {
    assert(!is_max_cost());
    import_cost += add_import_cost;
  }
 
  /// Add to memory cost
  void add_mem(double add_mem_cost) {
    assert(!is_max_cost());
    mem_cost += add_mem_cost;
  }
};
 
void get_sweep_read_cost(TABLE *table, ha_rows nrows, bool interrupted,
                         Cost_estimate *cost);
 
/*
  The below two are not used (and not handled) in this milestone of this WL
  entry because there seems to be no use for them at this stage of
  implementation.
*/
#define HA_MRR_SINGLE_POINT 1
#define HA_MRR_FIXED_KEY 2
 
/*
  Indicates that RANGE_SEQ_IF::next(&range) doesn't need to fill in the
  'range' parameter.
*/
#define HA_MRR_NO_ASSOCIATION 4
 
/*
  The MRR user will provide ranges in key order, and MRR implementation
  must return rows in key order.
  Passing this flag to multi_read_range_init() may cause the
  default MRR handler to be used even if HA_MRR_USE_DEFAULT_IMPL
  was not specified.
  (If the native MRR impl. can not provide SORTED result)
*/
#define HA_MRR_SORTED 8
 
/* MRR implementation doesn't have to retrieve full records */
#define HA_MRR_INDEX_ONLY 16
 
/*
  The passed memory buffer is of maximum possible size, the caller can't
  assume larger buffer.
*/
#define HA_MRR_LIMITS 32
 
/*
  Flag set <=> default MRR implementation is used
  (The choice is made by **_info[_const]() function which may set this
   flag. SQL layer remembers the flag value and then passes it to
   multi_read_range_init().
*/
#define HA_MRR_USE_DEFAULT_IMPL 64
 
/*
  Used only as parameter to multi_range_read_info():
  Flag set <=> the caller guarantees that the bounds of the scanned ranges
  will not have NULL values.
*/
#define HA_MRR_NO_NULL_ENDPOINTS 128
 
/*
  Set by the MRR implementation to signal that it will natively
  produced sorted result if multi_range_read_init() is called with
  the HA_MRR_SORTED flag - Else multi_range_read_init(HA_MRR_SORTED)
  will revert to use the default MRR implementation.
*/
#define HA_MRR_SUPPORT_SORTED 256
 
class ha_statistics {
 public:
  ulonglong data_file_length;     /* Length off data file */
  ulonglong max_data_file_length; /* Length off data file */
  ulonglong index_file_length;
  ulonglong max_index_file_length;
  ulonglong delete_length; /* Free bytes */
  ulonglong auto_increment_value;
  /*
    The number of records in the table.
      0    - means the table has exactly 0 rows
    other  - if (table_flags() & HA_STATS_RECORDS_IS_EXACT)
               the value is the exact number of records in the table
             else
               it is an estimate
  */
  ha_rows records;
  ha_rows deleted;       /* Deleted records */
  ulong mean_rec_length; /* physical reclength */
  /* TODO: create_time should be retrieved from the new DD. Remove this. */
  time_t create_time; /* When table was created */
  ulong check_time;
  ulong update_time;
  uint block_size; /* index block size */
 
  /*
    number of buffer bytes that native mrr implementation needs,
  */
  uint mrr_length_per_rec;
 
  /**
    Estimate for how much of the table that is availabe in a memory
    buffer. Valid range is [0..1]. If it has the special value
    IN_MEMORY_ESTIMATE_UNKNOWN (defined in structs.h), it means that
    the storage engine has not supplied any value for it.
  */
  double table_in_mem_estimate;
 
  ha_statistics()
      : data_file_length(0),
        max_data_file_length(0),
        index_file_length(0),
        delete_length(0),
        auto_increment_value(0),
        records(0),
        deleted(0),
        mean_rec_length(0),
        create_time(0),
        check_time(0),
        update_time(0),
        block_size(0),
        table_in_mem_estimate(IN_MEMORY_ESTIMATE_UNKNOWN) {}
};
 
/**
  Calculates length of key.
 
  Given a key index and a map of key parts return length of buffer used by key
  parts.
 
  @param  table        Table containing the key
  @param  key          Key index
  @param  keypart_map  which key parts that is used
 
  @return Length of used key parts.
*/
uint calculate_key_len(TABLE *table, uint key, key_part_map keypart_map);
/*
  bitmap with first N+1 bits set
  (keypart_map for a key prefix of [0..N] keyparts)
*/
#define make_keypart_map(N) (((key_part_map)2 << (N)) - 1)
/*
  bitmap with first N bits set
  (keypart_map for a key prefix of [0..N-1] keyparts)
*/
#define make_prev_keypart_map(N) (((key_part_map)1 << (N)) - 1)
 
/** Base class to be used by handlers different shares */
class Handler_share {
 public:
  Handler_share() = default;
  virtual ~Handler_share() = default;
};
 
/**
  Wrapper for struct ft_hints.
*/
 
class Ft_hints {
 private:
  struct ft_hints hints;
 
 public:
  Ft_hints(uint ft_flags) {
    hints.flags = ft_flags;
    hints.op_type = FT_OP_UNDEFINED;
    hints.op_value = 0.0;
    hints.limit = HA_POS_ERROR;
  }
 
  /**
    Set comparison operation type and and value for master MATCH function.
 
     @param type   comparison operation type
     @param value  comparison operation value
  */
  void set_hint_op(enum ft_operation type, double value) {
    hints.op_type = type;
    hints.op_value = value;
  }
 
  /**
    Set Ft_hints flag.
 
    @param ft_flag Ft_hints flag
  */
  void set_hint_flag(uint ft_flag) { hints.flags |= ft_flag; }
 
  /**
    Set Ft_hints limit.
 
    @param ft_limit limit
  */
  void set_hint_limit(ha_rows ft_limit) { hints.limit = ft_limit; }
 
  /**
    Get Ft_hints limit.
 
    @return Ft_hints limit
  */
  ha_rows get_limit() { return hints.limit; }
 
  /**
    Get Ft_hints operation value.
 
    @return operation value
  */
  double get_op_value() { return hints.op_value; }
 
  /**
    Get Ft_hints operation type.
 
    @return operation type
  */
  enum ft_operation get_op_type() { return hints.op_type; }
 
  /**
    Get Ft_hints flags.
 
    @return Ft_hints flags
  */
  uint get_flags() { return hints.flags; }
 
  /**
     Get ft_hints struct.
 
     @return pointer to ft_hints struct
   */
  struct ft_hints *get_hints() {
    return &hints;
  }
};
 
/**
  The handler class is the interface for dynamically loadable
  storage engines. Do not add ifdefs and take care when adding or
  changing virtual functions to avoid vtable confusion
 
  Functions in this class accept and return table columns data. Two data
  representation formats are used:
  1. TableRecordFormat - Used to pass [partial] table records to/from
     storage engine
 
  2. KeyTupleFormat - used to pass index search tuples (aka "keys") to
     storage engine. See opt_range.cc for description of this format.
 
  TableRecordFormat
  =================
  [Warning: this description is work in progress and may be incomplete]
  The table record is stored in a fixed-size buffer:
 
    record: null_bytes, column1_data, column2_data, ...
 
  The offsets of the parts of the buffer are also fixed: every column has
  an offset to its column{i}_data, and if it is nullable it also has its own
  bit in null_bytes.
 
  The record buffer only includes data about columns that are marked in the
  relevant column set (table->read_set and/or table->write_set, depending on
  the situation).
  <not-sure>It could be that it is required that null bits of non-present
  columns are set to 1</not-sure>
 
  VARIOUS EXCEPTIONS AND SPECIAL CASES
 
  If the table has no nullable columns, then null_bytes is still
  present, its length is one byte <not-sure> which must be set to 0xFF
  at all times. </not-sure>
 
  If the table has columns of type BIT, then certain bits from those columns
  may be stored in null_bytes as well. Grep around for Field_bit for
  details.
 
  For blob columns (see Field_blob), the record buffer stores length of the
  data, following by memory pointer to the blob data. The pointer is owned
  by the storage engine and is valid until the next operation.
 
  If a blob column has NULL value, then its length and blob data pointer
  must be set to 0.
 
 
  Overview of main modules of the handler API
  ===========================================
  The overview below was copied from the storage/partition/ha_partition.h when
  support for non-native partitioning was removed.
 
  -------------------------------------------------------------------------
  MODULE create/delete handler object
  -------------------------------------------------------------------------
  Object create/delete method. Normally called when a table object
  exists.
 
  -------------------------------------------------------------------------
  MODULE meta data changes
  -------------------------------------------------------------------------
  Meta data routines to CREATE, DROP, RENAME table are often used at
  ALTER TABLE (update_create_info used from ALTER TABLE and SHOW ..).
 
  Methods:
    delete_table()
    rename_table()
    create()
    update_create_info()
 
  -------------------------------------------------------------------------
  MODULE open/close object
  -------------------------------------------------------------------------
  Open and close handler object to ensure all underlying files and
  objects allocated and deallocated for query handling is handled
  properly.
 
  A handler object is opened as part of its initialisation and before
  being used for normal queries (not before meta-data changes always.
  If the object was opened it will also be closed before being deleted.
 
  Methods:
    open()
    close()
 
  -------------------------------------------------------------------------
  MODULE start/end statement
  -------------------------------------------------------------------------
  This module contains methods that are used to understand start/end of
  statements, transaction boundaries, and aid for proper concurrency
  control.
 
  Methods:
    store_lock()
    external_lock()
    start_stmt()
    lock_count()
    unlock_row()
    was_semi_consistent_read()
    try_semi_consistent_read()
 
  -------------------------------------------------------------------------
  MODULE change record
  -------------------------------------------------------------------------
  This part of the handler interface is used to change the records
  after INSERT, DELETE, UPDATE, REPLACE method calls but also other
  special meta-data operations as ALTER TABLE, LOAD DATA, TRUNCATE.
 
  These methods are used for insert (write_row), update (update_row)
  and delete (delete_row). All methods to change data always work on
  one row at a time. update_row and delete_row also contains the old
  row.
  delete_all_rows will delete all rows in the table in one call as a
  special optimization for DELETE from table;
 
  Bulk inserts are supported if all underlying handlers support it.
  start_bulk_insert and end_bulk_insert is called before and after a
  number of calls to write_row.
 
  Methods:
    write_row()
    update_row()
    delete_row()
    delete_all_rows()
    start_bulk_insert()
    end_bulk_insert()
 
  -------------------------------------------------------------------------
  MODULE full table scan
  -------------------------------------------------------------------------
  This module is used for the most basic access method for any table
  handler. This is to fetch all data through a full table scan. No
  indexes are needed to implement this part.
  It contains one method to start the scan (rnd_init) that can also be
  called multiple times (typical in a nested loop join). Then proceeding
  to the next record (rnd_next) and closing the scan (rnd_end).
  To remember a record for later access there is a method (position)
  and there is a method used to retrieve the record based on the stored
  position.
  The position can be a file position, a primary key, a ROWID dependent
  on the handler below.
 
  All functions that retrieve records and are callable through the
  handler interface must indicate whether a record is present after the call
  or not. Record found is indicated by returning 0 and setting table status
  to "has row". Record not found is indicated by returning a non-zero value
  and setting table status to "no row".
  @see TABLE::set_found_row() and TABLE::set_no_row().
  By enforcing these rules in the handler interface, storage handler functions
  need not set any status in struct TABLE. These notes also apply to module
  index scan, documented below.
 
  Methods:
 
    rnd_init()
    rnd_end()
    rnd_next()
    rnd_pos()
    rnd_pos_by_record()
    position()
 
  -------------------------------------------------------------------------
  MODULE index scan
  -------------------------------------------------------------------------
  This part of the handler interface is used to perform access through
  indexes. The interface is defined as a scan interface but the handler
  can also use key lookup if the index is a unique index or a primary
  key index.
  Index scans are mostly useful for SELECT queries but are an important
  part also of UPDATE, DELETE, REPLACE and CREATE TABLE table AS SELECT
  and so forth.
  Naturally an index is needed for an index scan and indexes can either
  be ordered, hash based. Some ordered indexes can return data in order
  but not necessarily all of them.
  There are many flags that define the behavior of indexes in the
  various handlers. These methods are found in the optimizer module.
 
  index_read is called to start a scan of an index. The find_flag defines
  the semantics of the scan. These flags are defined in
  include/my_base.h
  index_read_idx is the same but also initializes index before calling doing
  the same thing as index_read. Thus it is similar to index_init followed
  by index_read. This is also how we implement it.
 
  index_read/index_read_idx does also return the first row. Thus for
  key lookups, the index_read will be the only call to the handler in
  the index scan.
 
  index_init initializes an index before using it and index_end does
  any end processing needed.
 
  Methods:
    index_read_map()
    index_init()
    index_end()
    index_read_idx_map()
    index_next()
    index_prev()
    index_first()
    index_last()
    index_next_same()
    index_read_last_map()
    read_range_first()
    read_range_next()
 
  -------------------------------------------------------------------------
  MODULE information calls
  -------------------------------------------------------------------------
  This calls are used to inform the handler of specifics of the ongoing
  scans and other actions. Most of these are used for optimisation
  purposes.
 
  Methods:
    info()
    get_dynamic_partition_info
    extra()
    extra_opt()
    reset()
 
  -------------------------------------------------------------------------
  MODULE optimizer support
  -------------------------------------------------------------------------
  NOTE:
  One important part of the public handler interface that is not depicted in
  the methods is the attribute records which is defined in the base class.
  This is looked upon directly and is set by calling info(HA_STATUS_INFO) ?
 
  Methods:
    min_rows_for_estimate()
    get_biggest_used_partition()
    scan_time()
    read_time()
    records_in_range()
    estimate_rows_upper_bound()
    records()
 
  -------------------------------------------------------------------------
  MODULE print messages
  -------------------------------------------------------------------------
  This module contains various methods that returns text messages for
  table types, index type and error messages.
 
  Methods:
    table_type()
    get_row_type()
    print_error()
    get_error_message()
 
  -------------------------------------------------------------------------
  MODULE handler characteristics
  -------------------------------------------------------------------------
  This module contains a number of methods defining limitations and
  characteristics of the handler (see also documentation regarding the
  individual flags).
 
  Methods:
    table_flags()
    index_flags()
    min_of_the_max_uint()
    max_supported_record_length()
    max_supported_keys()
    max_supported_key_parts()
    max_supported_key_length()
    max_supported_key_part_length()
    low_byte_first()
    extra_rec_buf_length()
    min_record_length(uint options)
    primary_key_is_clustered()
    ha_key_alg get_default_index_algorithm()
    is_index_algorithm_supported()
 
  -------------------------------------------------------------------------
  MODULE compare records
  -------------------------------------------------------------------------
  cmp_ref checks if two references are the same. For most handlers this is
  a simple memcmp of the reference. However some handlers use primary key
  as reference and this can be the same even if memcmp says they are
  different. This is due to character sets and end spaces and so forth.
 
  Methods:
    cmp_ref()
 
  -------------------------------------------------------------------------
  MODULE auto increment
  -------------------------------------------------------------------------
  This module is used to handle the support of auto increments.
 
  This variable in the handler is used as part of the handler interface
  It is maintained by the parent handler object and should not be
  touched by child handler objects (see handler.cc for its use).
 
  Methods:
    get_auto_increment()
    release_auto_increment()
 
  -------------------------------------------------------------------------
  MODULE initialize handler for HANDLER call
  -------------------------------------------------------------------------
  This method is a special InnoDB method called before a HANDLER query.
 
  Methods:
    init_table_handle_for_HANDLER()
 
  -------------------------------------------------------------------------
  MODULE fulltext index
  -------------------------------------------------------------------------
  Fulltext index support.
 
  Methods:
    ft_init_ext_with_hints()
    ft_init()
    ft_init_ext()
    ft_read()
 
  -------------------------------------------------------------------------
  MODULE in-place ALTER TABLE
  -------------------------------------------------------------------------
  Methods for in-place ALTER TABLE support (implemented by InnoDB and NDB).
 
  Methods:
    check_if_supported_inplace_alter()
    prepare_inplace_alter_table()
    inplace_alter_table()
    commit_inplace_alter_table()
    notify_table_changed()
 
  -------------------------------------------------------------------------
  MODULE tablespace support
  -------------------------------------------------------------------------
  Methods:
    discard_or_import_tablespace()
 
  -------------------------------------------------------------------------
  MODULE administrative DDL
  -------------------------------------------------------------------------
  Methods:
    optimize()
    analyze()
    check()
    repair()
    check_and_repair()
    auto_repair()
    is_crashed()
    check_for_upgrade()
    checksum()
    assign_to_keycache()
 
  -------------------------------------------------------------------------
  MODULE enable/disable indexes
  -------------------------------------------------------------------------
  Enable/Disable Indexes are only supported by HEAP and MyISAM.
 
  Methods:
    disable_indexes()
    enable_indexes()
    indexes_are_disabled()
 
  -------------------------------------------------------------------------
  MODULE append_create_info
  -------------------------------------------------------------------------
  Only used by MyISAM MERGE tables.
 
  Methods:
    append_create_info()
 
  -------------------------------------------------------------------------
  MODULE partitioning specific handler API
  -------------------------------------------------------------------------
  Methods:
    get_partition_handler()
*/
 
class handler {
  friend class Partition_handler;
 
 public:
  typedef ulonglong Table_flags;
 
 protected:
  TABLE_SHARE *table_share;          /* The table definition */
  TABLE *table;                      /* The current open table */
  Table_flags cached_table_flags{0}; /* Set on init() and open() */
 
  ha_rows estimation_rows_to_insert;
 
 public:
  handlerton *ht; /* storage engine of this handler */
  /** Pointer to current row */
  uchar *ref;
  /** Pointer to duplicate row */
  uchar *dup_ref;
 
  ha_statistics stats;
 
  /* MultiRangeRead-related members: */
  range_seq_t mrr_iter;   /* Interator to traverse the range sequence */
  RANGE_SEQ_IF mrr_funcs; /* Range sequence traversal functions */
  HANDLER_BUFFER *multi_range_buffer; /* MRR buffer info */
  uint ranges_in_seq; /* Total number of ranges in the traversed sequence */
  /* true <=> source MRR ranges and the output are ordered */
  bool mrr_is_output_sorted;
 
  /* true <=> we're currently traversing a range in mrr_cur_range. */
  bool mrr_have_range;
  /* Current range (the one we're now returning rows from) */
  KEY_MULTI_RANGE mrr_cur_range;
 
  /*
    The direction of the current range or index scan. This is used by
    the ICP implementation to determine if it has reached the end
    of the current range.
  */
  enum enum_range_scan_direction { RANGE_SCAN_ASC, RANGE_SCAN_DESC };
 
 private:
  Record_buffer *m_record_buffer = nullptr;  ///< Buffer for multi-row reads.
  /*
    Storage space for the end range value. Should only be accessed using
    the end_range pointer. The content is invalid when end_range is NULL.
  */
  key_range save_end_range;
  enum_range_scan_direction range_scan_direction;
  int key_compare_result_on_equal;
 
  /**
    Pointer to the handler of the table in the primary storage engine,
    if this handler represents a table in a secondary storage engine.
  */
  handler *m_primary_handler{nullptr};
 
 protected:
  KEY_PART_INFO *range_key_part;
  bool eq_range;
  /*
    true <=> the engine guarantees that returned records are within the range
    being scanned.
  */
  bool in_range_check_pushed_down;
 
 public:
  /**
    End value for a range scan. If this is NULL the range scan has no
    end value. Should also be NULL when there is no ongoing range scan.
    Used by the read_range() functions and also evaluated by pushed
    index conditions.
  */
  key_range *end_range;
  /**
    Flag which tells if #end_range contains a virtual generated column.
    The content is invalid when #end_range is @c nullptr.
  */
  bool m_virt_gcol_in_end_range = false;
  uint errkey; /* Last dup key */
  uint key_used_on_scan;
  uint active_index;
  /** Length of ref (1-8 or the clustered key length) */
  uint ref_length;
  FT_INFO *ft_handler;
  enum { NONE = 0, INDEX, RND, SAMPLING } inited;
  bool implicit_emptied; /* Can be !=0 only if HEAP */
  const Item *pushed_cond;
 
  Item *pushed_idx_cond;
  uint pushed_idx_cond_keyno; /* The index which the above condition is for */
 
  /**
    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().
  */
  ulonglong next_insert_id;
  /**
    insert id for the current row (*autogenerated*; if not
    autogenerated, it's 0).
    At first successful insertion, this variable is stored into
    THD::first_successful_insert_id_in_cur_stmt.
  */
  ulonglong insert_id_for_cur_row;
  /**
    Interval returned by get_auto_increment() and being consumed by the
    inserter.
  */
  Discrete_interval auto_inc_interval_for_cur_row;
  /**
     Number of reserved auto-increment intervals. Serves as a heuristic
     when we have no estimation of how many records the statement will insert:
     the more intervals we have reserved, the bigger the next one. Reset in
     handler::ha_release_auto_increment().
  */
  uint auto_inc_intervals_count;
 
  /**
    Instrumented table associated with this handler.
  */
  PSI_table *m_psi;
 
  std::mt19937 m_random_number_engine;
  double m_sampling_percentage;
 
 private:
  /** Internal state of the batch instrumentation. */
  enum batch_mode_t {
    /** Batch mode not used. */
    PSI_BATCH_MODE_NONE,
    /** Batch mode used, before first table io. */
    PSI_BATCH_MODE_STARTING,
    /** Batch mode used, after first table io. */
    PSI_BATCH_MODE_STARTED
  };
  /**
    Batch mode state.
    @sa start_psi_batch_mode.
    @sa end_psi_batch_mode.
  */
  batch_mode_t m_psi_batch_mode;
  /**
    The number of rows in the batch.
    @sa start_psi_batch_mode.
    @sa end_psi_batch_mode.
  */
  ulonglong m_psi_numrows;
  /**
    The current event in a batch.
    @sa start_psi_batch_mode.
    @sa end_psi_batch_mode.
  */
  PSI_table_locker *m_psi_locker;
  /**
    Storage for the event in a batch.
    @sa start_psi_batch_mode.
    @sa end_psi_batch_mode.
  */
  PSI_table_locker_state m_psi_locker_state;
 
 public:
  void unbind_psi();
  void rebind_psi();
  /**
    Put the handler in 'batch' mode when collecting
    table io instrumented events.
    When operating in batch mode:
    - a single start event is generated in the performance schema.
    - all table io performed between @c start_psi_batch_mode
      and @c end_psi_batch_mode is not instrumented:
      the number of rows affected is counted instead in @c m_psi_numrows.
    - a single end event is generated in the performance schema
      when the batch mode ends with @c end_psi_batch_mode.
  */
  void start_psi_batch_mode();
  /** End a batch started with @c start_psi_batch_mode. */
  void end_psi_batch_mode();
  /**
     If a PSI batch was started, turn if off.
     @returns true if it was started.
  */
  bool end_psi_batch_mode_if_started() {
    bool rc = m_psi_batch_mode;
    if (rc) end_psi_batch_mode();
    return rc;
  }
 
 private:
  /**
    The lock type set by when calling::ha_external_lock(). This is
    propagated down to the storage engine. The reason for also storing
    it here, is that when doing MRR we need to create/clone a second handler
    object. This cloned handler object needs to know about the lock_type used.
  */
  int m_lock_type;
  /**
    Pointer where to store/retrieve the Handler_share pointer.
    For non partitioned handlers this is &TABLE_SHARE::ha_share.
  */
  Handler_share **ha_share;
 
  /**
    Some non-virtual ha_* functions, responsible for reading rows,
    like ha_rnd_pos(), must ensure that virtual generated columns are
    calculated before they return. For that, they should set this
    member to true at their start, and check it before they return: if
    the member is still true, it means they should calculate; if it's
    false, it means the calculation has been done by some called
    lower-level function and does not need to be re-done (which is why
    we need this status flag: to avoid redundant calculations, for
    performance).
 
    Note that when updating generated fields, the NULL row status in
    the underlying TABLE objects matter, so be sure to reset them if needed!
  */
  bool m_update_generated_read_fields;
 
  /* Filter row ids to weed out duplicates when multi-valued index is used */
  Unique_on_insert *m_unique;
 
 public:
  handler(handlerton *ht_arg, TABLE_SHARE *share_arg)
      : table_share(share_arg),
        table(nullptr),
        estimation_rows_to_insert(0),
        ht(ht_arg),
        ref(nullptr),
        range_scan_direction(RANGE_SCAN_ASC),
        in_range_check_pushed_down(false),
        end_range(nullptr),
        key_used_on_scan(MAX_KEY),
        active_index(MAX_KEY),
        ref_length(sizeof(my_off_t)),
        ft_handler(nullptr),
        inited(NONE),
        implicit_emptied(false),
        pushed_cond(nullptr),
        pushed_idx_cond(nullptr),
        pushed_idx_cond_keyno(MAX_KEY),
        next_insert_id(0),
        insert_id_for_cur_row(0),
        auto_inc_intervals_count(0),
        m_psi(nullptr),
        m_psi_batch_mode(PSI_BATCH_MODE_NONE),
        m_psi_numrows(0),
        m_psi_locker(nullptr),
        m_lock_type(F_UNLCK),
        ha_share(nullptr),
        m_update_generated_read_fields(false),
        m_unique(nullptr) {
    DBUG_PRINT("info", ("handler created F_UNLCK %d F_RDLCK %d F_WRLCK %d",
                        F_UNLCK, F_RDLCK, F_WRLCK));
  }
 
  virtual ~handler(void) {
    assert(m_psi == nullptr);
    assert(m_psi_batch_mode == PSI_BATCH_MODE_NONE);
    assert(m_psi_locker == nullptr);
    assert(m_lock_type == F_UNLCK);
    assert(inited == NONE);
  }
 
  /**
    Return extra handler specific text for EXPLAIN.
  */
  virtual std::string explain_extra() const { return ""; }
 
  /*
    @todo reorganize functions, make proper public/protected/private qualifiers
  */
  virtual handler *clone(const char *name, MEM_ROOT *mem_root);
  /** This is called after create to allow us to set up cached variables */
  void init() { cached_table_flags = table_flags(); }
  /* ha_ methods: public wrappers for private virtual API */
 
  /**
    Set a record buffer that the storage engine can use for multi-row reads.
    The buffer has to be provided prior to the first read from an index or a
    table.
 
    @param buffer the buffer to use for multi-row reads
  */
  void ha_set_record_buffer(Record_buffer *buffer) { m_record_buffer = buffer; }
 
  /**
    Get the record buffer that was set with ha_set_record_buffer().
 
    @return the buffer to use for multi-row reads, or nullptr if there is none
  */
  Record_buffer *ha_get_record_buffer() const { return m_record_buffer; }
 
  /**
    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?
 
    Storage engines that support using a Record_buffer should override
    handler::is_record_buffer_wanted().
 
    @param[out] max_rows  gets set to the maximum number of records to
                          allocate space for in the buffer if the function
                          returns true
 
    @retval true   if the handler would like a Record_buffer
    @retval false  if the handler does not want a Record_buffer
  */
  bool ha_is_record_buffer_wanted(ha_rows *const max_rows) const {
    return is_record_buffer_wanted(max_rows);
  }
 
  int ha_open(TABLE *table, const char *name, int mode, int test_if_locked,
              const dd::Table *table_def);
  int ha_close(void);
  int ha_index_init(uint idx, bool sorted);
  int ha_index_end();
  int ha_rnd_init(bool scan);
  int ha_rnd_end();
  int ha_rnd_next(uchar *buf);
  // See the comment on m_update_generated_read_fields.
  int ha_rnd_pos(uchar *buf, uchar *pos);
  int ha_index_read_map(uchar *buf, const uchar *key, key_part_map keypart_map,
                        enum ha_rkey_function find_flag);
  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);
  int ha_index_next(uchar *buf);
  int ha_index_prev(uchar *buf);
  int ha_index_first(uchar *buf);
  int ha_index_last(uchar *buf);
  int ha_index_next_same(uchar *buf, const uchar *key, uint keylen);
  int ha_reset();
  /* this is necessary in many places, e.g. in HANDLER command */
  int ha_index_or_rnd_end() {
    return inited == INDEX ? ha_index_end() : inited == RND ? ha_rnd_end() : 0;
  }
  /**
    The cached_table_flags is set at ha_open and ha_external_lock
  */
  Table_flags ha_table_flags() const { return cached_table_flags; }
  /**
    These functions represent the public interface to *users* of the
    handler class, hence they are *not* virtual. For the inheritance
    interface, see the (private) functions write_row(), update_row(),
    and delete_row() below.
  */
  int ha_external_lock(THD *thd, int lock_type);
  int ha_write_row(uchar *buf);
  /**
    Update the current row.
 
    @param old_data  the old contents of the row
    @param new_data  the new contents of the row
    @return error status (zero on success, HA_ERR_* error code on error)
  */
  int ha_update_row(const uchar *old_data, uchar *new_data);
  int ha_delete_row(const uchar *buf);
  void ha_release_auto_increment();
 
  int ha_check_for_upgrade(HA_CHECK_OPT *check_opt);
  /** to be actually called to get 'check()' functionality*/
  int ha_check(THD *thd, HA_CHECK_OPT *check_opt);
  int ha_repair(THD *thd, HA_CHECK_OPT *check_opt);
  void ha_start_bulk_insert(ha_rows rows);
  int ha_end_bulk_insert();
  int ha_bulk_update_row(const uchar *old_data, uchar *new_data,
                         uint *dup_key_found);
  int ha_delete_all_rows();
  int ha_truncate(dd::Table *table_def);
  int ha_optimize(THD *thd, HA_CHECK_OPT *check_opt);
  int ha_analyze(THD *thd, HA_CHECK_OPT *check_opt);
  bool ha_check_and_repair(THD *thd);
  int ha_disable_indexes(uint mode);
  int ha_enable_indexes(uint mode);
  int ha_discard_or_import_tablespace(bool discard, dd::Table *table_def);
  int ha_rename_table(const char *from, const char *to,
                      const dd::Table *from_table_def, dd::Table *to_table_def);
  int ha_delete_table(const char *name, const dd::Table *table_def);
  void ha_drop_table(const char *name);
 
  int ha_create(const char *name, TABLE *form, HA_CREATE_INFO *info,
                dd::Table *table_def);
 
  int ha_load_table(const TABLE &table);
 
  int ha_unload_table(const char *db_name, const char *table_name,
                      bool error_if_not_loaded);
 
  /**
    Initializes a parallel scan. It creates a parallel_scan_ctx that has to
    be used across all parallel_scan methods. Also, gets the number of
    threads that would be spawned for parallel scan.
    @param[out] scan_ctx              The parallel scan context.
    @param[out] num_threads           Number of threads used for the scan.
    @param[in]  use_reserved_threads  true if reserved threads are to be used
                                      if we exhaust the max cap of number of
                                      parallel read threads that can be
                                      spawned at a time
    @return error code
    @retval 0 on success
  */
  virtual int parallel_scan_init(void *&scan_ctx MY_ATTRIBUTE((unused)),
                                 size_t *num_threads MY_ATTRIBUTE((unused)),
                                 bool use_reserved_threads
                                     MY_ATTRIBUTE((unused))) {
    return 0;
  }
 
  /**
    This callback is called by each parallel load thread at the beginning of
    the parallel load for the adapter scan.
    @param cookie      The cookie for this thread
    @param ncols       Number of columns in each row
    @param row_len     The size of a row in bytes
    @param col_offsets An array of size ncols, where each element represents
                       the offset of a column in the row data. The memory of
                       this array belongs to the caller and will be free-ed
                       after the pload_end_cbk call.
    @param null_byte_offsets An array of size ncols, where each element
                       represents the offset of a column in the row data. The
                       memory of this array belongs to the caller and will be
                       free-ed after the pload_end_cbk call.
    @param null_bitmasks An array of size ncols, where each element
                       represents the bitmask required to get the null bit. The
                       memory of this array belongs to the caller and will be
                     free-ed after the pload_end_cbk call.
  */
  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 when processing
    of rows is required for the adapter scan.
    @param[in] cookie       The cookie for this thread
    @param[in] nrows        The nrows that are available
    @param[in] rowdata      The mysql-in-memory row data buffer. This is a
    memory buffer for nrows records. The length of each record is fixed and
    communicated via Load_init_cbk
    @param[in] partition_id Partition id if it's a partitioned table, else
    std::numeric_limits<uint64_t>::max()
    @returns true if there is an error, false otherwise.
  */
  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 has ended for the adapter scan.
    @param[in] cookie    The cookie for this thread
  */
  using Load_end_cbk = std::function<void(void *cookie)>;
 
  /**
    Run the parallel read of data.
    @param[in]  scan_ctx Scan context of the parallel read.
    @param[in,out] thread_ctxs Caller thread contexts.
    @param[in]  init_fn  Callback called by each parallel load
                         thread at the beginning of the parallel load.
    @param[in]  load_fn  Callback called by each parallel load
                         thread when processing of rows is required.
    @param[in]  end_fn   Callback called by each parallel load
                         thread when processing of rows has ended.
    @return error code
    @retval 0 on success
  */
  virtual int parallel_scan(void *scan_ctx MY_ATTRIBUTE((unused)),
                            void **thread_ctxs MY_ATTRIBUTE((unused)),
                            Load_init_cbk init_fn MY_ATTRIBUTE((unused)),
                            Load_cbk load_fn MY_ATTRIBUTE((unused)),
                            Load_end_cbk end_fn MY_ATTRIBUTE((unused))) {
    return 0;
  }
 
  /**
    End of the parallel scan.
    @param[in]      scan_ctx      A scan context created by parallel_scan_init.
  */
  virtual void parallel_scan_end(void *scan_ctx MY_ATTRIBUTE((unused))) {
    return;
  }
 
  /**
    Submit a dd::Table object representing a core DD table having
    hardcoded data to be filled in by the DDSE. This function can be
    used for retrieving the hard coded SE private data for the
    mysql.dd_properties table, before creating or opening it, or for
    retrieving the hard coded SE private data for a core table,
    before creating or opening them.
 
    @param dd_table [in,out]    A dd::Table object representing
                                a core DD table.
    @param reset                Reset counters.
 
    @retval true                An error occurred.
    @retval false               Success - no errors.
   */
 
  bool ha_get_se_private_data(dd::Table *dd_table, bool reset);
 
  void adjust_next_insert_id_after_explicit_value(ulonglong nr);
  int update_auto_increment();
  virtual void print_error(int error, myf errflag);
  virtual bool get_error_message(int error, String *buf);
  uint get_dup_key(int error);
  /**
    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.
 
    If any of the table or key name is not available this method will return
    false and will not change any of child_table_name or child_key_name.
 
    @param [out] child_table_name    Table name
    @param [in] child_table_name_len Table name buffer size
    @param [out] child_key_name      Key name
    @param [in] child_key_name_len   Key name buffer size
 
    @retval  true                  table and key names were available
                                   and were written into the corresponding
                                   out parameters.
    @retval  false                 table and key names were not available,
                                   the out parameters were not touched.
  */
  virtual bool get_foreign_dup_key(char *child_table_name,
                                   uint child_table_name_len,
                                   char *child_key_name,
                                   uint child_key_name_len);
  /**
    Change the internal TABLE_SHARE pointer.
 
    @param table_arg    TABLE object
    @param share        New share to use
 
    @note Is used in error handling in ha_delete_table.
  */
 
  virtual void change_table_ptr(TABLE *table_arg, TABLE_SHARE *share) {
    table = table_arg;
    table_share = share;
  }
  const TABLE_SHARE *get_table_share() const { return table_share; }
 
  /* Estimates calculation */
 
  /**
    @deprecated This function is deprecated and will be removed in a future
                version. Use table_scan_cost() instead.
  */
 
  virtual double scan_time() {
    return ulonglong2double(stats.data_file_length) / IO_SIZE + 2;
  }
 
  /**
    The cost of reading a set of ranges from the table using an index
    to access it.
 
    @deprecated This function is deprecated and will be removed in a future
                version. Use read_cost() instead.
 
    @param index  The index number.
    @param ranges The number of ranges to be read.
    @param rows   Total number of rows to be read.
 
    This method can be used to calculate the total cost of scanning a table
    using an index by calling it using read_time(index, 1, table_size).
  */
 
  virtual double read_time(uint index MY_ATTRIBUTE((unused)), uint ranges,
                           ha_rows rows) {
    return rows2double(ranges + rows);
  }
 
  /**
    @deprecated This function is deprecated and will be removed in a future
                version. Use index_scan_cost() instead.
  */
 
  virtual double index_only_read_time(uint keynr, double records);
 
  /**
    Cost estimate for doing a complete table scan.
 
    @note For this version it is recommended that storage engines continue
    to override scan_time() instead of this function.
 
    @returns the estimated cost
  */
 
  virtual Cost_estimate table_scan_cost();
 
  /**
    Cost estimate for reading a number of ranges from an index.
 
    The cost estimate will only include the cost of reading data that
    is contained in the index. If the records need to be read, use
    read_cost() instead.
 
    @note The ranges parameter is currently ignored and is not taken
    into account in the cost estimate.
 
    @note For this version it is recommended that storage engines continue
    to override index_only_read_time() instead of this function.
 
    @param index  the index number
    @param ranges the number of ranges to be read
    @param rows   total number of rows to be read
 
    @returns the estimated cost
  */
 
  virtual Cost_estimate index_scan_cost(uint index, double ranges, double rows);
 
  /**
    Cost estimate for reading a set of ranges from the table using an index
    to access it.
 
    @note For this version it is recommended that storage engines continue
    to override read_time() instead of this function.
 
    @param index  the index number
    @param ranges the number of ranges to be read
    @param rows   total number of rows to be read
 
    @returns the estimated cost
  */
 
  virtual Cost_estimate read_cost(uint index, double ranges, double rows);
 
  /**
    Return an estimate on the amount of memory the storage engine will
    use for caching data in memory. If this is unknown or the storage
    engine does not cache data in memory -1 is returned.
  */
  virtual longlong get_memory_buffer_size() const { return -1; }
 
  /**
    Return an estimate of how much of the table that is currently stored
    in main memory.
 
    This estimate should be the fraction of the table that currently
    is available in a main memory buffer. The estimate should be in the
    range from 0.0 (nothing in memory) to 1.0 (entire table in memory).
 
    @return The fraction of the table in main memory buffer
  */
 
  double table_in_memory_estimate() const;
 
  /**
    Return an estimate of how much of the index that is currently stored
    in main memory.
 
    This estimate should be the fraction of the index that currently
    is available in a main memory buffer. The estimate should be in the
    range from 0.0 (nothing in memory) to 1.0 (entire index in memory).
 
    @param keyno the index to get an estimate for
 
    @return The fraction of the index in main memory buffer
  */
 
  double index_in_memory_estimate(uint keyno) const;
 
  /**
    Initialize sampling.
 
    @param[out] scan_ctx  A scan context created by this method that has to be
    used in sample_next
    @param[in]  sampling_percentage percentage of records that need to be
    sampled
    @param[in]  sampling_seed       random seed that the random generator will
    use
    @param[in]  sampling_method     sampling method to be used; currently only
    SYSTEM sampling is supported
    @param[in]  tablesample         true if the sampling is for tablesample
 
    @return 0 for success, else one of the HA_xxx values in case of error.
  */
  int ha_sample_init(void *&scan_ctx, double sampling_percentage,
                     int sampling_seed, enum_sampling_method sampling_method,
                     const bool tablesample);
 
  /**
    Get the next record for sampling.
 
    @param[in]  scan_ctx  Scan context of the sampling
    @param[in]  buf       buffer to place the read record
 
    @return 0 for success, else one of the HA_xxx values in case of error.
  */
  int ha_sample_next(void *scan_ctx, uchar *buf);
 
  /**
    End sampling.
 
    @param[in] scan_ctx  Scan context of the sampling
 
    @return 0 for success, else one of the HA_xxx values in case of error.
  */
  int ha_sample_end(void *scan_ctx);
 
 private:
  int check_collation_compatibility();
 
  /**
    Make a guestimate for how much of a table or index is in a memory
    buffer in the case where the storage engine has not provided any
    estimate for this.
 
    @param table_index_size size of the table or index
 
    @return The fraction of the table or index in main memory buffer
  */
 
  double estimate_in_memory_buffer(ulonglong table_index_size) const;
 
 public:
  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);
  virtual ha_rows multi_range_read_info(uint keyno, uint n_ranges, uint keys,
                                        uint *bufsz, uint *flags,
                                        Cost_estimate *cost);
  virtual int multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param,
                                    uint n_ranges, uint mode,
                                    HANDLER_BUFFER *buf);
 
  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() {
    return (ha_table_flags() & HA_NO_TRANSACTIONS) == 0;
  }
  virtual uint extra_rec_buf_length() const { return 0; }
 
  /**
    @brief Determine whether an error can be ignored or not.
 
    @details This method is used to analyze the error to see whether the
    error is ignorable or not. Such errors will be reported as warnings
    instead of errors for IGNORE statements. This means that the statement
    will not abort, but instead continue to the next row.
 
    HA_ERR_FOUND_DUP_UNIQUE is a special case in MyISAM that means the
    same thing as HA_ERR_FOUND_DUP_KEY, but can in some cases lead to
    a slightly different error message.
 
    @param error  error code received from the handler interface (HA_ERR_...)
 
    @return   whether the error is ignorablel or not
      @retval true  the error is ignorable
      @retval false the error is not ignorable
  */
 
  virtual bool is_ignorable_error(int error);
 
  /**
    @brief Determine whether an error is fatal or not.
 
    @details This method is used to analyze the error to see whether the
    error is fatal or not. A fatal error is an error that will not be
    possible to handle with SP handlers and will not be subject to
    retry attempts on the slave.
 
    @param error  error code received from the handler interface (HA_ERR_...)
 
    @return   whether the error is fatal or not
      @retval true  the error is fatal
      @retval false the error is not fatal
  */
 
  virtual bool is_fatal_error(int error);
 
 protected:
  virtual int multi_range_read_next(char **range_info);
 
  /**
    Number of rows in table. If HA_COUNT_ROWS_INSTANT is set, count is
    available instantly. Else do a table scan.
 
    @param num_rows [out]  num_rows number of rows in table.
 
    @retval 0 for OK, one of the HA_xxx values in case of error.
  */
  virtual int records(ha_rows *num_rows);
 
  /**
    Number of rows in table counted using the secondary index chosen by
    optimizer. See comments in optimize_aggregated_query() .
 
      @param num_rows [out]  Number of rows in table.
      @param index           Index chosen by optimizer for counting.
 
      @retval 0 for OK, one of the HA_xxx values in case of error.
  */
  virtual int records_from_index(ha_rows *num_rows, uint index);
 
 private:
  /**
    Function will handle the error code from call to records() and
    records_from_index().
 
      @param error     return code from records() and records_from_index().
      @param num_rows  Check if it contains HA_POS_ERROR in case error < 0.
 
      @retval 0 for OK, one of the HA_xxx values in case of error.
  */
  int handle_records_error(int error, ha_rows *num_rows);
 
 public:
  /**
    Wrapper function to call records() in storage engine.
 
      @param num_rows [out]  Number of rows in table.
 
      @retval 0 for OK, one of the HA_xxx values in case of error.
  */
  int ha_records(ha_rows *num_rows) {
    return handle_records_error(records(num_rows), num_rows);
  }
 
  /**
    Wrapper function to call records_from_index() in storage engine.
 
      @param num_rows [out]  Number of rows in table.
      @param index           Index chosen by optimizer for counting.
 
      @retval 0 for OK, one of the HA_xxx values in case of error.
  */
  int ha_records(ha_rows *num_rows, uint index) {
    return handle_records_error(records_from_index(num_rows, index), num_rows);
  }
 
  /**
    Return upper bound of current number of records in the table
    (max. of how many records one will retrieve when doing a full table scan)
    If upper bound is not known, HA_POS_ERROR should be returned as a max
    possible upper bound.
  */
  virtual ha_rows estimate_rows_upper_bound() {
    return stats.records + EXTRA_RECORDS;
  }
 
  /**
    Get real row type for the table created based on one specified by user,
    CREATE TABLE options and SE capabilities.
  */
  virtual enum row_type get_real_row_type(
      const HA_CREATE_INFO *create_info) const {
    return (create_info->table_options & HA_OPTION_COMPRESS_RECORD)
               ? ROW_TYPE_COMPRESSED
               : ((create_info->table_options & HA_OPTION_PACK_RECORD)
                      ? ROW_TYPE_DYNAMIC
                      : ROW_TYPE_FIXED);
  }
 
  /**
    Get default key algorithm for SE. It is used when user has not provided
    algorithm explicitly or when algorithm specified is not supported by SE.
  */
  virtual enum ha_key_alg get_default_index_algorithm() const {
    return HA_KEY_ALG_SE_SPECIFIC;
  }
 
  /**
    Check if SE supports specific key algorithm.
 
    @note This method is never used for FULLTEXT or SPATIAL keys.
          We rely on handler::ha_table_flags() to check if such keys
          are supported.
  */
  virtual bool is_index_algorithm_supported(enum ha_key_alg key_alg) const {
    return key_alg == HA_KEY_ALG_SE_SPECIFIC;
  }
 
  /**
    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. Normally the handler should ignore all calls until we have done
    a ha_rnd_init() or ha_index_init(), write_row(), update_row or delete_row()
    as there may be several calls to this routine.
  */
  virtual void column_bitmaps_signal();
  uint get_index(void) const { return active_index; }
 
  /**
    @retval  false   Bulk update used by handler
    @retval  true    Bulk update not used, normal operation used
  */
  virtual bool start_bulk_update() { return true; }
  /**
    @retval  false   Bulk delete used by handler
    @retval  true    Bulk delete not used, normal operation used
  */
  virtual bool start_bulk_delete() { return true; }
  /**
    After this call all outstanding updates must be performed. The number
    of duplicate key errors are reported in the duplicate key parameter.
    It is allowed to continue to the batched update after this call, the
    handler has to wait until end_bulk_update with changing state.
 
    @param    dup_key_found       Number of duplicate keys found
 
    @retval  0           Success
    @retval  >0          Error code
  */
  virtual int exec_bulk_update(uint *dup_key_found MY_ATTRIBUTE((unused))) {
    assert(false);
    return HA_ERR_WRONG_COMMAND;
  }
  /**
    Perform any needed clean-up, no outstanding updates are there at the
    moment.
  */
  virtual void end_bulk_update() { return; }
  /**
    Execute all outstanding deletes and close down the bulk delete.
 
    @retval 0             Success
    @retval >0            Error code
  */
  virtual int end_bulk_delete() {
    assert(false);
    return HA_ERR_WRONG_COMMAND;
  }
 
 protected:
  /**
     @brief
     Positions an index cursor to the index specified in the handle
     ('active_index'). Fetches the row if available. If the key value is null,
     begin at the first key of the index.
     @returns 0 if success (found a record); non-zero if no record.
  */
  virtual int index_read_map(uchar *buf, const uchar *key,
                             key_part_map keypart_map,
                             enum ha_rkey_function find_flag) {
    uint key_len = calculate_key_len(table, active_index, keypart_map);
    return index_read(buf, key, key_len, find_flag);
  }
  /**
    Positions an index cursor to the index specified in argument. Fetches
    the row if available. If the key value is null, begin at the first key of
    the index.
    @sa index_read_map()
  */
  virtual int index_read_idx_map(uchar *buf, uint index, const uchar *key,
                                 key_part_map keypart_map,
                                 enum ha_rkey_function find_flag);
 
  /*
    These methods are used to jump to next or previous entry in the index
    scan. There are also methods to jump to first and last entry.
  */
  /// @see index_read_map().
  virtual int index_next(uchar *) { return HA_ERR_WRONG_COMMAND; }
 
  /// @see index_read_map().
  virtual int index_prev(uchar *) { return HA_ERR_WRONG_COMMAND; }
 
  /// @see index_read_map().
  virtual int index_first(uchar *) { return HA_ERR_WRONG_COMMAND; }
 
  /// @see index_read_map().
  virtual int index_last(uchar *) { return HA_ERR_WRONG_COMMAND; }
 
  /// @see index_read_map().
  virtual int index_next_same(uchar *buf, const uchar *key, uint keylen);
  /**
    The following functions works like index_read, but it find the last
    row with the current key value or prefix.
    @see index_read_map().
  */
  virtual int index_read_last_map(uchar *buf, const uchar *key,
                                  key_part_map keypart_map) {
    uint key_len = calculate_key_len(table, active_index, keypart_map);
    return index_read_last(buf, key, key_len);
  }
 
  virtual int read_range_first(const key_range *start_key,
                               const key_range *end_key, bool eq_range,
                               bool sorted);
  virtual int read_range_next();
 
 public:
  /**
    Set the end position for a range scan. This is used for checking
    for when to end the range scan and by the ICP code to determine
    that the next record is within the current range.
 
    @param range     The end value for the range scan
    @param direction Direction of the range scan
  */
  void set_end_range(const key_range *range,
                     enum_range_scan_direction direction);
  int compare_key(key_range *range);
  int compare_key_icp(const key_range *range) const;
  int compare_key_in_buffer(const uchar *buf) const;
  virtual int ft_init() { return HA_ERR_WRONG_COMMAND; }
  virtual FT_INFO *ft_init_ext(uint flags MY_ATTRIBUTE((unused)),
                               uint inx MY_ATTRIBUTE((unused)),
                               String *key MY_ATTRIBUTE((unused))) {
    return nullptr;
  }
  virtual FT_INFO *ft_init_ext_with_hints(uint inx, String *key,
                                          Ft_hints *hints) {
    return ft_init_ext(hints->get_flags(), inx, key);
  }
  int ha_ft_read(uchar *buf);
  int ha_read_first_row(uchar *buf, uint primary_key);
 
 protected:
  /// @see index_read_map().
  virtual int rnd_next(uchar *buf) = 0;
  /// @see index_read_map().
  virtual int rnd_pos(uchar *buf, uchar *pos) = 0;
 
  virtual int ft_read(uchar *) { return HA_ERR_WRONG_COMMAND; }
 
 public:
  /**
    This function only works for handlers having
    HA_PRIMARY_KEY_REQUIRED_FOR_POSITION set.
    It will return the row with the PK given in the record argument.
  */
  virtual int rnd_pos_by_record(uchar *record) {
    int error;
    assert(table_flags() & HA_PRIMARY_KEY_REQUIRED_FOR_POSITION);
 
    error = ha_rnd_init(false);
    if (error != 0) return error;
 
    position(record);
    error = ha_rnd_pos(record, ref);
 
    ha_rnd_end();
    return error;
  }
 
  /**
    Find number of records in a range.
 
    Given a starting key, and an ending key estimate the number of rows that
    will exist between the two. max_key may be empty which in case determine
    if start_key matches any rows. Used by optimizer to calculate cost of
    using a particular index.
 
    @param inx      Index number
    @param min_key  Start of range
    @param max_key  End of range
 
    @return Number of rows in range.
  */
 
  virtual ha_rows records_in_range(uint inx MY_ATTRIBUTE((unused)),
                                   key_range *min_key MY_ATTRIBUTE((unused)),
                                   key_range *max_key MY_ATTRIBUTE((unused))) {
    return (ha_rows)10;
  }
  /*
    If HA_PRIMARY_KEY_REQUIRED_FOR_POSITION is set, then it sets ref
    (reference to the row, aka position, with the primary key given in
    the record).
    Otherwise it set ref to the current row.
  */
  virtual void position(const uchar *record) = 0;
 
  /**
    General method to gather info from handler
 
    ::info() is used to return information to the optimizer.
    SHOW also makes use of this data Another note, if your handler
    doesn't proved exact record count, you will probably want to
    have the following in your code:
    if (records < 2)
      records = 2;
    The reason is that the server will optimize for cases of only a single
    record. If in a table scan you don't know the number of records
    it will probably be better to set records to two so you can return
    as many records as you need.
 
    Along with records a few more variables you may wish to set are:
      records
      deleted
      data_file_length
      index_file_length
      delete_length
      check_time
    Take a look at the public variables in handler.h for more information.
    See also my_base.h for a full description.
 
    @param   flag          Specifies what info is requested
  */
 
  virtual int info(uint flag) = 0;
  virtual uint32 calculate_key_hash_value(
      Field **field_array MY_ATTRIBUTE((unused))) {
    assert(0);
    return 0;
  }
  /**
    Request storage engine to do an extra operation: enable,disable or run some
    functionality.
 
    @param  operation  the operation to perform
 
    @returns
      0     on success
      error otherwise
  */
  int ha_extra(enum ha_extra_function operation);
 
 private:
  /**
    Storage engine specific implementation of ha_extra()
 
    @param  operation  the operation to perform
 
    @returns
      0     on success
      error otherwise
  */
  virtual int extra(enum ha_extra_function operation MY_ATTRIBUTE((unused))) {
    return 0;
  }
 
 public:
  virtual int extra_opt(enum ha_extra_function operation,
                        ulong cache_size MY_ATTRIBUTE((unused))) {
    return extra(operation);
  }
 
  /**
    Let storage engine inspect the optimized 'plan' and pick whatever
    it like for being pushed down to the engine. (Join, conditions, ..)
 
    The handler implementation should keep track of what it 'pushed',
    such that later calls to the handlers access methods should
    activate the pushed (part of) the execution plan on the storage
    engines.
 
    @param  table
            Abstract Query Plan 'table' object for the table
            being pushed to
 
    @returns
      0     on success
      error otherwise
  */
  virtual int engine_push(AQP::Table_access *table MY_ATTRIBUTE((unused))) {
    return 0;
  }
 
  /**
    Start read (before write) removal on the current table.
    @see HA_READ_BEFORE_WRITE_REMOVAL
  */
  virtual bool start_read_removal(void) {
    assert(0);
    return false;
  }
 
  /**
    End read (before write) removal and return the number of rows
    really written
    @see HA_READ_BEFORE_WRITE_REMOVAL
  */
  virtual ha_rows end_read_removal(void) {
    assert(0);
    return (ha_rows)0;
  }
 
  /**
    Normally, when running UPDATE or DELETE queries, we need to wait for other
    transactions to release their locks on a given row before we can read it and
    potentially update it. However, in READ UNCOMMITTED and READ COMMITTED, we
    can ignore these locks if we don't intend to modify the row (e.g., because
    it failed a WHERE). This is signaled through enabling “semi-consistent
    read”, by calling try_semi_consistent_read(true) (and then setting it back
    to false after finishing the query).
 
    If semi-consistent read is enabled, and we are in READ UNCOMMITTED or READ
    COMMITTED, the storage engine is permitted to return rows that are locked
    and thus un-updatable. If the optimizer doesn't want the row, e.g., because
    it got filtered out, it can call unlock_row() as usual. However, if it
    intends to update the row, it needs to call was_semi_consistent_read()
    before doing so. If was_semi_consistent_read() returns false, the row was
    never locked to begin with and can be updated as usual. However, if it
    returns 1, it was read optimistically, must be discarded (ie., do not try to
    update the row) and must be re-read with locking enabled. The next read call
    after was_semi_consistent_read() will automatically re-read the same row,
    this time with locking enabled.
 
    Thus, typical use in an UPDATE scenario would look like this:
 
        file->try_semi_consistent_read(true);
        file->ha_rnd_init(true);
        while (file->ha_rnd_next(table->record[0]) == 0) {
          if (row is filtered...) {
            file->unlock_row();
            continue;
          }
          if (file->was_semi_consistent_read()) {
            // Discard the row; next ha_rnd_next() will read it again with
            // locking.