← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/cursor.h

  • Committer: Monty Taylor
  • Date: 2009-12-14 22:00:27 UTC
  • mto: (1241.9.10 out-of-tree)
  • mto: This revision was merged to the branch mainline in revision 1250.
  • Revision ID: mordred@inaugust.com-20091214220027-kpmfbl452nctzc0g
pandora-build v0.85 - Fixed C++ standard setting.

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>
 
25
#include <drizzled/table_identifier.h>
28
26
 
29
27
/* Definitions for parameters to do with Cursor-routines */
30
28
 
31
 
#include <drizzled/thr_lock.h>
 
29
#include <mysys/thr_lock.h>
 
30
#include <mysys/hash.h>
32
31
#include <drizzled/sql_string.h>
33
32
#include <drizzled/sql_list.h>
34
33
#include <drizzled/plugin/storage_engine.h>
38
37
 
39
38
#include <drizzled/message/table.pb.h>
40
39
 
 
40
/* Bits to show what an alter table will do */
 
41
#include <drizzled/sql_bitmap.h>
 
42
 
 
43
#include <drizzled/cursor.h>
 
44
 
41
45
#include <bitset>
42
46
#include <algorithm>
43
47
 
44
 
namespace drizzled
45
 
{
46
 
 
47
48
#define HA_MAX_ALTER_FLAGS 40
48
49
 
 
50
 
49
51
typedef std::bitset<HA_MAX_ALTER_FLAGS> HA_ALTER_FLAGS;
50
52
 
51
53
extern uint64_t refresh_version;  /* Increments on each reload */
52
54
 
 
55
 
 
56
typedef bool (*qc_engine_callback)(Session *session, char *table_key,
 
57
                                      uint32_t key_length,
 
58
                                      uint64_t *engine_data);
 
59
 
 
60
 
 
61
/* The Cursor for a table type.  Will be included in the Table structure */
 
62
 
53
63
class Table;
54
64
class TableList;
55
65
class TableShare;
56
66
class Select_Lex_Unit;
57
 
class ForeignKeyInfo;
58
 
struct Order;
 
67
struct st_foreign_key_info;
 
68
typedef struct st_foreign_key_info FOREIGN_KEY_INFO;
 
69
struct order_st;
59
70
 
60
71
class Item;
 
72
struct st_table_log_memory_entry;
61
73
 
62
74
class LEX;
63
75
class Select_Lex;
66
78
class CreateField;
67
79
class sys_var_str;
68
80
class Item_ident;
 
81
typedef struct st_sort_field SORT_FIELD;
69
82
 
70
83
typedef List<Item> List_item;
 
84
 
 
85
typedef struct st_savepoint SAVEPOINT;
 
86
extern uint32_t savepoint_alloc_size;
71
87
extern KEY_CREATE_INFO default_key_create_info;
72
88
 
73
89
/* Forward declaration for condition pushdown to storage engine */
74
90
typedef class Item COND;
75
91
 
76
 
typedef struct system_status_var system_status_var;
77
 
 
78
 
namespace optimizer
79
 
{
80
 
  class CostVector;
81
 
}
82
 
 
 
92
typedef struct system_status_var SSV;
 
93
 
 
94
class COST_VECT;
 
95
 
 
96
uint32_t calculate_key_len(Table *, uint, const unsigned char *, key_part_map);
83
97
/*
84
98
  bitmap with first N+1 bits set
85
99
  (keypart_map for a key prefix of [0..N] keyparts)
136
150
  present, its length is one byte <not-sure> which must be set to 0xFF
137
151
  at all times. </not-sure>
138
152
 
 
153
  If the table has columns of type BIT, then certain bits from those columns
 
154
  may be stored in null_bytes as well. Grep around for Field_bit for
 
155
  details.
 
156
 
139
157
  For blob columns (see Field_blob), the record buffer stores length of the
140
158
  data, following by memory pointer to the blob data. The pointer is owned
141
159
  by the storage engine and is valid until the next operation.
143
161
  If a blob column has NULL value, then its length and blob data pointer
144
162
  must be set to 0.
145
163
*/
146
 
class Cursor
 
164
 
 
165
class Cursor :public Sql_alloc
147
166
{
148
 
  Table &table;               /* The current open table */
149
 
  plugin::StorageEngine &engine;      /* storage engine of this Cursor */
150
 
 
151
167
protected:
 
168
  TableShare *table_share;   /* The table definition */
 
169
  Table *table;               /* The current open table */
 
170
 
152
171
  ha_rows estimation_rows_to_insert;
153
 
 
154
172
public:
155
 
  inline plugin::StorageEngine *getEngine() const       /* table_type for handler */
 
173
  drizzled::plugin::StorageEngine *engine;      /* storage engine of this Cursor */
 
174
  inline drizzled::plugin::StorageEngine *getEngine() const     /* table_type for handler */
156
175
  {
157
 
    return &engine;
 
176
    return engine;
158
177
  }
159
178
  unsigned char *ref;                           /* Pointer to current row */
160
179
  unsigned char *dup_ref;                       /* Pointer to duplicate row */
161
180
 
162
 
  TableShare *getShare();
163
 
 
164
 
  Table *getTable() const
165
 
  {
166
 
    return &table;
167
 
  }
168
 
 
169
181
  ha_statistics stats;
170
182
  /** MultiRangeRead-related members: */
171
183
  range_seq_t mrr_iter;    /* Interator to traverse the range sequence */
172
184
  RANGE_SEQ_IF mrr_funcs;  /* Range sequence traversal functions */
173
 
 
 
185
  HANDLER_BUFFER *multi_range_buffer; /* MRR buffer info */
174
186
  uint32_t ranges_in_seq; /* Total number of ranges in the traversed sequence */
175
187
  /* true <=> source MRR ranges and the output are ordered */
176
188
  bool mrr_is_output_sorted;
179
191
  bool mrr_have_range;
180
192
 
181
193
  bool eq_range;
 
194
  /*
 
195
    true <=> the engine guarantees that returned records are within the range
 
196
    being scanned.
 
197
  */
 
198
  bool in_range_check_pushed_down;
182
199
 
183
200
  /** Current range (the one we're now returning rows from) */
184
201
  KEY_MULTI_RANGE mrr_cur_range;
185
202
 
186
203
  /** The following are for read_range() */
187
204
  key_range save_end_range, *end_range;
188
 
  KeyPartInfo *range_key_part;
 
205
  KEY_PART_INFO *range_key_part;
189
206
  int key_compare_result_on_equal;
190
207
 
191
208
  uint32_t errkey;                              /* Last dup key */
195
212
  uint32_t ref_length;
196
213
  enum {NONE=0, INDEX, RND} inited;
197
214
  bool locked;
 
215
  bool implicit_emptied;                /* Can be !=0 only if HEAP */
198
216
 
199
217
  /**
200
218
    next_insert_id is the next value which should be inserted into the
206
224
    get_auto_increment().
207
225
  */
208
226
  uint64_t next_insert_id;
209
 
  uint64_t getNextInsertId()
210
 
  {
211
 
    return next_insert_id;
212
 
  }
213
 
 
214
227
  /**
215
228
    insert id for the current row (*autogenerated*; if not
216
229
    autogenerated, it's 0).
224
237
  */
225
238
  Discrete_interval auto_inc_interval_for_cur_row;
226
239
 
227
 
  Cursor(plugin::StorageEngine &engine_arg, Table &share_arg);
 
240
  Cursor(drizzled::plugin::StorageEngine &engine_arg, TableShare &share_arg)
 
241
    :table_share(&share_arg), table(0),
 
242
    estimation_rows_to_insert(0), engine(&engine_arg),
 
243
    ref(0), in_range_check_pushed_down(false),
 
244
    key_used_on_scan(MAX_KEY), active_index(MAX_KEY),
 
245
    ref_length(sizeof(my_off_t)),
 
246
    inited(NONE),
 
247
    locked(false), implicit_emptied(0),
 
248
    next_insert_id(0), insert_id_for_cur_row(0)
 
249
    {}
228
250
  virtual ~Cursor(void);
229
 
  virtual Cursor *clone(memory::Root *mem_root);
 
251
  virtual Cursor *clone(MEM_ROOT *mem_root);
230
252
 
231
253
  /* ha_ methods: pubilc wrappers for private virtual API */
232
254
 
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();
 
255
  int ha_open(Table *table, const char *name, int mode, int test_if_locked);
 
256
  int ha_index_init(uint32_t idx, bool sorted);
 
257
  int ha_index_end();
 
258
  int ha_rnd_init(bool scan);
 
259
  int ha_rnd_end();
238
260
  int ha_reset();
239
261
 
240
262
  /* this is necessary in many places, e.g. in HANDLER command */
243
265
  /**
244
266
    These functions represent the public interface to *users* of the
245
267
    Cursor class, hence they are *not* virtual. For the inheritance
246
 
    interface, see the (private) functions doInsertRecord(), doUpdateRecord(),
247
 
    and doDeleteRecord() below.
 
268
    interface, see the (private) functions write_row(), update_row(),
 
269
    and delete_row() below.
248
270
  */
249
271
  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);
 
272
  int ha_write_row(unsigned char * buf);
 
273
  int ha_update_row(const unsigned char * old_data, unsigned char * new_data);
 
274
  int ha_delete_row(const unsigned char * buf);
253
275
  void ha_release_auto_increment();
254
276
 
255
277
  /** to be actually called to get 'check()' functionality*/
268
290
 
269
291
  void adjust_next_insert_id_after_explicit_value(uint64_t nr);
270
292
  int update_auto_increment();
 
293
  virtual void change_table_ptr(Table *table_arg, TableShare *share);
271
294
 
272
295
  /* Estimates calculation */
273
296
  virtual double scan_time(void)
280
303
  virtual ha_rows multi_range_read_info_const(uint32_t keyno, RANGE_SEQ_IF *seq,
281
304
                                              void *seq_init_param,
282
305
                                              uint32_t n_ranges, uint32_t *bufsz,
283
 
                                              uint32_t *flags, optimizer::CostVector *cost);
 
306
                                              uint32_t *flags, COST_VECT *cost);
