handler.h 14.2 KB
Newer Older
unknown's avatar
unknown committed
1
/* Copyright (C) 2000 MySQL AB & MySQL Finland AB & TCX DataKonsult AB
2

unknown's avatar
unknown committed
3 4 5 6
   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; either version 2 of the License, or
   (at your option) any later version.
7

unknown's avatar
unknown committed
8 9 10 11
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.
12

unknown's avatar
unknown committed
13 14 15 16 17 18 19 20 21 22 23
   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */


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

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

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

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

unknown's avatar
unknown committed
30
#if defined(HAVE_BERKELEY_DB) || defined(HAVE_INNOBASE_DB)
31 32 33
#define USING_TRANSACTIONS
#endif

unknown's avatar
unknown committed
34 35
// the following is for checking tables

36 37 38 39 40 41
#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
42
#define HA_ADMIN_INVALID         -5
unknown's avatar
unknown committed
43 44 45 46 47 48 49 50

/* Bits in bas_flag to show what database can do */
#define HA_READ_NEXT		1	/* Read next record with same key */
#define HA_READ_PREV		2	/* Read prev. record with same key */
#define HA_READ_ORDER		4	/* Read through record-keys in order */
#define HA_READ_RND_SAME	8	/* Read RND-record to KEY-record
					   (To update with RND-read)	   */
#define HA_KEYPOS_TO_RNDPOS	16	/* ha_info gives pos to record */
51
#define HA_TABLE_SCAN_ON_INDEX  32	/* No separate data/index file */
unknown's avatar
unknown committed
52 53
#define HA_REC_NOT_IN_SEQ	64	/* ha_info don't return recnumber;
					   It returns a position to ha_r_rnd */
54
#define HA_ONLY_WHOLE_INDEX	128	/* Can't use part key searches */
55
#define HA_NOT_READ_PREFIX_LAST	256	/* RSAME can't restore index */
unknown's avatar
unknown committed
56 57 58 59 60 61 62 63 64 65 66 67 68 69 70
#define HA_WRONG_ASCII_ORDER	512	/* Can't use sorting through key */
#define HA_HAVE_KEY_READ_ONLY	1024	/* Can read only keys (no record) */
#define HA_READ_NOT_EXACT_KEY	2048	/* Can read record after/before key */
#define HA_NO_INDEX		4096	/* No index needed for next/prev */
#define HA_KEY_READ_WRONG_STR	16384	/* keyread returns converted strings */
#define HA_NULL_KEY		32768	/* One can have keys with NULL */
#define HA_DUPP_POS		65536	/* ha_position() gives dupp row */
#define HA_NO_BLOBS		131072	/* Doesn't support blobs */
#define HA_BLOB_KEY		(HA_NO_BLOBS*2) /* key on blob */
#define HA_AUTO_PART_KEY	(HA_BLOB_KEY*2)
#define HA_REQUIRE_PRIMARY_KEY	(HA_AUTO_PART_KEY*2)
#define HA_NOT_EXACT_COUNT	(HA_REQUIRE_PRIMARY_KEY*2)
#define HA_NO_WRITE_DELAYED	(HA_NOT_EXACT_COUNT*2)
#define HA_PRIMARY_KEY_IN_READ_INDEX (HA_NO_WRITE_DELAYED*2)
#define HA_DROP_BEFORE_CREATE	(HA_PRIMARY_KEY_IN_READ_INDEX*2)
71
#define HA_NOT_READ_AFTER_KEY	(HA_DROP_BEFORE_CREATE*2)
72
#define HA_NOT_DELETE_WITH_CACHE (HA_NOT_READ_AFTER_KEY*2)
73
#define HA_NO_TEMP_TABLES       (HA_NOT_DELETE_WITH_CACHE*2)
unknown's avatar
unknown committed
74
#define HA_NO_PREFIX_CHAR_KEYS	(HA_NO_TEMP_TABLES*2) 
75 76
#define HA_CAN_FULLTEXT         (HA_NO_PREFIX_CHAR_KEYS*2)
#define HA_CAN_SQL_HANDLER      (HA_CAN_FULLTEXT*2)
unknown's avatar
unknown committed
77

78 79 80 81 82 83 84
/* Old not used flags */
/*
  Next record gives next record according last record read (even
  if database is updated after read)
*/
#define HA_LASTKEY_ORDER	0

unknown's avatar
unknown committed
85
	/* Parameters for open() (in register form->filestat) */
unknown's avatar
unknown committed
86
	/* HA_GET_INFO does an implicit HA_ABORT_IF_LOCKED */
unknown's avatar
unknown committed
87 88 89 90 91 92 93 94 95 96 97 98 99 100 101

