← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.h

  • Committer: Monty Taylor
  • Date: 2010-04-14 17:24:09 UTC
  • mto: This revision was merged to the branch mainline in revision 1470.
  • Revision ID: mordred@inaugust.com-20100414172409-msncde88yewjrlhx
Moved gcc-specific optoins to their own thing.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table.h
24
24
#define DRIZZLED_TABLE_H
25
25
 
26
26
#include <string>
27
 
#include <boost/dynamic_bitset.hpp>
28
27
 
29
28
#include "drizzled/order.h"
30
29
#include "drizzled/filesort_info.h"
33
32
#include "drizzled/cursor.h"
34
33
#include "drizzled/lex_string.h"
35
34
#include "drizzled/table_list.h"
36
 
#include "drizzled/definition/table.h"
 
35
#include "drizzled/table_share.h"
37
36
#include "drizzled/atomics.h"
38
37
#include "drizzled/query_id.h"
39
38
 
55
54
typedef enum enum_table_category TABLE_CATEGORY;
56
55
typedef struct st_columndef MI_COLUMNDEF;
57
56
 
 
57
bool create_myisam_from_heap(Session *session, Table *table,
 
58
                             MI_COLUMNDEF *start_recinfo,
 
59
                             MI_COLUMNDEF **recinfo,
 
60
                             int error, bool ignore_last_dupp_key_error);
 
61
 
58
62
/**
59
63
 * Class representing a set of records, either in a temporary, 
60
64
 * normal, or derived table.
61
65
 */
62
66
class Table 
63
67
{
 
68
public:
 
69
 
 
70
  TableShare *s; /**< Pointer to the shared metadata about the table */
64
71
  Field **field; /**< Pointer to fields collection */
65
 
public:
66
 
 
67
 
  Field **getFields() const
68
 
  {
69
 
    return field;
70
 
  }
71
 
 
72
 
  Field *getField(uint32_t arg) const
73
 
  {
74
 
    return field[arg];
75
 
  }
76
 
 
77
 
  void setFields(Field **arg)
78
 
  {
79
 
    field= arg;
80
 
  }
81
 
 
82
 
  void setFieldAt(Field *arg, uint32_t arg_pos)
83
 
  {
84
 
    field[arg_pos]= arg;
85
 
  }
86
72
 
87
73
  Cursor *cursor; /**< Pointer to the storage engine's Cursor managing this table */
88
 
private:
89
74
  Table *next;
90
 
public:
91
 
  Table *getNext() const
92
 
  {
93
 
    return next;
94
 
  }
95
 
 
96
 
  Table **getNextPtr()
97
 
  {
98
 
    return &next;
99
 
  }
100
 
 
101
 
  void setNext(Table *arg)
102
 
  {
103
 
    next= arg;
104
 
  }
105
 
 
106
 
  void unlink()
107
 
  {
108
 
    getNext()->setPrev(getPrev());              /* remove from used chain */
109
 
    getPrev()->setNext(getNext());
110
 
  }
111
 
 
112
 
private:
113
75
  Table *prev;
114
 
public:
115
 
  Table *getPrev() const
116
 
  {
117
 
    return prev;
118
 
  }
119
 
 
120
 
  Table **getPrevPtr()
121
 
  {
122
 
    return &prev;
123
 
  }
124
 
 
125
 
  void setPrev(Table *arg)
126
 
  {
127
 
    prev= arg;
128
 
  }
129
 
 
130
 
  boost::dynamic_bitset<> *read_set; /* Active column sets */
131
 
  boost::dynamic_bitset<> *write_set; /* Active column sets */
 
76
 
 
77
  MyBitmap *read_set; /* Active column sets */
 
78
  MyBitmap *write_set; /* Active column sets */
132
79
 
133
80
  uint32_t tablenr;
134
81
  uint32_t db_stat; /**< information about the cursor as in Cursor.h */
135
82
 
136
 
  boost::dynamic_bitset<> def_read_set; /**< Default read set of columns */
137
 
  boost::dynamic_bitset<> def_write_set; /**< Default write set of columns */
138
 
  boost::dynamic_bitset<> tmp_set; /* Not sure about this... */
 
83
  MyBitmap def_read_set; /**< Default read set of columns */
 
84
  MyBitmap def_write_set; /**< Default write set of columns */
 
85
  MyBitmap tmp_set; /* Not sure about this... */
139
86
 
140
87
  Session *in_use; /**< Pointer to the current session using this object */
141
88
  Session *getSession()
143
90
    return in_use;
144
91
  }
