handler.h 30.7 KB
Newer Older
1
/* Copyright (C) 2000,2004 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
2

unknown's avatar
unknown committed
3 4 5 6
   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; either version 2 of the License, or
   (at your option) any later version.
7

unknown's avatar
unknown committed
8 9 10 11
   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.
12

unknown's avatar
unknown committed
13 14 15 16 17 18 19 20 21 22 23
   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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


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

#ifdef __GNUC__
#pragma interface			/* gcc class implementation */
#endif

unknown's avatar
unknown committed
24
#include <ft_global.h>
unknown's avatar
unknown committed
25
#include <keycache.h>
unknown's avatar
unknown committed
26

unknown's avatar
unknown committed
27 28 29 30
#ifndef NO_HASH
#define NO_HASH				/* Not yet implemented */
#endif

unknown's avatar
unknown committed
31 32
#if defined(HAVE_BERKELEY_DB) || defined(HAVE_INNOBASE_DB) || \
    defined(HAVE_NDBCLUSTER_DB)
33 34 35
#define USING_TRANSACTIONS
#endif

unknown's avatar
unknown committed
36 37
// the following is for checking tables

38 39 40 41 42 43
#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
unknown's avatar
unknown committed
44
#define HA_ADMIN_INVALID         -5
unknown's avatar
unknown committed
45
#define HA_ADMIN_REJECT          -6
46
#define HA_ADMIN_TRY_ALTER       -7
47
#define HA_ADMIN_WRONG_CHECKSUM  -8
unknown's avatar
unknown committed
48

49
/* Bits in table_flags() to show what database can do */
unknown's avatar
unknown committed
50 51 52 53 54
#define HA_READ_RND_SAME       (1 << 0) /* can switch index during the scan
                                           with ::rnd_same() - not used yet.
                                           see mi_rsame/heap_rsame/myrg_rsame */
#define HA_TABLE_SCAN_ON_INDEX (1 << 2) /* No separate data/index file */
#define HA_REC_NOT_IN_SEQ      (1 << 3) /* ha_info don't return recnumber;
unknown's avatar
unknown committed
55
                                           It returns a position to ha_r_rnd */
unknown's avatar
unknown committed
56
#define HA_CAN_GEOMETRY        (1 << 4)
57
#define HA_FAST_KEY_READ       (1 << 5) /* no need for a record cache in filesort */
unknown's avatar
unknown committed
58 59
#define HA_NULL_IN_KEY         (1 << 7) /* One can have keys with NULL */
#define HA_DUPP_POS            (1 << 8) /* ha_position() gives dup row */
unknown's avatar
unknown committed
60
#define HA_NO_BLOBS            (1 << 9) /* Doesn't support blobs */
unknown's avatar
unknown committed
61 62 63
#define HA_CAN_INDEX_BLOBS     (1 << 10)
#define HA_AUTO_PART_KEY       (1 << 11) /* auto-increment in multi-part key */
#define HA_REQUIRE_PRIMARY_KEY (1 << 12) /* .. and can't create a hidden one */
unknown's avatar
unknown committed
64
#define HA_NOT_EXACT_COUNT     (1 << 13)
unknown's avatar
unknown committed
65 66 67
#define HA_CAN_INSERT_DELAYED  (1 << 14) /* only handlers with table-level locks
                                            need no special code to support
                                            INSERT DELAYED */
unknown's avatar
unknown committed
68 69 70 71 72 73 74
#define HA_PRIMARY_KEY_IN_READ_INDEX (1 << 15)
#define HA_NOT_DELETE_WITH_CACHE (1 << 18)
#define HA_NO_PREFIX_CHAR_KEYS (1 << 20)
#define HA_CAN_FULLTEXT        (1 << 21)
#define HA_CAN_SQL_HANDLER     (1 << 22)
#define HA_NO_AUTO_INCREMENT   (1 << 23)
#define HA_HAS_CHECKSUM        (1 << 24)
unknown's avatar
unknown committed
75
/* Table data are stored in separate files (for lower_case_table_names) */
unknown's avatar
unknown committed
76
#define HA_FILE_BASED	       (1 << 26)
77
#define HA_NO_VARCHAR	       (1 << 27)
unknown's avatar
unknown committed
78
#define HA_CAN_BIT_FIELD       (1 << 28) /* supports bit fields */
unknown's avatar
unknown committed
79
#define HA_NEED_READ_RANGE_BUFFER (1 << 29) /* for read_multi_range */
unknown's avatar
unknown committed
80

81

82
/* bits in index_flags(index_number) for what you can do with index */
unknown's avatar
unknown committed
83 84 85 86
#define HA_READ_NEXT            1       /* TODO really use this flag */
#define HA_READ_PREV            2       /* supports ::index_prev */
#define HA_READ_ORDER           4       /* index_next/prev follow sort order */
#define HA_READ_RANGE           8       /* can find all records in a range */
87
#define HA_ONLY_WHOLE_INDEX	16	/* Can't use part key searches */
unknown's avatar
unknown committed
88
#define HA_KEYREAD_ONLY         64	/* Support HA_EXTRA_KEYREAD */
89

