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

bk@work.mysql.com's avatar
bk@work.mysql.com 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

bk@work.mysql.com's avatar
bk@work.mysql.com 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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
13 14 15 16 17 18 19
   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 */

20
#ifdef USE_PRAGMA_INTERFACE
bk@work.mysql.com's avatar
bk@work.mysql.com committed
21 22 23
#pragma interface			/* gcc class implementation */
#endif

24
#include <ft_global.h>
25
#include <keycache.h>
26

bk@work.mysql.com's avatar
bk@work.mysql.com committed
27 28 29 30
#ifndef NO_HASH
#define NO_HASH				/* Not yet implemented */
#endif

31 32
#define USING_TRANSACTIONS

bk@work.mysql.com's avatar
bk@work.mysql.com committed
33 34
// the following is for checking tables

35 36 37 38 39 40
#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
41
#define HA_ADMIN_INVALID         -5
vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
42
#define HA_ADMIN_REJECT          -6
43
#define HA_ADMIN_TRY_ALTER       -7
44
#define HA_ADMIN_WRONG_CHECKSUM  -8
igor@rurik.mysql.com's avatar
igor@rurik.mysql.com committed
45
#define HA_ADMIN_NOT_BASE_TABLE  -9
46 47 48
#define HA_ADMIN_NEEDS_UPGRADE  -10
#define HA_ADMIN_NEEDS_ALTER    -11
#define HA_ADMIN_NEEDS_CHECK    -12
bk@work.mysql.com's avatar
bk@work.mysql.com committed
49

50
/* Bits in table_flags() to show what database can do */
51 52 53 54 55 56

/*
  Can switch index during the scan with ::rnd_same() - not used yet.
  see mi_rsame/heap_rsame/myrg_rsame
*/
#define HA_READ_RND_SAME       (1 << 0)
57 58
#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;
serg@serg.mylan's avatar
serg@serg.mylan committed
59
                                           It returns a position to ha_r_rnd */
60
#define HA_CAN_GEOMETRY        (1 << 4)
61 62 63 64 65 66
/*
  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
  filesort to decide if we should sort key + data or key + pointer-to-row
*/
#define HA_FAST_KEY_READ       (1 << 5)
67 68
#define HA_NULL_IN_KEY         (1 << 7) /* One can have keys with NULL */
#define HA_DUPP_POS            (1 << 8) /* ha_position() gives dup row */
serg@serg.mylan's avatar
serg@serg.mylan committed
69
#define HA_NO_BLOBS            (1 << 9) /* Doesn't support blobs */
70 71 72
#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 */
serg@serg.mylan's avatar
serg@serg.mylan committed
73
#define HA_NOT_EXACT_COUNT     (1 << 13)
74 75 76 77 78
/*
  INSERT_DELAYED only works with handlers that uses MySQL internal table
  level locks
*/
#define HA_CAN_INSERT_DELAYED  (1 << 14)
serg@serg.mylan's avatar
serg@serg.mylan committed
79
#define HA_PRIMARY_KEY_IN_READ_INDEX (1 << 15)
80 81 82 83 84 85 86
/*
  If HA_PRIMARY_KEY_ALLOW_RANDOM_ACCESS is set, it means that the engine can
  do this: the position of an arbitrary record can be retrieved using
  position() when the table has a primary key, effectively allowing random
  access on the table based on a given record.
*/ 
#define HA_PRIMARY_KEY_ALLOW_RANDOM_ACCESS (1 << 16) 
serg@serg.mylan's avatar
serg@serg.mylan committed
87 88 89 90 91 92
#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)
93
/* Table data are stored in separate files (for lower_case_table_names) */
monty@mysql.com's avatar
monty@mysql.com committed
94
#define HA_FILE_BASED	       (1 << 26)
95
#define HA_NO_VARCHAR	       (1 << 27)
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
96
#define HA_CAN_BIT_FIELD       (1 << 28) /* supports bit fields */
ingo@mysql.com's avatar
ingo@mysql.com committed
97
#define HA_NEED_READ_RANGE_BUFFER (1 << 29) /* for read_multi_range */
98
#define HA_ANY_INDEX_MAY_BE_UNIQUE (1 << 30)
99
#define HA_NO_COPY_ON_ALTER    (1 << 31)
monty@mysql.com's avatar
monty@mysql.com committed
100

101
/* bits in index_flags(index_number) for what you can do with index */
102 103 104 105
#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 */
106
#define HA_ONLY_WHOLE_INDEX	16	/* Can't use part key searches */
107
#define HA_KEYREAD_ONLY         64	/* Support HA_EXTRA_KEYREAD */
108

109 110 111
/*
  bits in alter_table_flags:
*/
112 113 114 115
/*
  These bits are set if different kinds of indexes can be created
  off-line without re-create of the table (but with a table lock).
*/
116 117 118 119 120 121
#define HA_ONLINE_ADD_INDEX_NO_WRITES           (1L << 0) /*add index w/lock*/
#define HA_ONLINE_DROP_INDEX_NO_WRITES          (1L << 1) /*drop index w/lock*/
#define HA_ONLINE_ADD_UNIQUE_INDEX_NO_WRITES    (1L << 2) /*add unique w/lock*/
#define HA_ONLINE_DROP_UNIQUE_INDEX_NO_WRITES   (1L << 3) /*drop uniq. w/lock*/
#define HA_ONLINE_ADD_PK_INDEX_NO_WRITES        (1L << 4) /*add prim. w/lock*/
#define HA_ONLINE_DROP_PK_INDEX_NO_WRITES       (1L << 5) /*drop prim. w/lock*/
122 123 124 125 126
/*
  These are set if different kinds of indexes can be created on-line
  (without a table lock). If a handler is capable of one or more of
  these, it should also set the corresponding *_NO_WRITES bit(s).
*/
127 128 129 130 131 132
#define HA_ONLINE_ADD_INDEX                     (1L << 6) /*add index online*/
#define HA_ONLINE_DROP_INDEX                    (1L << 7) /*drop index online*/
#define HA_ONLINE_ADD_UNIQUE_INDEX              (1L << 8) /*add unique online*/
#define HA_ONLINE_DROP_UNIQUE_INDEX             (1L << 9) /*drop uniq. online*/
#define HA_ONLINE_ADD_PK_INDEX                  (1L << 10)/*add prim. online*/
#define HA_ONLINE_DROP_PK_INDEX                 (1L << 11)/*drop prim. online*/
133

134 135 136 137 138 139
/*
  Index scan will not return records in rowid order. Not guaranteed to be
  set for unordered (e.g. HASH) indexes.
*/
#define HA_KEY_SCAN_NOT_ROR     128 

140 141 142 143 144 145
/* 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

146 147
/*
  Note: the following includes binlog and closing 0.
148 149 150
  so: innodb + bdb + ndb + binlog + myisam + myisammrg + archive +
      example + csv + heap + blackhole + federated + 0
  (yes, the sum is deliberately inaccurate)
151
*/
152
#define MAX_HA 15
153

154 155 156 157
/*
  Parameters for open() (in register form->filestat)
  HA_GET_INFO does an implicit HA_ABORT_IF_LOCKED
*/
bk@work.mysql.com's avatar
bk@work.mysql.com committed
158 159 160 161 162 163