284
307
  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);
 
308
                                    uint32_t *bufsz, uint32_t *flags, COST_VECT *cost);
286
309
  virtual int multi_range_read_init(RANGE_SEQ_IF *seq, void *seq_init_param,
287
 
                                    uint32_t n_ranges, uint32_t mode);
 
310
                                    uint32_t n_ranges, uint32_t mode,
 
311
                                    HANDLER_BUFFER *buf);
288
312
  virtual int multi_range_read_next(char **range_info);
289
313
 
290
314
 
308
332
    (table_flags() & (HA_HAS_RECORDS | HA_STATS_RECORDS_IS_EXACT)) != 0
309
333
  */
310
334
  virtual ha_rows records();
311
 
  virtual uint64_t tableSize();
312
 
  virtual uint64_t rowSize();
313
335
  /**
314
336
    Return upper bound of current number of records in the table
315
337
    (max. of how many records one will retrieve when doing a full table scan)
319
341
  virtual ha_rows estimate_rows_upper_bound()
320
342
  { return stats.records+EXTRA_RECORDS; }
321
343
 
 
344
  /**
 
345
    Get the row type from the storage engine.  If this method returns
 
346
    ROW_TYPE_NOT_USED, the information in HA_CREATE_INFO should be used.
 
347
  */
 