90 91 92 93 94 95
/* 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

96 97 98 99
/*
  Note: the following includes binlog and closing 0.
  so: innodb+bdb+ndb+binlog+0
*/
unknown's avatar
unknown committed
100
#define MAX_HA 6
101

102
/*
103 104 105 106
  Bits in index_ddl_flags(KEY *wanted_index)
  for what ddl you can do with index
  If none is set, the wanted type of index is not supported
  by the handler at all. See WorkLog 1563.
107 108 109 110 111
*/
#define HA_DDL_SUPPORT   1 /* Supported by handler */
#define HA_DDL_WITH_LOCK 2 /* Can create/drop with locked table */
#define HA_DDL_ONLINE    4 /* Can create/drop without lock */

112 113 114 115
/*
  Parameters for open() (in register form->filestat)
  HA_GET_INFO does an implicit HA_ABORT_IF_LOCKED
*/
unknown's avatar
unknown committed
116 117 118 119 120 121

#define HA_OPEN_KEYFILE		1
#define HA_OPEN_RNDFILE		2
#define HA_GET_INDEX		4
#define HA_GET_INFO		8	/* do a ha_info() after open */
#define HA_READ_ONLY		16	/* File opened as readonly */
122 123
/* Try readonly if can't open with read and write */
#define HA_TRY_READ_ONLY	32
unknown's avatar
unknown committed
124 125 126 127 128
#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

129
	/* Errors on write which is recoverable  (Key exist) */
unknown's avatar
unknown committed
130
#define HA_WRITE_SKIP 121		/* Duplicate key on write */
unknown's avatar
unknown committed
131 132 133 134 135 136 137 138 139 140 141 142 143
#define HA_READ_CHECK 123		/* Update with is recoverable */
#define HA_CANT_DO_THAT 131		/* Databasehandler can't do it */

	/* 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_OPTION_NO_CHECKSUM	(1L << 17)
#define HA_OPTION_NO_DELAY_KEY_WRITE (1L << 18)
#define HA_MAX_REC_LENGTH	65535

144 145
/* Table caching type */
#define HA_CACHE_TBL_NONTRANSACT 0
146 147 148 149
#define HA_CACHE_TBL_NOCACHE     1
#define HA_CACHE_TBL_ASKTRANSACT 2
#define HA_CACHE_TBL_TRANSACT    4

150 151
/* Options of START TRANSACTION statement (and later of SET TRANSACTION stmt) */
#define MYSQL_START_TRANS_OPT_WITH_CONS_SNAPSHOT 1
152

153 154
enum db_type
{
unknown's avatar
unknown committed
155 156 157 158
  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,
159
  DB_TYPE_BERKELEY_DB, DB_TYPE_INNODB,
unknown's avatar
unknown committed
160
  DB_TYPE_GEMINI, DB_TYPE_NDBCLUSTER,
161
  DB_TYPE_EXAMPLE_DB, DB_TYPE_ARCHIVE_DB, DB_TYPE_CSV_DB,
162
  DB_TYPE_FEDERATED_DB,
163

unknown's avatar
unknown committed
164 165
  DB_TYPE_DEFAULT // Must be last
};
unknown's avatar
unknown committed
166

167 168 169 170 171 172 173
struct show_table_type_st {
  const char *type;
  SHOW_COMP_OPTION *value;
  const char *comment;
  enum db_type db_type;
};

174
enum row_type { ROW_TYPE_NOT_USED=-1, ROW_TYPE_DEFAULT, ROW_TYPE_FIXED,
175 176
		ROW_TYPE_DYNAMIC, ROW_TYPE_COMPRESSED,
		ROW_TYPE_REDUNDANT, ROW_TYPE_COMPACT };
unknown's avatar
unknown committed
177 178 179 180

/* struct to hold information about the table that should be created */

/* Bits in used_fields */
181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
#define HA_CREATE_USED_AUTO             (1L << 0)
#define HA_CREATE_USED_RAID             (1L << 1)
#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)
unknown's avatar
unknown committed
199

unknown's avatar
unknown committed
200
typedef ulonglong my_xid;
201 202 203 204
#define MYSQL_XID_PREFIX "MySQLXid"
#define MYSQL_XID_PREFIX_LEN 8 // must be a multiple of 8
#define MYSQL_XID_OFFSET (MYSQL_XID_PREFIX_LEN+sizeof(server_id))
#define MYSQL_XID_GTRID_LEN (MYSQL_XID_OFFSET+sizeof(my_xid))
205 206 207 208 209 210 211 212 213

#define XIDDATASIZE 128
#define MAXGTRIDSIZE 64
#define MAXBQUALSIZE 64

