← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/handler.h

  • Committer: Monty Taylor
  • Date: 2008-12-18 07:24:54 UTC
  • mto: This revision was merged to the branch mainline in revision 714.
  • Revision ID: monty@bitters-20081218072454-8pnep622damjgqli
Fixed one more my_time thing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/handler.h
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2008 Sun Microsystems, Inc.
 
4
 *  Copyright (C) 2008 Sun Microsystems
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
17
17
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
18
18
 */
19
19
 
20
 
#ifndef DRIZZLED_CURSOR_H
21
 
#define DRIZZLED_CURSOR_H
 
20
#ifndef DRIZZLED_HANDLER_H
 
21
#define DRIZZLED_HANDLER_H
22
22
 
23
23
#include <drizzled/xid.h>
24
 
#include <drizzled/discrete_interval.h>
25
 
#include <drizzled/identifier.h>
26
 
#include <drizzled/definitions.h>
27
 
#include <drizzled/key_map.h>
28
 
#include <drizzled/error_t.h>
29
 
 
30
 
/* Definitions for parameters to do with Cursor-routines */
31
 
 
32
 
#include <drizzled/thr_lock.h>
 
24
 
 
25
/* Definitions for parameters to do with handler-routines */
 
26
 
 
27
#include <storage/myisam/keycache.h>
 
28
#include <mysys/thr_lock.h>
 
29
#include <mysys/hash.h>
 
30
#include <drizzled/sql_string.h>
33
31
#include <drizzled/sql_list.h>
 
32
#include <drizzled/handlerton.h>
34
33
#include <drizzled/handler_structs.h>
35
34
#include <drizzled/ha_statistics.h>
36
 
#include <drizzled/atomics.h>
37
 
 
38
 
#include <drizzled/message/table.h>
39
 
 
40
 
#include <bitset>
41
 
#include <algorithm>
42
 
 
43
 
#include "drizzled/visibility.h"
44
 
 
45
 
namespace drizzled
46
 
