~drizzle-trunk/drizzle/development

/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-

 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:

 *

 *  Copyright (C) 2008 Sun Microsystems

 *

 *  This program is free software; you can redistribute it and/or modify

 *  it under the terms of the GNU General Public License as published by

 *  the Free Software Foundation; version 2 of the License.

 *

 *  This program is distributed in the hope that it will be useful,

 *  but WITHOUT ANY WARRANTY; without even the implied warranty of

 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

 *  GNU General Public License for more details.

 *

 *  You should have received a copy of the GNU General Public License

 *  along with this program; if not, write to the Free Software

 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 */

#ifndef DRIZZLED_HANDLER_H

#define DRIZZLED_HANDLER_H

#include <drizzled/xid.h>

/* Definitions for parameters to do with handler-routines */

#include <storage/myisam/keycache.h>

#include <mysys/thr_lock.h>

#include <mysys/hash.h>

#include <drizzled/sql_string.h>

#include <drizzled/sql_list.h>

#include <drizzled/handlerton.h>

#include <drizzled/handler_structs.h>

#include <drizzled/ha_statistics.h>

/* Bits to show what an alter table will do */

#include <drizzled/sql_bitmap.h>

#define HA_MAX_ALTER_FLAGS 40

typedef Bitmap<HA_MAX_ALTER_FLAGS> HA_ALTER_FLAGS;

typedef bool (*qc_engine_callback)(Session *session, char *table_key,

                                      uint32_t key_length,

                                      uint64_t *engine_data);

/* The handler for a table type.  Will be included in the Table structure */

class Table;

class TableList;

typedef struct st_table_share TABLE_SHARE;

struct st_foreign_key_info;

typedef struct st_foreign_key_info FOREIGN_KEY_INFO;

struct order_st;

class Item;

struct st_table_log_memory_entry;

class LEX;

typedef class st_select_lex SELECT_LEX;

typedef class st_select_lex_unit SELECT_LEX_UNIT;

class Alter_info;

class select_result;

class Create_field;

class sys_var_str;

class Item_ident;

typedef struct st_sort_field SORT_FIELD;

typedef List<Item> List_item;

typedef struct st_savepoint SAVEPOINT;

extern uint32_t savepoint_alloc_size;

extern KEY_CREATE_INFO default_key_create_info;

/* Forward declaration for condition pushdown to storage engine */

typedef class Item COND;

typedef struct system_status_var SSV;

class COST_VECT;

uint16_t &mrr_persistent_flag_storage(range_seq_t seq, uint32_t idx);

char* &mrr_get_ptr_by_idx(range_seq_t seq, uint32_t idx);

uint32_t calculate_key_len(Table *, uint, const unsigned char *, key_part_map);

/*

  bitmap with first N+1 bits set

  (keypart_map for a key prefix of [0..N] keyparts)

*/

template<class T>

inline key_part_map make_keypart_map(T a)

{

  return (((key_part_map)2 << a) - 1);

}

/*

  bitmap with first N bits set

  (keypart_map for a key prefix of [0..N-1] keyparts)

*/

template<class T>

inline key_part_map make_prev_keypart_map(T a)

{

  return (((key_part_map)1 << a) - 1);

}

/**

  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

  f 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.

*/

class handler :public Sql_alloc

{

public:

  typedef uint64_t Table_flags;

protected:

  struct st_table_share *table_share;   /* The table definition */

  Table *table;               /* The current open table */

  Table_flags cached_table_flags;       /* Set on init() and open() */

  ha_rows estimation_rows_to_insert;

public:

  handlerton *ht;                 /* storage engine of this handler */

  unsigned char *ref;				/* Pointer to current row */

  unsigned char *dup_ref;			/* Pointer to duplicate row */

  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 */

  uint32_t 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 following are for read_range() */

  key_range save_end_range, *end_range;

  KEY_PART_INFO *range_key_part;

  int key_compare_result_on_equal;

  bool eq_range;

  /* 

    true <=> the engine guarantees that returned records are within the range

    being scanned.

  */

  bool in_range_check_pushed_down;

  uint32_t errkey;				/* Last dup key */

  uint32_t key_used_on_scan;

  uint32_t active_index;

  /** Length of ref (1-8 or the clustered key length) */

  uint32_t ref_length;

  enum {NONE=0, INDEX, RND} inited;

  bool locked;

  bool implicit_emptied;                /* Can be !=0 only if HEAP */

  const Item *pushed_cond;