struct xid_t {
  long formatID;
  long gtrid_length;
  long bqual_length;
214
  char data[XIDDATASIZE];  // not \0-terminated !
215

216 217 218 219
  bool eq(LEX_STRING *l) { return eq(l->length, 0, l->str); }
  bool eq(long g, long b, const char *d)
  { return g == gtrid_length && b == bqual_length && !memcmp(d, data, g+b); }
  void set(LEX_STRING *l) { set(l->length, 0, l->str); }
unknown's avatar
unknown committed
220
  void set(ulonglong l)
221 222 223
  {
    set(MYSQL_XID_PREFIX_LEN, 0, MYSQL_XID_PREFIX);
    *(ulong*)(data+MYSQL_XID_PREFIX_LEN)=server_id;
unknown's avatar
unknown committed
224
    *(my_xid*)(data+MYSQL_XID_OFFSET)=l;
225 226 227 228 229 230 231 232 233 234 235 236 237
    gtrid_length=MYSQL_XID_GTRID_LEN;
  }
  void set(long g, long b, const char *d)
  {
    formatID=1;
    gtrid_length= g;
    bqual_length= b;
    memcpy(data, d, g+b);
  }
  bool is_null() { return formatID == -1; }
  void null() { formatID= -1; }
  my_xid quick_get_my_xid()
  {
unknown's avatar
unknown committed
238
    return *(my_xid*)(data+MYSQL_XID_OFFSET);
239 240 241 242 243 244 245 246 247
  }
  my_xid get_my_xid()
  {
    return gtrid_length == MYSQL_XID_GTRID_LEN && bqual_length == 0 &&
           *(ulong*)(data+MYSQL_XID_PREFIX_LEN) == server_id &&
           !memcmp(data, MYSQL_XID_PREFIX, MYSQL_XID_PREFIX_LEN) ?
           quick_get_my_xid() : 0;
  }
};
248 249
typedef struct xid_t XID;

250 251 252
/* for recover() handlerton call */
#define MIN_XID_LIST_SIZE  128
#define MAX_XID_LIST_SIZE  (1024*128)
253

unknown's avatar
unknown committed
254 255 256 257 258 259
/*
  handlerton is a singleton structure - one instance per storage engine -
  to provide access to storage engine functionality that works on
  "global" level (unlike handler class that works on per-table basis)

  usually handlerton instance is defined statically in ha_xxx.cc as
260

unknown's avatar
unknown committed
261 262 263 264
  static handlerton { ... } xxx_hton;

  savepoint_*, prepare, recover, and *_by_xid pointers can be 0.
*/
265 266
typedef struct
{
unknown's avatar
unknown committed
267 268 269 270 271 272 273 274 275
  /*
    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.
   */
276
   uint slot;
unknown's avatar
unknown committed
277 278 279 280 281 282 283 284 285
   /*
     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.
   */
286
   uint savepoint_offset;
unknown's avatar
unknown committed
287 288 289 290 291 292 293 294
   /*
     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
   */
295
   int  (*close_connection)(THD *thd);
unknown's avatar
unknown committed
296 297 298 299
   /*
     sv points to an uninitialized storage area of requested size
     (see savepoint_offset description)
   */
300
   int  (*savepoint_set)(THD *thd, void *sv);
unknown's avatar
unknown committed
301 302 303 304
   /*
     sv points to a storage area, that was earlier passed
     to the savepoint_set call
   */
305 306
   int  (*savepoint_rollback)(THD *thd, void *sv);
   int  (*savepoint_release)(THD *thd, void *sv);
unknown's avatar
unknown committed
307 308 309 310 311 312 313
   /*
     '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.
   */
314 315 316 317 318 319 320 321
   int  (*commit)(THD *thd, bool all);
   int  (*rollback)(THD *thd, bool all);
   int  (*prepare)(THD *thd, bool all);
   int  (*recover)(XID *xid_list, uint len);
   int  (*commit_by_xid)(XID *xid);
   int  (*rollback_by_xid)(XID *xid);
} handlerton;

322 323
typedef struct st_thd_trans
{
unknown's avatar
unknown committed
324
  /* number of entries in the ht[] */
325
  uint        nht;
unknown's avatar
unknown committed
326
  /* true is not all entries in the ht[] support 2pc */
327
  bool        no_2pc;
unknown's avatar
unknown committed
328
  /* storage engines that registered themselves for this transaction */
329 330 331
  handlerton *ht[MAX_HA];
} THD_TRANS;

unknown's avatar
unknown committed
332 333 334
enum enum_tx_isolation { ISO_READ_UNCOMMITTED, ISO_READ_COMMITTED,
			 ISO_REPEATABLE_READ, ISO_SERIALIZABLE};

unknown's avatar
unknown committed
335 336
typedef struct st_ha_create_information
{
337
  CHARSET_INFO *table_charset, *default_table_charset;
unknown's avatar
unknown committed
338 339 340
  const char *comment,*password;
  const char *data_file_name, *index_file_name;
  const char *alias;
341 342 343 344
  ulonglong max_rows,min_rows;
  ulonglong auto_increment_value;
  ulong table_options;
  ulong avg_row_length;
unknown's avatar
unknown committed
345 346
  ulong raid_chunksize;
  ulong used_fields;
347
  SQL_LIST merge_list;
348 349
  enum db_type db_type;
  enum row_type row_type;
350
  uint options;				/* OR of HA_CREATE_ options */
351
  uint raid_type,raid_chunks;
352
  uint merge_insert_method;
353
  bool table_existed;			/* 1 in create if table existed */
354
  bool frm_only;                        /* 1 if no ha_create_table() */
355
  bool varchar;                         /* 1 if table has a VARCHAR */
unknown's avatar
unknown committed
356 357 358 359 360 361 362
} HA_CREATE_INFO;


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