{
 
35
 
 
36
/* Bits to show what an alter table will do */
 
37
#include <drizzled/sql_bitmap.h>
47
38
 
48
39
#define HA_MAX_ALTER_FLAGS 40
49
 
 
50
 
typedef std::bitset<HA_MAX_ALTER_FLAGS> HA_ALTER_FLAGS;
51
 
 
52
 
class AlterInfo;
53
 
class CreateField;
54
 
class ForeignKeyInfo;
 
40
typedef Bitmap<HA_MAX_ALTER_FLAGS> HA_ALTER_FLAGS;
 
41
 
 
42
 
 
43
typedef bool (*qc_engine_callback)(Session *session, char *table_key,
 
44
                                      uint32_t key_length,
 
45
                                      uint64_t *engine_data);
 
46
 
 
47
 
 
48
/* The handler for a table type.  Will be included in the Table structure */
 
49
 
 
50
class Table;
 
51
class TableList;
 
52
typedef struct st_table_share TABLE_SHARE;
 
53
struct st_foreign_key_info;
 
54
typedef struct st_foreign_key_info FOREIGN_KEY_INFO;
 
55
struct order_st;
 
56
 
55
57
class Item;
56
 
class Item_ident;
 
58
struct st_table_log_memory_entry;
 
59
 
57
60
class LEX;
58
 
class Select_Lex;
59
 
class Select_Lex_Unit;
60
 
class String;
61
 
class Table;
62
 
class TableList;
63
 
class TableShare;
 
61
typedef class st_select_lex SELECT_LEX;
 
62
typedef class st_select_lex_unit SELECT_LEX_UNIT;
 
63
class Alter_info;
64
64
class select_result;
 
65
class Create_field;
65
66
class sys_var_str;
66
 
struct Order;
 
67
class Item_ident;
 
68
typedef struct st_sort_field SORT_FIELD;
67
69
 
68
70
typedef List<Item> List_item;
 
71
 
 
72
typedef struct st_savepoint SAVEPOINT;
 
73
extern uint32_t savepoint_alloc_size;
69
74
extern KEY_CREATE_INFO default_key_create_info;
70
75
 
71
76
/* Forward declaration for condition pushdown to storage engine */
72
77
typedef class Item COND;
73
78
 
74
 
typedef struct system_status_var system_status_var;
75
 
 
76
 
namespace optimizer { class CostVector; }
77
 
namespace plugin { class StorageEngine; }
78
 
 
 
79
typedef struct system_status_var SSV;
 
80
 
 
81
class COST_VECT;
 
82
 
 
83
uint16_t &mrr_persistent_flag_storage(range_seq_t seq, uint32_t idx);
 
84
char* &mrr_get_ptr_by_idx(range_seq_t seq, uint32_t idx);
 
85
 
 
86
uint32_t calculate_key_len(Table *, uint, const unsigned char *, key_part_map);
79
87
/*
80
88
  bitmap with first N+1 bits set
81
89
  (keypart_map for a key prefix of [0..N] keyparts)
97
105
}
98
106
 
99
107
/**
100
 
  The Cursor class is the interface for dynamically loadable
 
108
  The handler class is the interface for dynamically loadable
101
109
  storage engines. Do not add ifdefs and take care when adding or
102
110
  changing virtual functions to avoid vtable confusion
103
111
 
107
115
     storage engine
108
116
 
109
117
  2. KeyTupleFormat - used to pass index search tuples (aka "keys") to
110
 
     storage engine. See optimizer/range.cc for description of this format.
 
118
     storage engine. See opt_range.cc for description of this format.
111
119
 
112
120
  TableRecordFormat
113
121
  =================
132
140
  present, its length is one byte <not-sure> which must be set to 0xFF
133
141
  at all times. </not-sure>
134
142
 
 
143
  If the table has columns of type BIT, then certain bits from those columns
 
144
  may be stored in null_bytes as well. Grep around for Field_bit for
 
145
  details.
 
146
 
135
147
  For blob columns (see Field_blob), the record buffer stores length of the
136
148
  data, following by memory pointer to the blob data. The pointer is owned
137
149
  by the storage engine and is valid until the next operation.
139
151
  If a blob column has NULL value, then its length and blob data pointer
140
152
  must be set to 0.
141
153
*/
142
 
class DRIZZLED_API Cursor
 
154
 
 
155
class handler :public Sql_alloc
143
156
{
144
 
  friend class SEAPITesterCursor;
145
 
  Table &table;               /* The current open table */
146
 
  plugin::StorageEngine &engine;      /* storage engine of this Cursor */
147
 
 
 
157
public:
 
158
  typedef uint64_t Table_flags;
148
159
protected:
 
160
  struct st_table_share *table_share;   /* The table definition */
 
161
  Table *table;               /* The current open table */
 
162
  Table_flags cached_table_flags;       /* Set on init() and open() */
 
163
 
149
164
  ha_rows estimation_rows_to_insert;
150
 
 
151
165
public:
152
 
  inline plugin::StorageEngine *getEngine() const       /* table_type for handler */
153
 
  {
154
 
    return &engine;
155
 
  }
 
166
  handlerton *ht;                 /* storage engine of this handler */
156
167
  unsigned char *ref;                           /* Pointer to current row */
157
168
  unsigned char *dup_ref;                       /* Pointer to duplicate row */
158
169
 
159
 
  TableShare *getShare();
160
 
 
161
 
  Table *getTable() const
162
 
  {
163
 
    return &table;
164
 
  }
165
 
 
166
170
  ha_statistics stats;
167
171
  /** MultiRangeRead-related members: */
168
172
  range_seq_t mrr_iter;    /* Interator to traverse the range sequence */
169
173
  RANGE_SEQ_IF mrr_funcs;  /* Range sequence traversal functions */
170
 
 
 
174
  HANDLER_BUFFER *multi_range_buffer; /* MRR buffer info */
171
175
  uint32_t ranges_in_seq; /* Total number of ranges in the traversed sequence */
172
176
  /* true <=> source MRR ranges and the output are ordered */
173
177
  bool mrr_is_output_sorted;
174
178
 
175
179
  /** true <=> we're currently traversing a range in mrr_cur_range. */
176
180
  bool mrr_have_range;
177
 
 
178
 
  bool eq_range;
179
 
 
180
181
  /** Current range (the one we're now returning rows from) */
181
182
  KEY_MULTI_RANGE mrr_cur_range;
182
183
 
183
184
  /** The following are for read_range() */
184
185
  key_range save_end_range, *end_range;
185
 
  KeyPartInfo *range_key_part;
 
186
  KEY_PART_INFO *range_key_part;
186
187
  int key_compare_result_on_equal;
 
188
  bool eq_range;
 
189
  /*
 
190
    true <=> the engine guarantees that returned records are within the range
 
191
    being scanned.
 
192
  */
 
193
  bool in_range_check_pushed_down;
187
194
 
188
195
  uint32_t errkey;                              /* Last dup key */
189
196
  uint32_t key_used_on_scan;
192
199
  uint32_t ref_length;
193
200
  enum {NONE=0, INDEX, RND} inited;
194
201
  bool locked;
 
202
  bool implicit_emptied;                /* Can be !=0 only if HEAP */
 
203
  const Item *pushed_cond;
 
204
 
 
205
  Item *pushed_idx_cond;
 
206
  uint32_t pushed_idx_cond_keyno;  /* The index which the above condition is for */
195
207
 
196
208
  /**
197
209
    next_insert_id is the next value which should be inserted into the
203
215
    get_auto_increment().
204
216
  */
205
217
  uint64_t next_insert_id;
206
 
  uint64_t getNextInsertId()
207
 
  {
208
 
    return next_insert_id;
209
 
  }
210
 
 
211
 
  /**
212
 
    Used by SHOW TABLE STATUS to get the current auto_inc from the engine
213
 
  */
214
 
  uint64_t getAutoIncrement()
215
 
  {
216
 
    return stats.auto_increment_value;
217
 
  }
218
 
 
219
218
  /**
220
219
    insert id for the current row (*autogenerated*; if not
221
220
    autogenerated, it's 0).
229
228
  */
230
229
  Discrete_interval auto_inc_interval_for_cur_row;
231
230
 
232
 
  Cursor(plugin::StorageEngine &engine_arg, Table &share_arg);
233
 
  virtual ~Cursor(void);
234
 
  virtual Cursor *clone(memory::Root *mem_root);
 
231
  handler(handlerton *ht_arg, TABLE_SHARE *share_arg)
 
232
    :table_share(share_arg), table(0),
 
233
    estimation_rows_to_insert(0), ht(ht_arg),
 
234
    ref(0), in_range_check_pushed_down(false),
 
235
    key_used_on_scan(MAX_KEY), active_index(MAX_KEY),
 
236
    ref_length(sizeof(my_off_t)),
 
237
    inited(NONE),
 
238
    locked(false), implicit_emptied(0),
 
239
    pushed_cond(0), pushed_idx_cond(NULL), pushed_idx_cond_keyno(MAX_KEY),
 
240
    next_insert_id(0), insert_id_for_cur_row(0)
 
241
    {}
 
242
  virtual ~handler(void)
 
243
  {
 
244
    assert(locked == false);
 
245
    /* TODO: assert(inited == NONE); */
 
246
  }
 
247
  virtual handler *clone(MEM_ROOT *mem_root);
 
248
  /** This is called after create to allow us to set up cached variables */
 
249
  void init()
 
250
  {
 
251
    cached_table_flags= table_flags();
 
252
  }
235
253
 
236
254
  /* ha_ methods: pubilc wrappers for private virtual API */
237
255
 
238
 
  int ha_open(const identifier::Table &identifier, int mode, int test_if_locked);
239
 
  int startIndexScan(uint32_t idx, bool sorted) __attribute__ ((warn_unused_result));
240
 
  int endIndexScan();
241
 
  int startTableScan(bool scan) __attribute__ ((warn_unused_result));
242
 
  int endTableScan();
 
256
  int ha_open(Table *table, const char *name, int mode, int test_if_locked);
 
257
  int ha_index_init(uint32_t idx, bool sorted);
 
258
  int ha_index_end();
 
259
  int ha_rnd_init(bool scan);
 
260
  int ha_rnd_end();
243
261
  int ha_reset();
244
262
 
245
263
  /* this is necessary in many places, e.g. in HANDLER command */
246
264
  int ha_index_or_rnd_end();
 
265
  Table_flags ha_table_flags() const;
247
266
 
248
267
  /**
249
268
    These functions represent the public interface to *users* of the
250
 
    Cursor class, hence they are *not* virtual. For the inheritance
251
 
    interface, see the (private) functions doInsertRecord(), doUpdateRecord(),
252
 
    and doDeleteRecord() below.
 
269
    handler class, hence they are *not* virtual. For the inheritance
 
270
    interface, see the (private) functions write_row(), update_row(),
 
271
    and delete_row() below.
253
272
  */
254
273
  int ha_external_lock(Session *session, int lock_type);
255
 
  int insertRecord(unsigned char * buf) __attribute__ ((warn_unused_result));
256
 
  int updateRecord(const unsigned char * old_data, unsigned char * new_data) __attribute__ ((warn_unused_result));
257
 
  int deleteRecord(const unsigned char * buf) __attribute__ ((warn_unused_result));
 
274
  int ha_write_row(unsigned char * buf);
 
275
  int ha_update_row(const unsigned char * old_data, unsigned char * new_data);
 
276
  int ha_delete_row(const unsigned char * buf);
258
277
  void ha_release_auto_increment();
259
278
 
 
279
  int ha_check_for_upgrade(HA_CHECK_OPT *check_opt);
260
280
  /** to be actually called to get 'check()' functionality*/
261
281
  int ha_check(Session *session, HA_CHECK_OPT *check_opt);
262
 
 
 
282
  int ha_repair(Session* session, HA_CHECK_OPT* check_opt);
263
283
  void ha_start_bulk_insert(ha_rows rows);
264
284
  int ha_end_bulk_insert();
 
285
  int ha_bulk_update_row(const unsigned char *old_data, unsigned char *new_data,
 
286
                         uint32_t *dup_key_found);
265
287
  int ha_delete_all_rows();
266
288
  int ha_reset_auto_increment(uint64_t value);
 
289
  int ha_optimize(Session* session, HA_CHECK_OPT* check_opt);
267
290
  int ha_analyze(Session* session, HA_CHECK_OPT* check_opt);
268
 
 
 
291
  bool ha_check_and_repair(Session *session);
269
292
  int ha_disable_indexes(uint32_t mode);
270
293
  int ha_enable_indexes(uint32_t mode);
271
294
  int ha_discard_or_import_tablespace(bool discard);
272
 
  void closeMarkForDelete(const char *name);
 
295
  void ha_prepare_for_alter();
 
296
  int ha_rename_table(const char *from, const char *to);
 
297
  int ha_delete_table(const char *name);
 
298
  void ha_drop_table(const char *name);
 
299
 
 
300
  int ha_create(const char *name, Table *form, HA_CREATE_INFO *info);
 
301
 
 
302
  int ha_create_handler_files(const char *name, const char *old_name,
 
303
                              int action_flag, HA_CREATE_INFO *info);
273
304
 
274
305
  void adjust_next_insert_id_after_explicit_value(uint64_t nr);
275
306
  int update_auto_increment();
 
307
  void print_keydup_error(uint32_t key_nr, const char *msg);
 
308
  virtual void print_error(int error, myf errflag);
 
309
  virtual bool get_error_message(int error, String *buf);
 
310
  uint32_t get_dup_key(int error);
 
311
  virtual void change_table_ptr(Table *table_arg, TABLE_SHARE *share);
276
312
 
277
313
  /* Estimates calculation */
278
314
  virtual double scan_time(void)
285
321
  virtual ha_rows multi_range_read_info_const(uint32_t keyno, RANGE_SEQ_IF *seq,
286
322
                                              void *seq_init_param,
287
323
                                              uint32_t n_ranges, uint32_t *bufsz,
288
 
                                              uint32_t *flags, optimizer::CostVector *cost);
 
324
                                              uint32_t *flags, COST_VECT *cost);
289
325
  virtual int multi_range_read_info(uint32_t keyno, uint32_t n_ranges, uint32_t keys,
290
 
                                    uint32_t *bufsz, uint32_t *flags, optimizer::CostVector *cost);
 
326
                                    uint32_t *bufsz, uint32_t *flags, COST_VECT *cost);
291
327
  virtual int multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param,
292
 
                                    uint32_t n_ranges, uint32_t mode);
 
328
                                    uint32_t n_ranges, uint32_t mode,
 
329
                                    HANDLER_BUFFER *buf);
293
330
  virtual int multi_range_read_next(char **range_info);
294
331
 
295
332
 
296
333
  virtual const key_map *keys_to_use_for_scanning();
297
334
  bool has_transactions();
 
335
  virtual uint32_t extra_rec_buf_length() const { return 0; }
298
336
 
299
337
  /**
300
338
    This method is used to analyse the error to see whether the error
301
339
    is ignorable or not, certain handlers can have more error that are
302
 
    ignorable than others. E.g. the partition Cursor can get inserts
 
340
    ignorable than others. E.g. the partition handler can get inserts
303
341
    into a range where there is no partition and this is an ignorable
304
342
    error.
305
343
    HA_ERR_FOUND_DUP_UNIQUE is a special case in MyISAM that means the
313
351
    (table_flags() & (HA_HAS_RECORDS | HA_STATS_RECORDS_IS_EXACT)) != 0
314
352
  */
315
353
  virtual ha_rows records();
316
 
  virtual uint64_t tableSize();
317
 
  virtual uint64_t rowSize();
318
354
  /**
319
355
    Return upper bound of current number of records in the table
320
356
    (max. of how many records one will retrieve when doing a full table scan)
324
360
  virtual ha_rows estimate_rows_upper_bound()
325
361
  { return stats.records+EXTRA_RECORDS; }
326
362
 
 
363
  /**
 
364
    Get the row type from the storage engine.  If this method returns
 
365
    ROW_TYPE_NOT_USED, the information in HA_CREATE_INFO should be used.
 
366
  */
 