  Item *pushed_idx_cond;

  uint32_t 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().

  */

  uint64_t 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

    Session::first_successful_insert_id_in_cur_stmt.

  */

  uint64_t 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;

  handler(handlerton *ht_arg, TABLE_SHARE *share_arg)

    :table_share(share_arg), table(0),

    estimation_rows_to_insert(0), ht(ht_arg),

    ref(0), in_range_check_pushed_down(false),

    key_used_on_scan(MAX_KEY), active_index(MAX_KEY),

    ref_length(sizeof(my_off_t)),

    inited(NONE),

    locked(false), implicit_emptied(0),

    pushed_cond(0), pushed_idx_cond(NULL), pushed_idx_cond_keyno(MAX_KEY),

    next_insert_id(0), insert_id_for_cur_row(0)

    {}

  virtual ~handler(void)

  {

    assert(locked == false);

    /* TODO: assert(inited == NONE); */

  }

  virtual handler *clone(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: pubilc wrappers for private virtual API */

  int ha_open(Table *table, const char *name, int mode, int test_if_locked);

  int ha_index_init(uint32_t idx, bool sorted);

  int ha_index_end();

  int ha_rnd_init(bool scan);

  int ha_rnd_end();

  int ha_reset();

  /* this is necessary in many places, e.g. in HANDLER command */

  int ha_index_or_rnd_end();

  Table_flags ha_table_flags() const;

  /**

    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(Session *session, int lock_type);

  int ha_write_row(unsigned char * buf);

  int ha_update_row(const unsigned char * old_data, unsigned char * new_data);

  int ha_delete_row(const unsigned char * 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(Session *session, HA_CHECK_OPT *check_opt);

  int ha_repair(Session* session, HA_CHECK_OPT* check_opt);

  void ha_start_bulk_insert(ha_rows rows);

  int ha_end_bulk_insert();

  int ha_bulk_update_row(const unsigned char *old_data, unsigned char *new_data,

                         uint32_t *dup_key_found);

  int ha_delete_all_rows();

  int ha_reset_auto_increment(uint64_t value);

  int ha_optimize(Session* session, HA_CHECK_OPT* check_opt);

  int ha_analyze(Session* session, HA_CHECK_OPT* check_opt);

  bool ha_check_and_repair(Session *session);

  int ha_disable_indexes(uint32_t mode);

  int ha_enable_indexes(uint32_t mode);

  int ha_discard_or_import_tablespace(bool discard);

  void ha_prepare_for_alter();

  int ha_rename_table(const char *from, const char *to);

  int ha_delete_table(const char *name);

  void ha_drop_table(const char *name);

  int ha_create(const char *name, Table *form, HA_CREATE_INFO *info);

  int ha_create_handler_files(const char *name, const char *old_name,

                              int action_flag, HA_CREATE_INFO *info);

  void adjust_next_insert_id_after_explicit_value(uint64_t nr);

  int update_auto_increment();

  void print_keydup_error(uint32_t key_nr, const char *msg);

  virtual void print_error(int error, myf errflag);

  virtual bool get_error_message(int error, String *buf);

  uint32_t get_dup_key(int error);

  virtual void change_table_ptr(Table *table_arg, TABLE_SHARE *share);

  /* Estimates calculation */

  virtual double scan_time(void)

  { return uint64_t2double(stats.data_file_length) / IO_SIZE + 2; }

  virtual double read_time(uint32_t index __attribute__((unused)),

                           uint32_t ranges, ha_rows rows)

  { return rows2double(ranges+rows); }

  virtual double index_only_read_time(uint32_t keynr, double records);

  virtual ha_rows multi_range_read_info_const(uint32_t keyno, RANGE_SEQ_IF *seq,

                                              void *seq_init_param, 

                                              uint32_t n_ranges, uint32_t *bufsz,

                                              uint32_t *flags, COST_VECT *cost);

  virtual int multi_range_read_info(uint32_t keyno, uint32_t n_ranges, uint32_t keys,

                                    uint32_t *bufsz, uint32_t *flags, COST_VECT *cost);

  virtual int multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param,

                                    uint32_t n_ranges, uint32_t mode,

                                    HANDLER_BUFFER *buf);

  virtual int multi_range_read_next(char **range_info);

  virtual const key_map *keys_to_use_for_scanning();

  bool has_transactions();

  virtual uint32_t extra_rec_buf_length() const { return 0; }

