Drizzled Public API Documentation

table.pb.h

00001 // Generated by the protocol buffer compiler.  DO NOT EDIT!
00002 // source: table.proto
00003 
00004 #ifndef PROTOBUF_table_2eproto__INCLUDED
00005 #define PROTOBUF_table_2eproto__INCLUDED
00006 
00007 #include <string>
00008 
00009 #include <google/protobuf/stubs/common.h>
00010 
00011 #if GOOGLE_PROTOBUF_VERSION < 2003000
00012 #error This file was generated by a newer version of protoc which is
00013 #error incompatible with your Protocol Buffer headers.  Please update
00014 #error your headers.
00015 #endif
00016 #if 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
00017 #error This file was generated by an older version of protoc which is
00018 #error incompatible with your Protocol Buffer headers.  Please
00019 #error regenerate this file with a newer version of protoc.
00020 #endif
00021 
00022 #include <google/protobuf/generated_message_util.h>
00023 #include <google/protobuf/repeated_field.h>
00024 #include <google/protobuf/extension_set.h>
00025 #include <google/protobuf/generated_message_reflection.h>
00026 #include "engine.pb.h"
00027 #include "replication_options.pb.h"
00028 // @@protoc_insertion_point(includes)
00029 
00030 namespace drizzled {
00031 namespace message {
00032 
00033 // Internal implementation detail -- do not call these.
00034 void  protobuf_AddDesc_table_2eproto();
00035 void protobuf_AssignDesc_table_2eproto();
00036 void protobuf_ShutdownFile_table_2eproto();
00037 
00038 class Table;
00039 class Table_TableOptions;
00040 class Table_ForeignKeyConstraint;
00041 class Table_Field;
00042 class Table_Field_FieldOptions;
00043 class Table_Field_FieldConstraints;
00044 class Table_Field_NumericFieldOptions;
00045 class Table_Field_StringFieldOptions;
00046 class Table_Field_EnumerationValues;
00047 class Table_Field_TimeFieldOptions;
00048 class Table_Index;
00049 class Table_Index_IndexPart;
00050 class Table_Index_Options;
00051 class AlterTable;
00052 
00053 enum Table_ForeignKeyConstraint_ForeignKeyMatchOption {
00054   Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_UNDEFINED = 0,
00055   Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_FULL = 1,
00056   Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_PARTIAL = 2,
00057   Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_SIMPLE = 3
00058 };
00059 bool Table_ForeignKeyConstraint_ForeignKeyMatchOption_IsValid(int value);
00060 const Table_ForeignKeyConstraint_ForeignKeyMatchOption Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_MIN = Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_UNDEFINED;
00061 const Table_ForeignKeyConstraint_ForeignKeyMatchOption Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_MAX = Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_SIMPLE;
00062 const int Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_ARRAYSIZE = Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_MAX + 1;
00063 
00064 const ::google::protobuf::EnumDescriptor* Table_ForeignKeyConstraint_ForeignKeyMatchOption_descriptor();
00065 inline const ::std::string& Table_ForeignKeyConstraint_ForeignKeyMatchOption_Name(Table_ForeignKeyConstraint_ForeignKeyMatchOption value) {
00066   return ::google::protobuf::internal::NameOfEnum(
00067     Table_ForeignKeyConstraint_ForeignKeyMatchOption_descriptor(), value);
00068 }
00069 inline bool Table_ForeignKeyConstraint_ForeignKeyMatchOption_Parse(
00070     const ::std::string& name, Table_ForeignKeyConstraint_ForeignKeyMatchOption* value) {
00071   return ::google::protobuf::internal::ParseNamedEnum<Table_ForeignKeyConstraint_ForeignKeyMatchOption>(
00072     Table_ForeignKeyConstraint_ForeignKeyMatchOption_descriptor(), name, value);
00073 }
00074 enum Table_ForeignKeyConstraint_ForeignKeyOption {
00075   Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_UNDEF = 0,
00076   Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_RESTRICT = 1,
00077   Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_CASCADE = 2,
00078   Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_SET_NULL = 3,
00079   Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_NO_ACTION = 4,
00080   Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_SET_DEFAULT = 5
00081 };
00082 bool Table_ForeignKeyConstraint_ForeignKeyOption_IsValid(int value);
00083 const Table_ForeignKeyConstraint_ForeignKeyOption Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_MIN = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_UNDEF;
00084 const Table_ForeignKeyConstraint_ForeignKeyOption Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_MAX = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_SET_DEFAULT;
00085 const int Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_ARRAYSIZE = Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_MAX + 1;
00086 
00087 const ::google::protobuf::EnumDescriptor* Table_ForeignKeyConstraint_ForeignKeyOption_descriptor();
00088 inline const ::std::string& Table_ForeignKeyConstraint_ForeignKeyOption_Name(Table_ForeignKeyConstraint_ForeignKeyOption value) {
00089   return ::google::protobuf::internal::NameOfEnum(
00090     Table_ForeignKeyConstraint_ForeignKeyOption_descriptor(), value);
00091 }
00092 inline bool Table_ForeignKeyConstraint_ForeignKeyOption_Parse(
00093     const ::std::string& name, Table_ForeignKeyConstraint_ForeignKeyOption* value) {
00094   return ::google::protobuf::internal::ParseNamedEnum<Table_ForeignKeyConstraint_ForeignKeyOption>(
00095     Table_ForeignKeyConstraint_ForeignKeyOption_descriptor(), name, value);
00096 }
00097 enum Table_Field_FieldType {
00098   Table_Field_FieldType_DOUBLE = 0,
00099   Table_Field_FieldType_VARCHAR = 1,
00100   Table_Field_FieldType_BLOB = 2,
00101   Table_Field_FieldType_ENUM = 3,
00102   Table_Field_FieldType_INTEGER = 4,
00103   Table_Field_FieldType_BIGINT = 5,
00104   Table_Field_FieldType_DECIMAL = 6,
00105   Table_Field_FieldType_DATE = 7,
00106   Table_Field_FieldType_EPOCH = 9,
00107   Table_Field_FieldType_DATETIME = 10,
00108   Table_Field_FieldType_UUID = 11,
00109   Table_Field_FieldType_TIME = 12,
00110   Table_Field_FieldType_BOOLEAN = 13
00111 };
00112 bool Table_Field_FieldType_IsValid(int value);
00113 const Table_Field_FieldType Table_Field_FieldType_FieldType_MIN = Table_Field_FieldType_DOUBLE;
00114 const Table_Field_FieldType Table_Field_FieldType_FieldType_MAX = Table_Field_FieldType_BOOLEAN;
00115 const int Table_Field_FieldType_FieldType_ARRAYSIZE = Table_Field_FieldType_FieldType_MAX + 1;
00116 
00117 const ::google::protobuf::EnumDescriptor* Table_Field_FieldType_descriptor();
00118 inline const ::std::string& Table_Field_FieldType_Name(Table_Field_FieldType value) {
00119   return ::google::protobuf::internal::NameOfEnum(
00120     Table_Field_FieldType_descriptor(), value);
00121 }
00122 inline bool Table_Field_FieldType_Parse(
00123     const ::std::string& name, Table_Field_FieldType* value) {
00124   return ::google::protobuf::internal::ParseNamedEnum<Table_Field_FieldType>(
00125     Table_Field_FieldType_descriptor(), name, value);
00126 }
00127 enum Table_Index_IndexType {
00128   Table_Index_IndexType_UNKNOWN_INDEX = 0,
00129   Table_Index_IndexType_BTREE = 1,
00130   Table_Index_IndexType_RTREE = 2,
00131   Table_Index_IndexType_HASH = 3,
00132   Table_Index_IndexType_FULLTEXT = 4
00133 };
00134 bool Table_Index_IndexType_IsValid(int value);
00135 const Table_Index_IndexType Table_Index_IndexType_IndexType_MIN = Table_Index_IndexType_UNKNOWN_INDEX;
00136 const Table_Index_IndexType Table_Index_IndexType_IndexType_MAX = Table_Index_IndexType_FULLTEXT;
00137 const int Table_Index_IndexType_IndexType_ARRAYSIZE = Table_Index_IndexType_IndexType_MAX + 1;
00138 
00139 const ::google::protobuf::EnumDescriptor* Table_Index_IndexType_descriptor();
00140 inline const ::std::string& Table_Index_IndexType_Name(Table_Index_IndexType value) {
00141   return ::google::protobuf::internal::NameOfEnum(
00142     Table_Index_IndexType_descriptor(), value);
00143 }
00144 inline bool Table_Index_IndexType_Parse(
00145     const ::std::string& name, Table_Index_IndexType* value) {
00146   return ::google::protobuf::internal::ParseNamedEnum<Table_Index_IndexType>(
00147     Table_Index_IndexType_descriptor(), name, value);
00148 }
00149 enum Table_TableType {
00150   Table_TableType_STANDARD = 0,
00151   Table_TableType_TEMPORARY = 1,
00152   Table_TableType_INTERNAL = 2,
00153   Table_TableType_FUNCTION = 3
00154 };
00155 bool Table_TableType_IsValid(int value);
00156 const Table_TableType Table_TableType_TableType_MIN = Table_TableType_STANDARD;
00157 const Table_TableType Table_TableType_TableType_MAX = Table_TableType_FUNCTION;
00158 const int Table_TableType_TableType_ARRAYSIZE = Table_TableType_TableType_MAX + 1;
00159 
00160 const ::google::protobuf::EnumDescriptor* Table_TableType_descriptor();
00161 inline const ::std::string& Table_TableType_Name(Table_TableType value) {
00162   return ::google::protobuf::internal::NameOfEnum(
00163     Table_TableType_descriptor(), value);
00164 }
00165 inline bool Table_TableType_Parse(
00166     const ::std::string& name, Table_TableType* value) {
00167   return ::google::protobuf::internal::ParseNamedEnum<Table_TableType>(
00168     Table_TableType_descriptor(), name, value);
00169 }
00170 // ===================================================================
00171 
00172 class Table_TableOptions : public ::google::protobuf::Message {
00173  public:
00174   Table_TableOptions();
00175   virtual ~Table_TableOptions();
00176   
00177   Table_TableOptions(const Table_TableOptions& from);
00178   
00179   inline Table_TableOptions& operator=(const Table_TableOptions& from) {
00180     CopyFrom(from);
00181     return *this;
00182   }
00183   
00184   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00185     return _unknown_fields_;
00186   }
00187   
00188   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00189     return &_unknown_fields_;
00190   }
00191   
00192   static const ::google::protobuf::Descriptor* descriptor();
00193   static const Table_TableOptions& default_instance();
00194   
00195   void Swap(Table_TableOptions* other);
00196   
00197   // implements Message ----------------------------------------------
00198   
00199   Table_TableOptions* New() const;
00200   void CopyFrom(const ::google::protobuf::Message& from);
00201   void MergeFrom(const ::google::protobuf::Message& from);
00202   void CopyFrom(const Table_TableOptions& from);
00203   void MergeFrom(const Table_TableOptions& from);
00204   void Clear();
00205   bool IsInitialized() const;
00206   
00207   int ByteSize() const;
00208   bool MergePartialFromCodedStream(
00209       ::google::protobuf::io::CodedInputStream* input);
00210   void SerializeWithCachedSizes(
00211       ::google::protobuf::io::CodedOutputStream* output) const;
00212   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00213   int GetCachedSize() const { return _cached_size_; }
00214   private:
00215   void SharedCtor();
00216   void SharedDtor();
00217   void SetCachedSize(int size) const;
00218   public:
00219   
00220   ::google::protobuf::Metadata GetMetadata() const;
00221   
00222   // nested types ----------------------------------------------------
00223   
00224   // accessors -------------------------------------------------------
00225   
00226   // optional bool has_user_set_auto_increment_value = 1;
00227   inline bool has_has_user_set_auto_increment_value() const;
00228   inline void clear_has_user_set_auto_increment_value();
00229   static const int kHasUserSetAutoIncrementValueFieldNumber = 1;
00230   inline bool has_user_set_auto_increment_value() const;
00231   inline void set_has_user_set_auto_increment_value(bool value);
00232   
00233   // optional string collation = 2;
00234   inline bool has_collation() const;
00235   inline void clear_collation();
00236   static const int kCollationFieldNumber = 2;
00237   inline const ::std::string& collation() const;
00238   inline void set_collation(const ::std::string& value);
00239   inline void set_collation(const char* value);
00240   inline void set_collation(const char* value, size_t size);
00241   inline ::std::string* mutable_collation();
00242   
00243   // optional uint32 collation_id = 3;
00244   inline bool has_collation_id() const;
00245   inline void clear_collation_id();
00246   static const int kCollationIdFieldNumber = 3;
00247   inline ::google::protobuf::uint32 collation_id() const;
00248   inline void set_collation_id(::google::protobuf::uint32 value);
00249   
00250   // optional string data_file_name = 5;
00251   inline bool has_data_file_name() const;
00252   inline void clear_data_file_name();
00253   static const int kDataFileNameFieldNumber = 5;
00254   inline const ::std::string& data_file_name() const;
00255   inline void set_data_file_name(const ::std::string& value);
00256   inline void set_data_file_name(const char* value);
00257   inline void set_data_file_name(const char* value, size_t size);
00258   inline ::std::string* mutable_data_file_name();
00259   
00260   // optional string index_file_name = 6;
00261   inline bool has_index_file_name() const;
00262   inline void clear_index_file_name();
00263   static const int kIndexFileNameFieldNumber = 6;
00264   inline const ::std::string& index_file_name() const;
00265   inline void set_index_file_name(const ::std::string& value);
00266   inline void set_index_file_name(const char* value);
00267   inline void set_index_file_name(const char* value, size_t size);
00268   inline ::std::string* mutable_index_file_name();
00269   
00270   // optional uint64 max_rows = 7;
00271   inline bool has_max_rows() const;
00272   inline void clear_max_rows();
00273   static const int kMaxRowsFieldNumber = 7;
00274   inline ::google::protobuf::uint64 max_rows() const;
00275   inline void set_max_rows(::google::protobuf::uint64 value);
00276   
00277   // optional uint64 min_rows = 8;
00278   inline bool has_min_rows() const;
00279   inline void clear_min_rows();
00280   static const int kMinRowsFieldNumber = 8;
00281   inline ::google::protobuf::uint64 min_rows() const;
00282   inline void set_min_rows(::google::protobuf::uint64 value);
00283   
00284   // optional uint64 auto_increment_value = 9;
00285   inline bool has_auto_increment_value() const;
00286   inline void clear_auto_increment_value();
00287   static const int kAutoIncrementValueFieldNumber = 9;
00288   inline ::google::protobuf::uint64 auto_increment_value() const;
00289   inline void set_auto_increment_value(::google::protobuf::uint64 value);
00290   
00291   // optional uint32 avg_row_length = 11;
00292   inline bool has_avg_row_length() const;
00293   inline void clear_avg_row_length();
00294   static const int kAvgRowLengthFieldNumber = 11;
00295   inline ::google::protobuf::uint32 avg_row_length() const;
00296   inline void set_avg_row_length(::google::protobuf::uint32 value);
00297   
00298   // optional uint32 block_size = 13;
00299   inline bool has_block_size() const;
00300   inline void clear_block_size();
00301   static const int kBlockSizeFieldNumber = 13;
00302   inline ::google::protobuf::uint32 block_size() const;
00303   inline void set_block_size(::google::protobuf::uint32 value);
00304   
00305   // optional string comment = 14;
00306   inline bool has_comment() const;
00307   inline void clear_comment();
00308   static const int kCommentFieldNumber = 14;
00309   inline const ::std::string& comment() const;
00310   inline void set_comment(const ::std::string& value);
00311   inline void set_comment(const char* value);
00312   inline void set_comment(const char* value, size_t size);
00313   inline ::std::string* mutable_comment();
00314   
00315   // optional bool pack_record = 16;
00316   inline bool has_pack_record() const;
00317   inline void clear_pack_record();
00318   static const int kPackRecordFieldNumber = 16;
00319   inline bool pack_record() const;
00320   inline void set_pack_record(bool value);
00321   
00322   // optional bool checksum = 17;
00323   inline bool has_checksum() const;
00324   inline void clear_checksum();
00325   static const int kChecksumFieldNumber = 17;
00326   inline bool checksum() const;
00327   inline void set_checksum(bool value);
00328   
00329   // optional bool page_checksum = 18;
00330   inline bool has_page_checksum() const;
00331   inline void clear_page_checksum();
00332   static const int kPageChecksumFieldNumber = 18;
00333   inline bool page_checksum() const;
00334   inline void set_page_checksum(bool value);
00335   
00336   // optional bool delay_key_write = 19;
00337   inline bool has_delay_key_write() const;
00338   inline void clear_delay_key_write();
00339   static const int kDelayKeyWriteFieldNumber = 19;
00340   inline bool delay_key_write() const;
00341   inline void set_delay_key_write(bool value);
00342   
00343   // optional bool dont_replicate = 20;
00344   inline bool has_dont_replicate() const;
00345   inline void clear_dont_replicate();
00346   static const int kDontReplicateFieldNumber = 20;
00347   inline bool dont_replicate() const;
00348   inline void set_dont_replicate(bool value);
00349   
00350   // @@protoc_insertion_point(class_scope:drizzled.message.Table.TableOptions)
00351  private:
00352   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00353   mutable int _cached_size_;
00354   
00355   bool has_user_set_auto_increment_value_;
00356   ::std::string* collation_;
00357   static const ::std::string _default_collation_;
00358   ::google::protobuf::uint32 collation_id_;
00359   ::std::string* data_file_name_;
00360   static const ::std::string _default_data_file_name_;
00361   ::std::string* index_file_name_;
00362   static const ::std::string _default_index_file_name_;
00363   ::google::protobuf::uint64 max_rows_;
00364   ::google::protobuf::uint64 min_rows_;
00365   ::google::protobuf::uint64 auto_increment_value_;
00366   ::google::protobuf::uint32 avg_row_length_;
00367   ::google::protobuf::uint32 block_size_;
00368   ::std::string* comment_;
00369   static const ::std::string _default_comment_;
00370   bool pack_record_;
00371   bool checksum_;
00372   bool page_checksum_;
00373   bool delay_key_write_;
00374   bool dont_replicate_;
00375   friend void  protobuf_AddDesc_table_2eproto();
00376   friend void protobuf_AssignDesc_table_2eproto();
00377   friend void protobuf_ShutdownFile_table_2eproto();
00378   
00379   ::google::protobuf::uint32 _has_bits_[(16 + 31) / 32];
00380   
00381   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00382   inline bool _has_bit(int index) const {
00383     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00384   }
00385   inline void _set_bit(int index) {
00386     _has_bits_[index / 32] |= (1u << (index % 32));
00387   }
00388   inline void _clear_bit(int index) {
00389     _has_bits_[index / 32] &= ~(1u << (index % 32));
00390   }
00391   
00392   void InitAsDefaultInstance();
00393   static Table_TableOptions* default_instance_;
00394 };
00395 // -------------------------------------------------------------------
00396 
00397 class Table_ForeignKeyConstraint : public ::google::protobuf::Message {
00398  public:
00399   Table_ForeignKeyConstraint();
00400   virtual ~Table_ForeignKeyConstraint();
00401   
00402   Table_ForeignKeyConstraint(const Table_ForeignKeyConstraint& from);
00403   
00404   inline Table_ForeignKeyConstraint& operator=(const Table_ForeignKeyConstraint& from) {
00405     CopyFrom(from);
00406     return *this;
00407   }
00408   
00409   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00410     return _unknown_fields_;
00411   }
00412   
00413   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00414     return &_unknown_fields_;
00415   }
00416   
00417   static const ::google::protobuf::Descriptor* descriptor();
00418   static const Table_ForeignKeyConstraint& default_instance();
00419   
00420   void Swap(Table_ForeignKeyConstraint* other);
00421   
00422   // implements Message ----------------------------------------------
00423   
00424   Table_ForeignKeyConstraint* New() const;
00425   void CopyFrom(const ::google::protobuf::Message& from);
00426   void MergeFrom(const ::google::protobuf::Message& from);
00427   void CopyFrom(const Table_ForeignKeyConstraint& from);
00428   void MergeFrom(const Table_ForeignKeyConstraint& from);
00429   void Clear();
00430   bool IsInitialized() const;
00431   
00432   int ByteSize() const;
00433   bool MergePartialFromCodedStream(
00434       ::google::protobuf::io::CodedInputStream* input);
00435   void SerializeWithCachedSizes(
00436       ::google::protobuf::io::CodedOutputStream* output) const;
00437   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00438   int GetCachedSize() const { return _cached_size_; }
00439   private:
00440   void SharedCtor();
00441   void SharedDtor();
00442   void SetCachedSize(int size) const;
00443   public:
00444   
00445   ::google::protobuf::Metadata GetMetadata() const;
00446   
00447   // nested types ----------------------------------------------------
00448   
00449   typedef Table_ForeignKeyConstraint_ForeignKeyMatchOption ForeignKeyMatchOption;
00450   static const ForeignKeyMatchOption MATCH_UNDEFINED = Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_UNDEFINED;
00451   static const ForeignKeyMatchOption MATCH_FULL = Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_FULL;
00452   static const ForeignKeyMatchOption MATCH_PARTIAL = Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_PARTIAL;
00453   static const ForeignKeyMatchOption MATCH_SIMPLE = Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_SIMPLE;
00454   static inline bool ForeignKeyMatchOption_IsValid(int value) {
00455     return Table_ForeignKeyConstraint_ForeignKeyMatchOption_IsValid(value);
00456   }
00457   static const ForeignKeyMatchOption ForeignKeyMatchOption_MIN =
00458     Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_MIN;
00459   static const ForeignKeyMatchOption ForeignKeyMatchOption_MAX =
00460     Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_MAX;
00461   static const int ForeignKeyMatchOption_ARRAYSIZE =
00462     Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_ARRAYSIZE;
00463   static inline const ::google::protobuf::EnumDescriptor*
00464   ForeignKeyMatchOption_descriptor() {
00465     return Table_ForeignKeyConstraint_ForeignKeyMatchOption_descriptor();
00466   }
00467   static inline const ::std::string& ForeignKeyMatchOption_Name(ForeignKeyMatchOption value) {
00468     return Table_ForeignKeyConstraint_ForeignKeyMatchOption_Name(value);
00469   }
00470   static inline bool ForeignKeyMatchOption_Parse(const ::std::string& name,
00471       ForeignKeyMatchOption* value) {
00472     return Table_ForeignKeyConstraint_ForeignKeyMatchOption_Parse(name, value);
00473   }
00474   
00475   typedef Table_ForeignKeyConstraint_ForeignKeyOption ForeignKeyOption;
00476   static const ForeignKeyOption OPTION_UNDEF = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_UNDEF;
00477   static const ForeignKeyOption OPTION_RESTRICT = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_RESTRICT;
00478   static const ForeignKeyOption OPTION_CASCADE = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_CASCADE;
00479   static const ForeignKeyOption OPTION_SET_NULL = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_SET_NULL;
00480   static const ForeignKeyOption OPTION_NO_ACTION = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_NO_ACTION;
00481   static const ForeignKeyOption OPTION_SET_DEFAULT = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_SET_DEFAULT;
00482   static inline bool ForeignKeyOption_IsValid(int value) {
00483     return Table_ForeignKeyConstraint_ForeignKeyOption_IsValid(value);
00484   }
00485   static const ForeignKeyOption ForeignKeyOption_MIN =
00486     Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_MIN;
00487   static const ForeignKeyOption ForeignKeyOption_MAX =
00488     Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_MAX;
00489   static const int ForeignKeyOption_ARRAYSIZE =
00490     Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_ARRAYSIZE;
00491   static inline const ::google::protobuf::EnumDescriptor*
00492   ForeignKeyOption_descriptor() {
00493     return Table_ForeignKeyConstraint_ForeignKeyOption_descriptor();
00494   }
00495   static inline const ::std::string& ForeignKeyOption_Name(ForeignKeyOption value) {
00496     return Table_ForeignKeyConstraint_ForeignKeyOption_Name(value);
00497   }
00498   static inline bool ForeignKeyOption_Parse(const ::std::string& name,
00499       ForeignKeyOption* value) {
00500     return Table_ForeignKeyConstraint_ForeignKeyOption_Parse(name, value);
00501   }
00502   
00503   // accessors -------------------------------------------------------
00504   
00505   // optional string name = 1;
00506   inline bool has_name() const;
00507   inline void clear_name();
00508   static const int kNameFieldNumber = 1;
00509   inline const ::std::string& name() const;
00510   inline void set_name(const ::std::string& value);
00511   inline void set_name(const char* value);
00512   inline void set_name(const char* value, size_t size);
00513   inline ::std::string* mutable_name();
00514   
00515   // repeated string column_names = 2;
00516   inline int column_names_size() const;
00517   inline void clear_column_names();
00518   static const int kColumnNamesFieldNumber = 2;
00519   inline const ::std::string& column_names(int index) const;
00520   inline ::std::string* mutable_column_names(int index);
00521   inline void set_column_names(int index, const ::std::string& value);
00522   inline void set_column_names(int index, const char* value);
00523   inline void set_column_names(int index, const char* value, size_t size);
00524   inline ::std::string* add_column_names();
00525   inline void add_column_names(const ::std::string& value);
00526   inline void add_column_names(const char* value);
00527   inline void add_column_names(const char* value, size_t size);
00528   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& column_names() const;
00529   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_column_names();
00530   
00531   // required string references_table_name = 3;
00532   inline bool has_references_table_name() const;
00533   inline void clear_references_table_name();
00534   static const int kReferencesTableNameFieldNumber = 3;
00535   inline const ::std::string& references_table_name() const;
00536   inline void set_references_table_name(const ::std::string& value);
00537   inline void set_references_table_name(const char* value);
00538   inline void set_references_table_name(const char* value, size_t size);
00539   inline ::std::string* mutable_references_table_name();
00540   
00541   // repeated string references_columns = 4;
00542   inline int references_columns_size() const;
00543   inline void clear_references_columns();
00544   static const int kReferencesColumnsFieldNumber = 4;
00545   inline const ::std::string& references_columns(int index) const;
00546   inline ::std::string* mutable_references_columns(int index);
00547   inline void set_references_columns(int index, const ::std::string& value);
00548   inline void set_references_columns(int index, const char* value);
00549   inline void set_references_columns(int index, const char* value, size_t size);
00550   inline ::std::string* add_references_columns();
00551   inline void add_references_columns(const ::std::string& value);
00552   inline void add_references_columns(const char* value);
00553   inline void add_references_columns(const char* value, size_t size);
00554   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& references_columns() const;
00555   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_references_columns();
00556   
00557   // required .drizzled.message.Table.ForeignKeyConstraint.ForeignKeyMatchOption match = 5;
00558   inline bool has_match() const;
00559   inline void clear_match();
00560   static const int kMatchFieldNumber = 5;
00561   inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption match() const;
00562   inline void set_match(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption value);
00563   
00564   // required .drizzled.message.Table.ForeignKeyConstraint.ForeignKeyOption update_option = 6 [default = OPTION_UNDEF];
00565   inline bool has_update_option() const;
00566   inline void clear_update_option();
00567   static const int kUpdateOptionFieldNumber = 6;
00568   inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption update_option() const;
00569   inline void set_update_option(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption value);
00570   
00571   // required .drizzled.message.Table.ForeignKeyConstraint.ForeignKeyOption delete_option = 7 [default = OPTION_UNDEF];
00572   inline bool has_delete_option() const;
00573   inline void clear_delete_option();
00574   static const int kDeleteOptionFieldNumber = 7;
00575   inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption delete_option() const;
00576   inline void set_delete_option(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption value);
00577   
00578   // @@protoc_insertion_point(class_scope:drizzled.message.Table.ForeignKeyConstraint)
00579  private:
00580   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00581   mutable int _cached_size_;
00582   
00583   ::std::string* name_;
00584   static const ::std::string _default_name_;
00585   ::google::protobuf::RepeatedPtrField< ::std::string> column_names_;
00586   ::std::string* references_table_name_;
00587   static const ::std::string _default_references_table_name_;
00588   ::google::protobuf::RepeatedPtrField< ::std::string> references_columns_;
00589   int match_;
00590   int update_option_;
00591   int delete_option_;
00592   friend void  protobuf_AddDesc_table_2eproto();
00593   friend void protobuf_AssignDesc_table_2eproto();
00594   friend void protobuf_ShutdownFile_table_2eproto();
00595   
00596   ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
00597   
00598   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00599   inline bool _has_bit(int index) const {
00600     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00601   }
00602   inline void _set_bit(int index) {
00603     _has_bits_[index / 32] |= (1u << (index % 32));
00604   }
00605   inline void _clear_bit(int index) {
00606     _has_bits_[index / 32] &= ~(1u << (index % 32));
00607   }
00608   
00609   void InitAsDefaultInstance();
00610   static Table_ForeignKeyConstraint* default_instance_;
00611 };
00612 // -------------------------------------------------------------------
00613 
00614 class Table_Field_FieldOptions : public ::google::protobuf::Message {
00615  public:
00616   Table_Field_FieldOptions();
00617   virtual ~Table_Field_FieldOptions();
00618   
00619   Table_Field_FieldOptions(const Table_Field_FieldOptions& from);
00620   
00621   inline Table_Field_FieldOptions& operator=(const Table_Field_FieldOptions& from) {
00622     CopyFrom(from);
00623     return *this;
00624   }
00625   
00626   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00627     return _unknown_fields_;
00628   }
00629   
00630   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00631     return &_unknown_fields_;
00632   }
00633   
00634   static const ::google::protobuf::Descriptor* descriptor();
00635   static const Table_Field_FieldOptions& default_instance();
00636   
00637   void Swap(Table_Field_FieldOptions* other);
00638   
00639   // implements Message ----------------------------------------------
00640   
00641   Table_Field_FieldOptions* New() const;
00642   void CopyFrom(const ::google::protobuf::Message& from);
00643   void MergeFrom(const ::google::protobuf::Message& from);
00644   void CopyFrom(const Table_Field_FieldOptions& from);
00645   void MergeFrom(const Table_Field_FieldOptions& from);
00646   void Clear();
00647   bool IsInitialized() const;
00648   
00649   int ByteSize() const;
00650   bool MergePartialFromCodedStream(
00651       ::google::protobuf::io::CodedInputStream* input);
00652   void SerializeWithCachedSizes(
00653       ::google::protobuf::io::CodedOutputStream* output) const;
00654   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00655   int GetCachedSize() const { return _cached_size_; }
00656   private:
00657   void SharedCtor();
00658   void SharedDtor();
00659   void SetCachedSize(int size) const;
00660   public:
00661   
00662   ::google::protobuf::Metadata GetMetadata() const;
00663   
00664   // nested types ----------------------------------------------------
00665   
00666   // accessors -------------------------------------------------------
00667   
00668   // optional string default_value = 1;
00669   inline bool has_default_value() const;
00670   inline void clear_default_value();
00671   static const int kDefaultValueFieldNumber = 1;
00672   inline const ::std::string& default_value() const;
00673   inline void set_default_value(const ::std::string& value);
00674   inline void set_default_value(const char* value);
00675   inline void set_default_value(const char* value, size_t size);
00676   inline ::std::string* mutable_default_value();
00677   
00678   // optional string update_value = 2;
00679   inline bool has_update_value() const;
00680   inline void clear_update_value();
00681   static const int kUpdateValueFieldNumber = 2;
00682   inline const ::std::string& update_value() const;
00683   inline void set_update_value(const ::std::string& value);
00684   inline void set_update_value(const char* value);
00685   inline void set_update_value(const char* value, size_t size);
00686   inline ::std::string* mutable_update_value();
00687   
00688   // optional bool default_null = 3 [default = false];
00689   inline bool has_default_null() const;
00690   inline void clear_default_null();
00691   static const int kDefaultNullFieldNumber = 3;
00692   inline bool default_null() const;
00693   inline void set_default_null(bool value);
00694   
00695   // optional bytes default_bin_value = 4;
00696   inline bool has_default_bin_value() const;
00697   inline void clear_default_bin_value();
00698   static const int kDefaultBinValueFieldNumber = 4;
00699   inline const ::std::string& default_bin_value() const;
00700   inline void set_default_bin_value(const ::std::string& value);
00701   inline void set_default_bin_value(const char* value);
00702   inline void set_default_bin_value(const void* value, size_t size);
00703   inline ::std::string* mutable_default_bin_value();
00704   
00705   // optional string default_expression = 5;
00706   inline bool has_default_expression() const;
00707   inline void clear_default_expression();
00708   static const int kDefaultExpressionFieldNumber = 5;
00709   inline const ::std::string& default_expression() const;
00710   inline void set_default_expression(const ::std::string& value);
00711   inline void set_default_expression(const char* value);
00712   inline void set_default_expression(const char* value, size_t size);
00713   inline ::std::string* mutable_default_expression();
00714   
00715   // optional string update_expression = 6;
00716   inline bool has_update_expression() const;
00717   inline void clear_update_expression();
00718   static const int kUpdateExpressionFieldNumber = 6;
00719   inline const ::std::string& update_expression() const;
00720   inline void set_update_expression(const ::std::string& value);
00721   inline void set_update_expression(const char* value);
00722   inline void set_update_expression(const char* value, size_t size);
00723   inline ::std::string* mutable_update_expression();
00724   
00725   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.FieldOptions)
00726  private:
00727   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00728   mutable int _cached_size_;
00729   
00730   ::std::string* default_value_;
00731   static const ::std::string _default_default_value_;
00732   ::std::string* update_value_;
00733   static const ::std::string _default_update_value_;
00734   bool default_null_;
00735   ::std::string* default_bin_value_;
00736   static const ::std::string _default_default_bin_value_;
00737   ::std::string* default_expression_;
00738   static const ::std::string _default_default_expression_;
00739   ::std::string* update_expression_;
00740   static const ::std::string _default_update_expression_;
00741   friend void  protobuf_AddDesc_table_2eproto();
00742   friend void protobuf_AssignDesc_table_2eproto();
00743   friend void protobuf_ShutdownFile_table_2eproto();
00744   
00745   ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
00746   
00747   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00748   inline bool _has_bit(int index) const {
00749     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00750   }
00751   inline void _set_bit(int index) {
00752     _has_bits_[index / 32] |= (1u << (index % 32));
00753   }
00754   inline void _clear_bit(int index) {
00755     _has_bits_[index / 32] &= ~(1u << (index % 32));
00756   }
00757   
00758   void InitAsDefaultInstance();
00759   static Table_Field_FieldOptions* default_instance_;
00760 };
00761 // -------------------------------------------------------------------
00762 
00763 class Table_Field_FieldConstraints : public ::google::protobuf::Message {
00764  public:
00765   Table_Field_FieldConstraints();
00766   virtual ~Table_Field_FieldConstraints();
00767   
00768   Table_Field_FieldConstraints(const Table_Field_FieldConstraints& from);
00769   
00770   inline Table_Field_FieldConstraints& operator=(const Table_Field_FieldConstraints& from) {
00771     CopyFrom(from);
00772     return *this;
00773   }
00774   
00775   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00776     return _unknown_fields_;
00777   }
00778   
00779   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00780     return &_unknown_fields_;
00781   }
00782   
00783   static const ::google::protobuf::Descriptor* descriptor();
00784   static const Table_Field_FieldConstraints& default_instance();
00785   
00786   void Swap(Table_Field_FieldConstraints* other);
00787   
00788   // implements Message ----------------------------------------------
00789   
00790   Table_Field_FieldConstraints* New() const;
00791   void CopyFrom(const ::google::protobuf::Message& from);
00792   void MergeFrom(const ::google::protobuf::Message& from);
00793   void CopyFrom(const Table_Field_FieldConstraints& from);
00794   void MergeFrom(const Table_Field_FieldConstraints& from);
00795   void Clear();
00796   bool IsInitialized() const;
00797   
00798   int ByteSize() const;
00799   bool MergePartialFromCodedStream(
00800       ::google::protobuf::io::CodedInputStream* input);
00801   void SerializeWithCachedSizes(
00802       ::google::protobuf::io::CodedOutputStream* output) const;
00803   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00804   int GetCachedSize() const { return _cached_size_; }
00805   private:
00806   void SharedCtor();
00807   void SharedDtor();
00808   void SetCachedSize(int size) const;
00809   public:
00810   
00811   ::google::protobuf::Metadata GetMetadata() const;
00812   
00813   // nested types ----------------------------------------------------
00814   
00815   // accessors -------------------------------------------------------
00816   
00817   // optional bool is_nullable = 1 [default = true];
00818   inline bool has_is_nullable() const;
00819   inline void clear_is_nullable();
00820   static const int kIsNullableFieldNumber = 1;
00821   inline bool is_nullable() const;
00822   inline void set_is_nullable(bool value);
00823   
00824   // optional bool is_unsigned = 2 [default = false];
00825   inline bool has_is_unsigned() const;
00826   inline void clear_is_unsigned();
00827   static const int kIsUnsignedFieldNumber = 2;
00828   inline bool is_unsigned() const;
00829   inline void set_is_unsigned(bool value);
00830   
00831   // optional bool is_notnull = 3 [default = false];
00832   inline bool has_is_notnull() const;
00833   inline void clear_is_notnull();
00834   static const int kIsNotnullFieldNumber = 3;
00835   inline bool is_notnull() const;
00836   inline void set_is_notnull(bool value);
00837   
00838   // optional bool is_unique = 4 [default = false];
00839   inline bool has_is_unique() const;
00840   inline void clear_is_unique();
00841   static const int kIsUniqueFieldNumber = 4;
00842   inline bool is_unique() const;
00843   inline void set_is_unique(bool value);
00844   
00845   // repeated string expression = 16;
00846   inline int expression_size() const;
00847   inline void clear_expression();
00848   static const int kExpressionFieldNumber = 16;
00849   inline const ::std::string& expression(int index) const;
00850   inline ::std::string* mutable_expression(int index);
00851   inline void set_expression(int index, const ::std::string& value);
00852   inline void set_expression(int index, const char* value);
00853   inline void set_expression(int index, const char* value, size_t size);
00854   inline ::std::string* add_expression();
00855   inline void add_expression(const ::std::string& value);
00856   inline void add_expression(const char* value);
00857   inline void add_expression(const char* value, size_t size);
00858   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& expression() const;
00859   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_expression();
00860   
00861   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.FieldConstraints)
00862  private:
00863   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00864   mutable int _cached_size_;
00865   
00866   bool is_nullable_;
00867   bool is_unsigned_;
00868   bool is_notnull_;
00869   bool is_unique_;
00870   ::google::protobuf::RepeatedPtrField< ::std::string> expression_;
00871   friend void  protobuf_AddDesc_table_2eproto();
00872   friend void protobuf_AssignDesc_table_2eproto();
00873   friend void protobuf_ShutdownFile_table_2eproto();
00874   
00875   ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
00876   
00877   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00878   inline bool _has_bit(int index) const {
00879     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00880   }
00881   inline void _set_bit(int index) {
00882     _has_bits_[index / 32] |= (1u << (index % 32));
00883   }
00884   inline void _clear_bit(int index) {
00885     _has_bits_[index / 32] &= ~(1u << (index % 32));
00886   }
00887   
00888   void InitAsDefaultInstance();
00889   static Table_Field_FieldConstraints* default_instance_;
00890 };
00891 // -------------------------------------------------------------------
00892 
00893 class Table_Field_NumericFieldOptions : public ::google::protobuf::Message {
00894  public:
00895   Table_Field_NumericFieldOptions();
00896   virtual ~Table_Field_NumericFieldOptions();
00897   
00898   Table_Field_NumericFieldOptions(const Table_Field_NumericFieldOptions& from);
00899   
00900   inline Table_Field_NumericFieldOptions& operator=(const Table_Field_NumericFieldOptions& from) {
00901     CopyFrom(from);
00902     return *this;
00903   }
00904   
00905   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00906     return _unknown_fields_;
00907   }
00908   
00909   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00910     return &_unknown_fields_;
00911   }
00912   
00913   static const ::google::protobuf::Descriptor* descriptor();
00914   static const Table_Field_NumericFieldOptions& default_instance();
00915   
00916   void Swap(Table_Field_NumericFieldOptions* other);
00917   
00918   // implements Message ----------------------------------------------
00919   
00920   Table_Field_NumericFieldOptions* New() const;
00921   void CopyFrom(const ::google::protobuf::Message& from);
00922   void MergeFrom(const ::google::protobuf::Message& from);
00923   void CopyFrom(const Table_Field_NumericFieldOptions& from);
00924   void MergeFrom(const Table_Field_NumericFieldOptions& from);
00925   void Clear();
00926   bool IsInitialized() const;
00927   
00928   int ByteSize() const;
00929   bool MergePartialFromCodedStream(
00930       ::google::protobuf::io::CodedInputStream* input);
00931   void SerializeWithCachedSizes(
00932       ::google::protobuf::io::CodedOutputStream* output) const;
00933   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00934   int GetCachedSize() const { return _cached_size_; }
00935   private:
00936   void SharedCtor();
00937   void SharedDtor();
00938   void SetCachedSize(int size) const;
00939   public:
00940   
00941   ::google::protobuf::Metadata GetMetadata() const;
00942   
00943   // nested types ----------------------------------------------------
00944   
00945   // accessors -------------------------------------------------------
00946   
00947   // optional bool is_autoincrement = 1 [default = false];
00948   inline bool has_is_autoincrement() const;
00949   inline void clear_is_autoincrement();
00950   static const int kIsAutoincrementFieldNumber = 1;
00951   inline bool is_autoincrement() const;
00952   inline void set_is_autoincrement(bool value);
00953   
00954   // optional uint32 scale = 2;
00955   inline bool has_scale() const;
00956   inline void clear_scale();
00957   static const int kScaleFieldNumber = 2;
00958   inline ::google::protobuf::uint32 scale() const;
00959   inline void set_scale(::google::protobuf::uint32 value);
00960   
00961   // optional uint32 precision = 3;
00962   inline bool has_precision() const;
00963   inline void clear_precision();
00964   static const int kPrecisionFieldNumber = 3;
00965   inline ::google::protobuf::uint32 precision() const;
00966   inline void set_precision(::google::protobuf::uint32 value);
00967   
00968   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.NumericFieldOptions)
00969  private:
00970   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00971   mutable int _cached_size_;
00972   
00973   bool is_autoincrement_;
00974   ::google::protobuf::uint32 scale_;
00975   ::google::protobuf::uint32 precision_;
00976   friend void  protobuf_AddDesc_table_2eproto();
00977   friend void protobuf_AssignDesc_table_2eproto();
00978   friend void protobuf_ShutdownFile_table_2eproto();
00979   
00980   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
00981   
00982   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00983   inline bool _has_bit(int index) const {
00984     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00985   }
00986   inline void _set_bit(int index) {
00987     _has_bits_[index / 32] |= (1u << (index % 32));
00988   }
00989   inline void _clear_bit(int index) {
00990     _has_bits_[index / 32] &= ~(1u << (index % 32));
00991   }
00992   
00993   void InitAsDefaultInstance();
00994   static Table_Field_NumericFieldOptions* default_instance_;
00995 };
00996 // -------------------------------------------------------------------
00997 
00998 class Table_Field_StringFieldOptions : public ::google::protobuf::Message {
00999  public:
01000   Table_Field_StringFieldOptions();
01001   virtual ~Table_Field_StringFieldOptions();
01002   
01003   Table_Field_StringFieldOptions(const Table_Field_StringFieldOptions& from);
01004   
01005   inline Table_Field_StringFieldOptions& operator=(const Table_Field_StringFieldOptions& from) {
01006     CopyFrom(from);
01007     return *this;
01008   }
01009   
01010   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01011     return _unknown_fields_;
01012   }
01013   
01014   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01015     return &_unknown_fields_;
01016   }
01017   
01018   static const ::google::protobuf::Descriptor* descriptor();
01019   static const Table_Field_StringFieldOptions& default_instance();
01020   
01021   void Swap(Table_Field_StringFieldOptions* other);
01022   
01023   // implements Message ----------------------------------------------
01024   
01025   Table_Field_StringFieldOptions* New() const;
01026   void CopyFrom(const ::google::protobuf::Message& from);
01027   void MergeFrom(const ::google::protobuf::Message& from);
01028   void CopyFrom(const Table_Field_StringFieldOptions& from);
01029   void MergeFrom(const Table_Field_StringFieldOptions& from);
01030   void Clear();
01031   bool IsInitialized() const;
01032   
01033   int ByteSize() const;
01034   bool MergePartialFromCodedStream(
01035       ::google::protobuf::io::CodedInputStream* input);
01036   void SerializeWithCachedSizes(
01037       ::google::protobuf::io::CodedOutputStream* output) const;
01038   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01039   int GetCachedSize() const { return _cached_size_; }
01040   private:
01041   void SharedCtor();
01042   void SharedDtor();
01043   void SetCachedSize(int size) const;
01044   public:
01045   
01046   ::google::protobuf::Metadata GetMetadata() const;
01047   
01048   // nested types ----------------------------------------------------
01049   
01050   // accessors -------------------------------------------------------
01051   
01052   // optional bool is_fixed_width = 1 [default = false];
01053   inline bool has_is_fixed_width() const;
01054   inline void clear_is_fixed_width();
01055   static const int kIsFixedWidthFieldNumber = 1;
01056   inline bool is_fixed_width() const;
01057   inline void set_is_fixed_width(bool value);
01058   
01059   // optional uint32 length = 2;
01060   inline bool has_length() const;
01061   inline void clear_length();
01062   static const int kLengthFieldNumber = 2;
01063   inline ::google::protobuf::uint32 length() const;
01064   inline void set_length(::google::protobuf::uint32 value);
01065   
01066   // optional uint32 collation_id = 3;
01067   inline bool has_collation_id() const;
01068   inline void clear_collation_id();
01069   static const int kCollationIdFieldNumber = 3;
01070   inline ::google::protobuf::uint32 collation_id() const;
01071   inline void set_collation_id(::google::protobuf::uint32 value);
01072   
01073   // optional string collation = 4;
01074   inline bool has_collation() const;
01075   inline void clear_collation();
01076   static const int kCollationFieldNumber = 4;
01077   inline const ::std::string& collation() const;
01078   inline void set_collation(const ::std::string& value);
01079   inline void set_collation(const char* value);
01080   inline void set_collation(const char* value, size_t size);
01081   inline ::std::string* mutable_collation();
01082   
01083   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.StringFieldOptions)
01084  private:
01085   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01086   mutable int _cached_size_;
01087   
01088   bool is_fixed_width_;
01089   ::google::protobuf::uint32 length_;
01090   ::google::protobuf::uint32 collation_id_;
01091   ::std::string* collation_;
01092   static const ::std::string _default_collation_;
01093   friend void  protobuf_AddDesc_table_2eproto();
01094   friend void protobuf_AssignDesc_table_2eproto();
01095   friend void protobuf_ShutdownFile_table_2eproto();
01096   
01097   ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
01098   
01099   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01100   inline bool _has_bit(int index) const {
01101     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01102   }
01103   inline void _set_bit(int index) {
01104     _has_bits_[index / 32] |= (1u << (index % 32));
01105   }
01106   inline void _clear_bit(int index) {
01107     _has_bits_[index / 32] &= ~(1u << (index % 32));
01108   }
01109   
01110   void InitAsDefaultInstance();
01111   static Table_Field_StringFieldOptions* default_instance_;
01112 };
01113 // -------------------------------------------------------------------
01114 
01115 class Table_Field_EnumerationValues : public ::google::protobuf::Message {
01116  public:
01117   Table_Field_EnumerationValues();
01118   virtual ~Table_Field_EnumerationValues();
01119   
01120   Table_Field_EnumerationValues(const Table_Field_EnumerationValues& from);
01121   
01122   inline Table_Field_EnumerationValues& operator=(const Table_Field_EnumerationValues& from) {
01123     CopyFrom(from);
01124     return *this;
01125   }
01126   
01127   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01128     return _unknown_fields_;
01129   }
01130   
01131   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01132     return &_unknown_fields_;
01133   }
01134   
01135   static const ::google::protobuf::Descriptor* descriptor();
01136   static const Table_Field_EnumerationValues& default_instance();
01137   
01138   void Swap(Table_Field_EnumerationValues* other);
01139   
01140   // implements Message ----------------------------------------------
01141   
01142   Table_Field_EnumerationValues* New() const;
01143   void CopyFrom(const ::google::protobuf::Message& from);
01144   void MergeFrom(const ::google::protobuf::Message& from);
01145   void CopyFrom(const Table_Field_EnumerationValues& from);
01146   void MergeFrom(const Table_Field_EnumerationValues& from);
01147   void Clear();
01148   bool IsInitialized() const;
01149   
01150   int ByteSize() const;
01151   bool MergePartialFromCodedStream(
01152       ::google::protobuf::io::CodedInputStream* input);
01153   void SerializeWithCachedSizes(
01154       ::google::protobuf::io::CodedOutputStream* output) const;
01155   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01156   int GetCachedSize() const { return _cached_size_; }
01157   private:
01158   void SharedCtor();
01159   void SharedDtor();
01160   void SetCachedSize(int size) const;
01161   public:
01162   
01163   ::google::protobuf::Metadata GetMetadata() const;
01164   
01165   // nested types ----------------------------------------------------
01166   
01167   // accessors -------------------------------------------------------
01168   
01169   // optional uint32 collation_id = 2;
01170   inline bool has_collation_id() const;
01171   inline void clear_collation_id();
01172   static const int kCollationIdFieldNumber = 2;
01173   inline ::google::protobuf::uint32 collation_id() const;
01174   inline void set_collation_id(::google::protobuf::uint32 value);
01175   
01176   // optional string collation = 3;
01177   inline bool has_collation() const;
01178   inline void clear_collation();
01179   static const int kCollationFieldNumber = 3;
01180   inline const ::std::string& collation() const;
01181   inline void set_collation(const ::std::string& value);
01182   inline void set_collation(const char* value);
01183   inline void set_collation(const char* value, size_t size);
01184   inline ::std::string* mutable_collation();
01185   
01186   // repeated string field_value = 4;
01187   inline int field_value_size() const;
01188   inline void clear_field_value();
01189   static const int kFieldValueFieldNumber = 4;
01190   inline const ::std::string& field_value(int index) const;
01191   inline ::std::string* mutable_field_value(int index);
01192   inline void set_field_value(int index, const ::std::string& value);
01193   inline void set_field_value(int index, const char* value);
01194   inline void set_field_value(int index, const char* value, size_t size);
01195   inline ::std::string* add_field_value();
01196   inline void add_field_value(const ::std::string& value);
01197   inline void add_field_value(const char* value);
01198   inline void add_field_value(const char* value, size_t size);
01199   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& field_value() const;
01200   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_field_value();
01201   
01202   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.EnumerationValues)
01203  private:
01204   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01205   mutable int _cached_size_;
01206   
01207   ::google::protobuf::uint32 collation_id_;
01208   ::std::string* collation_;
01209   static const ::std::string _default_collation_;
01210   ::google::protobuf::RepeatedPtrField< ::std::string> field_value_;
01211   friend void  protobuf_AddDesc_table_2eproto();
01212   friend void protobuf_AssignDesc_table_2eproto();
01213   friend void protobuf_ShutdownFile_table_2eproto();
01214   
01215   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
01216   
01217   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01218   inline bool _has_bit(int index) const {
01219     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01220   }
01221   inline void _set_bit(int index) {
01222     _has_bits_[index / 32] |= (1u << (index % 32));
01223   }
01224   inline void _clear_bit(int index) {
01225     _has_bits_[index / 32] &= ~(1u << (index % 32));
01226   }
01227   
01228   void InitAsDefaultInstance();
01229   static Table_Field_EnumerationValues* default_instance_;
01230 };
01231 // -------------------------------------------------------------------
01232 
01233 class Table_Field_TimeFieldOptions : public ::google::protobuf::Message {
01234  public:
01235   Table_Field_TimeFieldOptions();
01236   virtual ~Table_Field_TimeFieldOptions();
01237   
01238   Table_Field_TimeFieldOptions(const Table_Field_TimeFieldOptions& from);
01239   
01240   inline Table_Field_TimeFieldOptions& operator=(const Table_Field_TimeFieldOptions& from) {
01241     CopyFrom(from);
01242     return *this;
01243   }
01244   
01245   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01246     return _unknown_fields_;
01247   }
01248   
01249   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01250     return &_unknown_fields_;
01251   }
01252   
01253   static const ::google::protobuf::Descriptor* descriptor();
01254   static const Table_Field_TimeFieldOptions& default_instance();
01255   
01256   void Swap(Table_Field_TimeFieldOptions* other);
01257   
01258   // implements Message ----------------------------------------------
01259   
01260   Table_Field_TimeFieldOptions* New() const;
01261   void CopyFrom(const ::google::protobuf::Message& from);
01262   void MergeFrom(const ::google::protobuf::Message& from);
01263   void CopyFrom(const Table_Field_TimeFieldOptions& from);
01264   void MergeFrom(const Table_Field_TimeFieldOptions& from);
01265   void Clear();
01266   bool IsInitialized() const;
01267   
01268   int ByteSize() const;
01269   bool MergePartialFromCodedStream(
01270       ::google::protobuf::io::CodedInputStream* input);
01271   void SerializeWithCachedSizes(
01272       ::google::protobuf::io::CodedOutputStream* output) const;
01273   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01274   int GetCachedSize() const { return _cached_size_; }
01275   private:
01276   void SharedCtor();
01277   void SharedDtor();
01278   void SetCachedSize(int size) const;
01279   public:
01280   
01281   ::google::protobuf::Metadata GetMetadata() const;
01282   
01283   // nested types ----------------------------------------------------
01284   
01285   // accessors -------------------------------------------------------
01286   
01287   // optional bool microseconds = 1;
01288   inline bool has_microseconds() const;
01289   inline void clear_microseconds();
01290   static const int kMicrosecondsFieldNumber = 1;
01291   inline bool microseconds() const;
01292   inline void set_microseconds(bool value);
01293   
01294   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.TimeFieldOptions)
01295  private:
01296   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01297   mutable int _cached_size_;
01298   
01299   bool microseconds_;
01300   friend void  protobuf_AddDesc_table_2eproto();
01301   friend void protobuf_AssignDesc_table_2eproto();
01302   friend void protobuf_ShutdownFile_table_2eproto();
01303   
01304   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
01305   
01306   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01307   inline bool _has_bit(int index) const {
01308     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01309   }
01310   inline void _set_bit(int index) {
01311     _has_bits_[index / 32] |= (1u << (index % 32));
01312   }
01313   inline void _clear_bit(int index) {
01314     _has_bits_[index / 32] &= ~(1u << (index % 32));
01315   }
01316   
01317   void InitAsDefaultInstance();
01318   static Table_Field_TimeFieldOptions* default_instance_;
01319 };
01320 // -------------------------------------------------------------------
01321 
01322 class Table_Field : public ::google::protobuf::Message {
01323  public:
01324   Table_Field();
01325   virtual ~Table_Field();
01326   
01327   Table_Field(const Table_Field& from);
01328   
01329   inline Table_Field& operator=(const Table_Field& from) {
01330     CopyFrom(from);
01331     return *this;
01332   }
01333   
01334   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01335     return _unknown_fields_;
01336   }
01337   
01338   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01339     return &_unknown_fields_;
01340   }
01341   
01342   static const ::google::protobuf::Descriptor* descriptor();
01343   static const Table_Field& default_instance();
01344   
01345   void Swap(Table_Field* other);
01346   
01347   // implements Message ----------------------------------------------
01348   
01349   Table_Field* New() const;
01350   void CopyFrom(const ::google::protobuf::Message& from);
01351   void MergeFrom(const ::google::protobuf::Message& from);
01352   void CopyFrom(const Table_Field& from);
01353   void MergeFrom(const Table_Field& from);
01354   void Clear();
01355   bool IsInitialized() const;
01356   
01357   int ByteSize() const;
01358   bool MergePartialFromCodedStream(
01359       ::google::protobuf::io::CodedInputStream* input);
01360   void SerializeWithCachedSizes(
01361       ::google::protobuf::io::CodedOutputStream* output) const;
01362   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01363   int GetCachedSize() const { return _cached_size_; }
01364   private:
01365   void SharedCtor();
01366   void SharedDtor();
01367   void SetCachedSize(int size) const;
01368   public:
01369   
01370   ::google::protobuf::Metadata GetMetadata() const;
01371   
01372   // nested types ----------------------------------------------------
01373   
01374   typedef Table_Field_FieldOptions FieldOptions;
01375   typedef Table_Field_FieldConstraints FieldConstraints;
01376   typedef Table_Field_NumericFieldOptions NumericFieldOptions;
01377   typedef Table_Field_StringFieldOptions StringFieldOptions;
01378   typedef Table_Field_EnumerationValues EnumerationValues;
01379   typedef Table_Field_TimeFieldOptions TimeFieldOptions;
01380   
01381   typedef Table_Field_FieldType FieldType;
01382   static const FieldType DOUBLE = Table_Field_FieldType_DOUBLE;
01383   static const FieldType VARCHAR = Table_Field_FieldType_VARCHAR;
01384   static const FieldType BLOB = Table_Field_FieldType_BLOB;
01385   static const FieldType ENUM = Table_Field_FieldType_ENUM;
01386   static const FieldType INTEGER = Table_Field_FieldType_INTEGER;
01387   static const FieldType BIGINT = Table_Field_FieldType_BIGINT;
01388   static const FieldType DECIMAL = Table_Field_FieldType_DECIMAL;
01389   static const FieldType DATE = Table_Field_FieldType_DATE;
01390   static const FieldType EPOCH = Table_Field_FieldType_EPOCH;
01391   static const FieldType DATETIME = Table_Field_FieldType_DATETIME;
01392   static const FieldType UUID = Table_Field_FieldType_UUID;
01393   static const FieldType TIME = Table_Field_FieldType_TIME;
01394   static const FieldType BOOLEAN = Table_Field_FieldType_BOOLEAN;
01395   static inline bool FieldType_IsValid(int value) {
01396     return Table_Field_FieldType_IsValid(value);
01397   }
01398   static const FieldType FieldType_MIN =
01399     Table_Field_FieldType_FieldType_MIN;
01400   static const FieldType FieldType_MAX =
01401     Table_Field_FieldType_FieldType_MAX;
01402   static const int FieldType_ARRAYSIZE =
01403     Table_Field_FieldType_FieldType_ARRAYSIZE;
01404   static inline const ::google::protobuf::EnumDescriptor*
01405   FieldType_descriptor() {
01406     return Table_Field_FieldType_descriptor();
01407   }
01408   static inline const ::std::string& FieldType_Name(FieldType value) {
01409     return Table_Field_FieldType_Name(value);
01410   }
01411   static inline bool FieldType_Parse(const ::std::string& name,
01412       FieldType* value) {
01413     return Table_Field_FieldType_Parse(name, value);
01414   }
01415   
01416   // accessors -------------------------------------------------------
01417   
01418   // required string name = 1;
01419   inline bool has_name() const;
01420   inline void clear_name();
01421   static const int kNameFieldNumber = 1;
01422   inline const ::std::string& name() const;
01423   inline void set_name(const ::std::string& value);
01424   inline void set_name(const char* value);
01425   inline void set_name(const char* value, size_t size);
01426   inline ::std::string* mutable_name();
01427   
01428   // required .drizzled.message.Table.Field.FieldType type = 2;
01429   inline bool has_type() const;
01430   inline void clear_type();
01431   static const int kTypeFieldNumber = 2;
01432   inline ::drizzled::message::Table_Field_FieldType type() const;
01433   inline void set_type(::drizzled::message::Table_Field_FieldType value);
01434   
01435   // optional .drizzled.message.Table.Field.FieldOptions options = 4;
01436   inline bool has_options() const;
01437   inline void clear_options();
01438   static const int kOptionsFieldNumber = 4;
01439   inline const ::drizzled::message::Table_Field_FieldOptions& options() const;
01440   inline ::drizzled::message::Table_Field_FieldOptions* mutable_options();
01441   
01442   // optional .drizzled.message.Table.Field.FieldConstraints constraints = 5;
01443   inline bool has_constraints() const;
01444   inline void clear_constraints();
01445   static const int kConstraintsFieldNumber = 5;
01446   inline const ::drizzled::message::Table_Field_FieldConstraints& constraints() const;
01447   inline ::drizzled::message::Table_Field_FieldConstraints* mutable_constraints();
01448   
01449   // optional .drizzled.message.Table.Field.NumericFieldOptions numeric_options = 6;
01450   inline bool has_numeric_options() const;
01451   inline void clear_numeric_options();
01452   static const int kNumericOptionsFieldNumber = 6;
01453   inline const ::drizzled::message::Table_Field_NumericFieldOptions& numeric_options() const;
01454   inline ::drizzled::message::Table_Field_NumericFieldOptions* mutable_numeric_options();
01455   
01456   // optional .drizzled.message.Table.Field.StringFieldOptions string_options = 7;
01457   inline bool has_string_options() const;
01458   inline void clear_string_options();
01459   static const int kStringOptionsFieldNumber = 7;
01460   inline const ::drizzled::message::Table_Field_StringFieldOptions& string_options() const;
01461   inline ::drizzled::message::Table_Field_StringFieldOptions* mutable_string_options();
01462   
01463   // optional .drizzled.message.Table.Field.TimeFieldOptions time_options = 8;
01464   inline bool has_time_options() const;
01465   inline void clear_time_options();
01466   static const int kTimeOptionsFieldNumber = 8;
01467   inline const ::drizzled::message::Table_Field_TimeFieldOptions& time_options() const;
01468   inline ::drizzled::message::Table_Field_TimeFieldOptions* mutable_time_options();
01469   
01470   // optional string comment = 16;
01471   inline bool has_comment() const;
01472   inline void clear_comment();
01473   static const int kCommentFieldNumber = 16;
01474   inline const ::std::string& comment() const;
01475   inline void set_comment(const ::std::string& value);
01476   inline void set_comment(const char* value);
01477   inline void set_comment(const char* value, size_t size);
01478   inline ::std::string* mutable_comment();
01479   
01480   // optional .drizzled.message.Table.Field.EnumerationValues enumeration_values = 17;
01481   inline bool has_enumeration_values() const;
01482   inline void clear_enumeration_values();
01483   static const int kEnumerationValuesFieldNumber = 17;
01484   inline const ::drizzled::message::Table_Field_EnumerationValues& enumeration_values() const;
01485   inline ::drizzled::message::Table_Field_EnumerationValues* mutable_enumeration_values();
01486   
01487   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field)
01488  private:
01489   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01490   mutable int _cached_size_;
01491   
01492   ::std::string* name_;
01493   static const ::std::string _default_name_;
01494   int type_;
01495   ::drizzled::message::Table_Field_FieldOptions* options_;
01496   ::drizzled::message::Table_Field_FieldConstraints* constraints_;
01497   ::drizzled::message::Table_Field_NumericFieldOptions* numeric_options_;
01498   ::drizzled::message::Table_Field_StringFieldOptions* string_options_;
01499   ::drizzled::message::Table_Field_TimeFieldOptions* time_options_;
01500   ::std::string* comment_;
01501   static const ::std::string _default_comment_;
01502   ::drizzled::message::Table_Field_EnumerationValues* enumeration_values_;
01503   friend void  protobuf_AddDesc_table_2eproto();
01504   friend void protobuf_AssignDesc_table_2eproto();
01505   friend void protobuf_ShutdownFile_table_2eproto();
01506   
01507   ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];
01508   
01509   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01510   inline bool _has_bit(int index) const {
01511     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01512   }
01513   inline void _set_bit(int index) {
01514     _has_bits_[index / 32] |= (1u << (index % 32));
01515   }
01516   inline void _clear_bit(int index) {
01517     _has_bits_[index / 32] &= ~(1u << (index % 32));
01518   }
01519   
01520   void InitAsDefaultInstance();
01521   static Table_Field* default_instance_;
01522 };
01523 // -------------------------------------------------------------------
01524 
01525 class Table_Index_IndexPart : public ::google::protobuf::Message {
01526  public:
01527   Table_Index_IndexPart();
01528   virtual ~Table_Index_IndexPart();
01529   
01530   Table_Index_IndexPart(const Table_Index_IndexPart& from);
01531   
01532   inline Table_Index_IndexPart& operator=(const Table_Index_IndexPart& from) {
01533     CopyFrom(from);
01534     return *this;
01535   }
01536   
01537   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01538     return _unknown_fields_;
01539   }
01540   
01541   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01542     return &_unknown_fields_;
01543   }
01544   
01545   static const ::google::protobuf::Descriptor* descriptor();
01546   static const Table_Index_IndexPart& default_instance();
01547   
01548   void Swap(Table_Index_IndexPart* other);
01549   
01550   // implements Message ----------------------------------------------
01551   
01552   Table_Index_IndexPart* New() const;
01553   void CopyFrom(const ::google::protobuf::Message& from);
01554   void MergeFrom(const ::google::protobuf::Message& from);
01555   void CopyFrom(const Table_Index_IndexPart& from);
01556   void MergeFrom(const Table_Index_IndexPart& from);
01557   void Clear();
01558   bool IsInitialized() const;
01559   
01560   int ByteSize() const;
01561   bool MergePartialFromCodedStream(
01562       ::google::protobuf::io::CodedInputStream* input);
01563   void SerializeWithCachedSizes(
01564       ::google::protobuf::io::CodedOutputStream* output) const;
01565   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01566   int GetCachedSize() const { return _cached_size_; }
01567   private:
01568   void SharedCtor();
01569   void SharedDtor();
01570   void SetCachedSize(int size) const;
01571   public:
01572   
01573   ::google::protobuf::Metadata GetMetadata() const;
01574   
01575   // nested types ----------------------------------------------------
01576   
01577   // accessors -------------------------------------------------------
01578   
01579   // required uint32 fieldnr = 1;
01580   inline bool has_fieldnr() const;
01581   inline void clear_fieldnr();
01582   static const int kFieldnrFieldNumber = 1;
01583   inline ::google::protobuf::uint32 fieldnr() const;
01584   inline void set_fieldnr(::google::protobuf::uint32 value);
01585   
01586   // optional uint32 compare_length = 2;
01587   inline bool has_compare_length() const;
01588   inline void clear_compare_length();
01589   static const int kCompareLengthFieldNumber = 2;
01590   inline ::google::protobuf::uint32 compare_length() const;
01591   inline void set_compare_length(::google::protobuf::uint32 value);
01592   
01593   // optional bool in_reverse_order = 3 [default = false];
01594   inline bool has_in_reverse_order() const;
01595   inline void clear_in_reverse_order();
01596   static const int kInReverseOrderFieldNumber = 3;
01597   inline bool in_reverse_order() const;
01598   inline void set_in_reverse_order(bool value);
01599   
01600   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Index.IndexPart)
01601  private:
01602   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01603   mutable int _cached_size_;
01604   
01605   ::google::protobuf::uint32 fieldnr_;
01606   ::google::protobuf::uint32 compare_length_;
01607   bool in_reverse_order_;
01608   friend void  protobuf_AddDesc_table_2eproto();
01609   friend void protobuf_AssignDesc_table_2eproto();
01610   friend void protobuf_ShutdownFile_table_2eproto();
01611   
01612   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
01613   
01614   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01615   inline bool _has_bit(int index) const {
01616     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01617   }
01618   inline void _set_bit(int index) {
01619     _has_bits_[index / 32] |= (1u << (index % 32));
01620   }
01621   inline void _clear_bit(int index) {
01622     _has_bits_[index / 32] &= ~(1u << (index % 32));
01623   }
01624   
01625   void InitAsDefaultInstance();
01626   static Table_Index_IndexPart* default_instance_;
01627 };
01628 // -------------------------------------------------------------------
01629 
01630 class Table_Index_Options : public ::google::protobuf::Message {
01631  public:
01632   Table_Index_Options();
01633   virtual ~Table_Index_Options();
01634   
01635   Table_Index_Options(const Table_Index_Options& from);
01636   
01637   inline Table_Index_Options& operator=(const Table_Index_Options& from) {
01638     CopyFrom(from);
01639     return *this;
01640   }
01641   
01642   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01643     return _unknown_fields_;
01644   }
01645   
01646   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01647     return &_unknown_fields_;
01648   }
01649   
01650   static const ::google::protobuf::Descriptor* descriptor();
01651   static const Table_Index_Options& default_instance();
01652   
01653   void Swap(Table_Index_Options* other);
01654   
01655   // implements Message ----------------------------------------------
01656   
01657   Table_Index_Options* New() const;
01658   void CopyFrom(const ::google::protobuf::Message& from);
01659   void MergeFrom(const ::google::protobuf::Message& from);
01660   void CopyFrom(const Table_Index_Options& from);
01661   void MergeFrom(const Table_Index_Options& from);
01662   void Clear();
01663   bool IsInitialized() const;
01664   
01665   int ByteSize() const;
01666   bool MergePartialFromCodedStream(
01667       ::google::protobuf::io::CodedInputStream* input);
01668   void SerializeWithCachedSizes(
01669       ::google::protobuf::io::CodedOutputStream* output) const;
01670   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01671   int GetCachedSize() const { return _cached_size_; }
01672   private:
01673   void SharedCtor();
01674   void SharedDtor();
01675   void SetCachedSize(int size) const;
01676   public:
01677   
01678   ::google::protobuf::Metadata GetMetadata() const;
01679   
01680   // nested types ----------------------------------------------------
01681   
01682   // accessors -------------------------------------------------------
01683   
01684   // optional bool pack_key = 1;
01685   inline bool has_pack_key() const;
01686   inline void clear_pack_key();
01687   static const int kPackKeyFieldNumber = 1;
01688   inline bool pack_key() const;
01689   inline void set_pack_key(bool value);
01690   
01691   // optional bool binary_pack_key = 2;
01692   inline bool has_binary_pack_key() const;
01693   inline void clear_binary_pack_key();
01694   static const int kBinaryPackKeyFieldNumber = 2;
01695   inline bool binary_pack_key() const;
01696   inline void set_binary_pack_key(bool value);
01697   
01698   // optional bool var_length_key = 3;
01699   inline bool has_var_length_key() const;
01700   inline void clear_var_length_key();
01701   static const int kVarLengthKeyFieldNumber = 3;
01702   inline bool var_length_key() const;
01703   inline void set_var_length_key(bool value);
01704   
01705   // optional bool null_part_key = 4;
01706   inline bool has_null_part_key() const;
01707   inline void clear_null_part_key();
01708   static const int kNullPartKeyFieldNumber = 4;
01709   inline bool null_part_key() const;
01710   inline void set_null_part_key(bool value);
01711   
01712   // optional uint32 key_block_size = 5;
01713   inline bool has_key_block_size() const;
01714   inline void clear_key_block_size();
01715   static const int kKeyBlockSizeFieldNumber = 5;
01716   inline ::google::protobuf::uint32 key_block_size() const;
01717   inline void set_key_block_size(::google::protobuf::uint32 value);
01718   
01719   // optional bool has_partial_segments = 6;
01720   inline bool has_has_partial_segments() const;
01721   inline void clear_has_partial_segments();
01722   static const int kHasPartialSegmentsFieldNumber = 6;
01723   inline bool has_partial_segments() const;
01724   inline void set_has_partial_segments(bool value);
01725   
01726   // optional bool auto_generated_key = 7;
01727   inline bool has_auto_generated_key() const;
01728   inline void clear_auto_generated_key();
01729   static const int kAutoGeneratedKeyFieldNumber = 7;
01730   inline bool auto_generated_key() const;
01731   inline void set_auto_generated_key(bool value);
01732   
01733   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Index.Options)
01734  private:
01735   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01736   mutable int _cached_size_;
01737   
01738   bool pack_key_;
01739   bool binary_pack_key_;
01740   bool var_length_key_;
01741   bool null_part_key_;
01742   ::google::protobuf::uint32 key_block_size_;
01743   bool has_partial_segments_;
01744   bool auto_generated_key_;
01745   friend void  protobuf_AddDesc_table_2eproto();
01746   friend void protobuf_AssignDesc_table_2eproto();
01747   friend void protobuf_ShutdownFile_table_2eproto();
01748   
01749   ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
01750   
01751   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01752   inline bool _has_bit(int index) const {
01753     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01754   }
01755   inline void _set_bit(int index) {
01756     _has_bits_[index / 32] |= (1u << (index % 32));
01757   }
01758   inline void _clear_bit(int index) {
01759     _has_bits_[index / 32] &= ~(1u << (index % 32));
01760   }
01761   
01762   void InitAsDefaultInstance();
01763   static Table_Index_Options* default_instance_;
01764 };
01765 // -------------------------------------------------------------------
01766 
01767 class Table_Index : public ::google::protobuf::Message {
01768  public:
01769   Table_Index();
01770   virtual ~Table_Index();
01771   
01772   Table_Index(const Table_Index& from);
01773   
01774   inline Table_Index& operator=(const Table_Index& from) {
01775     CopyFrom(from);
01776     return *this;
01777   }
01778   
01779   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01780     return _unknown_fields_;
01781   }
01782   
01783   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01784     return &_unknown_fields_;
01785   }
01786   
01787   static const ::google::protobuf::Descriptor* descriptor();
01788   static const Table_Index& default_instance();
01789   
01790   void Swap(Table_Index* other);
01791   
01792   // implements Message ----------------------------------------------
01793   
01794   Table_Index* New() const;
01795   void CopyFrom(const ::google::protobuf::Message& from);
01796   void MergeFrom(const ::google::protobuf::Message& from);
01797   void CopyFrom(const Table_Index& from);
01798   void MergeFrom(const Table_Index& from);
01799   void Clear();
01800   bool IsInitialized() const;
01801   
01802   int ByteSize() const;
01803   bool MergePartialFromCodedStream(
01804       ::google::protobuf::io::CodedInputStream* input);
01805   void SerializeWithCachedSizes(
01806       ::google::protobuf::io::CodedOutputStream* output) const;
01807   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01808   int GetCachedSize() const { return _cached_size_; }
01809   private:
01810   void SharedCtor();
01811   void SharedDtor();
01812   void SetCachedSize(int size) const;
01813   public:
01814   
01815   ::google::protobuf::Metadata GetMetadata() const;
01816   
01817   // nested types ----------------------------------------------------
01818   
01819   typedef Table_Index_IndexPart IndexPart;
01820   typedef Table_Index_Options Options;
01821   
01822   typedef Table_Index_IndexType IndexType;
01823   static const IndexType UNKNOWN_INDEX = Table_Index_IndexType_UNKNOWN_INDEX;
01824   static const IndexType BTREE = Table_Index_IndexType_BTREE;
01825   static const IndexType RTREE = Table_Index_IndexType_RTREE;
01826   static const IndexType HASH = Table_Index_IndexType_HASH;
01827   static const IndexType FULLTEXT = Table_Index_IndexType_FULLTEXT;
01828   static inline bool IndexType_IsValid(int value) {
01829     return Table_Index_IndexType_IsValid(value);
01830   }
01831   static const IndexType IndexType_MIN =
01832     Table_Index_IndexType_IndexType_MIN;
01833   static const IndexType IndexType_MAX =
01834     Table_Index_IndexType_IndexType_MAX;
01835   static const int IndexType_ARRAYSIZE =
01836     Table_Index_IndexType_IndexType_ARRAYSIZE;
01837   static inline const ::google::protobuf::EnumDescriptor*
01838   IndexType_descriptor() {
01839     return Table_Index_IndexType_descriptor();
01840   }
01841   static inline const ::std::string& IndexType_Name(IndexType value) {
01842     return Table_Index_IndexType_Name(value);
01843   }
01844   static inline bool IndexType_Parse(const ::std::string& name,
01845       IndexType* value) {
01846     return Table_Index_IndexType_Parse(name, value);
01847   }
01848   
01849   // accessors -------------------------------------------------------
01850   
01851   // required string name = 1;
01852   inline bool has_name() const;
01853   inline void clear_name();
01854   static const int kNameFieldNumber = 1;
01855   inline const ::std::string& name() const;
01856   inline void set_name(const ::std::string& value);
01857   inline void set_name(const char* value);
01858   inline void set_name(const char* value, size_t size);
01859   inline ::std::string* mutable_name();
01860   
01861   // required bool is_primary = 2;
01862   inline bool has_is_primary() const;
01863   inline void clear_is_primary();
01864   static const int kIsPrimaryFieldNumber = 2;
01865   inline bool is_primary() const;
01866   inline void set_is_primary(bool value);
01867   
01868   // required bool is_unique = 3;
01869   inline bool has_is_unique() const;
01870   inline void clear_is_unique();
01871   static const int kIsUniqueFieldNumber = 3;
01872   inline bool is_unique() const;
01873   inline void set_is_unique(bool value);
01874   
01875   // required .drizzled.message.Table.Index.IndexType type = 4 [default = UNKNOWN_INDEX];
01876   inline bool has_type() const;
01877   inline void clear_type();
01878   static const int kTypeFieldNumber = 4;
01879   inline ::drizzled::message::Table_Index_IndexType type() const;
01880   inline void set_type(::drizzled::message::Table_Index_IndexType value);
01881   
01882   // required uint32 key_length = 5;
01883   inline bool has_key_length() const;
01884   inline void clear_key_length();
01885   static const int kKeyLengthFieldNumber = 5;
01886   inline ::google::protobuf::uint32 key_length() const;
01887   inline void set_key_length(::google::protobuf::uint32 value);
01888   
01889   // repeated .drizzled.message.Table.Index.IndexPart index_part = 6;
01890   inline int index_part_size() const;
01891   inline void clear_index_part();
01892   static const int kIndexPartFieldNumber = 6;
01893   inline const ::drizzled::message::Table_Index_IndexPart& index_part(int index) const;
01894   inline ::drizzled::message::Table_Index_IndexPart* mutable_index_part(int index);
01895   inline ::drizzled::message::Table_Index_IndexPart* add_index_part();
01896   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart >&
01897       index_part() const;
01898   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart >*
01899       mutable_index_part();
01900   
01901   // optional .drizzled.message.Table.Index.Options options = 7;
01902   inline bool has_options() const;
01903   inline void clear_options();
01904   static const int kOptionsFieldNumber = 7;
01905   inline const ::drizzled::message::Table_Index_Options& options() const;
01906   inline ::drizzled::message::Table_Index_Options* mutable_options();
01907   
01908   // optional string comment = 8;
01909   inline bool has_comment() const;
01910   inline void clear_comment();
01911   static const int kCommentFieldNumber = 8;
01912   inline const ::std::string& comment() const;
01913   inline void set_comment(const ::std::string& value);
01914   inline void set_comment(const char* value);
01915   inline void set_comment(const char* value, size_t size);
01916   inline ::std::string* mutable_comment();
01917   
01918   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Index)
01919  private:
01920   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01921   mutable int _cached_size_;
01922   
01923   ::std::string* name_;
01924   static const ::std::string _default_name_;
01925   bool is_primary_;
01926   bool is_unique_;
01927   int type_;
01928   ::google::protobuf::uint32 key_length_;
01929   ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart > index_part_;
01930   ::drizzled::message::Table_Index_Options* options_;
01931   ::std::string* comment_;
01932   static const ::std::string _default_comment_;
01933   friend void  protobuf_AddDesc_table_2eproto();
01934   friend void protobuf_AssignDesc_table_2eproto();
01935   friend void protobuf_ShutdownFile_table_2eproto();
01936   
01937   ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];
01938   
01939   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01940   inline bool _has_bit(int index) const {
01941     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01942   }
01943   inline void _set_bit(int index) {
01944     _has_bits_[index / 32] |= (1u << (index % 32));
01945   }
01946   inline void _clear_bit(int index) {
01947     _has_bits_[index / 32] &= ~(1u << (index % 32));
01948   }
01949   
01950   void InitAsDefaultInstance();
01951   static Table_Index* default_instance_;
01952 };
01953 // -------------------------------------------------------------------
01954 
01955 class Table : public ::google::protobuf::Message {
01956  public:
01957   Table();
01958   virtual ~Table();
01959   
01960   Table(const Table& from);
01961   
01962   inline Table& operator=(const Table& from) {
01963     CopyFrom(from);
01964     return *this;
01965   }
01966   
01967   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01968     return _unknown_fields_;
01969   }
01970   
01971   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01972     return &_unknown_fields_;
01973   }
01974   
01975   static const ::google::protobuf::Descriptor* descriptor();
01976   static const Table& default_instance();
01977   
01978   void Swap(Table* other);
01979   
01980   // implements Message ----------------------------------------------
01981   
01982   Table* New() const;
01983   void CopyFrom(const ::google::protobuf::Message& from);
01984   void MergeFrom(const ::google::protobuf::Message& from);
01985   void CopyFrom(const Table& from);
01986   void MergeFrom(const Table& from);
01987   void Clear();
01988   bool IsInitialized() const;
01989   
01990   int ByteSize() const;
01991   bool MergePartialFromCodedStream(
01992       ::google::protobuf::io::CodedInputStream* input);
01993   void SerializeWithCachedSizes(
01994       ::google::protobuf::io::CodedOutputStream* output) const;
01995   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01996   int GetCachedSize() const { return _cached_size_; }
01997   private:
01998   void SharedCtor();
01999   void SharedDtor();
02000   void SetCachedSize(int size) const;
02001   public:
02002   
02003   ::google::protobuf::Metadata GetMetadata() const;
02004   
02005   // nested types ----------------------------------------------------
02006   
02007   typedef Table_TableOptions TableOptions;
02008   typedef Table_ForeignKeyConstraint ForeignKeyConstraint;
02009   typedef Table_Field Field;
02010   typedef Table_Index Index;
02011   
02012   typedef Table_TableType TableType;
02013   static const TableType STANDARD = Table_TableType_STANDARD;
02014   static const TableType TEMPORARY = Table_TableType_TEMPORARY;
02015   static const TableType INTERNAL = Table_TableType_INTERNAL;
02016   static const TableType FUNCTION = Table_TableType_FUNCTION;
02017   static inline bool TableType_IsValid(int value) {
02018     return Table_TableType_IsValid(value);
02019   }
02020   static const TableType TableType_MIN =
02021     Table_TableType_TableType_MIN;
02022   static const TableType TableType_MAX =
02023     Table_TableType_TableType_MAX;
02024   static const int TableType_ARRAYSIZE =
02025     Table_TableType_TableType_ARRAYSIZE;
02026   static inline const ::google::protobuf::EnumDescriptor*
02027   TableType_descriptor() {
02028     return Table_TableType_descriptor();
02029   }
02030   static inline const ::std::string& TableType_Name(TableType value) {
02031     return Table_TableType_Name(value);
02032   }
02033   static inline bool TableType_Parse(const ::std::string& name,
02034       TableType* value) {
02035     return Table_TableType_Parse(name, value);
02036   }
02037   
02038   // accessors -------------------------------------------------------
02039   
02040   // required string name = 1;
02041   inline bool has_name() const;
02042   inline void clear_name();
02043   static const int kNameFieldNumber = 1;
02044   inline const ::std::string& name() const;
02045   inline void set_name(const ::std::string& value);
02046   inline void set_name(const char* value);
02047   inline void set_name(const char* value, size_t size);
02048   inline ::std::string* mutable_name();
02049   
02050   // required string schema = 6;
02051   inline bool has_schema() const;
02052   inline void clear_schema();
02053   static const int kSchemaFieldNumber = 6;
02054   inline const ::std::string& schema() const;
02055   inline void set_schema(const ::std::string& value);
02056   inline void set_schema(const char* value);
02057   inline void set_schema(const char* value, size_t size);
02058   inline ::std::string* mutable_schema();
02059   
02060   // required .drizzled.message.Table.TableType type = 5;
02061   inline bool has_type() const;
02062   inline void clear_type();
02063   static const int kTypeFieldNumber = 5;
02064   inline ::drizzled::message::Table_TableType type() const;
02065   inline void set_type(::drizzled::message::Table_TableType value);
02066   
02067   // required .drizzled.message.Engine engine = 2;
02068   inline bool has_engine() const;
02069   inline void clear_engine();
02070   static const int kEngineFieldNumber = 2;
02071   inline const ::drizzled::message::Engine& engine() const;
02072   inline ::drizzled::message::Engine* mutable_engine();
02073   
02074   // repeated .drizzled.message.Table.Field field = 3;
02075   inline int field_size() const;
02076   inline void clear_field();
02077   static const int kFieldFieldNumber = 3;
02078   inline const ::drizzled::message::Table_Field& field(int index) const;
02079   inline ::drizzled::message::Table_Field* mutable_field(int index);
02080   inline ::drizzled::message::Table_Field* add_field();
02081   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >&
02082       field() const;
02083   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >*
02084       mutable_field();
02085   
02086   // repeated .drizzled.message.Table.Index indexes = 4;
02087   inline int indexes_size() const;
02088   inline void clear_indexes();
02089   static const int kIndexesFieldNumber = 4;
02090   inline const ::drizzled::message::Table_Index& indexes(int index) const;
02091   inline ::drizzled::message::Table_Index* mutable_indexes(int index);
02092   inline ::drizzled::message::Table_Index* add_indexes();
02093   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index >&
02094       indexes() const;
02095   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index >*
02096       mutable_indexes();
02097   
02098   // repeated .drizzled.message.Table.ForeignKeyConstraint fk_constraint = 8;
02099   inline int fk_constraint_size() const;
02100   inline void clear_fk_constraint();
02101   static const int kFkConstraintFieldNumber = 8;
02102   inline const ::drizzled::message::Table_ForeignKeyConstraint& fk_constraint(int index) const;
02103   inline ::drizzled::message::Table_ForeignKeyConstraint* mutable_fk_constraint(int index);
02104   inline ::drizzled::message::Table_ForeignKeyConstraint* add_fk_constraint();
02105   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint >&
02106       fk_constraint() const;
02107   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint >*
02108       mutable_fk_constraint();
02109   
02110   // optional .drizzled.message.Table.TableOptions options = 9;
02111   inline bool has_options() const;
02112   inline void clear_options();
02113   static const int kOptionsFieldNumber = 9;
02114   inline const ::drizzled::message::Table_TableOptions& options() const;
02115   inline ::drizzled::message::Table_TableOptions* mutable_options();
02116   
02117   // required uint64 creation_timestamp = 11 [default = 0];
02118   inline bool has_creation_timestamp() const;
02119   inline void clear_creation_timestamp();
02120   static const int kCreationTimestampFieldNumber = 11;
02121   inline ::google::protobuf::uint64 creation_timestamp() const;
02122   inline void set_creation_timestamp(::google::protobuf::uint64 value);
02123   
02124   // required uint64 update_timestamp = 12 [default = 0];
02125   inline bool has_update_timestamp() const;
02126   inline void clear_update_timestamp();
02127   static const int kUpdateTimestampFieldNumber = 12;
02128   inline ::google::protobuf::uint64 update_timestamp() const;
02129   inline void set_update_timestamp(::google::protobuf::uint64 value);
02130   
02131   // optional string catalog = 13;
02132   inline bool has_catalog() const;
02133   inline void clear_catalog();
02134   static const int kCatalogFieldNumber = 13;
02135   inline const ::std::string& catalog() const;
02136   inline void set_catalog(const ::std::string& value);
02137   inline void set_catalog(const char* value);
02138   inline void set_catalog(const char* value, size_t size);
02139   inline ::std::string* mutable_catalog();
02140   
02141   // optional string uuid = 14;
02142   inline bool has_uuid() const;
02143   inline void clear_uuid();
02144   static const int kUuidFieldNumber = 14;
02145   inline const ::std::string& uuid() const;
02146   inline void set_uuid(const ::std::string& value);
02147   inline void set_uuid(const char* value);
02148   inline void set_uuid(const char* value, size_t size);
02149   inline ::std::string* mutable_uuid();
02150   
02151   // optional uint64 version = 15;
02152   inline bool has_version() const;
02153   inline void clear_version();
02154   static const int kVersionFieldNumber = 15;
02155   inline ::google::protobuf::uint64 version() const;
02156   inline void set_version(::google::protobuf::uint64 value);
02157   
02158   // optional .drizzled.message.ReplicationOptions replication_options = 16;
02159   inline bool has_replication_options() const;
02160   inline void clear_replication_options();
02161   static const int kReplicationOptionsFieldNumber = 16;
02162   inline const ::drizzled::message::ReplicationOptions& replication_options() const;
02163   inline ::drizzled::message::ReplicationOptions* mutable_replication_options();
02164   
02165   // @@protoc_insertion_point(class_scope:drizzled.message.Table)
02166  private:
02167   ::google::protobuf::UnknownFieldSet _unknown_fields_;
02168   mutable int _cached_size_;
02169   
02170   ::std::string* name_;
02171   static const ::std::string _default_name_;
02172   ::std::string* schema_;
02173   static const ::std::string _default_schema_;
02174   int type_;
02175   ::drizzled::message::Engine* engine_;
02176   ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field > field_;
02177   ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index > indexes_;
02178   ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint > fk_constraint_;
02179   ::drizzled::message::Table_TableOptions* options_;
02180   ::google::protobuf::uint64 creation_timestamp_;
02181   ::google::protobuf::uint64 update_timestamp_;
02182   ::std::string* catalog_;
02183   static const ::std::string _default_catalog_;
02184   ::std::string* uuid_;
02185   static const ::std::string _default_uuid_;
02186   ::google::protobuf::uint64 version_;
02187   ::drizzled::message::ReplicationOptions* replication_options_;
02188   friend void  protobuf_AddDesc_table_2eproto();
02189   friend void protobuf_AssignDesc_table_2eproto();
02190   friend void protobuf_ShutdownFile_table_2eproto();
02191   
02192   ::google::protobuf::uint32 _has_bits_[(14 + 31) / 32];
02193   
02194   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
02195   inline bool _has_bit(int index) const {
02196     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
02197   }
02198   inline void _set_bit(int index) {
02199     _has_bits_[index / 32] |= (1u << (index % 32));
02200   }
02201   inline void _clear_bit(int index) {
02202     _has_bits_[index / 32] &= ~(1u << (index % 32));
02203   }
02204   
02205   void InitAsDefaultInstance();
02206   static Table* default_instance_;
02207 };
02208 // -------------------------------------------------------------------
02209 
02210 class AlterTable : public ::google::protobuf::Message {
02211  public:
02212   AlterTable();
02213   virtual ~AlterTable();
02214   
02215   AlterTable(const AlterTable& from);
02216   
02217   inline AlterTable& operator=(const AlterTable& from) {
02218     CopyFrom(from);
02219     return *this;
02220   }
02221   
02222   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
02223     return _unknown_fields_;
02224   }
02225   
02226   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
02227     return &_unknown_fields_;
02228   }
02229   
02230   static const ::google::protobuf::Descriptor* descriptor();
02231   static const AlterTable& default_instance();
02232   
02233   void Swap(AlterTable* other);
02234   
02235   // implements Message ----------------------------------------------
02236   
02237   AlterTable* New() const;
02238   void CopyFrom(const ::google::protobuf::Message& from);
02239   void MergeFrom(const ::google::protobuf::Message& from);
02240   void CopyFrom(const AlterTable& from);
02241   void MergeFrom(const AlterTable& from);
02242   void Clear();
02243   bool IsInitialized() const;
02244   
02245   int ByteSize() const;
02246   bool MergePartialFromCodedStream(
02247       ::google::protobuf::io::CodedInputStream* input);
02248   void SerializeWithCachedSizes(
02249       ::google::protobuf::io::CodedOutputStream* output) const;
02250   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
02251   int GetCachedSize() const { return _cached_size_; }
02252   private:
02253   void SharedCtor();
02254   void SharedDtor();
02255   void SetCachedSize(int size) const;
02256   public:
02257   
02258   ::google::protobuf::Metadata GetMetadata() const;
02259   
02260   // nested types ----------------------------------------------------
02261   
02262   // accessors -------------------------------------------------------
02263   
02264   // repeated .drizzled.message.Table.Field added_field = 1;
02265   inline int added_field_size() const;
02266   inline void clear_added_field();
02267   static const int kAddedFieldFieldNumber = 1;
02268   inline const ::drizzled::message::Table_Field& added_field(int index) const;
02269   inline ::drizzled::message::Table_Field* mutable_added_field(int index);
02270   inline ::drizzled::message::Table_Field* add_added_field();
02271   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >&
02272       added_field() const;
02273   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >*
02274       mutable_added_field();
02275   
02276   // @@protoc_insertion_point(class_scope:drizzled.message.AlterTable)
02277  private:
02278   ::google::protobuf::UnknownFieldSet _unknown_fields_;
02279   mutable int _cached_size_;
02280   
02281   ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field > added_field_;
02282   friend void  protobuf_AddDesc_table_2eproto();
02283   friend void protobuf_AssignDesc_table_2eproto();
02284   friend void protobuf_ShutdownFile_table_2eproto();
02285   
02286   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
02287   
02288   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
02289   inline bool _has_bit(int index) const {
02290     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
02291   }
02292   inline void _set_bit(int index) {
02293     _has_bits_[index / 32] |= (1u << (index % 32));
02294   }
02295   inline void _clear_bit(int index) {
02296     _has_bits_[index / 32] &= ~(1u << (index % 32));
02297   }
02298   
02299   void InitAsDefaultInstance();
02300   static AlterTable* default_instance_;
02301 };
02302 // ===================================================================
02303 
02304 
02305 // ===================================================================
02306 
02307 // Table_TableOptions
02308 
02309 // optional bool has_user_set_auto_increment_value = 1;
02310 inline bool Table_TableOptions::has_has_user_set_auto_increment_value() const {
02311   return _has_bit(0);
02312 }
02313 inline void Table_TableOptions::clear_has_user_set_auto_increment_value() {
02314   has_user_set_auto_increment_value_ = false;
02315   _clear_bit(0);
02316 }
02317 inline bool Table_TableOptions::has_user_set_auto_increment_value() const {
02318   return has_user_set_auto_increment_value_;
02319 }
02320 inline void Table_TableOptions::set_has_user_set_auto_increment_value(bool value) {
02321   _set_bit(0);
02322   has_user_set_auto_increment_value_ = value;
02323 }
02324 
02325 // optional string collation = 2;
02326 inline bool Table_TableOptions::has_collation() const {
02327   return _has_bit(1);
02328 }
02329 inline void Table_TableOptions::clear_collation() {
02330   if (collation_ != &_default_collation_) {
02331     collation_->clear();
02332   }
02333   _clear_bit(1);
02334 }
02335 inline const ::std::string& Table_TableOptions::collation() const {
02336   return *collation_;
02337 }
02338 inline void Table_TableOptions::set_collation(const ::std::string& value) {
02339   _set_bit(1);
02340   if (collation_ == &_default_collation_) {
02341     collation_ = new ::std::string;
02342   }
02343   collation_->assign(value);
02344 }
02345 inline void Table_TableOptions::set_collation(const char* value) {
02346   _set_bit(1);
02347   if (collation_ == &_default_collation_) {
02348     collation_ = new ::std::string;
02349   }
02350   collation_->assign(value);
02351 }
02352 inline void Table_TableOptions::set_collation(const char* value, size_t size) {
02353   _set_bit(1);
02354   if (collation_ == &_default_collation_) {
02355     collation_ = new ::std::string;
02356   }
02357   collation_->assign(reinterpret_cast<const char*>(value), size);
02358 }
02359 inline ::std::string* Table_TableOptions::mutable_collation() {
02360   _set_bit(1);
02361   if (collation_ == &_default_collation_) {
02362     collation_ = new ::std::string;
02363   }
02364   return collation_;
02365 }
02366 
02367 // optional uint32 collation_id = 3;
02368 inline bool Table_TableOptions::has_collation_id() const {
02369   return _has_bit(2);
02370 }
02371 inline void Table_TableOptions::clear_collation_id() {
02372   collation_id_ = 0u;
02373   _clear_bit(2);
02374 }
02375 inline ::google::protobuf::uint32 Table_TableOptions::collation_id() const {
02376   return collation_id_;
02377 }
02378 inline void Table_TableOptions::set_collation_id(::google::protobuf::uint32 value) {
02379   _set_bit(2);
02380   collation_id_ = value;
02381 }
02382 
02383 // optional string data_file_name = 5;
02384 inline bool Table_TableOptions::has_data_file_name() const {
02385   return _has_bit(3);
02386 }
02387 inline void Table_TableOptions::clear_data_file_name() {
02388   if (data_file_name_ != &_default_data_file_name_) {
02389     data_file_name_->clear();
02390   }
02391   _clear_bit(3);
02392 }
02393 inline const ::std::string& Table_TableOptions::data_file_name() const {
02394   return *data_file_name_;
02395 }
02396 inline void Table_TableOptions::set_data_file_name(const ::std::string& value) {
02397   _set_bit(3);
02398   if (data_file_name_ == &_default_data_file_name_) {
02399     data_file_name_ = new ::std::string;
02400   }
02401   data_file_name_->assign(value);
02402 }
02403 inline void Table_TableOptions::set_data_file_name(const char* value) {
02404   _set_bit(3);
02405   if (data_file_name_ == &_default_data_file_name_) {
02406     data_file_name_ = new ::std::string;
02407   }
02408   data_file_name_->assign(value);
02409 }
02410 inline void Table_TableOptions::set_data_file_name(const char* value, size_t size) {
02411   _set_bit(3);
02412   if (data_file_name_ == &_default_data_file_name_) {
02413     data_file_name_ = new ::std::string;
02414   }
02415   data_file_name_->assign(reinterpret_cast<const char*>(value), size);
02416 }
02417 inline ::std::string* Table_TableOptions::mutable_data_file_name() {
02418   _set_bit(3);
02419   if (data_file_name_ == &_default_data_file_name_) {
02420     data_file_name_ = new ::std::string;
02421   }
02422   return data_file_name_;
02423 }
02424 
02425 // optional string index_file_name = 6;
02426 inline bool Table_TableOptions::has_index_file_name() const {
02427   return _has_bit(4);
02428 }
02429 inline void Table_TableOptions::clear_index_file_name() {
02430   if (index_file_name_ != &_default_index_file_name_) {
02431     index_file_name_->clear();
02432   }
02433   _clear_bit(4);
02434 }
02435 inline const ::std::string& Table_TableOptions::index_file_name() const {
02436   return *index_file_name_;
02437 }
02438 inline void Table_TableOptions::set_index_file_name(const ::std::string& value) {
02439   _set_bit(4);
02440   if (index_file_name_ == &_default_index_file_name_) {
02441     index_file_name_ = new ::std::string;
02442   }
02443   index_file_name_->assign(value);
02444 }
02445 inline void Table_TableOptions::set_index_file_name(const char* value) {
02446   _set_bit(4);
02447   if (index_file_name_ == &_default_index_file_name_) {
02448     index_file_name_ = new ::std::string;
02449   }
02450   index_file_name_->assign(value);
02451 }
02452 inline void Table_TableOptions::set_index_file_name(const char* value, size_t size) {
02453   _set_bit(4);
02454   if (index_file_name_ == &_default_index_file_name_) {
02455     index_file_name_ = new ::std::string;
02456   }
02457   index_file_name_->assign(reinterpret_cast<const char*>(value), size);
02458 }
02459 inline ::std::string* Table_TableOptions::mutable_index_file_name() {
02460   _set_bit(4);
02461   if (index_file_name_ == &_default_index_file_name_) {
02462     index_file_name_ = new ::std::string;
02463   }
02464   return index_file_name_;
02465 }
02466 
02467 // optional uint64 max_rows = 7;
02468 inline bool Table_TableOptions::has_max_rows() const {
02469   return _has_bit(5);
02470 }
02471 inline void Table_TableOptions::clear_max_rows() {
02472   max_rows_ = GOOGLE_ULONGLONG(0);
02473   _clear_bit(5);
02474 }
02475 inline ::google::protobuf::uint64 Table_TableOptions::max_rows() const {
02476   return max_rows_;
02477 }
02478 inline void Table_TableOptions::set_max_rows(::google::protobuf::uint64 value) {
02479   _set_bit(5);
02480   max_rows_ = value;
02481 }
02482 
02483 // optional uint64 min_rows = 8;
02484 inline bool Table_TableOptions::has_min_rows() const {
02485   return _has_bit(6);
02486 }
02487 inline void Table_TableOptions::clear_min_rows() {
02488   min_rows_ = GOOGLE_ULONGLONG(0);
02489   _clear_bit(6);
02490 }
02491 inline ::google::protobuf::uint64 Table_TableOptions::min_rows() const {
02492   return min_rows_;
02493 }
02494 inline void Table_TableOptions::set_min_rows(::google::protobuf::uint64 value) {
02495   _set_bit(6);
02496   min_rows_ = value;
02497 }
02498 
02499 // optional uint64 auto_increment_value = 9;
02500 inline bool Table_TableOptions::has_auto_increment_value() const {
02501   return _has_bit(7);
02502 }
02503 inline void Table_TableOptions::clear_auto_increment_value() {
02504   auto_increment_value_ = GOOGLE_ULONGLONG(0);
02505   _clear_bit(7);
02506 }
02507 inline ::google::protobuf::uint64 Table_TableOptions::auto_increment_value() const {
02508   return auto_increment_value_;
02509 }
02510 inline void Table_TableOptions::set_auto_increment_value(::google::protobuf::uint64 value) {
02511   _set_bit(7);
02512   auto_increment_value_ = value;
02513 }
02514 
02515 // optional uint32 avg_row_length = 11;
02516 inline bool Table_TableOptions::has_avg_row_length() const {
02517   return _has_bit(8);
02518 }
02519 inline void Table_TableOptions::clear_avg_row_length() {
02520   avg_row_length_ = 0u;
02521   _clear_bit(8);
02522 }
02523 inline ::google::protobuf::uint32 Table_TableOptions::avg_row_length() const {
02524   return avg_row_length_;
02525 }
02526 inline void Table_TableOptions::set_avg_row_length(::google::protobuf::uint32 value) {
02527   _set_bit(8);
02528   avg_row_length_ = value;
02529 }
02530 
02531 // optional uint32 block_size = 13;
02532 inline bool Table_TableOptions::has_block_size() const {
02533   return _has_bit(9);
02534 }
02535 inline void Table_TableOptions::clear_block_size() {
02536   block_size_ = 0u;
02537   _clear_bit(9);
02538 }
02539 inline ::google::protobuf::uint32 Table_TableOptions::block_size() const {
02540   return block_size_;
02541 }
02542 inline void Table_TableOptions::set_block_size(::google::protobuf::uint32 value) {
02543   _set_bit(9);
02544   block_size_ = value;
02545 }
02546 
02547 // optional string comment = 14;
02548 inline bool Table_TableOptions::has_comment() const {
02549   return _has_bit(10);
02550 }
02551 inline void Table_TableOptions::clear_comment() {
02552   if (comment_ != &_default_comment_) {
02553     comment_->clear();
02554   }
02555   _clear_bit(10);
02556 }
02557 inline const ::std::string& Table_TableOptions::comment() const {
02558   return *comment_;
02559 }
02560 inline void Table_TableOptions::set_comment(const ::std::string& value) {
02561   _set_bit(10);
02562   if (comment_ == &_default_comment_) {
02563     comment_ = new ::std::string;
02564   }
02565   comment_->assign(value);
02566 }
02567 inline void Table_TableOptions::set_comment(const char* value) {
02568   _set_bit(10);
02569   if (comment_ == &_default_comment_) {
02570     comment_ = new ::std::string;
02571   }
02572   comment_->assign(value);
02573 }
02574 inline void Table_TableOptions::set_comment(const char* value, size_t size) {
02575   _set_bit(10);
02576   if (comment_ == &_default_comment_) {
02577     comment_ = new ::std::string;
02578   }
02579   comment_->assign(reinterpret_cast<const char*>(value), size);
02580 }
02581 inline ::std::string* Table_TableOptions::mutable_comment() {
02582   _set_bit(10);
02583   if (comment_ == &_default_comment_) {
02584     comment_ = new ::std::string;
02585   }
02586   return comment_;
02587 }
02588 
02589 // optional bool pack_record = 16;
02590 inline bool Table_TableOptions::has_pack_record() const {
02591   return _has_bit(11);
02592 }
02593 inline void Table_TableOptions::clear_pack_record() {
02594   pack_record_ = false;
02595   _clear_bit(11);
02596 }
02597 inline bool Table_TableOptions::pack_record() const {
02598   return pack_record_;
02599 }
02600 inline void Table_TableOptions::set_pack_record(bool value) {
02601   _set_bit(11);
02602   pack_record_ = value;
02603 }
02604 
02605 // optional bool checksum = 17;
02606 inline bool Table_TableOptions::has_checksum() const {
02607   return _has_bit(12);
02608 }
02609 inline void Table_TableOptions::clear_checksum() {
02610   checksum_ = false;
02611   _clear_bit(12);
02612 }
02613 inline bool Table_TableOptions::checksum() const {
02614   return checksum_;
02615 }
02616 inline void Table_TableOptions::set_checksum(bool value) {
02617   _set_bit(12);
02618   checksum_ = value;
02619 }
02620 
02621 // optional bool page_checksum = 18;
02622 inline bool Table_TableOptions::has_page_checksum() const {
02623   return _has_bit(13);
02624 }
02625 inline void Table_TableOptions::clear_page_checksum() {
02626   page_checksum_ = false;
02627   _clear_bit(13);
02628 }
02629 inline bool Table_TableOptions::page_checksum() const {
02630   return page_checksum_;
02631 }
02632 inline void Table_TableOptions::set_page_checksum(bool value) {
02633   _set_bit(13);
02634   page_checksum_ = value;
02635 }
02636 
02637 // optional bool delay_key_write = 19;
02638 inline bool Table_TableOptions::has_delay_key_write() const {
02639   return _has_bit(14);
02640 }
02641 inline void Table_TableOptions::clear_delay_key_write() {
02642   delay_key_write_ = false;
02643   _clear_bit(14);
02644 }
02645 inline bool Table_TableOptions::delay_key_write() const {
02646   return delay_key_write_;
02647 }
02648 inline void Table_TableOptions::set_delay_key_write(bool value) {
02649   _set_bit(14);
02650   delay_key_write_ = value;
02651 }
02652 
02653 // optional bool dont_replicate = 20;
02654 inline bool Table_TableOptions::has_dont_replicate() const {
02655   return _has_bit(15);
02656 }
02657 inline void Table_TableOptions::clear_dont_replicate() {
02658   dont_replicate_ = false;
02659   _clear_bit(15);
02660 }
02661 inline bool Table_TableOptions::dont_replicate() const {
02662   return dont_replicate_;
02663 }
02664 inline void Table_TableOptions::set_dont_replicate(bool value) {
02665   _set_bit(15);
02666   dont_replicate_ = value;
02667 }
02668 
02669 // -------------------------------------------------------------------
02670 
02671 // Table_ForeignKeyConstraint
02672 
02673 // optional string name = 1;
02674 inline bool Table_ForeignKeyConstraint::has_name() const {
02675   return _has_bit(0);
02676 }
02677 inline void Table_ForeignKeyConstraint::clear_name() {
02678   if (name_ != &_default_name_) {
02679     name_->clear();
02680   }
02681   _clear_bit(0);
02682 }
02683 inline const ::std::string& Table_ForeignKeyConstraint::name() const {
02684   return *name_;
02685 }
02686 inline void Table_ForeignKeyConstraint::set_name(const ::std::string& value) {
02687   _set_bit(0);
02688   if (name_ == &_default_name_) {
02689     name_ = new ::std::string;
02690   }
02691   name_->assign(value);
02692 }
02693 inline void Table_ForeignKeyConstraint::set_name(const char* value) {
02694   _set_bit(0);
02695   if (name_ == &_default_name_) {
02696     name_ = new ::std::string;
02697   }
02698   name_->assign(value);
02699 }
02700 inline void Table_ForeignKeyConstraint::set_name(const char* value, size_t size) {
02701   _set_bit(0);
02702   if (name_ == &_default_name_) {
02703     name_ = new ::std::string;
02704   }
02705   name_->assign(reinterpret_cast<const char*>(value), size);
02706 }
02707 inline ::std::string* Table_ForeignKeyConstraint::mutable_name() {
02708   _set_bit(0);
02709   if (name_ == &_default_name_) {
02710     name_ = new ::std::string;
02711   }
02712   return name_;
02713 }
02714 
02715 // repeated string column_names = 2;
02716 inline int Table_ForeignKeyConstraint::column_names_size() const {
02717   return column_names_.size();
02718 }
02719 inline void Table_ForeignKeyConstraint::clear_column_names() {
02720   column_names_.Clear();
02721 }
02722 inline const ::std::string& Table_ForeignKeyConstraint::column_names(int index) const {
02723   return column_names_.Get(index);
02724 }
02725 inline ::std::string* Table_ForeignKeyConstraint::mutable_column_names(int index) {
02726   return column_names_.Mutable(index);
02727 }
02728 inline void Table_ForeignKeyConstraint::set_column_names(int index, const ::std::string& value) {
02729   column_names_.Mutable(index)->assign(value);
02730 }
02731 inline void Table_ForeignKeyConstraint::set_column_names(int index, const char* value) {
02732   column_names_.Mutable(index)->assign(value);
02733 }
02734 inline void Table_ForeignKeyConstraint::set_column_names(int index, const char* value, size_t size) {
02735   column_names_.Mutable(index)->assign(
02736     reinterpret_cast<const char*>(value), size);
02737 }
02738 inline ::std::string* Table_ForeignKeyConstraint::add_column_names() {
02739   return column_names_.Add();
02740 }
02741 inline void Table_ForeignKeyConstraint::add_column_names(const ::std::string& value) {
02742   column_names_.Add()->assign(value);
02743 }
02744 inline void Table_ForeignKeyConstraint::add_column_names(const char* value) {
02745   column_names_.Add()->assign(value);
02746 }
02747 inline void Table_ForeignKeyConstraint::add_column_names(const char* value, size_t size) {
02748   column_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
02749 }
02750 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
02751 Table_ForeignKeyConstraint::column_names() const {
02752   return column_names_;
02753 }
02754 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
02755 Table_ForeignKeyConstraint::mutable_column_names() {
02756   return &column_names_;
02757 }
02758 
02759 // required string references_table_name = 3;
02760 inline bool Table_ForeignKeyConstraint::has_references_table_name() const {
02761   return _has_bit(2);
02762 }
02763 inline void Table_ForeignKeyConstraint::clear_references_table_name() {
02764   if (references_table_name_ != &_default_references_table_name_) {
02765     references_table_name_->clear();
02766   }
02767   _clear_bit(2);
02768 }
02769 inline const ::std::string& Table_ForeignKeyConstraint::references_table_name() const {
02770   return *references_table_name_;
02771 }
02772 inline void Table_ForeignKeyConstraint::set_references_table_name(const ::std::string& value) {
02773   _set_bit(2);
02774   if (references_table_name_ == &_default_references_table_name_) {
02775     references_table_name_ = new ::std::string;
02776   }
02777   references_table_name_->assign(value);
02778 }
02779 inline void Table_ForeignKeyConstraint::set_references_table_name(const char* value) {
02780   _set_bit(2);
02781   if (references_table_name_ == &_default_references_table_name_) {
02782     references_table_name_ = new ::std::string;
02783   }
02784   references_table_name_->assign(value);
02785 }
02786 inline void Table_ForeignKeyConstraint::set_references_table_name(const char* value, size_t size) {
02787   _set_bit(2);
02788   if (references_table_name_ == &_default_references_table_name_) {
02789     references_table_name_ = new ::std::string;
02790   }
02791   references_table_name_->assign(reinterpret_cast<const char*>(value), size);
02792 }
02793 inline ::std::string* Table_ForeignKeyConstraint::mutable_references_table_name() {
02794   _set_bit(2);
02795   if (references_table_name_ == &_default_references_table_name_) {
02796     references_table_name_ = new ::std::string;
02797   }
02798   return references_table_name_;
02799 }
02800 
02801 // repeated string references_columns = 4;
02802 inline int Table_ForeignKeyConstraint::references_columns_size() const {
02803   return references_columns_.size();
02804 }
02805 inline void Table_ForeignKeyConstraint::clear_references_columns() {
02806   references_columns_.Clear();
02807 }
02808 inline const ::std::string& Table_ForeignKeyConstraint::references_columns(int index) const {
02809   return references_columns_.Get(index);
02810 }
02811 inline ::std::string* Table_ForeignKeyConstraint::mutable_references_columns(int index) {
02812   return references_columns_.Mutable(index);
02813 }
02814 inline void Table_ForeignKeyConstraint::set_references_columns(int index, const ::std::string& value) {
02815   references_columns_.Mutable(index)->assign(value);
02816 }
02817 inline void Table_ForeignKeyConstraint::set_references_columns(int index, const char* value) {
02818   references_columns_.Mutable(index)->assign(value);
02819 }
02820 inline void Table_ForeignKeyConstraint::set_references_columns(int index, const char* value, size_t size) {
02821   references_columns_.Mutable(index)->assign(
02822     reinterpret_cast<const char*>(value), size);
02823 }
02824 inline ::std::string* Table_ForeignKeyConstraint::add_references_columns() {
02825   return references_columns_.Add();
02826 }
02827 inline void Table_ForeignKeyConstraint::add_references_columns(const ::std::string& value) {
02828   references_columns_.Add()->assign(value);
02829 }
02830 inline void Table_ForeignKeyConstraint::add_references_columns(const char* value) {
02831   references_columns_.Add()->assign(value);
02832 }
02833 inline void Table_ForeignKeyConstraint::add_references_columns(const char* value, size_t size) {
02834   references_columns_.Add()->assign(reinterpret_cast<const char*>(value), size);
02835 }
02836 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
02837 Table_ForeignKeyConstraint::references_columns() const {
02838   return references_columns_;
02839 }
02840 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
02841 Table_ForeignKeyConstraint::mutable_references_columns() {
02842   return &references_columns_;
02843 }
02844 
02845 // required .drizzled.message.Table.ForeignKeyConstraint.ForeignKeyMatchOption match = 5;
02846 inline bool Table_ForeignKeyConstraint::has_match() const {
02847   return _has_bit(4);
02848 }
02849 inline void Table_ForeignKeyConstraint::clear_match() {
02850   match_ = 0;
02851   _clear_bit(4);
02852 }
02853 inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption Table_ForeignKeyConstraint::match() const {
02854   return static_cast< ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption >(match_);
02855 }
02856 inline void Table_ForeignKeyConstraint::set_match(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption value) {
02857   GOOGLE_DCHECK(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption_IsValid(value));
02858   _set_bit(4);
02859   match_ = value;
02860 }
02861 
02862 // required .drizzled.message.Table.ForeignKeyConstraint.ForeignKeyOption update_option = 6 [default = OPTION_UNDEF];
02863 inline bool Table_ForeignKeyConstraint::has_update_option() const {
02864   return _has_bit(5);
02865 }
02866 inline void Table_ForeignKeyConstraint::clear_update_option() {
02867   update_option_ = 0;
02868   _clear_bit(5);
02869 }
02870 inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption Table_ForeignKeyConstraint::update_option() const {
02871   return static_cast< ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption >(update_option_);
02872 }
02873 inline void Table_ForeignKeyConstraint::set_update_option(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption value) {
02874   GOOGLE_DCHECK(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption_IsValid(value));
02875   _set_bit(5);
02876   update_option_ = value;
02877 }
02878 
02879 // required .drizzled.message.Table.ForeignKeyConstraint.ForeignKeyOption delete_option = 7 [default = OPTION_UNDEF];
02880 inline bool Table_ForeignKeyConstraint::has_delete_option() const {
02881   return _has_bit(6);
02882 }
02883 inline void Table_ForeignKeyConstraint::clear_delete_option() {
02884   delete_option_ = 0;
02885   _clear_bit(6);
02886 }
02887 inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption Table_ForeignKeyConstraint::delete_option() const {
02888   return static_cast< ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption >(delete_option_);
02889 }
02890 inline void Table_ForeignKeyConstraint::set_delete_option(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption value) {
02891   GOOGLE_DCHECK(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption_IsValid(value));
02892   _set_bit(6);
02893   delete_option_ = value;
02894 }
02895 
02896 // -------------------------------------------------------------------
02897 
02898 // Table_Field_FieldOptions
02899 
02900 // optional string default_value = 1;
02901 inline bool Table_Field_FieldOptions::has_default_value() const {
02902   return _has_bit(0);
02903 }
02904 inline void Table_Field_FieldOptions::clear_default_value() {
02905   if (default_value_ != &_default_default_value_) {
02906     default_value_->clear();
02907   }
02908   _clear_bit(0);
02909 }
02910 inline const ::std::string& Table_Field_FieldOptions::default_value() const {
02911   return *default_value_;
02912 }
02913 inline void Table_Field_FieldOptions::set_default_value(const ::std::string& value) {
02914   _set_bit(0);
02915   if (default_value_ == &_default_default_value_) {
02916     default_value_ = new ::std::string;
02917   }
02918   default_value_->assign(value);
02919 }
02920 inline void Table_Field_FieldOptions::set_default_value(const char* value) {
02921   _set_bit(0);
02922   if (default_value_ == &_default_default_value_) {
02923     default_value_ = new ::std::string;
02924   }
02925   default_value_->assign(value);
02926 }
02927 inline void Table_Field_FieldOptions::set_default_value(const char* value, size_t size) {
02928   _set_bit(0);
02929   if (default_value_ == &_default_default_value_) {
02930     default_value_ = new ::std::string;
02931   }
02932   default_value_->assign(reinterpret_cast<const char*>(value), size);
02933 }
02934 inline ::std::string* Table_Field_FieldOptions::mutable_default_value() {
02935   _set_bit(0);
02936   if (default_value_ == &_default_default_value_) {
02937     default_value_ = new ::std::string;
02938   }
02939   return default_value_;
02940 }
02941 
02942 // optional string update_value = 2;
02943 inline bool Table_Field_FieldOptions::has_update_value() const {
02944   return _has_bit(1);
02945 }
02946 inline void Table_Field_FieldOptions::clear_update_value() {
02947   if (update_value_ != &_default_update_value_) {
02948     update_value_->clear();
02949   }
02950   _clear_bit(1);
02951 }
02952 inline const ::std::string& Table_Field_FieldOptions::update_value() const {
02953   return *update_value_;
02954 }
02955 inline void Table_Field_FieldOptions::set_update_value(const ::std::string& value) {
02956   _set_bit(1);
02957   if (update_value_ == &_default_update_value_) {
02958     update_value_ = new ::std::string;
02959   }
02960   update_value_->assign(value);
02961 }
02962 inline void Table_Field_FieldOptions::set_update_value(const char* value) {
02963   _set_bit(1);
02964   if (update_value_ == &_default_update_value_) {
02965     update_value_ = new ::std::string;
02966   }
02967   update_value_->assign(value);
02968 }
02969 inline void Table_Field_FieldOptions::set_update_value(const char* value, size_t size) {
02970   _set_bit(1);
02971   if (update_value_ == &_default_update_value_) {
02972     update_value_ = new ::std::string;
02973   }
02974   update_value_->assign(reinterpret_cast<const char*>(value), size);
02975 }
02976 inline ::std::string* Table_Field_FieldOptions::mutable_update_value() {
02977   _set_bit(1);
02978   if (update_value_ == &_default_update_value_) {
02979     update_value_ = new ::std::string;
02980   }
02981   return update_value_;
02982 }
02983 
02984 // optional bool default_null = 3 [default = false];
02985 inline bool Table_Field_FieldOptions::has_default_null() const {
02986   return _has_bit(2);
02987 }
02988 inline void Table_Field_FieldOptions::clear_default_null() {
02989   default_null_ = false;
02990   _clear_bit(2);
02991 }
02992 inline bool Table_Field_FieldOptions::default_null() const {
02993   return default_null_;
02994 }
02995 inline void Table_Field_FieldOptions::set_default_null(bool value) {
02996   _set_bit(2);
02997   default_null_ = value;
02998 }
02999 
03000 // optional bytes default_bin_value = 4;
03001 inline bool Table_Field_FieldOptions::has_default_bin_value() const {
03002   return _has_bit(3);
03003 }
03004 inline void Table_Field_FieldOptions::clear_default_bin_value() {
03005   if (default_bin_value_ != &_default_default_bin_value_) {
03006     default_bin_value_->clear();
03007   }
03008   _clear_bit(3);
03009 }
03010 inline const ::std::string& Table_Field_FieldOptions::default_bin_value() const {
03011   return *default_bin_value_;
03012 }
03013 inline void Table_Field_FieldOptions::set_default_bin_value(const ::std::string& value) {
03014   _set_bit(3);
03015   if (default_bin_value_ == &_default_default_bin_value_) {
03016     default_bin_value_ = new ::std::string;
03017   }
03018   default_bin_value_->assign(value);
03019 }
03020 inline void Table_Field_FieldOptions::set_default_bin_value(const char* value) {
03021   _set_bit(3);
03022   if (default_bin_value_ == &_default_default_bin_value_) {
03023     default_bin_value_ = new ::std::string;
03024   }
03025   default_bin_value_->assign(value);
03026 }
03027 inline void Table_Field_FieldOptions::set_default_bin_value(const void* value, size_t size) {
03028   _set_bit(3);
03029   if (default_bin_value_ == &_default_default_bin_value_) {
03030     default_bin_value_ = new ::std::string;
03031   }
03032   default_bin_value_->assign(reinterpret_cast<const char*>(value), size);
03033 }
03034 inline ::std::string* Table_Field_FieldOptions::mutable_default_bin_value() {
03035   _set_bit(3);
03036   if (default_bin_value_ == &_default_default_bin_value_) {
03037     default_bin_value_ = new ::std::string;
03038   }
03039   return default_bin_value_;
03040 }
03041 
03042 // optional string default_expression = 5;
03043 inline bool Table_Field_FieldOptions::has_default_expression() const {
03044   return _has_bit(4);
03045 }
03046 inline void Table_Field_FieldOptions::clear_default_expression() {
03047   if (default_expression_ != &_default_default_expression_) {
03048     default_expression_->clear();
03049   }
03050   _clear_bit(4);
03051 }
03052 inline const ::std::string& Table_Field_FieldOptions::default_expression() const {
03053   return *default_expression_;
03054 }
03055 inline void Table_Field_FieldOptions::set_default_expression(const ::std::string& value) {
03056   _set_bit(4);
03057   if (default_expression_ == &_default_default_expression_) {
03058     default_expression_ = new ::std::string;
03059   }
03060   default_expression_->assign(value);
03061 }
03062 inline void Table_Field_FieldOptions::set_default_expression(const char* value) {
03063   _set_bit(4);
03064   if (default_expression_ == &_default_default_expression_) {
03065     default_expression_ = new ::std::string;
03066   }
03067   default_expression_->assign(value);
03068 }
03069 inline void Table_Field_FieldOptions::set_default_expression(const char* value, size_t size) {
03070   _set_bit(4);
03071   if (default_expression_ == &_default_default_expression_) {
03072     default_expression_ = new ::std::string;
03073   }
03074   default_expression_->assign(reinterpret_cast<const char*>(value), size);
03075 }
03076 inline ::std::string* Table_Field_FieldOptions::mutable_default_expression() {
03077   _set_bit(4);
03078   if (default_expression_ == &_default_default_expression_) {
03079     default_expression_ = new ::std::string;
03080   }
03081   return default_expression_;
03082 }
03083 
03084 // optional string update_expression = 6;
03085 inline bool Table_Field_FieldOptions::has_update_expression() const {
03086   return _has_bit(5);
03087 }
03088 inline void Table_Field_FieldOptions::clear_update_expression() {
03089   if (update_expression_ != &_default_update_expression_) {
03090     update_expression_->clear();
03091   }
03092   _clear_bit(5);
03093 }
03094 inline const ::std::string& Table_Field_FieldOptions::update_expression() const {
03095   return *update_expression_;
03096 }
03097 inline void Table_Field_FieldOptions::set_update_expression(const ::std::string& value) {
03098   _set_bit(5);
03099   if (update_expression_ == &_default_update_expression_) {
03100     update_expression_ = new ::std::string;
03101   }
03102   update_expression_->assign(value);
03103 }
03104 inline void Table_Field_FieldOptions::set_update_expression(const char* value) {
03105   _set_bit(5);
03106   if (update_expression_ == &_default_update_expression_) {
03107     update_expression_ = new ::std::string;
03108   }
03109   update_expression_->assign(value);
03110 }
03111 inline void Table_Field_FieldOptions::set_update_expression(const char* value, size_t size) {
03112   _set_bit(5);
03113   if (update_expression_ == &_default_update_expression_) {
03114     update_expression_ = new ::std::string;
03115   }
03116   update_expression_->assign(reinterpret_cast<const char*>(value), size);
03117 }
03118 inline ::std::string* Table_Field_FieldOptions::mutable_update_expression() {
03119   _set_bit(5);
03120   if (update_expression_ == &_default_update_expression_) {
03121     update_expression_ = new ::std::string;
03122   }
03123   return update_expression_;
03124 }
03125 
03126 // -------------------------------------------------------------------
03127 
03128 // Table_Field_FieldConstraints
03129 
03130 // optional bool is_nullable = 1 [default = true];
03131 inline bool Table_Field_FieldConstraints::has_is_nullable() const {
03132   return _has_bit(0);
03133 }
03134 inline void Table_Field_FieldConstraints::clear_is_nullable() {
03135   is_nullable_ = true;
03136   _clear_bit(0);
03137 }
03138 inline bool Table_Field_FieldConstraints::is_nullable() const {
03139   return is_nullable_;
03140 }
03141 inline void Table_Field_FieldConstraints::set_is_nullable(bool value) {
03142   _set_bit(0);
03143   is_nullable_ = value;
03144 }
03145 
03146 // optional bool is_unsigned = 2 [default = false];
03147 inline bool Table_Field_FieldConstraints::has_is_unsigned() const {
03148   return _has_bit(1);
03149 }
03150 inline void Table_Field_FieldConstraints::clear_is_unsigned() {
03151   is_unsigned_ = false;
03152   _clear_bit(1);
03153 }
03154 inline bool Table_Field_FieldConstraints::is_unsigned() const {
03155   return is_unsigned_;
03156 }
03157 inline void Table_Field_FieldConstraints::set_is_unsigned(bool value) {
03158   _set_bit(1);
03159   is_unsigned_ = value;
03160 }
03161 
03162 // optional bool is_notnull = 3 [default = false];
03163 inline bool Table_Field_FieldConstraints::has_is_notnull() const {
03164   return _has_bit(2);
03165 }
03166 inline void Table_Field_FieldConstraints::clear_is_notnull() {
03167   is_notnull_ = false;
03168   _clear_bit(2);
03169 }
03170 inline bool Table_Field_FieldConstraints::is_notnull() const {
03171   return is_notnull_;
03172 }
03173 inline void Table_Field_FieldConstraints::set_is_notnull(bool value) {
03174   _set_bit(2);
03175   is_notnull_ = value;
03176 }
03177 
03178 // optional bool is_unique = 4 [default = false];
03179 inline bool Table_Field_FieldConstraints::has_is_unique() const {
03180   return _has_bit(3);
03181 }
03182 inline void Table_Field_FieldConstraints::clear_is_unique() {
03183   is_unique_ = false;
03184   _clear_bit(3);
03185 }
03186 inline bool Table_Field_FieldConstraints::is_unique() const {
03187   return is_unique_;
03188 }
03189 inline void Table_Field_FieldConstraints::set_is_unique(bool value) {
03190   _set_bit(3);
03191   is_unique_ = value;
03192 }
03193 
03194 // repeated string expression = 16;
03195 inline int Table_Field_FieldConstraints::expression_size() const {
03196   return expression_.size();
03197 }
03198 inline void Table_Field_FieldConstraints::clear_expression() {
03199   expression_.Clear();
03200 }
03201 inline const ::std::string& Table_Field_FieldConstraints::expression(int index) const {
03202   return expression_.Get(index);
03203 }
03204 inline ::std::string* Table_Field_FieldConstraints::mutable_expression(int index) {
03205   return expression_.Mutable(index);
03206 }
03207 inline void Table_Field_FieldConstraints::set_expression(int index, const ::std::string& value) {
03208   expression_.Mutable(index)->assign(value);
03209 }
03210 inline void Table_Field_FieldConstraints::set_expression(int index, const char* value) {
03211   expression_.Mutable(index)->assign(value);
03212 }
03213 inline void Table_Field_FieldConstraints::set_expression(int index, const char* value, size_t size) {
03214   expression_.Mutable(index)->assign(
03215     reinterpret_cast<const char*>(value), size);
03216 }
03217 inline ::std::string* Table_Field_FieldConstraints::add_expression() {
03218   return expression_.Add();
03219 }
03220 inline void Table_Field_FieldConstraints::add_expression(const ::std::string& value) {
03221   expression_.Add()->assign(value);
03222 }
03223 inline void Table_Field_FieldConstraints::add_expression(const char* value) {
03224   expression_.Add()->assign(value);
03225 }
03226 inline void Table_Field_FieldConstraints::add_expression(const char* value, size_t size) {
03227   expression_.Add()->assign(reinterpret_cast<const char*>(value), size);
03228 }
03229 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
03230 Table_Field_FieldConstraints::expression() const {
03231   return expression_;
03232 }
03233 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
03234 Table_Field_FieldConstraints::mutable_expression() {
03235   return &expression_;
03236 }
03237 
03238 // -------------------------------------------------------------------
03239 
03240 // Table_Field_NumericFieldOptions
03241 
03242 // optional bool is_autoincrement = 1 [default = false];
03243 inline bool Table_Field_NumericFieldOptions::has_is_autoincrement() const {
03244   return _has_bit(0);
03245 }
03246 inline void Table_Field_NumericFieldOptions::clear_is_autoincrement() {
03247   is_autoincrement_ = false;
03248   _clear_bit(0);
03249 }
03250 inline bool Table_Field_NumericFieldOptions::is_autoincrement() const {
03251   return is_autoincrement_;
03252 }
03253 inline void Table_Field_NumericFieldOptions::set_is_autoincrement(bool value) {
03254   _set_bit(0);
03255   is_autoincrement_ = value;
03256 }
03257 
03258 // optional uint32 scale = 2;
03259 inline bool Table_Field_NumericFieldOptions::has_scale() const {
03260   return _has_bit(1);
03261 }
03262 inline void Table_Field_NumericFieldOptions::clear_scale() {
03263   scale_ = 0u;
03264   _clear_bit(1);
03265 }
03266 inline ::google::protobuf::uint32 Table_Field_NumericFieldOptions::scale() const {
03267   return scale_;
03268 }
03269 inline void Table_Field_NumericFieldOptions::set_scale(::google::protobuf::uint32 value) {
03270   _set_bit(1);
03271   scale_ = value;
03272 }
03273 
03274 // optional uint32 precision = 3;
03275 inline bool Table_Field_NumericFieldOptions::has_precision() const {
03276   return _has_bit(2);
03277 }
03278 inline void Table_Field_NumericFieldOptions::clear_precision() {
03279   precision_ = 0u;
03280   _clear_bit(2);
03281 }
03282 inline ::google::protobuf::uint32 Table_Field_NumericFieldOptions::precision() const {
03283   return precision_;
03284 }
03285 inline void Table_Field_NumericFieldOptions::set_precision(::google::protobuf::uint32 value) {
03286   _set_bit(2);
03287   precision_ = value;
03288 }
03289 
03290 // -------------------------------------------------------------------
03291 
03292 // Table_Field_StringFieldOptions
03293 
03294 // optional bool is_fixed_width = 1 [default = false];
03295 inline bool Table_Field_StringFieldOptions::has_is_fixed_width() const {
03296   return _has_bit(0);
03297 }
03298 inline void Table_Field_StringFieldOptions::clear_is_fixed_width() {
03299   is_fixed_width_ = false;
03300   _clear_bit(0);
03301 }
03302 inline bool Table_Field_StringFieldOptions::is_fixed_width() const {
03303   return is_fixed_width_;
03304 }
03305 inline void Table_Field_StringFieldOptions::set_is_fixed_width(bool value) {
03306   _set_bit(0);
03307   is_fixed_width_ = value;
03308 }
03309 
03310 // optional uint32 length = 2;
03311 inline bool Table_Field_StringFieldOptions::has_length() const {
03312   return _has_bit(1);
03313 }
03314 inline void Table_Field_StringFieldOptions::clear_length() {
03315   length_ = 0u;
03316   _clear_bit(1);
03317 }
03318 inline ::google::protobuf::uint32 Table_Field_StringFieldOptions::length() const {
03319   return length_;
03320 }
03321 inline void Table_Field_StringFieldOptions::set_length(::google::protobuf::uint32 value) {
03322   _set_bit(1);
03323   length_ = value;
03324 }
03325 
03326 // optional uint32 collation_id = 3;
03327 inline bool Table_Field_StringFieldOptions::has_collation_id() const {
03328   return _has_bit(2);
03329 }
03330 inline void Table_Field_StringFieldOptions::clear_collation_id() {
03331   collation_id_ = 0u;
03332   _clear_bit(2);
03333 }
03334 inline ::google::protobuf::uint32 Table_Field_StringFieldOptions::collation_id() const {
03335   return collation_id_;
03336 }
03337 inline void Table_Field_StringFieldOptions::set_collation_id(::google::protobuf::uint32 value) {
03338   _set_bit(2);
03339   collation_id_ = value;
03340 }
03341 
03342 // optional string collation = 4;
03343 inline bool Table_Field_StringFieldOptions::has_collation() const {
03344   return _has_bit(3);
03345 }
03346 inline void Table_Field_StringFieldOptions::clear_collation() {
03347   if (collation_ != &_default_collation_) {
03348     collation_->clear();
03349   }
03350   _clear_bit(3);
03351 }
03352 inline const ::std::string& Table_Field_StringFieldOptions::collation() const {
03353   return *collation_;
03354 }
03355 inline void Table_Field_StringFieldOptions::set_collation(const ::std::string& value) {
03356   _set_bit(3);
03357   if (collation_ == &_default_collation_) {
03358     collation_ = new ::std::string;
03359   }
03360   collation_->assign(value);
03361 }
03362 inline void Table_Field_StringFieldOptions::set_collation(const char* value) {
03363   _set_bit(3);
03364   if (collation_ == &_default_collation_) {
03365     collation_ = new ::std::string;
03366   }
03367   collation_->assign(value);
03368 }
03369 inline void Table_Field_StringFieldOptions::set_collation(const char* value, size_t size) {
03370   _set_bit(3);
03371   if (collation_ == &_default_collation_) {
03372     collation_ = new ::std::string;
03373   }
03374   collation_->assign(reinterpret_cast<const char*>(value), size);
03375 }
03376 inline ::std::string* Table_Field_StringFieldOptions::mutable_collation() {
03377   _set_bit(3);
03378   if (collation_ == &_default_collation_) {
03379     collation_ = new ::std::string;
03380   }
03381   return collation_;
03382 }
03383 
03384 // -------------------------------------------------------------------
03385 
03386 // Table_Field_EnumerationValues
03387 
03388 // optional uint32 collation_id = 2;
03389 inline bool Table_Field_EnumerationValues::has_collation_id() const {
03390   return _has_bit(0);
03391 }
03392 inline void Table_Field_EnumerationValues::clear_collation_id() {
03393   collation_id_ = 0u;
03394   _clear_bit(0);
03395 }
03396 inline ::google::protobuf::uint32 Table_Field_EnumerationValues::collation_id() const {
03397   return collation_id_;
03398 }
03399 inline void Table_Field_EnumerationValues::set_collation_id(::google::protobuf::uint32 value) {
03400   _set_bit(0);
03401   collation_id_ = value;
03402 }
03403 
03404 // optional string collation = 3;
03405 inline bool Table_Field_EnumerationValues::has_collation() const {
03406   return _has_bit(1);
03407 }
03408 inline void Table_Field_EnumerationValues::clear_collation() {
03409   if (collation_ != &_default_collation_) {
03410     collation_->clear();
03411   }
03412   _clear_bit(1);
03413 }
03414 inline const ::std::string& Table_Field_EnumerationValues::collation() const {
03415   return *collation_;
03416 }
03417 inline void Table_Field_EnumerationValues::set_collation(const ::std::string& value) {
03418   _set_bit(1);
03419   if (collation_ == &_default_collation_) {
03420     collation_ = new ::std::string;
03421   }
03422   collation_->assign(value);
03423 }
03424 inline void Table_Field_EnumerationValues::set_collation(const char* value) {
03425   _set_bit(1);
03426   if (collation_ == &_default_collation_) {
03427     collation_ = new ::std::string;
03428   }
03429   collation_->assign(value);
03430 }
03431 inline void Table_Field_EnumerationValues::set_collation(const char* value, size_t size) {
03432   _set_bit(1);
03433   if (collation_ == &_default_collation_) {
03434     collation_ = new ::std::string;
03435   }
03436   collation_->assign(reinterpret_cast<const char*>(value), size);
03437 }
03438 inline ::std::string* Table_Field_EnumerationValues::mutable_collation() {
03439   _set_bit(1);
03440   if (collation_ == &_default_collation_) {
03441     collation_ = new ::std::string;
03442   }
03443   return collation_;
03444 }
03445 
03446 // repeated string field_value = 4;
03447 inline int Table_Field_EnumerationValues::field_value_size() const {
03448   return field_value_.size();
03449 }
03450 inline void Table_Field_EnumerationValues::clear_field_value() {
03451   field_value_.Clear();
03452 }
03453 inline const ::std::string& Table_Field_EnumerationValues::field_value(int index) const {
03454   return field_value_.Get(index);
03455 }
03456 inline ::std::string* Table_Field_EnumerationValues::mutable_field_value(int index) {
03457   return field_value_.Mutable(index);
03458 }
03459 inline void Table_Field_EnumerationValues::set_field_value(int index, const ::std::string& value) {
03460   field_value_.Mutable(index)->assign(value);
03461 }
03462 inline void Table_Field_EnumerationValues::set_field_value(int index, const char* value) {
03463   field_value_.Mutable(index)->assign(value);
03464 }
03465 inline void Table_Field_EnumerationValues::set_field_value(int index, const char* value, size_t size) {
03466   field_value_.Mutable(index)->assign(
03467     reinterpret_cast<const char*>(value), size);
03468 }
03469 inline ::std::string* Table_Field_EnumerationValues::add_field_value() {
03470   return field_value_.Add();
03471 }
03472 inline void Table_Field_EnumerationValues::add_field_value(const ::std::string& value) {
03473   field_value_.Add()->assign(value);
03474 }
03475 inline void Table_Field_EnumerationValues::add_field_value(const char* value) {
03476   field_value_.Add()->assign(value);
03477 }
03478 inline void Table_Field_EnumerationValues::add_field_value(const char* value, size_t size) {
03479   field_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
03480 }
03481 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
03482 Table_Field_EnumerationValues::field_value() const {
03483   return field_value_;
03484 }
03485 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
03486 Table_Field_EnumerationValues::mutable_field_value() {
03487   return &field_value_;
03488 }
03489 
03490 // -------------------------------------------------------------------
03491 
03492 // Table_Field_TimeFieldOptions
03493 
03494 // optional bool microseconds = 1;
03495 inline bool Table_Field_TimeFieldOptions::has_microseconds() const {
03496   return _has_bit(0);
03497 }
03498 inline void Table_Field_TimeFieldOptions::clear_microseconds() {
03499   microseconds_ = false;
03500   _clear_bit(0);
03501 }
03502 inline bool Table_Field_TimeFieldOptions::microseconds() const {
03503   return microseconds_;
03504 }
03505 inline void Table_Field_TimeFieldOptions::set_microseconds(bool value) {
03506   _set_bit(0);
03507   microseconds_ = value;
03508 }
03509 
03510 // -------------------------------------------------------------------
03511 
03512 // Table_Field
03513 
03514 // required string name = 1;
03515 inline bool Table_Field::has_name() const {
03516   return _has_bit(0);
03517 }
03518 inline void Table_Field::clear_name() {
03519   if (name_ != &_default_name_) {
03520     name_->clear();
03521   }
03522   _clear_bit(0);
03523 }
03524 inline const ::std::string& Table_Field::name() const {
03525   return *name_;
03526 }
03527 inline void Table_Field::set_name(const ::std::string& value) {
03528   _set_bit(0);
03529   if (name_ == &_default_name_) {
03530     name_ = new ::std::string;
03531   }
03532   name_->assign(value);
03533 }
03534 inline void Table_Field::set_name(const char* value) {
03535   _set_bit(0);
03536   if (name_ == &_default_name_) {
03537     name_ = new ::std::string;
03538   }
03539   name_->assign(value);
03540 }
03541 inline void Table_Field::set_name(const char* value, size_t size) {
03542   _set_bit(0);
03543   if (name_ == &_default_name_) {
03544     name_ = new ::std::string;
03545   }
03546   name_->assign(reinterpret_cast<const char*>(value), size);
03547 }
03548 inline ::std::string* Table_Field::mutable_name() {
03549   _set_bit(0);
03550   if (name_ == &_default_name_) {
03551     name_ = new ::std::string;
03552   }
03553   return name_;
03554 }
03555 
03556 // required .drizzled.message.Table.Field.FieldType type = 2;
03557 inline bool Table_Field::has_type() const {
03558   return _has_bit(1);
03559 }
03560 inline void Table_Field::clear_type() {
03561   type_ = 0;
03562   _clear_bit(1);
03563 }
03564 inline ::drizzled::message::Table_Field_FieldType Table_Field::type() const {
03565   return static_cast< ::drizzled::message::Table_Field_FieldType >(type_);
03566 }
03567 inline void Table_Field::set_type(::drizzled::message::Table_Field_FieldType value) {
03568   GOOGLE_DCHECK(::drizzled::message::Table_Field_FieldType_IsValid(value));
03569   _set_bit(1);
03570   type_ = value;
03571 }
03572 
03573 // optional .drizzled.message.Table.Field.FieldOptions options = 4;
03574 inline bool Table_Field::has_options() const {
03575   return _has_bit(2);
03576 }
03577 inline void Table_Field::clear_options() {
03578   if (options_ != NULL) options_->::drizzled::message::Table_Field_FieldOptions::Clear();
03579   _clear_bit(2);
03580 }
03581 inline const ::drizzled::message::Table_Field_FieldOptions& Table_Field::options() const {
03582   return options_ != NULL ? *options_ : *default_instance_->options_;
03583 }
03584 inline ::drizzled::message::Table_Field_FieldOptions* Table_Field::mutable_options() {
03585   _set_bit(2);
03586   if (options_ == NULL) options_ = new ::drizzled::message::Table_Field_FieldOptions;
03587   return options_;
03588 }
03589 
03590 // optional .drizzled.message.Table.Field.FieldConstraints constraints = 5;
03591 inline bool Table_Field::has_constraints() const {
03592   return _has_bit(3);
03593 }
03594 inline void Table_Field::clear_constraints() {
03595   if (constraints_ != NULL) constraints_->::drizzled::message::Table_Field_FieldConstraints::Clear();
03596   _clear_bit(3);
03597 }
03598 inline const ::drizzled::message::Table_Field_FieldConstraints& Table_Field::constraints() const {
03599   return constraints_ != NULL ? *constraints_ : *default_instance_->constraints_;
03600 }
03601 inline ::drizzled::message::Table_Field_FieldConstraints* Table_Field::mutable_constraints() {
03602   _set_bit(3);
03603   if (constraints_ == NULL) constraints_ = new ::drizzled::message::Table_Field_FieldConstraints;
03604   return constraints_;
03605 }
03606 
03607 // optional .drizzled.message.Table.Field.NumericFieldOptions numeric_options = 6;
03608 inline bool Table_Field::has_numeric_options() const {
03609   return _has_bit(4);
03610 }
03611 inline void Table_Field::clear_numeric_options() {
03612   if (numeric_options_ != NULL) numeric_options_->::drizzled::message::Table_Field_NumericFieldOptions::Clear();
03613   _clear_bit(4);
03614 }
03615 inline const ::drizzled::message::Table_Field_NumericFieldOptions& Table_Field::numeric_options() const {
03616   return numeric_options_ != NULL ? *numeric_options_ : *default_instance_->numeric_options_;
03617 }
03618 inline ::drizzled::message::Table_Field_NumericFieldOptions* Table_Field::mutable_numeric_options() {
03619   _set_bit(4);
03620   if (numeric_options_ == NULL) numeric_options_ = new ::drizzled::message::Table_Field_NumericFieldOptions;
03621   return numeric_options_;
03622 }
03623 
03624 // optional .drizzled.message.Table.Field.StringFieldOptions string_options = 7;
03625 inline bool Table_Field::has_string_options() const {
03626   return _has_bit(5);
03627 }
03628 inline void Table_Field::clear_string_options() {
03629   if (string_options_ != NULL) string_options_->::drizzled::message::Table_Field_StringFieldOptions::Clear();
03630   _clear_bit(5);
03631 }
03632 inline const ::drizzled::message::Table_Field_StringFieldOptions& Table_Field::string_options() const {
03633   return string_options_ != NULL ? *string_options_ : *default_instance_->string_options_;
03634 }
03635 inline ::drizzled::message::Table_Field_StringFieldOptions* Table_Field::mutable_string_options() {
03636   _set_bit(5);
03637   if (string_options_ == NULL) string_options_ = new ::drizzled::message::Table_Field_StringFieldOptions;
03638   return string_options_;
03639 }
03640 
03641 // optional .drizzled.message.Table.Field.TimeFieldOptions time_options = 8;
03642 inline bool Table_Field::has_time_options() const {
03643   return _has_bit(6);
03644 }
03645 inline void Table_Field::clear_time_options() {
03646   if (time_options_ != NULL) time_options_->::drizzled::message::Table_Field_TimeFieldOptions::Clear();
03647   _clear_bit(6);
03648 }
03649 inline const ::drizzled::message::Table_Field_TimeFieldOptions& Table_Field::time_options() const {
03650   return time_options_ != NULL ? *time_options_ : *default_instance_->time_options_;
03651 }
03652 inline ::drizzled::message::Table_Field_TimeFieldOptions* Table_Field::mutable_time_options() {
03653   _set_bit(6);
03654   if (time_options_ == NULL) time_options_ = new ::drizzled::message::Table_Field_TimeFieldOptions;
03655   return time_options_;
03656 }
03657 
03658 // optional string comment = 16;
03659 inline bool Table_Field::has_comment() const {
03660   return _has_bit(7);
03661 }
03662 inline void Table_Field::clear_comment() {
03663   if (comment_ != &_default_comment_) {
03664     comment_->clear();
03665   }
03666   _clear_bit(7);
03667 }
03668 inline const ::std::string& Table_Field::comment() const {
03669   return *comment_;
03670 }
03671 inline void Table_Field::set_comment(const ::std::string& value) {
03672   _set_bit(7);
03673   if (comment_ == &_default_comment_) {
03674     comment_ = new ::std::string;
03675   }
03676   comment_->assign(value);
03677 }
03678 inline void Table_Field::set_comment(const char* value) {
03679   _set_bit(7);
03680   if (comment_ == &_default_comment_) {
03681     comment_ = new ::std::string;
03682   }
03683   comment_->assign(value);
03684 }
03685 inline void Table_Field::set_comment(const char* value, size_t size) {
03686   _set_bit(7);
03687   if (comment_ == &_default_comment_) {
03688     comment_ = new ::std::string;
03689   }
03690   comment_->assign(reinterpret_cast<const char*>(value), size);
03691 }
03692 inline ::std::string* Table_Field::mutable_comment() {
03693   _set_bit(7);
03694   if (comment_ == &_default_comment_) {
03695     comment_ = new ::std::string;
03696   }
03697   return comment_;
03698 }
03699 
03700 // optional .drizzled.message.Table.Field.EnumerationValues enumeration_values = 17;
03701 inline bool Table_Field::has_enumeration_values() const {
03702   return _has_bit(8);
03703 }
03704 inline void Table_Field::clear_enumeration_values() {
03705   if (enumeration_values_ != NULL) enumeration_values_->::drizzled::message::Table_Field_EnumerationValues::Clear();
03706   _clear_bit(8);
03707 }
03708 inline const ::drizzled::message::Table_Field_EnumerationValues& Table_Field::enumeration_values() const {
03709   return enumeration_values_ != NULL ? *enumeration_values_ : *default_instance_->enumeration_values_;
03710 }
03711 inline ::drizzled::message::Table_Field_EnumerationValues* Table_Field::mutable_enumeration_values() {
03712   _set_bit(8);
03713   if (enumeration_values_ == NULL) enumeration_values_ = new ::drizzled::message::Table_Field_EnumerationValues;
03714   return enumeration_values_;
03715 }
03716 
03717 // -------------------------------------------------------------------
03718 
03719 // Table_Index_IndexPart
03720 
03721 // required uint32 fieldnr = 1;
03722 inline bool Table_Index_IndexPart::has_fieldnr() const {
03723   return _has_bit(0);
03724 }
03725 inline void Table_Index_IndexPart::clear_fieldnr() {
03726   fieldnr_ = 0u;
03727   _clear_bit(0);
03728 }
03729 inline ::google::protobuf::uint32 Table_Index_IndexPart::fieldnr() const {
03730   return fieldnr_;
03731 }
03732 inline void Table_Index_IndexPart::set_fieldnr(::google::protobuf::uint32 value) {
03733   _set_bit(0);
03734   fieldnr_ = value;
03735 }
03736 
03737 // optional uint32 compare_length = 2;
03738 inline bool Table_Index_IndexPart::has_compare_length() const {
03739   return _has_bit(1);
03740 }
03741 inline void Table_Index_IndexPart::clear_compare_length() {
03742   compare_length_ = 0u;
03743   _clear_bit(1);
03744 }
03745 inline ::google::protobuf::uint32 Table_Index_IndexPart::compare_length() const {
03746   return compare_length_;
03747 }
03748 inline void Table_Index_IndexPart::set_compare_length(::google::protobuf::uint32 value) {
03749   _set_bit(1);
03750   compare_length_ = value;
03751 }
03752 
03753 // optional bool in_reverse_order = 3 [default = false];
03754 inline bool Table_Index_IndexPart::has_in_reverse_order() const {
03755   return _has_bit(2);
03756 }
03757 inline void Table_Index_IndexPart::clear_in_reverse_order() {
03758   in_reverse_order_ = false;
03759   _clear_bit(2);
03760 }
03761 inline bool Table_Index_IndexPart::in_reverse_order() const {
03762   return in_reverse_order_;
03763 }
03764 inline void Table_Index_IndexPart::set_in_reverse_order(bool value) {
03765   _set_bit(2);
03766   in_reverse_order_ = value;
03767 }
03768 
03769 // -------------------------------------------------------------------
03770 
03771 // Table_Index_Options
03772 
03773 // optional bool pack_key = 1;
03774 inline bool Table_Index_Options::has_pack_key() const {
03775   return _has_bit(0);
03776 }
03777 inline void Table_Index_Options::clear_pack_key() {
03778   pack_key_ = false;
03779   _clear_bit(0);
03780 }
03781 inline bool Table_Index_Options::pack_key() const {
03782   return pack_key_;
03783 }
03784 inline void Table_Index_Options::set_pack_key(bool value) {
03785   _set_bit(0);
03786   pack_key_ = value;
03787 }
03788 
03789 // optional bool binary_pack_key = 2;
03790 inline bool Table_Index_Options::has_binary_pack_key() const {
03791   return _has_bit(1);
03792 }
03793 inline void Table_Index_Options::clear_binary_pack_key() {
03794   binary_pack_key_ = false;
03795   _clear_bit(1);
03796 }
03797 inline bool Table_Index_Options::binary_pack_key() const {
03798   return binary_pack_key_;
03799 }
03800 inline void Table_Index_Options::set_binary_pack_key(bool value) {
03801   _set_bit(1);
03802   binary_pack_key_ = value;
03803 }
03804 
03805 // optional bool var_length_key = 3;
03806 inline bool Table_Index_Options::has_var_length_key() const {
03807   return _has_bit(2);
03808 }
03809 inline void Table_Index_Options::clear_var_length_key() {
03810   var_length_key_ = false;
03811   _clear_bit(2);
03812 }
03813 inline bool Table_Index_Options::var_length_key() const {
03814   return var_length_key_;
03815 }
03816 inline void Table_Index_Options::set_var_length_key(bool value) {
03817   _set_bit(2);
03818   var_length_key_ = value;
03819 }
03820 
03821 // optional bool null_part_key = 4;
03822 inline bool Table_Index_Options::has_null_part_key() const {
03823   return _has_bit(3);
03824 }
03825 inline void Table_Index_Options::clear_null_part_key() {
03826   null_part_key_ = false;
03827   _clear_bit(3);
03828 }
03829 inline bool Table_Index_Options::null_part_key() const {
03830   return null_part_key_;
03831 }
03832 inline void Table_Index_Options::set_null_part_key(bool value) {
03833   _set_bit(3);
03834   null_part_key_ = value;
03835 }
03836 
03837 // optional uint32 key_block_size = 5;
03838 inline bool Table_Index_Options::has_key_block_size() const {
03839   return _has_bit(4);
03840 }
03841 inline void Table_Index_Options::clear_key_block_size() {
03842   key_block_size_ = 0u;
03843   _clear_bit(4);
03844 }
03845 inline ::google::protobuf::uint32 Table_Index_Options::key_block_size() const {
03846   return key_block_size_;
03847 }
03848 inline void Table_Index_Options::set_key_block_size(::google::protobuf::uint32 value) {
03849   _set_bit(4);
03850   key_block_size_ = value;
03851 }
03852 
03853 // optional bool has_partial_segments = 6;
03854 inline bool Table_Index_Options::has_has_partial_segments() const {
03855   return _has_bit(5);
03856 }
03857 inline void Table_Index_Options::clear_has_partial_segments() {
03858   has_partial_segments_ = false;
03859   _clear_bit(5);
03860 }
03861 inline bool Table_Index_Options::has_partial_segments() const {
03862   return has_partial_segments_;
03863 }
03864 inline void Table_Index_Options::set_has_partial_segments(bool value) {
03865   _set_bit(5);
03866   has_partial_segments_ = value;
03867 }
03868 
03869 // optional bool auto_generated_key = 7;
03870 inline bool Table_Index_Options::has_auto_generated_key() const {
03871   return _has_bit(6);
03872 }
03873 inline void Table_Index_Options::clear_auto_generated_key() {
03874   auto_generated_key_ = false;
03875   _clear_bit(6);
03876 }
03877 inline bool Table_Index_Options::auto_generated_key() const {
03878   return auto_generated_key_;
03879 }
03880 inline void Table_Index_Options::set_auto_generated_key(bool value) {
03881   _set_bit(6);
03882   auto_generated_key_ = value;
03883 }
03884 
03885 // -------------------------------------------------------------------
03886 
03887 // Table_Index
03888 
03889 // required string name = 1;
03890 inline bool Table_Index::has_name() const {
03891   return _has_bit(0);
03892 }
03893 inline void Table_Index::clear_name() {
03894   if (name_ != &_default_name_) {
03895     name_->clear();
03896   }
03897   _clear_bit(0);
03898 }
03899 inline const ::std::string& Table_Index::name() const {
03900   return *name_;
03901 }
03902 inline void Table_Index::set_name(const ::std::string& value) {
03903   _set_bit(0);
03904   if (name_ == &_default_name_) {
03905     name_ = new ::std::string;
03906   }
03907   name_->assign(value);
03908 }
03909 inline void Table_Index::set_name(const char* value) {
03910   _set_bit(0);
03911   if (name_ == &_default_name_) {
03912     name_ = new ::std::string;
03913   }
03914   name_->assign(value);
03915 }
03916 inline void Table_Index::set_name(const char* value, size_t size) {
03917   _set_bit(0);
03918   if (name_ == &_default_name_) {
03919     name_ = new ::std::string;
03920   }
03921   name_->assign(reinterpret_cast<const char*>(value), size);
03922 }
03923 inline ::std::string* Table_Index::mutable_name() {
03924   _set_bit(0);
03925   if (name_ == &_default_name_) {
03926     name_ = new ::std::string;
03927   }
03928   return name_;
03929 }
03930 
03931 // required bool is_primary = 2;
03932 inline bool Table_Index::has_is_primary() const {
03933   return _has_bit(1);
03934 }
03935 inline void Table_Index::clear_is_primary() {
03936   is_primary_ = false;
03937   _clear_bit(1);
03938 }
03939 inline bool Table_Index::is_primary() const {
03940   return is_primary_;
03941 }
03942 inline void Table_Index::set_is_primary(bool value) {
03943   _set_bit(1);
03944   is_primary_ = value;
03945 }
03946 
03947 // required bool is_unique = 3;
03948 inline bool Table_Index::has_is_unique() const {
03949   return _has_bit(2);
03950 }
03951 inline void Table_Index::clear_is_unique() {
03952   is_unique_ = false;
03953   _clear_bit(2);
03954 }
03955 inline bool Table_Index::is_unique() const {
03956   return is_unique_;
03957 }
03958 inline void Table_Index::set_is_unique(bool value) {
03959   _set_bit(2);
03960   is_unique_ = value;
03961 }
03962 
03963 // required .drizzled.message.Table.Index.IndexType type = 4 [default = UNKNOWN_INDEX];
03964 inline bool Table_Index::has_type() const {
03965   return _has_bit(3);
03966 }
03967 inline void Table_Index::clear_type() {
03968   type_ = 0;
03969   _clear_bit(3);
03970 }
03971 inline ::drizzled::message::Table_Index_IndexType Table_Index::type() const {
03972   return static_cast< ::drizzled::message::Table_Index_IndexType >(type_);
03973 }
03974 inline void Table_Index::set_type(::drizzled::message::Table_Index_IndexType value) {
03975   GOOGLE_DCHECK(::drizzled::message::Table_Index_IndexType_IsValid(value));
03976   _set_bit(3);
03977   type_ = value;
03978 }
03979 
03980 // required uint32 key_length = 5;
03981 inline bool Table_Index::has_key_length() const {
03982   return _has_bit(4);
03983 }
03984 inline void Table_Index::clear_key_length() {
03985   key_length_ = 0u;
03986   _clear_bit(4);
03987 }
03988 inline ::google::protobuf::uint32 Table_Index::key_length() const {
03989   return key_length_;
03990 }
03991 inline void Table_Index::set_key_length(::google::protobuf::uint32 value) {
03992   _set_bit(4);
03993   key_length_ = value;
03994 }
03995 
03996 // repeated .drizzled.message.Table.Index.IndexPart index_part = 6;
03997 inline int Table_Index::index_part_size() const {
03998   return index_part_.size();
03999 }
04000 inline void Table_Index::clear_index_part() {
04001   index_part_.Clear();
04002 }
04003 inline const ::drizzled::message::Table_Index_IndexPart& Table_Index::index_part(int index) const {
04004   return index_part_.Get(index);
04005 }
04006 inline ::drizzled::message::Table_Index_IndexPart* Table_Index::mutable_index_part(int index) {
04007   return index_part_.Mutable(index);
04008 }
04009 inline ::drizzled::message::Table_Index_IndexPart* Table_Index::add_index_part() {
04010   return index_part_.Add();
04011 }
04012 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart >&
04013 Table_Index::index_part() const {
04014   return index_part_;
04015 }
04016 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart >*
04017 Table_Index::mutable_index_part() {
04018   return &index_part_;
04019 }
04020 
04021 // optional .drizzled.message.Table.Index.Options options = 7;
04022 inline bool Table_Index::has_options() const {
04023   return _has_bit(6);
04024 }
04025 inline void Table_Index::clear_options() {
04026   if (options_ != NULL) options_->::drizzled::message::Table_Index_Options::Clear();
04027   _clear_bit(6);
04028 }
04029 inline const ::drizzled::message::Table_Index_Options& Table_Index::options() const {
04030   return options_ != NULL ? *options_ : *default_instance_->options_;
04031 }
04032 inline ::drizzled::message::Table_Index_Options* Table_Index::mutable_options() {
04033   _set_bit(6);
04034   if (options_ == NULL) options_ = new ::drizzled::message::Table_Index_Options;
04035   return options_;
04036 }
04037 
04038 // optional string comment = 8;
04039 inline bool Table_Index::has_comment() const {
04040   return _has_bit(7);
04041 }
04042 inline void Table_Index::clear_comment() {
04043   if (comment_ != &_default_comment_) {
04044     comment_->clear();
04045   }
04046   _clear_bit(7);
04047 }
04048 inline const ::std::string& Table_Index::comment() const {
04049   return *comment_;
04050 }
04051 inline void Table_Index::set_comment(const ::std::string& value) {
04052   _set_bit(7);
04053   if (comment_ == &_default_comment_) {
04054     comment_ = new ::std::string;
04055   }
04056   comment_->assign(value);
04057 }
04058 inline void Table_Index::set_comment(const char* value) {
04059   _set_bit(7);
04060   if (comment_ == &_default_comment_) {
04061     comment_ = new ::std::string;
04062   }
04063   comment_->assign(value);
04064 }
04065 inline void Table_Index::set_comment(const char* value, size_t size) {
04066   _set_bit(7);
04067   if (comment_ == &_default_comment_) {
04068     comment_ = new ::std::string;
04069   }
04070   comment_->assign(reinterpret_cast<const char*>(value), size);
04071 }
04072 inline ::std::string* Table_Index::mutable_comment() {
04073   _set_bit(7);
04074   if (comment_ == &_default_comment_) {
04075     comment_ = new ::std::string;
04076   }
04077   return comment_;
04078 }
04079 
04080 // -------------------------------------------------------------------
04081 
04082 // Table
04083 
04084 // required string name = 1;
04085 inline bool Table::has_name() const {
04086   return _has_bit(0);
04087 }
04088 inline void Table::clear_name() {
04089   if (name_ != &_default_name_) {
04090     name_->clear();
04091   }
04092   _clear_bit(0);
04093 }
04094 inline const ::std::string& Table::name() const {
04095   return *name_;
04096 }
04097 inline void Table::set_name(const ::std::string& value) {
04098   _set_bit(0);
04099   if (name_ == &_default_name_) {
04100     name_ = new ::std::string;
04101   }
04102   name_->assign(value);
04103 }
04104 inline void Table::set_name(const char* value) {
04105   _set_bit(0);
04106   if (name_ == &_default_name_) {
04107     name_ = new ::std::string;
04108   }
04109   name_->assign(value);
04110 }
04111 inline void Table::set_name(const char* value, size_t size) {
04112   _set_bit(0);
04113   if (name_ == &_default_name_) {
04114     name_ = new ::std::string;
04115   }
04116   name_->assign(reinterpret_cast<const char*>(value), size);
04117 }
04118 inline ::std::string* Table::mutable_name() {
04119   _set_bit(0);
04120   if (name_ == &_default_name_) {
04121     name_ = new ::std::string;
04122   }
04123   return name_;
04124 }
04125 
04126 // required string schema = 6;
04127 inline bool Table::has_schema() const {
04128   return _has_bit(1);
04129 }
04130 inline void Table::clear_schema() {
04131   if (schema_ != &_default_schema_) {
04132     schema_->clear();
04133   }
04134   _clear_bit(1);
04135 }
04136 inline const ::std::string& Table::schema() const {
04137   return *schema_;
04138 }
04139 inline void Table::set_schema(const ::std::string& value) {
04140   _set_bit(1);
04141   if (schema_ == &_default_schema_) {
04142     schema_ = new ::std::string;
04143   }
04144   schema_->assign(value);
04145 }
04146 inline void Table::set_schema(const char* value) {
04147   _set_bit(1);
04148   if (schema_ == &_default_schema_) {
04149     schema_ = new ::std::string;
04150   }
04151   schema_->assign(value);
04152 }
04153 inline void Table::set_schema(const char* value, size_t size) {
04154   _set_bit(1);
04155   if (schema_ == &_default_schema_) {
04156     schema_ = new ::std::string;
04157   }
04158   schema_->assign(reinterpret_cast<const char*>(value), size);
04159 }
04160 inline ::std::string* Table::mutable_schema() {
04161   _set_bit(1);
04162   if (schema_ == &_default_schema_) {
04163     schema_ = new ::std::string;
04164   }
04165   return schema_;
04166 }
04167 
04168 // required .drizzled.message.Table.TableType type = 5;
04169 inline bool Table::has_type() const {
04170   return _has_bit(2);
04171 }
04172 inline void Table::clear_type() {
04173   type_ = 0;
04174   _clear_bit(2);
04175 }
04176 inline ::drizzled::message::Table_TableType Table::type() const {
04177   return static_cast< ::drizzled::message::Table_TableType >(type_);
04178 }
04179 inline void Table::set_type(::drizzled::message::Table_TableType value) {
04180   GOOGLE_DCHECK(::drizzled::message::Table_TableType_IsValid(value));
04181   _set_bit(2);
04182   type_ = value;
04183 }
04184 
04185 // required .drizzled.message.Engine engine = 2;
04186 inline bool Table::has_engine() const {
04187   return _has_bit(3);
04188 }
04189 inline void Table::clear_engine() {
04190   if (engine_ != NULL) engine_->::drizzled::message::Engine::Clear();
04191   _clear_bit(3);
04192 }
04193 inline const ::drizzled::message::Engine& Table::engine() const {
04194   return engine_ != NULL ? *engine_ : *default_instance_->engine_;
04195 }
04196 inline ::drizzled::message::Engine* Table::mutable_engine() {
04197   _set_bit(3);
04198   if (engine_ == NULL) engine_ = new ::drizzled::message::Engine;
04199   return engine_;
04200 }
04201 
04202 // repeated .drizzled.message.Table.Field field = 3;
04203 inline int Table::field_size() const {
04204   return field_.size();
04205 }
04206 inline void Table::clear_field() {
04207   field_.Clear();
04208 }
04209 inline const ::drizzled::message::Table_Field& Table::field(int index) const {
04210   return field_.Get(index);
04211 }
04212 inline ::drizzled::message::Table_Field* Table::mutable_field(int index) {
04213   return field_.Mutable(index);
04214 }
04215 inline ::drizzled::message::Table_Field* Table::add_field() {
04216   return field_.Add();
04217 }
04218 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >&
04219 Table::field() const {
04220   return field_;
04221 }
04222 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >*
04223 Table::mutable_field() {
04224   return &field_;
04225 }
04226 
04227 // repeated .drizzled.message.Table.Index indexes = 4;
04228 inline int Table::indexes_size() const {
04229   return indexes_.size();
04230 }
04231 inline void Table::clear_indexes() {
04232   indexes_.Clear();
04233 }
04234 inline const ::drizzled::message::Table_Index& Table::indexes(int index) const {
04235   return indexes_.Get(index);
04236 }
04237 inline ::drizzled::message::Table_Index* Table::mutable_indexes(int index) {
04238   return indexes_.Mutable(index);
04239 }
04240 inline ::drizzled::message::Table_Index* Table::add_indexes() {
04241   return indexes_.Add();
04242 }
04243 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index >&
04244 Table::indexes() const {
04245   return indexes_;
04246 }
04247 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index >*
04248 Table::mutable_indexes() {
04249   return &indexes_;
04250 }
04251 
04252 // repeated .drizzled.message.Table.ForeignKeyConstraint fk_constraint = 8;
04253 inline int Table::fk_constraint_size() const {
04254   return fk_constraint_.size();
04255 }
04256 inline void Table::clear_fk_constraint() {
04257   fk_constraint_.Clear();
04258 }
04259 inline const ::drizzled::message::Table_ForeignKeyConstraint& Table::fk_constraint(int index) const {
04260   return fk_constraint_.Get(index);
04261 }
04262 inline ::drizzled::message::Table_ForeignKeyConstraint* Table::mutable_fk_constraint(int index) {
04263   return fk_constraint_.Mutable(index);
04264 }
04265 inline ::drizzled::message::Table_ForeignKeyConstraint* Table::add_fk_constraint() {
04266   return fk_constraint_.Add();
04267 }
04268 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint >&
04269 Table::fk_constraint() const {
04270   return fk_constraint_;
04271 }
04272 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint >*
04273 Table::mutable_fk_constraint() {
04274   return &fk_constraint_;
04275 }
04276 
04277 // optional .drizzled.message.Table.TableOptions options = 9;
04278 inline bool Table::has_options() const {
04279   return _has_bit(7);
04280 }
04281 inline void Table::clear_options() {
04282   if (options_ != NULL) options_->::drizzled::message::Table_TableOptions::Clear();
04283   _clear_bit(7);
04284 }
04285 inline const ::drizzled::message::Table_TableOptions& Table::options() const {
04286   return options_ != NULL ? *options_ : *default_instance_->options_;
04287 }
04288 inline ::drizzled::message::Table_TableOptions* Table::mutable_options() {
04289   _set_bit(7);
04290   if (options_ == NULL) options_ = new ::drizzled::message::Table_TableOptions;
04291   return options_;
04292 }
04293 
04294 // required uint64 creation_timestamp = 11 [default = 0];
04295 inline bool Table::has_creation_timestamp() const {
04296   return _has_bit(8);
04297 }
04298 inline void Table::clear_creation_timestamp() {
04299   creation_timestamp_ = GOOGLE_ULONGLONG(0);
04300   _clear_bit(8);
04301 }
04302 inline ::google::protobuf::uint64 Table::creation_timestamp() const {
04303   return creation_timestamp_;
04304 }
04305 inline void Table::set_creation_timestamp(::google::protobuf::uint64 value) {
04306   _set_bit(8);
04307   creation_timestamp_ = value;
04308 }
04309 
04310 // required uint64 update_timestamp = 12 [default = 0];
04311 inline bool Table::has_update_timestamp() const {
04312   return _has_bit(9);
04313 }
04314 inline void Table::clear_update_timestamp() {
04315   update_timestamp_ = GOOGLE_ULONGLONG(0);
04316   _clear_bit(9);
04317 }
04318 inline ::google::protobuf::uint64 Table::update_timestamp() const {
04319   return update_timestamp_;
04320 }
04321 inline void Table::set_update_timestamp(::google::protobuf::uint64 value) {
04322   _set_bit(9);
04323   update_timestamp_ = value;
04324 }
04325 
04326 // optional string catalog = 13;
04327 inline bool Table::has_catalog() const {
04328   return _has_bit(10);
04329 }
04330 inline void Table::clear_catalog() {
04331   if (catalog_ != &_default_catalog_) {
04332     catalog_->clear();
04333   }
04334   _clear_bit(10);
04335 }
04336 inline const ::std::string& Table::catalog() const {
04337   return *catalog_;
04338 }
04339 inline void Table::set_catalog(const ::std::string& value) {
04340   _set_bit(10);
04341   if (catalog_ == &_default_catalog_) {
04342     catalog_ = new ::std::string;
04343   }
04344   catalog_->assign(value);
04345 }
04346 inline void Table::set_catalog(const char* value) {
04347   _set_bit(10);
04348   if (catalog_ == &_default_catalog_) {
04349     catalog_ = new ::std::string;
04350   }
04351   catalog_->assign(value);
04352 }
04353 inline void Table::set_catalog(const char* value, size_t size) {
04354   _set_bit(10);
04355   if (catalog_ == &_default_catalog_) {
04356     catalog_ = new ::std::string;
04357   }
04358   catalog_->assign(reinterpret_cast<const char*>(value), size);
04359 }
04360 inline ::std::string* Table::mutable_catalog() {
04361   _set_bit(10);
04362   if (catalog_ == &_default_catalog_) {
04363     catalog_ = new ::std::string;
04364   }
04365   return catalog_;
04366 }
04367 
04368 // optional string uuid = 14;
04369 inline bool Table::has_uuid() const {
04370   return _has_bit(11);
04371 }
04372 inline void Table::clear_uuid() {
04373   if (uuid_ != &_default_uuid_) {
04374     uuid_->clear();
04375   }
04376   _clear_bit(11);
04377 }
04378 inline const ::std::string& Table::uuid() const {
04379   return *uuid_;
04380 }
04381 inline void Table::set_uuid(const ::std::string& value) {
04382   _set_bit(11);
04383   if (uuid_ == &_default_uuid_) {
04384     uuid_ = new ::std::string;
04385   }
04386   uuid_->assign(value);
04387 }
04388 inline void Table::set_uuid(const char* value) {
04389   _set_bit(11);
04390   if (uuid_ == &_default_uuid_) {
04391     uuid_ = new ::std::string;
04392   }
04393   uuid_->assign(value);
04394 }
04395 inline void Table::set_uuid(const char* value, size_t size) {
04396   _set_bit(11);
04397   if (uuid_ == &_default_uuid_) {
04398     uuid_ = new ::std::string;
04399   }
04400   uuid_->assign(reinterpret_cast<const char*>(value), size);
04401 }
04402 inline ::std::string* Table::mutable_uuid() {
04403   _set_bit(11);
04404   if (uuid_ == &_default_uuid_) {
04405     uuid_ = new ::std::string;
04406   }
04407   return uuid_;
04408 }
04409 
04410 // optional uint64 version = 15;
04411 inline bool Table::has_version() const {
04412   return _has_bit(12);
04413 }
04414 inline void Table::clear_version() {
04415   version_ = GOOGLE_ULONGLONG(0);
04416   _clear_bit(12);
04417 }
04418 inline ::google::protobuf::uint64 Table::version() const {
04419   return version_;
04420 }
04421 inline void Table::set_version(::google::protobuf::uint64 value) {
04422   _set_bit(12);
04423   version_ = value;
04424 }
04425 
04426 // optional .drizzled.message.ReplicationOptions replication_options = 16;
04427 inline bool Table::has_replication_options() const {
04428   return _has_bit(13);
04429 }
04430 inline void Table::clear_replication_options() {
04431   if (replication_options_ != NULL) replication_options_->::drizzled::message::ReplicationOptions::Clear();
04432   _clear_bit(13);
04433 }
04434 inline const ::drizzled::message::ReplicationOptions& Table::replication_options() const {
04435   return replication_options_ != NULL ? *replication_options_ : *default_instance_->replication_options_;
04436 }
04437 inline ::drizzled::message::ReplicationOptions* Table::mutable_replication_options() {
04438   _set_bit(13);
04439   if (replication_options_ == NULL) replication_options_ = new ::drizzled::message::ReplicationOptions;
04440   return replication_options_;
04441 }
04442 
04443 // -------------------------------------------------------------------
04444 
04445 // AlterTable
04446 
04447 // repeated .drizzled.message.Table.Field added_field = 1;
04448 inline int AlterTable::added_field_size() const {
04449   return added_field_.size();
04450 }
04451 inline void AlterTable::clear_added_field() {
04452   added_field_.Clear();
04453 }
04454 inline const ::drizzled::message::Table_Field& AlterTable::added_field(int index) const {
04455   return added_field_.Get(index);
04456 }
04457 inline ::drizzled::message::Table_Field* AlterTable::mutable_added_field(int index) {
04458   return added_field_.Mutable(index);
04459 }
04460 inline ::drizzled::message::Table_Field* AlterTable::add_added_field() {
04461   return added_field_.Add();
04462 }
04463 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >&
04464 AlterTable::added_field() const {
04465   return added_field_;
04466 }
04467 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >*
04468 AlterTable::mutable_added_field() {
04469   return &added_field_;
04470 }
04471 
04472 
04473 // @@protoc_insertion_point(namespace_scope)
04474 
04475 }  // namespace message
04476 }  // namespace drizzled
04477 
04478 #ifndef SWIG
04479 namespace google {
04480 namespace protobuf {
04481 
04482 template <>
04483 inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption>() {
04484   return ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption_descriptor();
04485 }
04486 template <>
04487 inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption>() {
04488   return ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption_descriptor();
04489 }
04490 template <>
04491 inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_Field_FieldType>() {
04492   return ::drizzled::message::Table_Field_FieldType_descriptor();
04493 }
04494 template <>
04495 inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_Index_IndexType>() {
04496   return ::drizzled::message::Table_Index_IndexType_descriptor();
04497 }
04498 template <>
04499 inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_TableType>() {
04500   return ::drizzled::message::Table_TableType_descriptor();
04501 }
04502 
04503 }  // namespace google
04504 }  // namespace protobuf
04505 #endif  // SWIG
04506 
04507 // @@protoc_insertion_point(global_scope)
04508 
04509 #endif  // PROTOBUF_table_2eproto__INCLUDED