367
  virtual enum row_type get_row_type() const { return ROW_TYPE_NOT_USED; }
 
368
 
327
369
  virtual const char *index_type(uint32_t)
328
370
  { assert(0); return "";}
329
371
 
330
372
 
 
373
  /**
 
374
    Signal that the table->read_set and table->write_set table maps changed
 
375
    The handler is allowed to set additional bits in the above map in this
 
376
    call. Normally the handler should ignore all calls until we have done
 
377
    a ha_rnd_init() or ha_index_init(), write_row(), update_row or delete_row()
 
378
    as there may be several calls to this routine.
 
379
  */
 
380
  virtual void column_bitmaps_signal();
331
381
  uint32_t get_index(void) const { return active_index; }
332
382
  virtual int close(void)=0;
333
383
 
334
384
  /**
 
385
    @retval  0   Bulk update used by handler
 
386
    @retval  1   Bulk update not used, normal operation used
 
387
  */
 
388
  virtual bool start_bulk_update() { return 1; }
 
389
  /**
 
390
    @retval  0   Bulk delete used by handler
 
391
    @retval  1   Bulk delete not used, normal operation used
 
392
  */
 
393
  virtual bool start_bulk_delete() { return 1; }
 
394
  /**
 
395
    After this call all outstanding updates must be performed. The number
 
396
    of duplicate key errors are reported in the duplicate key parameter.
 
397
    It is allowed to continue to the batched update after this call, the
 
398
    handler has to wait until end_bulk_update with changing state.
 
399
 
 
400
    @param    dup_key_found       Number of duplicate keys found
 
401
 
 
402
    @retval  0           Success
 
403
    @retval  >0          Error code
 
404
  */
 
405
  virtual int exec_bulk_update(uint32_t *)
 
406
  {
 
407
    assert(false);
 
408
    return HA_ERR_WRONG_COMMAND;
 
409
  }
 
410
  /**
 
411
    Perform any needed clean-up, no outstanding updates are there at the
 
412
    moment.
 
413
  */
 
414
  virtual void end_bulk_update() { return; }
 
415
  /**
 
416
    Execute all outstanding deletes and close down the bulk delete.
 
417
 
 
418
    @retval 0             Success
 
419
    @retval >0            Error code
 
420
  */
 
421
  virtual int end_bulk_delete()
 
422
  {
 
423
    assert(false);
 
424
    return HA_ERR_WRONG_COMMAND;
 
425
  }
 
426
  /**
335
427
     @brief
336
428
     Positions an index cursor to the index specified in the handle. Fetches the
337
429
     row if available. If the key value is null, begin at the first key of the
338
430
     index.
339
431
  */
340
 
  virtual int index_read_map(unsigned char * buf, const unsigned char *key,
 
432
  virtual int index_read_map(unsigned char * buf, const unsigned char * key,
341
433
                             key_part_map keypart_map,
342
434
                             enum ha_rkey_function find_flag)
343
435
  {
344
 
    uint32_t key_len= calculate_key_len(active_index, keypart_map);
 
436
    uint32_t key_len= calculate_key_len(table, active_index, key, keypart_map);
345
437
    return  index_read(buf, key, key_len, find_flag);
346
438
  }
347
439
  /**
354
446
                                 const unsigned char * key,
355
447
                                 key_part_map keypart_map,
356
448
                                 enum ha_rkey_function find_flag);
357
 
  virtual int index_next(unsigned char *) __attribute__ ((warn_unused_result))
 
449
  virtual int index_next(unsigned char *)
358
450
   { return  HA_ERR_WRONG_COMMAND; }
359
451
  virtual int index_prev(unsigned char *)
360
452
   { return  HA_ERR_WRONG_COMMAND; }
363
455
  virtual int index_last(unsigned char *)
364
456
   { return  HA_ERR_WRONG_COMMAND; }
365
457
  virtual int index_next_same(unsigned char *, const unsigned char *, uint32_t);
366
 
 
367
 
private:
368
 
  uint32_t calculate_key_len(uint32_t key_position, key_part_map keypart_map_arg);
369
 
public:
370
 
 
371
458
  /**
372
459
     @brief
373
460
     The following functions works like index_read, but it find the last
376
463
  virtual int index_read_last_map(unsigned char * buf, const unsigned char * key,
377
464
                                  key_part_map keypart_map)
378
465
  {
379
 
    uint32_t key_len= calculate_key_len(active_index, keypart_map);
 
466
    uint32_t key_len= calculate_key_len(table, active_index, key, keypart_map);
380
467
    return index_read_last(buf, key, key_len);
381
468
  }
382
469
  virtual int read_range_first(const key_range *start_key,
384
471
                               bool eq_range, bool sorted);
385
472
  virtual int read_range_next();
386
473
  int compare_key(key_range *range);
 
474
  int compare_key2(key_range *range);
387
475
  virtual int rnd_next(unsigned char *)=0;
388
476
  virtual int rnd_pos(unsigned char *, unsigned char *)=0;
 
477
  /**
 
478
    One has to use this method when to find
 
479
    random position by record as the plain
 
480
    position() call doesn't work for some
 
481
    handlers for random position.
 
482
  */
 
483
  virtual int rnd_pos_by_record(unsigned char *record);
389
484
  virtual int read_first_row(unsigned char *buf, uint32_t primary_key);
 
485
  /**
 
486
    The following function is only needed for tables that may be temporary
 
487
    tables during joins.
 
488
  */
 
489
  virtual int restart_rnd_next(unsigned char *, unsigned char *)
 
490
    { return HA_ERR_WRONG_COMMAND; }
390
491
  virtual int rnd_same(unsigned char *, uint32_t)
391
492
    { return HA_ERR_WRONG_COMMAND; }
392
493
  virtual ha_rows records_in_range(uint32_t, key_range *, key_range *)
393
494
    { return (ha_rows) 10; }
394
495
  virtual void position(const unsigned char *record)=0;
395
 
  virtual int info(uint32_t)=0; // see my_base.h for full description
 
496
  virtual int info(uint)=0; // see my_base.h for full description
396
497
  virtual uint32_t calculate_key_hash_value(Field **)
397
498
  { assert(0); return 0; }
398
499
  virtual int extra(enum ha_extra_function)
421
522
  */
422
523
  virtual void try_semi_consistent_read(bool) {}
423
524
  virtual void unlock_row(void) {}
 
525
  virtual int start_stmt(Session *, thr_lock_type)
 
526
  {return 0;}
424
527
  virtual void get_auto_increment(uint64_t offset, uint64_t increment,
425
528
                                  uint64_t nb_desired_values,
426
529
                                  uint64_t *first_value,
427
 
                                  uint64_t *nb_reserved_values)= 0;
428
 
 
 
530
                                  uint64_t *nb_reserved_values);
429
531
  void set_next_insert_id(uint64_t id)
430
532
  {
431
533
    next_insert_id= id;
446
548
      insert_id_for_cur_row;
447
549
  }
448
550
 
 
551
  virtual void update_create_info(HA_CREATE_INFO *) {}
 
552
  int check_old_types(void);
 
553
  virtual int assign_to_keycache(Session*, HA_CHECK_OPT *)
 
554
  { return HA_ADMIN_NOT_IMPLEMENTED; }
449
555
  /* end of the list of admin commands */
450
556
 
451
557
  virtual int indexes_are_disabled(void) {return 0;}
 
558
  virtual char *update_table_comment(const char * comment)
 
559
  { return (char*) comment;}
452
560
  virtual void append_create_info(String *)
453
561
  {}
454
562
  /**
461
569
    @retval   true            Foreign key defined on table or index
462
570
    @retval   false           No foreign key defined
463
571
  */
 
572
  virtual bool is_fk_defined_on_table_or_index(uint32_t)
 
573
  { return false; }
464
574
  virtual char* get_foreign_key_create_info(void)
465
 
  { return NULL;}  /* gets foreign key create string from InnoDB */
466
 
  /** used in ALTER Table; if changing storage engine is allowed.
467
 
      e.g. not be allowed if table has foreign key constraints in engine.
468
 
   */
469
 
  virtual bool can_switch_engines(void) { return true; }
 
575
  { return(NULL);}  /* gets foreign key create string from InnoDB */
 
576
  /** used in ALTER Table; 1 if changing storage engine is allowed */
 
577
  virtual bool can_switch_engines(void) { return 1; }
470
578
  /** used in REPLACE; is > 0 if table is referred by a FOREIGN KEY */
471
 
  virtual int get_foreign_key_list(Session *, List<ForeignKeyInfo> *)
 
579
  virtual int get_foreign_key_list(Session *, List<FOREIGN_KEY_INFO> *)
472
580
  { return 0; }
473
581
  virtual uint32_t referenced_by_foreign_key() { return 0;}
 
582
  virtual void init_table_handle_for_HANDLER()
 
583
  { return; }       /* prepare InnoDB for HANDLER */
474
584
  virtual void free_foreign_key_create_info(char *) {}
475
 
 
 
585
  /** The following can be called without an open handler */
 
586
  virtual const char *table_type() const =0;
 
