← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table.h

  • Committer: LinuxJedi
  • Date: 2010-09-09 06:14:45 UTC
  • mto: (1750.1.1 build)
  • mto: This revision was merged to the branch mainline in revision 1751.
  • Revision ID: linuxjedi@linuxjedi-laptop-20100909061445-1jz91d5eed932616
Fix another wrong header, grr...

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
 
61
60
 */
62
61
class Table 
63
62
{
 
63
public:
 
64
  TableShare *s; /**< Pointer to the shared metadata about the table */
 
65
 
 
66
private:
64
67
  Field **field; /**< Pointer to fields collection */
65
68
public:
66
69
 
127
130
    prev= arg;
128
131
  }
129
132
 
130
 
  boost::dynamic_bitset<> *read_set; /* Active column sets */
131
 
  boost::dynamic_bitset<> *write_set; /* Active column sets */
 
133
  MyBitmap *read_set; /* Active column sets */
 
134
  MyBitmap *write_set; /* Active column sets */
132
135
 
133
136
  uint32_t tablenr;
134
137
  uint32_t db_stat; /**< information about the cursor as in Cursor.h */
135
138
 
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... */
 
139
  MyBitmap def_read_set; /**< Default read set of columns */
 
140
  MyBitmap def_write_set; /**< Default write set of columns */
 
141
  MyBitmap tmp_set; /* Not sure about this... */
139
142
 
140
143
  Session *in_use; /**< Pointer to the current session using this object */
141
144
  Session *getSession()
161
164
  Field_timestamp *timestamp_field; /**< Points to the auto-setting timestamp field, if any */
162
165
 
163
166
  TableList *pos_in_table_list; /* Element referring to this table */
164
 
  Order *group;
 
167
  order_st *group;
165
168
  
166
169
  const char *getAlias() const
167
170
  {
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:
 
171
    return alias;
 
172
  }
 
173
 
 
174
  const char *alias; /**< alias or table name if no alias */
184
175
 
185
176
  unsigned char *null_flags;
186
177
 
363
354
    return mem_root.strmake_root(str_arg, len_arg);
364
355
  }
365
356
 
366
 
  filesort_info sort;
 
357
  filesort_info_st sort;
367
358
 
368
359
  Table();
369
 
  virtual ~Table();
 
360
  virtual ~Table() { };
370
361
 
371
362
  int report_error(int error);
372
363
  /**
380
371
  void resetTable(Session *session, TableShare *share, uint32_t db_stat_arg);
381
372
 
382
373
  /* 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);
 
374
  inline const TableShare *getShare() const { assert(s); return s; } /* Get rid of this long term */
 
375
  inline bool hasShare() const { return s ? true : false ; } /* Get rid of this long term */
 
376
  inline TableShare *getMutableShare() { assert(s); return s; } /* Get rid of this long term */
 
377
  inline void setShare(TableShare *new_share) { s= new_share; } /* Get rid of this long term */
 
378
  inline uint32_t sizeKeys() { return s->sizeKeys(); }
 
379
  inline uint32_t sizeFields() { return s->sizeFields(); }
 
380
  inline uint32_t getRecordLength() const { return s->getRecordLength(); }
 
381
  inline uint32_t sizeBlobFields() { return s->blob_fields; }
 
382
  inline uint32_t *getBlobField() { return &s->blob_field[0]; }
403
383
 
404
384
  Field_blob *getBlobFieldAt(uint32_t arg) const
405
385
  {
406
 
    if (arg < getShare()->blob_fields)
407
 
      return (Field_blob*) field[getShare()->blob_field[arg]]; /*NOTE: Using 'Table.field' NOT SharedTable.field. */
 
386
    if (arg < s->blob_fields)
 
387
      return (Field_blob*) field[s->blob_field[arg]]; /*NOTE: Using 'Table.field' NOT SharedTable.field. */
408
388
 
409
389
    return NULL;
410
390
  }
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(); }
 
391
  inline uint8_t getBlobPtrSize() { return s->blob_ptr_size; }
 
392
  inline uint32_t getNullBytes() { return s->null_bytes; }
 
393
  inline uint32_t getNullFields() { return s->null_fields; }
 
394
  inline unsigned char *getDefaultValues() { return  s->getDefaultValues(); }
 
395
  inline const char *getSchemaName()  const { return s->getSchemaName(); }
 
396
  inline const char *getTableName()  const { return s->getTableName(); }
417
397
 
418
 
  inline bool isDatabaseLowByteFirst() { return getShare()->db_low_byte_first; } /* Portable row format */
419
 
  inline bool isNameLock() const { return open_placeholder; }
 
398
  inline bool isDatabaseLowByteFirst() { return s->db_low_byte_first; } /* Portable row format */
 
399
  inline bool isNameLock() const { return s->isNameLock(); }
 
400
  inline bool isReplaceWithNameLock() { return s->replace_with_name_lock; }
420
401
 
421
402
  uint32_t index_flags(uint32_t idx) const