348
  virtual enum row_type get_row_type() const { return ROW_TYPE_NOT_USED; }
 
349
 
322
350
  virtual const char *index_type(uint32_t)
323
351
  { assert(0); return "";}
324
352
 
332
360
     row if available. If the key value is null, begin at the first key of the
333
361
     index.
334
362
  */
335
 
  virtual int index_read_map(unsigned char * buf, const unsigned char *key,
 
363
  virtual int index_read_map(unsigned char * buf, const unsigned char * key,
336
364
                             key_part_map keypart_map,
337
365
                             enum ha_rkey_function find_flag)
338
366
  {
339
 
    uint32_t key_len= calculate_key_len(active_index, keypart_map);
 
367
    uint32_t key_len= calculate_key_len(table, active_index, key, keypart_map);
340
368
    return  index_read(buf, key, key_len, find_flag);
341
369
  }
342
370
  /**
358
386
  virtual int index_last(unsigned char *)
359
387
   { return  HA_ERR_WRONG_COMMAND; }
360
388
  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
389
  /**
367
390
     @brief
368
391
     The following functions works like index_read, but it find the last
371
394
  virtual int index_read_last_map(unsigned char * buf, const unsigned char * key,
372
395
                                  key_part_map keypart_map)
373
396
  {
374
 
    uint32_t key_len= calculate_key_len(active_index, keypart_map);
 
397
    uint32_t key_len= calculate_key_len(table, active_index, key, keypart_map);
375
398
    return index_read_last(buf, key, key_len);
376
399
  }
377
400
  virtual int read_range_first(const key_range *start_key,
379
402
                               bool eq_range, bool sorted);
380
403
  virtual int read_range_next();
381
404
  int compare_key(key_range *range);
 
405
  int compare_key2(key_range *range);
382
406
  virtual int rnd_next(unsigned char *)=0;
383
407
  virtual int rnd_pos(unsigned char *, unsigned char *)=0;
 
408
  /**
 
409
    One has to use this method when to find
 
410
    random position by record as the plain
 
411
    position() call doesn't work for some
 
412
    handlers for random position.
 
413
  */
 
414
  virtual int rnd_pos_by_record(unsigned char *record);
384
415
  virtual int read_first_row(unsigned char *buf, uint32_t primary_key);
 
416
  /**
 
417
    The following function is only needed for tables that may be temporary
 
418
    tables during joins.
 
419
  */
 
420
  virtual int restart_rnd_next(unsigned char *, unsigned char *)
 
421
    { return HA_ERR_WRONG_COMMAND; }
385
422
  virtual int rnd_same(unsigned char *, uint32_t)
386
423
    { return HA_ERR_WRONG_COMMAND; }
387
424
  virtual ha_rows records_in_range(uint32_t, key_range *, key_range *)
416
453
  */
417
454
  virtual void try_semi_consistent_read(bool) {}
418
455
  virtual void unlock_row(void) {}
 
456
  virtual int start_stmt(Session *, thr_lock_type)
 
457
  {return 0;}
419
458
  virtual void get_auto_increment(uint64_t offset, uint64_t increment,
420
459
                                  uint64_t nb_desired_values,
421
460
                                  uint64_t *first_value,
422
 
                                  uint64_t *nb_reserved_values)= 0;
423
 
 
 
461
                                  uint64_t *nb_reserved_values);