#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 */
164 165
/* Try readonly if can't open with read and write */
#define HA_TRY_READ_ONLY	32
bk@work.mysql.com's avatar
bk@work.mysql.com committed
166 167 168 169 170
#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

171
	/* Errors on write which is recoverable  (Key exist) */
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
172
#define HA_WRITE_SKIP 121		/* Duplicate key on write */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
173 174 175 176 177 178 179 180 181 182 183 184 185
#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

186 187
/* Table caching type */
#define HA_CACHE_TBL_NONTRANSACT 0
188 189 190 191
#define HA_CACHE_TBL_NOCACHE     1
#define HA_CACHE_TBL_ASKTRANSACT 2
#define HA_CACHE_TBL_TRANSACT    4

192 193
/* Options of START TRANSACTION statement (and later of SET TRANSACTION stmt) */
#define MYSQL_START_TRANS_OPT_WITH_CONS_SNAPSHOT 1
194

195
enum legacy_db_type
196
{
197 198 199 200
  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,
201
  DB_TYPE_BERKELEY_DB, DB_TYPE_INNODB,
202
  DB_TYPE_GEMINI, DB_TYPE_NDBCLUSTER,
203
  DB_TYPE_EXAMPLE_DB, DB_TYPE_ARCHIVE_DB, DB_TYPE_CSV_DB,
204
  DB_TYPE_FEDERATED_DB,
205
  DB_TYPE_BLACKHOLE_DB,
206
  DB_TYPE_PARTITION_DB,
207
  DB_TYPE_BINLOG,
208
  DB_TYPE_DEFAULT=127 // Must be last
209
};
bk@work.mysql.com's avatar
bk@work.mysql.com committed
210

211
enum row_type { ROW_TYPE_NOT_USED=-1, ROW_TYPE_DEFAULT, ROW_TYPE_FIXED,
212 213
		ROW_TYPE_DYNAMIC, ROW_TYPE_COMPRESSED,
		ROW_TYPE_REDUNDANT, ROW_TYPE_COMPACT };
bk@work.mysql.com's avatar
bk@work.mysql.com committed
214

tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232
enum enum_binlog_func {
  BFN_RESET_LOGS=        1,
  BFN_RESET_SLAVE=       2,
  BFN_BINLOG_WAIT=       3,
  BFN_BINLOG_END=        4,
  BFN_BINLOG_PURGE_FILE= 5
};

enum enum_binlog_command {
  LOGCOM_CREATE_TABLE,
  LOGCOM_ALTER_TABLE,
  LOGCOM_RENAME_TABLE,
  LOGCOM_DROP_TABLE,
  LOGCOM_CREATE_DB,
  LOGCOM_ALTER_DB,
  LOGCOM_DROP_DB
};

bk@work.mysql.com's avatar
bk@work.mysql.com committed
233 234 235
/* struct to hold information about the table that should be created */

/* Bits in used_fields */
236
#define HA_CREATE_USED_AUTO             (1L << 0)
237
#define HA_CREATE_USED_RAID             (1L << 1) //RAID is no longer availble
238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253
#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)
254
#define HA_CREATE_USED_CONNECTION       (1L << 18)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
255

256
typedef ulonglong my_xid; // this line is the same as in log_event.h
257 258 259 260
#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))
261 262 263 264 265

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

266 267 268
#define COMPATIBLE_DATA_YES 0
#define COMPATIBLE_DATA_NO  1

