handler.h 34.3 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
   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
unknown's avatar
unknown committed
21 22 23
#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
#define HA_ADMIN_NOT_BASE_TABLE  -9
unknown's avatar
unknown 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)
unknown's avatar
unknown committed
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;
unknown's avatar
unknown committed
59
                                           It returns a position to ha_r_rnd */
unknown's avatar
unknown committed
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)
unknown's avatar
unknown committed
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 */
unknown's avatar
unknown committed
69
#define HA_NO_BLOBS            (1 << 9) /* Doesn't support blobs */
unknown's avatar
unknown committed
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 */
unknown's avatar
unknown 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)
unknown's avatar
unknown committed
79 80 81 82 83 84 85
#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
86
/* Table data are stored in separate files (for lower_case_table_names) */
unknown's avatar
unknown committed
87
#define HA_FILE_BASED	       (1 << 26)
88
#define HA_NO_VARCHAR	       (1 << 27)
unknown's avatar
unknown committed
89
#define HA_CAN_BIT_FIELD       (1 << 28) /* supports bit fields */
unknown's avatar
unknown committed
90
#define HA_NEED_READ_RANGE_BUFFER (1 << 29) /* for read_multi_range */
91
#define HA_ANY_INDEX_MAY_BE_UNIQUE (1 << 30)
unknown's avatar
unknown committed
92

93

94
/* bits in index_flags(index_number) for what you can do with index */
unknown's avatar
unknown committed
95 96 97 98
#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 */
99
#define HA_ONLY_WHOLE_INDEX	16	/* Can't use part key searches */
unknown's avatar
unknown committed
100
#define HA_KEYREAD_ONLY         64	/* Support HA_EXTRA_KEYREAD */
101

102 103 104 105 106 107 108
/*
  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 


109 110 111 112 113 114
/* 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

115 116
/*
  Note: the following includes binlog and closing 0.
117 118 119
  so: innodb + bdb + ndb + binlog + myisam + myisammrg + archive +
      example + csv + heap + blackhole + federated + 0
  (yes, the sum is deliberately inaccurate)
120
*/
121
#define MAX_HA 14
122

123
/*
124 125 126 127
  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.
128 129 130 131 132
*/
#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 */

133 134 135 136
/*
  Parameters for open() (in register form->filestat)
  HA_GET_INFO does an implicit HA_ABORT_IF_LOCKED
*/
unknown's avatar
unknown committed
137 138 139 140 141 142

#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 */
143 144
/* Try readonly if can't open with read and write */
#define HA_TRY_READ_ONLY	32
unknown's avatar
unknown committed
145 146 147 148 149
#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

150
	/* Errors on write which is recoverable  (Key exist) */
unknown's avatar
unknown committed
151
#define HA_WRITE_SKIP 121		/* Duplicate key on write */
unknown's avatar
unknown committed
152 153 154 155 156 157 158 159 160 161 162 163 164
#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

165 166
/* Table caching type */
#define HA_CACHE_TBL_NONTRANSACT 0
167 168 169 170
#define HA_CACHE_TBL_NOCACHE     1
#define HA_CACHE_TBL_ASKTRANSACT 2
#define HA_CACHE_TBL_TRANSACT    4

171 172
/* Options of START TRANSACTION statement (and later of SET TRANSACTION stmt) */
#define MYSQL_START_TRANS_OPT_WITH_CONS_SNAPSHOT 1
173

174 175
enum db_type
{
unknown's avatar
unknown committed
176 177 178 179
  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,
180
  DB_TYPE_BERKELEY_DB, DB_TYPE_INNODB,
unknown's avatar
unknown committed
181
  DB_TYPE_GEMINI, DB_TYPE_NDBCLUSTER,
182
  DB_TYPE_EXAMPLE_DB, DB_TYPE_ARCHIVE_DB, DB_TYPE_CSV_DB,
183
  DB_TYPE_FEDERATED_DB,
184
  DB_TYPE_BLACKHOLE_DB,
unknown's avatar
unknown committed
185 186
  DB_TYPE_DEFAULT // Must be last
};
unknown's avatar
unknown committed
187

