// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: table.proto

#ifndef PROTOBUF_table_2eproto__INCLUDED
#define PROTOBUF_table_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 2003000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_message_reflection.h>
#include "engine.pb.h"
// @@protoc_insertion_point(includes)

namespace drizzled {
namespace message {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_table_2eproto();
void protobuf_AssignDesc_table_2eproto();
void protobuf_ShutdownFile_table_2eproto();

class Table;
class Table_TableOptions;
class Table_ForeignKeyConstraint;
class Table_Field;
class Table_Field_FieldOptions;
class Table_Field_TimestampFieldOptions;
class Table_Field_FieldConstraints;
class Table_Field_NumericFieldOptions;
class Table_Field_StringFieldOptions;
class Table_Field_EnumerationValues;
class Table_Index;
class Table_Index_IndexPart;
class Table_Index_Options;
class AlterTable;

enum Table_TableOptions_RowType {
  Table_TableOptions_RowType_ROW_TYPE_DEFAULT = 0,
  Table_TableOptions_RowType_ROW_TYPE_FIXED = 1,
  Table_TableOptions_RowType_ROW_TYPE_DYNAMIC = 2,
  Table_TableOptions_RowType_ROW_TYPE_COMPRESSED = 3,
  Table_TableOptions_RowType_ROW_TYPE_REDUNDANT = 4,
  Table_TableOptions_RowType_ROW_TYPE_COMPACT = 5,
  Table_TableOptions_RowType_ROW_TYPE_PAGE = 6
};
bool Table_TableOptions_RowType_IsValid(int value);
const Table_TableOptions_RowType Table_TableOptions_RowType_RowType_MIN = Table_TableOptions_RowType_ROW_TYPE_DEFAULT;
const Table_TableOptions_RowType Table_TableOptions_RowType_RowType_MAX = Table_TableOptions_RowType_ROW_TYPE_PAGE;
const int Table_TableOptions_RowType_RowType_ARRAYSIZE = Table_TableOptions_RowType_RowType_MAX + 1;

const ::google::protobuf::EnumDescriptor* Table_TableOptions_RowType_descriptor();
inline const ::std::string& Table_TableOptions_RowType_Name(Table_TableOptions_RowType value) {
  return ::google::protobuf::internal::NameOfEnum(
    Table_TableOptions_RowType_descriptor(), value);
}
inline bool Table_TableOptions_RowType_Parse(
    const ::std::string& name, Table_TableOptions_RowType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Table_TableOptions_RowType>(
    Table_TableOptions_RowType_descriptor(), name, value);
}
enum Table_Field_FieldType {
  Table_Field_FieldType_DOUBLE = 0,
  Table_Field_FieldType_VARCHAR = 1,
  Table_Field_FieldType_BLOB = 2,
  Table_Field_FieldType_ENUM = 3,
  Table_Field_FieldType_INTEGER = 4,
  Table_Field_FieldType_BIGINT = 5,
  Table_Field_FieldType_DECIMAL = 6,
  Table_Field_FieldType_DATE = 7,
  Table_Field_FieldType_TIMESTAMP = 9,
  Table_Field_FieldType_DATETIME = 10
};
bool Table_Field_FieldType_IsValid(int value);
const Table_Field_FieldType Table_Field_FieldType_FieldType_MIN = Table_Field_FieldType_DOUBLE;
const Table_Field_FieldType Table_Field_FieldType_FieldType_MAX = Table_Field_FieldType_DATETIME;
const int Table_Field_FieldType_FieldType_ARRAYSIZE = Table_Field_FieldType_FieldType_MAX + 1;

const ::google::protobuf::EnumDescriptor* Table_Field_FieldType_descriptor();
inline const ::std::string& Table_Field_FieldType_Name(Table_Field_FieldType value) {
  return ::google::protobuf::internal::NameOfEnum(
    Table_Field_FieldType_descriptor(), value);
}
inline bool Table_Field_FieldType_Parse(
    const ::std::string& name, Table_Field_FieldType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Table_Field_FieldType>(
    Table_Field_FieldType_descriptor(), name, value);
}
enum Table_Index_IndexType {
  Table_Index_IndexType_UNKNOWN_INDEX = 0,
  Table_Index_IndexType_BTREE = 1,
  Table_Index_IndexType_RTREE = 2,
  Table_Index_IndexType_HASH = 3,
  Table_Index_IndexType_FULLTEXT = 4
};
bool Table_Index_IndexType_IsValid(int value);
const Table_Index_IndexType Table_Index_IndexType_IndexType_MIN = Table_Index_IndexType_UNKNOWN_INDEX;
const Table_Index_IndexType Table_Index_IndexType_IndexType_MAX = Table_Index_IndexType_FULLTEXT;
const int Table_Index_IndexType_IndexType_ARRAYSIZE = Table_Index_IndexType_IndexType_MAX + 1;

const ::google::protobuf::EnumDescriptor* Table_Index_IndexType_descriptor();
inline const ::std::string& Table_Index_IndexType_Name(Table_Index_IndexType value) {
  return ::google::protobuf::internal::NameOfEnum(
    Table_Index_IndexType_descriptor(), value);
}
inline bool Table_Index_IndexType_Parse(
    const ::std::string& name, Table_Index_IndexType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Table_Index_IndexType>(
    Table_Index_IndexType_descriptor(), name, value);
}
enum Table_TableType {
  Table_TableType_STANDARD = 0,
  Table_TableType_TEMPORARY = 1,
  Table_TableType_INTERNAL = 2,
  Table_TableType_FUNCTION = 3
};
bool Table_TableType_IsValid(int value);
const Table_TableType Table_TableType_TableType_MIN = Table_TableType_STANDARD;
const Table_TableType Table_TableType_TableType_MAX = Table_TableType_FUNCTION;
const int Table_TableType_TableType_ARRAYSIZE = Table_TableType_TableType_MAX + 1;

const ::google::protobuf::EnumDescriptor* Table_TableType_descriptor();
inline const ::std::string& Table_TableType_Name(Table_TableType value) {
  return ::google::protobuf::internal::NameOfEnum(
    Table_TableType_descriptor(), value);
}
inline bool Table_TableType_Parse(
    const ::std::string& name, Table_TableType* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Table_TableType>(
    Table_TableType_descriptor(), name, value);
}
// ===================================================================

class Table_TableOptions : public ::google::protobuf::Message {
 public:
  Table_TableOptions();
  virtual ~Table_TableOptions();
  
  Table_TableOptions(const Table_TableOptions& from);
  
