← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table_share.h

Fixed for null values in transaction log.

Show diffs side-by-side

added added

removed removed

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