~drizzle-trunk/drizzle/development

 

 

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

#pragma interface                       /* gcc class implementation */

#endif

 

 

#ifndef NO_HASH

#define NO_HASH                         /* Not yet implemented */

#define HA_ADMIN_NEEDS_CHECK    -12

 

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

 

#define HA_MAX_ALTER_FLAGS 39

typedef Bitmap<HA_MAX_ALTER_FLAGS> HA_ALTER_FLAGS;

  row to be able to find the row later.

*/

#define HA_REC_NOT_IN_SEQ      (1 << 3)

/*

  Reading keys in random order is as fast as reading keys in sort order

  (Used in records.cc to decide if we should use a record cache and by

#define HA_REQUIRE_PRIMARY_KEY (1 << 12) /* .. and can't create a hidden one */

#define HA_STATS_RECORDS_IS_EXACT (1 << 13) /* stats.records is exact */

/*

  If we get the primary key columns for free when we do an index read

  It also implies that we have to retrive the primary key when using

  position() and rnd_pos().

  uses a primary key. Without primary key, we can't call position().

*/ 

#define HA_PRIMARY_KEY_REQUIRED_FOR_POSITION (1 << 16) 

#define HA_NOT_DELETE_WITH_CACHE (1 << 18)

/*

  The following is we need to a primary key to delete (and update) a row.

*/

#define HA_PRIMARY_KEY_REQUIRED_FOR_DELETE (1 << 19)

#define HA_NO_PREFIX_CHAR_KEYS (1 << 20)

#define HA_NO_AUTO_INCREMENT   (1 << 23)

#define HA_HAS_CHECKSUM        (1 << 24)

/* Table data are stored in separate files (for lower_case_table_names) */

#define HA_FILE_BASED          (1 << 26)

#define HA_NEED_READ_RANGE_BUFFER (1 << 29) /* for read_multi_range */

#define HA_ANY_INDEX_MAY_BE_UNIQUE (1 << 30)

 

/*

  Engine is capable of row-format and statement-format logging,

  respectively

*/

 

 

/*

  Set of all binlog flags. Currently only contain the capabilities

  set.

  This is actually removed even before it was introduced the first time.

  The new idea is that handlers will handle the lock level already in

 

  HA_PARTITION_ONE_PHASE is a flag that can be set by handlers that take

  care of changing the partitions online and in one phase. Thus all phases

#define HA_BLOCK_LOCK           256     /* unlock when reading some records */

#define HA_OPEN_TEMPORARY       512

 

#define HA_LOCK_IN_SHARE_MODE      F_RDLCK

#define HA_LOCK_IN_EXCLUSIVE_MODE  F_WRLCK

 

#define HA_CACHE_TBL_TRANSACT    4

 

/* Options of START TRANSACTION statement (and later of SET TRANSACTION stmt) */

 

/* Flags for method is_fatal_error */

#define HA_CHECK_DUP_KEY 1

 

enum legacy_db_type

{

  DB_TYPE_FIRST_DYNAMIC=42,

  DB_TYPE_DEFAULT=127 // Must be last

};

 

/* Bits in used_fields */

#define HA_CREATE_USED_AUTO             (1L << 0)

#define HA_CREATE_USED_RAID             (1L << 1) /* Historical, no longer supported */

#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_DELAY_KEY_WRITE  (1L << 14)

#define HA_CREATE_USED_ROW_FORMAT       (1L << 15)

#define HA_CREATE_USED_COMMENT          (1L << 16)

#define HA_CREATE_USED_CONNECTION       (1L << 18)

#define HA_CREATE_USED_KEY_BLOCK_SIZE   (1L << 19)

#define HA_CREATE_USED_PAGE_CHECKSUM    (1L << 21)

 

typedef uint64_t my_xid; // this line is the same as in log_event.h

 

#define MAXGTRIDSIZE 64

#define MAXBQUALSIZE 64

 

#define COMPATIBLE_DATA_YES 0

#define COMPATIBLE_DATA_NO  1

 