struct st_table;
typedef struct st_table TABLE;
363 364
struct st_foreign_key_info;
typedef struct st_foreign_key_info FOREIGN_KEY_INFO;
unknown's avatar
unknown committed
365

366 367 368
typedef struct st_savepoint SAVEPOINT;
extern ulong savepoint_alloc_size;

369
/* Forward declaration for condition pushdown to storage engine */
unknown's avatar
Merge  
unknown committed
370 371
typedef struct Item COND;

unknown's avatar
unknown committed
372 373 374
typedef struct st_ha_check_opt
{
  ulong sort_buffer_size;
unknown's avatar
unknown committed
375 376
  uint flags;       /* isam layer flags (e.g. for myisamchk) */
  uint sql_flags;   /* sql layer flags - for something myisamchk cannot do */
unknown's avatar
unknown committed
377
  KEY_CACHE *key_cache;	/* new key cache when changing key cache */
unknown's avatar
unknown committed
378
  void init();
unknown's avatar
unknown committed
379 380
} HA_CHECK_OPT;

381

unknown's avatar
unknown committed
382 383 384 385 386 387 388 389 390 391 392 393 394 395 396
/*
  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).
*/

typedef struct st_handler_buffer
{
  const byte *buffer;         /* Buffer one can start using */
  const byte *buffer_end;     /* End of buffer */
  byte *end_of_used_area;     /* End of area that was used by handler */
} HANDLER_BUFFER;


unknown's avatar
unknown committed
397 398 399 400 401
class handler :public Sql_alloc
{
 protected:
  struct st_table *table;		/* The table definition */

unknown's avatar
unknown committed
402 403 404 405 406 407 408 409 410 411 412 413
  virtual int index_init(uint idx) { active_index=idx; return 0; }
  virtual int index_end() { active_index=MAX_KEY; return 0; }
  /*
    rnd_init() can be called two times without rnd_end() in between
    (it only makes sense if scan=1).
    then the second call should prepare for the new table scan (e.g
    if rnd_init allocates the cursor, second call should position it
    to the start of the table, no need to deallocate and allocate it again
  */
  virtual int rnd_init(bool scan) =0;
  virtual int rnd_end() { return 0; }

unknown's avatar
unknown committed
414 415 416 417 418 419 420 421 422
public:
  byte *ref;				/* Pointer to current row */
  byte *dupp_ref;			/* Pointer to dupp row */
  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;
423 424
  ha_rows records;			/* Records in table */
  ha_rows deleted;			/* Deleted records */
unknown's avatar
unknown committed
425
  ulong raid_chunksize;
426
  ulong mean_rec_length;		/* physical reclength */
unknown's avatar
unknown committed
427 428 429
  time_t create_time;			/* When table was created */
  time_t check_time;
  time_t update_time;
430

unknown's avatar
unknown committed
431 432 433 434 435 436
  /* The following are for read_multi_range */
  bool multi_range_sorted;
  KEY_MULTI_RANGE *multi_range_curr;
  KEY_MULTI_RANGE *multi_range_end;
  HANDLER_BUFFER *multi_range_buffer;

437 438 439 440
  /* 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;
unknown's avatar
unknown committed
441
  bool eq_range;
442

443 444 445 446 447 448 449
  uint errkey;				/* Last dup key */
  uint sortkey, key_used_on_scan;
  uint active_index;
  /* Length of ref (1-8 or the clustered key length) */
  uint ref_length;
  uint block_size;			/* index block size */
  uint raid_type,raid_chunks;
unknown's avatar
unknown committed
450
  FT_INFO *ft_handler;
451
  enum {NONE=0, INDEX, RND} inited;
452
  bool  auto_increment_column_changed;
453
  bool implicit_emptied;                /* Can be !=0 only if HEAP */
454
  const COND *pushed_cond;
455

456 457 458 459 460
  handler(TABLE *table_arg) :table(table_arg),
    ref(0), 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),
unknown's avatar
unknown committed
461
    key_used_on_scan(MAX_KEY), active_index(MAX_KEY),
462
    ref_length(sizeof(my_off_t)), block_size(0),
463 464
    raid_type(0), ft_handler(0), inited(NONE), implicit_emptied(0),
    pushed_cond(NULL)
unknown's avatar
unknown committed
465
    {}
unknown's avatar
unknown committed
466
  virtual ~handler(void) { /* TODO: DBUG_ASSERT(inited == NONE); */ }
unknown's avatar
unknown committed
467 468
  int ha_open(const char *name, int mode, int test_if_locked);
  void update_auto_increment();
unknown's avatar
unknown committed
469
  virtual void print_error(int error, myf errflag);
470
  virtual bool get_error_message(int error, String *buf);
unknown's avatar
unknown committed
471 472 473
  uint get_dup_key(int error);
  void change_table_ptr(TABLE *table_arg) { table=table_arg; }
  virtual double scan_time()
474
    { return ulonglong2double(data_file_length) / IO_SIZE + 2; }
unknown's avatar
unknown committed
475 476
  virtual double read_time(uint index, uint ranges, ha_rows rows)
 { return rows2double(ranges+rows); }
