← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/definition/table.h

  • Committer: Stewart Smith
  • Date: 2011-01-14 05:16:49 UTC
  • mto: (2086.1.3 build)
  • mto: This revision was merged to the branch mainline in revision 2087.
  • Revision ID: stewart@flamingspork.com-20110114051649-4kg0mdrgdtako8vp
add a FIXME to flesh out insert docs

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/definition/table.h
23
23
  instance of table share per one table in the database.
24
24
*/
25
25
 
26
 
#ifndef DRIZZLED_TABLE_INSTANCE_BASE_H
27
 
#define DRIZZLED_TABLE_INSTANCE_BASE_H
 
26
#ifndef DRIZZLED_DEFINITION_TABLE_H
 
27
#define DRIZZLED_DEFINITION_TABLE_H
28
28
 
29
29
#include <string>
30
30
 
32
32
#include <boost/thread/condition_variable.hpp>
33
33
#include <boost/dynamic_bitset.hpp>
34
34
#include <boost/shared_ptr.hpp>
35
 
#include <boost/scoped_ptr.hpp>
36
 
 
37
 
#include <drizzled/memory/root.h>
38
 
#include <drizzled/message.h>
39
 
#include <drizzled/util/string.h>
40
 
 
41
 
#include <drizzled/lex_string.h>
42
 
#include <drizzled/key_map.h>
43
 
 
44
 
#include <drizzled/table/cache.h>
45
 
 
46
 
#include <drizzled/field.h>
47
 
 
 
35
 
 
36
#include "drizzled/typelib.h"
 
37
#include "drizzled/memory/root.h"
 
38
#include "drizzled/message/table.pb.h"
 
39
#include "drizzled/util/string.h"
 
40
 
 
41
#include "drizzled/table/cache.h"
48
42
 