269 270 271 272
struct xid_t {
  long formatID;
  long gtrid_length;
  long bqual_length;
273
  char data[XIDDATASIZE];  // not \0-terminated !
274

275
  xid_t() {}                                /* Remove gcc warning */  
serg@serg.mylan's avatar
serg@serg.mylan committed
276
  bool eq(struct xid_t *xid)
277
  { return eq(xid->gtrid_length, xid->bqual_length, xid->data); }
278 279
  bool eq(long g, long b, const char *d)
  { return g == gtrid_length && b == bqual_length && !memcmp(d, data, g+b); }
serg@serg.mylan's avatar
serg@serg.mylan committed
280
  void set(struct xid_t *xid)
281
  { memcpy(this, xid, xid->length()); }
serg@serg.mylan's avatar
serg@serg.mylan committed
282 283 284 285 286 287
  void set(long f, const char *g, long gl, const char *b, long bl)
  {
    formatID= f;
    memcpy(data, g, gtrid_length= gl);
    memcpy(data+gl, b, bqual_length= bl);
  }
288
  void set(ulonglong xid)
289
  {
290
    my_xid tmp;
serg@serg.mylan's avatar
serg@serg.mylan committed
291
    formatID= 1;
292
    set(MYSQL_XID_PREFIX_LEN, 0, MYSQL_XID_PREFIX);
293 294 295
    memcpy(data+MYSQL_XID_PREFIX_LEN, &server_id, sizeof(server_id));
    tmp= xid;
    memcpy(data+MYSQL_XID_OFFSET, &tmp, sizeof(tmp));
296 297 298 299
    gtrid_length=MYSQL_XID_GTRID_LEN;
  }
  void set(long g, long b, const char *d)
  {
serg@serg.mylan's avatar
serg@serg.mylan committed
300
    formatID= 1;
301 302 303 304 305 306 307 308
    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()
  {
309 310 311
    my_xid tmp;
    memcpy(&tmp, data+MYSQL_XID_OFFSET, sizeof(tmp));
    return tmp;
312 313 314 315
  }
  my_xid get_my_xid()
  {
    return gtrid_length == MYSQL_XID_GTRID_LEN && bqual_length == 0 &&
serg@serg.mylan's avatar
serg@serg.mylan committed
316
           !memcmp(data+MYSQL_XID_PREFIX_LEN, &server_id, sizeof(server_id)) &&
317 318 319
           !memcmp(data, MYSQL_XID_PREFIX, MYSQL_XID_PREFIX_LEN) ?
           quick_get_my_xid() : 0;
  }
320 321 322 323 324
  uint length()
  {
    return sizeof(formatID)+sizeof(gtrid_length)+sizeof(bqual_length)+
           gtrid_length+bqual_length;
  }
325 326 327 328 329 330 331 332
  byte *key()
  {
    return (byte *)&gtrid_length;
  }
  uint key_length()
  {
    return sizeof(gtrid_length)+sizeof(bqual_length)+gtrid_length+bqual_length;
  }
333
};
334 335
typedef struct xid_t XID;

336 337
/* for recover() handlerton call */
#define MIN_XID_LIST_SIZE  128
338 339 340
#ifdef SAFEMALLOC
#define MAX_XID_LIST_SIZE  256
#else
341
#define MAX_XID_LIST_SIZE  (1024*128)
342
#endif
343

344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419
/*
  These structures are used to pass information from a set of SQL commands
  on add/drop/change tablespace definitions to the proper hton.
*/
#define UNDEF_NODEGROUP 65535
enum ts_command_type
{
  TS_CMD_NOT_DEFINED = -1,
  CREATE_TABLESPACE = 0,
  ALTER_TABLESPACE = 1,
  CREATE_LOGFILE_GROUP = 2,
  ALTER_LOGFILE_GROUP = 3,
  DROP_TABLESPACE = 4,
  DROP_LOGFILE_GROUP = 5,
  CHANGE_FILE_TABLESPACE = 6,
  ALTER_ACCESS_MODE_TABLESPACE = 7
};

enum ts_alter_tablespace_type
{
  TS_ALTER_TABLESPACE_TYPE_NOT_DEFINED = -1,
  ALTER_TABLESPACE_ADD_FILE = 1,
  ALTER_TABLESPACE_DROP_FILE = 2
};

enum tablespace_access_mode
{
  TS_NOT_DEFINED= -1,
  TS_READ_ONLY = 0,
  TS_READ_WRITE = 1,
  TS_NOT_ACCESSIBLE = 2
};

class st_alter_tablespace : public Sql_alloc
{
  public:
  const char *tablespace_name;
  const char *logfile_group_name;
  enum ts_command_type ts_cmd_type;
  enum ts_alter_tablespace_type ts_alter_tablespace_type;
  const char *data_file_name;
  const char *undo_file_name;
  const char *redo_file_name;
  ulonglong extent_size;
  ulonglong undo_buffer_size;
  ulonglong redo_buffer_size;
  ulonglong initial_size;
  ulonglong autoextend_size;
  ulonglong max_size;
  uint nodegroup_id;
  enum legacy_db_type storage_engine;
  bool wait_until_completed;
  const char *ts_comment;
  enum tablespace_access_mode ts_access_mode;
  st_alter_tablespace()
  {
    tablespace_name= NULL;
    logfile_group_name= "DEFAULT_LG"; //Default log file group
    ts_cmd_type= TS_CMD_NOT_DEFINED;
    data_file_name= NULL;
    undo_file_name= NULL;
    redo_file_name= NULL;
    extent_size= 1024*1024;        //Default 1 MByte
    undo_buffer_size= 8*1024*1024; //Default 8 MByte
    redo_buffer_size= 8*1024*1024; //Default 8 MByte
    initial_size= 128*1024*1024;   //Default 128 MByte
    autoextend_size= 0;            //No autoextension as default
    max_size= 0;                   //Max size == initial size => no extension
    storage_engine= DB_TYPE_UNKNOWN;
    nodegroup_id= UNDEF_NODEGROUP;
    wait_until_completed= TRUE;
    ts_comment= NULL;
    ts_access_mode= TS_NOT_DEFINED;
  }
};

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

struct st_table;
typedef struct st_table TABLE;
424
typedef struct st_table_share TABLE_SHARE;
425 426
struct st_foreign_key_info;
typedef struct st_foreign_key_info FOREIGN_KEY_INFO;
427 428 429
typedef bool (stat_print_fn)(THD *thd, const char *type, uint type_len,
                             const char *file, uint file_len,
                             const char *status, uint status_len);
430 431
enum ha_stat_type { HA_ENGINE_STATUS, HA_ENGINE_LOGS, HA_ENGINE_MUTEX };

432 433
/*
  handlerton is a singleton structure - one instance per storage engine -
serg@serg.mylan's avatar
serg@serg.mylan committed
434 435
  to provide access to storage engine functionality that works on the
  "global" level (unlike handler class that works on a per-table basis)
436 437

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

439 440 441 442
  static handlerton { ... } xxx_hton;

  savepoint_*, prepare, recover, and *_by_xid pointers can be 0.
*/
443 444
typedef struct
{
445 446 447 448
  /*
    handlerton structure version
   */
  const int interface_version;
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
449 450
/* last version change: 0x0001 in 5.1.6 */
#define MYSQL_HANDLERTON_INTERFACE_VERSION 0x0001
451 452


serg@serg.mylan's avatar
serg@serg.mylan committed
453 454 455 456
  /*
    storage engine name as it should be printed to a user
  */
  const char *name;
457 458 459 460 461 462 463 464 465 466 467 468 469 470 471

  /*
    Historical marker for if the engine is available of not 
  */
  SHOW_COMP_OPTION state;

  /*
    A comment used by SHOW to describe an engine.
  */
  const char *comment;

  /*
    Historical number used for frm file to determine the correct storage engine.
    This is going away and new engines will just use "name" for this.
  */
472
  enum legacy_db_type db_type;
473 474 475 476 477
  /* 
    Method that initizlizes a storage engine
  */
  bool (*init)();

478 479 480 481 482 483 484 485 486
  /*
    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.
   */
487
   uint slot;
488 489 490 491 492 493 494 495 496
   /*
     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.
   */
497
   uint savepoint_offset;
498 499 500 501 502 503 504 505
   /*
     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
   */
506
   int  (*close_connection)(THD *thd);
507 508 509 510
   /*
     sv points to an uninitialized storage area of requested size
     (see savepoint_offset description)
   */
511
   int  (*savepoint_set)(THD *thd, void *sv);
512 513 514 515
   /*
     sv points to a storage area, that was earlier passed
     to the savepoint_set call
   */
516 517
   int  (*savepoint_rollback)(THD *thd, void *sv);
   int  (*savepoint_release)(THD *thd, void *sv);
518 519 520 521 522 523 524
   /*
     '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.
   */
525 526 527 528 529 530
   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);
531 532 533
   void *(*create_cursor_read_view)();
   void (*set_cursor_read_view)(void *);
   void (*close_cursor_read_view)(void *);
534
   handler *(*create)(TABLE_SHARE *table);
535 536 537 538 539
   void (*drop_database)(char* path);
   int (*panic)(enum ha_panic_function flag);
   int (*start_consistent_snapshot)(THD *thd);
   bool (*flush_logs)();
   bool (*show_status)(THD *thd, stat_print_fn *print, enum ha_stat_type stat);
540 541
   uint (*partition_flags)();
   uint (*alter_table_flags)(uint flags);
542
   int (*alter_tablespace)(THD *thd, st_alter_tablespace *ts_info);
543 544 545
   int (*fill_files_table)(THD *thd,
                           struct st_table_list *tables,
                           class Item *cond);
546
   uint32 flags;                                /* global handler flags */
547 548 549
   /*
      Those handlerton functions below are properly initialized at handler
      init.
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
550 551 552 553 554
   */
   int (*binlog_func)(THD *thd, enum_binlog_func fn, void *arg);
   void (*binlog_log_query)(THD *thd, enum_binlog_command binlog_command,
                            const char *query, uint query_length,
                            const char *db, const char *table_name);
555 556
} handlerton;

557 558
extern const handlerton default_hton;

559 560
struct show_table_alias_st {
  const char *alias;
561
  enum legacy_db_type type;
562 563
};

564
/* Possible flags of a handlerton */
565 566
#define HTON_NO_FLAGS                 0
#define HTON_CLOSE_CURSORS_AT_COMMIT (1 << 0)
567 568 569
#define HTON_ALTER_NOT_SUPPORTED     (1 << 1) //Engine does not support alter
#define HTON_CAN_RECREATE            (1 << 2) //Delete all is used fro truncate
#define HTON_HIDDEN                  (1 << 3) //Engine does not appear in lists
570 571
#define HTON_FLUSH_AFTER_RENAME      (1 << 4)
#define HTON_NOT_USER_SELECTABLE     (1 << 5)
572
#define HTON_TEMPORARY_NOT_SUPPORTED (1 << 6) //Having temporary tables not supported
573

574 575
typedef struct st_thd_trans
{
576
  /* number of entries in the ht[] */
577
  uint        nht;
578
  /* true is not all entries in the ht[] support 2pc */
579
  bool        no_2pc;
580
  /* storage engines that registered themselves for this transaction */
581 582 583
  handlerton *ht[MAX_HA];
} THD_TRANS;

monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
584 585 586
enum enum_tx_isolation { ISO_READ_UNCOMMITTED, ISO_READ_COMMITTED,
			 ISO_REPEATABLE_READ, ISO_SERIALIZABLE};

587

588 589
enum ndb_distribution { ND_KEYHASH= 0, ND_LINHASH= 1 };

590

591 592 593 594 595 596 597 598 599 600 601 602 603
typedef struct {
  ulonglong data_file_length;
  ulonglong max_data_file_length;
  ulonglong index_file_length;
  ulonglong delete_length;
  ha_rows records;
  ulong mean_rec_length;
  time_t create_time;
  time_t check_time;
  time_t update_time;
  ulonglong check_sum;
} PARTITION_INFO;

604 605 606 607 608
#define UNDEF_NODEGROUP 65535
class Item;

class partition_info;

609 610 611 612
struct st_partition_iter;
#define NOT_A_PARTITION_ID ((uint32)-1)


613

bk@work.mysql.com's avatar
bk@work.mysql.com committed
614 615
typedef struct st_ha_create_information
{
616
  CHARSET_INFO *table_charset, *default_table_charset;
617
  LEX_STRING connect_string;
618
  const char *comment,*password, *tablespace;
619 620
  const char *data_file_name, *index_file_name;
  const char *alias;
621 622 623 624
  ulonglong max_rows,min_rows;
  ulonglong auto_increment_value;
  ulong table_options;
  ulong avg_row_length;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
625
  ulong used_fields;
626
  SQL_LIST merge_list;
627
  handlerton *db_type;
628
  enum row_type row_type;
629
  uint null_bits;                       /* NULL bits at start of record */
630
  uint options;				/* OR of HA_CREATE_ options */
631
  uint merge_insert_method;
632
  uint extra_size;                      /* length of extra data segment */
633
  bool table_existed;			/* 1 in create if table existed */
634
  bool frm_only;                        /* 1 if no ha_create_table() */
635
  bool varchar;                         /* 1 if table has a VARCHAR */
636
  bool store_on_disk;                   /* 1 if table stored on disk */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
637 638 639 640
} HA_CREATE_INFO;



641 642 643
typedef struct st_savepoint SAVEPOINT;
extern ulong savepoint_alloc_size;

644
/* Forward declaration for condition pushdown to storage engine */
645
typedef class Item COND;
mskold@mysql.com's avatar
Merge  
mskold@mysql.com committed
646

bk@work.mysql.com's avatar
bk@work.mysql.com committed
647 648
typedef struct st_ha_check_opt
{
649
  st_ha_check_opt() {}                        /* Remove gcc warning */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
650
  ulong sort_buffer_size;
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
651 652
  uint flags;       /* isam layer flags (e.g. for myisamchk) */
  uint sql_flags;   /* sql layer flags - for something myisamchk cannot do */
653
  KEY_CACHE *key_cache;	/* new key cache when changing key cache */
654
  void init();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
655 656
} HA_CHECK_OPT;

657

658

ingo@mysql.com's avatar
ingo@mysql.com committed
659 660 661 662 663 664 665 666 667 668 669 670 671 672
/*
  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;

673 674
typedef struct system_status_var SSV;

675 676 677 678 679
/*
  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
 */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
680 681
class handler :public Sql_alloc
{
682 683
  friend class ha_partition;

bk@work.mysql.com's avatar
bk@work.mysql.com committed
684
 protected:
685 686
  struct st_table_share *table_share;   /* The table definition */
  struct st_table *table;               /* The current open table */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
687

688
  virtual int index_init(uint idx, bool sorted) { active_index=idx; return 0; }
689 690 691 692 693 694 695 696 697 698 699
  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; }

700 701 702
  void ha_statistic_increment(ulong SSV::*offset) const;


703 704
private:
  virtual int reset() { return extra(HA_EXTRA_RESET); }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
705
public:
706
  const handlerton *ht;                 /* storage engine of this handler */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
707 708 709 710 711 712 713 714
  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;
715 716 717
  ha_rows records;			/* Records in table */
  ha_rows deleted;			/* Deleted records */
  ulong mean_rec_length;		/* physical reclength */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
718 719 720
  time_t create_time;			/* When table was created */
  time_t check_time;
  time_t update_time;
721

ingo@mysql.com's avatar
ingo@mysql.com committed
722 723 724 725 726 727
  /* 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;

728 729 730 731
  /* 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;
732
  bool eq_range;
733

734 735 736 737 738 739
  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 */
740
  FT_INFO *ft_handler;
741
  enum {NONE=0, INDEX, RND} inited;
742
  bool  auto_increment_column_changed;
743
  bool implicit_emptied;                /* Can be !=0 only if HEAP */
744
  const COND *pushed_cond;
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
745 746
  MY_BITMAP *read_set;
  MY_BITMAP *write_set;
747

748 749
  handler(const handlerton *ht_arg, TABLE_SHARE *share_arg)
    :table_share(share_arg), ht(ht_arg),
750 751 752 753
    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),
754
    key_used_on_scan(MAX_KEY), active_index(MAX_KEY),
755
    ref_length(sizeof(my_off_t)), block_size(0),
756
    ft_handler(0), inited(NONE), implicit_emptied(0),
757
    pushed_cond(NULL)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
758
    {}
759 760 761 762
  virtual ~handler(void)
  {
    /* TODO: DBUG_ASSERT(inited == NONE); */
  }
763 764 765 766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782
  /*
    Check whether a handler allows to lock the table.

    SYNOPSIS
      check_if_locking_is_allowed()
        thd     Handler of the thread, trying to lock the table
        table   Table handler to check
        count   Number of locks already granted to the table

    DESCRIPTION
      Check whether a handler allows to lock the table. For instance,
      MyISAM does not allow to lock mysql.proc along with other tables.
      This limitation stems from the fact that MyISAM does not support
      row-level locking and we have to add this limitation to avoid
      deadlocks.

    RETURN
      TRUE      Locking is allowed
      FALSE     Locking is not allowed. The error was thrown.
  */
783 784 785 786
  virtual bool check_if_locking_is_allowed(uint sql_command,
                                           ulong type, TABLE *table,
                                           uint count,
                                           bool called_by_logger_thread)
787 788 789
  {
    return TRUE;
  }
790
  virtual int ha_initialise();
791
  int ha_open(TABLE *table, const char *name, int mode, int test_if_locked);
792
  bool update_auto_increment();
793
  virtual void print_error(int error, myf errflag);
794
  virtual bool get_error_message(int error, String *buf);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
795
  uint get_dup_key(int error);