#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 */
#define HA_TRY_READ_ONLY	32	/* Try readonly if can't */
					/* open with read and write */
#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

	/* Error on write which is recoverable  (Key exist) */

unknown's avatar
unknown committed
102
#define HA_WRITE_SKIP 121		/* Duplicate key on write */
unknown's avatar
unknown committed
103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119
#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

enum db_type { 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,
120
	       DB_TYPE_BERKELEY_DB, DB_TYPE_INNODB, DB_TYPE_GEMINI,
unknown's avatar
unknown committed
121 122
	       DB_TYPE_DEFAULT };

123 124
enum row_type { ROW_TYPE_NOT_USED=-1, ROW_TYPE_DEFAULT, ROW_TYPE_FIXED,
		ROW_TYPE_DYNAMIC, ROW_TYPE_COMPRESSED};
unknown's avatar
unknown committed
125 126 127 128

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

/* Bits in used_fields */
129 130 131 132
#define HA_CREATE_USED_AUTO		1
#define HA_CREATE_USED_RAID		2
#define HA_CREATE_USED_UNION		4
#define HA_CREATE_USED_INSERT_METHOD	8
133 134 135 136
#define HA_CREATE_USED_MIN_ROWS		16
#define HA_CREATE_USED_MAX_ROWS		32
#define HA_CREATE_USED_AVG_ROW_LENGTH	64
#define HA_CREATE_USED_PACK_KEYS	128
unknown's avatar
unknown committed
137

138 139 140
typedef struct st_thd_trans {
  void *bdb_tid;
  void *innobase_tid;
unknown's avatar
unknown committed
141
  bool innodb_active_trans;
142 143
} THD_TRANS;

unknown's avatar
unknown committed
144 145 146
enum enum_tx_isolation { ISO_READ_UNCOMMITTED, ISO_READ_COMMITTED,
			 ISO_REPEATABLE_READ, ISO_SERIALIZABLE};

unknown's avatar
unknown committed
147 148 149 150 151 152 153 154 155
typedef struct st_ha_create_information
{
  ulong table_options;
  enum db_type db_type;
  enum row_type row_type;
  ulong avg_row_length;
  ulonglong max_rows,min_rows;
  ulonglong auto_increment_value;
  char *comment,*password;
156
  char *data_file_name, *index_file_name;
157
  char *create_statement;
unknown's avatar
unknown committed
158 159 160 161 162
  uint options;					/* OR of HA_CREATE_ options */
  uint raid_type,raid_chunks;
  ulong raid_chunksize;
  bool if_not_exists;
  ulong used_fields;
163
  SQL_LIST merge_list;
164
  uint merge_insert_method;
unknown's avatar
unknown committed
165 166 167 168 169 170 171 172 173 174 175 176 177 178 179
} HA_CREATE_INFO;


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

struct st_table;
typedef struct st_table TABLE;
extern ulong myisam_sort_buffer_size;

typedef struct st_ha_check_opt
{
  ulong sort_buffer_size;
  uint flags;
  bool quick;
  bool changed_files;
180
  bool optimize;
181
  bool retry_without_quick;
unknown's avatar
unknown committed
182 183
  inline void init()
  {
184
    flags= 0; quick= optimize= retry_without_quick=0;
unknown's avatar
unknown committed
185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215
    sort_buffer_size = myisam_sort_buffer_size;
  }
} HA_CHECK_OPT;

class handler :public Sql_alloc
{
 protected:
  struct st_table *table;		/* The table definition */
  uint  active_index;

public:
  byte *ref;				/* Pointer to current row */
  byte *dupp_ref;			/* Pointer to dupp row */
  uint ref_length;			/* Length of ref (1-8) */
  uint block_size;			/* index block size */
  ha_rows records;			/* Records i datafilen */
  ha_rows deleted;			/* Deleted records */
  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;
  uint raid_type,raid_chunks;
  ulong raid_chunksize;
  uint errkey;				/* Last dup key */
  uint sortkey, key_used_on_scan;
  time_t create_time;			/* When table was created */
  time_t check_time;
  time_t update_time;
  ulong mean_rec_length;		/* physical reclength */
unknown's avatar
unknown committed
216
  FT_INFO *ft_handler;
217
  bool  auto_increment_column_changed;
unknown's avatar
unknown committed
218 219 220 221 222 223 224

