← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/handler.h

  • Committer: Brian Aker
  • Date: 2009-02-11 02:40:38 UTC
  • mfrom: (873.1.1 temporal-new)
  • Revision ID: brian@tangent.org-20090211024038-nor7dnb3zgnejq25
Merge Jay.

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