796 797 798 799 800
  void change_table_ptr(TABLE *table_arg, TABLE_SHARE *share)
  {
    table= table_arg;
    table_share= share;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
801
  virtual double scan_time()
802
    { return ulonglong2double(data_file_length) / IO_SIZE + 2; }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
803 804
  virtual double read_time(uint index, uint ranges, ha_rows rows)
 { return rows2double(ranges+rows); }
serg@serg.mylan's avatar
serg@serg.mylan committed
805
  virtual const key_map *keys_to_use_for_scanning() { return &key_map_empty; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
806
  virtual bool has_transactions(){ return 0;}
807
  virtual uint extra_rec_buf_length() const { return 0; }
sergefp@mysql.com's avatar
sergefp@mysql.com committed
808 809 810 811 812 813 814 815 816
  
  /*
    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; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
817

818 819 820 821 822 823
  /*
    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; }

824 825
  virtual const char *index_type(uint key_number) { DBUG_ASSERT(0); return "";}

826
  int ha_index_init(uint idx, bool sorted)
827
  {
monty@mysql.com's avatar
monty@mysql.com committed
828
    DBUG_ENTER("ha_index_init");
829 830
    DBUG_ASSERT(inited==NONE);
    inited=INDEX;
831
    DBUG_RETURN(index_init(idx, sorted));
832 833 834
  }
  int ha_index_end()
  {
monty@mysql.com's avatar
monty@mysql.com committed
835
    DBUG_ENTER("ha_index_end");
836 837
    DBUG_ASSERT(inited==INDEX);
    inited=NONE;
monty@mysql.com's avatar
monty@mysql.com committed
838
    DBUG_RETURN(index_end());
839
  }
840
  int ha_rnd_init(bool scan)
841
  {
monty@mysql.com's avatar
monty@mysql.com committed
842
    DBUG_ENTER("ha_rnd_init");
843 844
    DBUG_ASSERT(inited==NONE || (inited==RND && scan));
    inited=RND;
monty@mysql.com's avatar
monty@mysql.com committed
845
    DBUG_RETURN(rnd_init(scan));
846 847 848
  }
  int ha_rnd_end()
  {
monty@mysql.com's avatar
monty@mysql.com committed
849
    DBUG_ENTER("ha_rnd_end");
850 851
    DBUG_ASSERT(inited==RND);
    inited=NONE;
monty@mysql.com's avatar
monty@mysql.com committed
852
    DBUG_RETURN(rnd_end());
853
  }
854 855 856 857 858 859 860
  int ha_reset()
  {
    DBUG_ENTER("ha_reset");
    ha_clear_all_set();
    DBUG_RETURN(reset());
  }
    
monty@mysql.com's avatar
monty@mysql.com committed
861
  /* this is necessary in many places, e.g. in HANDLER command */
862 863 864 865
  int ha_index_or_rnd_end()
  {
    return inited == INDEX ? ha_index_end() : inited == RND ? ha_rnd_end() : 0;
  }
866 867 868 869 870 871 872 873 874 875 876 877
  /*
    These are a set of routines used to enable handlers to only read/write
    partial lists of the fields in the table. The bit vector is maintained
    by the server part and is used by the handler at calls to read/write
    data in the table.
    It replaces the use of query id's for this purpose. The benefit is that
    the handler can also set bits in the read/write set if it has special
    needs and it is also easy for other parts of the server to interact
    with the handler (e.g. the replication part for row-level logging).
    The routines are all part of the general handler and are not possible
    to override by a handler. A handler can however set/reset bits by
    calling these routines.
878 879 880 881 882 883

    The methods ha_retrieve_all_cols and ha_retrieve_all_pk are made
    virtual to handle InnoDB specifics. If InnoDB doesn't need the
    extra parameters HA_EXTRA_RETRIEVE_ALL_COLS and
    HA_EXTRA_RETRIEVE_PRIMARY_KEY anymore then these methods need not be
    virtual anymore.
884
  */
885 886
  virtual int ha_retrieve_all_cols();
  virtual int ha_retrieve_all_pk();
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
887 888 889 890 891 892 893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955 956 957 958 959 960 961 962 963 964 965 966 967 968 969 970 971 972 973 974 975 976 977 978 979 980 981 982 983
  void ha_set_all_bits_in_read_set()
  {
    DBUG_ENTER("ha_set_all_bits_in_read_set");
    bitmap_set_all(read_set);
    DBUG_VOID_RETURN;
  }
  void ha_set_all_bits_in_write_set()
  {
    DBUG_ENTER("ha_set_all_bits_in_write_set");
    bitmap_set_all(write_set);
    DBUG_VOID_RETURN;
  }
  void ha_set_bit_in_read_set(uint fieldnr)
  {
    DBUG_ENTER("ha_set_bit_in_read_set");
    DBUG_PRINT("info", ("fieldnr = %d", fieldnr));
    bitmap_set_bit(read_set, fieldnr);
    DBUG_VOID_RETURN;
  }
  void ha_clear_bit_in_read_set(uint fieldnr)
  {
    DBUG_ENTER("ha_clear_bit_in_read_set");
    DBUG_PRINT("info", ("fieldnr = %d", fieldnr));
    bitmap_clear_bit(read_set, fieldnr);
    DBUG_VOID_RETURN;
  }
  void ha_set_bit_in_write_set(uint fieldnr)
  {
    DBUG_ENTER("ha_set_bit_in_write_set");
    DBUG_PRINT("info", ("fieldnr = %d", fieldnr));
    bitmap_set_bit(write_set, fieldnr);
    DBUG_VOID_RETURN;
  }
  void ha_clear_bit_in_write_set(uint fieldnr)
  {
    DBUG_ENTER("ha_clear_bit_in_write_set");
    DBUG_PRINT("info", ("fieldnr = %d", fieldnr));
    bitmap_clear_bit(write_set, fieldnr);
    DBUG_VOID_RETURN;
  }
  void ha_set_bit_in_rw_set(uint fieldnr, bool write_op)
  {
    DBUG_ENTER("ha_set_bit_in_rw_set");
    DBUG_PRINT("info", ("Set bit %u in read set", fieldnr));
    bitmap_set_bit(read_set, fieldnr);
    if (!write_op) {
      DBUG_VOID_RETURN;
    }
    else
    {
      DBUG_PRINT("info", ("Set bit %u in read and write set", fieldnr));
      bitmap_set_bit(write_set, fieldnr);
    }
    DBUG_VOID_RETURN;
  }
  bool ha_get_bit_in_read_set(uint fieldnr)
  {
    bool bit_set=bitmap_is_set(read_set,fieldnr);
    DBUG_ENTER("ha_get_bit_in_read_set");
    DBUG_PRINT("info", ("bit %u = %u", fieldnr, bit_set));
    DBUG_RETURN(bit_set);
  }
  bool ha_get_bit_in_write_set(uint fieldnr)
  {
    bool bit_set=bitmap_is_set(write_set,fieldnr);
    DBUG_ENTER("ha_get_bit_in_write_set");
    DBUG_PRINT("info", ("bit %u = %u", fieldnr, bit_set));
    DBUG_RETURN(bit_set);
  }
  bool ha_get_all_bit_in_read_set()
  {
    bool all_bits_set= bitmap_is_set_all(read_set);
    DBUG_ENTER("ha_get_all_bit_in_read_set");
    DBUG_PRINT("info", ("all bits set = %u", all_bits_set));
    DBUG_RETURN(all_bits_set);
  }
  bool ha_get_all_bit_in_read_clear()
  {
    bool all_bits_set= bitmap_is_clear_all(read_set);
    DBUG_ENTER("ha_get_all_bit_in_read_clear");
    DBUG_PRINT("info", ("all bits clear = %u", all_bits_set));
    DBUG_RETURN(all_bits_set);
  }
  bool ha_get_all_bit_in_write_set()
  {
    bool all_bits_set= bitmap_is_set_all(write_set);
    DBUG_ENTER("ha_get_all_bit_in_write_set");
    DBUG_PRINT("info", ("all bits set = %u", all_bits_set));
    DBUG_RETURN(all_bits_set);
  }
  bool ha_get_all_bit_in_write_clear()
  {
    bool all_bits_set= bitmap_is_clear_all(write_set);
    DBUG_ENTER("ha_get_all_bit_in_write_clear");
    DBUG_PRINT("info", ("all bits clear = %u", all_bits_set));
    DBUG_RETURN(all_bits_set);
  }
984 985
  void ha_set_primary_key_in_read_set();
  int ha_allocate_read_write_set(ulong no_fields);
986
  void ha_clear_all_set();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
987
  uint get_index(void) const { return active_index; }
988
  virtual int open(const char *name, int mode, uint test_if_locked)=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
989
  virtual int close(void)=0;
990 991 992
  virtual int ha_write_row(byte * buf);
  virtual int ha_update_row(const byte * old_data, byte * new_data);
  virtual int ha_delete_row(const byte * buf);
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
993 994 995 996 997 998
  /*
    If the handler does it's own injection of the rows, this member function
    should return 'true'.
  */
  virtual bool is_injective() const { return false; }
  
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
999 1000 1001 1002 1003 1004 1005 1006 1007 1008 1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029
  /*
    SYNOPSIS
      start_bulk_update()
    RETURN
      0   Bulk update used by handler
      1   Bulk update not used, normal operation used
  */
  virtual bool start_bulk_update() { return 1; }
  /*
    SYNOPSIS
      start_bulk_delete()
    RETURN
      0   Bulk delete used by handler
      1   Bulk delete not used, normal operation used
  */
  virtual bool start_bulk_delete() { return 1; }
  /*
    SYNOPSIS
    This method is similar to update_row, however the handler doesn't need
    to execute the updates at this point in time. The handler can be certain
    that another call to bulk_update_row will occur OR a call to
    exec_bulk_update before the set of updates in this query is concluded.

      bulk_update_row()
        old_data       Old record
        new_data       New record
        dup_key_found  Number of duplicate keys found
    RETURN
      0   Bulk delete used by handler
      1   Bulk delete not used, normal operation used
  */
mronstrom@mysql.com[mikron]'s avatar
mronstrom@mysql.com[mikron] committed
1030 1031 1032 1033 1034 1035
  virtual int bulk_update_row(const byte *old_data, byte *new_data,
                              uint *dup_key_found)
  {
    DBUG_ASSERT(FALSE);
    return HA_ERR_WRONG_COMMAND;
  }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048
  /*
    SYNOPSIS
    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.

      exec_bulk_update()
        dup_key_found       Number of duplicate keys found
    RETURN
      0           Success
      >0          Error code
  */
mronstrom@mysql.com[mikron]'s avatar
mronstrom@mysql.com[mikron] committed
1049 1050 1051 1052 1053
  virtual int exec_bulk_update(uint *dup_key_found)
  {
    DBUG_ASSERT(FALSE);
    return HA_ERR_WRONG_COMMAND;
  }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
1054 1055 1056 1057 1058 1059 1060 1061 1062
  /*
    SYNOPSIS
    Perform any needed clean-up, no outstanding updates are there at the
    moment.

      end_bulk_update()
    RETURN
      Nothing
  */
mronstrom@mysql.com[mikron]'s avatar
mronstrom@mysql.com[mikron] committed
1063
  virtual void end_bulk_update() { return; }
mronstrom@mysql.com's avatar
mronstrom@mysql.com committed
1064 1065 1066 1067 1068 1069 1070 1071 1072
  /*
    SYNOPSIS
    Execute all outstanding deletes and close down the bulk delete.

      end_bulk_delete()
    RETURN
    0             Success
    >0            Error code
  */
mronstrom@mysql.com[mikron]'s avatar
mronstrom@mysql.com[mikron] committed
1073 1074 1075 1076 1077
  virtual int end_bulk_delete()
  {
    DBUG_ASSERT(FALSE);
    return HA_ERR_WRONG_COMMAND;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1078
  virtual int index_read(byte * buf, const byte * key,
1079 1080
			 uint key_len, enum ha_rkey_function find_flag)
   { return  HA_ERR_WRONG_COMMAND; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1081
  virtual int index_read_idx(byte * buf, uint index, const byte * key,
1082 1083 1084 1085 1086 1087 1088 1089 1090
			     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; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1091
  virtual int index_next_same(byte *buf, const byte *key, uint keylen);
1092
  virtual int index_read_last(byte * buf, const byte * key, uint key_len)
1093
   { return (my_errno=HA_ERR_WRONG_COMMAND); }
ingo@mysql.com's avatar
ingo@mysql.com committed
1094 1095 1096 1097
  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);
1098
  virtual int read_range_first(const key_range *start_key,
1099 1100 1101
                               const key_range *end_key,
                               bool eq_range, bool sorted);
  virtual int read_range_next();
1102
  int compare_key(key_range *range);
1103
  virtual int ft_init() { return HA_ERR_WRONG_COMMAND; }
1104
  void ft_end() { ft_handler=NULL; }
1105
  virtual FT_INFO *ft_init_ext(uint flags, uint inx,String *key)
1106
    { return NULL; }
1107
  virtual int ft_read(byte *buf) { return HA_ERR_WRONG_COMMAND; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1108 1109
  virtual int rnd_next(byte *buf)=0;
  virtual int rnd_pos(byte * buf, byte *pos)=0;
1110
  virtual int read_first_row(byte *buf, uint primary_key);
1111 1112 1113 1114 1115 1116 1117 1118
  /*
    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; }
1119 1120
  virtual ha_rows records_in_range(uint inx, key_range *min_key,
                                   key_range *max_key)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1121 1122
    { return (ha_rows) 10; }
  virtual void position(const byte *record)=0;
1123
  virtual void info(uint)=0; // see my_base.h for full description
1124 1125
  virtual void get_dynamic_partition_info(PARTITION_INFO *stat_info,
                                          uint part_id);
1126 1127
  virtual int extra(enum ha_extra_function operation)
  { return 0; }
1128
  virtual int extra_opt(enum ha_extra_function operation, ulong cache_size)
1129
  { return extra(operation); }
1130
  virtual int external_lock(THD *thd, int lock_type) { return 0; }
1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150
  /*
    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) {}
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
1151
  virtual void unlock_row() {}
serg@serg.mylan's avatar
serg@serg.mylan committed
1152
  virtual int start_stmt(THD *thd, thr_lock_type lock_type) {return 0;}
1153 1154 1155 1156 1157 1158 1159 1160
  /*
    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); }
1161 1162
  virtual ulonglong get_auto_increment();
  virtual void restore_auto_increment();
1163

osku@127.(none)'s avatar
osku@127.(none) committed
1164 1165 1166 1167 1168 1169 1170
  /*
    Reset the auto-increment counter to the given value, i.e. the next row
    inserted will get the given value. This is called e.g. after TRUNCATE
    is emulated by doing a 'DELETE FROM t'. HA_ERR_WRONG_COMMAND is
    returned by storage engines that don't support this operation.
  */
  virtual int reset_auto_increment(ulonglong value)
1171 1172
  { return HA_ERR_WRONG_COMMAND; }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1173
  virtual void update_create_info(HA_CREATE_INFO *create_info) {}
1174 1175
protected:
  /* to be implemented in handlers */
1176 1177 1178 1179

  /* admin commands - called from mysql_admin_table */
  virtual int check(THD* thd, HA_CHECK_OPT* check_opt)
  { return HA_ADMIN_NOT_IMPLEMENTED; }
1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193

  /*
     in these two methods check_opt can be modified
     to specify CHECK option to use to call check()
     upon the table
  */
  virtual int check_for_upgrade(HA_CHECK_OPT *check_opt)
  { return 0; }
public:
  int ha_check_for_upgrade(HA_CHECK_OPT *check_opt);
  int check_old_types();
  /* to be actually called to get 'check()' functionality*/
  int ha_check(THD *thd, HA_CHECK_OPT *check_opt);
   
1194 1195
  virtual int backup(THD* thd, HA_CHECK_OPT* check_opt)
  { return HA_ADMIN_NOT_IMPLEMENTED; }
1196 1197 1198 1199
  /*
    restore assumes .frm file must exist, and that generate_table() has been
    called; It will just copy the data file and run repair.
  */
1200 1201
  virtual int restore(THD* thd, HA_CHECK_OPT* check_opt)
  { return HA_ADMIN_NOT_IMPLEMENTED; }
1202
protected:
1203 1204
  virtual int repair(THD* thd, HA_CHECK_OPT* check_opt)
  { return HA_ADMIN_NOT_IMPLEMENTED; }
1205 1206
public:
  int ha_repair(THD* thd, HA_CHECK_OPT* check_opt);
1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218
  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; }
1219 1220 1221
  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;}
1222 1223
  virtual void start_bulk_insert(ha_rows rows) {}
  virtual int end_bulk_insert() {return 0; }
1224 1225 1226
  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; }
1227 1228 1229
  virtual char *update_table_comment(const char * comment)
  { return (char*) comment;}
  virtual void append_create_info(String *packet) {}
1230 1231 1232 1233 1234 1235 1236 1237 1238 1239 1240 1241 1242 1243
  /*
    SYNOPSIS
      is_fk_defined_on_table_or_index()
      index            Index to check if foreign key uses it
    RETURN VALUE
       TRUE            Foreign key defined on table or index
       FALSE           No foreign key defined
    DESCRIPTION
      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).
  */
  virtual bool is_fk_defined_on_table_or_index(uint index)
  { return FALSE; }
1244 1245
  virtual char* get_foreign_key_create_info()
  { return(NULL);}  /* gets foreign key create string from InnoDB */
1246
  virtual char* get_tablespace_name(THD *thd)
1247
  { return(NULL);}  /* gets tablespace name from handler */
1248 1249
  /* used in ALTER TABLE; 1 if changing storage engine is allowed */
  virtual bool can_switch_engines() { return 1; }
monty@mysql.com's avatar
monty@mysql.com committed
1250
  /* used in REPLACE; is > 0 if table is referred by a FOREIGN KEY */
1251 1252
  virtual int get_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list)
  { return 0; }
monty@mysql.com's avatar
monty@mysql.com committed
1253
  virtual uint referenced_by_foreign_key() { return 0;}
1254
  virtual void init_table_handle_for_HANDLER()
serg@serg.mylan's avatar
serg@serg.mylan committed
1255 1256
  { return; }       /* prepare InnoDB for HANDLER */
  virtual void free_foreign_key_create_info(char* str) {}
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1257 1258 1259
  /* The following can be called without an open handler */
  virtual const char *table_type() const =0;
  virtual const char **bas_ext() const =0;
1260
  virtual ulong table_flags(void) const =0;
1261

1262
  virtual int get_default_no_partitions(ulonglong max_rows) { return 1;}
1263 1264 1265 1266 1267 1268 1269 1270
  virtual void set_auto_partitions(partition_info *part_info) { return; }
  virtual bool get_no_parts(const char *name,
                            uint *no_parts)
  {
    *no_parts= 0;
    return 0;
  }
  virtual void set_part_info(partition_info *part_info) {return;}
1271

1272
  virtual ulong index_flags(uint idx, uint part, bool all_parts) const =0;
1273

1274
  virtual int add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys)