unknown's avatar
unknown committed
477
  virtual const key_map *keys_to_use_for_scanning() { return &key_map_empty; }
unknown's avatar
unknown committed
478
  virtual bool has_transactions(){ return 0;}
479
  virtual uint extra_rec_buf_length() { return 0; }
unknown's avatar
unknown committed
480 481 482 483 484 485 486 487 488
  
  /*
    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 records+EXTRA_RECORDS; }
unknown's avatar
unknown committed
489

490 491 492 493 494 495
  /*
    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; }

unknown's avatar
unknown committed
496 497 498 499
  virtual const char *index_type(uint key_number) { DBUG_ASSERT(0); return "";}

  int ha_index_init(uint idx)
  {
unknown's avatar
unknown committed
500
    DBUG_ENTER("ha_index_init");
unknown's avatar
unknown committed
501 502
    DBUG_ASSERT(inited==NONE);
    inited=INDEX;
unknown's avatar
unknown committed
503
    DBUG_RETURN(index_init(idx));
unknown's avatar
unknown committed
504 505 506
  }
  int ha_index_end()
  {
unknown's avatar
unknown committed
507
    DBUG_ENTER("ha_index_end");
unknown's avatar
unknown committed
508 509
    DBUG_ASSERT(inited==INDEX);
    inited=NONE;
unknown's avatar
unknown committed
510
    DBUG_RETURN(index_end());
unknown's avatar
unknown committed
511
  }
512
  int ha_rnd_init(bool scan)
unknown's avatar
unknown committed
513
  {
unknown's avatar
unknown committed
514
    DBUG_ENTER("ha_rnd_init");
unknown's avatar
unknown committed
515 516
    DBUG_ASSERT(inited==NONE || (inited==RND && scan));
    inited=RND;
unknown's avatar
unknown committed
517
    DBUG_RETURN(rnd_init(scan));
unknown's avatar
unknown committed
518 519 520
  }
  int ha_rnd_end()
  {
unknown's avatar
unknown committed
521
    DBUG_ENTER("ha_rnd_end");
unknown's avatar
unknown committed
522 523
    DBUG_ASSERT(inited==RND);
    inited=NONE;
unknown's avatar
unknown committed
524
    DBUG_RETURN(rnd_end());
unknown's avatar
unknown committed
525
  }
unknown's avatar
unknown committed
526
  /* this is necessary in many places, e.g. in HANDLER command */
unknown's avatar
unknown committed
527 528 529 530
  int ha_index_or_rnd_end()
  {
    return inited == INDEX ? ha_index_end() : inited == RND ? ha_rnd_end() : 0;
  }
unknown's avatar
unknown committed
531
  uint get_index(void) const { return active_index; }
532
  virtual int open(const char *name, int mode, uint test_if_locked)=0;
unknown's avatar
unknown committed
533
  virtual int close(void)=0;
unknown's avatar
unknown committed
534 535 536 537 538
  virtual int write_row(byte * buf) { return  HA_ERR_WRONG_COMMAND; }
  virtual int update_row(const byte * old_data, byte * new_data)
   { return  HA_ERR_WRONG_COMMAND; }
  virtual int delete_row(const byte * buf)
   { return  HA_ERR_WRONG_COMMAND; }
unknown's avatar
unknown committed
539
  virtual int index_read(byte * buf, const byte * key,
unknown's avatar
unknown committed
540 541
			 uint key_len, enum ha_rkey_function find_flag)
   { return  HA_ERR_WRONG_COMMAND; }
unknown's avatar
unknown committed
542
  virtual int index_read_idx(byte * buf, uint index, const byte * key,
unknown's avatar
unknown committed
543 544 545 546 547 548 549 550 551
			     uint key_len, enum ha_rkey_function find_flag);
  virtual int index_next(byte * buf)
   { return  HA_ERR_WRONG_COMMAND; }
  virtual int index_prev(byte * buf)
   { return  HA_ERR_WRONG_COMMAND; }
  virtual int index_first(byte * buf)
   { return  HA_ERR_WRONG_COMMAND; }
  virtual int index_last(byte * buf)
   { return  HA_ERR_WRONG_COMMAND; }
unknown's avatar
unknown committed
552
  virtual int index_next_same(byte *buf, const byte *key, uint keylen);
553
  virtual int index_read_last(byte * buf, const byte * key, uint key_len)
unknown's avatar
unknown committed
554
   { return (my_errno=HA_ERR_WRONG_COMMAND); }
unknown's avatar
unknown committed
555 556 557 558
  virtual int read_multi_range_first(KEY_MULTI_RANGE **found_range_p,
                                     KEY_MULTI_RANGE *ranges, uint range_count,
                                     bool sorted, HANDLER_BUFFER *buffer);
  virtual int read_multi_range_next(KEY_MULTI_RANGE **found_range_p);
559
  virtual int read_range_first(const key_range *start_key,
unknown's avatar
unknown committed
560 561 562
                               const key_range *end_key,
                               bool eq_range, bool sorted);
  virtual int read_range_next();
563
  int compare_key(key_range *range);
unknown's avatar
unknown committed
564
  virtual int ft_init() { return HA_ERR_WRONG_COMMAND; }