188
enum row_type { ROW_TYPE_NOT_USED=-1, ROW_TYPE_DEFAULT, ROW_TYPE_FIXED,
189 190
		ROW_TYPE_DYNAMIC, ROW_TYPE_COMPRESSED,
		ROW_TYPE_REDUNDANT, ROW_TYPE_COMPACT };
unknown's avatar
unknown committed
191 192 193 194

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

/* Bits in used_fields */
195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212
#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)
213
#define HA_CREATE_USED_CONNECTION       (1L << 18)
unknown's avatar
unknown committed
214

215
typedef ulonglong my_xid; // this line is the same as in log_event.h
216 217 218 219
#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))
220 221 222 223 224 225 226 227 228

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

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

unknown's avatar
unknown committed
231
  bool eq(struct xid_t *xid)
232
  { return eq(xid->gtrid_length, xid->bqual_length, xid->data); }
233 234
  bool eq(long g, long b, const char *d)
  { return g == gtrid_length && b == bqual_length && !memcmp(d, data, g+b); }
unknown's avatar
unknown committed
235
  void set(struct xid_t *xid)
236
  { memcpy(this, xid, xid->length()); }
unknown's avatar
unknown committed
237 238 239 240 241 242
  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);
  }
243
  void set(ulonglong xid)
244
  {
245
    my_xid tmp;
unknown's avatar
unknown committed
246
    formatID= 1;
247
    set(MYSQL_XID_PREFIX_LEN, 0, MYSQL_XID_PREFIX);
248 249 250
    memcpy(data+MYSQL_XID_PREFIX_LEN, &server_id, sizeof(server_id));
    tmp= xid;
    memcpy(data+MYSQL_XID_OFFSET, &tmp, sizeof(tmp));
251 252 253 254
    gtrid_length=MYSQL_XID_GTRID_LEN;
  }
  void set(long g, long b, const char *d)
  {
unknown's avatar
unknown committed
255
    formatID= 1;
256 257 258 259 260 261 262 263
    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()
  {
264 265 266
    my_xid tmp;
    memcpy(&tmp, data+MYSQL_XID_OFFSET, sizeof(tmp));
    return tmp;
267 268 269 270
  }
  my_xid get_my_xid()
  {
    return gtrid_length == MYSQL_XID_GTRID_LEN && bqual_length == 0 &&
unknown's avatar
unknown committed
271
           !memcmp(data+MYSQL_XID_PREFIX_LEN, &server_id, sizeof(server_id)) &&
272 273 274
           !memcmp(data, MYSQL_XID_PREFIX, MYSQL_XID_PREFIX_LEN) ?
           quick_get_my_xid() : 0;
  }
275 276 277 278 279
  uint length()
  {
    return sizeof(formatID)+sizeof(gtrid_length)+sizeof(bqual_length)+
           gtrid_length+bqual_length;
  }
280 281 282 283 284 285 286 287
  byte *key()
  {
    return (byte *)&gtrid_length;
  }
  uint key_length()
  {
    return sizeof(gtrid_length)+sizeof(bqual_length)+gtrid_length+bqual_length;
  }
288
};
289 290
typedef struct xid_t XID;

291 292
/* for recover() handlerton call */
#define MIN_XID_LIST_SIZE  128
293 294 295
#ifdef SAFEMALLOC
#define MAX_XID_LIST_SIZE  256
#else
296
#define MAX_XID_LIST_SIZE  (1024*128)
297
#endif
298