  handler(TABLE *table_arg) : table(table_arg),active_index(MAX_REF_PARTS),
    ref(0),ref_length(sizeof(my_off_t)), block_size(0),records(0),deleted(0),
    data_file_length(0), max_data_file_length(0), index_file_length(0),
    delete_length(0), auto_increment_value(0), raid_type(0),
    key_used_on_scan(MAX_KEY),
    create_time(0), check_time(0), update_time(0), mean_rec_length(0),
225
    ft_handler(0)
unknown's avatar
unknown committed
226
    {}
unknown's avatar
unknown committed
227
  virtual ~handler(void) {}
unknown's avatar
unknown committed
228 229 230
  int ha_open(const char *name, int mode, int test_if_locked);
  void update_timestamp(byte *record);
  void update_auto_increment();
unknown's avatar
unknown committed
231
  virtual void print_error(int error, myf errflag);
unknown's avatar
unknown committed
232 233 234 235 236 237
  uint get_dup_key(int error);
  void change_table_ptr(TABLE *table_arg) { table=table_arg; }
  virtual double scan_time()
    { return ulonglong2double(data_file_length) / IO_SIZE + 1; }
  virtual double read_time(ha_rows rows) { return rows; }
  virtual bool fast_key_read() { return 0;}
unknown's avatar
unknown committed
238
  virtual key_map keys_to_use_for_scanning() { return 0; }
unknown's avatar
unknown committed
239
  virtual bool has_transactions(){ return 0;}
240
  virtual uint extra_rec_buf_length() { return 0; }
241
  virtual ha_rows estimate_number_of_rows() { return records+EXTRA_RECORDS; }
242
  virtual const char *index_type(uint key_number) { return "";}
unknown's avatar
unknown committed
243 244 245 246

  virtual int index_init(uint idx) { active_index=idx; return 0;}
  virtual int index_end() {return 0; }
  uint get_index(void) const { return active_index; }
247
  virtual int open(const char *name, int mode, uint test_if_locked)=0;
unknown's avatar
unknown committed
248 249 250 251 252 253
  virtual void initialize(void) {}
  virtual int close(void)=0;
  virtual int write_row(byte * buf)=0;
  virtual int update_row(const byte * old_data, byte * new_data)=0;
  virtual int delete_row(const byte * buf)=0;
  virtual int index_read(byte * buf, const byte * key,
254
			 uint key_len, enum ha_rkey_function find_flag)=0;
unknown's avatar
unknown committed
255 256 257 258 259 260 261
  virtual int index_read_idx(byte * buf, uint index, const byte * key,
			     uint key_len, enum ha_rkey_function find_flag)=0;
  virtual int index_next(byte * buf)=0;
  virtual int index_prev(byte * buf)=0;
  virtual int index_first(byte * buf)=0;
  virtual int index_last(byte * buf)=0;
  virtual int index_next_same(byte *buf, const byte *key, uint keylen);
262 263 264 265
  virtual int index_read_last(byte * buf, const byte * key, uint key_len)
  {
    return (my_errno=HA_ERR_WRONG_COMMAND);
  }
266
  virtual int ft_init()
267
    { return -1; }
unknown's avatar
unknown committed
268
  virtual FT_INFO *ft_init_ext(uint mode,uint inx,const byte *key, uint keylen,
269
			    bool presort)
unknown's avatar
unknown committed
270
    { return NULL; }
unknown's avatar
unknown committed
271 272 273 274 275
  virtual int ft_read(byte *buf) { return -1; }
  virtual int rnd_init(bool scan=1)=0;
  virtual int rnd_end() { return 0; }
  virtual int rnd_next(byte *buf)=0;
  virtual int rnd_pos(byte * buf, byte *pos)=0;
276
  virtual int read_first_row(byte *buf, uint primary_key);
unknown's avatar
unknown committed
277 278 279 280 281 282 283 284 285 286 287 288 289
  virtual int restart_rnd_next(byte *buf, byte *pos);
  virtual ha_rows records_in_range(int inx,
			           const byte *start_key,uint start_key_len,
			           enum ha_rkey_function start_search_flag,
			           const byte *end_key,uint end_key_len,
			           enum ha_rkey_function end_search_flag)
    { return (ha_rows) 10; }
  virtual void position(const byte *record)=0;
  virtual my_off_t row_position() { return HA_OFFSET_ERROR; }
  virtual void info(uint)=0;
  virtual int extra(enum ha_extra_function operation)=0;
  virtual int reset()=0;
  virtual int external_lock(THD *thd, int lock_type)=0;
unknown's avatar
unknown committed
290
  virtual void unlock_row() {}
unknown's avatar
unknown committed
291
  virtual int start_stmt(THD *thd) {return 0;}
unknown's avatar
unknown committed
292 293 294
  virtual int delete_all_rows();
  virtual longlong get_auto_increment();
  virtual void update_create_info(HA_CREATE_INFO *create_info) {}
295 296
  virtual int check(THD* thd,   HA_CHECK_OPT* check_opt );
  virtual int repair(THD* thd,  HA_CHECK_OPT* check_opt);
297
  virtual bool check_and_repair(THD *thd) {return 1;}
298 299
  virtual int optimize(THD* thd,HA_CHECK_OPT* check_opt);
  virtual int analyze(THD* thd, HA_CHECK_OPT* check_opt);
unknown's avatar
unknown committed
300 301
  virtual int backup(THD* thd, HA_CHECK_OPT* check_opt);
  virtual int restore(THD* thd, HA_CHECK_OPT* check_opt);
302 303
  // assumes .frm file must exist, and you must have already called
  // generate_table() - it will just copy the data file and run repair
304

unknown's avatar
unknown committed
305
  virtual int dump(THD* thd, int fd = -1) { return ER_DUMP_NOT_IMPLEMENTED; }
306 307
  virtual void deactivate_non_unique_index(ha_rows rows) {}
  virtual bool activate_all_index(THD *thd) {return 0;}
unknown's avatar
unknown committed
308 309 310
  // not implemented by default
  virtual int net_read_dump(NET* net)
  { return ER_DUMP_NOT_IMPLEMENTED; }
311 312 313
  virtual char *update_table_comment(const char * comment)
  { return (char*) comment;}
  virtual void append_create_info(String *packet) {}
314

unknown's avatar
unknown committed
315 316 317 318 319 320 321 322
  /* The following can be called without an open handler */
  virtual const char *table_type() const =0;
  virtual const char **bas_ext() const =0;
  virtual ulong option_flag() const =0;
  virtual uint max_record_length() const =0;
  virtual uint max_keys() const =0;
  virtual uint max_key_parts() const =0;
  virtual uint max_key_length()const =0;
323
  virtual uint max_key_part_length() { return 255; }
unknown's avatar
unknown committed
324 325
  virtual uint min_record_length(uint options) const { return 1; }
  virtual bool low_byte_first() const { return 1; }
326 327
  virtual bool is_crashed() const  { return 0; }
  virtual bool auto_repair() const { return 0; }
unknown's avatar
unknown committed
328 329 330 331 332 333 334 335 336 337 338 339 340