587
  /**
 
588
    If frm_error() is called then we will use this to find out what file
 
589
    extentions exist for the storage engine. This is also used by the default
 
590
    rename_table and delete_table method in handler.cc.
 
591
 
 
592
    For engines that have two file name extentions (separate meta/index file
 
593
    and data file), the order of elements is relevant. First element of engine
 
594
    file name extentions array should be meta/index file extention. Second
 
595
    element - data file extention. This order is assumed by
 
596
    prepare_for_repair() when REPAIR Table ... USE_FRM is issued.
 
597
  */
 
598
  virtual const char **bas_ext() const =0;
 
599
 
 
600
  virtual int get_default_no_partitions(HA_CREATE_INFO *) { return 1;}
 
601
  virtual bool get_no_parts(const char *, uint32_t *no_parts)
 
602
  {
 
603
    *no_parts= 0;
 
604
    return 0;
 
605
  }
 
606
 
 
607
  virtual uint32_t index_flags(uint32_t idx, uint32_t part, bool all_parts) const =0;
 
608
 
 
609
  virtual int add_index(Table *, KEY *, uint32_t)
 
610
  { return (HA_ERR_WRONG_COMMAND); }
 
611
  virtual int prepare_drop_index(Table *, uint32_t *, uint32_t)
 
612
  { return (HA_ERR_WRONG_COMMAND); }
 
613
  virtual int final_drop_index(Table *)
 
614
  { return (HA_ERR_WRONG_COMMAND); }
 
615
 
 
616
  uint32_t max_record_length() const
 
617
  { return cmin((unsigned int)HA_MAX_REC_LENGTH, max_supported_record_length()); }
 
618
  uint32_t max_keys() const
 
619
  { return cmin((unsigned int)MAX_KEY, max_supported_keys()); }
 
620
  uint32_t max_key_parts() const
 
621
  { return cmin((unsigned int)MAX_REF_PARTS, max_supported_key_parts()); }
 
622
  uint32_t max_key_length() const
 
623
  { return cmin((unsigned int)MAX_KEY_LENGTH, max_supported_key_length()); }
 
624
  uint32_t max_key_part_length(void) const
 
625
  { return cmin((unsigned int)MAX_KEY_LENGTH, max_supported_key_part_length()); }
 
626
 
 
627
  virtual uint32_t max_supported_record_length(void) const
 
628
  { return HA_MAX_REC_LENGTH; }
 
629
  virtual uint32_t max_supported_keys(void) const { return 0; }
 
630
  virtual uint32_t max_supported_key_parts(void) const { return MAX_REF_PARTS; }
 
631
  virtual uint32_t max_supported_key_length(void) const { return MAX_KEY_LENGTH; }
 
632
  virtual uint32_t max_supported_key_part_length(void) const { return 255; }
 
633
  virtual uint32_t min_record_length(uint32_t) const
 
634
  { return 1; }
 
635
 
 
636
  virtual bool low_byte_first(void) const { return 1; }
 
637
  virtual uint32_t checksum(void) const { return 0; }
 
638
  virtual bool is_crashed(void) const  { return 0; }
 
639
  virtual bool auto_repair(void) const { return 0; }
 
640
 
 
641
 
 
642
#define CHF_CREATE_FLAG 0
 
643
#define CHF_DELETE_FLAG 1
 
644
#define CHF_RENAME_FLAG 2
 
645
 
 
646
 
 
647
  /**
 
648
    @note lock_count() can return > 1 if the table is MERGE or partitioned.
 
649
  */
 
650
  virtual uint32_t lock_count(void) const { return 1; }
476
651
  /**
477
652
    Is not invoked for non-transactional temporary tables.
478
653
 
480
655
    or partitioned.
481
656
 
482
657
    @note that one can NOT rely on table->in_use in store_lock().  It may
483
 
    refer to a different thread if called from abortLockForThread().
 
658
    refer to a different thread if called from mysql_lock_abort_for_thread().
484
659
 
485
660
    @note If the table is MERGE, store_lock() can return less locks
486
661
    than lock_count() claimed. This can happen when the MERGE children
487
662
    are not attached when this is called from another thread.
488
663
  */
489
 
  virtual THR_LOCK_DATA **store_lock(Session *,
 
664
  virtual THR_LOCK_DATA **store_lock(Session *session,
490
665
                                     THR_LOCK_DATA **to,
491
 
                                     enum thr_lock_type)
 
666
                                     enum thr_lock_type lock_type)=0;
 
667
 
 
668
  /** Type of table for caching query */
 
669
  virtual uint8_t table_cache_type() { return HA_CACHE_TBL_NONTRANSACT; }
 
670
 
 
671
 
 
672
  /**
 
673
    @brief Register a named table with a call back function to the query cache.
 
674
 
 
675
    @param session The thread handle
 
676
    @param table_key A pointer to the table name in the table cache
 
677
    @param key_length The length of the table name
 
678
    @param[out] engine_callback The pointer to the storage engine call back
 
679
      function
 
680
    @param[out] engine_data Storage engine specific data which could be
 
681
      anything
 
682
 
 
683
    This method offers the storage engine, the possibility to store a reference
 
684
    to a table name which is going to be used with query cache.
 
685
    The method is called each time a statement is written to the cache and can
 
686
    be used to verify if a specific statement is cachable. It also offers
 
687
    the possibility to register a generic (but static) call back function which
 
688
    is called each time a statement is matched against the query cache.
 
689
 
 
690
    @note If engine_data supplied with this function is different from
 
691
      engine_data supplied with the callback function, and the callback returns
 
692
      false, a table invalidation on the current table will occur.
 
693
 
 
694
    @return Upon success the engine_callback will point to the storage engine
 
695
      call back function, if any, and engine_data will point to any storage
 
696
      engine data used in the specific implementation.
 
697
      @retval true Success
 
698
      @retval false The specified table or current statement should not be
 
699
        cached
 
700
  */
 
701
 
 
702
  virtual bool
 
703
    register_query_cache_table(Session *, char *, uint32_t,
 
704
                               qc_engine_callback *engine_callback,
 
705
                               uint64_t *)
492
706
  {
493
 
    assert(0); // Impossible programming situation
494
 
 
495
 
    return(to);
 
707
    *engine_callback= 0;
 
708
    return true;
496
709
  }
497
710
 
 
711
 
498
712
 /*
499
713
   @retval true   Primary key (if there is one) is clustered
500
714
                  key covering all fields
506
720
   return memcmp(ref1, ref2, ref_length);
507
721
 }
508
722
 
509
 
  virtual bool isOrdered(void)
 
723
 /*
 
724
   Condition pushdown to storage engines
 
725
 */
 
726
 
 
727
 /**
 
728
   Push condition down to the table handler.
 
729
 
 
730
   @param  cond   Condition to be pushed. The condition tree must not be
 
731
                  modified by the by the caller.
 
732
 
 
733
   @return
 
734
     The 'remainder' condition that caller must use to filter out records.
 
735
     NULL means the handler will not return rows that do not match the
 
736
     passed condition.
 
737
 
 
738
   @note
 
739
   The pushed conditions form a stack (from which one can remove the
 
740
   last pushed condition using cond_pop).
 
741
   The table handler filters out rows using (pushed_cond1 AND pushed_cond2
 
742
   AND ... AND pushed_condN)
 
743
   or less restrictive condition, depending on handler's capabilities.
 
744
 
 
745
   handler->ha_reset() call empties the condition stack.
 
746
   Calls to rnd_init/rnd_end, index_init/index_end etc do not affect the
 
747
   condition stack.
 
748
 */
 
749
 virtual const COND *cond_push(const COND *cond) { return cond; }
 
750
 
 
751
 /**
 
752
   Pop the top condition from the condition stack of the handler instance.
 
753
 
 
754
   Pops the top if condition stack, if stack is not empty.
 
755
 */
 
756
 virtual void cond_pop(void) { return; }
 
757
 
 
758
 virtual Item *idx_cond_push(uint32_t, Item *idx_cond)
 
759
 { return idx_cond; }
 
760
 
 
761
 /*
 
762
    Part of old fast alter table, to be depricated
 
763
  */
 
764
 virtual bool
 
765
   check_if_incompatible_data(HA_CREATE_INFO *, uint32_t)
 
766
 { return COMPATIBLE_DATA_NO; }
 
767
 
 
768
 /* On-line ALTER Table interface */
 
769
 
 
770
 /**
 
771
    Check if a storage engine supports a particular alter table on-line
 
772
 
 
773
    @param    altered_table     A temporary table show what table is to
 
774
                                change to
 
775
    @param    create_info       Information from the parsing phase about new
 
776
                                table properties.
 
777
    @param    alter_flags       Bitmask that shows what will be changed
 
778
    @param    table_changes     Shows if table layout has changed (for
 
779
                                backwards compatibility with
 
780
                                check_if_incompatible_data
 
781
 
 
782
    @retval   HA_ALTER_ERROR                Unexpected error
 
783
    @retval   HA_ALTER_SUPPORTED_WAIT_LOCK  Supported, but requires DDL lock
 
784
    @retval   HA_ALTER_SUPPORTED_NO_LOCK    Supported
 
785
    @retval   HA_ALTER_NOT_SUPPORTED        Not supported
 
786
 
 
787
    @note
 
788
      The default implementation is implemented to support fast
 
789
      alter table (storage engines that support some changes by
 
790
      just changing the frm file) without any change in the handler
 
791
      implementation.
 
792
 */
 