unknown's avatar
unknown committed
299 300
/*
  handlerton is a singleton structure - one instance per storage engine -
unknown's avatar
unknown committed
301 302
  to provide access to storage engine functionality that works on the
  "global" level (unlike handler class that works on a per-table basis)
unknown's avatar
unknown committed
303 304

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

unknown's avatar
unknown committed
306 307 308 309
  static handlerton { ... } xxx_hton;

  savepoint_*, prepare, recover, and *_by_xid pointers can be 0.
*/
310 311
typedef struct
{
unknown's avatar
unknown committed
312 313 314 315
  /*
    storage engine name as it should be printed to a user
  */
  const char *name;
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336

  /*
    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.
  */
  enum db_type db_type;
  /* 
    Method that initizlizes a storage engine
  */
  bool (*init)();

unknown's avatar
unknown committed
337 338 339 340 341 342 343 344 345
  /*
    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.
   */
346
   uint slot;
unknown's avatar
unknown committed
347 348 349 350 351 352 353 354 355
   /*
     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.
   */
356
   uint savepoint_offset;
unknown's avatar
unknown committed
357 358 359 360 361 362 363 364
   /*
     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
   */
365
   int  (*close_connection)(THD *thd);
unknown's avatar
unknown committed
366 367 368 369
   /*
     sv points to an uninitialized storage area of requested size
     (see savepoint_offset description)
   */
370
   int  (*savepoint_set)(THD *thd, void *sv);
unknown's avatar
unknown committed
371 372 373 374
   /*
     sv points to a storage area, that was earlier passed
     to the savepoint_set call
   */
375 376
   int  (*savepoint_rollback)(THD *thd, void *sv);
   int  (*savepoint_release)(THD *thd, void *sv);
unknown's avatar
unknown committed
377 378 379 380 381 382 383
   /*
     '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.
   */
384 385 386 387 388 389
   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);
390 391 392
   void *(*create_cursor_read_view)();
   void (*set_cursor_read_view)(void *);
   void (*close_cursor_read_view)(void *);
393
   uint32 flags;                                /* global handler flags */
394 395
} handlerton;

396 397 398 399 400
struct show_table_alias_st {
  const char *alias;
  const char *type;
};

401
/* Possible flags of a handlerton */
402 403 404 405
#define HTON_NO_FLAGS                 0
#define HTON_CLOSE_CURSORS_AT_COMMIT (1 << 0)
#define HTON_ALTER_NOT_SUPPORTED     (1 << 1)
#define HTON_CAN_RECREATE            (1 << 2)
406

407 408
typedef struct st_thd_trans
{
unknown's avatar
unknown committed
409
  /* number of entries in the ht[] */
410
  uint        nht;
unknown's avatar
unknown committed
411
  /* true is not all entries in the ht[] support 2pc */
412
  bool        no_2pc;
unknown's avatar
unknown committed
413
  /* storage engines that registered themselves for this transaction */
414 415 416
  handlerton *ht[MAX_HA];
} THD_TRANS;

unknown's avatar
unknown committed
417 418 419
enum enum_tx_isolation { ISO_READ_UNCOMMITTED, ISO_READ_COMMITTED,
			 ISO_REPEATABLE_READ, ISO_SERIALIZABLE};

unknown's avatar
unknown committed
420 421
typedef struct st_ha_create_information
{
422
  CHARSET_INFO *table_charset, *default_table_charset;
423
  LEX_STRING connect_string;
unknown's avatar
unknown committed
424 425 426
  const char *comment,*password;
  const char *data_file_name, *index_file_name;
  const char *alias;
427 428 429 430
  ulonglong max_rows,min_rows;
  ulonglong auto_increment_value;
  ulong table_options;
  ulong avg_row_length;
unknown's avatar
unknown committed
431 432
  ulong raid_chunksize;
  ulong used_fields;
433
  SQL_LIST merge_list;
434 435
  enum db_type db_type;
  enum row_type row_type;
436
  uint null_bits;                       /* NULL bits at start of record */
437
  uint options;				/* OR of HA_CREATE_ options */
438
  uint raid_type,raid_chunks;
439
  uint merge_insert_method;
440
  uint extra_size;                      /* length of extra data segment */
441
  bool table_existed;			/* 1 in create if table existed */
442
  bool frm_only;                        /* 1 if no ha_create_table() */
443
  bool varchar;                         /* 1 if table has a VARCHAR */
unknown's avatar
unknown committed
444 445 446 447 448 449 450
} HA_CREATE_INFO;


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

struct st_table;
typedef struct st_table TABLE;
451 452
struct st_foreign_key_info;
typedef struct st_foreign_key_info FOREIGN_KEY_INFO;
unknown's avatar
unknown committed
453

454 455 456
typedef struct st_savepoint SAVEPOINT;
extern ulong savepoint_alloc_size;