424
462
  void set_next_insert_id(uint64_t id)
425
463
  {
426
464
    next_insert_id= id;
441
479
      insert_id_for_cur_row;
442
480
  }
443
481
 
 
482
  virtual void update_create_info(HA_CREATE_INFO *) {}
 
483
  int check_old_types(void);
444
484
  /* end of the list of admin commands */
445
485
 
446
486
  virtual int indexes_are_disabled(void) {return 0;}
463
503
   */
464
504
  virtual bool can_switch_engines(void) { return true; }
465
505
  /** used in REPLACE; is > 0 if table is referred by a FOREIGN KEY */
466
 
  virtual int get_foreign_key_list(Session *, List<ForeignKeyInfo> *)
 
506
  virtual int get_foreign_key_list(Session *, List<FOREIGN_KEY_INFO> *)
467
507
  { return 0; }
468
508
  virtual uint32_t referenced_by_foreign_key() { return 0;}
469
509
  virtual void free_foreign_key_create_info(char *) {}
 
510
  /** The following can be called without an open Cursor */
 
511
 
 
512
  virtual int add_index(Table *, KEY *, uint32_t)
 
513
  { return (HA_ERR_WRONG_COMMAND); }
 
514
  virtual int prepare_drop_index(Table *, uint32_t *, uint32_t)
 
515
  { return (HA_ERR_WRONG_COMMAND); }
 
516
  virtual int final_drop_index(Table *)
 
517
  { return (HA_ERR_WRONG_COMMAND); }
 
518
 
 
519
  virtual uint32_t checksum(void) const { return 0; }
470
520
 
