handler.h 33.8 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
#if defined(HAVE_BERKELEY_DB) || defined(HAVE_INNOBASE_DB) || \
    defined(HAVE_NDBCLUSTER_DB)
33 34 35
#define USING_TRANSACTIONS
#endif

bk@work.mysql.com's avatar
bk@work.mysql.com 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
44
#define HA_ADMIN_INVALID         -5
vva@eagle.mysql.r18.ru's avatar
vva@eagle.mysql.r18.ru committed
45
#define HA_ADMIN_REJECT          -6
46
#define HA_ADMIN_TRY_ALTER       -7
47
#define HA_ADMIN_WRONG_CHECKSUM  -8
bk@work.mysql.com's avatar
bk@work.mysql.com committed
48

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

/*
  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)
56 57
#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
58
                                           It returns a position to ha_r_rnd */
59
#define HA_CAN_GEOMETRY        (1 << 4)
60 61 62 63 64 65
/*
  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)
66 67
#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
68
#define HA_NO_BLOBS            (1 << 9) /* Doesn't support blobs */
69 70 71
#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
72
#define HA_NOT_EXACT_COUNT     (1 << 13)
73 74 75 76 77
/*
  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
78 79 80 81 82 83 84
#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)
85
/* Table data are stored in separate files (for lower_case_table_names) */
monty@mysql.com's avatar
monty@mysql.com committed
86
#define HA_FILE_BASED	       (1 << 26)
87
#define HA_NO_VARCHAR	       (1 << 27)
ram@gw.mysql.r18.ru's avatar
ram@gw.mysql.r18.ru committed
88
#define HA_CAN_BIT_FIELD       (1 << 28) /* supports bit fields */
ingo@mysql.com's avatar
ingo@mysql.com committed
89
#define HA_NEED_READ_RANGE_BUFFER (1 << 29) /* for read_multi_range */
90
#define HA_ANY_INDEX_MAY_BE_UNIQUE (1 << 30)
monty@mysql.com's avatar
monty@mysql.com committed
91

92

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

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


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

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

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

132 133 134 135
/*
  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
136 137 138 139 140 141

#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 */
142 143
/* 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
144 145 146 147 148
#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

149
	/* Errors on write which is recoverable  (Key exist) */
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
150
#define HA_WRITE_SKIP 121		/* Duplicate key on write */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
151 152 153 154 155 156 157 158 159 160 161 162 163
#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

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

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

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

187
enum row_type { ROW_TYPE_NOT_USED=-1, ROW_TYPE_DEFAULT, ROW_TYPE_FIXED,
188 189
		ROW_TYPE_DYNAMIC, ROW_TYPE_COMPRESSED,
		ROW_TYPE_REDUNDANT, ROW_TYPE_COMPACT };
bk@work.mysql.com's avatar
bk@work.mysql.com committed
190 191 192 193

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

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

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

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

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

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

282 283
/* for recover() handlerton call */
#define MIN_XID_LIST_SIZE  128
284 285 286
#ifdef SAFEMALLOC
#define MAX_XID_LIST_SIZE  256
#else
287
#define MAX_XID_LIST_SIZE  (1024*128)
288
#endif
289

290 291
/*
  handlerton is a singleton structure - one instance per storage engine -
serg@serg.mylan's avatar
serg@serg.mylan committed
292 293
  to provide access to storage engine functionality that works on the
  "global" level (unlike handler class that works on a per-table basis)
294 295

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

297 298 299 300
  static handlerton { ... } xxx_hton;

  savepoint_*, prepare, recover, and *_by_xid pointers can be 0.
*/
301 302
typedef struct
{
serg@serg.mylan's avatar
serg@serg.mylan committed
303 304 305 306
  /*
    storage engine name as it should be printed to a user
  */
  const char *name;
307 308 309 310 311 312 313 314 315
  /*
    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.
   */
316
   uint slot;
317 318 319 320 321 322 323 324 325
   /*
     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.
   */
326
   uint savepoint_offset;
327 328 329 330 331 332 333 334
   /*
     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
   */
335
   int  (*close_connection)(THD *thd);
336 337 338 339
   /*
     sv points to an uninitialized storage area of requested size
     (see savepoint_offset description)
   */
340
   int  (*savepoint_set)(THD *thd, void *sv);
341 342 343 344
   /*
     sv points to a storage area, that was earlier passed
     to the savepoint_set call
   */
345 346
   int  (*savepoint_rollback)(THD *thd, void *sv);
   int  (*savepoint_release)(THD *thd, void *sv);
347 348 349 350 351 352 353
   /*
     '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.
   */
354 355 356 357 358 359
   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);