457
/* Forward declaration for condition pushdown to storage engine */
458
typedef class Item COND;
unknown's avatar
Merge  
unknown committed
459

unknown's avatar
unknown committed
460 461 462
typedef struct st_ha_check_opt
{
  ulong sort_buffer_size;
unknown's avatar
unknown committed
463 464
  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
465
  KEY_CACHE *key_cache;	/* new key cache when changing key cache */
unknown's avatar
unknown committed
466
  void init();
unknown's avatar
unknown committed
467 468
} HA_CHECK_OPT;

469

unknown's avatar
unknown committed
470 471 472 473 474 475 476 477 478 479 480 481 482 483 484
/*
  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
485 486 487 488 489
class handler :public Sql_alloc
{
 protected:
  struct st_table *table;		/* The table definition */

unknown's avatar
unknown committed
490 491 492 493 494 495 496 497 498 499 500 501
  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
502
public:
503
  const handlerton *ht;                 /* storage engine of this handler */
unknown's avatar
unknown committed
504 505 506 507 508 509 510 511
  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;
512 513
  ha_rows records;			/* Records in table */
  ha_rows deleted;			/* Deleted records */
unknown's avatar
unknown committed
514
  ulong raid_chunksize;
515
  ulong mean_rec_length;		/* physical reclength */
unknown's avatar
unknown committed
516 517 518
  time_t create_time;			/* When table was created */
  time_t check_time;
  time_t update_time;
519

unknown's avatar
unknown committed
520 521 522 523 524 525
  /* 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;

526 527 528 529
  /* 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
530
  bool eq_range;
531

532 533 534 535 536 537 538
  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
539
  FT_INFO *ft_handler;
540
  enum {NONE=0, INDEX, RND} inited;
541
  bool  auto_increment_column_changed;
542
  bool implicit_emptied;                /* Can be !=0 only if HEAP */
543
  const COND *pushed_cond;
544

545 546
  handler(const handlerton *ht_arg, TABLE *table_arg) :table(table_arg),
    ht(ht_arg),
547 548 549 550
    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
551
    key_used_on_scan(MAX_KEY), active_index(MAX_KEY),
552
    ref_length(sizeof(my_off_t)), block_size(0),
553 554
    raid_type(0), ft_handler(0), inited(NONE), implicit_emptied(0),
    pushed_cond(NULL)
unknown's avatar
unknown committed
555
    {}
unknown's avatar
unknown committed
556
  virtual ~handler(void) { /* TODO: DBUG_ASSERT(inited == NONE); */ }
unknown's avatar
unknown committed
557
  int ha_open(const char *name, int mode, int test_if_locked);
558
  bool update_auto_increment();
unknown's avatar
unknown committed
559
  virtual void print_error(int error, myf errflag);
560
  virtual bool get_error_message(int error, String *buf);
unknown's avatar
unknown committed
561 562 563
  uint get_dup_key(int error);
  void change_table_ptr(TABLE *table_arg) { table=table_arg; }
  virtual double scan_time()
564
    { return ulonglong2double(data_file_length) / IO_SIZE + 2; }
unknown's avatar
unknown committed
565 566
  virtual double read_time(uint index, uint ranges, ha_rows rows)
 { return rows2double(ranges+rows); }
unknown's avatar
unknown committed
567
  virtual const key_map *keys_to_use_for_scanning() { return &key_map_empty; }
unknown's avatar
unknown committed
568
  virtual bool has_transactions(){ return 0;}
569
  virtual uint extra_rec_buf_length() { return 0; }