  /**

    This method is used to analyse the error to see whether the error

    is ignorable or not, certain handlers can have more error that are

    ignorable than others. E.g. the partition handler can get inserts

    into a range where there is no partition and this is an ignorable

    error.

    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.

  */

  virtual bool is_fatal_error(int error, uint32_t flags);

  /**

    Number of rows in table. It will only be called if

    (table_flags() & (HA_HAS_RECORDS | HA_STATS_RECORDS_IS_EXACT)) != 0

  */

  virtual ha_rows records();

  /**

    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 the row type from the storage engine.  If this method returns

    ROW_TYPE_NOT_USED, the information in HA_CREATE_INFO should be used.

  */

  virtual enum row_type get_row_type() const { return ROW_TYPE_NOT_USED; }

  virtual const char *index_type(uint32_t key_number __attribute__((unused)))

  { assert(0); return "";}

  /**

    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();

  uint32_t get_index(void) const { return active_index; }

  virtual int close(void)=0;

  /**

    @retval  0   Bulk update used by handler

    @retval  1   Bulk update not used, normal operation used

  */

  virtual bool start_bulk_update() { return 1; }

  /**

    @retval  0   Bulk delete used by handler

    @retval  1   Bulk delete not used, normal operation used

  */

  virtual bool start_bulk_delete() { return 1; }

  /**

    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(uint32_t *dup_key_found __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;

  }

  /**

     @brief

     Positions an index cursor to the index specified in the handle. Fetches the

     row if available. If the key value is null, begin at the first key of the

     index.

  */

  virtual int index_read_map(unsigned char * buf, const unsigned char * key,

                             key_part_map keypart_map,

                             enum ha_rkey_function find_flag)

  {

    uint32_t key_len= calculate_key_len(table, active_index, key, keypart_map);

    return  index_read(buf, key, key_len, find_flag);

  }

  /**

     @brief

     Positions an index cursor to the index specified in the handle. Fetches the

     row if available. If the key value is null, begin at the first key of the

     index.

  */

  virtual int index_read_idx_map(unsigned char * buf, uint32_t index, const unsigned char * key,

                                 key_part_map keypart_map,

                                 enum ha_rkey_function find_flag);

  virtual int index_next(unsigned char * buf __attribute__((unused)))

   { return  HA_ERR_WRONG_COMMAND; }

  virtual int index_prev(unsigned char * buf __attribute__((unused)))

   { return  HA_ERR_WRONG_COMMAND; }

  virtual int index_first(unsigned char * buf __attribute__((unused)))

   { return  HA_ERR_WRONG_COMMAND; }

  virtual int index_last(unsigned char * buf __attribute__((unused)))

   { return  HA_ERR_WRONG_COMMAND; }

  virtual int index_next_same(unsigned char *buf __attribute__((unused)),

                              const unsigned char *key __attribute__((unused)),

                              uint32_t keylen __attribute__((unused)));

  /**

     @brief

     The following functions works like index_read, but it find the last

     row with the current key value or prefix.

  */

  virtual int index_read_last_map(unsigned char * buf, const unsigned char * key,

                                  key_part_map keypart_map)

