← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/cursor.h

New merge for TableShare

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/cursor.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
25
 
29
26
/* Definitions for parameters to do with Cursor-routines */
30
27
 
31
 
#include <drizzled/thr_lock.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
32
#include <drizzled/plugin/storage_engine.h>
38
36
 
39
37
#include <drizzled/message/table.pb.h>
40
38
 
 
39
/* Bits to show what an alter table will do */
 
40
#include <drizzled/sql_bitmap.h>
 
41
 
 
42
#include <drizzled/cursor.h>
 
43
 
41
44
#include <bitset>
42
45
#include <algorithm>
43
46
 
44
 
namespace drizzled
45
 
{
46
 
 
47
47
#define HA_MAX_ALTER_FLAGS 40
48
48
 
 
49
 
49
50
typedef std::bitset<HA_MAX_ALTER_FLAGS> HA_ALTER_FLAGS;
50
51
 
51
52
extern uint64_t refresh_version;  /* Increments on each reload */
52
53
 
 
54
 
 
55
typedef bool (*qc_engine_callback)(Session *session, char *table_key,
 
56
                                      uint32_t key_length,
 
57
                                      uint64_t *engine_data);
 
58
 
 
59
 
 
60
/* The Cursor for a table type.  Will be included in the Table structure */
 
61
 
53
62
class Table;
54
63
class TableList;
55
64
class TableShare;
56
65
class Select_Lex_Unit;
57
 
class ForeignKeyInfo;
58
 
struct Order;
 
66
struct st_foreign_key_info;
 
67
typedef struct st_foreign_key_info FOREIGN_KEY_INFO;
 
68
struct order_st;
59
69
 
60
70
class Item;
 
71
struct st_table_log_memory_entry;
61
72
 
62
73
class LEX;
63
74
class Select_Lex;
66
77
class CreateField;
67
78
class sys_var_str;
68
79
class Item_ident;
 
80
typedef struct st_sort_field SORT_FIELD;
69
81
 
70
82
typedef List<Item> List_item;
 
83
 
 
84
typedef struct st_savepoint SAVEPOINT;
 
85
extern uint32_t savepoint_alloc_size;
71
86
extern KEY_CREATE_INFO default_key_create_info;
72
87
 
73
88
/* Forward declaration for condition pushdown to storage engine */
74
89
typedef class Item COND;
75
90
 
76
 
typedef struct system_status_var system_status_var;
77
 
 
78
 
namespace optimizer
79
 
{
80
 
  class CostVector;
81
 
}
82
 
 
 
91
typedef struct system_status_var SSV;
 
92
 
 
93
class COST_VECT;
 
94
 
 
95
uint32_t calculate_key_len(Table *, uint, const unsigned char *, key_part_map);
83
96
/*
84
97
  bitmap with first N+1 bits set
85
98
  (keypart_map for a key prefix of [0..N] keyparts)
111
124
     storage engine
112
125
 
113
126
  2. KeyTupleFormat - used to pass index search tuples (aka "keys") to
114
 
     storage engine. See optimizer/range.cc for description of this format.
 
127
     storage engine. See opt_range.cc for description of this format.
115
128
 
116
129
  TableRecordFormat
117
130
  =================
136
149
  present, its length is one byte <not-sure> which must be set to 0xFF
137
150
  at all times. </not-sure>
138
151
 
 
152
  If the table has columns of type BIT, then certain bits from those columns
 
153
  may be stored in null_bytes as well. Grep around for Field_bit for
 
154
  details.
 
155
 
139
156
  For blob columns (see Field_blob), the record buffer stores length of the
140
157
  data, following by memory pointer to the blob data. The pointer is owned
141
158
  by the storage engine and is valid until the next operation.
143
160
  If a blob column has NULL value, then its length and blob data pointer
144
161
  must be set to 0.
145
162
*/
146
 
class Cursor
 
163
 
 
164
class Cursor :public Sql_alloc
147
165
{
148
 
  Table &table;               /* The current open table */
149
 
  plugin::StorageEngine &engine;      /* storage engine of this Cursor */
150
 
 
151
166
protected:
 
167
  TableShare *table_share;   /* The table definition */
 
168
  Table *table;               /* The current open table */
 
169
 
152
170
  ha_rows estimation_rows_to_insert;
153
 
 
154
171
public:
155
 
  inline plugin::StorageEngine *getEngine() const       /* table_type for handler */
156
 
  {
157
 
    return &engine;
158
 
  }
159
 
  unsigned char *ref;                           /* Pointer to current row */
 
172
  drizzled::plugin::StorageEngine *engine;      /* storage engine of this Cursor */
 
173
  unsigned char *ref;                           /* Pointer to current row */
160
174
  unsigned char *dup_ref;                       /* Pointer to duplicate row */
161
175
 
162
 
  TableShare *getShare();
163
 
 
164
 
  Table *getTable() const
165
 
  {
166
 
    return &table;
167
 
  }
168
 
 
169
176
  ha_statistics stats;
170
177
  /** MultiRangeRead-related members: */
171
178
  range_seq_t mrr_iter;    /* Interator to traverse the range sequence */
172
179
  RANGE_SEQ_IF mrr_funcs;  /* Range sequence traversal functions */
173
 
 
 
180
  HANDLER_BUFFER *multi_range_buffer; /* MRR buffer info */
174
181
  uint32_t ranges_in_seq; /* Total number of ranges in the traversed sequence */
175
182
  /* true <=> source MRR ranges and the output are ordered */
176
183
  bool mrr_is_output_sorted;
179
186
  bool mrr_have_range;
180
187
 
181
188
  bool eq_range;
 
189
  /*
 
190
    true <=> the engine guarantees that returned records are within the range
 
191
    being scanned.
 
192
  */
 
193
  bool in_range_check_pushed_down;
182
194
 
183
195
  /** Current range (the one we're now returning rows from) */
184
196
  KEY_MULTI_RANGE mrr_cur_range;
185
197
 
186
198
  /** The following are for read_range() */
187
199
  key_range save_end_range, *end_range;
188
 
  KeyPartInfo *range_key_part;
 
200
  KEY_PART_INFO *range_key_part;
189
201
  int key_compare_result_on_equal;
190
202
 
191
203
  uint32_t errkey;                              /* Last dup key */
195
207
  uint32_t ref_length;
196
208
  enum {NONE=0, INDEX, RND} inited;
197
209
  bool locked;
 
210
  bool implicit_emptied;                /* Can be !=0 only if HEAP */
198
211
 
199
212
  /**
200
213
    next_insert_id is the next value which should be inserted into the
206
219
    get_auto_increment().
207
220
  */
208
221
  uint64_t next_insert_id;
209
 
  uint64_t getNextInsertId()
210
 
  {
211
 
    return next_insert_id;
212
 
  }
213
 
 
214
222
  /**
215
223
    insert id for the current row (*autogenerated*; if not
216
224
    autogenerated, it's 0).
224
232
  */
225
233
  Discrete_interval auto_inc_interval_for_cur_row;
226
234
 
227
 
  Cursor(plugin::StorageEngine &engine_arg, Table &share_arg);
 
235
  Cursor(drizzled::plugin::StorageEngine &engine_arg, TableShare &share_arg)
 
236
    :table_share(&share_arg), table(0),
 
237
    estimation_rows_to_insert(0), engine(&engine_arg),
 
238
    ref(0), in_range_check_pushed_down(false),
 
239
    key_used_on_scan(MAX_KEY), active_index(MAX_KEY),
 
240
    ref_length(sizeof(my_off_t)),
 
241
    inited(NONE),
 
242
    locked(false), implicit_emptied(0),
 
243
    next_insert_id(0), insert_id_for_cur_row(0)
 
244
    {}
228
245
  virtual ~Cursor(void);
229
 
  virtual Cursor *clone(memory::Root *mem_root);
 
246
  virtual Cursor *clone(MEM_ROOT *mem_root);
230
247
 
231
248
  /* ha_ methods: pubilc wrappers for private virtual API */
232
249
 
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();
 
250
  int ha_open(Table *table, const char *name, int mode, int test_if_locked);
 
251
  int ha_index_init(uint32_t idx, bool sorted);
 
252
  int ha_index_end();
 
253
  int ha_rnd_init(bool scan);
 
254
  int ha_rnd_end();
238
255
  int ha_reset();
239
256
 
240
257
  /* this is necessary in many places, e.g. in HANDLER command */
241
258
  int ha_index_or_rnd_end();
 
259
  drizzled::plugin::StorageEngine::Table_flags ha_table_flags() const;
242
260
 
243
261
  /**
244
262
    These functions represent the public interface to *users* of the
245
263
    Cursor class, hence they are *not* virtual. For the inheritance
246
 
    interface, see the (private) functions doInsertRecord(), doUpdateRecord(),
247
 
    and doDeleteRecord() below.
 
264
    interface, see the (private) functions write_row(), update_row(),
 
265
    and delete_row() below.
248
266
  */
249
267
  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);
 
268
  int ha_write_row(unsigned char * buf);
 
269
  int ha_update_row(const unsigned char * old_data, unsigned char * new_data);
 
270
  int ha_delete_row(const unsigned char * buf);
253
271
  void ha_release_auto_increment();
254
272
 
255
273
  /** to be actually called to get 'check()' functionality*/
257
275
 
258
276
  void ha_start_bulk_insert(ha_rows rows);
259
277
  int ha_end_bulk_insert();
 
278
  int ha_bulk_update_row(const unsigned char *old_data, unsigned char *new_data,
 
279
                         uint32_t *dup_key_found);
260
280
  int ha_delete_all_rows();
261
281
  int ha_reset_auto_increment(uint64_t value);
 
282
  int ha_optimize(Session* session, HA_CHECK_OPT* check_opt);
262
283
  int ha_analyze(Session* session, HA_CHECK_OPT* check_opt);
263
284
 
264
285
  int ha_disable_indexes(uint32_t mode);
268
289
 
269
290
  void adjust_next_insert_id_after_explicit_value(uint64_t nr);
270
291
  int update_auto_increment();
 
292
  virtual void change_table_ptr(Table *table_arg, TableShare *share);
271
293
 
272
294
  /* Estimates calculation */
273
295
  virtual double scan_time(void)
280
302
  virtual ha_rows multi_range_read_info_const(uint32_t keyno, RANGE_SEQ_IF *seq,
281
303
                                              void *seq_init_param,
282
304
                                              uint32_t n_ranges, uint32_t *bufsz,
283
 
                                              uint32_t *flags, optimizer::CostVector *cost);
 
305
                                              uint32_t *flags, COST_VECT *cost);
