← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/table_share.h

  • Committer: lbieber
  • Date: 2010-10-06 16:34:16 UTC
  • mfrom: (1816.1.3 build)
  • Revision ID: lbieber@orisndriz08-20101006163416-ea0sl59qgpglk21y
Merge Monty - Change the requirement from either libinnodb to libhaildb. Also, tied it to version 2.2
Merge Andrew - fix bug 650935: remove --compress from all clients
Merge Andrew - fix bug 653471: Add -A to drizzle client
Merge Travis - 621861 = To change C structs to C++ classes in Drizzle

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