145
92
 
146
 
  unsigned char *getInsertRecord()
147
 
  {
148
 
    return record[0];
149
 
  }
150
 
 
151
 
  unsigned char *getUpdateRecord()
152
 
  {
153
 
    return record[1];
154
 
  }
155
 
 
156
93
  unsigned char *record[2]; /**< Pointer to "records" */
157
 
  std::vector<unsigned char> insert_values; /* used by INSERT ... UPDATE */
158
 
  KeyInfo  *key_info; /**< data of keys in database */
 
94
  unsigned char *insert_values; /* used by INSERT ... UPDATE */
 
95
  KEY  *key_info; /**< data of keys in database */
159
96
  Field *next_number_field; /**< Set if next_number is activated. @TODO What the heck is the difference between this and the next member? */
160
97
  Field *found_next_number_field; /**< Points to the "next-number" field (autoincrement field) */
161
98
  Field_timestamp *timestamp_field; /**< Points to the auto-setting timestamp field, if any */
162
99
 
163
100
  TableList *pos_in_table_list; /* Element referring to this table */
164
 
  Order *group;
165
 
  
166
 
  const char *getAlias() const
167
 
  {
168
 
    return _alias.c_str();
169
 
  }
170
 
 
171
 
  void clearAlias()
172
 
  {
173
 
    _alias.clear();
174
 
  }
175
 
 
176
 
  void setAlias(const char *arg)
177
 
  {
178
 
    _alias= arg;
179
 
  }
180
 
 
181
 
private:
182
 
  std::string _alias; /**< alias or table name if no alias */
183
 
public:
184
 
 
 
101
  order_st *group;
 
102
  const char *alias; /**< alias or table name if no alias */
185
103
  unsigned char *null_flags;
186
104
 
187
105
  uint32_t lock_position; /**< Position in DRIZZLE_LOCK.table */
188
106
  uint32_t lock_data_start; /**< Start pos. in DRIZZLE_LOCK.locks */
189
107
  uint32_t lock_count; /**< Number of locks */
190
108
  uint32_t used_fields;
191
 
  uint32_t status; /* What's in getInsertRecord() */
 
109
  uint32_t status; /* What's in record[0] */
192
110
  /* number of select if it is derived table */
193
111
  uint32_t derived_select_number;
194
112
  int current_lock; /**< Type of lock on table */
208
126
  bool null_row;
209
127
 
210
128
  bool force_index;
211
 
  bool distinct;
212
 
  bool const_table;
213
 
  bool no_rows;
 
129
  bool distinct,const_table,no_rows;
214
130
  bool key_read;
215
131
  bool no_keyread;
