← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table/instance/base.h

  • Committer: Monty Taylor
  • Date: 2011-02-13 17:26:39 UTC
  • mfrom: (2157.2.2 give-in-to-pkg-config)
  • mto: This revision was merged to the branch mainline in revision 2166.
  • Revision ID: mordred@inaugust.com-20110213172639-nhy7i72sfhoq13ms
Merged in pkg-config fixes.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/table/instance/base.h
1
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
 *
4
 
 *  Copyright (C) 2009 Sun Microsystems
 
4
 *  Copyright (C) 2009 Sun Microsystems, Inc.
5
5
 *
6
6
 *  This program is free software; you can redistribute it and/or modify
7
7
 *  it under the terms of the GNU General Public License as published by
23
23
  instance of table share per one table in the database.
24
24
*/
25
25
 
26
 
#ifndef DRIZZLED_TABLE_SHARE_H
27
 
#define DRIZZLED_TABLE_SHARE_H
 
26
#ifndef DRIZZLED_TABLE_INSTANCE_BASE_H
 
27
#define DRIZZLED_TABLE_INSTANCE_BASE_H
28
28
 
29
29
#include <string>
30
30
 
31
31
#include <boost/unordered_map.hpp>
32
32
#include <boost/thread/condition_variable.hpp>
 
33
#include <boost/dynamic_bitset.hpp>
 
34
#include <boost/shared_ptr.hpp>
 
35
#include <boost/scoped_ptr.hpp>
33
36
 
34
37
#include "drizzled/typelib.h"
35
38
#include "drizzled/memory/root.h"
36
 
#include "drizzled/message/table.pb.h"
 
39
#include "drizzled/message.h"
37
40
#include "drizzled/util/string.h"
38
41
 
 
42
#include "drizzled/lex_string.h"
 
43
#include "drizzled/key_map.h"
 
44
 
 
45
#include "drizzled/table/cache.h"
 
46
 
 
47
#include <drizzled/field.h>
 
48
 
 
49
 