284
306
  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);
 
307
                                    uint32_t *bufsz, uint32_t *flags, COST_VECT *cost);
286
308
  virtual int multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param,
287
 
                                    uint32_t n_ranges, uint32_t mode);
 
309
                                    uint32_t n_ranges, uint32_t mode,
 
310
                                    HANDLER_BUFFER *buf);
288
311
  virtual int multi_range_read_next(char **range_info);
289
312
 
290
313
 
308
331
    (table_flags() & (HA_HAS_RECORDS | HA_STATS_RECORDS_IS_EXACT)) != 0
309
332
  */
310
333
  virtual ha_rows records();
311
 
  virtual uint64_t tableSize();
312
 
  virtual uint64_t rowSize();
313
334
  /**
314
335
    Return upper bound of current number of records in the table
315
336
    (max. of how many records one will retrieve when doing a full table scan)
319
340
  virtual ha_rows estimate_rows_upper_bound()
320
341
  { return stats.records+EXTRA_RECORDS; }
321
342
 
 
343
  /**
 
344
    Get the row type from the storage engine.  If this method returns
 
345
    ROW_TYPE_NOT_USED, the information in HA_CREATE_INFO should be used.
 
346
  */
 
347
  virtual enum row_type get_row_type() const { return ROW_TYPE_NOT_USED; }
 