565
  void ft_end() { ft_handler=NULL; }
566
  virtual FT_INFO *ft_init_ext(uint flags, uint inx,String *key)
unknown's avatar
unknown committed
567
    { return NULL; }
unknown's avatar
unknown committed
568
  virtual int ft_read(byte *buf) { return HA_ERR_WRONG_COMMAND; }
unknown's avatar
unknown committed
569 570
  virtual int rnd_next(byte *buf)=0;
  virtual int rnd_pos(byte * buf, byte *pos)=0;
571
  virtual int read_first_row(byte *buf, uint primary_key);
unknown's avatar
unknown committed
572 573 574 575 576 577 578 579
  /*
    The following function is only needed for tables that may be temporary
    tables during joins
  */
  virtual int restart_rnd_next(byte *buf, byte *pos)
    { return HA_ERR_WRONG_COMMAND; }
  virtual int rnd_same(byte *buf, uint inx)
    { return HA_ERR_WRONG_COMMAND; }
unknown's avatar
unknown committed
580 581
  virtual ha_rows records_in_range(uint inx, key_range *min_key,
                                   key_range *max_key)
unknown's avatar
unknown committed
582 583 584
    { return (ha_rows) 10; }
  virtual void position(const byte *record)=0;
  virtual void info(uint)=0;
unknown's avatar
unknown committed
585 586
  virtual int extra(enum ha_extra_function operation)
  { return 0; }
unknown's avatar
unknown committed
587
  virtual int extra_opt(enum ha_extra_function operation, ulong cache_size)
unknown's avatar
unknown committed
588
  { return extra(operation); }
589
  virtual int reset() { return extra(HA_EXTRA_RESET); }
590
  virtual int external_lock(THD *thd, int lock_type) { return 0; }
unknown's avatar
unknown committed
591
  virtual void unlock_row() {}
unknown's avatar
unknown committed
592
  virtual int start_stmt(THD *thd) {return 0;}
unknown's avatar
unknown committed
593 594 595 596 597 598 599 600
  /*
    This is called to delete all rows in a table
    If the handler don't support this, then this function will
    return HA_ERR_WRONG_COMMAND and MySQL will delete the rows one
    by one.
  */
  virtual int delete_all_rows()
  { return (my_errno=HA_ERR_WRONG_COMMAND); }
601 602
  virtual ulonglong get_auto_increment();
  virtual void restore_auto_increment();
unknown's avatar
unknown committed
603
  virtual void update_create_info(HA_CREATE_INFO *create_info) {}
unknown's avatar
unknown committed
604 605 606 607 608 609

  /* admin commands - called from mysql_admin_table */
  virtual int check(THD* thd, HA_CHECK_OPT* check_opt)
  { return HA_ADMIN_NOT_IMPLEMENTED; }
  virtual int backup(THD* thd, HA_CHECK_OPT* check_opt)
  { return HA_ADMIN_NOT_IMPLEMENTED; }
610 611 612 613
  /*
    restore assumes .frm file must exist, and that generate_table() has been
    called; It will just copy the data file and run repair.
  */
unknown's avatar
unknown committed
614 615 616 617 618 619 620 621 622 623 624 625 626 627 628 629
  virtual int restore(THD* thd, HA_CHECK_OPT* check_opt)
  { return HA_ADMIN_NOT_IMPLEMENTED; }
  virtual int repair(THD* thd, HA_CHECK_OPT* check_opt)
  { return HA_ADMIN_NOT_IMPLEMENTED; }
  virtual int optimize(THD* thd, HA_CHECK_OPT* check_opt)
  { return HA_ADMIN_NOT_IMPLEMENTED; }
  virtual int analyze(THD* thd, HA_CHECK_OPT* check_opt)
  { return HA_ADMIN_NOT_IMPLEMENTED; }
  virtual int assign_to_keycache(THD* thd, HA_CHECK_OPT* check_opt)
  { return HA_ADMIN_NOT_IMPLEMENTED; }
  virtual int preload_keys(THD* thd, HA_CHECK_OPT* check_opt)
  { return HA_ADMIN_NOT_IMPLEMENTED; }
  /* end of the list of admin commands */

  virtual bool check_and_repair(THD *thd) { return HA_ERR_WRONG_COMMAND; }
  virtual int dump(THD* thd, int fd = -1) { return HA_ERR_WRONG_COMMAND; }
630 631 632
  virtual int disable_indexes(uint mode) { return HA_ERR_WRONG_COMMAND; }
  virtual int enable_indexes(uint mode) { return HA_ERR_WRONG_COMMAND; }
  virtual int indexes_are_disabled(void) {return 0;}
633 634
  virtual void start_bulk_insert(ha_rows rows) {}
  virtual int end_bulk_insert() {return 0; }
unknown's avatar
unknown committed
635 636 637
  virtual int discard_or_import_tablespace(my_bool discard)
  {return HA_ERR_WRONG_COMMAND;}
  virtual int net_read_dump(NET* net) { return HA_ERR_WRONG_COMMAND; }
638 639 640
  virtual char *update_table_comment(const char * comment)
  { return (char*) comment;}
  virtual void append_create_info(String *packet) {}