216
132
  /*
325
241
  uint32_t quick_key_parts[MAX_KEY];
326
242
  uint32_t quick_n_ranges[MAX_KEY];
327
243
 
328
 
private:
329
244
  memory::Root mem_root;
330
 
 
331
 
  void init_mem_root()
332
 
  {
333
 
    init_sql_alloc(&mem_root, TABLE_ALLOC_BLOCK_SIZE, 0);
334
 
  }
335
 
public:
336
 
  memory::Root *getMemRoot()
337
 
  {
338
 
    if (not mem_root.alloc_root_inited())
339
 
    {
340
 
      init_mem_root();
341
 
    }
342
 
 
343
 
    return &mem_root;
344
 
  }
345
 
 
346
 
  void *alloc_root(size_t arg)
347
 
  {
348
 
    if (not mem_root.alloc_root_inited())
349
 
    {
350
 
      init_mem_root();
351
 
    }
352
 
 
353
 
    return mem_root.alloc_root(arg);
354
 
  }
355
 
 
356
 
  char *strmake_root(const char *str_arg, size_t len_arg)
357
 
  {
358
 
    if (not mem_root.alloc_root_inited())
359
 
    {
360
 
      init_mem_root();
361
 
    }
362
 
 
363
 
    return mem_root.strmake_root(str_arg, len_arg);
364
 
  }
365
 
 
366
 
  filesort_info sort;
 
245
  filesort_info_st sort;
367
246
 
368
247
  Table();
369
 
  virtual ~Table();
370
248
 
371
249
  int report_error(int error);
372
250
  /**
373
251
   * Free information allocated by openfrm
374
252
   *
375
253
   * @param If true if we also want to free table_share
376
 
   * @note this should all be the destructor
377
254
   */
378
 
  int delete_table(bool free_share= false);
 
255
  int closefrm(bool free_share);
379
256
 
380
257
  void resetTable(Session *session, TableShare *share, uint32_t db_stat_arg);
381
258
 
382
259
  /* SHARE methods */
383
 
  virtual const TableShare *getShare() const= 0; /* Get rid of this long term */
384
 
  virtual TableShare *getMutableShare()= 0; /* Get rid of this long term */
385
 
  virtual bool hasShare() const= 0; /* Get rid of this long term */
386
 
  virtual void setShare(TableShare *new_share)= 0; /* Get rid of this long term */
387
 
 
388
 
  virtual void release(void)= 0;
389
 
 
390
 
  uint32_t sizeKeys() { return getMutableShare()->sizeKeys(); }
391
 
  uint32_t sizeFields() { return getMutableShare()->sizeFields(); }
392
 
  uint32_t getRecordLength() const { return getShare()->getRecordLength(); }
393
 
  uint32_t sizeBlobFields() { return getMutableShare()->blob_fields; }
394
 
  uint32_t *getBlobField() { return &getMutableShare()->blob_field[0]; }
395
 
 
396
 
public:
397
 
  virtual bool hasVariableWidth() const
398
 
  {
399
 
    return getShare()->hasVariableWidth(); // We should calculate this.
400
 
  }
401
 
 
402
 
  virtual void setVariableWidth(void);
403
 
 
404
 
  Field_blob *getBlobFieldAt(uint32_t arg) const
405
 
  {
406
 
    if (arg < getShare()->blob_fields)
407
 
      return (Field_blob*) field[getShare()->blob_field[arg]]; /*NOTE: Using 'Table.field' NOT SharedTable.field. */
408
 
 
409
 
    return NULL;
410
 
  }
411
 
  inline uint8_t getBlobPtrSize() { return getShare()->blob_ptr_size; }
412
 
  inline uint32_t getNullBytes() { return getShare()->null_bytes; }
413
 
  inline uint32_t getNullFields() { return getShare()->null_fields; }
414
 
  inline unsigned char *getDefaultValues() { return  getMutableShare()->getDefaultValues(); }
415
 
  inline const char *getSchemaName()  const { return getShare()->getSchemaName(); }
416
 
  inline const char *getTableName()  const { return getShare()->getTableName(); }
417
 
 
418
 
  inline bool isDatabaseLowByteFirst() { return getShare()->db_low_byte_first; } /* Portable row format */
419
 
  inline bool isNameLock() const { return open_placeholder; }
 
260
  inline const TableShare *getShare() const { assert(s); return s; } /* Get rid of this long term */
 
261
  inline void setShare(TableShare *new_share) { s= new_share; } /* Get rid of this long term */
 
262
  inline uint32_t sizeKeys() { return s->keys; }
 
263
  inline uint32_t sizeFields() { return s->fields; }
 