  {

    uint32_t key_len= calculate_key_len(table, active_index, key, 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();

  int compare_key(key_range *range);

  int compare_key2(key_range *range);

  virtual int rnd_next(unsigned char *buf __attribute__((unused)))=0;

  virtual int rnd_pos(unsigned char * buf __attribute__((unused)),

                      unsigned char *pos __attribute__((unused)))=0;

  /**

    One has to use this method when to find

    random position by record as the plain

    position() call doesn't work for some

    handlers for random position.

  */

  virtual int rnd_pos_by_record(unsigned char *record);

  virtual int read_first_row(unsigned char *buf, uint32_t primary_key);

  /**

    The following function is only needed for tables that may be temporary

    tables during joins.

  */

  virtual int restart_rnd_next(unsigned char *buf __attribute__((unused)),

                               unsigned char *pos __attribute__((unused)))

    { return HA_ERR_WRONG_COMMAND; }

  virtual int rnd_same(unsigned char *buf __attribute__((unused)),

                       uint32_t inx __attribute__((unused)))

    { return HA_ERR_WRONG_COMMAND; }

  virtual ha_rows records_in_range(uint32_t inx __attribute__((unused)),

                                   key_range *min_key __attribute__((unused)),

                                   key_range *max_key __attribute__((unused)))

    { return (ha_rows) 10; }

  virtual void position(const unsigned char *record)=0;

  virtual int info(uint)=0; // see my_base.h for full description

  virtual uint32_t calculate_key_hash_value(Field **field_array __attribute__((unused)))

  { assert(0); return 0; }

  virtual int extra(enum ha_extra_function operation __attribute__((unused)))

  { return 0; }

  virtual int extra_opt(enum ha_extra_function operation,

                        uint32_t cache_size __attribute__((unused)))

  { return extra(operation); }

  /**

    In an UPDATE or DELETE, if the row under the cursor was locked by another

    transaction, and the engine used an optimistic read of the last

    committed row value under the cursor, then the engine returns 1 from this

    function. MySQL must NOT try to update this optimistic value. If the

    optimistic value does not match the WHERE condition, MySQL can decide to

    skip over this row. Currently only works for InnoDB. This can be used to

    avoid unnecessary lock waits.

    If this method returns nonzero, it will also signal the storage

    engine that the next read will be a locking re-read of the row.

  */

  virtual bool was_semi_consistent_read() { return 0; }

  /**

    Tell the engine whether it should avoid unnecessary lock waits.

    If yes, in an UPDATE or DELETE, if the row under the cursor was locked

    by another transaction, the engine may try an optimistic read of

    the last committed row value under the cursor.

  */

  virtual void try_semi_consistent_read(bool) {}

  virtual void unlock_row(void) {}

  virtual int start_stmt(Session *session __attribute__((unused)),

                         thr_lock_type lock_type __attribute__((unused)))

  {return 0;}

  virtual void get_auto_increment(uint64_t offset, uint64_t increment,

                                  uint64_t nb_desired_values,

                                  uint64_t *first_value,

                                  uint64_t *nb_reserved_values);

  void set_next_insert_id(uint64_t id)

  {

    next_insert_id= id;

  }

  void restore_auto_increment(uint64_t prev_insert_id)

  {

    /*

      Insertion of a row failed, re-use the lastly generated auto_increment

      id, for the next row. This is achieved by resetting next_insert_id to

      what it was before the failed insertion (that old value is provided by

      the caller). If that value was 0, it was the first row of the INSERT;

      then if insert_id_for_cur_row contains 0 it means no id was generated

      for this first row, so no id was generated since the INSERT started, so

      we should set next_insert_id to 0; if insert_id_for_cur_row is not 0, it

      is the generated id of the first and failed row, so we use it.

    */

    next_insert_id= (prev_insert_id > 0) ? prev_insert_id :

      insert_id_for_cur_row;

  }

  virtual void update_create_info(HA_CREATE_INFO *create_info __attribute__((unused))) {}

  int check_old_types(void);

  virtual int assign_to_keycache(Session* session __attribute__((unused)),

                                 HA_CHECK_OPT* check_opt __attribute__((unused)))

  { return HA_ADMIN_NOT_IMPLEMENTED; }

  /* end of the list of admin commands */

  virtual int indexes_are_disabled(void) {return 0;}

  virtual char *update_table_comment(const char * comment)

  { return (char*) comment;}

  virtual void append_create_info(String *packet __attribute__((unused)))

  {}

  /**

      If index == MAX_KEY then a check for table is made and if index <

      MAX_KEY then a check is made if the table has foreign keys and if

      a foreign key uses this index (and thus the index cannot be dropped).

    @param  index            Index to check if foreign key uses it

    @retval   true            Foreign key defined on table or index

    @retval   false           No foreign key defined

  */

  virtual bool is_fk_defined_on_table_or_index(uint32_t index __attribute__((unused)))

  { return false; }

  virtual char* get_foreign_key_create_info(void)

  { return(NULL);}  /* gets foreign key create string from InnoDB */

  /** used in ALTER Table; 1 if changing storage engine is allowed */

  virtual bool can_switch_engines(void) { return 1; }

  /** used in REPLACE; is > 0 if table is referred by a FOREIGN KEY */

  virtual int get_foreign_key_list(Session *session __attribute__((unused)),

                                   List<FOREIGN_KEY_INFO> *f_key_list __attribute__((unused)))

  { return 0; }

  virtual uint32_t referenced_by_foreign_key() { return 0;}

  virtual void init_table_handle_for_HANDLER()

  { return; }       /* prepare InnoDB for HANDLER */

  virtual void free_foreign_key_create_info(char* str __attribute__((unused))) {}

  /** The following can be called without an open handler */

  virtual const char *table_type() const =0;

  /**

    If frm_error() is called then we will use this to find out what file

    extentions exist for the storage engine. This is also used by the default

    rename_table and delete_table method 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.

  */

  virtual const char **bas_ext() const =0;

  virtual int get_default_no_partitions(HA_CREATE_INFO *info __attribute__((unused))) { return 1;}

  virtual bool get_no_parts(const char *name __attribute__((unused)),

                            uint32_t *no_parts)

  {

    *no_parts= 0;

    return 0;

  }

  virtual uint32_t index_flags(uint32_t idx, uint32_t part, bool all_parts) const =0;

  virtual int add_index(Table *table_arg __attribute__((unused)),

                        KEY *key_info __attribute__((unused)),

                        uint32_t num_of_keys __attribute__((unused)))

  { return (HA_ERR_WRONG_COMMAND); }

  virtual int prepare_drop_index(Table *table_arg __attribute__((unused)),

                                 uint32_t *key_num __attribute__((unused)),

                                 uint32_t num_of_keys __attribute__((unused)))

  { return (HA_ERR_WRONG_COMMAND); }

  virtual int final_drop_index(Table *table_arg __attribute__((unused)))

  { return (HA_ERR_WRONG_COMMAND); }

  uint32_t max_record_length() const

  { return cmin((unsigned int)HA_MAX_REC_LENGTH, max_supported_record_length()); }

  uint32_t max_keys() const

  { return cmin((unsigned int)MAX_KEY, max_supported_keys()); }

  uint32_t max_key_parts() const

  { return cmin((unsigned int)MAX_REF_PARTS, max_supported_key_parts()); }

  uint32_t max_key_length() const

  { return cmin((unsigned int)MAX_KEY_LENGTH, max_supported_key_length()); }

  uint32_t max_key_part_length(void) const

  { return cmin((unsigned int)MAX_KEY_LENGTH, max_supported_key_part_length()); }

  virtual uint32_t max_supported_record_length(void) const

  { return HA_MAX_REC_LENGTH; }

  virtual uint32_t max_supported_keys(void) const { return 0; }

  virtual uint32_t max_supported_key_parts(void) const { return MAX_REF_PARTS; }

  virtual uint32_t max_supported_key_length(void) const { return MAX_KEY_LENGTH; }

  virtual uint32_t max_supported_key_part_length(void) const { return 255; }

  virtual uint32_t min_record_length(uint32_t options __attribute__((unused))) const

  { return 1; }

  virtual bool low_byte_first(void) const { return 1; }

  virtual uint32_t checksum(void) const { return 0; }

  virtual bool is_crashed(void) const  { return 0; }

  virtual bool auto_repair(void) const { return 0; }

#define CHF_CREATE_FLAG 0

#define CHF_DELETE_FLAG 1

#define CHF_RENAME_FLAG 2

  /**

    @note lock_count() can return > 1 if the table is MERGE or partitioned.

  */

  virtual uint32_t lock_count(void) const { return 1; }

  /**

    Is not invoked for non-transactional temporary tables.

    @note store_lock() can return more than one lock if the table is MERGE

    or partitioned.

    @note that one can NOT rely on table->in_use in store_lock().  It may

    refer to a different thread if called from mysql_lock_abort_for_thread().

    @note If the table is MERGE, store_lock() can return less locks

    than lock_count() claimed. This can happen when the MERGE children

    are not attached when this is called from another thread.

  */

  virtual THR_LOCK_DATA **store_lock(Session *session,

                                     THR_LOCK_DATA **to,

                                     enum thr_lock_type lock_type)=0;

  /** Type of table for caching query */

  virtual uint8_t table_cache_type() { return HA_CACHE_TBL_NONTRANSACT; }

  /**

    @brief Register a named table with a call back function to the query cache.

    @param session The thread handle

    @param table_key A pointer to the table name in the table cache

    @param key_length The length of the table name

    @param[out] engine_callback The pointer to the storage engine call back

      function

    @param[out] engine_data Storage engine specific data which could be

      anything

    This method offers the storage engine, the possibility to store a reference

    to a table name which is going to be used with query cache. 

    The method is called each time a statement is written to the cache and can

    be used to verify if a specific statement is cachable. It also offers

    the possibility to register a generic (but static) call back function which

    is called each time a statement is matched against the query cache.

    @note If engine_data supplied with this function is different from

      engine_data supplied with the callback function, and the callback returns

      false, a table invalidation on the current table will occur.