641 642
  virtual char* get_foreign_key_create_info()
  { return(NULL);}  /* gets foreign key create string from InnoDB */
unknown's avatar
unknown committed
643
  /* used in REPLACE; is > 0 if table is referred by a FOREIGN KEY */
644 645
  virtual int get_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list)
  { return 0; }
unknown's avatar
unknown committed
646
  virtual uint referenced_by_foreign_key() { return 0;}
unknown's avatar
unknown committed
647
  virtual void init_table_handle_for_HANDLER()
unknown's avatar
unknown committed
648 649
  { return; }       /* prepare InnoDB for HANDLER */
  virtual void free_foreign_key_create_info(char* str) {}
unknown's avatar
unknown committed
650 651 652
  /* The following can be called without an open handler */
  virtual const char *table_type() const =0;
  virtual const char **bas_ext() const =0;
653
  virtual ulong table_flags(void) const =0;
654
  virtual ulong index_flags(uint idx, uint part, bool all_parts) const =0;
655
  virtual ulong index_ddl_flags(KEY *wanted_index) const
unknown's avatar
unknown committed
656
  { return (HA_DDL_SUPPORT); }
657
  virtual int add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys)
unknown's avatar
unknown committed
658
  { return (HA_ERR_WRONG_COMMAND); }
659
  virtual int drop_index(TABLE *table_arg, uint *key_num, uint num_of_keys)
unknown's avatar
unknown committed
660 661 662 663 664 665 666 667 668 669
  { return (HA_ERR_WRONG_COMMAND); }

  uint max_record_length() const
  { return min(HA_MAX_REC_LENGTH, max_supported_record_length()); }
  uint max_keys() const
  { return min(MAX_KEY, max_supported_keys()); }
  uint max_key_parts() const
  { return min(MAX_REF_PARTS, max_supported_key_parts()); }
  uint max_key_length() const
  { return min(MAX_KEY_LENGTH, max_supported_key_length()); }
unknown's avatar
unknown committed
670
  uint max_key_part_length() const
unknown's avatar
unknown committed
671 672 673 674 675 676
  { return min(MAX_KEY_LENGTH, max_supported_key_part_length()); }

  virtual uint max_supported_record_length() const { return HA_MAX_REC_LENGTH; }
  virtual uint max_supported_keys() const { return 0; }
  virtual uint max_supported_key_parts() const { return MAX_REF_PARTS; }
  virtual uint max_supported_key_length() const { return MAX_KEY_LENGTH; }
677
  virtual uint max_supported_key_part_length() const { return 255; }
unknown's avatar
unknown committed
678
  virtual uint min_record_length(uint options) const { return 1; }
unknown's avatar
unknown committed
679

unknown's avatar
unknown committed
680
  virtual bool low_byte_first() const { return 1; }
unknown's avatar
unknown committed
681
  virtual uint checksum() const { return 0; }
682 683
  virtual bool is_crashed() const  { return 0; }
  virtual bool auto_repair() const { return 0; }
unknown's avatar
unknown committed
684

unknown's avatar
unknown committed
685 686 687 688
  /*
    default rename_table() and delete_table() rename/delete files with a
    given name and extensions from bas_ext()
  */
unknown's avatar
unknown committed
689 690
  virtual int rename_table(const char *from, const char *to);
  virtual int delete_table(const char *name);
unknown's avatar
unknown committed
691
  
unknown's avatar
unknown committed
692
  virtual int create(const char *name, TABLE *form, HA_CREATE_INFO *info)=0;
unknown's avatar
unknown committed
693 694

  /* lock_count() can be more than one if the table is a MERGE */
unknown's avatar
unknown committed
695 696 697 698
  virtual uint lock_count(void) const { return 1; }
  virtual THR_LOCK_DATA **store_lock(THD *thd,
				     THR_LOCK_DATA **to,
				     enum thr_lock_type lock_type)=0;
699 700 701

  /* Type of table for caching query */
  virtual uint8 table_cache_type() { return HA_CACHE_TBL_NONTRANSACT; }
702 703 704 705 706 707
  /* ask handler about permission to cache table when query is to be cached */
  virtual my_bool register_query_cache_table(THD *thd, char *table_key,
					     uint key_length,
					     qc_engine_callback 
					     *engine_callback,
					     ulonglong *engine_data)
unknown's avatar
unknown committed
708 709 710 711
  {
    *engine_callback= 0;
    return 1;
  }
unknown's avatar
unknown committed
712 713 714 715 716 717 718 719 720 721 722
 /*
  RETURN
    true  Primary key (if there is one) is clustered key covering all fields
    false otherwise
 */
 virtual bool primary_key_is_clustered() { return FALSE; }

 virtual int cmp_ref(const byte *ref1, const byte *ref2)
 {
   return memcmp(ref1, ref2, ref_length);
 }
unknown's avatar
Merge  
unknown committed
723 724 725 726
 
 /*
   Condition pushdown to storage engines
 */
727