471
521
  /**
472
522
    Is not invoked for non-transactional temporary tables.
475
525
    or partitioned.
476
526
 
477
527
    @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().
 
528
    refer to a different thread if called from mysql_lock_abort_for_thread().
479
529
 
480
530
    @note If the table is MERGE, store_lock() can return less locks
481
531
    than lock_count() claimed. This can happen when the MERGE children
509
559
 
510
560
protected:
511
561
  /* Service methods for use by storage engines. */
512
 
  void ha_statistic_increment(uint64_t system_status_var::*offset) const;
 
562
  void ha_statistic_increment(ulong SSV::*offset) const;
513
563
  void **ha_data(Session *) const;
 
564
  Session *ha_session(void) const;
514
565
 
515
566
private:
516
567
  /* Private helpers */
517
 
  inline void setTransactionReadWrite();
 
568
  inline void mark_trx_read_write();
518
569
private:
519
570
  /*
520
571
    Low-level primitives for storage engines.  These should be
522
573
    the corresponding 'ha_*' method above.
523
574
  */
524
575
 
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)
 
576
  virtual int open(const char *name, int mode, uint32_t test_if_locked)=0;
 
577
  virtual int index_init(uint32_t idx, bool)
528
578
  { active_index= idx; return 0; }
529
 
  virtual int doEndIndexScan() { active_index= MAX_KEY; return 0; }
 
579
  virtual int index_end() { active_index= MAX_KEY; return 0; }
530
580
  /**
531
 
    doStartTableScan() can be called two times without doEndTableScan() in between
 
581
    rnd_init() can be called two times without rnd_end() in between
532
582
    (it only makes sense if scan=1).
533
583
    then the second call should prepare for the new table scan (e.g
534
584
    if rnd_init allocates the cursor, second call should position it
535
585
    to the start of the table, no need to deallocate and allocate it again
536
586
  */
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 *)
 
587
  virtual int rnd_init(bool scan)= 0;
 
588
  virtual int rnd_end() { return 0; }
 
589
  virtual int write_row(unsigned char *)
 
590
  {
 
591
    return HA_ERR_WRONG_COMMAND;
 
592
  }
 
593
 
 
594
  virtual int update_row(const unsigned char *, unsigned char *)
 
595
  {
 
596
    return HA_ERR_WRONG_COMMAND;
 
597
  }
 
598
 
 
599
  virtual int delete_row(const unsigned char *)
550
600
  {
551
601
    return HA_ERR_WRONG_COMMAND;
552
602
  }
583
633
  {
584
634
    return 0;
585
635
  }
586
 
  virtual void release_auto_increment(void) { return; }
 
636
  virtual void release_auto_increment(void) { return; };
587
637
  /** admin commands - called from mysql_admin_table */
588
638
  virtual int check(Session *)
589
639
  { return HA_ADMIN_NOT_IMPLEMENTED; }
595
645
                         uint32_t, enum ha_rkey_function)
596
646
   { return  HA_ERR_WRONG_COMMAND; }
597
647
  virtual int index_read_last(unsigned char *, const unsigned char *, uint32_t)
598
 
   { return (errno= HA_ERR_WRONG_COMMAND); }
 
648
   { return (my_errno= HA_ERR_WRONG_COMMAND); }
599
649
  /**
600
650
    This is called to delete all rows in a table
601
651
    If the Cursor don't support this, then this function will
603
653
    by one.
604
654
  */
605
655
  virtual int delete_all_rows(void)
606
 
  { return (errno=HA_ERR_WRONG_COMMAND); }
 
656
  { return (my_errno=HA_ERR_WRONG_COMMAND); }
607
657
  /**
608
658
    Reset the auto-increment counter to the given value, i.e. the next row
609
659
    inserted will get the given value. This is called e.g. after TRUNCATE
623
673
  { return HA_ERR_WRONG_COMMAND; }
624
674
 
625
675
  virtual int discard_or_import_tablespace(bool)
626
 
  { return (errno=HA_ERR_WRONG_COMMAND); }
 
676
  { return (my_errno=HA_ERR_WRONG_COMMAND); }
627
677
 
628
678
  /* 
629
679
    @todo this is just for the HEAP engine, it should
635
685
};
636
686
 
637
687
extern const char *ha_row_type[];
 
688
extern const char *tx_isolation_names[];
 
689
extern const char *binlog_format_names[];
 
690
extern TYPELIB tx_isolation_typelib;
 
691
extern uint32_t total_ha, total_ha_2pc;
 
692
 
 
693
       /* Wrapper functions */
 