360 361 362
   void *(*create_cursor_read_view)();
   void (*set_cursor_read_view)(void *);
   void (*close_cursor_read_view)(void *);
363
   uint32 flags;                                /* global handler flags */
364 365
} handlerton;

366 367 368 369 370 371 372 373 374 375 376 377 378
struct show_table_type_st {
  const char *type;
  SHOW_COMP_OPTION *value;
  const char *comment;
  enum db_type db_type;
  handlerton *ht;
};

struct show_table_alias_st {
  const char *alias;
  const char *type;
};

379 380 381 382
/* Possible flags of a handlerton */
#define HTON_NO_FLAGS 0
#define HTON_CLOSE_CURSORS_AT_COMMIT 1

383 384
typedef struct st_thd_trans
{
385
  /* number of entries in the ht[] */
386
  uint        nht;
387
  /* true is not all entries in the ht[] support 2pc */
388
  bool        no_2pc;
389
  /* storage engines that registered themselves for this transaction */
390 391 392
  handlerton *ht[MAX_HA];
} THD_TRANS;

monty@tik.mysql.fi's avatar
monty@tik.mysql.fi committed
393 394 395
enum enum_tx_isolation { ISO_READ_UNCOMMITTED, ISO_READ_COMMITTED,
			 ISO_REPEATABLE_READ, ISO_SERIALIZABLE};

bk@work.mysql.com's avatar
bk@work.mysql.com committed
396 397
typedef struct st_ha_create_information
{
398
  CHARSET_INFO *table_charset, *default_table_charset;
399
  LEX_STRING connect_string;
400 401 402
  const char *comment,*password;
  const char *data_file_name, *index_file_name;
  const char *alias;
403 404 405 406
  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
407 408
  ulong raid_chunksize;
  ulong used_fields;
409
  SQL_LIST merge_list;
410 411
  enum db_type db_type;
  enum row_type row_type;
412
  uint null_bits;                       /* NULL bits at start of record */
413
  uint options;				/* OR of HA_CREATE_ options */
414
  uint raid_type,raid_chunks;
415
  uint merge_insert_method;
416
  bool table_existed;			/* 1 in create if table existed */
417
  bool frm_only;                        /* 1 if no ha_create_table() */
418
  bool varchar;                         /* 1 if table has a VARCHAR */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
419 420 421 422 423 424 425
} HA_CREATE_INFO;


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

struct st_table;
typedef struct st_table TABLE;
426 427
struct st_foreign_key_info;
typedef struct st_foreign_key_info FOREIGN_KEY_INFO;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
428

429 430 431
typedef struct st_savepoint SAVEPOINT;
extern ulong savepoint_alloc_size;

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

bk@work.mysql.com's avatar
bk@work.mysql.com committed
435 436 437
typedef struct st_ha_check_opt
{
  ulong sort_buffer_size;
serg@serg.mysql.com's avatar
serg@serg.mysql.com committed
438 439
  uint flags;       /* isam layer flags (e.g. for myisamchk) */
  uint sql_flags;   /* sql layer flags - for something myisamchk cannot do */
440
  KEY_CACHE *key_cache;	/* new key cache when changing key cache */
441
  void init();
bk@work.mysql.com's avatar
bk@work.mysql.com committed
442 443
} HA_CHECK_OPT;

444

ingo@mysql.com's avatar
ingo@mysql.com committed
445 446 447 448 449 450 451 452 453 454 455 456 457 458 459
/*
  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;


bk@work.mysql.com's avatar
bk@work.mysql.com committed
460 461 462 463 464
class handler :public Sql_alloc
{
 protected:
  struct st_table *table;		/* The table definition */

465 466 467 468 469 470 471 472 473 474 475 476
  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; }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
477
public:
478
  const handlerton *ht;                 /* storage engine of this handler */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
479 480 481 482 483 484 485 486
  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;
487 488
  ha_rows records;			/* Records in table */
  ha_rows deleted;			/* Deleted records */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
489
  ulong raid_chunksize;
490
  ulong mean_rec_length;		/* physical reclength */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
491 492 493
  time_t create_time;			/* When table was created */
  time_t check_time;
  time_t update_time;
494

ingo@mysql.com's avatar
ingo@mysql.com committed
495 496 497 498 499 500
  /* 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;

501 502 503 504
  /* 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;
505
  bool eq_range;
506

507 508 509 510 511 512 513
  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;
514
  FT_INFO *ft_handler;
515
  enum {NONE=0, INDEX, RND} inited;
516
  bool  auto_increment_column_changed;
517
  bool implicit_emptied;                /* Can be !=0 only if HEAP */