264
  inline uint32_t getRecordLength() { return s->reclength; }
 
265
  inline uint32_t sizeBlobFields() { return s->blob_fields; }
 
266
  inline uint32_t *getBlobField() { return s->blob_field; }
 
267
  inline uint32_t getNullBytes() { return s->null_bytes; }
 
268
  inline uint32_t getNullFields() { return s->null_fields; }
 
269
  inline unsigned char *getDefaultValues() { return s->default_values; }
 
270
 
 
271
  inline bool isDatabaseLowByteFirst() { return s->db_low_byte_first; } /* Portable row format */
 
272
  inline bool isNameLock() { return s->name_lock; }
 
273
  inline bool isReplaceWithNameLock() { return s->replace_with_name_lock; }
 
274
  inline bool isWaitingOnCondition() { return s->waiting_on_cond; } /* Protection against free */
420
275
 
421
276
  uint32_t index_flags(uint32_t idx) const
422
277
  {
423
 
    return getShare()->storage_engine->index_flags(getShare()->getKeyInfo(idx).algorithm);
 
278
    return s->storage_engine->index_flags(s->key_info[idx].algorithm);
424
279
  }
425
280
 
426
 
  inline plugin::StorageEngine *getEngine() const   /* table_type for handler */
 
281
  inline plugin::StorageEngine *getEngine() const       /* table_type for handler */
427
282
  {
428
 
    return getShare()->storage_engine;
 
283
    return s->storage_engine;
429
284
  }
430
285
 
431
 
  Cursor &getCursor() const /* table_type for handler */
 
286
  Cursor &getCursor() const     /* table_type for handler */
432
287
  {
433
288
    assert(cursor);
434
289
    return *cursor;
435
290
  }
436
291
 
 
292
  /* For TMP tables, should be pulled out as a class */
 
293
  void updateCreateInfo(message::Table *table_proto);
 
294
  void setup_tmp_table_column_bitmaps(unsigned char *bitmaps);
 
295
  bool create_myisam_tmp_table(KEY *keyinfo,
 
296
                               MI_COLUMNDEF *start_recinfo,
 
297
                               MI_COLUMNDEF **recinfo,
 
298
                               uint64_t options);
 
299
  void free_tmp_table(Session *session);
 
300
  bool open_tmp_table();
437
301
  size_t max_row_length(const unsigned char *data);
438
302
  uint32_t find_shortest_key(const key_map *usable_keys);
439
303
  bool compare_record(Field **ptr);
440
 
  bool records_are_comparable();
441
 
  bool compare_records();
 
304
  bool compare_record();
442
305
  /* TODO: the (re)storeRecord's may be able to be further condensed */
443
306
  void storeRecord();
444
307
  void storeRecordAsInsert();
447
310
  void restoreRecordAsDefault();
448
311
  void emptyRecord();
449
312
 
450
 
 
451
313
  /* See if this can be blown away */
452
314
  inline uint32_t getDBStat () { return db_stat; }
453
315
  inline uint32_t setDBStat () { return db_stat; }
470
332
  bool fill_item_list(List<Item> *item_list) const;
471
333
  void clear_column_bitmaps(void);
472
334
  void prepare_for_position(void);
473
 
  void mark_columns_used_by_index_no_reset(uint32_t index, boost::dynamic_bitset<>& bitmap);
 
335
  void mark_columns_used_by_index_no_reset(uint32_t index, MyBitmap *map);
474
336
  void mark_columns_used_by_index_no_reset(uint32_t index);
475
337
  void mark_columns_used_by_index(uint32_t index);
476
338
  void restore_column_maps_after_mark_index();
478
340
  void mark_columns_needed_for_update(void);
479
341
  void mark_columns_needed_for_delete(void);
480
342
  void mark_columns_needed_for_insert(void);
481
 
  void column_bitmaps_set(boost::dynamic_bitset<>& read_set_arg,
482
 
                          boost::dynamic_bitset<>& write_set_arg);