348
 
322
349
  virtual const char *index_type(uint32_t)
323
350
  { assert(0); return "";}
324
351
 
327
354
  virtual int close(void)=0;
328
355
 
329
356
  /**
 
357
    @retval  0   Bulk update used by Cursor
 
358
    @retval  1   Bulk update not used, normal operation used
 
359
  */
 
360
  virtual bool start_bulk_update() { return 1; }
 
361
  /**
 
362
    @retval  0   Bulk delete used by Cursor
 
363
    @retval  1   Bulk delete not used, normal operation used
 
364
  */
 
365
  virtual bool start_bulk_delete() { return 1; }
 
366
  /**
 
367
    After this call all outstanding updates must be performed. The number
 
368
    of duplicate key errors are reported in the duplicate key parameter.
 
369
    It is allowed to continue to the batched update after this call, the
 
370
    Cursor has to wait until end_bulk_update with changing state.
 
371
 
 
372
    @param    dup_key_found       Number of duplicate keys found
 
373
 
 
374
    @retval  0           Success
 
375
    @retval  >0          Error code
 
376
  */
 
377
  virtual int exec_bulk_update(uint32_t *)
 
378
  {
 
379
    assert(false);
 
380
    return HA_ERR_WRONG_COMMAND;
 
381
  }
 