422
403
  {
423
 
    return getShare()->storage_engine->index_flags(getShare()->getKeyInfo(idx).algorithm);
 
404
    return s->storage_engine->index_flags(s->getKeyInfo(idx).algorithm);
424
405
  }
425
406
 
426
407
  inline plugin::StorageEngine *getEngine() const   /* table_type for handler */
427
408
  {
428
 
    return getShare()->storage_engine;
 
409
    return s->storage_engine;
429
410
  }
430
411
 
431
412
  Cursor &getCursor() const /* table_type for handler */
434
415
    return *cursor;
435
416
  }
436
417
 
 
418
  /* For TMP tables, should be pulled out as a class */
 
419
  void setup_tmp_table_column_bitmaps(unsigned char *bitmaps);
 
420
  bool create_myisam_tmp_table(KeyInfo *keyinfo,
 
421
                               MI_COLUMNDEF *start_recinfo,
 
422
                               MI_COLUMNDEF **recinfo,
 
423
                               uint64_t options);
 
424
  void free_tmp_table(Session *session);
 
425
  bool open_tmp_table();
437
426
  size_t max_row_length(const unsigned char *data);
438
427
  uint32_t find_shortest_key(const key_map *usable_keys);
439
428
  bool compare_record(Field **ptr);
440
 
  bool records_are_comparable();
441
 
  bool compare_records();
 
429
  bool compare_record();
442
430
  /* TODO: the (re)storeRecord's may be able to be further condensed */
443
431
  void storeRecord();
444
432
  void storeRecordAsInsert();
447
435
  void restoreRecordAsDefault();
448
436
  void emptyRecord();
449
437
 
450
 
 
451
438
  /* See if this can be blown away */
452
439
  inline uint32_t getDBStat () { return db_stat; }
453
440
  inline uint32_t setDBStat () { return db_stat; }
470
457
  bool fill_item_list(List<Item> *item_list) const;
471
458
  void clear_column_bitmaps(void);
472
459
  void prepare_for_position(void);
473
 
  void mark_columns_used_by_index_no_reset(uint32_t index, boost::dynamic_bitset<>& bitmap);
 
460
  void mark_columns_used_by_index_no_reset(uint32_t index, MyBitmap *map);
474
461
  void mark_columns_used_by_index_no_reset(uint32_t index);
475
462
  void mark_columns_used_by_index(uint32_t index);
476
463
  void restore_column_maps_after_mark_index();
478
465
  void mark_columns_needed_for_update(void);
479
466
  void mark_columns_needed_for_delete(void);
480
467
  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);
 
468
  inline void column_bitmaps_set(MyBitmap *read_set_arg,
 
469
                                 MyBitmap *write_set_arg)
 
470
  {
 
471
    read_set= read_set_arg;
 
472
    write_set= write_set_arg;
 
473
  }
 
474
 
 
475
  void restore_column_map(my_bitmap_map *old);
 
476
 
 
477
  my_bitmap_map *use_all_columns(MyBitmap *bitmap);
487
478
  inline void use_all_columns()
488
479
  {
489
 
    column_bitmaps_set(getMutableShare()->all_set, getMutableShare()->all_set);
 
480
    column_bitmaps_set(&s->all_set, &s->all_set);
490
481
  }
491
482
 
492
483
  inline void default_column_bitmaps()
498
489
  /* Both of the below should go away once we can move this bit to the field objects */
499
490
  inline bool isReadSet(uint32_t index)
500
491
  {
501
 
    return read_set->test(index);
 
492
    return read_set->isBitSet(index);
502
493
  }
503
494
 
504
495
  inline void setReadSet(uint32_t index)
505
496
  {
506
 
    read_set->set(index);
 
497
    read_set->setBit(index);
507
498
  }
508
499
 
509
500
  inline void setReadSet()
510
501
  {
511
 
    read_set->set();
 
502
    read_set->setAll();
512
503
  }
513
504
 
514
505
  inline void clearReadSet(uint32_t index)
515
506
  {
516
 
    read_set->reset(index);
 
507
    read_set->clearBit(index);
517
508
  }
518
509
 
519
510
  inline void clearReadSet()
520
511
  {
521
 
    read_set->reset();
 
512
    read_set->clearAll();
522
513
  }
523
514
 
524
515
  inline bool isWriteSet(uint32_t index)
525
516
  {
526
 
    return write_set->test(index);
 
517
    return write_set->isBitSet(index);
527
518
  }
528
519
 
529
520
  inline void setWriteSet(uint32_t index)
530
521
  {
531
 
    write_set->set(index);
 
522
    write_set->setBit(index);
532
523
  }
533
524
 
534
525
  inline void setWriteSet()
535
526
  {
536
 
    write_set->set();
 
527
    write_set->setAll();
537
528
  }
538
529
 
539
530
  inline void clearWriteSet(uint32_t index)
540
531
  {
541
 
    write_set->reset(index);
 
532
    write_set->clearBit(index);
542
533
  }