793
 virtual int check_if_supported_alter(Table *, HA_CREATE_INFO *create_info,
 
794
                                      HA_ALTER_FLAGS * alter_flags, uint32_t table_changes)
 
795
 {
 
796
   if (this->check_if_incompatible_data(create_info, table_changes)
 
797
       == COMPATIBLE_DATA_NO)
 
798
     return(HA_ALTER_NOT_SUPPORTED);
 
799
   else if ((*alter_flags & HA_ALTER_STORED_VCOL).is_set())
 
800
     return(HA_ALTER_NOT_SUPPORTED);
 
801
   else
 
802
     return(HA_ALTER_SUPPORTED_WAIT_LOCK);
 
803
 }
 
804
 /**
 
805
   Tell storage engine to prepare for the on-line alter table (pre-alter)
 
806
 
 
807
   @param     session               The thread handle
 
808
   @param     altered_table     A temporary table show what table is to
 
809
                                change to
 
810
   @param     alter_info        Storage place for data used during phase1
 
811
                                and phase2
 
812
   @param     alter_flags       Bitmask that shows what will be changed
 
813
 
 
814
   @retval   0      OK
 
815
   @retval   error  error code passed from storage engine
 
816
 */
 
817
 virtual int alter_table_phase1(Session *, Table *, HA_CREATE_INFO *, HA_ALTER_INFO *,
 
818
                                HA_ALTER_FLAGS *)
 
819
 {
 
820
   return HA_ERR_UNSUPPORTED;
 
821
 }
 
822
 /**
 
823
    Tell storage engine to perform the on-line alter table (alter)
 
824
 
 
825
    @param    session               The thread handle
 
826
    @param    altered_table     A temporary table show what table is to
 
827
                                change to
 
828
    @param    alter_info        Storage place for data used during phase1
 
829
                                and phase2
 
830
    @param    alter_flags       Bitmask that shows what will be changed
 
831
 
 
832
    @retval  0      OK
 
833
    @retval  error  error code passed from storage engine
 
834
 
 
835
    @note
 
836
      If check_if_supported_alter returns HA_ALTER_SUPPORTED_WAIT_LOCK
 
837
      this call is to be wrapped with a DDL lock. This is currently NOT
 
838
      supported.
 
839
 */
 
840
 virtual int alter_table_phase2(Session *, Table *, HA_CREATE_INFO *, HA_ALTER_INFO *,
 
841
                                HA_ALTER_FLAGS *)
 
842
 {
 
843
   return HA_ERR_UNSUPPORTED;
 
844
 }
 
845
 /**
 
846
    Tell storage engine that changed frm file is now on disk and table
 
847
    has been re-opened (post-alter)
 
848
 
 
849
    @param    session               The thread handle
 
850
    @param    table             The altered table, re-opened
 
851
 */
 
852
 virtual int alter_table_phase3(Session *, Table *)
 
853
 {
 
854
   return HA_ERR_UNSUPPORTED;
 
855
 }
 
856
 
 
857
  /**
 
858
    use_hidden_primary_key() is called in case of an update/delete when
 
859
    (table_flags() and HA_PRIMARY_KEY_REQUIRED_FOR_DELETE) is defined
 
860
    but we don't have a primary key
 
861
  */
 
862
  virtual void use_hidden_primary_key();
 
863
 
 
864
  /**
 
865
    Lock table.
 
866
 
 
867
    @param    session                     Thread handle
 
868
    @param    lock_type               HA_LOCK_IN_SHARE_MODE     (F_RDLCK)
 
869
                                      HA_LOCK_IN_EXCLUSIVE_MODE (F_WRLCK)
 
870
    @param    lock_timeout            -1 default timeout
 
871
                                      0  no wait
 
872
                                      >0 wait timeout in milliseconds.
 
873
 
 
874
   @note
 
875
      lock_timeout >0 is not used by MySQL currently. If the storage
 
876
      engine does not support NOWAIT (lock_timeout == 0) it should
 
877
      return an error. But if it does not support WAIT X (lock_timeout
 
878
      >0) it should treat it as lock_timeout == -1 and wait a default
 
879
      (or even hard-coded) timeout.
 
880
 
 
881
    @retval HA_ERR_WRONG_COMMAND      Storage engine does not support
 
882
                                      lock_table()
 
883
    @retval HA_ERR_UNSUPPORTED        Storage engine does not support NOWAIT
 
884
    @retval HA_ERR_LOCK_WAIT_TIMEOUT  Lock request timed out or
 
885
                                      lock conflict with NOWAIT option
 
886
    @retval HA_ERR_LOCK_DEADLOCK      Deadlock detected
 
887
  */
 
888
  virtual int lock_table(Session *, int, int)
510
889
  {
511
 
    return false;
 
890
    return HA_ERR_WRONG_COMMAND;
512
891
  }
513
 
 
 
892
  /*
 
893
    This procedure defines if the storage engine supports virtual columns.
 
894
    Default false means "not supported".
 
895
  */
 
896
  virtual bool check_if_supported_virtual_columns(void)
 
897
  { return false; }
514
898
 
515
899
protected:
516
900
  /* Service methods for use by storage engines. */
517
 
  void ha_statistic_increment(uint64_t system_status_var::*offset) const;
 
901
  void ha_statistic_increment(ulong SSV::*offset) const;
518
902
  void **ha_data(Session *) const;
 
903
  Session *ha_session(void) const;
 
904
 
 
905
  /**
 
906
    Default rename_table() and delete_table() rename/delete files with a
 
907
    given name and extensions from bas_ext().
 
908
 
 
909
    These methods can be overridden, but their default implementation
 
910
    provide useful functionality.
 
911
  */
 
912
  virtual int rename_table(const char *from, const char *to);
 
913
  /**
 
914
    Delete a table in the engine. Called for base as well as temporary
 
915
    tables.
 
916
  */
 
917
  virtual int delete_table(const char *name);
519
918
 
520
919
private:
521
920
  /* Private helpers */
522
 
  inline void setTransactionReadWrite();
 
921
  inline void mark_trx_read_write();
523
922
private:
524
923
  /*
525
924
    Low-level primitives for storage engines.  These should be
527
926
    the corresponding 'ha_*' method above.
528
927
  */
529
928
 
530
 
  virtual int open(const char *, int , uint32_t ) { assert(0); return -1; }
531
 
  virtual int doOpen(const identifier::Table &identifier, int mode, uint32_t test_if_locked);
532
 
  virtual int doStartIndexScan(uint32_t idx, bool)
 
929
  virtual int open(const char *name, int mode, uint32_t test_if_locked)=0;
 
930
  virtual int index_init(uint32_t idx, bool)
533
931
  { active_index= idx; return 0; }
534
 
  virtual int doEndIndexScan() { active_index= MAX_KEY; return 0; }
 
932
  virtual int index_end() { active_index= MAX_KEY; return 0; }
535
933
  /**
536
 
    doStartTableScan() can be called two times without doEndTableScan() in between
 
934
    rnd_init() can be called two times without rnd_end() in between
537
935
    (it only makes sense if scan=1).
538
936
    then the second call should prepare for the new table scan (e.g
539
937
    if rnd_init allocates the cursor, second call should position it
540
938
    to the start of the table, no need to deallocate and allocate it again
541
939
  */
542
 
  virtual int doStartTableScan(bool scan) __attribute__ ((warn_unused_result)) = 0;
543
 
  virtual int doEndTableScan() { return 0; }
544
 
  virtual int doInsertRecord(unsigned char *)
545
 
  {
546
 
    return HA_ERR_WRONG_COMMAND;
547
 
  }
548
 
 
549
 
  virtual int doUpdateRecord(const unsigned char *, unsigned char *)
550
 
  {
551
 
    return HA_ERR_WRONG_COMMAND;
552
 
  }
553
 
 
554
 
  virtual int doDeleteRecord(const unsigned char *)
 
940
  virtual int rnd_init(bool scan)= 0;
 
941
  virtual int rnd_end() { return 0; }
 
942
  virtual int write_row(unsigned char *)
 
943
  {
 
944
    return HA_ERR_WRONG_COMMAND;
 
945
  }
 
946
 
 
947
  virtual int update_row(const unsigned char *, unsigned char *)
 
948
  {
 
949
    return HA_ERR_WRONG_COMMAND;
 
950
  }
 
951
 
 
952
  virtual int delete_row(const unsigned char *)
555
953
  {
556
954
    return HA_ERR_WRONG_COMMAND;
557
955
  }
561
959
    by that statement.
562
960
  */
563
961
  virtual int reset() { return 0; }
 
962
  virtual Table_flags table_flags(void) const= 0;
564
963
 