/**

  struct xid_t is binary compatible with the XID structure as

  in the X/Open CAE Specification, Distributed Transaction Processing:

  The XA Specification, X/Open Company Ltd., 1991.

  http://www.opengroup.org/bookstore/catalog/c193.htm

 

*/

struct xid_t {

  long formatID;

  {

    my_xid tmp;

    formatID= 1;

    tmp= xid;

  }

  void set(long g, long b, const char *d)

  {

  my_xid quick_get_my_xid()

  {

    my_xid tmp;

    return tmp;

  }

  my_xid get_my_xid()

  {

           quick_get_my_xid() : 0;

  }

  {

    return sizeof(formatID)+sizeof(gtrid_length)+sizeof(bqual_length)+

           gtrid_length+bqual_length;

  }

  {

  }

  {

    return sizeof(gtrid_length)+sizeof(bqual_length)+gtrid_length+bqual_length;

  }

 

struct handlerton;

 

 

typedef struct st_table_share TABLE_SHARE;

struct st_foreign_key_info;

typedef struct st_foreign_key_info FOREIGN_KEY_INFO;

enum ha_stat_type { HA_ENGINE_STATUS, HA_ENGINE_LOGS, HA_ENGINE_MUTEX };

extern st_plugin_int *hton2plugin[MAX_HA];

 

 

   slot number is initialized by MySQL after xxx_init() is called.

   */

   /*

     to store per-savepoint data storage engine is provided with an area

     of a requested size (0 is ok here).

     area and need not be used by storage engine.

     see binlog_hton and binlog_savepoint_set/rollback for an example.

   */

   /*

     handlerton methods:

 

   int  (*commit)(handlerton *hton, THD *thd, bool all);

   int  (*rollback)(handlerton *hton, THD *thd, bool all);

   int  (*prepare)(handlerton *hton, THD *thd, bool all);

   int  (*commit_by_xid)(handlerton *hton, XID *xid);

   int  (*rollback_by_xid)(handlerton *hton, XID *xid);

   void *(*create_cursor_read_view)(handlerton *hton, THD *thd);

   void (*close_cursor_read_view)(handlerton *hton, THD *thd, void *read_view);

   handler *(*create)(handlerton *hton, TABLE_SHARE *table, MEM_ROOT *mem_root);

   void (*drop_database)(handlerton *hton, char* path);

   int (*start_consistent_snapshot)(handlerton *hton, THD *thd);

   bool (*flush_logs)(handlerton *hton);

   bool (*show_status)(handlerton *hton, THD *thd, stat_print_fn *print, enum ha_stat_type stat);

   int (*fill_files_table)(handlerton *hton, THD *thd,

                           class Item *cond);

   int (*release_temporary_latches)(handlerton *hton, THD *thd);

 

   int (*discover)(handlerton *hton, THD* thd, const char *db, 

                   const char *name,

                   size_t *frmlen);

   int (*table_exists_in_engine)(handlerton *hton, THD* thd, const char *db,

                                 const char *name);

   void *data; /* Location for engines to keep personal structures */

};

 

    Not-null only if this instance is a part of transaction.

    May assume a combination of enum values above.

  */

};

 

 

enum enum_tx_isolation { ISO_READ_UNCOMMITTED, ISO_READ_COMMITTED,

                         ISO_REPEATABLE_READ, ISO_SERIALIZABLE};

 