382
  /**
 
383
    Perform any needed clean-up, no outstanding updates are there at the
 
384
    moment.
 
385
  */
 
386
  virtual void end_bulk_update() { return; }
 
387
  /**
 
388
    Execute all outstanding deletes and close down the bulk delete.
 
389
 
 
390
    @retval 0             Success
 
391
    @retval >0            Error code
 
392
  */
 
393
  virtual int end_bulk_delete()
 
394
  {
 
395
    assert(false);
 
396
    return HA_ERR_WRONG_COMMAND;
 
397
  }
 
398
  /**
330
399
     @brief
331
400
     Positions an index cursor to the index specified in the handle. Fetches the
332
401
     row if available. If the key value is null, begin at the first key of the
333
402
     index.
334
403
  */
335
 
  virtual int index_read_map(unsigned char * buf, const unsigned char *key,
 
404
  virtual int index_read_map(unsigned char * buf, const unsigned char * key,
336
405
                             key_part_map keypart_map,
337
406
                             enum ha_rkey_function find_flag)
338
407
  {
339
 
    uint32_t key_len= calculate_key_len(active_index, keypart_map);
 
408
    uint32_t key_len= calculate_key_len(table, active_index, key, keypart_map);
340
409
    return  index_read(buf, key, key_len, find_flag);
341
410
  }
342
411
  /**
358
427
  virtual int index_last(unsigned char *)
359
428
   { return  HA_ERR_WRONG_COMMAND; }
360
429
  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
430
  /**
367
431
     @brief
368
432
     The following functions works like index_read, but it find the last
371
435
  virtual int index_read_last_map(unsigned char * buf, const unsigned char * key,
372
436
                                  key_part_map keypart_map)
373
437
  {
374
 
    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);
375
439
    return index_read_last(buf, key, key_len);
376
440
  }
377
441
  virtual int read_range_first(const key_range *start_key,
379
443
                               bool eq_range, bool sorted);
380
444
  virtual int read_range_next();
381
445
  int compare_key(key_range *range);
 
446
  int compare_key2(key_range *range);
382
447
  virtual int rnd_next(unsigned char *)=0;
383
448
  virtual int rnd_pos(unsigned char *, unsigned char *)=0;
 
449
  /**
 
450
    One has to use this method when to find
 
451
    random position by record as the plain
 
452
    position() call doesn't work for some
 
453
    handlers for random position.
 
454
  */
 
455
  virtual int rnd_pos_by_record(unsigned char *record);
384
456
  virtual int read_first_row(unsigned char *buf, uint32_t primary_key);
 
457
  /**
 
458
    The following function is only needed for tables that may be temporary
 
459
    tables during joins.
 
460
  */
 
461
  virtual int restart_rnd_next(unsigned char *, unsigned char *)
 
462
    { return HA_ERR_WRONG_COMMAND; }
385
463
  virtual int rnd_same(unsigned char *, uint32_t)
386
464
    { return HA_ERR_WRONG_COMMAND; }
387
465
  virtual ha_rows records_in_range(uint32_t, key_range *, key_range *)
416
494
  */
417
495
  virtual void try_semi_consistent_read(bool) {}
418
496
  virtual void unlock_row(void) {}
 
497
  virtual int start_stmt(Session *, thr_lock_type)
 
498
  {return 0;}
419
499
  virtual void get_auto_increment(uint64_t offset, uint64_t increment,
420
500
                                  uint64_t nb_desired_values,
421
501
                                  uint64_t *first_value,
422
 
                                  uint64_t *nb_reserved_values)= 0;
423
 
 
 
502
                                  uint64_t *nb_reserved_values);
424
503
  void set_next_insert_id(uint64_t id)
425
504
  {
426
505
    next_insert_id= id;
441
520
      insert_id_for_cur_row;
442
521
  }
443
522
 
 
523
  virtual void update_create_info(HA_CREATE_INFO *) {}
 