518
  const COND *pushed_cond;
519

520 521
  handler(const handlerton *ht_arg, TABLE *table_arg) :table(table_arg),
    ht(ht_arg),
522 523 524 525
    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),
526
    key_used_on_scan(MAX_KEY), active_index(MAX_KEY),
527
    ref_length(sizeof(my_off_t)), block_size(0),
528 529
    raid_type(0), ft_handler(0), inited(NONE), implicit_emptied(0),
    pushed_cond(NULL)
bk@work.mysql.com's avatar
bk@work.mysql.com committed
530
    {}
531
  virtual ~handler(void) { /* TODO: DBUG_ASSERT(inited == NONE); */ }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
532
  int ha_open(const char *name, int mode, int test_if_locked);
533
  bool update_auto_increment();
534
  virtual void print_error(int error, myf errflag);
535
  virtual bool get_error_message(int error, String *buf);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
536 537 538
  uint get_dup_key(int error);
  void change_table_ptr(TABLE *table_arg) { table=table_arg; }
  virtual double scan_time()
539
    { return ulonglong2double(data_file_length) / IO_SIZE + 2; }
monty@narttu.mysql.fi's avatar
monty@narttu.mysql.fi committed
540 541
  virtual double read_time(uint index, uint ranges, ha_rows rows)
 { return rows2double(ranges+rows); }
serg@serg.mylan's avatar
serg@serg.mylan committed
542
  virtual const key_map *keys_to_use_for_scanning() { return &key_map_empty; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
543
  virtual bool has_transactions(){ return 0;}
544
  virtual uint extra_rec_buf_length() { return 0; }
sergefp@mysql.com's avatar
sergefp@mysql.com committed
545 546 547 548 549 550 551 552 553
  
  /*
    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
554

555 556 557 558 559 560
  /*
    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; }

561 562 563 564
  virtual const char *index_type(uint key_number) { DBUG_ASSERT(0); return "";}

  int ha_index_init(uint idx)
  {
monty@mysql.com's avatar
monty@mysql.com committed
565
    DBUG_ENTER("ha_index_init");
566 567
    DBUG_ASSERT(inited==NONE);
    inited=INDEX;
monty@mysql.com's avatar
monty@mysql.com committed
568
    DBUG_RETURN(index_init(idx));
569 570 571
  }
  int ha_index_end()
  {
monty@mysql.com's avatar
monty@mysql.com committed
572
    DBUG_ENTER("ha_index_end");
573 574
    DBUG_ASSERT(inited==INDEX);
    inited=NONE;
monty@mysql.com's avatar
monty@mysql.com committed
575
    DBUG_RETURN(index_end());
576
  }
577
  int ha_rnd_init(bool scan)
578
  {
monty@mysql.com's avatar
monty@mysql.com committed
579
    DBUG_ENTER("ha_rnd_init");
580 581
    DBUG_ASSERT(inited==NONE || (inited==RND && scan));
    inited=RND;
monty@mysql.com's avatar
monty@mysql.com committed
582
    DBUG_RETURN(rnd_init(scan));
583 584 585
  }
  int ha_rnd_end()
  {
monty@mysql.com's avatar
monty@mysql.com committed
586
    DBUG_ENTER("ha_rnd_end");
587 588
    DBUG_ASSERT(inited==RND);
    inited=NONE;
monty@mysql.com's avatar
monty@mysql.com committed
589
    DBUG_RETURN(rnd_end());
590
  }
monty@mysql.com's avatar
monty@mysql.com committed
591
  /* this is necessary in many places, e.g. in HANDLER command */
592 593 594 595
  int ha_index_or_rnd_end()
  {
    return inited == INDEX ? ha_index_end() : inited == RND ? ha_rnd_end() : 0;
  }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
596
  uint get_index(void) const { return active_index; }
597
  virtual int open(const char *name, int mode, uint test_if_locked)=0;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
598
  virtual int close(void)=0;
599 600 601 602 603
  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; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
604
  virtual int index_read(byte * buf, const byte * key,
605 606
			 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
607
  virtual int index_read_idx(byte * buf, uint index, const byte * key,
608 609 610 611 612 613 614 615 616
			     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
617
  virtual int index_next_same(byte *buf, const byte *key, uint keylen);
618
  virtual int index_read_last(byte * buf, const byte * key, uint key_len)
619
   { return (my_errno=HA_ERR_WRONG_COMMAND); }
ingo@mysql.com's avatar
ingo@mysql.com committed
620 621 622 623
  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);
624
  virtual int read_range_first(const key_range *start_key,
625 626 627
                               const key_range *end_key,
                               bool eq_range, bool sorted);
  virtual int read_range_next();
628
  int compare_key(key_range *range);
629
  virtual int ft_init() { return HA_ERR_WRONG_COMMAND; }
630
  void ft_end() { ft_handler=NULL; }
631
  virtual FT_INFO *ft_init_ext(uint flags, uint inx,String *key)
632
    { return NULL; }
633
  virtual int ft_read(byte *buf) { return HA_ERR_WRONG_COMMAND; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
634 635
  virtual int rnd_next(byte *buf)=0;
  virtual int rnd_pos(byte * buf, byte *pos)=0;
636
  virtual int read_first_row(byte *buf, uint primary_key);
637 638 639 640 641 642 643 644
  /*
    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; }
645 646
  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
647 648 649
    { return (ha_rows) 10; }
  virtual void position(const byte *record)=0;
  virtual void info(uint)=0;
650 651
  virtual int extra(enum ha_extra_function operation)
  { return 0; }
652
  virtual int extra_opt(enum ha_extra_function operation, ulong cache_size)
653
  { return extra(operation); }
654
  virtual int reset() { return extra(HA_EXTRA_RESET); }
655
  virtual int external_lock(THD *thd, int lock_type) { return 0; }
monty@hundin.mysql.fi's avatar
monty@hundin.mysql.fi committed
656
  virtual void unlock_row() {}
serg@serg.mylan's avatar
serg@serg.mylan committed
657
  virtual int start_stmt(THD *thd, thr_lock_type lock_type) {return 0;}
658 659 660 661 662 663 664 665
  /*
    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); }
666 667
  virtual ulonglong get_auto_increment();
  virtual void restore_auto_increment();
668

osku@127.(none)'s avatar
osku@127.(none) committed
669 670 671 672 673 674 675
  /*
    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)
676 677
  { return HA_ERR_WRONG_COMMAND; }

bk@work.mysql.com's avatar
bk@work.mysql.com committed
678
  virtual void update_create_info(HA_CREATE_INFO *create_info) {}
679 680 681 682 683 684

  /* 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; }
685 686 687 688
  /*
    restore assumes .frm file must exist, and that generate_table() has been
    called; It will just copy the data file and run repair.
  */
689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
  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; }
705 706 707
  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;}
708 709
  virtual void start_bulk_insert(ha_rows rows) {}
  virtual int end_bulk_insert() {return 0; }
710 711 712
  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; }