typedef struct {

  uint64_t data_file_length;

  uint64_t max_data_file_length;

class Item;

struct st_table_log_memory_entry;

 

 

enum ha_choice { HA_CHOICE_UNDEF, HA_CHOICE_NO, HA_CHOICE_YES };

 

typedef struct st_ha_create_information

{

  LEX_STRING connect_string;

  LEX_STRING comment;

  const char *data_file_name, *index_file_name;

  uint32_t avg_row_length;

  uint32_t used_fields;

  uint32_t key_block_size;

  handlerton *db_type;

  enum row_type row_type;

  bool table_existed;                   /* 1 in create if table existed */

  bool frm_only;                        /* 1 if no ha_create_table() */

  bool varchar;                         /* 1 if table has a VARCHAR */

typedef struct st_ha_alter_information

{

  KEY  *key_info_buffer;

  void *data;

} HA_ALTER_INFO;

 

  TABLEOP_HOOKS() {}

  virtual ~TABLEOP_HOOKS() {}

 

  {

    do_prelock(tables, count);

  }

 

  {

    return do_postlock(tables, count);

  }

private:

  /* Function primitive that is called prior to locking tables */

  {

    /* Default is to do nothing */

  }

 

     @return Error code or zero.

   */

  {

    return 0;                           /* Default is to do nothing */

  }

{

  st_ha_check_opt() {}                        /* Remove gcc warning */

  uint32_t sort_buffer_size;

  KEY_CACHE *key_cache; /* new key cache when changing key cache */

  void init();

} HA_CHECK_OPT;

 

typedef struct st_handler_buffer

{

} HANDLER_BUFFER;

 

typedef struct system_status_var SSV;

    RETURN

      An opaque value to be used as RANGE_SEQ_IF::next() parameter

  */

 

 

  /*

      0 - Ok, the range structure filled with info about the next range

      1 - No more ranges

  */

} RANGE_SEQ_IF;

 

 

class COST_VECT

{ 

  }

};

 

                         COST_VECT *cost);

 

/*

  time_t create_time;                   /* When table was created */

  time_t check_time;

  time_t update_time;

 

  ha_statistics():

    data_file_length(0), max_data_file_length(0),

  {}

};

 

/*

  bitmap with first N+1 bits set

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

  typedef uint64_t Table_flags;

protected:

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

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

 

  ha_rows estimation_rows_to_insert;

public:

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

 

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

  /* true <=> source MRR ranges and the output are ordered */

  bool mrr_is_output_sorted;

 

  */

  bool in_range_check_pushed_down;

 

  /** Length of ref (1-8 or the clustered key 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;

 

  /**

    next_insert_id is the next value which should be inserted into the

  }

  /* ha_ methods: pubilc wrappers for private virtual API */

 

  {

    int result;

    assert(inited==NONE);

    and delete_row() below.

  */

  int ha_external_lock(THD *thd, int lock_type);

  void ha_release_auto_increment();

 

  int ha_check_for_upgrade(HA_CHECK_OPT *check_opt);

    estimation_rows_to_insert= 0;

    return end_bulk_insert();

  }

  int ha_delete_all_rows();

  int ha_reset_auto_increment(uint64_t value);

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

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

  virtual void print_error(int error, myf errflag);

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

  {

    table= table_arg;

    table_share= share;

  /* Estimates calculation */

  virtual double scan_time(void)

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

  { return rows2double(ranges+rows); }

 

  

                                              void *seq_init_param, 

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

                                    HANDLER_BUFFER *buf);

  virtual int multi_range_read_next(char **range_info);

 

  virtual const key_map *keys_to_use_for_scanning() { return &key_map_empty; }

  bool has_transactions()

  { return (ha_table_flags() & HA_NO_TRANSACTIONS) == 0; }

 

  /**

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

    same thing as HA_ERR_FOUND_DUP_KEY but can in some cases lead to

    a slightly different error message.

  */

  {

    if (!error ||

        ((flags & HA_CHECK_DUP_KEY) &&

  */

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

 

  { assert(0); return "";}

 

 

    as there may be several calls to this routine.

  */

  virtual void column_bitmaps_signal();

  virtual int close(void)=0;

 

  /**

    @retval  0           Success

    @retval  >0          Error code

  */

  {

    assert(false);

    return HA_ERR_WRONG_COMMAND;

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

     index.

  */

                             key_part_map keypart_map,

                             enum ha_rkey_function find_flag)

  {

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

  }

  /**

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

     index.

  */

                                 key_part_map keypart_map,

                                 enum ha_rkey_function find_flag);

  /**

     @brief

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

     row with the current key value or prefix.

  */

                                  key_part_map keypart_map)

  {

    return index_read_last(buf, key, key_len);

  }

  virtual int read_range_first(const key_range *start_key,

  virtual int read_range_next();

  int compare_key(key_range *range);

  int compare_key2(key_range *range);

  /**

    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.

  */

  /**

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

    tables during joins.

  */