1275
  { return (HA_ERR_WRONG_COMMAND); }
1276 1277 1278 1279
  virtual int prepare_drop_index(TABLE *table_arg, uint *key_num,
                                 uint num_of_keys)
  { return (HA_ERR_WRONG_COMMAND); }
  virtual int final_drop_index(TABLE *table_arg)
1280 1281 1282 1283 1284 1285 1286 1287 1288 1289
  { 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()); }
1290
  uint max_key_part_length() const
1291 1292 1293 1294 1295 1296
  { 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; }
1297
  virtual uint max_supported_key_part_length() const { return 255; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1298
  virtual uint min_record_length(uint options) const { return 1; }
1299

bk@work.mysql.com's avatar
bk@work.mysql.com committed
1300
  virtual bool low_byte_first() const { return 1; }
serg@serg.mylan's avatar
serg@serg.mylan committed
1301
  virtual uint checksum() const { return 0; }
1302 1303
  virtual bool is_crashed() const  { return 0; }
  virtual bool auto_repair() const { return 0; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1304

1305 1306 1307 1308
  /*
    default rename_table() and delete_table() rename/delete files with a
    given name and extensions from bas_ext()
  */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1309 1310
  virtual int rename_table(const char *from, const char *to);
  virtual int delete_table(const char *name);
1311
  virtual void drop_table(const char *name);
1312
  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1313
  virtual int create(const char *name, TABLE *form, HA_CREATE_INFO *info)=0;
1314
  virtual int create_handler_files(const char *name) { return FALSE;}
1315

1316 1317 1318 1319 1320 1321 1322
  virtual int change_partitions(HA_CREATE_INFO *create_info,
                                const char *path,
                                ulonglong *copied,
                                ulonglong *deleted,
                                const void *pack_frm_data,
                                uint pack_frm_len)
  { return HA_ERR_WRONG_COMMAND; }
1323 1324
  virtual int drop_partitions(const char *path)
  { return HA_ERR_WRONG_COMMAND; }
1325 1326 1327 1328 1329 1330 1331 1332 1333 1334 1335
  virtual int rename_partitions(const char *path)
  { return HA_ERR_WRONG_COMMAND; }
  virtual int optimize_partitions(THD *thd)
  { return HA_ERR_WRONG_COMMAND; }
  virtual int analyze_partitions(THD *thd)
  { return HA_ERR_WRONG_COMMAND; }
  virtual int check_partitions(THD *thd)
  { return HA_ERR_WRONG_COMMAND; }
  virtual int repair_partitions(THD *thd)
  { return HA_ERR_WRONG_COMMAND; }

1336
  /* lock_count() can be more than one if the table is a MERGE */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1337 1338 1339 1340
  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;
1341 1342 1343

  /* Type of table for caching query */
  virtual uint8 table_cache_type() { return HA_CACHE_TBL_NONTRANSACT; }
1344 1345 1346 1347 1348 1349
  /* 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)
1350 1351 1352 1353
  {
    *engine_callback= 0;
    return 1;
  }
monty@mysql.com's avatar
monty@mysql.com committed
1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364
 /*
  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);
 }
mskold@mysql.com's avatar
Merge  
mskold@mysql.com committed
1365 1366 1367 1368
 
 /*
   Condition pushdown to storage engines
 */
1369

1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382 1383 1384 1385 1386 1387 1388 1389 1390
 /*
   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.
 */ 
mskold@mysql.com's avatar
Merge  
mskold@mysql.com committed
1391
 virtual const COND *cond_push(const COND *cond) { return cond; };
1392 1393 1394 1395 1396 1397
 /*
   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
 */
mskold@mysql.com's avatar
Merge  
mskold@mysql.com committed
1398
 virtual void cond_pop() { return; };
1399 1400 1401
 virtual bool check_if_incompatible_data(HA_CREATE_INFO *create_info,
					 uint table_changes)
 { return COMPATIBLE_DATA_NO; }
1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426

private:

  /*
    Row-level primitives for storage engines. 
    These should be overridden by the storage engine class. To call
    these methods, use the corresponding 'ha_*' method above.
  */
  friend int ndb_add_binlog_index(THD *, void *);

  virtual int write_row(byte *buf __attribute__((unused))) 
  { 
    return HA_ERR_WRONG_COMMAND; 
  }

  virtual int update_row(const byte *old_data __attribute__((unused)),
                         byte *new_data __attribute__((unused)))
  { 
    return HA_ERR_WRONG_COMMAND; 
  }

  virtual int delete_row(const byte *buf __attribute__((unused)))
  { 
    return HA_ERR_WRONG_COMMAND; 
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1427 1428 1429 1430
};

	/* Some extern variables used with handlers */

1431
extern handlerton *sys_table_types[];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1432
extern const char *ha_row_type[];
1433
extern TYPELIB tx_isolation_typelib;
1434
extern TYPELIB myisam_stats_method_typelib;
1435
extern ulong total_ha, total_ha_2pc;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1436

1437
	/* Wrapper functions */
1438 1439 1440 1441
#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))
1442

1443
/* lookups */
1444 1445 1446
handlerton *ha_resolve_by_name(THD *thd, LEX_STRING *name);
handlerton *ha_resolve_by_legacy_type(THD *thd, enum legacy_db_type db_type);
const char *ha_get_storage_engine(enum legacy_db_type db_type);
1447
handler *get_new_handler(TABLE_SHARE *share, MEM_ROOT *alloc,
1448 1449
                         handlerton *db_type);
handlerton *ha_checktype(THD *thd, enum legacy_db_type database_type,
1450
                          bool no_substitute, bool report_error);
1451 1452


serg@serg.mylan's avatar
serg@serg.mylan committed
1453
static inline enum legacy_db_type ha_legacy_type(const handlerton *db_type)
1454 1455 1456 1457
{
  return (db_type == NULL) ? DB_TYPE_UNKNOWN : db_type->db_type;
}

serg@serg.mylan's avatar
serg@serg.mylan committed
1458
static inline const char *ha_resolve_storage_engine_name(const handlerton *db_type)
1459 1460 1461 1462
{
  return db_type == NULL ? "UNKNOWN" : db_type->name;
}

serg@serg.mylan's avatar
serg@serg.mylan committed
1463
static inline bool ha_check_storage_engine_flag(const handlerton *db_type, uint32 flag)
1464 1465 1466 1467
{
  return db_type == NULL ? FALSE : test(db_type->flags & flag);
}

serg@serg.mylan's avatar
serg@serg.mylan committed
1468
static inline bool ha_storage_engine_is_enabled(const handlerton *db_type)
1469
{
1470
  return (db_type && db_type->create) ?
1471 1472
         (db_type->state == SHOW_OPTION_YES) : FALSE;
}
1473 1474

/* basic stuff */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1475
int ha_init(void);
1476 1477 1478
int ha_register_builtin_plugins();
int ha_initialize_handlerton(handlerton *hton);

1479
TYPELIB *ha_known_exts(void);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1480
int ha_panic(enum ha_panic_function flag);
1481
void ha_close_connection(THD* thd);
1482
bool ha_flush_logs(handlerton *db_type);
1483
void ha_drop_database(char* path);
1484 1485 1486
int ha_create_table(THD *thd, const char *path,
                    const char *db, const char *table_name,
                    HA_CREATE_INFO *create_info,
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1487
		    bool update_create_info);
1488
int ha_delete_table(THD *thd, handlerton *db_type, const char *path,
1489
                    const char *db, const char *alias, bool generate_warning);
1490

1491
/* statistics and info */
1492
bool ha_show_status(THD *thd, handlerton *db_type, enum ha_stat_type stat);
1493

1494
/* discovery */
1495
int ha_create_table_from_engine(THD* thd, const char *db, const char *name);
1496 1497 1498 1499
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);
1500
int ha_table_exists_in_engine(THD* thd, const char* db, const char* name);
1501 1502

/* key cache */
1503 1504 1505
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);
1506
int ha_change_key_cache(KEY_CACHE *old_key_cache, KEY_CACHE *new_key_cache);
1507
int ha_end_key_cache(KEY_CACHE *key_cache);
1508

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1509
/* report to InnoDB that control passes to the client */
1510
int ha_release_temporary_latches(THD *thd);
1511 1512 1513