483
 
 
484
 
  void restore_column_map(const boost::dynamic_bitset<>& old);
485
 
 
486
 
  const boost::dynamic_bitset<> use_all_columns(boost::dynamic_bitset<>& map);
 
343
  inline void column_bitmaps_set(MyBitmap *read_set_arg,
 
344
                                 MyBitmap *write_set_arg)
 
345
  {
 
346
    read_set= read_set_arg;
 
347
    write_set= write_set_arg;
 
348
  }
 
349
 
 
350
  void restore_column_map(my_bitmap_map *old);
 
351
 
 
352
  my_bitmap_map *use_all_columns(MyBitmap *bitmap);
487
353
  inline void use_all_columns()
488
354
  {
489
 
    column_bitmaps_set(getMutableShare()->all_set, getMutableShare()->all_set);
 
355
    column_bitmaps_set(&s->all_set, &s->all_set);
490
356
  }
491
357
 
492
358
  inline void default_column_bitmaps()
498
364
  /* Both of the below should go away once we can move this bit to the field objects */
499
365
  inline bool isReadSet(uint32_t index)
500
366
  {
501
 
    return read_set->test(index);
 
367
    return read_set->isBitSet(index);
502
368
  }
503
369
 
504
370
  inline void setReadSet(uint32_t index)
505
371
  {
506
 
    read_set->set(index);
 
372
    read_set->setBit(index);
507
373
  }
508
374
 
509
375
  inline void setReadSet()
510
376
  {
511
 
    read_set->set();
 
377
    read_set->setAll();
512
378
  }
513
379
 
514
380
  inline void clearReadSet(uint32_t index)
515
381
  {
516
 
    read_set->reset(index);
 
382
    read_set->clearBit(index);
517
383
  }
518
384
 
519
385
  inline void clearReadSet()
520
386
  {
521
 
    read_set->reset();
 
387
    read_set->clearAll();
522
388
  }
523
389
 
524
390
  inline bool isWriteSet(uint32_t index)
525
391
  {
526
 
    return write_set->test(index);
 
392
    return write_set->isBitSet(index);
527
393
  }
528
394
 
529
395
  inline void setWriteSet(uint32_t index)
530
396
  {
531
 
    write_set->set(index);
 
397
    write_set->setBit(index);
532
398
  }
533
399
 
534
400
  inline void setWriteSet()
535
401
  {
536
 
    write_set->set();
 
402
    write_set->setAll();
537
403
  }
538
404
 
539
405
  inline void clearWriteSet(uint32_t index)
540
406
  {
541
 
    write_set->reset(index);
 
407
    write_set->clearBit(index);
542
408
  }
543
409
 
544
410
  inline void clearWriteSet()
545
411
  {
546
 
    write_set->reset();
 
412
    write_set->clearAll();
547
413
  }
548
414
 
549
415
  /* Is table open or should be treated as such by name-locking? */
556
422
  */
557
423
  inline bool needs_reopen_or_name_lock()
558
424
  { 
559
 
    return getShare()->getVersion() != refresh_version;
 
425
    return s->version != refresh_version;
560
426
  }
561
427
 
562
428
  /**
571
437
  {
572
438
    null_row= 1;
573
439
    status|= STATUS_NULL_ROW;
574
 
    memset(null_flags, 255, getShare()->null_bytes);
 
440
    memset(null_flags, 255, s->null_bytes);
575
441
  }
576
442
 
 
443
  bool renameAlterTemporaryTable(TableIdentifier &identifier);
577
444
  void free_io_cache();
578
445
  void filesort_free_buffers(bool full= false);
579
446
  void intern_close_table();
580
447
 
581
448
  void print_error(int error, myf errflag)
582
449
  {
583
 
    getShare()->storage_engine->print_error(error, errflag, *this);
 
450
    s->storage_engine->print_error(error, errflag, *this);
584
451
  }
585
452
 
586
453
  /**
603
470
  */