694
#define ha_commit(session) (ha_commit_trans((session), true))
 
695
#define ha_rollback(session) (ha_rollback_trans((session), true))
638
696
 
639
697
/* 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);
 
698
int ha_init_errors(void);
 
699
int ha_init(void);
 
700
int ha_end(void);
 
701
 
 
702
/* transactions: interface to plugin::StorageEngine functions */
 
703
int ha_commit_one_phase(Session *session, bool all);
 
704
int ha_rollback_trans(Session *session, bool all);
 
705
 
 
706
/* transactions: these functions never call plugin::StorageEngine functions directly */
 
707
int ha_commit_trans(Session *session, bool all);
 
708
int ha_autocommit_or_rollback(Session *session, int error);
 
709
int ha_enable_transaction(Session *session, bool on);
 
710
 
 
711
/* savepoints */
 
712
int ha_rollback_to_savepoint(Session *session, SAVEPOINT *sv);
 
713
int ha_savepoint(Session *session, SAVEPOINT *sv);
 
714
int ha_release_savepoint(Session *session, SAVEPOINT *sv);
 
715
 
 
716
/* these are called by storage engines */
 
717
void trans_register_ha(Session *session, bool all, drizzled::plugin::StorageEngine *engine);
 
718
 
 
719
uint32_t filename_to_tablename(const char *from, char *to, uint32_t to_length);
 
720
bool tablename_to_filename(const char *from, char *to, size_t to_length);
 
721
 
 
722
 
 
723
/*
 
724
  Storage engine has to assume the transaction will end up with 2pc if
 
725
   - there is more than one 2pc-capable storage engine available
 
726
   - in the current transaction 2pc was not disabled yet
 
727
*/
 
728
#define trans_need_2pc(session, all)                   ((total_ha_2pc > 1) && \
 
729
        !((all ? &session->transaction.all : &session->transaction.stmt)->no_2pc))
 
730
 
 
731
 
 
732
bool mysql_xa_recover(Session *session);
 
733
 
 
734
SORT_FIELD * make_unireg_sortorder(order_st *order, uint32_t *length,
 
735
                                   SORT_FIELD *sortorder);
645
736
int setup_order(Session *session, Item **ref_pointer_array, TableList *tables,
646
 
                List<Item> &fields, List <Item> &all_fields, Order *order);
 
737
                List<Item> &fields, List <Item> &all_fields, order_st *order);
647
738
int setup_group(Session *session, Item **ref_pointer_array, TableList *tables,
648
 
                List<Item> &fields, List<Item> &all_fields, Order *order,
 
739
                List<Item> &fields, List<Item> &all_fields, order_st *order,
649
740
                bool *hidden_group_fields);
650
741
bool fix_inner_refs(Session *session, List<Item> &all_fields, Select_Lex *select,
651
742
                    Item **ref_pointer_array);
652
743
 
653
744
bool handle_select(Session *session, LEX *lex, select_result *result,
654
745
                   uint64_t setup_tables_done_option);
 
746
bool mysql_select(Session *session, Item ***rref_pointer_array,
 
747
                  TableList *tables, uint32_t wild_num,  List<Item> &list,
 
748
                  COND *conds, uint32_t og_num, order_st *order, order_st *group,
 
749
                  Item *having, uint64_t select_type,
 
750
                  select_result *result, Select_Lex_Unit *unit,
 
751
                  Select_Lex *select_lex);
655
752
void free_underlaid_joins(Session *session, Select_Lex *select);
 
753
bool mysql_explain_union(Session *session, Select_Lex_Unit *unit,
 
754
                         select_result *result);
 
755
int mysql_explain_select(Session *session, Select_Lex *sl, char const *type,
 
756
                         select_result *result);
656
757
 