  virtual int rename_table(const char *from, const char *to);
  virtual int delete_table(const char *name);
  virtual int create(const char *name, TABLE *form, HA_CREATE_INFO *info)=0;
  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;
};

	/* Some extern variables used with handlers */

extern const char *ha_row_type[];
unknown's avatar
unknown committed
341
extern TYPELIB ha_table_typelib, tx_isolation_typelib;
unknown's avatar
unknown committed
342

343 344 345 346 347 348
	/* Wrapper functions */
#define ha_commit_stmt(thd) (ha_commit_trans((thd), &((thd)->transaction.stmt)))
#define ha_rollback_stmt(thd) (ha_rollback_trans((thd), &((thd)->transaction.stmt)))
#define ha_commit(thd) (ha_commit_trans((thd), &((thd)->transaction.all)))
#define ha_rollback(thd) (ha_rollback_trans((thd), &((thd)->transaction.all)))

349 350
#define ha_supports_generate(T) (T != DB_TYPE_INNODB)

unknown's avatar
unknown committed
351 352 353 354 355
handler *get_new_handler(TABLE *table, enum db_type db_type);
my_off_t ha_get_ptr(byte *ptr, uint pack_length);
void ha_store_ptr(byte *buff, uint pack_length, my_off_t pos);
int ha_init(void);
int ha_panic(enum ha_panic_function flag);
356
void ha_close_connection(THD* thd);
unknown's avatar
unknown committed
357 358 359 360
enum db_type ha_checktype(enum db_type database_type);
int ha_create_table(const char *name, HA_CREATE_INFO *create_info,
		    bool update_create_info);
int ha_delete_table(enum db_type db_type, const char *path);
361
void ha_drop_database(char* path);
unknown's avatar
unknown committed
362
void ha_key_cache(void);
unknown's avatar
unknown committed
363
int ha_start_stmt(THD *thd); 
364 365
int ha_commit_trans(THD *thd, THD_TRANS *trans);
int ha_rollback_trans(THD *thd, THD_TRANS *trans);
unknown's avatar
unknown committed
366
int ha_autocommit_or_rollback(THD *thd, int error);
unknown's avatar
unknown committed
367
void ha_set_spin_retries(uint retries);
unknown's avatar
unknown committed
368
bool ha_flush_logs(void);
369
int ha_recovery_logging(THD *thd, bool on);