565
964
  /**
566
965
    Is not invoked for non-transactional temporary tables.
567
966
 
568
967
    Tells the storage engine that we intend to read or write data
569
 
    from the table. This call is prefixed with a call to Cursor::store_lock()
570
 
    and is invoked only for those Cursor instances that stored the lock.
 
968
    from the table. This call is prefixed with a call to handler::store_lock()
 
969
    and is invoked only for those handler instances that stored the lock.
571
970
 
572
971
    Calls to rnd_init/index_init are prefixed with this call. When table
573
972
    IO is complete, we call external_lock(F_UNLCK).
588
987
  {
589
988
    return 0;
590
989
  }
591
 
  virtual void release_auto_increment(void) { return; }
 
990
  virtual void release_auto_increment(void) { return; };
592
991
  /** admin commands - called from mysql_admin_table */
593
 
  virtual int check(Session *)
 
992
  virtual int check_for_upgrade(HA_CHECK_OPT *)
 
993
  { return 0; }
 
994
  virtual int check(Session *, HA_CHECK_OPT *)
594
995
  { return HA_ADMIN_NOT_IMPLEMENTED; }
595
996
 
 
997
  /**
 
998
     In this method check_opt can be modified
 
999
     to specify CHECK option to use to call check()
 
1000
     upon the table.
 
1001
  */
 
1002
  virtual int repair(Session *, HA_CHECK_OPT *)
 
1003
  { return HA_ADMIN_NOT_IMPLEMENTED; }
596
1004
  virtual void start_bulk_insert(ha_rows)
597
1005
  {}
598
1006
  virtual int end_bulk_insert(void) { return 0; }
600
1008
                         uint32_t, enum ha_rkey_function)
601
1009
   { return  HA_ERR_WRONG_COMMAND; }
602
1010
  virtual int index_read_last(unsigned char *, const unsigned char *, uint32_t)
603
 
   { return (errno= HA_ERR_WRONG_COMMAND); }
 
1011
   { return (my_errno= HA_ERR_WRONG_COMMAND); }
 
1012
  /**
 
1013
    This method is similar to update_row, however the handler doesn't need
 
1014
    to execute the updates at this point in time. The handler can be certain
 
1015
    that another call to bulk_update_row will occur OR a call to
 
1016
    exec_bulk_update before the set of updates in this query is concluded.
 
1017
 
 
1018
    @param    old_data       Old record
 
1019
    @param    new_data       New record
 
1020
    @param    dup_key_found  Number of duplicate keys found
 
1021
 
 
1022
    @retval  0   Bulk delete used by handler
 
1023
    @retval  1   Bulk delete not used, normal operation used
 
1024
  */
 
1025
  virtual int bulk_update_row(const unsigned char *, unsigned char *, uint32_t *)
 
1026
  {
 
1027
    assert(false);
 
1028
    return HA_ERR_WRONG_COMMAND;
 
1029
  }
604
1030
  /**
605
1031
    This is called to delete all rows in a table
606
 
    If the Cursor don't support this, then this function will
 
1032
    If the handler don't support this, then this function will
607
1033
    return HA_ERR_WRONG_COMMAND and MySQL will delete the rows one
608
1034
    by one.
609
1035
  */
610
1036
  virtual int delete_all_rows(void)
611
 
  { return (errno=HA_ERR_WRONG_COMMAND); }
 
1037
  { return (my_errno=HA_ERR_WRONG_COMMAND); }
612
1038
  /**
613
1039
    Reset the auto-increment counter to the given value, i.e. the next row
614
1040
    inserted will get the given value. This is called e.g. after TRUNCATE
617
1043
  */
618
1044
  virtual int reset_auto_increment(uint64_t)
619
1045
  { return HA_ERR_WRONG_COMMAND; }
620
 
 
621
 
  virtual int analyze(Session *)
622
 
  { return HA_ADMIN_NOT_IMPLEMENTED; }
623
 
 
 
1046
  virtual int optimize(Session *, HA_CHECK_OPT *)
 
1047
  { return HA_ADMIN_NOT_IMPLEMENTED; }
 
1048
  virtual int analyze(Session *, HA_CHECK_OPT *)
 
1049
  { return HA_ADMIN_NOT_IMPLEMENTED; }
 
1050
  virtual bool check_and_repair(Session *)
 
1051
  { return true; }
624
1052
  virtual int disable_indexes(uint32_t)
625
1053
  { return HA_ERR_WRONG_COMMAND; }
626
 
 
627
1054
  virtual int enable_indexes(uint32_t)
628
1055
  { return HA_ERR_WRONG_COMMAND; }
629
 
 
630
1056
  virtual int discard_or_import_tablespace(bool)
631
 
  { return (errno=HA_ERR_WRONG_COMMAND); }
632
 
 
633
 
  /* 
634
 
    @todo this is just for the HEAP engine, it should
635
 
    be removed at some point in the future (and
636
 
    no new engine should ever use it). Right
637
 
    now HEAP does rely on it, so we cannot remove it.
638
 
  */
 
1057
  { return (my_errno=HA_ERR_WRONG_COMMAND); }
 
1058
  virtual void prepare_for_alter(void) { return; }
639
1059
  virtual void drop_table(const char *name);
 
1060
  virtual int create(const char *, Table *, HA_CREATE_INFO *)=0;
 
1061
 
 
1062
  virtual int create_handler_files(const char *, const char *, int, HA_CREATE_INFO *)
 
1063
  { return false; }
 
1064
};
 
1065
 
 
1066
 
 
1067
 
 
1068
/**
 
1069
  A Disk-Sweep MRR interface implementation
 
1070
 
 
1071
  This implementation makes range (and, in the future, 'ref') scans to read
 
1072
  table rows in disk sweeps.
 
1073
 
 
1074
  Currently it is used by MyISAM and InnoDB. Potentially it can be used with
 
1075
  any table handler that has non-clustered indexes and on-disk rows.
 
1076
*/
 
1077
 
 
1078
class DsMrr_impl
 
1079
{
 
1080
public:
 
1081
  typedef void (handler::*range_check_toggle_func_t)(bool on);
 
1082
 
 
1083
  DsMrr_impl()
 
1084
    : h2(NULL) {};
 
1085
 
 
1086
  handler *h; /* The "owner" handler object. It is used for scanning the index */
 
1087
  Table *table; /* Always equal to h->table */
 
1088
private:
 
1089
  /*
 
1090
    Secondary handler object. It is used to retrieve full table rows by
 
1091
    calling rnd_pos().
 
1092
  */
 
1093
  handler *h2;
 
1094
 
 
1095
  /* Buffer to store rowids, or (rowid, range_id) pairs */
 
1096
  unsigned char *rowids_buf;
 
1097
  unsigned char *rowids_buf_cur;   /* Current position when reading/writing */
 
1098
  unsigned char *rowids_buf_last;  /* When reading: end of used buffer space */
 
1099
  unsigned char *rowids_buf_end;   /* End of the buffer */
 
1100
 
 
1101
  bool dsmrr_eof; /* true <=> We have reached EOF when reading index tuples */
 
1102
 
 
1103
  /* true <=> need range association, buffer holds {rowid, range_id} pairs */
 
1104
  bool is_mrr_assoc;
 
1105
 
 
1106
  bool use_default_impl; /* true <=> shortcut all calls to default MRR impl */
 
1107
public:
 
1108
  void init(handler *h_arg, Table *table_arg)
 
1109
  {
 
1110
    h= h_arg;
 
1111
    table= table_arg;
 
1112
  }
 
1113
  int dsmrr_init(handler *h, KEY *key, RANGE_SEQ_IF *seq_funcs,
 
1114
                 void *seq_init_param, uint32_t n_ranges, uint32_t mode,
 
1115
                 HANDLER_BUFFER *buf);
 
1116
  void dsmrr_close();
 
1117
  int dsmrr_fill_buffer(handler *h);
 
1118
  int dsmrr_next(handler *h, char **range_info);
 
1119
 
 
1120
  int dsmrr_info(uint32_t keyno, uint32_t n_ranges, uint32_t keys, uint32_t *bufsz,
 
1121
                 uint32_t *flags, COST_VECT *cost);
 
1122
 
 
1123
  ha_rows dsmrr_info_const(uint32_t keyno, RANGE_SEQ_IF *seq,
 
1124
                            void *seq_init_param, uint32_t n_ranges, uint32_t *bufsz,
 
1125
                            uint32_t *flags, COST_VECT *cost);
 
1126
private:
 
1127
  bool key_uses_partial_cols(uint32_t keyno);
 
1128
  bool choose_mrr_impl(uint32_t keyno, ha_rows rows, uint32_t *flags, uint32_t *bufsz,
 
1129
                       COST_VECT *cost);
 
1130
  bool get_disk_sweep_mrr_cost(uint32_t keynr, ha_rows rows, uint32_t flags,
 
1131
                               uint32_t *buffer_size, COST_VECT *cost);
640
1132
};
641
1133
 
642
1134
extern const char *ha_row_type[];
 
1135
extern const char *tx_isolation_names[];
 
1136
extern const char *binlog_format_names[];
 
1137
extern TYPELIB tx_isolation_typelib;
 
1138
extern TYPELIB myisam_stats_method_typelib;
 
1139
extern uint32_t total_ha, total_ha_2pc;
 