524
  int check_old_types(void);
444
525
  /* end of the list of admin commands */
445
526
 
446
527
  virtual int indexes_are_disabled(void) {return 0;}
463
544
   */
464
545
  virtual bool can_switch_engines(void) { return true; }
465
546
  /** used in REPLACE; is > 0 if table is referred by a FOREIGN KEY */
466
 
  virtual int get_foreign_key_list(Session *, List<ForeignKeyInfo> *)
 
547
  virtual int get_foreign_key_list(Session *, List<FOREIGN_KEY_INFO> *)
467
548
  { return 0; }
468
549
  virtual uint32_t referenced_by_foreign_key() { return 0;}
469
550
  virtual void free_foreign_key_create_info(char *) {}
 
551
  /** The following can be called without an open Cursor */
 
552
 
 
553
  virtual uint32_t index_flags(uint32_t idx, uint32_t part, bool all_parts) const =0;
 
554
 
 
555
  virtual int add_index(Table *, KEY *, uint32_t)
 
556
  { return (HA_ERR_WRONG_COMMAND); }
 
557
  virtual int prepare_drop_index(Table *, uint32_t *, uint32_t)
 
558
  { return (HA_ERR_WRONG_COMMAND); }
 
559
  virtual int final_drop_index(Table *)
 
560
  { return (HA_ERR_WRONG_COMMAND); }
 
561
 
 
562
  uint32_t max_record_length() const
 
563
  { return std::min((unsigned int)HA_MAX_REC_LENGTH, max_supported_record_length()); }
 
564
  uint32_t max_keys() const
 
565
  { return std::min((unsigned int)MAX_KEY, max_supported_keys()); }
 
566
  uint32_t max_key_parts() const
 
567
  { return std::min((unsigned int)MAX_REF_PARTS, max_supported_key_parts()); }
 
568
  uint32_t max_key_length() const
 
569
  { return std::min((unsigned int)MAX_KEY_LENGTH, max_supported_key_length()); }
 
570
  uint32_t max_key_part_length(void) const
 
571
  { return std::min((unsigned int)MAX_KEY_LENGTH, max_supported_key_part_length()); }
 
572
 
 
573
  virtual uint32_t max_supported_record_length(void) const
 
574
  { return HA_MAX_REC_LENGTH; }
 
575
  virtual uint32_t max_supported_keys(void) const { return 0; }
 
576
  virtual uint32_t max_supported_key_parts(void) const { return MAX_REF_PARTS; }
 
577
  virtual uint32_t max_supported_key_length(void) const { return MAX_KEY_LENGTH; }
 
578
  virtual uint32_t max_supported_key_part_length(void) const { return 255; }
 
579
 
 
580
  virtual bool low_byte_first(void) const { return true; }
 
581
  virtual uint32_t checksum(void) const { return 0; }
 
582
  virtual bool is_crashed(void) const  { return false; }
 
583
  virtual bool auto_repair(void) const { return false; }
470
584
 
471
585
  /**
472
586
    Is not invoked for non-transactional temporary tables.
475
589
    or partitioned.
476
590
 
477
591
    @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().
 
592
    refer to a different thread if called from mysql_lock_abort_for_thread().
479
593
 
480
594
    @note If the table is MERGE, store_lock() can return less locks
481
595
    than lock_count() claimed. This can happen when the MERGE children
509
623
 
510
624
protected:
511
625
  /* Service methods for use by storage engines. */
512
 
  void ha_statistic_increment(uint64_t system_status_var::*offset) const;
 
626
  void ha_statistic_increment(ulong SSV::*offset) const;
513
627
  void **ha_data(Session *) const;
 
628
  Session *ha_session(void) const;
514
629
 
515
630
private:
516
631
  /* Private helpers */
517
 
  inline void setTransactionReadWrite();
 
632
  inline void mark_trx_read_write();
518
633
private:
519
634
  /*
520
635
    Low-level primitives for storage engines.  These should be
522
637
    the corresponding 'ha_*' method above.
523
638
  */
524
639
 
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)
 
640
  virtual int open(const char *name, int mode, uint32_t test_if_locked)=0;
 
641
  virtual int index_init(uint32_t idx, bool)
528
642
  { active_index= idx; return 0; }
529
 
  virtual int doEndIndexScan() { active_index= MAX_KEY; return 0; }
 