713 714 715
  virtual char *update_table_comment(const char * comment)
  { return (char*) comment;}
  virtual void append_create_info(String *packet) {}
716 717
  virtual char* get_foreign_key_create_info()
  { return(NULL);}  /* gets foreign key create string from InnoDB */
718 719
  /* 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
720
  /* used in REPLACE; is > 0 if table is referred by a FOREIGN KEY */
721 722
  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
723
  virtual uint referenced_by_foreign_key() { return 0;}
724
  virtual void init_table_handle_for_HANDLER()
serg@serg.mylan's avatar
serg@serg.mylan committed
725 726
  { 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
727 728 729
  /* The following can be called without an open handler */
  virtual const char *table_type() const =0;
  virtual const char **bas_ext() const =0;
730
  virtual ulong table_flags(void) const =0;
731
  virtual ulong index_flags(uint idx, uint part, bool all_parts) const =0;
732
  virtual ulong index_ddl_flags(KEY *wanted_index) const
733
  { return (HA_DDL_SUPPORT); }
734
  virtual int add_index(TABLE *table_arg, KEY *key_info, uint num_of_keys)
735
  { return (HA_ERR_WRONG_COMMAND); }
736
  virtual int drop_index(TABLE *table_arg, uint *key_num, uint num_of_keys)
737 738 739 740 741 742 743 744 745 746
  { 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()); }
747
  uint max_key_part_length() const
748 749 750 751 752 753
  { 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; }
754
  virtual uint max_supported_key_part_length() const { return 255; }
bk@work.mysql.com's avatar
bk@work.mysql.com committed
755
  virtual uint min_record_length(uint options) const { return 1; }
756

bk@work.mysql.com's avatar
bk@work.mysql.com committed
757
  virtual bool low_byte_first() const { return 1; }
serg@serg.mylan's avatar
serg@serg.mylan committed
758
  virtual uint checksum() const { return 0; }