1140
 
 
1141
       /* Wrapper functions */
 
1142
#define ha_commit(session) (ha_commit_trans((session), true))
 
1143
#define ha_rollback(session) (ha_rollback_trans((session), true))
643
1144
 
644
1145
/* basic stuff */
645
 
void ha_init_errors(void);
646
 
 
647
 
class SortField;
648
 
SortField *make_unireg_sortorder(Order *order, uint32_t *length,
649
 
                                 SortField *sortorder);
 
1146
int ha_init_errors(void);
 
1147
int ha_init(void);
 
1148
int ha_end(void);
 
1149
int ha_initialize_handlerton(st_plugin_int *plugin);
 
1150
int ha_finalize_handlerton(st_plugin_int *plugin);
 
1151
 
 
1152
TYPELIB *ha_known_exts(void);
 
1153
void ha_close_connection(Session* session);
 
1154
bool ha_flush_logs(handlerton *db_type);
 
1155
void ha_drop_database(char* path);
 
1156
int ha_create_table(Session *session, const char *path,
 
1157
                    const char *db, const char *table_name,
 
1158
                    HA_CREATE_INFO *create_info,
 
1159
                    bool update_create_info);
 
1160
int ha_delete_table(Session *session, const char *path,
 
1161
                    const char *db, const char *alias, bool generate_warning);
 
1162
 
 
1163
/* statistics and info */
 
1164
bool ha_show_status(Session *session, handlerton *db_type, enum ha_stat_type stat);
 
1165
 
 
1166
int ha_find_files(Session *session,const char *db,const char *path,
 
1167
                  const char *wild, bool dir, List<LEX_STRING>* files);
 
1168
int ha_table_exists_in_engine(Session* session, const char* db, const char* name);
 
1169
 
 
1170
/* key cache */
 
1171
extern "C" int ha_init_key_cache(const char *name, KEY_CACHE *key_cache);
 
1172
int ha_resize_key_cache(KEY_CACHE *key_cache);
 
1173
int ha_change_key_cache_param(KEY_CACHE *key_cache);
 
1174
int ha_change_key_cache(KEY_CACHE *old_key_cache, KEY_CACHE *new_key_cache);
 
1175
int ha_end_key_cache(KEY_CACHE *key_cache);
 
1176
 
 
1177
/* report to InnoDB that control passes to the client */
 
1178
int ha_release_temporary_latches(Session *session);
 
1179
 
 
1180
/* transactions: interface to handlerton functions */
 
1181
int ha_start_consistent_snapshot(Session *session);
 
1182
int ha_commit_or_rollback_by_xid(XID *xid, bool commit);
 
1183
int ha_commit_one_phase(Session *session, bool all);
 
1184
int ha_rollback_trans(Session *session, bool all);
 
1185
int ha_prepare(Session *session);
 
1186
int ha_recover(HASH *commit_list);
 
1187
 
 
1188
/* transactions: these functions never call handlerton functions directly */
 
1189
int ha_commit_trans(Session *session, bool all);
 
1190
int ha_autocommit_or_rollback(Session *session, int error);
 
1191
int ha_enable_transaction(Session *session, bool on);
 
1192
 
 
1193
/* savepoints */
 
1194
int ha_rollback_to_savepoint(Session *session, SAVEPOINT *sv);
 
1195
int ha_savepoint(Session *session, SAVEPOINT *sv);
 
1196
int ha_release_savepoint(Session *session, SAVEPOINT *sv);
 
1197
 
 
1198
/* these are called by storage engines */
 
1199
void trans_register_ha(Session *session, bool all, handlerton *ht);
 
1200
 
 
1201
void table_case_convert(char * name, uint32_t length);
 
1202
const char *table_case_name(HA_CREATE_INFO *info, const char *name);
 
1203
 
 
1204
extern char reg_ext[FN_EXTLEN];
 
1205
extern uint32_t reg_ext_length;
 
1206
extern ulong specialflag;
 
1207
extern uint32_t lower_case_table_names;
 
1208
uint32_t filename_to_tablename(const char *from, char *to, uint32_t to_length);
 
1209
uint32_t tablename_to_filename(const char *from, char *to, uint32_t to_length);
 
1210
 
 
1211
 
 
1212
bool mysql_ha_open(Session *session, TableList *tables, bool reopen);
 
1213
bool mysql_ha_close(Session *session, TableList *tables);
 
1214
bool mysql_ha_read(Session *, TableList *,enum enum_ha_read_modes,char *,
 
1215
                   List<Item> *,enum ha_rkey_function,Item *,ha_rows,ha_rows);
 
1216
void mysql_ha_flush(Session *session);
 
1217
void mysql_ha_rm_tables(Session *session, TableList *tables, bool is_locked);
 
1218
void mysql_ha_cleanup(Session *session);
 
1219
 
 
1220
/*
 
1221
  Storage engine has to assume the transaction will end up with 2pc if
 
1222
   - there is more than one 2pc-capable storage engine available
 
1223
   - in the current transaction 2pc was not disabled yet
 
1224
*/
 
1225
#define trans_need_2pc(session, all)                   ((total_ha_2pc > 1) && \
 
1226
        !((all ? &session->transaction.all : &session->transaction.stmt)->no_2pc))
 
1227
 
 
1228
 
 
1229
bool mysql_xa_recover(Session *session);
 
1230
 
 
1231
SORT_FIELD * make_unireg_sortorder(order_st *order, uint32_t *length,
 
1232
                                   SORT_FIELD *sortorder);
650
1233
int setup_order(Session *session, Item **ref_pointer_array, TableList *tables,
651
 
                List<Item> &fields, List <Item> &all_fields, Order *order);
 
1234
                List<Item> &fields, List <Item> &all_fields, order_st *order);
652
1235
int setup_group(Session *session, Item **ref_pointer_array, TableList *tables,
653
 
                List<Item> &fields, List<Item> &all_fields, Order *order,
 
1236
                List<Item> &fields, List<Item> &all_fields, order_st *order,
654
1237
                bool *hidden_group_fields);
655
 