604
471
  bool operator<(const Table &right) const
605
472
  {
606
 
    return getShare()->getCacheKey() < right.getShare()->getCacheKey();
 
473
    int result= strcasecmp(this->getShare()->getSchemaName(), right.getShare()->getSchemaName());
 
474
 
 
475
    if (result <  0)
 
476
      return true;
 
477
 
 
478
    if (result >  0)
 
479
      return false;
 
480
 
 
481
    result= strcasecmp(this->getShare()->getTableName(), right.getShare()->getTableName());
 
482
 
 
483
    if (result <  0)
 
484
      return true;
 
485
 
 
486
    if (result >  0)
 
487
      return false;
 
488
 
 
489
    if (this->getShare()->getTableProto()->type()  < right.getShare()->getTableProto()->type())
 
490
      return true;
 
491
 
 
492
    return false;
607
493
  }
608
494
 
609
495
  static bool compare(const Table *a, const Table *b)
613
499
 
614
500
  friend std::ostream& operator<<(std::ostream& output, const Table &table)
615
501
  {
616
 
    if (table.getShare())
617
 
    {
618
 
      output << "Table:(";
619
 
      output << table.getShare()->getSchemaName();
620
 
      output << ", ";
621
 
      output <<  table.getShare()->getTableName();
622
 
      output << ", ";
623
 
      output <<  table.getShare()->getTableTypeAsString();
624
 
      output << ")";
625
 
    }
626
 
    else
627
 
    {
628
 
      output << "Table:(has no share)";
629
 
    }
 
502
    output << "Table:(";
 
503
    output << table.getShare()->getSchemaName();
 
504
    output << ", ";
 
505
    output <<  table.getShare()->getTableName();
 
506
    output << ", ";
 
507
    output <<  table.getShare()->getTableTypeAsString();
 
508
    output << ")";
630
509
 
631
510
    return output;  // for multiple << operators.
632
511
  }
633
512
 
634
 
public:
635
 
  virtual bool isPlaceHolder(void) const
636
 
  {
637
 
    return false;
638
 
  }
639
513
};
640
514
 
641
 
/**
642
 
 * @class
643
 
 *  ForeignKeyInfo
644
 
 *
645
 
 * @brief
646
 
 *  This class defines the information for foreign keys.
647
 
 */
648
 
class ForeignKeyInfo
 
515
Table *create_virtual_tmp_table(Session *session, List<CreateField> &field_list);
 