643
  virtual int index_end() { active_index= MAX_KEY; return 0; }
530
644
  /**
531
 
    doStartTableScan() can be called two times without doEndTableScan() in between
 
645
    rnd_init() can be called two times without rnd_end() in between
532
646
    (it only makes sense if scan=1).
533
647
    then the second call should prepare for the new table scan (e.g
534
648
    if rnd_init allocates the cursor, second call should position it
535
649
    to the start of the table, no need to deallocate and allocate it again
536
650
  */
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 *)
 
651
  virtual int rnd_init(bool scan)= 0;
 
652
  virtual int rnd_end() { return 0; }
 
653
  virtual int write_row(unsigned char *)
 
654
  {
 
655
    return HA_ERR_WRONG_COMMAND;
 
656
  }
 
657
 
 
658
  virtual int update_row(const unsigned char *, unsigned char *)
 
659
  {
 
660
    return HA_ERR_WRONG_COMMAND;
 
661
  }
 
662
 
 
663
  virtual int delete_row(const unsigned char *)
550
664
  {
551
665
    return HA_ERR_WRONG_COMMAND;
552
666
  }
583
697
  {
584
698
    return 0;
585
699
  }
586
 
  virtual void release_auto_increment(void) { return; }
 
700
  virtual void release_auto_increment(void) { return; };
587
701
  /** admin commands - called from mysql_admin_table */
588
702
  virtual int check(Session *)
589
703
  { return HA_ADMIN_NOT_IMPLEMENTED; }
595
709
                         uint32_t, enum ha_rkey_function)
596
710
   { return  HA_ERR_WRONG_COMMAND; }
597
711
  virtual int index_read_last(unsigned char *, const unsigned char *, uint32_t)
598
 
   { return (errno= HA_ERR_WRONG_COMMAND); }
 
712
   { return (my_errno= HA_ERR_WRONG_COMMAND); }
 
713
  /**
 
714
    This method is similar to update_row, however the Cursor doesn't need
 
715
    to execute the updates at this point in time. The Cursor can be certain
 
716
    that another call to bulk_update_row will occur OR a call to
 
717
    exec_bulk_update before the set of updates in this query is concluded.
 
718
 
 
719
    @param    old_data       Old record
 
720
    @param    new_data       New record
 
721
    @param    dup_key_found  Number of duplicate keys found
 
722
 
 
723
    @retval  0   Bulk delete used by Cursor
 
724
    @retval  1   Bulk delete not used, normal operation used
 
725
  */
 
726
  virtual int bulk_update_row(const unsigned char *, unsigned char *, uint32_t *)
 
727
  {
 
728
    assert(false);
 
729
    return HA_ERR_WRONG_COMMAND;
 
730
  }
599
731
  /**
600
732
    This is called to delete all rows in a table
601
733
    If the Cursor don't support this, then this function will
603
735
    by one.
604
736
  */
605
737
  virtual int delete_all_rows(void)
606
 
  { return (errno=HA_ERR_WRONG_COMMAND); }
 
738
  { return (my_errno=HA_ERR_WRONG_COMMAND); }
607
739
  /**
608
740
    Reset the auto-increment counter to the given value, i.e. the next row
609
741
    inserted will get the given value. This is called e.g. after TRUNCATE
613
745
  virtual int reset_auto_increment(uint64_t)
614
746
  { return HA_ERR_WRONG_COMMAND; }
615
747
 
 
748
  virtual int optimize(Session *)
 
749
  { return HA_ADMIN_NOT_IMPLEMENTED; }
 
750
 
616
751
  virtual int analyze(Session *)
617
752
  { return HA_ADMIN_NOT_IMPLEMENTED; }
618
753
 
623
758
  { return HA_ERR_WRONG_COMMAND; }
624
759
 
625
760
  virtual int discard_or_import_tablespace(bool)
626
 
  { return (errno=HA_ERR_WRONG_COMMAND); }
 
761
  { return (my_errno=HA_ERR_WRONG_COMMAND); }
627
762
 
628
763
  /* 
629
764
    @todo this is just for the HEAP engine, it should
635
770
};
636
771
 
637
772
extern const char *ha_row_type[];
 
773
extern const char *tx_isolation_names[];
 
774
extern const char *binlog_format_names[];
 
775
extern TYPELIB tx_isolation_typelib;
 
776
extern uint32_t total_ha, total_ha_2pc;
 
777
 
 
778
       /* Wrapper functions */
 