543
534
 
544
535
  inline void clearWriteSet()
545
536
  {
546
 
    write_set->reset();
 
537
    write_set->clearAll();
547
538
  }
548
539
 
549
540
  /* Is table open or should be treated as such by name-locking? */
556
547
  */
557
548
  inline bool needs_reopen_or_name_lock()
558
549
  { 
559
 
    return getShare()->getVersion() != refresh_version;
 
550
    return s->getVersion() != refresh_version;
560
551
  }
561
552
 
562
553
  /**
571
562
  {
572
563
    null_row= 1;
573
564
    status|= STATUS_NULL_ROW;
574
 
    memset(null_flags, 255, getShare()->null_bytes);
 
565
    memset(null_flags, 255, s->null_bytes);
575
566
  }
576
567
 
577
568
  void free_io_cache();
580
571
 
581
572
  void print_error(int error, myf errflag)
582
573
  {
583
 
    getShare()->storage_engine->print_error(error, errflag, *this);
 
574
    s->storage_engine->print_error(error, errflag, *this);
584
575
  }
585
576
 
586
577
  /**
603
594
  */
604
595
  bool operator<(const Table &right) const
605
596
  {
606
 
    return getShare()->getCacheKey() < right.getShare()->getCacheKey();
 
597
    int result= strcasecmp(this->getShare()->getSchemaName(), right.getShare()->getSchemaName());
 
598
 
 
599
    if (result <  0)
 
600
      return true;
 
601
 
 
602
    if (result >  0)
 
603
      return false;
 
604
 
 
605
    result= strcasecmp(this->getShare()->getTableName(), right.getShare()->getTableName());
 
606
 
 
607
    if (result <  0)
 
608
      return true;
 
609
 
 
610
    if (result >  0)
 
611
      return false;
 
612
 
 
613
    if (this->getShare()->getTableProto()->type()  < right.getShare()->getTableProto()->type())
 
614
      return true;
 
615
 
 
616
    return false;
607
617
  }
608
618
 
609
619
  static bool compare(const Table *a, const Table *b)
613
623
 
614
624
  friend std::ostream& operator<<(std::ostream& output, const Table &table)
615
625
  {
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
 
    }
 
626
    output << "Table:(";
 
627
    output << table.getShare()->getSchemaName();
 
628
    output << ", ";
 
629
    output <<  table.getShare()->getTableName();
 
630
    output << ", ";
 
631
    output <<  table.getShare()->getTableTypeAsString();
 
632
    output << ")";
630
633
 
631
634
    return output;  // for multiple << operators.
632
635
  }
633
636
 
 
637
protected:
 
638
  bool is_placeholder_created;
 
639
 
634
640
public:
635
 
  virtual bool isPlaceHolder(void) const
 
641
  bool isPlaceHolder()
636
642
  {
637
 
    return false;
 
643
    return is_placeholder_created;
638
644
  }
639
645
};
640
646
 
820
826
class select_union;
821
827
class Tmp_Table_Param;
822
828
 
 
829
struct open_table_list_st
 
830
{
 
831
  std::string   db;
 
832
  std::string   table;
 
833
  uint32_t in_use;
 
834
  uint32_t locked;
 
835
 
 
836
  open_table_list_st() :
 
837
    in_use(0),
 
838
    locked(0)
 
839
  { }
 
840
 
 
841
};
 
842
 
823
843
void free_blobs(Table *table);
824
844
int set_zone(int nr,int min_zone,int max_zone);
825
845
uint32_t convert_period_to_month(uint32_t period);
830
850
 
831
851
namespace optimizer { class SqlSelect; }
832
852
 
 
853
ha_rows filesort(Session *session,
 
854
                 Table *form,
 
855
                 SortField *sortorder,
 
856
                 uint32_t s_length,
 
857
                 optimizer::SqlSelect *select,
 
858
                 ha_rows max_rows,
 
859
                 bool sort_positions,
 
860
                 ha_rows *examined_rows);
 
861
 
 
862
void filesort_free_buffers(Table *table, bool full);
833
863
void change_double_for_sort(double nr,unsigned char *to);
834
864
double my_double_round(double value, int64_t dec, bool dec_unsigned,
835
865
                       bool truncate);
839
869
TYPELIB *convert_strings_to_array_type(char * *typelibs, char * *end);
840
870
TYPELIB *typelib(memory::Root *mem_root, List<String> &strings);
841
871
ulong get_form_pos(int file, unsigned char *head, TYPELIB *save_names);
 
872
ulong next_io_size(ulong pos);
842
873
void append_unescaped(String *res, const char *pos, uint32_t length);
843
874
 
844
875
int rename_file_ext(const char * from,const char * to,const char * ext);
848
879
 
849
880
} /* namespace drizzled */
850
881
 
851
 
#include "drizzled/table/instance.h"
852
 
#include "drizzled/table/concurrent.h"
853
 
 
854
882
#endif /* DRIZZLED_TABLE_H */