759 760
  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
761

762 763 764 765
  /*
    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
766 767
  virtual int rename_table(const char *from, const char *to);
  virtual int delete_table(const char *name);
768
  
bk@work.mysql.com's avatar
bk@work.mysql.com committed
769
  virtual int create(const char *name, TABLE *form, HA_CREATE_INFO *info)=0;
770 771

  /* lock_count() can be more than one if the table is a MERGE */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
772 773 774 775
  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;
776 777 778

  /* Type of table for caching query */
  virtual uint8 table_cache_type() { return HA_CACHE_TBL_NONTRANSACT; }
779 780 781 782 783 784
  /* 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)
785 786 787 788
  {
    *engine_callback= 0;
    return 1;
  }
monty@mysql.com's avatar
monty@mysql.com committed
789 790 791 792 793 794 795 796 797 798 799
 /*
  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
800 801 802 803
 
 /*
   Condition pushdown to storage engines
 */
804

805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825
 /*
   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
826
 virtual const COND *cond_push(const COND *cond) { return cond; };
827 828 829 830 831 832
 /*
   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
833
 virtual void cond_pop() { return; };
bk@work.mysql.com's avatar
bk@work.mysql.com committed
834 835 836 837
};

	/* Some extern variables used with handlers */

838
extern struct show_table_type_st sys_table_types[];
bk@work.mysql.com's avatar
bk@work.mysql.com committed
839
extern const char *ha_row_type[];
840
extern TYPELIB tx_isolation_typelib;
841
extern TYPELIB myisam_stats_method_typelib;
842 843
extern handlerton *handlertons[MAX_HA];
extern ulong total_ha, total_ha_2pc;
bk@work.mysql.com's avatar
bk@work.mysql.com committed
844

845
	/* Wrapper functions */
846 847 848 849
#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))
850

851
#define ha_supports_generate(T) (T != DB_TYPE_INNODB && \
852
                                 T != DB_TYPE_BERKELEY_DB && \
853 854
                                 T != DB_TYPE_ARCHIVE_DB && \
                                 T != DB_TYPE_FEDERATED_DB && \
855
                                 T != DB_TYPE_NDBCLUSTER)
856

857
/* lookups */
858
enum db_type ha_resolve_by_name(const char *name, uint namelen);
859
const char *ha_get_storage_engine(enum db_type db_type);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
860
handler *get_new_handler(TABLE *table, enum db_type db_type);
861 862
enum db_type ha_checktype(THD *thd, enum db_type database_type,
                          bool no_substitute, bool report_error);
863 864

/* basic stuff */
bk@work.mysql.com's avatar
bk@work.mysql.com committed
865
int ha_init(void);
866
TYPELIB *ha_known_exts(void);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
867
int ha_panic(enum ha_panic_function flag);
868
int ha_update_statistics();
869
void ha_close_connection(THD* thd);
870
my_bool ha_storage_engine_is_enabled(enum db_type database_type);
871 872
bool ha_flush_logs(void);
void ha_drop_database(char* path);
bk@work.mysql.com's avatar
bk@work.mysql.com committed
873 874
int ha_create_table(const char *name, HA_CREATE_INFO *create_info,
		    bool update_create_info);
875 876
int ha_delete_table(THD *thd, enum db_type db_type, const char *path,
                    const char *alias, bool generate_warning);
877 878

/* discovery */
879
int ha_create_table_from_engine(THD* thd, const char *db, const char *name);
880 881 882 883
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);
884
int ha_table_exists_in_engine(THD* thd, const char* db, const char* name);
885 886

/* key cache */
887 888 889
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);
890
int ha_change_key_cache(KEY_CACHE *old_key_cache, KEY_CACHE *new_key_cache);
891
int ha_end_key_cache(KEY_CACHE *key_cache);
892

heikki@hundin.mysql.fi's avatar
heikki@hundin.mysql.fi committed
893
/* report to InnoDB that control passes to the client */
894
int ha_release_temporary_latches(THD *thd);
895 896 897

/* transactions: interface to handlerton functions */
int ha_start_consistent_snapshot(THD *thd);
serg@serg.mylan's avatar
serg@serg.mylan committed
898
int ha_commit_or_rollback_by_xid(XID *xid, bool commit);
899 900 901 902 903 904 905
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
906
int ha_autocommit_or_rollback(THD *thd, int error);
907
int ha_enable_transaction(THD *thd, bool on);
908 909 910 911 912 913

/* 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
914 915 916 917 918 919 920 921 922 923 924
/* 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
925 926 927 928
/* 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);