516
 
 
517
typedef struct st_foreign_key_info
649
518
{
650
 
public:
651
 
    /**
652
 
     * @brief
653
 
     *  This is the constructor with all properties set.
654
 
     *
655
 
     * @param[in] in_foreign_id The id of the foreign key
656
 
     * @param[in] in_referenced_db The referenced database name of the foreign key
657
 
     * @param[in] in_referenced_table The referenced table name of the foreign key
658
 
     * @param[in] in_update_method The update method of the foreign key.
659
 
     * @param[in] in_delete_method The delete method of the foreign key.
660
 
     * @param[in] in_referenced_key_name The name of referenced key
661
 
     * @param[in] in_foreign_fields The foreign fields
662
 
     * @param[in] in_referenced_fields The referenced fields
663
 
     */
664
 
    ForeignKeyInfo(LEX_STRING *in_foreign_id,
665
 
                   LEX_STRING *in_referenced_db,
666
 
                   LEX_STRING *in_referenced_table,
667
 
                   LEX_STRING *in_update_method,
668
 
                   LEX_STRING *in_delete_method,
669
 
                   LEX_STRING *in_referenced_key_name,
670
 
                   List<LEX_STRING> in_foreign_fields,
671
 
                   List<LEX_STRING> in_referenced_fields)
672
 
    :
673
 
      foreign_id(in_foreign_id),
674
 
      referenced_db(in_referenced_db),
675
 
      referenced_table(in_referenced_table),
676
 
      update_method(in_update_method),
677
 
      delete_method(in_delete_method),
678
 
      referenced_key_name(in_referenced_key_name),
679
 
      foreign_fields(in_foreign_fields),
680
 
      referenced_fields(in_referenced_fields)
681
 
    {}
682
 
 
683
 
    /**
684
 
     * @brief
685
 
     *  This is the default constructor. All properties are set to default values for their types.
686
 
     */
687
 
    ForeignKeyInfo()
688
 
    : foreign_id(NULL), referenced_db(NULL), referenced_table(NULL),
689
 
      update_method(NULL), delete_method(NULL), referenced_key_name(NULL)
690
 
    {}
691
 
 
692
 
    /**
693
 
     * @brief
694
 
     *  Gets the foreign id.
695
 
     *
696
 
     * @ retval  the foreign id
697
 
     */
698
 
    const LEX_STRING *getForeignId() const
699
 
    {
700
 
        return foreign_id;
701
 
    }
702
 
 
703
 
    /**
704
 
     * @brief
705
 
     *  Gets the name of the referenced database.
706
 
     *
707
 
     * @ retval  the name of the referenced database
708
 
     */
709
 
    const LEX_STRING *getReferencedDb() const
710
 
    {
711
 
        return referenced_db;
712
 
    }
713
 
 
714
 
    /**
715
 
     * @brief
716
 
     *  Gets the name of the referenced table.
717
 
     *
718
 
     * @ retval  the name of the referenced table
719
 
     */
720
 
    const LEX_STRING *getReferencedTable() const
721
 
    {
722
 
        return referenced_table;
723
 
    }
724
 
 
725
 
    /**
726
 
     * @brief
727
 
     *  Gets the update method.
728
 
     *
729
 
     * @ retval  the update method
730
 
     */
731
 
    const LEX_STRING *getUpdateMethod() const
732
 
    {
733
 
        return update_method;
734
 
    }
735
 
 
736
 
    /**
737
 
     * @brief
738
 
     *  Gets the delete method.
739
 
     *
740
 
     * @ retval  the delete method
741
 
     */
742
 
    const LEX_STRING *getDeleteMethod() const
743
 
    {
744
 
        return delete_method;
745
 
    }
746
 
 
747
 
    /**
748
 
     * @brief
749
 
     *  Gets the name of the referenced key.
750
 
     *
751
 
     * @ retval  the name of the referenced key
752
 
     */
753
 
    const LEX_STRING *getReferencedKeyName() const
754
 
    {
755
 
        return referenced_key_name;
756
 
    }
757
 
 
758
 
    /**
759
 
     * @brief
760
 
     *  Gets the foreign fields.
761
 
     *
762
 
     * @ retval  the foreign fields
763
 
     */
764
 
    const List<LEX_STRING> &getForeignFields() const
765
 
    {
766
 
        return foreign_fields;
767
 
    }
768
 
 
769
 
    /**
770
 
     * @brief
771
 
     *  Gets the referenced fields.
772
 
     *
773
 
     * @ retval  the referenced fields
774
 
     */
775
 
    const List<LEX_STRING> &getReferencedFields() const
776
 
    {
777
 
        return referenced_fields;
778
 
    }
779
 
private:
780
 
    /**
781
 
     * The foreign id.
782
 
     */
783
 
    LEX_STRING *foreign_id;
784
 
    /**
785
 
     * The name of the reference database.
786
 
     */
787
 
    LEX_STRING *referenced_db;
788
 
    /**
789
 
     * The name of the reference table.
790
 
     */
791
 
    LEX_STRING *referenced_table;
792
 
    /**
793
 
     * The update method.
794
 
     */
795
 
    LEX_STRING *update_method;
796
 
    /**
797
 
     * The delete method.
798
 
     */
799
 
    LEX_STRING *delete_method;
800
 
    /**
801
 
     * The name of the referenced key.
802
 
     */
803
 
    LEX_STRING *referenced_key_name;
804
 
    /**
805
 
     * The foreign fields.
806
 
     */
807
 
    List<LEX_STRING> foreign_fields;
808
 
    /**
809
 
     * The referenced fields.
810
 
     */
811
 
    List<LEX_STRING> referenced_fields;
812
 
};
 