779
#define ha_commit(session) (ha_commit_trans((session), true))
 
780
#define ha_rollback(session) (ha_rollback_trans((session), true))
638
781
 
639
782
/* 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);
 
783
int ha_init_errors(void);
 
784
int ha_init(void);
 
785
int ha_end(void);
 
786
 
 
787
/* transactions: interface to plugin::StorageEngine functions */
 
788
int ha_commit_one_phase(Session *session, bool all);
 
789
int ha_rollback_trans(Session *session, bool all);
 
790
 
 
791
/* transactions: these functions never call plugin::StorageEngine functions directly */
 
792
int ha_commit_trans(Session *session, bool all);
 
793
int ha_autocommit_or_rollback(Session *session, int error);
 
794
int ha_enable_transaction(Session *session, bool on);
 
795
 
 
796
/* savepoints */
 
797
int ha_rollback_to_savepoint(Session *session, SAVEPOINT *sv);
 
798
int ha_savepoint(Session *session, SAVEPOINT *sv);
 
799
int ha_release_savepoint(Session *session, SAVEPOINT *sv);
 
800
 
 
801
/* these are called by storage engines */
 
802
void trans_register_ha(Session *session, bool all, drizzled::plugin::StorageEngine *engine);
 
803
 
 
804
uint32_t filename_to_tablename(const char *from, char *to, uint32_t to_length);
 
805
bool tablename_to_filename(const char *from, char *to, size_t to_length);
 
806
 
 
807
 
 
808
/*
 
809
  Storage engine has to assume the transaction will end up with 2pc if
 
810
   - there is more than one 2pc-capable storage engine available
 
811
   - in the current transaction 2pc was not disabled yet
 
812
*/
 
813
#define trans_need_2pc(session, all)                   ((total_ha_2pc > 1) && \
 
814
        !((all ? &session->transaction.all : &session->transaction.stmt)->no_2pc))
 
815
 
 
816
 
 
817
bool mysql_xa_recover(Session *session);
 
818
 
 
819
SORT_FIELD * make_unireg_sortorder(order_st *order, uint32_t *length,
 
820
                                   SORT_FIELD *sortorder);
645
821
int setup_order(Session *session, Item **ref_pointer_array, TableList *tables,
646
 
                List<Item> &fields, List <Item> &all_fields, Order *order);
 
822
                List<Item> &fields, List <Item> &all_fields, order_st *order);
647
823
int setup_group(Session *session, Item **ref_pointer_array, TableList *tables,
648
 
                List<Item> &fields, List<Item> &all_fields, Order *order,
 
824
                List<Item> &fields, List<Item> &all_fields, order_st *order,
649
825
                bool *hidden_group_fields);
650
826
bool fix_inner_refs(Session *session, List<Item> &all_fields, Select_Lex *select,
651
827
                    Item **ref_pointer_array);
652
828
 
653
829
bool handle_select(Session *session, LEX *lex, select_result *result,
654
830
                   uint64_t setup_tables_done_option);
 
831
bool mysql_select(Session *session, Item ***rref_pointer_array,
 
832
                  TableList *tables, uint32_t wild_num,  List<Item> &list,
 
833
                  COND *conds, uint32_t og_num, order_st *order, order_st *group,
 
834
                  Item *having, uint64_t select_type,
 
835
                  select_result *result, Select_Lex_Unit *unit,
 
836
                  Select_Lex *select_lex);
655
837
void free_underlaid_joins(Session *session, Select_Lex *select);
 
838
bool mysql_explain_union(Session *session, Select_Lex_Unit *unit,
 
839
                         select_result *result);
 
840
int mysql_explain_select(Session *session, Select_Lex *sl, char const *type,
 
841
                         select_result *result);
656
842
 