  inline Table_TableOptions& operator=(const Table_TableOptions& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_TableOptions& default_instance();
  
  void Swap(Table_TableOptions* other);
  
  // implements Message ----------------------------------------------
  
  Table_TableOptions* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_TableOptions& from);
  void MergeFrom(const Table_TableOptions& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef Table_TableOptions_RowType RowType;
  static const RowType ROW_TYPE_DEFAULT = Table_TableOptions_RowType_ROW_TYPE_DEFAULT;
  static const RowType ROW_TYPE_FIXED = Table_TableOptions_RowType_ROW_TYPE_FIXED;
  static const RowType ROW_TYPE_DYNAMIC = Table_TableOptions_RowType_ROW_TYPE_DYNAMIC;
  static const RowType ROW_TYPE_COMPRESSED = Table_TableOptions_RowType_ROW_TYPE_COMPRESSED;
  static const RowType ROW_TYPE_REDUNDANT = Table_TableOptions_RowType_ROW_TYPE_REDUNDANT;
  static const RowType ROW_TYPE_COMPACT = Table_TableOptions_RowType_ROW_TYPE_COMPACT;
  static const RowType ROW_TYPE_PAGE = Table_TableOptions_RowType_ROW_TYPE_PAGE;
  static inline bool RowType_IsValid(int value) {
    return Table_TableOptions_RowType_IsValid(value);
  }
  static const RowType RowType_MIN =
    Table_TableOptions_RowType_RowType_MIN;
  static const RowType RowType_MAX =
    Table_TableOptions_RowType_RowType_MAX;
  static const int RowType_ARRAYSIZE =
    Table_TableOptions_RowType_RowType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  RowType_descriptor() {
    return Table_TableOptions_RowType_descriptor();
  }
  static inline const ::std::string& RowType_Name(RowType value) {
    return Table_TableOptions_RowType_Name(value);
  }
  static inline bool RowType_Parse(const ::std::string& name,
      RowType* value) {
    return Table_TableOptions_RowType_Parse(name, value);
  }
  
  // accessors -------------------------------------------------------
  
  // optional uint64 auto_increment = 1;
  inline bool has_auto_increment() const;
  inline void clear_auto_increment();
  static const int kAutoIncrementFieldNumber = 1;
  inline ::google::protobuf::uint64 auto_increment() const;
  inline void set_auto_increment(::google::protobuf::uint64 value);
  
  // optional string collation = 2;
  inline bool has_collation() const;
  inline void clear_collation();
  static const int kCollationFieldNumber = 2;
  inline const ::std::string& collation() const;
  inline void set_collation(const ::std::string& value);
  inline void set_collation(const char* value);
  inline void set_collation(const char* value, size_t size);
  inline ::std::string* mutable_collation();
  
  // optional uint32 collation_id = 3;
  inline bool has_collation_id() const;
  inline void clear_collation_id();
  static const int kCollationIdFieldNumber = 3;
  inline ::google::protobuf::uint32 collation_id() const;
  inline void set_collation_id(::google::protobuf::uint32 value);
  
  // optional string data_file_name = 5;
  inline bool has_data_file_name() const;
  inline void clear_data_file_name();
  static const int kDataFileNameFieldNumber = 5;
  inline const ::std::string& data_file_name() const;
  inline void set_data_file_name(const ::std::string& value);
  inline void set_data_file_name(const char* value);
  inline void set_data_file_name(const char* value, size_t size);
  inline ::std::string* mutable_data_file_name();
  
  // optional string index_file_name = 6;
  inline bool has_index_file_name() const;
  inline void clear_index_file_name();
  static const int kIndexFileNameFieldNumber = 6;
  inline const ::std::string& index_file_name() const;
  inline void set_index_file_name(const ::std::string& value);
  inline void set_index_file_name(const char* value);
  inline void set_index_file_name(const char* value, size_t size);
  inline ::std::string* mutable_index_file_name();
  
  // optional uint64 max_rows = 7;
  inline bool has_max_rows() const;
  inline void clear_max_rows();
  static const int kMaxRowsFieldNumber = 7;
  inline ::google::protobuf::uint64 max_rows() const;
  inline void set_max_rows(::google::protobuf::uint64 value);
  
  // optional uint64 min_rows = 8;
  inline bool has_min_rows() const;
  inline void clear_min_rows();
  static const int kMinRowsFieldNumber = 8;
  inline ::google::protobuf::uint64 min_rows() const;
  inline void set_min_rows(::google::protobuf::uint64 value);
  
  // optional uint64 auto_increment_value = 9;
  inline bool has_auto_increment_value() const;
  inline void clear_auto_increment_value();
  static const int kAutoIncrementValueFieldNumber = 9;
  inline ::google::protobuf::uint64 auto_increment_value() const;
  inline void set_auto_increment_value(::google::protobuf::uint64 value);
  
  // optional uint32 avg_row_length = 11;
  inline bool has_avg_row_length() const;
  inline void clear_avg_row_length();
  static const int kAvgRowLengthFieldNumber = 11;
  inline ::google::protobuf::uint32 avg_row_length() const;
  inline void set_avg_row_length(::google::protobuf::uint32 value);
  
  // optional uint32 block_size = 13;
  inline bool has_block_size() const;
  inline void clear_block_size();
  static const int kBlockSizeFieldNumber = 13;
  inline ::google::protobuf::uint32 block_size() const;
  inline void set_block_size(::google::protobuf::uint32 value);
  
  // optional string comment = 14;
  inline bool has_comment() const;
  inline void clear_comment();
  static const int kCommentFieldNumber = 14;
  inline const ::std::string& comment() const;
  inline void set_comment(const ::std::string& value);
  inline void set_comment(const char* value);
  inline void set_comment(const char* value, size_t size);
  inline ::std::string* mutable_comment();
  
  // optional bool pack_record = 16;
  inline bool has_pack_record() const;
  inline void clear_pack_record();
  static const int kPackRecordFieldNumber = 16;
  inline bool pack_record() const;
  inline void set_pack_record(bool value);
  
  // optional bool checksum = 17;
  inline bool has_checksum() const;
  inline void clear_checksum();
  static const int kChecksumFieldNumber = 17;
  inline bool checksum() const;
  inline void set_checksum(bool value);
  
  // optional bool page_checksum = 18;
  inline bool has_page_checksum() const;
  inline void clear_page_checksum();
  static const int kPageChecksumFieldNumber = 18;
  inline bool page_checksum() const;
  inline void set_page_checksum(bool value);
  
  // optional bool delay_key_write = 19;
  inline bool has_delay_key_write() const;
  inline void clear_delay_key_write();
  static const int kDelayKeyWriteFieldNumber = 19;
  inline bool delay_key_write() const;
  inline void set_delay_key_write(bool value);
  
  // optional .drizzled.message.Table.TableOptions.RowType row_type = 20;
  inline bool has_row_type() const;
  inline void clear_row_type();
  static const int kRowTypeFieldNumber = 20;
  inline ::drizzled::message::Table_TableOptions_RowType row_type() const;
  inline void set_row_type(::drizzled::message::Table_TableOptions_RowType value);
  
  // @@protoc_insertion_point(class_scope:drizzled.message.Table.TableOptions)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::google::protobuf::uint64 auto_increment_;
  ::std::string* collation_;
  static const ::std::string _default_collation_;
  ::google::protobuf::uint32 collation_id_;
  ::std::string* data_file_name_;
  static const ::std::string _default_data_file_name_;
  ::std::string* index_file_name_;
  static const ::std::string _default_index_file_name_;
  ::google::protobuf::uint64 max_rows_;
  ::google::protobuf::uint64 min_rows_;
  ::google::protobuf::uint64 auto_increment_value_;
  ::google::protobuf::uint32 avg_row_length_;
  ::google::protobuf::uint32 block_size_;
  ::std::string* comment_;
  static const ::std::string _default_comment_;
  bool pack_record_;
  bool checksum_;
  bool page_checksum_;
  bool delay_key_write_;
  int row_type_;
  friend void  protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(16 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Table_TableOptions* default_instance_;
};
// -------------------------------------------------------------------

class Table_ForeignKeyConstraint : public ::google::protobuf::Message {
 public:
  Table_ForeignKeyConstraint();
  virtual ~Table_ForeignKeyConstraint();
  
  Table_ForeignKeyConstraint(const Table_ForeignKeyConstraint& from);
  
  inline Table_ForeignKeyConstraint& operator=(const Table_ForeignKeyConstraint& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_ForeignKeyConstraint& default_instance();
  
  void Swap(Table_ForeignKeyConstraint* other);
  
  // implements Message ----------------------------------------------
  
  Table_ForeignKeyConstraint* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_ForeignKeyConstraint& from);
  void MergeFrom(const Table_ForeignKeyConstraint& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required string name = 1;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  
  // required .drizzled.message.Table.Field dependent = 2;
  inline bool has_dependent() const;
  inline void clear_dependent();
  static const int kDependentFieldNumber = 2;
  inline const ::drizzled::message::Table_Field& dependent() const;
  inline ::drizzled::message::Table_Field* mutable_dependent();
  
  // required .drizzled.message.Table.Field parent = 3;
  inline bool has_parent() const;
  inline void clear_parent();
  static const int kParentFieldNumber = 3;
  inline const ::drizzled::message::Table_Field& parent() const;
  inline ::drizzled::message::Table_Field* mutable_parent();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.Table.ForeignKeyConstraint)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* name_;
  static const ::std::string _default_name_;
  ::drizzled::message::Table_Field* dependent_;
  ::drizzled::message::Table_Field* parent_;
  friend void  protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Table_ForeignKeyConstraint* default_instance_;
};
// -------------------------------------------------------------------

class Table_Field_FieldOptions : public ::google::protobuf::Message {
 public:
  Table_Field_FieldOptions();
  virtual ~Table_Field_FieldOptions();
  
  Table_Field_FieldOptions(const Table_Field_FieldOptions& from);
  
  inline Table_Field_FieldOptions& operator=(const Table_Field_FieldOptions& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Field_FieldOptions& default_instance();
  
  void Swap(Table_Field_FieldOptions* other);
  
  // implements Message ----------------------------------------------
  
  Table_Field_FieldOptions* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Field_FieldOptions& from);
  void MergeFrom(const Table_Field_FieldOptions& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional string default_value = 1;
  inline bool has_default_value() const;
  inline void clear_default_value();
  static const int kDefaultValueFieldNumber = 1;
  inline const ::std::string& default_value() const;
  inline void set_default_value(const ::std::string& value);
  inline void set_default_value(const char* value);
  inline void set_default_value(const char* value, size_t size);
  inline ::std::string* mutable_default_value();
  
  // optional string update_value = 2;
  inline bool has_update_value() const;
  inline void clear_update_value();
  static const int kUpdateValueFieldNumber = 2;
  inline const ::std::string& update_value() const;
  inline void set_update_value(const ::std::string& value);
  inline void set_update_value(const char* value);
  inline void set_update_value(const char* value, size_t size);
  inline ::std::string* mutable_update_value();
  
  // optional bool default_null = 3 [default = false];
  inline bool has_default_null() const;
  inline void clear_default_null();
  static const int kDefaultNullFieldNumber = 3;
  inline bool default_null() const;
  inline void set_default_null(bool value);
  
  // optional bytes default_bin_value = 4;
  inline bool has_default_bin_value() const;
  inline void clear_default_bin_value();
  static const int kDefaultBinValueFieldNumber = 4;
  inline const ::std::string& default_bin_value() const;
  inline void set_default_bin_value(const ::std::string& value);
  inline void set_default_bin_value(const char* value);
  inline void set_default_bin_value(const void* value, size_t size);
  inline ::std::string* mutable_default_bin_value();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.FieldOptions)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* default_value_;
  static const ::std::string _default_default_value_;
  ::std::string* update_value_;
  static const ::std::string _default_update_value_;
  bool default_null_;
  ::std::string* default_bin_value_;
  static const ::std::string _default_default_bin_value_;
  friend void  protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Table_Field_FieldOptions* default_instance_;
};
// -------------------------------------------------------------------

class Table_Field_TimestampFieldOptions : public ::google::protobuf::Message {
 public:
  Table_Field_TimestampFieldOptions();
  virtual ~Table_Field_TimestampFieldOptions();
  
  Table_Field_TimestampFieldOptions(const Table_Field_TimestampFieldOptions& from);
  
  inline Table_Field_TimestampFieldOptions& operator=(const Table_Field_TimestampFieldOptions& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Field_TimestampFieldOptions& default_instance();
  
  void Swap(Table_Field_TimestampFieldOptions* other);
  
  // implements Message ----------------------------------------------
  
  Table_Field_TimestampFieldOptions* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Field_TimestampFieldOptions& from);
  void MergeFrom(const Table_Field_TimestampFieldOptions& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional bool auto_updates = 1 [default = false];
  inline bool has_auto_updates() const;
  inline void clear_auto_updates();
  static const int kAutoUpdatesFieldNumber = 1;
  inline bool auto_updates() const;
  inline void set_auto_updates(bool value);
  
  // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.TimestampFieldOptions)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  bool auto_updates_;
  friend void  protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Table_Field_TimestampFieldOptions* default_instance_;
};
// -------------------------------------------------------------------

class Table_Field_FieldConstraints : public ::google::protobuf::Message {
 public:
  Table_Field_FieldConstraints();
  virtual ~Table_Field_FieldConstraints();
  
  Table_Field_FieldConstraints(const Table_Field_FieldConstraints& from);
  
  inline Table_Field_FieldConstraints& operator=(const Table_Field_FieldConstraints& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Field_FieldConstraints& default_instance();
  
  void Swap(Table_Field_FieldConstraints* other);
  
  // implements Message ----------------------------------------------
  
  Table_Field_FieldConstraints* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Field_FieldConstraints& from);
  void MergeFrom(const Table_Field_FieldConstraints& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required bool is_nullable = 1 [default = true];
  inline bool has_is_nullable() const;
  inline void clear_is_nullable();
  static const int kIsNullableFieldNumber = 1;
  inline bool is_nullable() const;
  inline void set_is_nullable(bool value);
  
  // optional bool is_unsigned = 2 [default = false];
  inline bool has_is_unsigned() const;
  inline void clear_is_unsigned();
  static const int kIsUnsignedFieldNumber = 2;
  inline bool is_unsigned() const;
  inline void set_is_unsigned(bool value);
  
  // repeated string expression = 16;
  inline int expression_size() const;
  inline void clear_expression();
  static const int kExpressionFieldNumber = 16;
  inline const ::std::string& expression(int index) const;
  inline ::std::string* mutable_expression(int index);
  inline void set_expression(int index, const ::std::string& value);
  inline void set_expression(int index, const char* value);
  inline void set_expression(int index, const char* value, size_t size);
  inline ::std::string* add_expression();
  inline void add_expression(const ::std::string& value);
  inline void add_expression(const char* value);
  inline void add_expression(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& expression() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_expression();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.FieldConstraints)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  bool is_nullable_;
  bool is_unsigned_;
  ::google::protobuf::RepeatedPtrField< ::std::string> expression_;
  friend void  protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Table_Field_FieldConstraints* default_instance_;
};
// -------------------------------------------------------------------

class Table_Field_NumericFieldOptions : public ::google::protobuf::Message {
 public:
  Table_Field_NumericFieldOptions();
  virtual ~Table_Field_NumericFieldOptions();
  
  Table_Field_NumericFieldOptions(const Table_Field_NumericFieldOptions& from);
  
  inline Table_Field_NumericFieldOptions& operator=(const Table_Field_NumericFieldOptions& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Field_NumericFieldOptions& default_instance();
  
  void Swap(Table_Field_NumericFieldOptions* other);
  
  // implements Message ----------------------------------------------
  
  Table_Field_NumericFieldOptions* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Field_NumericFieldOptions& from);
  void MergeFrom(const Table_Field_NumericFieldOptions& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional bool is_autoincrement = 1 [default = false];
  inline bool has_is_autoincrement() const;
  inline void clear_is_autoincrement();
  static const int kIsAutoincrementFieldNumber = 1;
  inline bool is_autoincrement() const;
  inline void set_is_autoincrement(bool value);
  
  // optional uint32 scale = 2;
  inline bool has_scale() const;
  inline void clear_scale();
  static const int kScaleFieldNumber = 2;
  inline ::google::protobuf::uint32 scale() const;
  inline void set_scale(::google::protobuf::uint32 value);
  
  // optional uint32 precision = 3;
  inline bool has_precision() const;
  inline void clear_precision();
  static const int kPrecisionFieldNumber = 3;
  inline ::google::protobuf::uint32 precision() const;
  inline void set_precision(::google::protobuf::uint32 value);
  
  // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.NumericFieldOptions)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  bool is_autoincrement_;
  ::google::protobuf::uint32 scale_;
  ::google::protobuf::uint32 precision_;
  friend void  protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Table_Field_NumericFieldOptions* default_instance_;
};
// -------------------------------------------------------------------

class Table_Field_StringFieldOptions : public ::google::protobuf::Message {
 public:
  Table_Field_StringFieldOptions();
  virtual ~Table_Field_StringFieldOptions();
  
  Table_Field_StringFieldOptions(const Table_Field_StringFieldOptions& from);
  
  inline Table_Field_StringFieldOptions& operator=(const Table_Field_StringFieldOptions& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Field_StringFieldOptions& default_instance();
  
  void Swap(Table_Field_StringFieldOptions* other);
  
  // implements Message ----------------------------------------------
  
  Table_Field_StringFieldOptions* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Field_StringFieldOptions& from);
  void MergeFrom(const Table_Field_StringFieldOptions& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional bool is_fixed_width = 1 [default = false];
  inline bool has_is_fixed_width() const;
  inline void clear_is_fixed_width();
  static const int kIsFixedWidthFieldNumber = 1;
  inline bool is_fixed_width() const;
  inline void set_is_fixed_width(bool value);
  
  // optional uint32 length = 2;
  inline bool has_length() const;
  inline void clear_length();
  static const int kLengthFieldNumber = 2;
  inline ::google::protobuf::uint32 length() const;
  inline void set_length(::google::protobuf::uint32 value);
  
  // optional uint32 collation_id = 3;
  inline bool has_collation_id() const;
  inline void clear_collation_id();
  static const int kCollationIdFieldNumber = 3;
  inline ::google::protobuf::uint32 collation_id() const;
  inline void set_collation_id(::google::protobuf::uint32 value);
  
  // optional string collation = 4;
  inline bool has_collation() const;
  inline void clear_collation();
  static const int kCollationFieldNumber = 4;
  inline const ::std::string& collation() const;
  inline void set_collation(const ::std::string& value);
  inline void set_collation(const char* value);
  inline void set_collation(const char* value, size_t size);
  inline ::std::string* mutable_collation();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.StringFieldOptions)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  bool is_fixed_width_;
  ::google::protobuf::uint32 length_;
  ::google::protobuf::uint32 collation_id_;
  ::std::string* collation_;
  static const ::std::string _default_collation_;
  friend void  protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Table_Field_StringFieldOptions* default_instance_;
};
// -------------------------------------------------------------------

class Table_Field_EnumerationValues : public ::google::protobuf::Message {
 public:
  Table_Field_EnumerationValues();
  virtual ~Table_Field_EnumerationValues();
  
  Table_Field_EnumerationValues(const Table_Field_EnumerationValues& from);
  
  inline Table_Field_EnumerationValues& operator=(const Table_Field_EnumerationValues& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Field_EnumerationValues& default_instance();
  
  void Swap(Table_Field_EnumerationValues* other);
  
  // implements Message ----------------------------------------------
  
  Table_Field_EnumerationValues* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Field_EnumerationValues& from);
  void MergeFrom(const Table_Field_EnumerationValues& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional uint32 collation_id = 2;
  inline bool has_collation_id() const;
  inline void clear_collation_id();
  static const int kCollationIdFieldNumber = 2;
  inline ::google::protobuf::uint32 collation_id() const;
  inline void set_collation_id(::google::protobuf::uint32 value);
  
  // optional string collation = 3;
  inline bool has_collation() const;
  inline void clear_collation();
  static const int kCollationFieldNumber = 3;
  inline const ::std::string& collation() const;
  inline void set_collation(const ::std::string& value);
  inline void set_collation(const char* value);
  inline void set_collation(const char* value, size_t size);
  inline ::std::string* mutable_collation();
  
  // repeated string field_value = 4;
  inline int field_value_size() const;
  inline void clear_field_value();
  static const int kFieldValueFieldNumber = 4;
  inline const ::std::string& field_value(int index) const;
  inline ::std::string* mutable_field_value(int index);
  inline void set_field_value(int index, const ::std::string& value);
  inline void set_field_value(int index, const char* value);
  inline void set_field_value(int index, const char* value, size_t size);
  inline ::std::string* add_field_value();
  inline void add_field_value(const ::std::string& value);
  inline void add_field_value(const char* value);
  inline void add_field_value(const char* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& field_value() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_field_value();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.EnumerationValues)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::google::protobuf::uint32 collation_id_;
  ::std::string* collation_;
  static const ::std::string _default_collation_;
  ::google::protobuf::RepeatedPtrField< ::std::string> field_value_;
  friend void  protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Table_Field_EnumerationValues* default_instance_;
};
// -------------------------------------------------------------------

class Table_Field : public ::google::protobuf::Message {
 public:
  Table_Field();
  virtual ~Table_Field();
  
  Table_Field(const Table_Field& from);
  
  inline Table_Field& operator=(const Table_Field& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Field& default_instance();
  
  void Swap(Table_Field* other);
  
  // implements Message ----------------------------------------------
  
  Table_Field* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Field& from);
  void MergeFrom(const Table_Field& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef Table_Field_FieldOptions FieldOptions;
  typedef Table_Field_TimestampFieldOptions TimestampFieldOptions;
  typedef Table_Field_FieldConstraints FieldConstraints;
  typedef Table_Field_NumericFieldOptions NumericFieldOptions;
  typedef Table_Field_StringFieldOptions StringFieldOptions;
  typedef Table_Field_EnumerationValues EnumerationValues;
  
  typedef Table_Field_FieldType FieldType;
  static const FieldType DOUBLE = Table_Field_FieldType_DOUBLE;
  static const FieldType VARCHAR = Table_Field_FieldType_VARCHAR;
  static const FieldType BLOB = Table_Field_FieldType_BLOB;
  static const FieldType ENUM = Table_Field_FieldType_ENUM;
  static const FieldType INTEGER = Table_Field_FieldType_INTEGER;
  static const FieldType BIGINT = Table_Field_FieldType_BIGINT;
  static const FieldType DECIMAL = Table_Field_FieldType_DECIMAL;
  static const FieldType DATE = Table_Field_FieldType_DATE;
  static const FieldType TIMESTAMP = Table_Field_FieldType_TIMESTAMP;
  static const FieldType DATETIME = Table_Field_FieldType_DATETIME;
  static inline bool FieldType_IsValid(int value) {
    return Table_Field_FieldType_IsValid(value);
  }
  static const FieldType FieldType_MIN =
    Table_Field_FieldType_FieldType_MIN;
  static const FieldType FieldType_MAX =
    Table_Field_FieldType_FieldType_MAX;
  static const int FieldType_ARRAYSIZE =
    Table_Field_FieldType_FieldType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  FieldType_descriptor() {
    return Table_Field_FieldType_descriptor();
  }
  static inline const ::std::string& FieldType_Name(FieldType value) {
    return Table_Field_FieldType_Name(value);
  }
  static inline bool FieldType_Parse(const ::std::string& name,
      FieldType* value) {
    return Table_Field_FieldType_Parse(name, value);
  }
  
  // accessors -------------------------------------------------------
  
  // required string name = 1;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  
  // required .drizzled.message.Table.Field.FieldType type = 2;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 2;
  inline ::drizzled::message::Table_Field_FieldType type() const;
  inline void set_type(::drizzled::message::Table_Field_FieldType value);
  
  // optional .drizzled.message.Table.Field.FieldOptions options = 4;
  inline bool has_options() const;
  inline void clear_options();
  static const int kOptionsFieldNumber = 4;
  inline const ::drizzled::message::Table_Field_FieldOptions& options() const;
  inline ::drizzled::message::Table_Field_FieldOptions* mutable_options();
  
  // optional .drizzled.message.Table.Field.FieldConstraints constraints = 5;
  inline bool has_constraints() const;
  inline void clear_constraints();
  static const int kConstraintsFieldNumber = 5;
  inline const ::drizzled::message::Table_Field_FieldConstraints& constraints() const;
  inline ::drizzled::message::Table_Field_FieldConstraints* mutable_constraints();
  
  // optional .drizzled.message.Table.Field.NumericFieldOptions numeric_options = 6;
  inline bool has_numeric_options() const;
  inline void clear_numeric_options();
  static const int kNumericOptionsFieldNumber = 6;
  inline const ::drizzled::message::Table_Field_NumericFieldOptions& numeric_options() const;
  inline ::drizzled::message::Table_Field_NumericFieldOptions* mutable_numeric_options();
  
  // optional .drizzled.message.Table.Field.StringFieldOptions string_options = 7;
  inline bool has_string_options() const;
  inline void clear_string_options();
  static const int kStringOptionsFieldNumber = 7;
  inline const ::drizzled::message::Table_Field_StringFieldOptions& string_options() const;
  inline ::drizzled::message::Table_Field_StringFieldOptions* mutable_string_options();
  
  // optional string comment = 16;
  inline bool has_comment() const;
  inline void clear_comment();
  static const int kCommentFieldNumber = 16;
  inline const ::std::string& comment() const;
  inline void set_comment(const ::std::string& value);
  inline void set_comment(const char* value);
  inline void set_comment(const char* value, size_t size);
  inline ::std::string* mutable_comment();
  
  // optional .drizzled.message.Table.Field.EnumerationValues enumeration_values = 17;
  inline bool has_enumeration_values() const;
  inline void clear_enumeration_values();
  static const int kEnumerationValuesFieldNumber = 17;
  inline const ::drizzled::message::Table_Field_EnumerationValues& enumeration_values() const;
  inline ::drizzled::message::Table_Field_EnumerationValues* mutable_enumeration_values();
  
  // optional .drizzled.message.Table.Field.TimestampFieldOptions timestamp_options = 18;
  inline bool has_timestamp_options() const;
  inline void clear_timestamp_options();
  static const int kTimestampOptionsFieldNumber = 18;
  inline const ::drizzled::message::Table_Field_TimestampFieldOptions& timestamp_options() const;
  inline ::drizzled::message::Table_Field_TimestampFieldOptions* mutable_timestamp_options();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* name_;
  static const ::std::string _default_name_;
  int type_;
  ::drizzled::message::Table_Field_FieldOptions* options_;
  ::drizzled::message::Table_Field_FieldConstraints* constraints_;
  ::drizzled::message::Table_Field_NumericFieldOptions* numeric_options_;
  ::drizzled::message::Table_Field_StringFieldOptions* string_options_;
  ::std::string* comment_;
  static const ::std::string _default_comment_;
  ::drizzled::message::Table_Field_EnumerationValues* enumeration_values_;
  ::drizzled::message::Table_Field_TimestampFieldOptions* timestamp_options_;
  friend void  protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Table_Field* default_instance_;
};
// -------------------------------------------------------------------

class Table_Index_IndexPart : public ::google::protobuf::Message {
 public:
  Table_Index_IndexPart();
  virtual ~Table_Index_IndexPart();
  
  Table_Index_IndexPart(const Table_Index_IndexPart& from);
  
  inline Table_Index_IndexPart& operator=(const Table_Index_IndexPart& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Index_IndexPart& default_instance();
  
  void Swap(Table_Index_IndexPart* other);
  
  // implements Message ----------------------------------------------
  
  Table_Index_IndexPart* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Index_IndexPart& from);
  void MergeFrom(const Table_Index_IndexPart& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required uint32 fieldnr = 1;
  inline bool has_fieldnr() const;
  inline void clear_fieldnr();
  static const int kFieldnrFieldNumber = 1;
  inline ::google::protobuf::uint32 fieldnr() const;
  inline void set_fieldnr(::google::protobuf::uint32 value);
  
  // optional uint32 compare_length = 2;
  inline bool has_compare_length() const;
  inline void clear_compare_length();
  static const int kCompareLengthFieldNumber = 2;
  inline ::google::protobuf::uint32 compare_length() const;
  inline void set_compare_length(::google::protobuf::uint32 value);
  
  // optional bool in_reverse_order = 3 [default = false];
  inline bool has_in_reverse_order() const;
  inline void clear_in_reverse_order();
  static const int kInReverseOrderFieldNumber = 3;
  inline bool in_reverse_order() const;
  inline void set_in_reverse_order(bool value);
  
  // optional uint32 key_type = 101;
  inline bool has_key_type() const;
  inline void clear_key_type();
  static const int kKeyTypeFieldNumber = 101;
  inline ::google::protobuf::uint32 key_type() const;
  inline void set_key_type(::google::protobuf::uint32 value);
  
  // @@protoc_insertion_point(class_scope:drizzled.message.Table.Index.IndexPart)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::google::protobuf::uint32 fieldnr_;
  ::google::protobuf::uint32 compare_length_;
  bool in_reverse_order_;
  ::google::protobuf::uint32 key_type_;
  friend void  protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Table_Index_IndexPart* default_instance_;
};
// -------------------------------------------------------------------

class Table_Index_Options : public ::google::protobuf::Message {
 public:
  Table_Index_Options();
  virtual ~Table_Index_Options();
  
  Table_Index_Options(const Table_Index_Options& from);
  
  inline Table_Index_Options& operator=(const Table_Index_Options& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Index_Options& default_instance();
  
  void Swap(Table_Index_Options* other);
  
  // implements Message ----------------------------------------------
  
  Table_Index_Options* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Index_Options& from);
  void MergeFrom(const Table_Index_Options& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // optional bool pack_key = 1;
  inline bool has_pack_key() const;
  inline void clear_pack_key();
  static const int kPackKeyFieldNumber = 1;
  inline bool pack_key() const;
  inline void set_pack_key(bool value);
  
  // optional bool binary_pack_key = 2;
  inline bool has_binary_pack_key() const;
  inline void clear_binary_pack_key();
  static const int kBinaryPackKeyFieldNumber = 2;
  inline bool binary_pack_key() const;
  inline void set_binary_pack_key(bool value);
  
  // optional bool var_length_key = 3;
  inline bool has_var_length_key() const;
  inline void clear_var_length_key();
  static const int kVarLengthKeyFieldNumber = 3;
  inline bool var_length_key() const;
  inline void set_var_length_key(bool value);
  
  // optional bool null_part_key = 4;
  inline bool has_null_part_key() const;
  inline void clear_null_part_key();
  static const int kNullPartKeyFieldNumber = 4;
  inline bool null_part_key() const;
  inline void set_null_part_key(bool value);
  
  // optional uint32 key_block_size = 5;
  inline bool has_key_block_size() const;
  inline void clear_key_block_size();
  static const int kKeyBlockSizeFieldNumber = 5;
  inline ::google::protobuf::uint32 key_block_size() const;
  inline void set_key_block_size(::google::protobuf::uint32 value);
  
  // optional bool has_partial_segments = 6;
  inline bool has_has_partial_segments() const;
  inline void clear_has_partial_segments();
  static const int kHasPartialSegmentsFieldNumber = 6;
  inline bool has_partial_segments() const;
  inline void set_has_partial_segments(bool value);
  
  // optional bool auto_generated_key = 7;
  inline bool has_auto_generated_key() const;
  inline void clear_auto_generated_key();
  static const int kAutoGeneratedKeyFieldNumber = 7;
  inline bool auto_generated_key() const;
  inline void set_auto_generated_key(bool value);
  
  // @@protoc_insertion_point(class_scope:drizzled.message.Table.Index.Options)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  bool pack_key_;
  bool binary_pack_key_;
  bool var_length_key_;
  bool null_part_key_;
  ::google::protobuf::uint32 key_block_size_;
  bool has_partial_segments_;
  bool auto_generated_key_;
  friend void  protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Table_Index_Options* default_instance_;
};
// -------------------------------------------------------------------

class Table_Index : public ::google::protobuf::Message {
 public:
  Table_Index();
  virtual ~Table_Index();
  
  Table_Index(const Table_Index& from);
  
  inline Table_Index& operator=(const Table_Index& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Table_Index& default_instance();
  
  void Swap(Table_Index* other);
  
  // implements Message ----------------------------------------------
  
  Table_Index* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table_Index& from);
  void MergeFrom(const Table_Index& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef Table_Index_IndexPart IndexPart;
  typedef Table_Index_Options Options;
  
  typedef Table_Index_IndexType IndexType;
  static const IndexType UNKNOWN_INDEX = Table_Index_IndexType_UNKNOWN_INDEX;
  static const IndexType BTREE = Table_Index_IndexType_BTREE;
  static const IndexType RTREE = Table_Index_IndexType_RTREE;
  static const IndexType HASH = Table_Index_IndexType_HASH;
  static const IndexType FULLTEXT = Table_Index_IndexType_FULLTEXT;
  static inline bool IndexType_IsValid(int value) {
    return Table_Index_IndexType_IsValid(value);
  }
  static const IndexType IndexType_MIN =
    Table_Index_IndexType_IndexType_MIN;
  static const IndexType IndexType_MAX =
    Table_Index_IndexType_IndexType_MAX;
  static const int IndexType_ARRAYSIZE =
    Table_Index_IndexType_IndexType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  IndexType_descriptor() {
    return Table_Index_IndexType_descriptor();
  }
  static inline const ::std::string& IndexType_Name(IndexType value) {
    return Table_Index_IndexType_Name(value);
  }
  static inline bool IndexType_Parse(const ::std::string& name,
      IndexType* value) {
    return Table_Index_IndexType_Parse(name, value);
  }
  
  // accessors -------------------------------------------------------
  
  // required string name = 1;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  
  // required bool is_primary = 2;
  inline bool has_is_primary() const;
  inline void clear_is_primary();
  static const int kIsPrimaryFieldNumber = 2;
  inline bool is_primary() const;
  inline void set_is_primary(bool value);
  
  // required bool is_unique = 3;
  inline bool has_is_unique() const;
  inline void clear_is_unique();
  static const int kIsUniqueFieldNumber = 3;
  inline bool is_unique() const;
  inline void set_is_unique(bool value);
  
  // required .drizzled.message.Table.Index.IndexType type = 4 [default = UNKNOWN_INDEX];
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 4;
  inline ::drizzled::message::Table_Index_IndexType type() const;
  inline void set_type(::drizzled::message::Table_Index_IndexType value);
  
  // required uint32 key_length = 5;
  inline bool has_key_length() const;
  inline void clear_key_length();
  static const int kKeyLengthFieldNumber = 5;
  inline ::google::protobuf::uint32 key_length() const;
  inline void set_key_length(::google::protobuf::uint32 value);
  
  // repeated .drizzled.message.Table.Index.IndexPart index_part = 6;
  inline int index_part_size() const;
  inline void clear_index_part();
  static const int kIndexPartFieldNumber = 6;
  inline const ::drizzled::message::Table_Index_IndexPart& index_part(int index) const;
  inline ::drizzled::message::Table_Index_IndexPart* mutable_index_part(int index);
  inline ::drizzled::message::Table_Index_IndexPart* add_index_part();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart >&
      index_part() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart >*
      mutable_index_part();
  
  // optional .drizzled.message.Table.Index.Options options = 7;
  inline bool has_options() const;
  inline void clear_options();
  static const int kOptionsFieldNumber = 7;
  inline const ::drizzled::message::Table_Index_Options& options() const;
  inline ::drizzled::message::Table_Index_Options* mutable_options();
  
  // optional string comment = 8;
  inline bool has_comment() const;
  inline void clear_comment();
  static const int kCommentFieldNumber = 8;
  inline const ::std::string& comment() const;
  inline void set_comment(const ::std::string& value);
  inline void set_comment(const char* value);
  inline void set_comment(const char* value, size_t size);
  inline ::std::string* mutable_comment();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.Table.Index)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* name_;
  static const ::std::string _default_name_;
  bool is_primary_;
  bool is_unique_;
  int type_;
  ::google::protobuf::uint32 key_length_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart > index_part_;
  ::drizzled::message::Table_Index_Options* options_;
  ::std::string* comment_;
  static const ::std::string _default_comment_;
  friend void  protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Table_Index* default_instance_;
};
// -------------------------------------------------------------------

class Table : public ::google::protobuf::Message {
 public:
  Table();
  virtual ~Table();
  
  Table(const Table& from);
  
  inline Table& operator=(const Table& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Table& default_instance();
  
  void Swap(Table* other);
  
  // implements Message ----------------------------------------------
  
  Table* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Table& from);
  void MergeFrom(const Table& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef Table_TableOptions TableOptions;
  typedef Table_ForeignKeyConstraint ForeignKeyConstraint;
  typedef Table_Field Field;
  typedef Table_Index Index;
  
  typedef Table_TableType TableType;
  static const TableType STANDARD = Table_TableType_STANDARD;
  static const TableType TEMPORARY = Table_TableType_TEMPORARY;
  static const TableType INTERNAL = Table_TableType_INTERNAL;
  static const TableType FUNCTION = Table_TableType_FUNCTION;
  static inline bool TableType_IsValid(int value) {
    return Table_TableType_IsValid(value);
  }
  static const TableType TableType_MIN =
    Table_TableType_TableType_MIN;
  static const TableType TableType_MAX =
    Table_TableType_TableType_MAX;
  static const int TableType_ARRAYSIZE =
    Table_TableType_TableType_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  TableType_descriptor() {
    return Table_TableType_descriptor();
  }
  static inline const ::std::string& TableType_Name(TableType value) {
    return Table_TableType_Name(value);
  }
  static inline bool TableType_Parse(const ::std::string& name,
      TableType* value) {
    return Table_TableType_Parse(name, value);
  }
  
  // accessors -------------------------------------------------------
  
  // required string name = 1;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 1;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  
  // required string schema = 6;
  inline bool has_schema() const;
  inline void clear_schema();
  static const int kSchemaFieldNumber = 6;
  inline const ::std::string& schema() const;
  inline void set_schema(const ::std::string& value);
  inline void set_schema(const char* value);
  inline void set_schema(const char* value, size_t size);
  inline ::std::string* mutable_schema();
  
  // required .drizzled.message.Table.TableType type = 5;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 5;
  inline ::drizzled::message::Table_TableType type() const;
  inline void set_type(::drizzled::message::Table_TableType value);
  
  // required .drizzled.message.Engine engine = 2;
  inline bool has_engine() const;
  inline void clear_engine();
  static const int kEngineFieldNumber = 2;
  inline const ::drizzled::message::Engine& engine() const;
  inline ::drizzled::message::Engine* mutable_engine();
  
  // repeated .drizzled.message.Table.Field field = 3;
  inline int field_size() const;
  inline void clear_field();
  static const int kFieldFieldNumber = 3;
  inline const ::drizzled::message::Table_Field& field(int index) const;
  inline ::drizzled::message::Table_Field* mutable_field(int index);
  inline ::drizzled::message::Table_Field* add_field();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >&
      field() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >*
      mutable_field();
  
  // repeated .drizzled.message.Table.Index indexes = 4;
  inline int indexes_size() const;
  inline void clear_indexes();
  static const int kIndexesFieldNumber = 4;
  inline const ::drizzled::message::Table_Index& indexes(int index) const;
  inline ::drizzled::message::Table_Index* mutable_indexes(int index);
  inline ::drizzled::message::Table_Index* add_indexes();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index >&
      indexes() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index >*
      mutable_indexes();
  
  // repeated .drizzled.message.Table.ForeignKeyConstraint fk_constraint = 8;
  inline int fk_constraint_size() const;
  inline void clear_fk_constraint();
  static const int kFkConstraintFieldNumber = 8;
  inline const ::drizzled::message::Table_ForeignKeyConstraint& fk_constraint(int index) const;
  inline ::drizzled::message::Table_ForeignKeyConstraint* mutable_fk_constraint(int index);
  inline ::drizzled::message::Table_ForeignKeyConstraint* add_fk_constraint();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint >&
      fk_constraint() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint >*
      mutable_fk_constraint();
  
  // optional .drizzled.message.Table.TableOptions options = 9;
  inline bool has_options() const;
  inline void clear_options();
  static const int kOptionsFieldNumber = 9;
  inline const ::drizzled::message::Table_TableOptions& options() const;
  inline ::drizzled::message::Table_TableOptions* mutable_options();
  
  // required uint64 creation_timestamp = 11 [default = 0];
  inline bool has_creation_timestamp() const;
  inline void clear_creation_timestamp();
  static const int kCreationTimestampFieldNumber = 11;
  inline ::google::protobuf::uint64 creation_timestamp() const;
  inline void set_creation_timestamp(::google::protobuf::uint64 value);
  
  // required uint64 update_timestamp = 12 [default = 0];
  inline bool has_update_timestamp() const;
  inline void clear_update_timestamp();
  static const int kUpdateTimestampFieldNumber = 12;
  inline ::google::protobuf::uint64 update_timestamp() const;
  inline void set_update_timestamp(::google::protobuf::uint64 value);
  
  // optional string catalog = 13;
  inline bool has_catalog() const;
  inline void clear_catalog();
  static const int kCatalogFieldNumber = 13;
  inline const ::std::string& catalog() const;
  inline void set_catalog(const ::std::string& value);
  inline void set_catalog(const char* value);
  inline void set_catalog(const char* value, size_t size);
  inline ::std::string* mutable_catalog();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.Table)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* name_;
  static const ::std::string _default_name_;
  ::std::string* schema_;
  static const ::std::string _default_schema_;
  int type_;
  ::drizzled::message::Engine* engine_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field > field_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index > indexes_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint > fk_constraint_;
  ::drizzled::message::Table_TableOptions* options_;
  ::google::protobuf::uint64 creation_timestamp_;
  ::google::protobuf::uint64 update_timestamp_;
  ::std::string* catalog_;
  static const ::std::string _default_catalog_;
  friend void  protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(11 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Table* default_instance_;
};
// -------------------------------------------------------------------

class AlterTable : public ::google::protobuf::Message {
 public:
  AlterTable();
  virtual ~AlterTable();
  
  AlterTable(const AlterTable& from);
  
  inline AlterTable& operator=(const AlterTable& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const AlterTable& default_instance();
  
  void Swap(AlterTable* other);
  
  // implements Message ----------------------------------------------
  
  AlterTable* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const AlterTable& from);
  void MergeFrom(const AlterTable& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated .drizzled.message.Table.Field added_field = 1;
  inline int added_field_size() const;
  inline void clear_added_field();
  static const int kAddedFieldFieldNumber = 1;
  inline const ::drizzled::message::Table_Field& added_field(int index) const;
  inline ::drizzled::message::Table_Field* mutable_added_field(int index);
  inline ::drizzled::message::Table_Field* add_added_field();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >&
      added_field() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >*
      mutable_added_field();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.AlterTable)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field > added_field_;
  friend void  protobuf_AddDesc_table_2eproto();
  friend void protobuf_AssignDesc_table_2eproto();
  friend void protobuf_ShutdownFile_table_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static AlterTable* default_instance_;
};
// ===================================================================


// ===================================================================

// Table_TableOptions

// optional uint64 auto_increment = 1;
inline bool Table_TableOptions::has_auto_increment() const {
  return _has_bit(0);
}
inline void Table_TableOptions::clear_auto_increment() {
  auto_increment_ = GOOGLE_ULONGLONG(0);
  _clear_bit(0);
}
inline ::google::protobuf::uint64 Table_TableOptions::auto_increment() const {
  return auto_increment_;
}
inline void Table_TableOptions::set_auto_increment(::google::protobuf::uint64 value) {
  _set_bit(0);
  auto_increment_ = value;
}

// optional string collation = 2;
inline bool Table_TableOptions::has_collation() const {
  return _has_bit(1);
}
inline void Table_TableOptions::clear_collation() {
  if (collation_ != &_default_collation_) {
    collation_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& Table_TableOptions::collation() const {
  return *collation_;
}
inline void Table_TableOptions::set_collation(const ::std::string& value) {
  _set_bit(1);
  if (collation_ == &_default_collation_) {
    collation_ = new ::std::string;
  }
  collation_->assign(value);
}
inline void Table_TableOptions::set_collation(const char* value) {
  _set_bit(1);
  if (collation_ == &_default_collation_) {
    collation_ = new ::std::string;
  }
  collation_->assign(value);
}
inline void Table_TableOptions::set_collation(const char* value, size_t size) {
  _set_bit(1);
  if (collation_ == &_default_collation_) {
    collation_ = new ::std::string;
  }
  collation_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_TableOptions::mutable_collation() {
  _set_bit(1);
  if (collation_ == &_default_collation_) {
    collation_ = new ::std::string;
  }
  return collation_;
}

// optional uint32 collation_id = 3;
inline bool Table_TableOptions::has_collation_id() const {
  return _has_bit(2);
}
inline void Table_TableOptions::clear_collation_id() {
  collation_id_ = 0u;
  _clear_bit(2);
}
inline ::google::protobuf::uint32 Table_TableOptions::collation_id() const {
  return collation_id_;
}
inline void Table_TableOptions::set_collation_id(::google::protobuf::uint32 value) {
  _set_bit(2);
  collation_id_ = value;
}

// optional string data_file_name = 5;
inline bool Table_TableOptions::has_data_file_name() const {
  return _has_bit(3);
}
inline void Table_TableOptions::clear_data_file_name() {
  if (data_file_name_ != &_default_data_file_name_) {
    data_file_name_->clear();
  }
  _clear_bit(3);
}
inline const ::std::string& Table_TableOptions::data_file_name() const {
  return *data_file_name_;
}
inline void Table_TableOptions::set_data_file_name(const ::std::string& value) {
  _set_bit(3);
  if (data_file_name_ == &_default_data_file_name_) {
    data_file_name_ = new ::std::string;
  }
  data_file_name_->assign(value);
}
inline void Table_TableOptions::set_data_file_name(const char* value) {
  _set_bit(3);
  if (data_file_name_ == &_default_data_file_name_) {
    data_file_name_ = new ::std::string;
  }
  data_file_name_->assign(value);
}
inline void Table_TableOptions::set_data_file_name(const char* value, size_t size) {
  _set_bit(3);
  if (data_file_name_ == &_default_data_file_name_) {
    data_file_name_ = new ::std::string;
  }
  data_file_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_TableOptions::mutable_data_file_name() {
  _set_bit(3);
  if (data_file_name_ == &_default_data_file_name_) {
    data_file_name_ = new ::std::string;
  }
  return data_file_name_;
}

// optional string index_file_name = 6;
inline bool Table_TableOptions::has_index_file_name() const {
  return _has_bit(4);
}
inline void Table_TableOptions::clear_index_file_name() {
  if (index_file_name_ != &_default_index_file_name_) {
    index_file_name_->clear();
  }
  _clear_bit(4);
}
inline const ::std::string& Table_TableOptions::index_file_name() const {
  return *index_file_name_;
}
inline void Table_TableOptions::set_index_file_name(const ::std::string& value) {
  _set_bit(4);
  if (index_file_name_ == &_default_index_file_name_) {
    index_file_name_ = new ::std::string;
  }
  index_file_name_->assign(value);
}
inline void Table_TableOptions::set_index_file_name(const char* value) {
  _set_bit(4);
  if (index_file_name_ == &_default_index_file_name_) {
    index_file_name_ = new ::std::string;
  }
  index_file_name_->assign(value);
}
inline void Table_TableOptions::set_index_file_name(const char* value, size_t size) {
  _set_bit(4);
  if (index_file_name_ == &_default_index_file_name_) {
    index_file_name_ = new ::std::string;
  }
  index_file_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_TableOptions::mutable_index_file_name() {
  _set_bit(4);
  if (index_file_name_ == &_default_index_file_name_) {
    index_file_name_ = new ::std::string;
  }
  return index_file_name_;
}

// optional uint64 max_rows = 7;
inline bool Table_TableOptions::has_max_rows() const {
  return _has_bit(5);
}
inline void Table_TableOptions::clear_max_rows() {
  max_rows_ = GOOGLE_ULONGLONG(0);
  _clear_bit(5);
}
inline ::google::protobuf::uint64 Table_TableOptions::max_rows() const {
  return max_rows_;
}
inline void Table_TableOptions::set_max_rows(::google::protobuf::uint64 value) {
  _set_bit(5);
  max_rows_ = value;
}

// optional uint64 min_rows = 8;
inline bool Table_TableOptions::has_min_rows() const {
  return _has_bit(6);
}
inline void Table_TableOptions::clear_min_rows() {
  min_rows_ = GOOGLE_ULONGLONG(0);
  _clear_bit(6);
}
inline ::google::protobuf::uint64 Table_TableOptions::min_rows() const {
  return min_rows_;
}
inline void Table_TableOptions::set_min_rows(::google::protobuf::uint64 value) {
  _set_bit(6);
  min_rows_ = value;
}

// optional uint64 auto_increment_value = 9;
inline bool Table_TableOptions::has_auto_increment_value() const {
  return _has_bit(7);
}
inline void Table_TableOptions::clear_auto_increment_value() {
  auto_increment_value_ = GOOGLE_ULONGLONG(0);
  _clear_bit(7);
}
inline ::google::protobuf::uint64 Table_TableOptions::auto_increment_value() const {
  return auto_increment_value_;
}
inline void Table_TableOptions::set_auto_increment_value(::google::protobuf::uint64 value) {
  _set_bit(7);
  auto_increment_value_ = value;
}

// optional uint32 avg_row_length = 11;
inline bool Table_TableOptions::has_avg_row_length() const {
  return _has_bit(8);
}
inline void Table_TableOptions::clear_avg_row_length() {
  avg_row_length_ = 0u;
  _clear_bit(8);
}
inline ::google::protobuf::uint32 Table_TableOptions::avg_row_length() const {
  return avg_row_length_;
}
inline void Table_TableOptions::set_avg_row_length(::google::protobuf::uint32 value) {
  _set_bit(8);
  avg_row_length_ = value;
}

// optional uint32 block_size = 13;
inline bool Table_TableOptions::has_block_size() const {
  return _has_bit(9);
}
inline void Table_TableOptions::clear_block_size() {
  block_size_ = 0u;
  _clear_bit(9);
}
inline ::google::protobuf::uint32 Table_TableOptions::block_size() const {
  return block_size_;
}
inline void Table_TableOptions::set_block_size(::google::protobuf::uint32 value) {
  _set_bit(9);
  block_size_ = value;
}

// optional string comment = 14;
inline bool Table_TableOptions::has_comment() const {
  return _has_bit(10);
}
inline void Table_TableOptions::clear_comment() {
  if (comment_ != &_default_comment_) {
    comment_->clear();
  }
  _clear_bit(10);
}
inline const ::std::string& Table_TableOptions::comment() const {
  return *comment_;
}
inline void Table_TableOptions::set_comment(const ::std::string& value) {
  _set_bit(10);
  if (comment_ == &_default_comment_) {
    comment_ = new ::std::string;
  }
  comment_->assign(value);
}
inline void Table_TableOptions::set_comment(const char* value) {
  _set_bit(10);
  if (comment_ == &_default_comment_) {
    comment_ = new ::std::string;
  }
  comment_->assign(value);
}
inline void Table_TableOptions::set_comment(const char* value, size_t size) {
  _set_bit(10);
  if (comment_ == &_default_comment_) {
    comment_ = new ::std::string;
  }
  comment_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_TableOptions::mutable_comment() {
  _set_bit(10);
  if (comment_ == &_default_comment_) {
    comment_ = new ::std::string;
  }
  return comment_;
}

// optional bool pack_record = 16;
inline bool Table_TableOptions::has_pack_record() const {
  return _has_bit(11);
}
inline void Table_TableOptions::clear_pack_record() {
  pack_record_ = false;
  _clear_bit(11);
}
inline bool Table_TableOptions::pack_record() const {
  return pack_record_;
}
inline void Table_TableOptions::set_pack_record(bool value) {
  _set_bit(11);
  pack_record_ = value;
}

// optional bool checksum = 17;
inline bool Table_TableOptions::has_checksum() const {
  return _has_bit(12);
}
inline void Table_TableOptions::clear_checksum() {
  checksum_ = false;
  _clear_bit(12);
}
inline bool Table_TableOptions::checksum() const {
  return checksum_;
}
inline void Table_TableOptions::set_checksum(bool value) {
  _set_bit(12);
  checksum_ = value;
}

// optional bool page_checksum = 18;
inline bool Table_TableOptions::has_page_checksum() const {
  return _has_bit(13);
}
inline void Table_TableOptions::clear_page_checksum() {
  page_checksum_ = false;
  _clear_bit(13);
}
inline bool Table_TableOptions::page_checksum() const {
  return page_checksum_;
}
inline void Table_TableOptions::set_page_checksum(bool value) {
  _set_bit(13);
  page_checksum_ = value;
}

// optional bool delay_key_write = 19;
inline bool Table_TableOptions::has_delay_key_write() const {
  return _has_bit(14);
}
inline void Table_TableOptions::clear_delay_key_write() {
  delay_key_write_ = false;
  _clear_bit(14);
}
inline bool Table_TableOptions::delay_key_write() const {
  return delay_key_write_;
}
inline void Table_TableOptions::set_delay_key_write(bool value) {
  _set_bit(14);
  delay_key_write_ = value;
}

// optional .drizzled.message.Table.TableOptions.RowType row_type = 20;
inline bool Table_TableOptions::has_row_type() const {
  return _has_bit(15);
}
inline void Table_TableOptions::clear_row_type() {
  row_type_ = 0;
  _clear_bit(15);
}
inline ::drizzled::message::Table_TableOptions_RowType Table_TableOptions::row_type() const {
  return static_cast< ::drizzled::message::Table_TableOptions_RowType >(row_type_);
}
inline void Table_TableOptions::set_row_type(::drizzled::message::Table_TableOptions_RowType value) {
  GOOGLE_DCHECK(::drizzled::message::Table_TableOptions_RowType_IsValid(value));
  _set_bit(15);
  row_type_ = value;
}

// -------------------------------------------------------------------

// Table_ForeignKeyConstraint

// required string name = 1;
inline bool Table_ForeignKeyConstraint::has_name() const {
  return _has_bit(0);
}
inline void Table_ForeignKeyConstraint::clear_name() {
  if (name_ != &_default_name_) {
    name_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& Table_ForeignKeyConstraint::name() const {
  return *name_;
}
inline void Table_ForeignKeyConstraint::set_name(const ::std::string& value) {
  _set_bit(0);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Table_ForeignKeyConstraint::set_name(const char* value) {
  _set_bit(0);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Table_ForeignKeyConstraint::set_name(const char* value, size_t size) {
  _set_bit(0);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_ForeignKeyConstraint::mutable_name() {
  _set_bit(0);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  return name_;
}

// required .drizzled.message.Table.Field dependent = 2;
inline bool Table_ForeignKeyConstraint::has_dependent() const {
  return _has_bit(1);
}
inline void Table_ForeignKeyConstraint::clear_dependent() {
  if (dependent_ != NULL) dependent_->::drizzled::message::Table_Field::Clear();
  _clear_bit(1);
}
inline const ::drizzled::message::Table_Field& Table_ForeignKeyConstraint::dependent() const {
  return dependent_ != NULL ? *dependent_ : *default_instance_->dependent_;
}
inline ::drizzled::message::Table_Field* Table_ForeignKeyConstraint::mutable_dependent() {
  _set_bit(1);
  if (dependent_ == NULL) dependent_ = new ::drizzled::message::Table_Field;
  return dependent_;
}

// required .drizzled.message.Table.Field parent = 3;
inline bool Table_ForeignKeyConstraint::has_parent() const {
  return _has_bit(2);
}
inline void Table_ForeignKeyConstraint::clear_parent() {
  if (parent_ != NULL) parent_->::drizzled::message::Table_Field::Clear();
  _clear_bit(2);
}
inline const ::drizzled::message::Table_Field& Table_ForeignKeyConstraint::parent() const {
  return parent_ != NULL ? *parent_ : *default_instance_->parent_;
}
inline ::drizzled::message::Table_Field* Table_ForeignKeyConstraint::mutable_parent() {
  _set_bit(2);
  if (parent_ == NULL) parent_ = new ::drizzled::message::Table_Field;
  return parent_;
}

// -------------------------------------------------------------------

// Table_Field_FieldOptions

// optional string default_value = 1;
inline bool Table_Field_FieldOptions::has_default_value() const {
  return _has_bit(0);
}
inline void Table_Field_FieldOptions::clear_default_value() {
  if (default_value_ != &_default_default_value_) {
    default_value_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& Table_Field_FieldOptions::default_value() const {
  return *default_value_;
}
inline void Table_Field_FieldOptions::set_default_value(const ::std::string& value) {
  _set_bit(0);
  if (default_value_ == &_default_default_value_) {
    default_value_ = new ::std::string;
  }
  default_value_->assign(value);
}
inline void Table_Field_FieldOptions::set_default_value(const char* value) {
  _set_bit(0);
  if (default_value_ == &_default_default_value_) {
    default_value_ = new ::std::string;
  }
  default_value_->assign(value);
}
inline void Table_Field_FieldOptions::set_default_value(const char* value, size_t size) {
  _set_bit(0);
  if (default_value_ == &_default_default_value_) {
    default_value_ = new ::std::string;
  }
  default_value_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field_FieldOptions::mutable_default_value() {
  _set_bit(0);
  if (default_value_ == &_default_default_value_) {
    default_value_ = new ::std::string;
  }
  return default_value_;
}

// optional string update_value = 2;
inline bool Table_Field_FieldOptions::has_update_value() const {
  return _has_bit(1);
}
inline void Table_Field_FieldOptions::clear_update_value() {
  if (update_value_ != &_default_update_value_) {
    update_value_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& Table_Field_FieldOptions::update_value() const {
  return *update_value_;
}
inline void Table_Field_FieldOptions::set_update_value(const ::std::string& value) {
  _set_bit(1);
  if (update_value_ == &_default_update_value_) {
    update_value_ = new ::std::string;
  }
  update_value_->assign(value);
}
inline void Table_Field_FieldOptions::set_update_value(const char* value) {
  _set_bit(1);
  if (update_value_ == &_default_update_value_) {
    update_value_ = new ::std::string;
  }
  update_value_->assign(value);
}
inline void Table_Field_FieldOptions::set_update_value(const char* value, size_t size) {
  _set_bit(1);
  if (update_value_ == &_default_update_value_) {
    update_value_ = new ::std::string;
  }
  update_value_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field_FieldOptions::mutable_update_value() {
  _set_bit(1);
  if (update_value_ == &_default_update_value_) {
    update_value_ = new ::std::string;
  }
  return update_value_;
}

// optional bool default_null = 3 [default = false];
inline bool Table_Field_FieldOptions::has_default_null() const {
  return _has_bit(2);
}
inline void Table_Field_FieldOptions::clear_default_null() {
  default_null_ = false;
  _clear_bit(2);
}
inline bool Table_Field_FieldOptions::default_null() const {
  return default_null_;
}
inline void Table_Field_FieldOptions::set_default_null(bool value) {
  _set_bit(2);
  default_null_ = value;
}

// optional bytes default_bin_value = 4;
inline bool Table_Field_FieldOptions::has_default_bin_value() const {
  return _has_bit(3);
}
inline void Table_Field_FieldOptions::clear_default_bin_value() {
  if (default_bin_value_ != &_default_default_bin_value_) {
    default_bin_value_->clear();
  }
  _clear_bit(3);
}
inline const ::std::string& Table_Field_FieldOptions::default_bin_value() const {
  return *default_bin_value_;
}
inline void Table_Field_FieldOptions::set_default_bin_value(const ::std::string& value) {
  _set_bit(3);
  if (default_bin_value_ == &_default_default_bin_value_) {
    default_bin_value_ = new ::std::string;
  }
  default_bin_value_->assign(value);
}
inline void Table_Field_FieldOptions::set_default_bin_value(const char* value) {
  _set_bit(3);
  if (default_bin_value_ == &_default_default_bin_value_) {
    default_bin_value_ = new ::std::string;
  }
  default_bin_value_->assign(value);
}
inline void Table_Field_FieldOptions::set_default_bin_value(const void* value, size_t size) {
  _set_bit(3);
  if (default_bin_value_ == &_default_default_bin_value_) {
    default_bin_value_ = new ::std::string;
  }
  default_bin_value_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field_FieldOptions::mutable_default_bin_value() {
  _set_bit(3);
  if (default_bin_value_ == &_default_default_bin_value_) {
    default_bin_value_ = new ::std::string;
  }
  return default_bin_value_;
}

// -------------------------------------------------------------------

// Table_Field_TimestampFieldOptions

// optional bool auto_updates = 1 [default = false];
inline bool Table_Field_TimestampFieldOptions::has_auto_updates() const {
  return _has_bit(0);
}
inline void Table_Field_TimestampFieldOptions::clear_auto_updates() {
  auto_updates_ = false;
  _clear_bit(0);
}
inline bool Table_Field_TimestampFieldOptions::auto_updates() const {
  return auto_updates_;
}
inline void Table_Field_TimestampFieldOptions::set_auto_updates(bool value) {
  _set_bit(0);
  auto_updates_ = value;
}

// -------------------------------------------------------------------

// Table_Field_FieldConstraints

// required bool is_nullable = 1 [default = true];
inline bool Table_Field_FieldConstraints::has_is_nullable() const {
  return _has_bit(0);
}
inline void Table_Field_FieldConstraints::clear_is_nullable() {
  is_nullable_ = true;
  _clear_bit(0);
}
inline bool Table_Field_FieldConstraints::is_nullable() const {
  return is_nullable_;
}
inline void Table_Field_FieldConstraints::set_is_nullable(bool value) {
  _set_bit(0);
  is_nullable_ = value;
}

// optional bool is_unsigned = 2 [default = false];
inline bool Table_Field_FieldConstraints::has_is_unsigned() const {
  return _has_bit(1);
}
inline void Table_Field_FieldConstraints::clear_is_unsigned() {
  is_unsigned_ = false;
  _clear_bit(1);
}
inline bool Table_Field_FieldConstraints::is_unsigned() const {
  return is_unsigned_;
}
inline void Table_Field_FieldConstraints::set_is_unsigned(bool value) {
  _set_bit(1);
  is_unsigned_ = value;
}

// repeated string expression = 16;
inline int Table_Field_FieldConstraints::expression_size() const {
  return expression_.size();
}
inline void Table_Field_FieldConstraints::clear_expression() {
  expression_.Clear();
}
inline const ::std::string& Table_Field_FieldConstraints::expression(int index) const {
  return expression_.Get(index);
}
inline ::std::string* Table_Field_FieldConstraints::mutable_expression(int index) {
  return expression_.Mutable(index);
}
inline void Table_Field_FieldConstraints::set_expression(int index, const ::std::string& value) {
  expression_.Mutable(index)->assign(value);
}
inline void Table_Field_FieldConstraints::set_expression(int index, const char* value) {
  expression_.Mutable(index)->assign(value);
}
inline void Table_Field_FieldConstraints::set_expression(int index, const char* value, size_t size) {
  expression_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field_FieldConstraints::add_expression() {
  return expression_.Add();
}
inline void Table_Field_FieldConstraints::add_expression(const ::std::string& value) {
  expression_.Add()->assign(value);
}
inline void Table_Field_FieldConstraints::add_expression(const char* value) {
  expression_.Add()->assign(value);
}
inline void Table_Field_FieldConstraints::add_expression(const char* value, size_t size) {
  expression_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
Table_Field_FieldConstraints::expression() const {
  return expression_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
Table_Field_FieldConstraints::mutable_expression() {
  return &expression_;
}

// -------------------------------------------------------------------

// Table_Field_NumericFieldOptions

// optional bool is_autoincrement = 1 [default = false];
inline bool Table_Field_NumericFieldOptions::has_is_autoincrement() const {
  return _has_bit(0);
}
inline void Table_Field_NumericFieldOptions::clear_is_autoincrement() {
  is_autoincrement_ = false;
  _clear_bit(0);
}
inline bool Table_Field_NumericFieldOptions::is_autoincrement() const {
  return is_autoincrement_;
}
inline void Table_Field_NumericFieldOptions::set_is_autoincrement(bool value) {
  _set_bit(0);
  is_autoincrement_ = value;
}

// optional uint32 scale = 2;
inline bool Table_Field_NumericFieldOptions::has_scale() const {
  return _has_bit(1);
}
inline void Table_Field_NumericFieldOptions::clear_scale() {
  scale_ = 0u;
  _clear_bit(1);
}
inline ::google::protobuf::uint32 Table_Field_NumericFieldOptions::scale() const {
  return scale_;
}
inline void Table_Field_NumericFieldOptions::set_scale(::google::protobuf::uint32 value) {
  _set_bit(1);
  scale_ = value;
}

// optional uint32 precision = 3;
inline bool Table_Field_NumericFieldOptions::has_precision() const {
  return _has_bit(2);
}
inline void Table_Field_NumericFieldOptions::clear_precision() {
  precision_ = 0u;
  _clear_bit(2);
}
inline ::google::protobuf::uint32 Table_Field_NumericFieldOptions::precision() const {
  return precision_;
}
inline void Table_Field_NumericFieldOptions::set_precision(::google::protobuf::uint32 value) {
  _set_bit(2);
  precision_ = value;
}

// -------------------------------------------------------------------

// Table_Field_StringFieldOptions

// optional bool is_fixed_width = 1 [default = false];
inline bool Table_Field_StringFieldOptions::has_is_fixed_width() const {
  return _has_bit(0);
}
inline void Table_Field_StringFieldOptions::clear_is_fixed_width() {
  is_fixed_width_ = false;
  _clear_bit(0);
}
inline bool Table_Field_StringFieldOptions::is_fixed_width() const {
  return is_fixed_width_;
}
inline void Table_Field_StringFieldOptions::set_is_fixed_width(bool value) {
  _set_bit(0);
  is_fixed_width_ = value;
}

// optional uint32 length = 2;
inline bool Table_Field_StringFieldOptions::has_length() const {
  return _has_bit(1);
}
inline void Table_Field_StringFieldOptions::clear_length() {
  length_ = 0u;
  _clear_bit(1);
}
inline ::google::protobuf::uint32 Table_Field_StringFieldOptions::length() const {
  return length_;
}
inline void Table_Field_StringFieldOptions::set_length(::google::protobuf::uint32 value) {
  _set_bit(1);
  length_ = value;
}

// optional uint32 collation_id = 3;
inline bool Table_Field_StringFieldOptions::has_collation_id() const {
  return _has_bit(2);
}
inline void Table_Field_StringFieldOptions::clear_collation_id() {
  collation_id_ = 0u;
  _clear_bit(2);
}
inline ::google::protobuf::uint32 Table_Field_StringFieldOptions::collation_id() const {
  return collation_id_;
}
inline void Table_Field_StringFieldOptions::set_collation_id(::google::protobuf::uint32 value) {
  _set_bit(2);
  collation_id_ = value;
}

// optional string collation = 4;
inline bool Table_Field_StringFieldOptions::has_collation() const {
  return _has_bit(3);
}
inline void Table_Field_StringFieldOptions::clear_collation() {
  if (collation_ != &_default_collation_) {
    collation_->clear();
  }
  _clear_bit(3);
}
inline const ::std::string& Table_Field_StringFieldOptions::collation() const {
  return *collation_;
}
inline void Table_Field_StringFieldOptions::set_collation(const ::std::string& value) {
  _set_bit(3);
  if (collation_ == &_default_collation_) {
    collation_ = new ::std::string;
  }
  collation_->assign(value);
}
inline void Table_Field_StringFieldOptions::set_collation(const char* value) {
  _set_bit(3);
  if (collation_ == &_default_collation_) {
    collation_ = new ::std::string;
  }
  collation_->assign(value);
}
inline void Table_Field_StringFieldOptions::set_collation(const char* value, size_t size) {
  _set_bit(3);
  if (collation_ == &_default_collation_) {
    collation_ = new ::std::string;
  }
  collation_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field_StringFieldOptions::mutable_collation() {
  _set_bit(3);
  if (collation_ == &_default_collation_) {
    collation_ = new ::std::string;
  }
  return collation_;
}

// -------------------------------------------------------------------

// Table_Field_EnumerationValues

// optional uint32 collation_id = 2;
inline bool Table_Field_EnumerationValues::has_collation_id() const {
  return _has_bit(0);
}
inline void Table_Field_EnumerationValues::clear_collation_id() {
  collation_id_ = 0u;
  _clear_bit(0);
}
inline ::google::protobuf::uint32 Table_Field_EnumerationValues::collation_id() const {
  return collation_id_;
}
inline void Table_Field_EnumerationValues::set_collation_id(::google::protobuf::uint32 value) {
  _set_bit(0);
  collation_id_ = value;
}

// optional string collation = 3;
inline bool Table_Field_EnumerationValues::has_collation() const {
  return _has_bit(1);
}
inline void Table_Field_EnumerationValues::clear_collation() {
  if (collation_ != &_default_collation_) {
    collation_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& Table_Field_EnumerationValues::collation() const {
  return *collation_;
}
inline void Table_Field_EnumerationValues::set_collation(const ::std::string& value) {
  _set_bit(1);
  if (collation_ == &_default_collation_) {
    collation_ = new ::std::string;
  }
  collation_->assign(value);
}
inline void Table_Field_EnumerationValues::set_collation(const char* value) {
  _set_bit(1);
  if (collation_ == &_default_collation_) {
    collation_ = new ::std::string;
  }
  collation_->assign(value);
}
inline void Table_Field_EnumerationValues::set_collation(const char* value, size_t size) {
  _set_bit(1);
  if (collation_ == &_default_collation_) {
    collation_ = new ::std::string;
  }
  collation_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field_EnumerationValues::mutable_collation() {
  _set_bit(1);
  if (collation_ == &_default_collation_) {
    collation_ = new ::std::string;
  }
  return collation_;
}

// repeated string field_value = 4;
inline int Table_Field_EnumerationValues::field_value_size() const {
  return field_value_.size();
}
inline void Table_Field_EnumerationValues::clear_field_value() {
  field_value_.Clear();
}
inline const ::std::string& Table_Field_EnumerationValues::field_value(int index) const {
  return field_value_.Get(index);
}
inline ::std::string* Table_Field_EnumerationValues::mutable_field_value(int index) {
  return field_value_.Mutable(index);
}
inline void Table_Field_EnumerationValues::set_field_value(int index, const ::std::string& value) {
  field_value_.Mutable(index)->assign(value);
}
inline void Table_Field_EnumerationValues::set_field_value(int index, const char* value) {
  field_value_.Mutable(index)->assign(value);
}
inline void Table_Field_EnumerationValues::set_field_value(int index, const char* value, size_t size) {
  field_value_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field_EnumerationValues::add_field_value() {
  return field_value_.Add();
}
inline void Table_Field_EnumerationValues::add_field_value(const ::std::string& value) {
  field_value_.Add()->assign(value);
}
inline void Table_Field_EnumerationValues::add_field_value(const char* value) {
  field_value_.Add()->assign(value);
}
inline void Table_Field_EnumerationValues::add_field_value(const char* value, size_t size) {
  field_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
Table_Field_EnumerationValues::field_value() const {
  return field_value_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
Table_Field_EnumerationValues::mutable_field_value() {
  return &field_value_;
}

// -------------------------------------------------------------------

// Table_Field

// required string name = 1;
inline bool Table_Field::has_name() const {
  return _has_bit(0);
}
inline void Table_Field::clear_name() {
  if (name_ != &_default_name_) {
    name_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& Table_Field::name() const {
  return *name_;
}
inline void Table_Field::set_name(const ::std::string& value) {
  _set_bit(0);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Table_Field::set_name(const char* value) {
  _set_bit(0);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Table_Field::set_name(const char* value, size_t size) {
  _set_bit(0);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field::mutable_name() {
  _set_bit(0);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  return name_;
}

// required .drizzled.message.Table.Field.FieldType type = 2;
inline bool Table_Field::has_type() const {
  return _has_bit(1);
}
inline void Table_Field::clear_type() {
  type_ = 0;
  _clear_bit(1);
}
inline ::drizzled::message::Table_Field_FieldType Table_Field::type() const {
  return static_cast< ::drizzled::message::Table_Field_FieldType >(type_);
}
inline void Table_Field::set_type(::drizzled::message::Table_Field_FieldType value) {
  GOOGLE_DCHECK(::drizzled::message::Table_Field_FieldType_IsValid(value));
  _set_bit(1);
  type_ = value;
}

// optional .drizzled.message.Table.Field.FieldOptions options = 4;
inline bool Table_Field::has_options() const {
  return _has_bit(2);
}
inline void Table_Field::clear_options() {
  if (options_ != NULL) options_->::drizzled::message::Table_Field_FieldOptions::Clear();
  _clear_bit(2);
}
inline const ::drizzled::message::Table_Field_FieldOptions& Table_Field::options() const {
  return options_ != NULL ? *options_ : *default_instance_->options_;
}
inline ::drizzled::message::Table_Field_FieldOptions* Table_Field::mutable_options() {
  _set_bit(2);
  if (options_ == NULL) options_ = new ::drizzled::message::Table_Field_FieldOptions;
  return options_;
}

// optional .drizzled.message.Table.Field.FieldConstraints constraints = 5;
inline bool Table_Field::has_constraints() const {
  return _has_bit(3);
}
inline void Table_Field::clear_constraints() {
  if (constraints_ != NULL) constraints_->::drizzled::message::Table_Field_FieldConstraints::Clear();
  _clear_bit(3);
}
inline const ::drizzled::message::Table_Field_FieldConstraints& Table_Field::constraints() const {
  return constraints_ != NULL ? *constraints_ : *default_instance_->constraints_;
}
inline ::drizzled::message::Table_Field_FieldConstraints* Table_Field::mutable_constraints() {
  _set_bit(3);
  if (constraints_ == NULL) constraints_ = new ::drizzled::message::Table_Field_FieldConstraints;
  return constraints_;
}

// optional .drizzled.message.Table.Field.NumericFieldOptions numeric_options = 6;
inline bool Table_Field::has_numeric_options() const {
  return _has_bit(4);
}
inline void Table_Field::clear_numeric_options() {
  if (numeric_options_ != NULL) numeric_options_->::drizzled::message::Table_Field_NumericFieldOptions::Clear();
  _clear_bit(4);
}
inline const ::drizzled::message::Table_Field_NumericFieldOptions& Table_Field::numeric_options() const {
  return numeric_options_ != NULL ? *numeric_options_ : *default_instance_->numeric_options_;
}
inline ::drizzled::message::Table_Field_NumericFieldOptions* Table_Field::mutable_numeric_options() {
  _set_bit(4);
  if (numeric_options_ == NULL) numeric_options_ = new ::drizzled::message::Table_Field_NumericFieldOptions;
  return numeric_options_;
}

// optional .drizzled.message.Table.Field.StringFieldOptions string_options = 7;
inline bool Table_Field::has_string_options() const {
  return _has_bit(5);
}
inline void Table_Field::clear_string_options() {
  if (string_options_ != NULL) string_options_->::drizzled::message::Table_Field_StringFieldOptions::Clear();
  _clear_bit(5);
}
inline const ::drizzled::message::Table_Field_StringFieldOptions& Table_Field::string_options() const {
  return string_options_ != NULL ? *string_options_ : *default_instance_->string_options_;
}
inline ::drizzled::message::Table_Field_StringFieldOptions* Table_Field::mutable_string_options() {
  _set_bit(5);
  if (string_options_ == NULL) string_options_ = new ::drizzled::message::Table_Field_StringFieldOptions;
  return string_options_;
}

// optional string comment = 16;
inline bool Table_Field::has_comment() const {
  return _has_bit(6);
}
inline void Table_Field::clear_comment() {
  if (comment_ != &_default_comment_) {
    comment_->clear();
  }
  _clear_bit(6);
}
inline const ::std::string& Table_Field::comment() const {
  return *comment_;
}
inline void Table_Field::set_comment(const ::std::string& value) {
  _set_bit(6);
  if (comment_ == &_default_comment_) {
    comment_ = new ::std::string;
  }
  comment_->assign(value);
}
inline void Table_Field::set_comment(const char* value) {
  _set_bit(6);
  if (comment_ == &_default_comment_) {
    comment_ = new ::std::string;
  }
  comment_->assign(value);
}
inline void Table_Field::set_comment(const char* value, size_t size) {
  _set_bit(6);
  if (comment_ == &_default_comment_) {
    comment_ = new ::std::string;
  }
  comment_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Field::mutable_comment() {
  _set_bit(6);
  if (comment_ == &_default_comment_) {
    comment_ = new ::std::string;
  }
  return comment_;
}

// optional .drizzled.message.Table.Field.EnumerationValues enumeration_values = 17;
inline bool Table_Field::has_enumeration_values() const {
  return _has_bit(7);
}
inline void Table_Field::clear_enumeration_values() {
  if (enumeration_values_ != NULL) enumeration_values_->::drizzled::message::Table_Field_EnumerationValues::Clear();
  _clear_bit(7);
}
inline const ::drizzled::message::Table_Field_EnumerationValues& Table_Field::enumeration_values() const {
  return enumeration_values_ != NULL ? *enumeration_values_ : *default_instance_->enumeration_values_;
}
inline ::drizzled::message::Table_Field_EnumerationValues* Table_Field::mutable_enumeration_values() {
  _set_bit(7);
  if (enumeration_values_ == NULL) enumeration_values_ = new ::drizzled::message::Table_Field_EnumerationValues;
  return enumeration_values_;
}

// optional .drizzled.message.Table.Field.TimestampFieldOptions timestamp_options = 18;
inline bool Table_Field::has_timestamp_options() const {
  return _has_bit(8);
}
inline void Table_Field::clear_timestamp_options() {
  if (timestamp_options_ != NULL) timestamp_options_->::drizzled::message::Table_Field_TimestampFieldOptions::Clear();
  _clear_bit(8);
}
inline const ::drizzled::message::Table_Field_TimestampFieldOptions& Table_Field::timestamp_options() const {
  return timestamp_options_ != NULL ? *timestamp_options_ : *default_instance_->timestamp_options_;
}
inline ::drizzled::message::Table_Field_TimestampFieldOptions* Table_Field::mutable_timestamp_options() {
  _set_bit(8);
  if (timestamp_options_ == NULL) timestamp_options_ = new ::drizzled::message::Table_Field_TimestampFieldOptions;
  return timestamp_options_;
}

// -------------------------------------------------------------------

// Table_Index_IndexPart

// required uint32 fieldnr = 1;
inline bool Table_Index_IndexPart::has_fieldnr() const {
  return _has_bit(0);
}
inline void Table_Index_IndexPart::clear_fieldnr() {
  fieldnr_ = 0u;
  _clear_bit(0);
}
inline ::google::protobuf::uint32 Table_Index_IndexPart::fieldnr() const {
  return fieldnr_;
}
inline void Table_Index_IndexPart::set_fieldnr(::google::protobuf::uint32 value) {
  _set_bit(0);
  fieldnr_ = value;
}

// optional uint32 compare_length = 2;
inline bool Table_Index_IndexPart::has_compare_length() const {
  return _has_bit(1);
}
inline void Table_Index_IndexPart::clear_compare_length() {
  compare_length_ = 0u;
  _clear_bit(1);
}
inline ::google::protobuf::uint32 Table_Index_IndexPart::compare_length() const {
  return compare_length_;
}
inline void Table_Index_IndexPart::set_compare_length(::google::protobuf::uint32 value) {
  _set_bit(1);
  compare_length_ = value;
}

// optional bool in_reverse_order = 3 [default = false];
inline bool Table_Index_IndexPart::has_in_reverse_order() const {
  return _has_bit(2);
}
inline void Table_Index_IndexPart::clear_in_reverse_order() {
  in_reverse_order_ = false;
  _clear_bit(2);
}
inline bool Table_Index_IndexPart::in_reverse_order() const {
  return in_reverse_order_;
}
inline void Table_Index_IndexPart::set_in_reverse_order(bool value) {
  _set_bit(2);
  in_reverse_order_ = value;
}

// optional uint32 key_type = 101;
inline bool Table_Index_IndexPart::has_key_type() const {
  return _has_bit(3);
}
inline void Table_Index_IndexPart::clear_key_type() {
  key_type_ = 0u;
  _clear_bit(3);
}
inline ::google::protobuf::uint32 Table_Index_IndexPart::key_type() const {
  return key_type_;
}
inline void Table_Index_IndexPart::set_key_type(::google::protobuf::uint32 value) {
  _set_bit(3);
  key_type_ = value;
}

// -------------------------------------------------------------------

// Table_Index_Options

// optional bool pack_key = 1;
inline bool Table_Index_Options::has_pack_key() const {
  return _has_bit(0);
}
inline void Table_Index_Options::clear_pack_key() {
  pack_key_ = false;
  _clear_bit(0);
}
inline bool Table_Index_Options::pack_key() const {
  return pack_key_;
}
inline void Table_Index_Options::set_pack_key(bool value) {
  _set_bit(0);
  pack_key_ = value;
}

// optional bool binary_pack_key = 2;
inline bool Table_Index_Options::has_binary_pack_key() const {
  return _has_bit(1);
}
inline void Table_Index_Options::clear_binary_pack_key() {
  binary_pack_key_ = false;
  _clear_bit(1);
}
inline bool Table_Index_Options::binary_pack_key() const {
  return binary_pack_key_;
}
inline void Table_Index_Options::set_binary_pack_key(bool value) {
  _set_bit(1);
  binary_pack_key_ = value;
}

// optional bool var_length_key = 3;
inline bool Table_Index_Options::has_var_length_key() const {
  return _has_bit(2);
}
inline void Table_Index_Options::clear_var_length_key() {
  var_length_key_ = false;
  _clear_bit(2);
}
inline bool Table_Index_Options::var_length_key() const {
  return var_length_key_;
}
inline void Table_Index_Options::set_var_length_key(bool value) {
  _set_bit(2);
  var_length_key_ = value;
}

// optional bool null_part_key = 4;
inline bool Table_Index_Options::has_null_part_key() const {
  return _has_bit(3);
}
inline void Table_Index_Options::clear_null_part_key() {
  null_part_key_ = false;
  _clear_bit(3);
}
inline bool Table_Index_Options::null_part_key() const {
  return null_part_key_;
}
inline void Table_Index_Options::set_null_part_key(bool value) {
  _set_bit(3);
  null_part_key_ = value;
}

// optional uint32 key_block_size = 5;
inline bool Table_Index_Options::has_key_block_size() const {
  return _has_bit(4);
}
inline void Table_Index_Options::clear_key_block_size() {
  key_block_size_ = 0u;
  _clear_bit(4);
}
inline ::google::protobuf::uint32 Table_Index_Options::key_block_size() const {
  return key_block_size_;
}
inline void Table_Index_Options::set_key_block_size(::google::protobuf::uint32 value) {
  _set_bit(4);
  key_block_size_ = value;
}

// optional bool has_partial_segments = 6;
inline bool Table_Index_Options::has_has_partial_segments() const {
  return _has_bit(5);
}
inline void Table_Index_Options::clear_has_partial_segments() {
  has_partial_segments_ = false;
  _clear_bit(5);
}
inline bool Table_Index_Options::has_partial_segments() const {
  return has_partial_segments_;
}
inline void Table_Index_Options::set_has_partial_segments(bool value) {
  _set_bit(5);
  has_partial_segments_ = value;
}

// optional bool auto_generated_key = 7;
inline bool Table_Index_Options::has_auto_generated_key() const {
  return _has_bit(6);
}
inline void Table_Index_Options::clear_auto_generated_key() {
  auto_generated_key_ = false;
  _clear_bit(6);
}
inline bool Table_Index_Options::auto_generated_key() const {
  return auto_generated_key_;
}
inline void Table_Index_Options::set_auto_generated_key(bool value) {
  _set_bit(6);
  auto_generated_key_ = value;
}

// -------------------------------------------------------------------

// Table_Index

// required string name = 1;
inline bool Table_Index::has_name() const {
  return _has_bit(0);
}
inline void Table_Index::clear_name() {
  if (name_ != &_default_name_) {
    name_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& Table_Index::name() const {
  return *name_;
}
inline void Table_Index::set_name(const ::std::string& value) {
  _set_bit(0);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Table_Index::set_name(const char* value) {
  _set_bit(0);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Table_Index::set_name(const char* value, size_t size) {
  _set_bit(0);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Index::mutable_name() {
  _set_bit(0);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  return name_;
}

// required bool is_primary = 2;
inline bool Table_Index::has_is_primary() const {
  return _has_bit(1);
}
inline void Table_Index::clear_is_primary() {
  is_primary_ = false;
  _clear_bit(1);
}
inline bool Table_Index::is_primary() const {
  return is_primary_;
}
inline void Table_Index::set_is_primary(bool value) {
  _set_bit(1);
  is_primary_ = value;
}

// required bool is_unique = 3;
inline bool Table_Index::has_is_unique() const {
  return _has_bit(2);
}
inline void Table_Index::clear_is_unique() {
  is_unique_ = false;
  _clear_bit(2);
}
inline bool Table_Index::is_unique() const {
  return is_unique_;
}
inline void Table_Index::set_is_unique(bool value) {
  _set_bit(2);
  is_unique_ = value;
}

// required .drizzled.message.Table.Index.IndexType type = 4 [default = UNKNOWN_INDEX];
inline bool Table_Index::has_type() const {
  return _has_bit(3);
}
inline void Table_Index::clear_type() {
  type_ = 0;
  _clear_bit(3);
}
inline ::drizzled::message::Table_Index_IndexType Table_Index::type() const {
  return static_cast< ::drizzled::message::Table_Index_IndexType >(type_);
}
inline void Table_Index::set_type(::drizzled::message::Table_Index_IndexType value) {
  GOOGLE_DCHECK(::drizzled::message::Table_Index_IndexType_IsValid(value));
  _set_bit(3);
  type_ = value;
}

// required uint32 key_length = 5;
inline bool Table_Index::has_key_length() const {
  return _has_bit(4);
}
inline void Table_Index::clear_key_length() {
  key_length_ = 0u;
  _clear_bit(4);
}
inline ::google::protobuf::uint32 Table_Index::key_length() const {
  return key_length_;
}
inline void Table_Index::set_key_length(::google::protobuf::uint32 value) {
  _set_bit(4);
  key_length_ = value;
}

// repeated .drizzled.message.Table.Index.IndexPart index_part = 6;
inline int Table_Index::index_part_size() const {
  return index_part_.size();
}
inline void Table_Index::clear_index_part() {
  index_part_.Clear();
}
inline const ::drizzled::message::Table_Index_IndexPart& Table_Index::index_part(int index) const {
  return index_part_.Get(index);
}
inline ::drizzled::message::Table_Index_IndexPart* Table_Index::mutable_index_part(int index) {
  return index_part_.Mutable(index);
}
inline ::drizzled::message::Table_Index_IndexPart* Table_Index::add_index_part() {
  return index_part_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart >&
Table_Index::index_part() const {
  return index_part_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart >*
Table_Index::mutable_index_part() {
  return &index_part_;
}

// optional .drizzled.message.Table.Index.Options options = 7;
inline bool Table_Index::has_options() const {
  return _has_bit(6);
}
inline void Table_Index::clear_options() {
  if (options_ != NULL) options_->::drizzled::message::Table_Index_Options::Clear();
  _clear_bit(6);
}
inline const ::drizzled::message::Table_Index_Options& Table_Index::options() const {
  return options_ != NULL ? *options_ : *default_instance_->options_;
}
inline ::drizzled::message::Table_Index_Options* Table_Index::mutable_options() {
  _set_bit(6);
  if (options_ == NULL) options_ = new ::drizzled::message::Table_Index_Options;
  return options_;
}

// optional string comment = 8;
inline bool Table_Index::has_comment() const {
  return _has_bit(7);
}
inline void Table_Index::clear_comment() {
  if (comment_ != &_default_comment_) {
    comment_->clear();
  }
  _clear_bit(7);
}
inline const ::std::string& Table_Index::comment() const {
  return *comment_;
}
inline void Table_Index::set_comment(const ::std::string& value) {
  _set_bit(7);
  if (comment_ == &_default_comment_) {
    comment_ = new ::std::string;
  }
  comment_->assign(value);
}
inline void Table_Index::set_comment(const char* value) {
  _set_bit(7);
  if (comment_ == &_default_comment_) {
    comment_ = new ::std::string;
  }
  comment_->assign(value);
}
inline void Table_Index::set_comment(const char* value, size_t size) {
  _set_bit(7);
  if (comment_ == &_default_comment_) {
    comment_ = new ::std::string;
  }
  comment_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table_Index::mutable_comment() {
  _set_bit(7);
  if (comment_ == &_default_comment_) {
    comment_ = new ::std::string;
  }
  return comment_;
}

// -------------------------------------------------------------------

// Table

// required string name = 1;
inline bool Table::has_name() const {
  return _has_bit(0);
}
inline void Table::clear_name() {
  if (name_ != &_default_name_) {
    name_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& Table::name() const {
  return *name_;
}
inline void Table::set_name(const ::std::string& value) {
  _set_bit(0);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Table::set_name(const char* value) {
  _set_bit(0);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void Table::set_name(const char* value, size_t size) {
  _set_bit(0);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table::mutable_name() {
  _set_bit(0);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  return name_;
}

// required string schema = 6;
inline bool Table::has_schema() const {
  return _has_bit(1);
}
inline void Table::clear_schema() {
  if (schema_ != &_default_schema_) {
    schema_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& Table::schema() const {
  return *schema_;
}
inline void Table::set_schema(const ::std::string& value) {
  _set_bit(1);
  if (schema_ == &_default_schema_) {
    schema_ = new ::std::string;
  }
  schema_->assign(value);
}
inline void Table::set_schema(const char* value) {
  _set_bit(1);
  if (schema_ == &_default_schema_) {
    schema_ = new ::std::string;
  }
  schema_->assign(value);
}
inline void Table::set_schema(const char* value, size_t size) {
  _set_bit(1);
  if (schema_ == &_default_schema_) {
    schema_ = new ::std::string;
  }
  schema_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table::mutable_schema() {
  _set_bit(1);
  if (schema_ == &_default_schema_) {
    schema_ = new ::std::string;
  }
  return schema_;
}

// required .drizzled.message.Table.TableType type = 5;
inline bool Table::has_type() const {
  return _has_bit(2);
}
inline void Table::clear_type() {
  type_ = 0;
  _clear_bit(2);
}
inline ::drizzled::message::Table_TableType Table::type() const {
  return static_cast< ::drizzled::message::Table_TableType >(type_);
}
inline void Table::set_type(::drizzled::message::Table_TableType value) {
  GOOGLE_DCHECK(::drizzled::message::Table_TableType_IsValid(value));
  _set_bit(2);
  type_ = value;
}

// required .drizzled.message.Engine engine = 2;
inline bool Table::has_engine() const {
  return _has_bit(3);
}
inline void Table::clear_engine() {
  if (engine_ != NULL) engine_->::drizzled::message::Engine::Clear();
  _clear_bit(3);
}
inline const ::drizzled::message::Engine& Table::engine() const {
  return engine_ != NULL ? *engine_ : *default_instance_->engine_;
}
inline ::drizzled::message::Engine* Table::mutable_engine() {
  _set_bit(3);
  if (engine_ == NULL) engine_ = new ::drizzled::message::Engine;
  return engine_;
}

// repeated .drizzled.message.Table.Field field = 3;
inline int Table::field_size() const {
  return field_.size();
}
inline void Table::clear_field() {
  field_.Clear();
}
inline const ::drizzled::message::Table_Field& Table::field(int index) const {
  return field_.Get(index);
}
inline ::drizzled::message::Table_Field* Table::mutable_field(int index) {
  return field_.Mutable(index);
}
inline ::drizzled::message::Table_Field* Table::add_field() {
  return field_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >&
Table::field() const {
  return field_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >*
Table::mutable_field() {
  return &field_;
}

// repeated .drizzled.message.Table.Index indexes = 4;
inline int Table::indexes_size() const {
  return indexes_.size();
}
inline void Table::clear_indexes() {
  indexes_.Clear();
}
inline const ::drizzled::message::Table_Index& Table::indexes(int index) const {
  return indexes_.Get(index);
}
inline ::drizzled::message::Table_Index* Table::mutable_indexes(int index) {
  return indexes_.Mutable(index);
}
inline ::drizzled::message::Table_Index* Table::add_indexes() {
  return indexes_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index >&
Table::indexes() const {
  return indexes_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index >*
Table::mutable_indexes() {
  return &indexes_;
}

// repeated .drizzled.message.Table.ForeignKeyConstraint fk_constraint = 8;
inline int Table::fk_constraint_size() const {
  return fk_constraint_.size();
}
inline void Table::clear_fk_constraint() {
  fk_constraint_.Clear();
}
inline const ::drizzled::message::Table_ForeignKeyConstraint& Table::fk_constraint(int index) const {
  return fk_constraint_.Get(index);
}
inline ::drizzled::message::Table_ForeignKeyConstraint* Table::mutable_fk_constraint(int index) {
  return fk_constraint_.Mutable(index);
}
inline ::drizzled::message::Table_ForeignKeyConstraint* Table::add_fk_constraint() {
  return fk_constraint_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint >&
Table::fk_constraint() const {
  return fk_constraint_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint >*
Table::mutable_fk_constraint() {
  return &fk_constraint_;
}

// optional .drizzled.message.Table.TableOptions options = 9;
inline bool Table::has_options() const {
  return _has_bit(7);
}
inline void Table::clear_options() {
  if (options_ != NULL) options_->::drizzled::message::Table_TableOptions::Clear();
  _clear_bit(7);
}
inline const ::drizzled::message::Table_TableOptions& Table::options() const {
  return options_ != NULL ? *options_ : *default_instance_->options_;
}
inline ::drizzled::message::Table_TableOptions* Table::mutable_options() {
  _set_bit(7);
  if (options_ == NULL) options_ = new ::drizzled::message::Table_TableOptions;
  return options_;
}

// required uint64 creation_timestamp = 11 [default = 0];
inline bool Table::has_creation_timestamp() const {
  return _has_bit(8);
}
inline void Table::clear_creation_timestamp() {
  creation_timestamp_ = GOOGLE_ULONGLONG(0);
  _clear_bit(8);
}
inline ::google::protobuf::uint64 Table::creation_timestamp() const {
  return creation_timestamp_;
}
inline void Table::set_creation_timestamp(::google::protobuf::uint64 value) {
  _set_bit(8);
  creation_timestamp_ = value;
}

// required uint64 update_timestamp = 12 [default = 0];
inline bool Table::has_update_timestamp() const {
  return _has_bit(9);
}
inline void Table::clear_update_timestamp() {
  update_timestamp_ = GOOGLE_ULONGLONG(0);
  _clear_bit(9);
}
inline ::google::protobuf::uint64 Table::update_timestamp() const {
  return update_timestamp_;
}
inline void Table::set_update_timestamp(::google::protobuf::uint64 value) {
  _set_bit(9);
  update_timestamp_ = value;
}

// optional string catalog = 13;
inline bool Table::has_catalog() const {
  return _has_bit(10);
}
inline void Table::clear_catalog() {
  if (catalog_ != &_default_catalog_) {
    catalog_->clear();
  }
  _clear_bit(10);
}
inline const ::std::string& Table::catalog() const {
  return *catalog_;
}
inline void Table::set_catalog(const ::std::string& value) {
  _set_bit(10);
  if (catalog_ == &_default_catalog_) {
    catalog_ = new ::std::string;
  }
  catalog_->assign(value);
}
inline void Table::set_catalog(const char* value) {
  _set_bit(10);
  if (catalog_ == &_default_catalog_) {
    catalog_ = new ::std::string;
  }
  catalog_->assign(value);
}
inline void Table::set_catalog(const char* value, size_t size) {
  _set_bit(10);
  if (catalog_ == &_default_catalog_) {
    catalog_ = new ::std::string;
  }
  catalog_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Table::mutable_catalog() {
  _set_bit(10);
  if (catalog_ == &_default_catalog_) {
    catalog_ = new ::std::string;
  }
  return catalog_;
}

// -------------------------------------------------------------------

// AlterTable

// repeated .drizzled.message.Table.Field added_field = 1;
inline int AlterTable::added_field_size() const {
  return added_field_.size();
}
inline void AlterTable::clear_added_field() {
  added_field_.Clear();
}
inline const ::drizzled::message::Table_Field& AlterTable::added_field(int index) const {
  return added_field_.Get(index);
}
inline ::drizzled::message::Table_Field* AlterTable::mutable_added_field(int index) {
  return added_field_.Mutable(index);
}
inline ::drizzled::message::Table_Field* AlterTable::add_added_field() {
  return added_field_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >&
AlterTable::added_field() const {
  return added_field_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >*
AlterTable::mutable_added_field() {
  return &added_field_;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace message
}  // namespace drizzled

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_TableOptions_RowType>() {
  return ::drizzled::message::Table_TableOptions_RowType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_Field_FieldType>() {
  return ::drizzled::message::Table_Field_FieldType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_Index_IndexType>() {
  return ::drizzled::message::Table_Index_IndexType_descriptor();
}
template <>
inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_TableType>() {
  return ::drizzled::message::Table_TableType_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_table_2eproto__INCLUDED