39
50
namespace drizzled
40
51
{
41
52
 
42
 
typedef boost::unordered_map< TableIdentifier::Key, TableShare *> TableDefinitionCache;
43
 
 
44
 
const static std::string STANDARD_STRING("STANDARD");
45
 
const static std::string TEMPORARY_STRING("TEMPORARY");
46
 
const static std::string INTERNAL_STRING("INTERNAL");
47
 
const static std::string FUNCTION_STRING("FUNCTION");
 
53
const static std::string NO_PROTOBUFFER_AVAILABLE("NO PROTOBUFFER AVAILABLE");
48
54
 
49
55
namespace plugin
50
56
{
51
57
class EventObserverList;
 
58
class StorageEngine;
 
59
}
 
60
 
 
61
namespace table {
 
62
class Singular;
52
63
}
53
64
 
54
65
class Field_blob;
56
67
class TableShare
57
68
{
58
69
  typedef std::vector<std::string> StringVector;
 
70
 
59
71
public:
60
 
  TableShare(TableIdentifier::Type type_arg);
61
 
 
62
 
  TableShare(TableIdentifier &identifier, const TableIdentifier::Key &key); // Used by placeholder
63
 
 
64
 
  TableShare(const TableIdentifier &identifier); // Just used during createTable()
65
 
 
66
 
  TableShare(TableIdentifier::Type type_arg,
67
 
             TableIdentifier &identifier,
 
72
  typedef boost::shared_ptr<TableShare> shared_ptr;
 
73
  typedef std::vector <shared_ptr> vector;
 
74
 
 
75
  TableShare(const identifier::Table::Type type_arg);
 
76
 
 
77
  TableShare(const identifier::Table &identifier, const identifier::Table::Key &key); // Used by placeholder
 
78
 
 
79
  TableShare(const identifier::Table &identifier); // Just used during createTable()
 
80
 
 
81
  TableShare(const identifier::Table::Type type_arg,
 
82
             const identifier::Table &identifier,
68
83
             char *path_arg= NULL, uint32_t path_length_arg= 0); // Shares for cache
69
84
 
70
 
  ~TableShare();
 
85
  virtual ~TableShare();
71
86
 
72
87
private:
73
88
  /** Category of this table. */
74
89
  enum_table_category table_category;
75
90
 
76
 
  uint32_t open_count;                  /* Number of tables in open list */
77
91
public:
78
 
 
79
92
  bool isTemporaryCategory() const
80
93
  {
81
94
    return (table_category == TABLE_CATEGORY_TEMPORARY);
88
101
 
89
102
  /* The following is copied to each Table on OPEN */
90
103
  typedef std::vector<Field *> Fields;
 
104
 
91
105
private:
92
 
  Fields field;
 
106
  Fields _fields;
 
107
 
93
108
public:
94
109
  const Fields getFields() const
95
110
  {
96
 
    return field;
 
111
    return _fields;
 
112
  }
 
113
 
 
114
  Fields getFields()
 
115
  {
 
116
    return _fields;
97
117
  }
98
118
 
99
119
  Field ** getFields(bool)
100
120
  {
101
 
    return &field[0];
 
121
    return &_fields[0];
102
122
  }
103
123
 
104
124
  void setFields(uint32_t arg)
105
125
  {
106
 
    field.resize(arg);
 
126
    _fields.resize(arg);
107
127
  }
108
128
 
109
129
  uint32_t positionFields(Field **arg) const
110
130
  {
111
 
    return (arg - (Field **)&field[0]);
 
131
    return (arg - (Field **)&_fields[0]);
112
132
  }
113
133
 
114
134
  void pushField(Field *arg)
115
135
  {
116
 
    fields++;
117
 
    field.push_back(arg);
 
136
    _field_size++;
 
137
    _fields.push_back(arg);
118
138
  }
119
139
 
120
 
 
121
140
  Field **found_next_number_field;
 
141
 
122
142
private:
123
143
  Field *timestamp_field;               /* Used only during open */
 
144
 
124
145
public:
125
146
 
126
147
  Field *getTimestampField() const               /* Used only during open */
136
157
 
137
158
private:
138
159
  KeyInfo  *key_info;                   /* data of keys in database */
 
160
 
139
161
public:
140
162
  KeyInfo &getKeyInfo(uint32_t arg) const
141
163
  {
143
165
  }
144
166
  std::vector<uint>     blob_field;                     /* Index to blobs in Field arrray*/
145
167
 
 
168
private:
146
169
  /* hash of field names (contains pointers to elements of field array) */
147
 
private:
148
170
  typedef boost::unordered_map < std::string, Field **, util::insensitive_hash, util::insensitive_equal_to> FieldMap;
149
171
  typedef std::pair< std::string, Field ** > FieldMapPair;
150
172
  FieldMap name_hash; /* hash of field names */
 
173
 
151
174
public:
152
175
  size_t getNamedFieldSize() const
153
176
  {
166
189
 
167
190
private:
168
191
  memory::Root mem_root;
169
 
public:
 
192
 
170
193
  void *alloc_root(size_t arg)
171
194
  {
172
195
    return mem_root.alloc_root(arg);
182
205
    return &mem_root;
183
206
  }
184
207
 
185
 
private:
186
208
  std::vector<std::string> _keynames;
187
209
 
188
210
  void addKeyName(std::string arg)
191
213
                   arg.begin(), ::toupper);
192
214
    _keynames.push_back(arg);
193
215
  }
 
216
 
194
217
public:
195
218
  bool doesKeyNameExist(const char *name_arg, uint32_t name_length, uint32_t &position) const
196
219
  {
197
 
    std::string arg(name_arg, name_length);
198
 
    std::transform(arg.begin(), arg.end(),
199
 
                   arg.begin(), ::toupper);
200
 
 
201
 
    std::vector<std::string>::const_iterator iter= std::find(_keynames.begin(), _keynames.end(), arg);
202
 
 
203
 
    if (iter == _keynames.end())
204
 
      return false;
205
 
 
206
 
    position= iter -  _keynames.begin();
207
 
 
208
 
    return true;
 
220
    return doesKeyNameExist(std::string(name_arg, name_length), position);
209
221
  }
210
222
 
211
223
  bool doesKeyNameExist(std::string arg, uint32_t &position) const
217
229
 
218
230
    if (iter == _keynames.end())
219
231
    {
220
 
      position= -1; //historical, required for finding primary key from unique
 
232
      position= UINT32_MAX; //historical, required for finding primary key from unique
221
233
      return false;
222
234
    }
223
235
 
229
241
private:
230
242
  std::vector<TYPELIB> intervals;                       /* pointer to interval info */
231
243
 
232
 
  boost::mutex mutex;                /* For locking the share  */
233
 
  boost::condition_variable cond;                       /* To signal that share is ready */
234
 
 
235
 
 
236
 
  void lock()
237
 
  {
238
 
    mutex.lock();
239
 
  }
240
 
 
241
 
  void unlock()
242
 
  {
243
 
    mutex.unlock();
244
 
  }
245
244
public:
 
245
  virtual void lock()
 
246
  { }
 
247
 
 
248
  virtual void unlock()
 
249
  { }
246
250
 
247
251
private:
248
252
  std::vector<unsigned char> default_values;            /* row with default values */
 
253
 
249
254
public:
250
 
  unsigned char * getDefaultValues()
 
255
  // @note This needs to be made to be const in the future
 
256
  unsigned char *getDefaultValues()
251
257
  {
252
258
    return &default_values[0];
253
259
  }
256
262
    default_values.resize(arg);
257
263
  }
258
264
 
259
 
  const CHARSET_INFO *table_charset; /* Default charset of string fields */
260
 
 
261
 
  MyBitmap all_set;
262
 
private:
263
 
  std::vector<my_bitmap_map> all_bitmap;
264
 
 
265
 
public:
 
265
  const charset_info_st *table_charset; /* Default charset of string fields */
 
266
 
 
267
  boost::dynamic_bitset<> all_set;
 
268
 
266
269
  /*
267
270
    Key which is used for looking-up table in table cache and in the list
268
271
    of thread's temporary tables. Has the form of:
274
277
    To ensure this one can use set_table_cache() methods.
275
278
  */
276
279
private:
277
 
  TableIdentifier::Key private_key_for_cache; // This will not exist in the final design.
 
280
  identifier::Table::Key private_key_for_cache; // This will not exist in the final design.
278
281
  std::vector<char> private_normalized_path; // This will not exist in the final design.
279
282
  LEX_STRING db;                        /* Pointer to db */
280
283
  LEX_STRING table_name;                /* Table name (for open) */
281
284
  LEX_STRING path;      /* Path to table (from datadir) */
282
285
  LEX_STRING normalized_path;           /* unpack_filename(path) */
 
286
 
283
287
public:
284
288
 
285
289
  const char *getNormalizedPath() const
292
296
    return path.str;
293
297
  }
294
298
 
295
 
  const TableIdentifier::Key& getCacheKey() const // This should never be called when we aren't looking at a cache.
 
299
  const identifier::Table::Key& getCacheKey() const // This should never be called when we aren't looking at a cache.
296
300
  {
297
301
    assert(private_key_for_cache.size());
298
302
    return private_key_for_cache;
303
307
    return private_key_for_cache.size();
304
308
  }
305
309
 
 
310
private:
306
311
  void setPath(char *str_arg, uint32_t size_arg)
307
312
  {
308
313
    path.str= str_arg;
315
320
    normalized_path.length= size_arg;
316
321
  }
317
322
 
 
323
public:
 
324
 
318
325
  const char *getTableName() const
319
326
  {
320
327
    return table_name.str;
350
357
 
351
358
private:
352
359
  uint64_t   version;
 
360
 
353
361
public:
354
362
  uint64_t getVersion() const
355
363
  {
356
364
    return version;
357
365
  }
358
366
 
359
 
  void refreshVersion()
360
 
  {
361
 
   version= refresh_version;
362
 
  }
 
367
  void refreshVersion();
363
368
 
364
369
  void resetVersion()
365
370
  {
366
371
    version= 0;
367
372
  }
368
373
 
 
374
private:
369
375
  uint32_t   timestamp_offset;          /* Set to offset+1 of record */
370
 
private:
371
 
  uint32_t   reclength;                 /* Recordlength */
 
376
 
 
377
  uint32_t reclength;                   /* Recordlength */
 
378
  uint32_t stored_rec_length;         /* Stored record length*/
 
379
 
372
380
public:
373
 
  uint32_t   stored_rec_length;         /* Stored record length*/
 
381
  uint32_t sizeStoredRecord() const
 
382
  {
 
383
    return stored_rec_length;
 
384
  }
374
385
 
375
386
  uint32_t getRecordLength() const
376
387
  {
385
396
  const Field_blob *getBlobFieldAt(uint32_t arg) const
386
397
  {
387
398
    if (arg < blob_fields)
388
 
      return (Field_blob*) field[blob_field[arg]];
 
399
      return (Field_blob*) _fields[blob_field[arg]];
389
400
 
390
401
    return NULL;
391
402
  }
394
405
  /* Max rows is a hint to HEAP during a create tmp table */
395
406
  uint64_t max_rows;
396
407
 
397
 
  message::Table *table_proto;
 
408
  boost::scoped_ptr<message::Table> _table_message;
 
409
 
398
410
public:
399
 
 
400
411
  /*
401
 
    @note Without a table_proto, we assume we are building a STANDARD table.
 
412
    @note Without a _table_message, we assume we are building a STANDARD table.
402
413
    This will be modified once we use Identifiers in the Share itself.
403
414
  */
404
415
  message::Table::TableType getTableType() const
405
416
  {
406
 
    return table_proto ? table_proto->type() : message::Table::STANDARD;
 
417
    return getTableMessage() ? getTableMessage()->type() : message::Table::STANDARD;
407
418
  }
408
419
 
409
420
  const std::string &getTableTypeAsString() const
410
421
  {
411
 
    switch (table_proto->type())
412
 
    {
413
 
    default:
414
 
    case message::Table::STANDARD:
415
 
      return STANDARD_STRING;
416
 
    case message::Table::TEMPORARY:
417
 
      return TEMPORARY_STRING;
418
 
    case message::Table::INTERNAL:
419
 
      return INTERNAL_STRING;
420
 
    case message::Table::FUNCTION:
421
 
      return FUNCTION_STRING;
422
 
    }
 
422
    if (getTableMessage())
 
423
      return message::type(getTableMessage()->type());
 
424
 
 
425
    return NO_PROTOBUFFER_AVAILABLE;
423
426
  }
424
427
 
425
428
  /* This is only used in one location currently */
426
 
  inline message::Table *getTableProto() const
427
 
  {
428
 
    return table_proto;
429
 
  }
430
 
 
431
 
  inline void setTableProto(message::Table *arg)
432
 
  {
433
 
    assert(table_proto == NULL);
434
 
    table_proto= arg;
 
429
  inline message::Table *getTableMessage() const
 
430
  {
 
431
    return _table_message.get();
 
432
  }
 
433
 
 
434
  void setTableMessage(const message::Table &arg)
 
435
  {
 
436
    assert(not getTableMessage());
 
437
    _table_message.reset(new(std::nothrow) message::Table(arg));
 
438
  }
 
439
 
 
440
  const message::Table::Field &field(int32_t field_position) const
 
441
  {
 
442
    assert(getTableMessage());
 
443
    return getTableMessage()->field(field_position);
435
444
  }
436
445
 
437
446
  inline bool hasComment() const
438
447
  {
439
 
    return (table_proto) ?  table_proto->options().has_comment() : false; 
 
448
    return (getTableMessage()) ?  getTableMessage()->options().has_comment() : false; 
440
449
  }
441
450
 
442
451
  inline const char *getComment()
443
452
  {
444
 
    return (table_proto && table_proto->has_options()) ?  table_proto->options().comment().c_str() : NULL; 
 
453
    return (getTableMessage() && getTableMessage()->has_options()) ?  getTableMessage()->options().comment().c_str() : NULL; 
445
454
  }
446
455
 
447
456
  inline uint32_t getCommentLength() const
448
457
  {
449
 
    return (table_proto) ? table_proto->options().comment().length() : 0; 
 
458
    return (getTableMessage()) ? getTableMessage()->options().comment().length() : 0; 
450
459
  }
451
460
 
452
461
  inline uint64_t getMaxRows() const
476
485
  }
477
486
 
478
487
private:
479
 
  TableIdentifier::Type tmp_table;
 
488
  identifier::Table::Type tmp_table;
480
489
public:
481
490
 
482
 
  TableIdentifier::Type getType() const
 
491
  identifier::Table::Type getType() const
483
492
  {
484
493
    return tmp_table;
485
494
  }
486
495
 
487
496
private:
488
 
  uint32_t ref_count;       /* How many Table objects uses this */
 
497
  uint32_t _ref_count;       /* How many Table objects uses this */
 
498
 
489
499
public:
490
500
  uint32_t getTableCount() const
491
501
  {
492
 
    return ref_count;
 
502
    return _ref_count;
493
503
  }
494
504
 
495
505
  void incrementTableCount()
496
506
  {
497
507
    lock();
498
 
    ref_count++;
 
508
    _ref_count++;
499
509
    unlock();
500
510
  }
501
511
 
 
512
  uint32_t decrementTableCount()
 
513
  {
 
514
    return --_ref_count;
 
515
  }
 
516
 
502
517
  uint32_t null_bytes;
503
518
  uint32_t last_null_bit_pos;
504
 
  uint32_t fields;                              /* Number of fields */
 
519
private:
 
520
  uint32_t _field_size;                         /* Number of fields */
 
521
 
 
522
public:
 
523
  void setFieldSize(uint32_t arg)
 
524
  {
 
525
    _field_size= arg;
 
526
  }
505
527
 
506
528
  uint32_t sizeFields() const
507
529
  {
508
 
    return fields;
 
530
    return _field_size;
509
531
  }
510
532
 
511
533
  uint32_t rec_buff_length;                 /* Size of table->record[] buffer */
520
542
  uint32_t uniques;                         /* Number of UNIQUE index */
521
543
  uint32_t null_fields;                 /* number of null fields */
522
544
  uint32_t blob_fields;                 /* number of blob fields */
523
 
  uint32_t timestamp_field_offset;              /* Field number for timestamp field */
524
 
  uint32_t varchar_fields;                  /* number of varchar fields */
 
545
private:
 
546
  bool has_variable_width;                  /* number of varchar fields */
 
547
 
 
548
public:
 
549
  bool hasVariableWidth() const
 
550
  {
 
551
    return has_variable_width; // We should calculate this.
 
552
  }
 
553
  void setVariableWidth()
 
554
  {
 
555
    has_variable_width= true;
 
556
  }
525
557
  uint32_t db_create_options;           /* Create options from database */
526
558
  uint32_t db_options_in_use;           /* Options in use */
527
559
  uint32_t db_record_offset;            /* if HA_REC_IN_SEQ */
554
586
  uint32_t next_number_key_offset;          /* autoinc keypart offset in a key */
555
587
  uint32_t next_number_keypart;             /* autoinc keypart number in a key */
556
588
  uint32_t error, open_errno, errarg;       /* error from open_table_def() */
557
 
  uint32_t column_bitmap_size;
558
589
 
 
590
private:
559
591
  uint8_t blob_ptr_size;                        /* 4 or 8 */
 
592
 
 
593
public:
 
594
  uint8_t sizeBlobPtr() const
 
595
  {
 
596
    return blob_ptr_size;
 
597
  }
 
598
 
560
599
  bool db_low_byte_first;               /* Portable row format */
561
600
 
562
 
private:
563
 
  bool name_lock;
564
 
public:
565
 
  bool isNameLock() const
566
 
  {
567
 
    return name_lock;
568
 
  }
569
 
 
570
 
  bool replace_with_name_lock;
571
 
 
572
 
private:
573
 
  bool waiting_on_cond;                 /* Protection against free */
574
 
public:
575
 
  bool isWaitingOnCondition()
576
 
  {
577
 
    return waiting_on_cond;
578
 
  }
579
 
 
580
601
  /*
581
602
    Set of keys in use, implemented as a Bitmap.
582
603
    Excludes keys disabled by ALTER Table ... DISABLE KEYS.
588
609
    event_observers is a class containing all the event plugins that have 
589
610
    registered an interest in this table.
590
611
  */
591
 
  private:
592
 
  plugin::EventObserverList *event_observers;
593
 
  public:
594
 
  plugin::EventObserverList *getTableObservers() 
 
612
  virtual plugin::EventObserverList *getTableObservers() 
595
613
  { 
596
 
    return event_observers;
 
614
    return NULL;
597
615
  }
598
616
  
599
 
  void setTableObservers(plugin::EventObserverList *observers) 
600
 
  { 
601
 
    event_observers= observers;
602
 
  }
 
617
  virtual void setTableObservers(plugin::EventObserverList *) 
 
618
  { }
603
619
  
604
620
  /*
605
621
    Set share's identifier information.
610
626
    NOTES
611
627
  */
612
628
 
613
 
  void setIdentifier(TableIdentifier &identifier_arg);
614
 
 
615
 
  inline bool honor_global_locks()
616
 
  {
617
 
    return (table_category == TABLE_CATEGORY_USER);
618
 
  }
619
 
 
 
629
  void setIdentifier(const identifier::Table &identifier_arg);
620
630
 
621
631
  /*
622
632
    Initialize share for temporary tables
637
647
private:
638
648
  void init(const char *new_table_name,
639
649
            const char *new_path);
640
 
public:
641
650
 
 
651
protected:
642
652
  void open_table_error(int pass_error, int db_errno, int pass_errarg);
643
653
 
644
 
  static void cacheStart(void);
645
 
  static void release(TableShare *share);
646
 
  static void release(TableIdentifier &identifier);
647
 
  static const TableDefinitionCache &getCache();
648
 
  static TableShare *getShare(TableIdentifier &identifier);
649
 
  static TableShare *getShareCreate(Session *session, 
650
 
                                    TableIdentifier &identifier,
651
 
                                    int *error);
 
654
public:
 
655
 
 
656
  static TableShare::shared_ptr getShareCreate(Session *session, 
 
657
                                               const identifier::Table &identifier,
 
658
                                               int &error);
652
659
 
653
660
  friend std::ostream& operator<<(std::ostream& output, const TableShare &share)
654
661
  {
665
672
    return output;  // for multiple << operators.
666
673
  }
667
674
 
668
 
  Field *make_field(unsigned char *ptr,
 
675
protected:
 
676
  friend class drizzled::table::Singular;
 
677
 
 
678
  Field *make_field(const message::Table::Field &pfield,
 
679
                    unsigned char *ptr,
669
680
                    uint32_t field_length,
670
681
                    bool is_nullable,
671
682
                    unsigned char *null_pos,
672
683
                    unsigned char null_bit,
673
684
                    uint8_t decimals,
674
685
                    enum_field_types field_type,
675
 
                    const CHARSET_INFO * field_charset,
 
686
                    const charset_info_st * field_charset,
676
687
                    Field::utype unireg_check,
677
688
                    TYPELIB *interval,
678
689
                    const char *field_name);
679
690
 
680
 
  int open_table_def(Session& session, TableIdentifier &identifier);
 
691
  Field *make_field(const message::Table::Field &pfield,
 
692
                    unsigned char *ptr,
 
693
                    uint32_t field_length,
 
694
                    bool is_nullable,
 
695
                    unsigned char *null_pos,
 
696
                    unsigned char null_bit,
 
697
                    uint8_t decimals,
 
698
                    enum_field_types field_type,
 
699
                    const charset_info_st * field_charset,
 
700
                    Field::utype unireg_check,
 
701
                    TYPELIB *interval,
 
702
                    const char *field_name, 
 
703
                    bool is_unsigned);
 
704
 
 
705
public:
 
706
  int open_table_def(Session& session, const identifier::Table &identifier);
681
707
 
682
708
  int open_table_from_share(Session *session,
683
 
                            const TableIdentifier &identifier,
 
709
                            const identifier::Table &identifier,
684
710
                            const char *alias,
685
711
                            uint32_t db_stat, uint32_t ha_open_flags,
686
712
                            Table &outparam);
687
 
  int parse_table_proto(Session& session, message::Table &table);
688
713
private:
689
 
  int inner_parse_table_proto(Session& session, message::Table &table);
 
714
  int open_table_from_share_inner(Session *session,
 
715
                                  const char *alias,
 
716
                                  uint32_t db_stat,
 
717
                                  Table &outparam);
 
718
  int open_table_cursor_inner(const identifier::Table &identifier,
 
719
                              uint32_t db_stat, uint32_t ha_open_flags,
 
720
                              Table &outparam,
 
721
                              bool &error_reported);
 
722
public:
 
723
  bool parse_table_proto(Session& session, message::Table &table);
690
724
};
691
725
 
692
726
} /* namespace drizzled */
693
727
 
694
 
#endif /* DRIZZLED_TABLE_SHARE_H */
 
728
#endif /* DRIZZLED_TABLE_INSTANCE_BASE_H */