519
  LEX_STRING *forein_id;
 
520
  LEX_STRING *referenced_db;
 
521
  LEX_STRING *referenced_table;
 
522
  LEX_STRING *update_method;
 
523
  LEX_STRING *delete_method;
 
524
  LEX_STRING *referenced_key_name;
 
525
  List<LEX_STRING> foreign_fields;
 
526
  List<LEX_STRING> referenced_fields;
 
527
} FOREIGN_KEY_INFO;
 
528
 
 
529
 
813
530
 
814
531
class TableList;
815
532
 
816
 
#define JOIN_TYPE_LEFT  1
817
 
#define JOIN_TYPE_RIGHT 2
 
533
#define JOIN_TYPE_LEFT  1
 
534
#define JOIN_TYPE_RIGHT 2
818
535
 
819
536
struct st_lex;
820
537
class select_union;
821
538
class Tmp_Table_Param;
822
539
 
 
540
struct open_table_list_st
 
541
{
 
542
  std::string   db;
 
543
  std::string   table;
 
544
  uint32_t in_use;
 
545
  uint32_t locked;
 
546
 
 
547
  open_table_list_st() :
 
548
    in_use(0),
 
549
    locked(0)
 
550
  { }
 
551
 
 
552
};
 
553
 
 
554
TableShare *alloc_table_share(TableList *table_list, char *key,
 
555
                               uint32_t key_length);
 
556
int open_table_def(Session& session, TableIdentifier &identifier, TableShare *share);
 
557
void open_table_error(TableShare *share, int error, int db_errno, int errarg);
 
558
int open_table_from_share(Session *session, TableShare *share, const char *alias,
 
559
                          uint32_t db_stat, uint32_t ha_open_flags,
 
560
                          Table *outparam);
823
561
void free_blobs(Table *table);
824
562
int set_zone(int nr,int min_zone,int max_zone);
825
563
uint32_t convert_period_to_month(uint32_t period);
830
568
 
831
569
namespace optimizer { class SqlSelect; }
832
570
 
 
571
ha_rows filesort(Session *session,
 
572
                 Table *form,
 
573
                 st_sort_field *sortorder,
 
574
                 uint32_t s_length,
 
575
                 optimizer::SqlSelect *select,
 
576
                 ha_rows max_rows,
 
577
                 bool sort_positions,
 
578
                 ha_rows *examined_rows);
 
579
 
 
580
void filesort_free_buffers(Table *table, bool full);
833
581
void change_double_for_sort(double nr,unsigned char *to);
834
582
double my_double_round(double value, int64_t dec, bool dec_unsigned,
835
583
                       bool truncate);
839
587
TYPELIB *convert_strings_to_array_type(char * *typelibs, char * *end);
840
588
TYPELIB *typelib(memory::Root *mem_root, List<String> &strings);
841
589
ulong get_form_pos(int file, unsigned char *head, TYPELIB *save_names);
 
590
ulong next_io_size(ulong pos);
842
591
void append_unescaped(String *res, const char *pos, uint32_t length);
843
592
 
844
593
int rename_file_ext(const char * from,const char * to,const char * ext);
845
594
bool check_column_name(const char *name);
846
 
bool check_db_name(Session *session, SchemaIdentifier &schema);
 
595
bool check_db_name(SchemaIdentifier &schema);
847
596
bool check_table_name(const char *name, uint32_t length);
848
597
 
849
598
} /* namespace drizzled */
850
599
 
851
 
#include "drizzled/table/instance.h"
852
 
#include "drizzled/table/concurrent.h"
853
 
 
854
600
#endif /* DRIZZLED_TABLE_H */