657
843
bool mysql_handle_derived(LEX *lex, bool (*processor)(Session *session,
658
844
                                                      LEX *lex,
661
847
bool mysql_derived_filling(Session *session, LEX *lex, TableList *t);
662
848
int prepare_create_field(CreateField *sql_field,
663
849
                         uint32_t *blob_columns,
664
 
                         int *timestamps, int *timestamps_with_niladic);
 
850
                         int *timestamps, int *timestamps_with_niladic,
 
851
                         int64_t table_flags);
665
852
 
666
 
bool mysql_create_table(Session *session,
667
 
                        const TableIdentifier &identifier,
 
853
bool mysql_create_table(Session *session,const char *db, const char *table_name,
668
854
                        HA_CREATE_INFO *create_info,
669
 
                        message::Table &table_proto,
 
855
                        drizzled::message::Table *table_proto,
670
856
                        AlterInfo *alter_info,
671
857
                        bool tmp_table, uint32_t select_field_count,
672
858
                        bool is_if_not_exists);
673
859
 
674
 
bool mysql_create_table_no_lock(Session *session,
675
 
                                const TableIdentifier &identifier,
 
860
bool mysql_create_table_no_lock(Session *session, const char *db,
 
861
                                const char *table_name,
676
862
                                HA_CREATE_INFO *create_info,
677
 
                                message::Table &table_proto,
 
863
                                drizzled::message::Table *table_proto,
678
864
                                AlterInfo *alter_info,
679
 
                                bool tmp_table, uint32_t select_field_count,
 
865
                                bool tmp_table, uint32_t select_field_count, 
680
866
                                bool is_if_not_exists);
681
867
 
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,
 
868
bool mysql_recreate_table(Session *session, TableList *table_list);
 
869
 
 
870
bool mysql_create_like_table(Session* session, TableList* table, TableList* src_table,
 
871
                             drizzled::message::Table& create_table_proto,
 
872
                             drizzled::plugin::StorageEngine*,
686
873
                             bool is_if_not_exists,
687
874
                             bool is_engine_set);
688
875
 
689
 
bool mysql_rename_table(Session &session,
690
 
                        plugin::StorageEngine *base,
691
 
                        const TableIdentifier &old_identifier,
692
 
                        const TableIdentifier &new_identifier);
 
876
bool mysql_rename_table(drizzled::plugin::StorageEngine *base, const char *old_db,
 
877
                        const char * old_name, const char *new_db,
 
878
                        const char * new_name, uint32_t flags);
693
879
 
694
880
bool mysql_prepare_update(Session *session, TableList *table_list,
695
 
                          Item **conds, uint32_t order_num, Order *order);
 
881
                          Item **conds, uint32_t order_num, order_st *order);
696
882
int mysql_update(Session *session,TableList *tables,List<Item> &fields,
697
883
                 List<Item> &values,COND *conds,
698
 
                 uint32_t order_num, Order *order, ha_rows limit,
 
884
                 uint32_t order_num, order_st *order, ha_rows limit,
699
885
                 enum enum_duplicates handle_duplicates, bool ignore);
700
886
bool mysql_prepare_insert(Session *session, TableList *table_list, Table *table,
701
887
                          List<Item> &fields, List_item *values,
718
904
                             uint32_t key_length, uint32_t db_flags, int *error);
719
905
TableShare *get_cached_table_share(const char *db, const char *table_name);
720
906
bool reopen_name_locked_table(Session* session, TableList* table_list, bool link_in);
 
907
Table *table_cache_insert_placeholder(Session *session, const char *key,
 
908
                                      uint32_t key_length);
 
909
bool lock_table_name_if_not_cached(Session *session, const char *db,
 
910
                                   const char *table_name, Table **table);
 
911
bool reopen_table(Table *table);
721
912
bool reopen_tables(Session *session,bool get_locks,bool in_refresh);
 
913
void close_data_files_and_morph_locks(Session *session, const char *db,
 
914
                                      const char *table_name);
722
915
void close_handle_and_leave_table_as_lock(Table *table);
723
916
bool wait_for_tables(Session *session);
724
917
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);
 
918
Table *drop_locked_tables(Session *session,const char *db, const char *table_name);
 
919
void abort_locked_tables(Session *session,const char *db, const char *table_name);
727
920
extern Field *not_found_field;
728
921
extern Field *view_ref_found;
729
922
 
743
936
Field *
744
937
find_field_in_table(Session *session, Table *table, const char *name, uint32_t length,
745
938
                    bool allow_rowid, uint32_t *cached_field_index_ptr);
 
939
Field *
 
940
find_field_in_table_sef(Table *table, const char *name);
746
941
 
747
 
} /* namespace drizzled */
748
942
 
749
943
#endif /* DRIZZLED_CURSOR_H */