/* transactions: interface to handlerton functions */
int ha_start_consistent_snapshot(THD *thd);
serg@serg.mylan's avatar
serg@serg.mylan committed
1514
int ha_commit_or_rollback_by_xid(XID *xid, bool commit);
1515 1516 1517 1518 1519 1520 1521
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);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
1522
int ha_autocommit_or_rollback(THD *thd, int error);
1523
int ha_enable_transaction(THD *thd, bool on);
1524 1525 1526 1527 1528 1529

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

serg@serg.mylan's avatar
serg@serg.mylan committed
1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540
/* these are called by storage engines */
void trans_register_ha(THD *thd, bool all, handlerton *ht);

/*
  Storage engine has to assume the transaction will end up with 2pc if
   - there is more than one 2pc-capable storage engine available
   - in the current transaction 2pc was not disabled yet
*/
#define trans_need_2pc(thd, all)                   ((total_ha_2pc > 1) && \
        !((all ? &thd->transaction.all : &thd->transaction.stmt)->no_2pc))

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
1541 1542 1543 1544
/* semi-synchronous replication */
int ha_repl_report_sent_binlog(THD *thd, char *log_file_name,
                               my_off_t end_offset);
int ha_repl_report_replication_stop(THD *thd);
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
1545 1546 1547 1548 1549

#ifdef HAVE_NDB_BINLOG
int ha_reset_logs(THD *thd);
int ha_binlog_index_purge_file(THD *thd, const char *file);
void ha_reset_slave(THD *thd);
1550 1551
void ha_binlog_log_query(THD *thd, const handlerton *db_type,
                         enum_binlog_command binlog_command,
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
1552 1553 1554 1555 1556 1557 1558 1559
                         const char *query, uint query_length,
                         const char *db, const char *table_name);
void ha_binlog_wait(THD *thd);
int ha_binlog_end(THD *thd);
#else
#define ha_reset_logs(a) 0
#define ha_binlog_index_purge_file(a,b) 0
#define ha_reset_slave(a)
1560
#define ha_binlog_log_query(a,b,c,d,e,f,g);
tomas@poseidon.ndb.mysql.com's avatar
tomas@poseidon.ndb.mysql.com committed
1561 1562 1563
#define ha_binlog_wait(a)
#define ha_binlog_end(a) 0
#endif