← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/handler.h

  • Committer: Jay Pipes
  • Date: 2009-01-30 04:38:21 UTC
  • mto: This revision was merged to the branch mainline in revision 830.
  • Revision ID: jpipes@serialcoder-20090130043821-4d7jg2ftabefamxb
Fixes for the QUARTER() function to use new Temporal system and throw
errors on bad datetime values.

Added test case for QUARTER() function and modified func_time.test existing
test to correctly throw errors and report NULL, not 0 on NULL input.

Show diffs side-by-side

added added

removed removed

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