49
43
namespace drizzled
50
44
{
51
45
 
 
46
extern uint64_t refresh_version;
 
47
 
 
48
const static std::string STANDARD_STRING("STANDARD");
 
49
const static std::string TEMPORARY_STRING("TEMPORARY");
 
50
const static std::string INTERNAL_STRING("INTERNAL");
 
51
const static std::string FUNCTION_STRING("FUNCTION");
52
52
const static std::string NO_PROTOBUFFER_AVAILABLE("NO PROTOBUFFER AVAILABLE");
53
53
 
54
54
namespace plugin
55
55
{
56
56
class EventObserverList;
57
 
class StorageEngine;
58
57
}
59
58
 
60
59
namespace table {
61
 
class Singular;
 
60
class Instance;
62
61
}
63
62
 
64
63
class Field_blob;
71
70
  typedef boost::shared_ptr<TableShare> shared_ptr;
72
71
  typedef std::vector <shared_ptr> vector;
73
72
 
74
 
  TableShare(const identifier::Table::Type type_arg);
75
 
 
76
 
  TableShare(const identifier::Table &identifier, const identifier::Table::Key &key); // Used by placeholder
77
 
 
78
 
  TableShare(const identifier::Table &identifier); // Just used during createTable()
79
 
 
80
 
  TableShare(const identifier::Table::Type type_arg,
81
 
             const identifier::Table &identifier,
 
73
  TableShare(const TableIdentifier::Type type_arg);
 
74
 
 
75
  TableShare(const TableIdentifier &identifier, const TableIdentifier::Key &key); // Used by placeholder
 
76
 
 
77
  TableShare(const TableIdentifier &identifier); // Just used during createTable()
 
78
 
 
79
  TableShare(const TableIdentifier::Type type_arg,
 
80
             const TableIdentifier &identifier,
82
81
             char *path_arg= NULL, uint32_t path_length_arg= 0); // Shares for cache
83
82
 
84
 
  virtual ~TableShare();
 
83
  ~TableShare();
85
84
 
86
85
private:
87
86
  /** Category of this table. */
88
87
  enum_table_category table_category;
89
88
 
90
89
public:
 
90
 
91
91
  bool isTemporaryCategory() const
92
92
  {
93
93
    return (table_category == TABLE_CATEGORY_TEMPORARY);
100
100
 
101
101
  /* The following is copied to each Table on OPEN */
102
102
  typedef std::vector<Field *> Fields;
103
 
 
104
103
private:
105
104
  Fields _fields;
106
 
 
107
105
public:
108
106
  const Fields getFields() const
109
107
  {
136
134
    _fields.push_back(arg);
137
135
  }
138
136
 
 
137
 
139
138
  Field **found_next_number_field;
140
 
 
141
139
private:
142
140
  Field *timestamp_field;               /* Used only during open */
143
 
 
144
141
public:
145
142
 
146
143
  Field *getTimestampField() const               /* Used only during open */
156
153
 
157
154
private:
158
155
  KeyInfo  *key_info;                   /* data of keys in database */
159
 
 
160
156
public:
161
157
  KeyInfo &getKeyInfo(uint32_t arg) const
162
158
  {
164
160
  }
165
161
  std::vector<uint>     blob_field;                     /* Index to blobs in Field arrray*/
166
162
 
167
 
private:
168
163
  /* hash of field names (contains pointers to elements of field array) */
 
164
private:
169
165
  typedef boost::unordered_map < std::string, Field **, util::insensitive_hash, util::insensitive_equal_to> FieldMap;
170
166
  typedef std::pair< std::string, Field ** > FieldMapPair;
171
167
  FieldMap name_hash; /* hash of field names */
172
 
 
173
168
public:
174
169
  size_t getNamedFieldSize() const
175
170
  {
212
207
                   arg.begin(), ::toupper);
213
208
    _keynames.push_back(arg);
214
209
  }
215
 
 
216
210
public:
217
211
  bool doesKeyNameExist(const char *name_arg, uint32_t name_length, uint32_t &position) const
218
212
  {
240
234
private:
241
235
  std::vector<TYPELIB> intervals;                       /* pointer to interval info */
242
236
 
243
 
public:
244
 
  virtual void lock()
245
 
  { }
246
 
 
247
 
  virtual void unlock()
248
 
  { }
249
 
 
250
 
private:
 
237
  boost::mutex mutex;                /* For locking the share  */
 
238
  boost::condition_variable cond;                       /* To signal that share is ready */
 
239
 
 
240
 
 
241
  void lock()
 
242
  {
 
243
    mutex.lock();
 
244
  }
 
245
 
 
246
  void unlock()
 
247
  {
 
248
    mutex.unlock();
 
249
  }
 
250
 
251
251
  std::vector<unsigned char> default_values;            /* row with default values */
252
 
 
253
252
public:
254
253
  // @note This needs to be made to be const in the future
255
254
  unsigned char *getDefaultValues()
261
260
    default_values.resize(arg);
262
261
  }
263
262
 
264
 
  const charset_info_st *table_charset; /* Default charset of string fields */
 
263
  const CHARSET_INFO *table_charset; /* Default charset of string fields */
265
264
 
266
265
  boost::dynamic_bitset<> all_set;
267
266
 
276
275
    To ensure this one can use set_table_cache() methods.
277
276
  */
278
277
private:
279
 
  identifier::Table::Key private_key_for_cache; // This will not exist in the final design.
 
278
  TableIdentifier::Key private_key_for_cache; // This will not exist in the final design.
280
279
  std::vector<char> private_normalized_path; // This will not exist in the final design.
281
280
  LEX_STRING db;                        /* Pointer to db */
282
281
  LEX_STRING table_name;                /* Table name (for open) */
283
282
  LEX_STRING path;      /* Path to table (from datadir) */
284
283
  LEX_STRING normalized_path;           /* unpack_filename(path) */
285
 
 
286
284
public:
287
285
 
288
286
  const char *getNormalizedPath() const
295
293
    return path.str;
296
294
  }
297
295
 
298
 
  const identifier::Table::Key& getCacheKey() const // This should never be called when we aren't looking at a cache.
 
296
  const TableIdentifier::Key& getCacheKey() const // This should never be called when we aren't looking at a cache.
299
297
  {
300
298
    assert(private_key_for_cache.size());
301
299
    return private_key_for_cache;
318
316
    normalized_path.str= str_arg;
319
317
    normalized_path.length= size_arg;
320
318
  }
321
 
 
322
319
public:
323
320
 
324
321
  const char *getTableName() const
356
353
 
357
354
private:
358
355
  uint64_t   version;
359
 
 
360
356
public:
361
357
  uint64_t getVersion() const
362
358
  {
363
359
    return version;
364
360
  }
365
361
 
366
 
  void refreshVersion();
 
362
  void refreshVersion()
 
363
  {
 
364
   version= refresh_version;
 
365
  }
367
366
 
368
367
  void resetVersion()
369
368
  {
370
369
    version= 0;
371
370
  }
372
371
 
373
 
private:
374
372
  uint32_t   timestamp_offset;          /* Set to offset+1 of record */
375
 
 
376
 
  uint32_t reclength;                   /* Recordlength */
377
 
  uint32_t stored_rec_length;         /* Stored record length*/
378
 
 
 
373
private:
 
374
  uint32_t   reclength;                 /* Recordlength */
379
375
public:
380
 
  uint32_t sizeStoredRecord() const
381
 
  {
382
 
    return stored_rec_length;
383
 
  }
 
376
  uint32_t   stored_rec_length;         /* Stored record length*/
384
377
 
385
378
  uint32_t getRecordLength() const
386
379
  {
404
397
  /* Max rows is a hint to HEAP during a create tmp table */
405
398
  uint64_t max_rows;
406
399
 
407
 
  boost::scoped_ptr<message::Table> _table_message;
408
 
 
 
400
  message::Table *table_proto;
409
401
public:
 
402
 
410
403
  /*
411
 
    @note Without a _table_message, we assume we are building a STANDARD table.
 
404
    @note Without a table_proto, we assume we are building a STANDARD table.
412
405
    This will be modified once we use Identifiers in the Share itself.
413
406
  */
414
407
  message::Table::TableType getTableType() const
415
408
  {
416
 
    return getTableMessage() ? getTableMessage()->type() : message::Table::STANDARD;
 
409
    return table_proto ? table_proto->type() : message::Table::STANDARD;
417
410
  }
418
411
 
419
412
  const std::string &getTableTypeAsString() const
420
413
  {
421
 
    if (getTableMessage())
422
 
      return message::type(getTableMessage()->type());
423
 
 
424
 
    return NO_PROTOBUFFER_AVAILABLE;
 
414
    if (table_proto)
 
415
    {
 
416
      switch (table_proto->type())
 
417
      {
 
418
      default:
 
419
      case message::Table::STANDARD:
 
420
        return STANDARD_STRING;
 
421
      case message::Table::TEMPORARY:
 
422
        return TEMPORARY_STRING;
 
423
      case message::Table::INTERNAL:
 
424
        return INTERNAL_STRING;
 
425
      case message::Table::FUNCTION:
 
426
        return FUNCTION_STRING;
 
427
      }
 
428
    }
 
429
    else
 
430
    {
 
431
      return NO_PROTOBUFFER_AVAILABLE;
 
432
    }
425
433
  }
426
434
 
427
435
  /* This is only used in one location currently */
428
 
  inline message::Table *getTableMessage() const
429
 
  {
430
 
    return _table_message.get();
431
 
  }
432
 
 
433
 
  void setTableMessage(const message::Table &arg)
434
 
  {
435
 
    assert(not getTableMessage());
436
 
    _table_message.reset(new(std::nothrow) message::Table(arg));
 
436
  inline message::Table *getTableProto() const
 
437
  {
 
438
    return table_proto;
437
439
  }
438
440
 
439
441
  const message::Table::Field &field(int32_t field_position) const
440
442
  {
441
 
    assert(getTableMessage());
442
 
    return getTableMessage()->field(field_position);
 
443
    assert(table_proto);
 
444
    return table_proto->field(field_position);
 
445
  }
 
446
 
 
447
  inline void setTableProto(message::Table *arg)
 
448
  {
 
449
    assert(table_proto == NULL);
 
450
    table_proto= arg;
443
451
  }
444
452
 
445
453
  inline bool hasComment() const
446
454
  {
447
 
    return (getTableMessage()) ?  getTableMessage()->options().has_comment() : false; 
 
455
    return (table_proto) ?  table_proto->options().has_comment() : false; 
448
456
  }
449
457
 
450
458
  inline const char *getComment()
451
459
  {
452
 
    return (getTableMessage() && getTableMessage()->has_options()) ?  getTableMessage()->options().comment().c_str() : NULL; 
 
460
    return (table_proto && table_proto->has_options()) ?  table_proto->options().comment().c_str() : NULL; 
453
461
  }
454
462
 
455
463
  inline uint32_t getCommentLength() const
456
464
  {
457
 
    return (getTableMessage()) ? getTableMessage()->options().comment().length() : 0; 
 
465
    return (table_proto) ? table_proto->options().comment().length() : 0; 
458
466
  }
459
467
 
460
468
  inline uint64_t getMaxRows() const
484
492
  }
485
493
 
486
494
private:
487
 
  identifier::Table::Type tmp_table;
 
495
  TableIdentifier::Type tmp_table;
488
496
public:
489
497
 
490
 
  identifier::Table::Type getType() const
 
498
  TableIdentifier::Type getType() const
491
499
  {
492
500
    return tmp_table;
493
501
  }
494
502
 
495
503
private:
496
 
  uint32_t _ref_count;       /* How many Table objects uses this */
 
504
  uint32_t ref_count;       /* How many Table objects uses this */
497
505
 
498
506
public:
499
507
  uint32_t getTableCount() const
500
508
  {
501
 
    return _ref_count;
 
509
    return ref_count;
502
510
  }
503
511
 
504
512
  void incrementTableCount()
505
513
  {
506
514
    lock();
507
 
    _ref_count++;
 
515
    ref_count++;
508
516
    unlock();
509
517
  }
510
518
 
511
 
  uint32_t decrementTableCount()
512
 
  {
513
 
    return --_ref_count;
514
 
  }
515
 
 
516
519
  uint32_t null_bytes;
517
520
  uint32_t last_null_bit_pos;
518
521
private:
543
546
  uint32_t blob_fields;                 /* number of blob fields */
544
547
private:
545
548
  bool has_variable_width;                  /* number of varchar fields */
546
 
 
547
549
public:
548
550
  bool hasVariableWidth() const
549
551
  {
586
588
  uint32_t next_number_keypart;             /* autoinc keypart number in a key */
587
589
  uint32_t error, open_errno, errarg;       /* error from open_table_def() */
588
590
 
589
 
private:
590
591
  uint8_t blob_ptr_size;                        /* 4 or 8 */
591
 
 
592
 
public:
593
 
  uint8_t sizeBlobPtr() const
594
 
  {
595
 
    return blob_ptr_size;
596
 
  }
597
 
 
598
592
  bool db_low_byte_first;               /* Portable row format */
599
593
 
600
594
  /*
608
602
    event_observers is a class containing all the event plugins that have 
609
603
    registered an interest in this table.
610
604
  */
611
 
  virtual plugin::EventObserverList *getTableObservers() 
 
605
  private:
 
606
  plugin::EventObserverList *event_observers;
 
607
  public:
 
608
  plugin::EventObserverList *getTableObservers() 
612
609
  { 
613
 
    return NULL;
 
610
    return event_observers;
614
611
  }
615
612
  
616
 
  virtual void setTableObservers(plugin::EventObserverList *) 
617
 
  { }
 
613
  void setTableObservers(plugin::EventObserverList *observers) 
 
614
  { 
 
615
    event_observers= observers;
 
616
  }
618
617
  
619
618
  /*
620
619
    Set share's identifier information.
625
624
    NOTES
626
625
  */
627
626
 
628
 
  void setIdentifier(const identifier::Table &identifier_arg);
 
627
  void setIdentifier(const TableIdentifier &identifier_arg);
629
628
 
630
629
  /*
631
630
    Initialize share for temporary tables
646
645
private:
647
646
  void init(const char *new_table_name,
648
647
            const char *new_path);
 
648
public:
649
649
 
650
 
protected:
651
650
  void open_table_error(int pass_error, int db_errno, int pass_errarg);
652
651
 
653
 
public:
654
 
 
 
652
  static void release(TableShare *share);
 
653
  static void release(TableShare::shared_ptr &share);
 
654
  static void release(const TableIdentifier &identifier);
655
655
  static TableShare::shared_ptr getShareCreate(Session *session, 
656
 
                                               const identifier::Table &identifier,
 
656
                                               const TableIdentifier &identifier,
657
657
                                               int &error);
658
658
 
659
659
  friend std::ostream& operator<<(std::ostream& output, const TableShare &share)
672
672
  }
673
673
 
674
674
protected:
675
 
  friend class drizzled::table::Singular;
 
675
  friend class drizzled::table::Instance;
676
676
 
677
677
  Field *make_field(const message::Table::Field &pfield,
678
678
                    unsigned char *ptr,
682
682
                    unsigned char null_bit,
683
683
                    uint8_t decimals,
684
684
                    enum_field_types field_type,
685
 
                    const charset_info_st * field_charset,
 
685
                    const CHARSET_INFO * field_charset,
686
686
                    Field::utype unireg_check,
687
687
                    TYPELIB *interval,
688
688
                    const char *field_name);
695
695
                    unsigned char null_bit,
696
696
                    uint8_t decimals,
697
697
                    enum_field_types field_type,
698
 
                    const charset_info_st * field_charset,
 
698
                    const CHARSET_INFO * field_charset,
699
699
                    Field::utype unireg_check,
700
700
                    TYPELIB *interval,
701
701
                    const char *field_name, 
702
702
                    bool is_unsigned);
703
703
 
704
704
public:
705
 
  int open_table_def(Session& session, const identifier::Table &identifier);
 
705
  int open_table_def(Session& session, const TableIdentifier &identifier);
706
706
 
707
707
  int open_table_from_share(Session *session,
708
 
                            const identifier::Table &identifier,
 
708
                            const TableIdentifier &identifier,
709
709
                            const char *alias,
710
710
                            uint32_t db_stat, uint32_t ha_open_flags,
711
711
                            Table &outparam);
714
714
                                  const char *alias,
715
715
                                  uint32_t db_stat,
716
716
                                  Table &outparam);
717
 
  int open_table_cursor_inner(const identifier::Table &identifier,
 
717
  int open_table_cursor_inner(const TableIdentifier &identifier,
718
718
                              uint32_t db_stat, uint32_t ha_open_flags,
719
719
                              Table &outparam,
720
720
                              bool &error_reported);
721
721
public:
722
 
  bool parse_table_proto(Session& session, message::Table &table);
723
 
 
724
 
  virtual bool replicate() const
725
 
  {
726
 
    return false;
727
 
  }
 
722
  int parse_table_proto(Session& session, message::Table &table);
 
723
private:
 
724
  int inner_parse_table_proto(Session& session, message::Table &table);
728
725
};
729
726
 
730
727
} /* namespace drizzled */
731
728
 
732
 
#endif /* DRIZZLED_TABLE_INSTANCE_BASE_H */
 
729
#endif /* DRIZZLED_DEFINITION_TABLE_H */