~drizzle-trunk/drizzle/development

 

 

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

 

 

 

#ifndef NO_HASH

#define NO_HASH                         /* Not yet implemented */

#define HA_ADMIN_NEEDS_CHECK    -12

 

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

 

typedef Bitmap<HA_MAX_ALTER_FLAGS> HA_ALTER_FLAGS;

 

#define HA_ADD_INDEX                  (0)

#define HA_RENAME_TABLE               (36)

#define HA_ALTER_STORAGE_ENGINE       (37)

#define HA_RECREATE                   (38)

/* Remember to increase HA_MAX_ALTER_FLAGS when adding more flags! */

 

/* Return values for check_if_supported_alter */

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