728 729 730 731 732 733 734 735 736 737 738 739 740 741 742 743 744 745 746 747 748
 /*
   Push condition down to the table handler.
   SYNOPSIS
     cond_push()
     cond   Condition to be pushed. The condition tree must not be            
     modified by the by the caller.
   RETURN
     The 'remainder' condition that caller must use to filter out records.
     NULL means the handler will not return rows that do not match the
     passed condition.
   NOTES
   The pushed conditions form a stack (from which one can remove the
   last pushed condition using cond_pop).
   The table handler filters out rows using (pushed_cond1 AND pushed_cond2 
   AND ... AND pushed_condN)
   or less restrictive condition, depending on handler's capabilities.
   
   handler->extra(HA_EXTRA_RESET) call empties the condition stack.
   Calls to rnd_init/rnd_end, index_init/index_end etc do not affect the
   condition stack.
 */ 
unknown's avatar
Merge  
unknown committed
749
 virtual const COND *cond_push(const COND *cond) { return cond; };
750 751 752 753 754 755
 /*
   Pop the top condition from the condition stack of the handler instance.
   SYNOPSIS
     cond_pop()
     Pops the top if condition stack, if stack is not empty
 */
unknown's avatar
Merge  
unknown committed
756
 virtual void cond_pop() { return; };
unknown's avatar
unknown committed
757 758 759 760
};

	/* Some extern variables used with handlers */

761
extern struct show_table_type_st sys_table_types[];
unknown's avatar
unknown committed
762
extern const char *ha_row_type[];
763
extern TYPELIB tx_isolation_typelib;
764 765
extern handlerton *handlertons[MAX_HA];
extern ulong total_ha, total_ha_2pc;
unknown's avatar
unknown committed
766

767
	/* Wrapper functions */
768 769 770 771
#define ha_commit_stmt(thd) (ha_commit_trans((thd), FALSE))
#define ha_rollback_stmt(thd) (ha_rollback_trans((thd), FALSE))
#define ha_commit(thd) (ha_commit_trans((thd), TRUE))
#define ha_rollback(thd) (ha_rollback_trans((thd), TRUE))
772

773
#define ha_supports_generate(T) (T != DB_TYPE_INNODB && \
774 775
                                 T != DB_TYPE_BERKELEY_DB && \
                                 T != DB_TYPE_NDBCLUSTER)
776

777
/* lookups */
778
enum db_type ha_resolve_by_name(const char *name, uint namelen);
unknown's avatar
unknown committed
779
const char *ha_get_storage_engine(enum db_type db_type);
unknown's avatar
unknown committed
780
handler *get_new_handler(TABLE *table, enum db_type db_type);
781 782 783
enum db_type ha_checktype(enum db_type database_type);

/* basic stuff */
unknown's avatar
unknown committed
784
int ha_init(void);
785
TYPELIB *ha_known_exts(void);
unknown's avatar
unknown committed
786
int ha_panic(enum ha_panic_function flag);
787
int ha_update_statistics();
788
void ha_close_connection(THD* thd);
789 790
bool ha_flush_logs(void);
void ha_drop_database(char* path);
unknown's avatar
unknown committed
791 792
int ha_create_table(const char *name, HA_CREATE_INFO *create_info,
		    bool update_create_info);
793 794 795
int ha_delete_table(enum db_type db_type, const char *path);

/* discovery */
796 797
int ha_create_table_from_engine(THD* thd, const char *db, const char *name,
				bool create_if_found);
798 799 800 801 802 803 804
int ha_discover(THD* thd, const char* dbname, const char* name,
                const void** frmblob, uint* frmlen);
int ha_find_files(THD *thd,const char *db,const char *path,
                  const char *wild, bool dir,List<char>* files);
int ha_table_exists(THD* thd, const char* db, const char* name);

/* key cache */
unknown's avatar
unknown committed
805 806 807
int ha_init_key_cache(const char *name, KEY_CACHE *key_cache);
int ha_resize_key_cache(KEY_CACHE *key_cache);
int ha_change_key_cache_param(KEY_CACHE *key_cache);
808
int ha_change_key_cache(KEY_CACHE *old_key_cache, KEY_CACHE *new_key_cache);
unknown's avatar
unknown committed
809
int ha_end_key_cache(KEY_CACHE *key_cache);
810 811

/* weird stuff */
812
int ha_release_temporary_latches(THD *thd);
813 814 815 816 817 818 819 820 821 822 823

/* transactions: interface to handlerton functions */
int ha_start_consistent_snapshot(THD *thd);
int ha_commit_or_rollback_by_xid(LEX_STRING *ident, bool commit);
int ha_commit_one_phase(THD *thd, bool all);
int ha_rollback_trans(THD *thd, bool all);
int ha_prepare(THD *thd);
int ha_recover(HASH *commit_list);

/* transactions: these functions never call handlerton functions directly */
int ha_commit_trans(THD *thd, bool all);
unknown's avatar
unknown committed
824
int ha_autocommit_or_rollback(THD *thd, int error);
825
int ha_enable_transaction(THD *thd, bool on);
826 827 828 829 830 831 832
void trans_register_ha(THD *thd, bool all, handlerton *ht);

/* savepoints */
int ha_rollback_to_savepoint(THD *thd, SAVEPOINT *sv);
int ha_savepoint(THD *thd, SAVEPOINT *sv);
int ha_release_savepoint(THD *thd, SAVEPOINT *sv);