bool fix_inner_refs(Session *session, List<Item> &all_fields, Select_Lex *select,
 
1238
bool fix_inner_refs(Session *session, List<Item> &all_fields, SELECT_LEX *select,
656
1239
                    Item **ref_pointer_array);
657
1240
 
658
1241
bool handle_select(Session *session, LEX *lex, select_result *result,
659
 
                   uint64_t setup_tables_done_option);
660
 
void free_underlaid_joins(Session *session, Select_Lex *select);
661
 
 
662
 
bool handle_derived(LEX *lex, bool (*processor)(Session *session,
 
1242
                   ulong setup_tables_done_option);
 
1243
bool mysql_select(Session *session, Item ***rref_pointer_array,
 
1244
                  TableList *tables, uint32_t wild_num,  List<Item> &list,
 
1245
                  COND *conds, uint32_t og_num, order_st *order, order_st *group,
 
1246
                  Item *having, order_st *proc_param, uint64_t select_type,
 
1247
                  select_result *result, SELECT_LEX_UNIT *unit,
 
1248
                  SELECT_LEX *select_lex);
 
1249
void free_underlaid_joins(Session *session, SELECT_LEX *select);
 
1250
bool mysql_explain_union(Session *session, SELECT_LEX_UNIT *unit,
 
1251
                         select_result *result);
 
1252
int mysql_explain_select(Session *session, SELECT_LEX *sl, char const *type,
 
1253
                         select_result *result);
 
1254
bool mysql_union(Session *session, LEX *lex, select_result *result,
 
1255
                 SELECT_LEX_UNIT *unit, ulong setup_tables_done_option);
 
1256
bool mysql_handle_derived(LEX *lex, bool (*processor)(Session *session,
663
1257
                                                      LEX *lex,
664
1258
                                                      TableList *table));
665
 
bool derived_prepare(Session *session, LEX *lex, TableList *t);
666
 
bool derived_filling(Session *session, LEX *lex, TableList *t);
667
 
int prepare_create_field(CreateField *sql_field,
 
1259
bool mysql_derived_prepare(Session *session, LEX *lex, TableList *t);
 
1260
bool mysql_derived_filling(Session *session, LEX *lex, TableList *t);
 
1261
void sp_prepare_create_field(Session *session, Create_field *sql_field);
 
1262
int prepare_create_field(Create_field *sql_field,
668
1263
                         uint32_t *blob_columns,
669
 
                         int *timestamps, int *timestamps_with_niladic);
670
 
 
671
 
bool create_table(Session *session,
672
 
                  const identifier::Table &identifier,
673
 
                  HA_CREATE_INFO *create_info,
674
 
                  message::Table &table_proto,
675
 
                  AlterInfo *alter_info,
676
 
                  bool tmp_table, uint32_t select_field_count,
677
 
                  bool is_if_not_exists);
678
 
 
679
 
bool create_table_no_lock(Session *session,
680
 
                          const identifier::Table &identifier,
681
 
                          HA_CREATE_INFO *create_info,
682
 
                          message::Table &table_proto,
683
 
                          AlterInfo *alter_info,
684
 
                          bool tmp_table, uint32_t select_field_count,
685
 
                          bool is_if_not_exists);
686
 
 
687
 
bool create_like_table(Session* session,
688
 
                       identifier::Table::const_reference destination_identifier,
689
 
                       identifier::Table::const_reference source_identifier,
690
 
                       message::Table &create_table_proto,
691
 
                       bool is_if_not_exists,
692
 
                       bool is_engine_set);
693
 
 
694
 
bool rename_table(Session &session,
695
 
                        plugin::StorageEngine *base,
696
 
                        const identifier::Table &old_identifier,
697
 
                        const identifier::Table &new_identifier);
698
 
 
699
 
bool prepare_update(Session *session, TableList *table_list,
700
 
                          Item **conds, uint32_t order_num, Order *order);
701
 
int update_query(Session *session,TableList *tables,List<Item> &fields,
 
1264
                         int *timestamps, int *timestamps_with_niladic,
 
1265
                         int64_t table_flags);
 
1266
bool mysql_create_table(Session *session,const char *db, const char *table_name,
 
1267
                        HA_CREATE_INFO *create_info,
 
1268
                        Alter_info *alter_info,
 
1269
                        bool tmp_table, uint32_t select_field_count);
 
1270
bool mysql_create_table_no_lock(Session *session, const char *db,
 
1271
                                const char *table_name,
 
1272
                                HA_CREATE_INFO *create_info,
 
1273
                                Alter_info *alter_info,
 
1274
                                bool tmp_table, uint32_t select_field_count,
 
1275
                                bool lock_open_lock);
 
1276
 
 
1277
bool mysql_alter_table(Session *session, char *new_db, char *new_name,
 
1278
                       HA_CREATE_INFO *create_info,
 
1279
                       TableList *table_list,
 
1280
                       Alter_info *alter_info,
 
1281
                       uint32_t order_num, order_st *order, bool ignore);
 
1282
bool mysql_recreate_table(Session *session, TableList *table_list);
 
1283
bool mysql_create_like_table(Session *session, TableList *table,
 
1284
                             TableList *src_table,
 
1285
                             HA_CREATE_INFO *create_info);
 
1286
bool mysql_rename_table(handlerton *base, const char *old_db,
 
1287
                        const char * old_name, const char *new_db,
 
1288
                        const char * new_name, uint32_t flags);
 
1289
bool mysql_prepare_update(Session *session, TableList *table_list,
 
1290
                          Item **conds, uint32_t order_num, order_st *order);
 
1291
int mysql_update(Session *session,TableList *tables,List<Item> &fields,
702
1292
                 List<Item> &values,COND *conds,
703
 
                 uint32_t order_num, Order *order, ha_rows limit,
 
1293
                 uint32_t order_num, order_st *order, ha_rows limit,
704
1294
                 enum enum_duplicates handle_duplicates, bool ignore);
705
 
bool prepare_insert(Session *session, TableList *table_list, Table *table,
 
1295
bool mysql_multi_update(Session *session, TableList *table_list,
 
1296
                        List<Item> *fields, List<Item> *values,
 
1297
                        COND *conds, uint64_t options,
 
1298
                        enum enum_duplicates handle_duplicates, bool ignore,
 
1299
                        SELECT_LEX_UNIT *unit, SELECT_LEX *select_lex);
 
1300
bool mysql_prepare_insert(Session *session, TableList *table_list, Table *table,
706
1301
                          List<Item> &fields, List_item *values,
707
1302
                          List<Item> &update_fields,
708
1303
                          List<Item> &update_values, enum_duplicates duplic,
709
1304
                          COND **where, bool select_insert,
710
1305
                          bool check_fields, bool abort_on_warning);
711
 
bool insert_query(Session *session,TableList *table,List<Item> &fields,
 
1306
bool mysql_insert(Session *session,TableList *table,List<Item> &fields,
712
1307
                  List<List_item> &values, List<Item> &update_fields,
713
1308
                  List<Item> &update_values, enum_duplicates flag,
714
1309
                  bool ignore);
715
1310
int check_that_all_fields_are_given_values(Session *session, Table *entry,
716
1311
                                           TableList *table_list);
717
 
int prepare_delete(Session *session, TableList *table_list, Item **conds);
718
 
bool delete_query(Session *session, TableList *table_list, COND *conds,
 
1312
void prepare_triggers_for_insert_stmt(Table *table);
 
1313
int mysql_prepare_delete(Session *session, TableList *table_list, Item **conds);
 
1314
bool mysql_delete(Session *session, TableList *table_list, COND *conds,
719
1315
                  SQL_LIST *order, ha_rows rows, uint64_t options,
720
1316
                  bool reset_auto_increment);
721
 
bool truncate(Session& session, TableList *table_list);
722
 
TableShare *get_table_share(Session *session, TableList *table_list, char *key,
 
1317
bool mysql_truncate(Session *session, TableList *table_list, bool dont_send_ok);
 
1318
uint32_t create_table_def_key(Session *session, char *key, TableList *table_list,
 
1319
                              bool tmp_table);
 
1320
TABLE_SHARE *get_table_share(Session *session, TableList *table_list, char *key,
723
1321
                             uint32_t key_length, uint32_t db_flags, int *error);
724
 
TableShare *get_cached_table_share(const char *db, const char *table_name);
 
1322
void release_table_share(TABLE_SHARE *share, enum release_type type);
 
1323
TABLE_SHARE *get_cached_table_share(const char *db, const char *table_name);
 
1324
Table *open_ltable(Session *session, TableList *table_list, thr_lock_type update,
 
1325
                   uint32_t lock_flags);
 
1326
Table *open_table(Session *session, TableList *table_list, bool *refresh, uint32_t flags);
 
1327
bool name_lock_locked_table(Session *session, TableList *tables);
725
1328
bool reopen_name_locked_table(Session* session, TableList* table_list, bool link_in);
 
1329
Table *table_cache_insert_placeholder(Session *session, const char *key,
 
1330
                                      uint32_t key_length);
 
1331
bool lock_table_name_if_not_cached(Session *session, const char *db,
 
1332
                                   const char *table_name, Table **table);
 
1333
Table *find_locked_table(Session *session, const char *db,const char *table_name);
 
1334
void detach_merge_children(Table *table, bool clear_refs);
 
1335
bool fix_merge_after_open(TableList *old_child_list, TableList **old_last,
 
1336
                          TableList *new_child_list, TableList **new_last);
 
1337
bool reopen_table(Table *table);
726
1338
bool reopen_tables(Session *session,bool get_locks,bool in_refresh);
 
1339
void close_data_files_and_morph_locks(Session *session, const char *db,
 
1340
                                      const char *table_name);
727
1341
void close_handle_and_leave_table_as_lock(Table *table);
 
1342
bool open_new_frm(Session *session, TABLE_SHARE *share, const char *alias,
 
1343
                  uint32_t db_stat, uint32_t prgflag,
 
1344
                  uint32_t ha_open_flags, Table *outparam,
 
1345
                  TableList *table_desc, MEM_ROOT *mem_root);
728
1346
bool wait_for_tables(Session *session);
729
1347
bool table_is_used(Table *table, bool wait_for_name_lock);
730
 
Table *drop_locked_tables(Session *session, const drizzled::identifier::Table &identifier);
731
 
void abort_locked_tables(Session *session, const drizzled::identifier::Table &identifier);
 
1348
Table *drop_locked_tables(Session *session,const char *db, const char *table_name);
 
1349
void abort_locked_tables(Session *session,const char *db, const char *table_name);
 
1350
void execute_init_command(Session *session, sys_var_str *init_command_var,
 
1351
                          pthread_rwlock_t *var_mutex);
732
1352
extern Field *not_found_field;
733
1353
extern Field *view_ref_found;
734
1354
 
736
1356
find_field_in_tables(Session *session, Item_ident *item,
737
1357
                     TableList *first_table, TableList *last_table,
738
1358
                     Item **ref, find_item_error_report_type report_error,
739
 
                     bool register_tree_change);
 
1359
                     bool check_privileges, bool register_tree_change);
740
1360
Field *
741
1361
find_field_in_table_ref(Session *session, TableList *table_list,
742
1362
                        const char *name, uint32_t length,
743
1363
                        const char *item_name, const char *db_name,
744
1364
                        const char *table_name, Item **ref,
745
 
                        bool allow_rowid,
 
1365
                        bool check_privileges, bool allow_rowid,
746
1366
                        uint32_t *cached_field_index_ptr,
747
1367
                        bool register_tree_change, TableList **actual_table);
748
1368
Field *
749
1369
find_field_in_table(Session *session, Table *table, const char *name, uint32_t length,
750
1370
                    bool allow_rowid, uint32_t *cached_field_index_ptr);
751
 
 
752
 
} /* namespace drizzled */
753
 
 
754
 
#endif /* DRIZZLED_CURSOR_H */
 
1371
Field *
 
1372
find_field_in_table_sef(Table *table, const char *name);
 
1373
int update_virtual_fields_marked_for_write(Table *table,
 
1374
                                           bool ignore_stored=true);
 
1375
 
 
1376
 
 
1377
#endif /* DRIZZLED_HANDLER_H */