unknown's avatar
unknown committed
570 571 572 573 574 575 576 577 578
  
  /*
    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
579

580 581 582 583 584 585
  /*
    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
586 587 588 589
  virtual const char *index_type(uint key_number) { DBUG_ASSERT(0); return "";}

  int ha_index_init(uint idx)
  {
unknown's avatar
unknown committed
590
    DBUG_ENTER("ha_index_init");
unknown's avatar
unknown committed
591 592
    DBUG_ASSERT(inited==NONE);
    inited=INDEX;
unknown's avatar
unknown committed
593
    DBUG_RETURN(index_init(idx));
unknown's avatar
unknown committed
594 595 596
  }
  int ha_index_end()
  {
unknown's avatar
unknown committed
597
    DBUG_ENTER("ha_index_end");
unknown's avatar
unknown committed
598 599
    DBUG_ASSERT(inited==INDEX);
    inited=NONE;
unknown's avatar
unknown committed
600
    DBUG_RETURN(index_end());
unknown's avatar
unknown committed
601
  }
602
  int ha_rnd_init(bool scan)
unknown's avatar
unknown committed
603
  {
unknown's avatar
unknown committed
604
    DBUG_ENTER("ha_rnd_init");
unknown's avatar
unknown committed
605 606
    DBUG_ASSERT(inited==NONE || (inited==RND && scan));
    inited=RND;
unknown's avatar
unknown committed
607
    DBUG_RETURN(rnd_init(scan));
unknown's avatar
unknown committed
608 609 610
  }
  int ha_rnd_end()
  {
unknown's avatar
unknown committed
611
    DBUG_ENTER("ha_rnd_end");
unknown's avatar
unknown committed
612 613
    DBUG_ASSERT(inited==RND);
    inited=NONE;
unknown's avatar
unknown committed
614
    DBUG_RETURN(rnd_end());
unknown's avatar
unknown committed
615
  }
unknown's avatar
unknown committed
616
  /* this is necessary in many places, e.g. in HANDLER command */
unknown's avatar
unknown committed
617 618 619 620
  int ha_index_or_rnd_end()
  {
    return inited == INDEX ? ha_index_end() : inited == RND ? ha_rnd_end() : 0;
  }
unknown's avatar
unknown committed
621
  uint get_index(void) const { return active_index; }
622
  virtual int open(const char *name, int mode, uint test_if_locked)=0;
unknown's avatar
unknown committed
623
  virtual int close(void)=0;
unknown's avatar
unknown committed
624 625 626 627 628
  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
629
  virtual int index_read(byte * buf, const byte * key,
unknown's avatar
unknown committed
630 631
			 uint key_len, enum ha_rkey_function find_flag)
   { return  HA_ERR_WRONG_COMMAND; }
unknown's avatar
unknown committed
632
  virtual int index_read_idx(byte * buf, uint index, const byte * key,
unknown's avatar
unknown committed
633 634 635 636 637 638 639 640 641
			     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
642
  virtual int index_next_same(byte *buf, const byte *key, uint keylen);
643
  virtual int index_read_last(byte * buf, const byte * key, uint key_len)
unknown's avatar
unknown committed
644
   { return (my_errno=HA_ERR_WRONG_COMMAND); }
unknown's avatar
unknown committed
645 646 647 648
  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);
649
  virtual int read_range_first(const key_range *start_key,
unknown's avatar
unknown committed
650 651 652
                               const key_range *end_key,
                               bool eq_range, bool sorted);
  virtual int read_range_next();
653
  int compare_key(key_range *range);
unknown's avatar
unknown committed
654
  virtual int ft_init() { return HA_ERR_WRONG_COMMAND; }
655
  void ft_end() { ft_handler=NULL; }
656
  virtual FT_INFO *ft_init_ext(uint flags, uint inx,String *key)
unknown's avatar
unknown committed
657
    { return NULL; }
unknown's avatar
unknown committed
658
  virtual int ft_read(byte *buf) { return HA_ERR_WRONG_COMMAND; }
unknown's avatar
unknown committed
659 660
  virtual int rnd_next(byte *buf)=0;
  virtual int rnd_pos(byte * buf, byte *pos)=0;
661
  virtual int read_first_row(byte *buf, uint primary_key);