657
758
bool mysql_handle_derived(LEX *lex, bool (*processor)(Session *session,
658
759
                                                      LEX *lex,
664
765
                         int *timestamps, int *timestamps_with_niladic);
665
766
 
666
767
bool mysql_create_table(Session *session,
667
 
                        const TableIdentifier &identifier,
 
768
                        drizzled::TableIdentifier &identifier,
668
769
                        HA_CREATE_INFO *create_info,
669
 
                        message::Table &table_proto,
 
770
                        drizzled::message::Table *table_proto,
670
771
                        AlterInfo *alter_info,
671
772
                        bool tmp_table, uint32_t select_field_count,
672
773
                        bool is_if_not_exists);
673
774
 
674
775
bool mysql_create_table_no_lock(Session *session,
675
 
                                const TableIdentifier &identifier,
 
776
                                drizzled::TableIdentifier &identifier,
676
777
                                HA_CREATE_INFO *create_info,
677
 
                                message::Table &table_proto,
 
778
                                drizzled::message::Table *table_proto,
678
779
                                AlterInfo *alter_info,
679
 
                                bool tmp_table, uint32_t select_field_count,
 
780
                                bool tmp_table,
 
781
                                uint32_t select_field_count,
680
782
                                bool is_if_not_exists);
681
783
 
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,
 
784
bool mysql_create_like_table(Session* session, TableList* table, TableList* src_table,
 
785
                             drizzled::message::Table& create_table_proto,
 
786
                             drizzled::plugin::StorageEngine*,
686
787
                             bool is_if_not_exists,
687
788
                             bool is_engine_set);
688
789
 
689
 
bool mysql_rename_table(Session &session,
690
 
                        plugin::StorageEngine *base,
691
 
                        const TableIdentifier &old_identifier,
692
 
                        const TableIdentifier &new_identifier);
 
790
bool mysql_rename_table(drizzled::plugin::StorageEngine *base, const char *old_db,
 
791
                        const char * old_name, const char *new_db,
 
792
                        const char * new_name, uint32_t flags);
693
793
 
694
794
bool mysql_prepare_update(Session *session, TableList *table_list,
695
 
                          Item **conds, uint32_t order_num, Order *order);
 
795
                          Item **conds, uint32_t order_num, order_st *order);
696
796
int mysql_update(Session *session,TableList *tables,List<Item> &fields,
697
797
                 List<Item> &values,COND *conds,
698
 
                 uint32_t order_num, Order *order, ha_rows limit,
 
798
                 uint32_t order_num, order_st *order, ha_rows limit,
699
799
                 enum enum_duplicates handle_duplicates, bool ignore);
700
800
bool mysql_prepare_insert(Session *session, TableList *table_list, Table *table,
701
801
                          List<Item> &fields, List_item *values,
718
818
                             uint32_t key_length, uint32_t db_flags, int *error);
719
819
TableShare *get_cached_table_share(const char *db, const char *table_name);
720
820
bool reopen_name_locked_table(Session* session, TableList* table_list, bool link_in);
 
821
Table *table_cache_insert_placeholder(Session *session, const char *key,
 
822
                                      uint32_t key_length);
 
823
bool lock_table_name_if_not_cached(Session *session, const char *db,
 
824
                                   const char *table_name, Table **table);
 
825
bool reopen_table(Table *table);
721
826
bool reopen_tables(Session *session,bool get_locks,bool in_refresh);
 
827
void close_data_files_and_morph_locks(Session *session, const char *db,
 
828
                                      const char *table_name);
722
829
void close_handle_and_leave_table_as_lock(Table *table);
723
830
bool wait_for_tables(Session *session);
724
831
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);
 
832
Table *drop_locked_tables(Session *session,const char *db, const char *table_name);
 
833
void abort_locked_tables(Session *session,const char *db, const char *table_name);
727
834
extern Field *not_found_field;
728
835
extern Field *view_ref_found;
729
836
 
743
850
Field *
744
851
find_field_in_table(Session *session, Table *table, const char *name, uint32_t length,
745
852
                    bool allow_rowid, uint32_t *cached_field_index_ptr);
 
853
Field *
 
854
find_field_in_table_sef(Table *table, const char *name);
746
855
 
747
 
} /* namespace drizzled */
748
856
 
749
857
#endif /* DRIZZLED_CURSOR_H */