unknown's avatar
unknown committed
662 663 664 665 666 667 668 669
  /*
    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
670 671
  virtual ha_rows records_in_range(uint inx, key_range *min_key,
                                   key_range *max_key)
unknown's avatar
unknown committed
672 673 674
    { return (ha_rows) 10; }
  virtual void position(const byte *record)=0;
  virtual void info(uint)=0;
unknown's avatar
unknown committed
675 676
  virtual int extra(enum ha_extra_function operation)
  { return 0; }
unknown's avatar
unknown committed
677
  virtual int extra_opt(enum ha_extra_function operation, ulong cache_size)
unknown's avatar
unknown committed
678
  { return extra(operation); }
679
  virtual int reset() { return extra(HA_EXTRA_RESET); }
680
  virtual int external_lock(THD *thd, int lock_type) { return 0; }
unknown's avatar
unknown committed
681
  virtual void unlock_row() {}
unknown's avatar
unknown committed
682
  virtual int start_stmt(THD *thd, thr_lock_type lock_type) {return 0;}
unknown's avatar
unknown committed
683 684 685 686 687 688 689 690
  /*
    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); }
691 692
  virtual ulonglong get_auto_increment();
  virtual void restore_auto_increment();
693

unknown's avatar
unknown committed
694 695 696 697 698 699 700
  /*
    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)
701 702
  { return HA_ERR_WRONG_COMMAND; }

unknown's avatar
unknown committed
703
  virtual void update_create_info(HA_CREATE_INFO *create_info) {}
unknown's avatar
unknown committed
704 705 706 707 708 709

  /* 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; }
710 711 712 713
  /*
    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
714 715 716 717 718 719 720 721 722 723 724 725 726 727 728 729
  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; }
730 731 732
  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;}
733 734
  virtual void start_bulk_insert(ha_rows rows) {}
  virtual int end_bulk_insert() {return 0; }
unknown's avatar
unknown committed
735 736 737
  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; }
738 739 740
  virtual char *update_table_comment(const char * comment)
  { return (char*) comment;}
  virtual void append_create_info(String *packet) {}
741 742
  virtual char* get_foreign_key_create_info()
  { return(NULL);}  /* gets foreign key create string from InnoDB */
743 744
  /* used in ALTER TABLE; 1 if changing storage engine is allowed */
  virtual bool can_switch_engines() { return 1; }
unknown's avatar
unknown committed
745
  /* used in REPLACE; is > 0 if table is referred by a FOREIGN KEY */
746 747
  virtual int get_foreign_key_list(THD *thd, List<FOREIGN_KEY_INFO> *f_key_list)
  { return 0; }
unknown's avatar
unknown committed
748
  virtual uint referenced_by_foreign_key() { return 0;}
unknown's avatar
unknown committed
749
  virtual void init_table_handle_for_HANDLER()
unknown's avatar
unknown committed
750 751
  { return; }       /* prepare InnoDB for HANDLER */
  virtual void free_foreign_key_create_info(char* str) {}
unknown's avatar
unknown committed
752 753 754
  /* The following can be called without an open handler */
  virtual const char *table_type() const =0;
  virtual const char **bas_ext() const =0;
755
  virtual ulong table_flags(void) const =0;
756
  virtual ulong index_flags(uint idx, uint part, bool all_parts) const =0;
757
  virtual ulong index_ddl_flags(KEY *wanted_index) const
unknown's avatar
unknown committed
758
  { return (HA_DDL_SUPPORT); }
759
  virtual int add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys)
unknown's avatar
unknown committed
760
  { return (HA_ERR_WRONG_COMMAND); }
761
  virtual int drop_index(TABLE *table_arg, uint *key_num, uint num_of_keys)
unknown's avatar
unknown committed
762 763 764 765 766 767 768 769 770 771
  { 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
772
  uint max_key_part_length() const
unknown's avatar
unknown committed
773 774 775 776 777 778
  { 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; }
779
  virtual uint max_supported_key_part_length() const { return 255; }
unknown's avatar
unknown committed
780
  virtual uint min_record_length(uint options) const { return 1; }
unknown's avatar
unknown committed
781

unknown's avatar
unknown committed
782
  virtual bool low_byte_first() const { return 1; }
unknown's avatar
unknown committed
783
  virtual uint checksum() const { return 0; }
784 785
  virtual bool is_crashed() const  { return 0; }
  virtual bool auto_repair() const { return 0; }
unknown's avatar
unknown committed
786

unknown's avatar
unknown committed
787 788 789 790
  /*
    default rename_table() and delete_table() rename/delete files with a
    given name and extensions from bas_ext()
  */
unknown's avatar
unknown committed
791 792
  virtual int rename_table(const char *from, const char *to);
  virtual int delete_table(const char *name);
unknown's avatar
unknown committed
793
  
unknown's avatar
unknown committed
794
  virtual int create(const char *name, TABLE *form, HA_CREATE_INFO *info)=0;
unknown's avatar
unknown committed
795 796

  /* lock_count() can be more than one if the table is a MERGE */
unknown's avatar
unknown committed
797 798 799 800
  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;
801 802 803

  /* Type of table for caching query */
  virtual uint8 table_cache_type() { return HA_CACHE_TBL_NONTRANSACT; }
804 805 806 807 808 809
  /* 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
810 811 812 813
  {
    *engine_callback= 0;
    return 1;
  }
unknown's avatar
unknown committed
814 815 816 817 818 819 820 821 822 823 824
 /*
  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
825 826 827 828
 
 /*
   Condition pushdown to storage engines
 */
829

830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850
 /*
   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
851
 virtual const COND *cond_push(const COND *cond) { return cond; };
852 853 854 855 856 857
 /*
   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
858
 virtual void cond_pop() { return; };
unknown's avatar
unknown committed
859 860 861 862
};

	/* Some extern variables used with handlers */

863
extern handlerton *sys_table_types[];
unknown's avatar
unknown committed
864
extern const char *ha_row_type[];
865
extern TYPELIB tx_isolation_typelib;
866
extern TYPELIB myisam_stats_method_typelib;
867
extern ulong total_ha, total_ha_2pc;
unknown's avatar
unknown committed
868

869
	/* Wrapper functions */
870 871 872 873
#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))
874

875
/* lookups */
876
enum db_type ha_resolve_by_name(const char *name, uint namelen);
unknown's avatar
unknown committed
877
const char *ha_get_storage_engine(enum db_type db_type);
unknown's avatar
unknown committed
878
handler *get_new_handler(TABLE *table, enum db_type db_type);
879 880
enum db_type ha_checktype(THD *thd, enum db_type database_type,
                          bool no_substitute, bool report_error);
881
bool ha_check_storage_engine_flag(enum db_type db_type, uint32 flag);
882 883

/* basic stuff */
unknown's avatar
unknown committed
884
int ha_init(void);
885
TYPELIB *ha_known_exts(void);
unknown's avatar
unknown committed
886
int ha_panic(enum ha_panic_function flag);
887
int ha_update_statistics();
888
void ha_close_connection(THD* thd);
889
my_bool ha_storage_engine_is_enabled(enum db_type database_type);
890 891
bool ha_flush_logs(void);
void ha_drop_database(char* path);
unknown's avatar
unknown committed
892 893
int ha_create_table(const char *name, HA_CREATE_INFO *create_info,
		    bool update_create_info);
894 895
int ha_delete_table(THD *thd, enum db_type db_type, const char *path,
                    const char *alias, bool generate_warning);
896 897

/* discovery */
898
int ha_create_table_from_engine(THD* thd, const char *db, const char *name);
899 900 901 902
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);
unknown's avatar
unknown committed
903
int ha_table_exists_in_engine(THD* thd, const char* db, const char* name);
904 905

/* key cache */
unknown's avatar
unknown committed
906 907 908
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);
909
int ha_change_key_cache(KEY_CACHE *old_key_cache, KEY_CACHE *new_key_cache);
unknown's avatar
unknown committed
910
int ha_end_key_cache(KEY_CACHE *key_cache);
911

unknown's avatar
unknown committed
912
/* report to InnoDB that control passes to the client */
913
int ha_release_temporary_latches(THD *thd);
914 915 916

/* transactions: interface to handlerton functions */
int ha_start_consistent_snapshot(THD *thd);
unknown's avatar
unknown committed
917
int ha_commit_or_rollback_by_xid(XID *xid, bool commit);
918 919 920 921 922 923 924
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
925
int ha_autocommit_or_rollback(THD *thd, int error);
926
int ha_enable_transaction(THD *thd, bool on);
927 928 929 930 931 932

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

unknown's avatar
unknown committed
933 934 935 936 937 938 939 940 941 942 943
/* 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))

unknown's avatar
unknown committed
944 945 946 947
/* 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);