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 < 2004000
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 2004000 < 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   inline ::std::string* release_collation();
00243   
00244   // optional uint32 collation_id = 3;
00245   inline bool has_collation_id() const;
00246   inline void clear_collation_id();
00247   static const int kCollationIdFieldNumber = 3;
00248   inline ::google::protobuf::uint32 collation_id() const;
00249   inline void set_collation_id(::google::protobuf::uint32 value);
00250   
00251   // optional string data_file_name = 5;
00252   inline bool has_data_file_name() const;
00253   inline void clear_data_file_name();
00254   static const int kDataFileNameFieldNumber = 5;
00255   inline const ::std::string& data_file_name() const;
00256   inline void set_data_file_name(const ::std::string& value);
00257   inline void set_data_file_name(const char* value);
00258   inline void set_data_file_name(const char* value, size_t size);
00259   inline ::std::string* mutable_data_file_name();
00260   inline ::std::string* release_data_file_name();
00261   
00262   // optional string index_file_name = 6;
00263   inline bool has_index_file_name() const;
00264   inline void clear_index_file_name();
00265   static const int kIndexFileNameFieldNumber = 6;
00266   inline const ::std::string& index_file_name() const;
00267   inline void set_index_file_name(const ::std::string& value);
00268   inline void set_index_file_name(const char* value);
00269   inline void set_index_file_name(const char* value, size_t size);
00270   inline ::std::string* mutable_index_file_name();
00271   inline ::std::string* release_index_file_name();
00272   
00273   // optional uint64 max_rows = 7;
00274   inline bool has_max_rows() const;
00275   inline void clear_max_rows();
00276   static const int kMaxRowsFieldNumber = 7;
00277   inline ::google::protobuf::uint64 max_rows() const;
00278   inline void set_max_rows(::google::protobuf::uint64 value);
00279   
00280   // optional uint64 min_rows = 8;
00281   inline bool has_min_rows() const;
00282   inline void clear_min_rows();
00283   static const int kMinRowsFieldNumber = 8;
00284   inline ::google::protobuf::uint64 min_rows() const;
00285   inline void set_min_rows(::google::protobuf::uint64 value);
00286   
00287   // optional uint64 auto_increment_value = 9;
00288   inline bool has_auto_increment_value() const;
00289   inline void clear_auto_increment_value();
00290   static const int kAutoIncrementValueFieldNumber = 9;
00291   inline ::google::protobuf::uint64 auto_increment_value() const;
00292   inline void set_auto_increment_value(::google::protobuf::uint64 value);
00293   
00294   // optional uint32 avg_row_length = 11;
00295   inline bool has_avg_row_length() const;
00296   inline void clear_avg_row_length();
00297   static const int kAvgRowLengthFieldNumber = 11;
00298   inline ::google::protobuf::uint32 avg_row_length() const;
00299   inline void set_avg_row_length(::google::protobuf::uint32 value);
00300   
00301   // optional uint32 block_size = 13;
00302   inline bool has_block_size() const;
00303   inline void clear_block_size();
00304   static const int kBlockSizeFieldNumber = 13;
00305   inline ::google::protobuf::uint32 block_size() const;
00306   inline void set_block_size(::google::protobuf::uint32 value);
00307   
00308   // optional string comment = 14;
00309   inline bool has_comment() const;
00310   inline void clear_comment();
00311   static const int kCommentFieldNumber = 14;
00312   inline const ::std::string& comment() const;
00313   inline void set_comment(const ::std::string& value);
00314   inline void set_comment(const char* value);
00315   inline void set_comment(const char* value, size_t size);
00316   inline ::std::string* mutable_comment();
00317   inline ::std::string* release_comment();
00318   
00319   // optional bool pack_record = 16;
00320   inline bool has_pack_record() const;
00321   inline void clear_pack_record();
00322   static const int kPackRecordFieldNumber = 16;
00323   inline bool pack_record() const;
00324   inline void set_pack_record(bool value);
00325   
00326   // optional bool checksum = 17;
00327   inline bool has_checksum() const;
00328   inline void clear_checksum();
00329   static const int kChecksumFieldNumber = 17;
00330   inline bool checksum() const;
00331   inline void set_checksum(bool value);
00332   
00333   // optional bool page_checksum = 18;
00334   inline bool has_page_checksum() const;
00335   inline void clear_page_checksum();
00336   static const int kPageChecksumFieldNumber = 18;
00337   inline bool page_checksum() const;
00338   inline void set_page_checksum(bool value);
00339   
00340   // optional bool delay_key_write = 19;
00341   inline bool has_delay_key_write() const;
00342   inline void clear_delay_key_write();
00343   static const int kDelayKeyWriteFieldNumber = 19;
00344   inline bool delay_key_write() const;
00345   inline void set_delay_key_write(bool value);
00346   
00347   // optional bool dont_replicate = 20;
00348   inline bool has_dont_replicate() const;
00349   inline void clear_dont_replicate();
00350   static const int kDontReplicateFieldNumber = 20;
00351   inline bool dont_replicate() const;
00352   inline void set_dont_replicate(bool value);
00353   
00354   // @@protoc_insertion_point(class_scope:drizzled.message.Table.TableOptions)
00355  private:
00356   inline void set_has_has_user_set_auto_increment_value();
00357   inline void clear_has_has_user_set_auto_increment_value();
00358   inline void set_has_collation();
00359   inline void clear_has_collation();
00360   inline void set_has_collation_id();
00361   inline void clear_has_collation_id();
00362   inline void set_has_data_file_name();
00363   inline void clear_has_data_file_name();
00364   inline void set_has_index_file_name();
00365   inline void clear_has_index_file_name();
00366   inline void set_has_max_rows();
00367   inline void clear_has_max_rows();
00368   inline void set_has_min_rows();
00369   inline void clear_has_min_rows();
00370   inline void set_has_auto_increment_value();
00371   inline void clear_has_auto_increment_value();
00372   inline void set_has_avg_row_length();
00373   inline void clear_has_avg_row_length();
00374   inline void set_has_block_size();
00375   inline void clear_has_block_size();
00376   inline void set_has_comment();
00377   inline void clear_has_comment();
00378   inline void set_has_pack_record();
00379   inline void clear_has_pack_record();
00380   inline void set_has_checksum();
00381   inline void clear_has_checksum();
00382   inline void set_has_page_checksum();
00383   inline void clear_has_page_checksum();
00384   inline void set_has_delay_key_write();
00385   inline void clear_has_delay_key_write();
00386   inline void set_has_dont_replicate();
00387   inline void clear_has_dont_replicate();
00388   
00389   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00390   
00391   ::std::string* collation_;
00392   ::std::string* data_file_name_;
00393   ::std::string* index_file_name_;
00394   ::google::protobuf::uint64 max_rows_;
00395   ::google::protobuf::uint32 collation_id_;
00396   ::google::protobuf::uint32 avg_row_length_;
00397   ::google::protobuf::uint64 min_rows_;
00398   ::google::protobuf::uint64 auto_increment_value_;
00399   ::google::protobuf::uint32 block_size_;
00400   bool has_user_set_auto_increment_value_;
00401   bool pack_record_;
00402   bool checksum_;
00403   bool page_checksum_;
00404   ::std::string* comment_;
00405   bool delay_key_write_;
00406   bool dont_replicate_;
00407   
00408   mutable int _cached_size_;
00409   ::google::protobuf::uint32 _has_bits_[(16 + 31) / 32];
00410   
00411   friend void  protobuf_AddDesc_table_2eproto();
00412   friend void protobuf_AssignDesc_table_2eproto();
00413   friend void protobuf_ShutdownFile_table_2eproto();
00414   
00415   void InitAsDefaultInstance();
00416   static Table_TableOptions* default_instance_;
00417 };
00418 // -------------------------------------------------------------------
00419 
00420 class Table_ForeignKeyConstraint : public ::google::protobuf::Message {
00421  public:
00422   Table_ForeignKeyConstraint();
00423   virtual ~Table_ForeignKeyConstraint();
00424   
00425   Table_ForeignKeyConstraint(const Table_ForeignKeyConstraint& from);
00426   
00427   inline Table_ForeignKeyConstraint& operator=(const Table_ForeignKeyConstraint& from) {
00428     CopyFrom(from);
00429     return *this;
00430   }
00431   
00432   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00433     return _unknown_fields_;
00434   }
00435   
00436   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00437     return &_unknown_fields_;
00438   }
00439   
00440   static const ::google::protobuf::Descriptor* descriptor();
00441   static const Table_ForeignKeyConstraint& default_instance();
00442   
00443   void Swap(Table_ForeignKeyConstraint* other);
00444   
00445   // implements Message ----------------------------------------------
00446   
00447   Table_ForeignKeyConstraint* New() const;
00448   void CopyFrom(const ::google::protobuf::Message& from);
00449   void MergeFrom(const ::google::protobuf::Message& from);
00450   void CopyFrom(const Table_ForeignKeyConstraint& from);
00451   void MergeFrom(const Table_ForeignKeyConstraint& from);
00452   void Clear();
00453   bool IsInitialized() const;
00454   
00455   int ByteSize() const;
00456   bool MergePartialFromCodedStream(
00457       ::google::protobuf::io::CodedInputStream* input);
00458   void SerializeWithCachedSizes(
00459       ::google::protobuf::io::CodedOutputStream* output) const;
00460   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00461   int GetCachedSize() const { return _cached_size_; }
00462   private:
00463   void SharedCtor();
00464   void SharedDtor();
00465   void SetCachedSize(int size) const;
00466   public:
00467   
00468   ::google::protobuf::Metadata GetMetadata() const;
00469   
00470   // nested types ----------------------------------------------------
00471   
00472   typedef Table_ForeignKeyConstraint_ForeignKeyMatchOption ForeignKeyMatchOption;
00473   static const ForeignKeyMatchOption MATCH_UNDEFINED = Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_UNDEFINED;
00474   static const ForeignKeyMatchOption MATCH_FULL = Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_FULL;
00475   static const ForeignKeyMatchOption MATCH_PARTIAL = Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_PARTIAL;
00476   static const ForeignKeyMatchOption MATCH_SIMPLE = Table_ForeignKeyConstraint_ForeignKeyMatchOption_MATCH_SIMPLE;
00477   static inline bool ForeignKeyMatchOption_IsValid(int value) {
00478     return Table_ForeignKeyConstraint_ForeignKeyMatchOption_IsValid(value);
00479   }
00480   static const ForeignKeyMatchOption ForeignKeyMatchOption_MIN =
00481     Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_MIN;
00482   static const ForeignKeyMatchOption ForeignKeyMatchOption_MAX =
00483     Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_MAX;
00484   static const int ForeignKeyMatchOption_ARRAYSIZE =
00485     Table_ForeignKeyConstraint_ForeignKeyMatchOption_ForeignKeyMatchOption_ARRAYSIZE;
00486   static inline const ::google::protobuf::EnumDescriptor*
00487   ForeignKeyMatchOption_descriptor() {
00488     return Table_ForeignKeyConstraint_ForeignKeyMatchOption_descriptor();
00489   }
00490   static inline const ::std::string& ForeignKeyMatchOption_Name(ForeignKeyMatchOption value) {
00491     return Table_ForeignKeyConstraint_ForeignKeyMatchOption_Name(value);
00492   }
00493   static inline bool ForeignKeyMatchOption_Parse(const ::std::string& name,
00494       ForeignKeyMatchOption* value) {
00495     return Table_ForeignKeyConstraint_ForeignKeyMatchOption_Parse(name, value);
00496   }
00497   
00498   typedef Table_ForeignKeyConstraint_ForeignKeyOption ForeignKeyOption;
00499   static const ForeignKeyOption OPTION_UNDEF = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_UNDEF;
00500   static const ForeignKeyOption OPTION_RESTRICT = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_RESTRICT;
00501   static const ForeignKeyOption OPTION_CASCADE = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_CASCADE;
00502   static const ForeignKeyOption OPTION_SET_NULL = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_SET_NULL;
00503   static const ForeignKeyOption OPTION_NO_ACTION = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_NO_ACTION;
00504   static const ForeignKeyOption OPTION_SET_DEFAULT = Table_ForeignKeyConstraint_ForeignKeyOption_OPTION_SET_DEFAULT;
00505   static inline bool ForeignKeyOption_IsValid(int value) {
00506     return Table_ForeignKeyConstraint_ForeignKeyOption_IsValid(value);
00507   }
00508   static const ForeignKeyOption ForeignKeyOption_MIN =
00509     Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_MIN;
00510   static const ForeignKeyOption ForeignKeyOption_MAX =
00511     Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_MAX;
00512   static const int ForeignKeyOption_ARRAYSIZE =
00513     Table_ForeignKeyConstraint_ForeignKeyOption_ForeignKeyOption_ARRAYSIZE;
00514   static inline const ::google::protobuf::EnumDescriptor*
00515   ForeignKeyOption_descriptor() {
00516     return Table_ForeignKeyConstraint_ForeignKeyOption_descriptor();
00517   }
00518   static inline const ::std::string& ForeignKeyOption_Name(ForeignKeyOption value) {
00519     return Table_ForeignKeyConstraint_ForeignKeyOption_Name(value);
00520   }
00521   static inline bool ForeignKeyOption_Parse(const ::std::string& name,
00522       ForeignKeyOption* value) {
00523     return Table_ForeignKeyConstraint_ForeignKeyOption_Parse(name, value);
00524   }
00525   
00526   // accessors -------------------------------------------------------
00527   
00528   // optional string name = 1;
00529   inline bool has_name() const;
00530   inline void clear_name();
00531   static const int kNameFieldNumber = 1;
00532   inline const ::std::string& name() const;
00533   inline void set_name(const ::std::string& value);
00534   inline void set_name(const char* value);
00535   inline void set_name(const char* value, size_t size);
00536   inline ::std::string* mutable_name();
00537   inline ::std::string* release_name();
00538   
00539   // repeated string column_names = 2;
00540   inline int column_names_size() const;
00541   inline void clear_column_names();
00542   static const int kColumnNamesFieldNumber = 2;
00543   inline const ::std::string& column_names(int index) const;
00544   inline ::std::string* mutable_column_names(int index);
00545   inline void set_column_names(int index, const ::std::string& value);
00546   inline void set_column_names(int index, const char* value);
00547   inline void set_column_names(int index, const char* value, size_t size);
00548   inline ::std::string* add_column_names();
00549   inline void add_column_names(const ::std::string& value);
00550   inline void add_column_names(const char* value);
00551   inline void add_column_names(const char* value, size_t size);
00552   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& column_names() const;
00553   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_column_names();
00554   
00555   // required string references_table_name = 3;
00556   inline bool has_references_table_name() const;
00557   inline void clear_references_table_name();
00558   static const int kReferencesTableNameFieldNumber = 3;
00559   inline const ::std::string& references_table_name() const;
00560   inline void set_references_table_name(const ::std::string& value);
00561   inline void set_references_table_name(const char* value);
00562   inline void set_references_table_name(const char* value, size_t size);
00563   inline ::std::string* mutable_references_table_name();
00564   inline ::std::string* release_references_table_name();
00565   
00566   // repeated string references_columns = 4;
00567   inline int references_columns_size() const;
00568   inline void clear_references_columns();
00569   static const int kReferencesColumnsFieldNumber = 4;
00570   inline const ::std::string& references_columns(int index) const;
00571   inline ::std::string* mutable_references_columns(int index);
00572   inline void set_references_columns(int index, const ::std::string& value);
00573   inline void set_references_columns(int index, const char* value);
00574   inline void set_references_columns(int index, const char* value, size_t size);
00575   inline ::std::string* add_references_columns();
00576   inline void add_references_columns(const ::std::string& value);
00577   inline void add_references_columns(const char* value);
00578   inline void add_references_columns(const char* value, size_t size);
00579   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& references_columns() const;
00580   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_references_columns();
00581   
00582   // required .drizzled.message.Table.ForeignKeyConstraint.ForeignKeyMatchOption match = 5;
00583   inline bool has_match() const;
00584   inline void clear_match();
00585   static const int kMatchFieldNumber = 5;
00586   inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption match() const;
00587   inline void set_match(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption value);
00588   
00589   // required .drizzled.message.Table.ForeignKeyConstraint.ForeignKeyOption update_option = 6 [default = OPTION_UNDEF];
00590   inline bool has_update_option() const;
00591   inline void clear_update_option();
00592   static const int kUpdateOptionFieldNumber = 6;
00593   inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption update_option() const;
00594   inline void set_update_option(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption value);
00595   
00596   // required .drizzled.message.Table.ForeignKeyConstraint.ForeignKeyOption delete_option = 7 [default = OPTION_UNDEF];
00597   inline bool has_delete_option() const;
00598   inline void clear_delete_option();
00599   static const int kDeleteOptionFieldNumber = 7;
00600   inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption delete_option() const;
00601   inline void set_delete_option(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption value);
00602   
00603   // @@protoc_insertion_point(class_scope:drizzled.message.Table.ForeignKeyConstraint)
00604  private:
00605   inline void set_has_name();
00606   inline void clear_has_name();
00607   inline void set_has_references_table_name();
00608   inline void clear_has_references_table_name();
00609   inline void set_has_match();
00610   inline void clear_has_match();
00611   inline void set_has_update_option();
00612   inline void clear_has_update_option();
00613   inline void set_has_delete_option();
00614   inline void clear_has_delete_option();
00615   
00616   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00617   
00618   ::std::string* name_;
00619   ::google::protobuf::RepeatedPtrField< ::std::string> column_names_;
00620   ::std::string* references_table_name_;
00621   ::google::protobuf::RepeatedPtrField< ::std::string> references_columns_;
00622   int match_;
00623   int update_option_;
00624   int delete_option_;
00625   
00626   mutable int _cached_size_;
00627   ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
00628   
00629   friend void  protobuf_AddDesc_table_2eproto();
00630   friend void protobuf_AssignDesc_table_2eproto();
00631   friend void protobuf_ShutdownFile_table_2eproto();
00632   
00633   void InitAsDefaultInstance();
00634   static Table_ForeignKeyConstraint* default_instance_;
00635 };
00636 // -------------------------------------------------------------------
00637 
00638 class Table_Field_FieldOptions : public ::google::protobuf::Message {
00639  public:
00640   Table_Field_FieldOptions();
00641   virtual ~Table_Field_FieldOptions();
00642   
00643   Table_Field_FieldOptions(const Table_Field_FieldOptions& from);
00644   
00645   inline Table_Field_FieldOptions& operator=(const Table_Field_FieldOptions& from) {
00646     CopyFrom(from);
00647     return *this;
00648   }
00649   
00650   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00651     return _unknown_fields_;
00652   }
00653   
00654   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00655     return &_unknown_fields_;
00656   }
00657   
00658   static const ::google::protobuf::Descriptor* descriptor();
00659   static const Table_Field_FieldOptions& default_instance();
00660   
00661   void Swap(Table_Field_FieldOptions* other);
00662   
00663   // implements Message ----------------------------------------------
00664   
00665   Table_Field_FieldOptions* New() const;
00666   void CopyFrom(const ::google::protobuf::Message& from);
00667   void MergeFrom(const ::google::protobuf::Message& from);
00668   void CopyFrom(const Table_Field_FieldOptions& from);
00669   void MergeFrom(const Table_Field_FieldOptions& from);
00670   void Clear();
00671   bool IsInitialized() const;
00672   
00673   int ByteSize() const;
00674   bool MergePartialFromCodedStream(
00675       ::google::protobuf::io::CodedInputStream* input);
00676   void SerializeWithCachedSizes(
00677       ::google::protobuf::io::CodedOutputStream* output) const;
00678   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00679   int GetCachedSize() const { return _cached_size_; }
00680   private:
00681   void SharedCtor();
00682   void SharedDtor();
00683   void SetCachedSize(int size) const;
00684   public:
00685   
00686   ::google::protobuf::Metadata GetMetadata() const;
00687   
00688   // nested types ----------------------------------------------------
00689   
00690   // accessors -------------------------------------------------------
00691   
00692   // optional string default_value = 1;
00693   inline bool has_default_value() const;
00694   inline void clear_default_value();
00695   static const int kDefaultValueFieldNumber = 1;
00696   inline const ::std::string& default_value() const;
00697   inline void set_default_value(const ::std::string& value);
00698   inline void set_default_value(const char* value);
00699   inline void set_default_value(const char* value, size_t size);
00700   inline ::std::string* mutable_default_value();
00701   inline ::std::string* release_default_value();
00702   
00703   // optional string update_value = 2;
00704   inline bool has_update_value() const;
00705   inline void clear_update_value();
00706   static const int kUpdateValueFieldNumber = 2;
00707   inline const ::std::string& update_value() const;
00708   inline void set_update_value(const ::std::string& value);
00709   inline void set_update_value(const char* value);
00710   inline void set_update_value(const char* value, size_t size);
00711   inline ::std::string* mutable_update_value();
00712   inline ::std::string* release_update_value();
00713   
00714   // optional bool default_null = 3 [default = false];
00715   inline bool has_default_null() const;
00716   inline void clear_default_null();
00717   static const int kDefaultNullFieldNumber = 3;
00718   inline bool default_null() const;
00719   inline void set_default_null(bool value);
00720   
00721   // optional bytes default_bin_value = 4;
00722   inline bool has_default_bin_value() const;
00723   inline void clear_default_bin_value();
00724   static const int kDefaultBinValueFieldNumber = 4;
00725   inline const ::std::string& default_bin_value() const;
00726   inline void set_default_bin_value(const ::std::string& value);
00727   inline void set_default_bin_value(const char* value);
00728   inline void set_default_bin_value(const void* value, size_t size);
00729   inline ::std::string* mutable_default_bin_value();
00730   inline ::std::string* release_default_bin_value();
00731   
00732   // optional string default_expression = 5;
00733   inline bool has_default_expression() const;
00734   inline void clear_default_expression();
00735   static const int kDefaultExpressionFieldNumber = 5;
00736   inline const ::std::string& default_expression() const;
00737   inline void set_default_expression(const ::std::string& value);
00738   inline void set_default_expression(const char* value);
00739   inline void set_default_expression(const char* value, size_t size);
00740   inline ::std::string* mutable_default_expression();
00741   inline ::std::string* release_default_expression();
00742   
00743   // optional string update_expression = 6;
00744   inline bool has_update_expression() const;
00745   inline void clear_update_expression();
00746   static const int kUpdateExpressionFieldNumber = 6;
00747   inline const ::std::string& update_expression() const;
00748   inline void set_update_expression(const ::std::string& value);
00749   inline void set_update_expression(const char* value);
00750   inline void set_update_expression(const char* value, size_t size);
00751   inline ::std::string* mutable_update_expression();
00752   inline ::std::string* release_update_expression();
00753   
00754   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.FieldOptions)
00755  private:
00756   inline void set_has_default_value();
00757   inline void clear_has_default_value();
00758   inline void set_has_update_value();
00759   inline void clear_has_update_value();
00760   inline void set_has_default_null();
00761   inline void clear_has_default_null();
00762   inline void set_has_default_bin_value();
00763   inline void clear_has_default_bin_value();
00764   inline void set_has_default_expression();
00765   inline void clear_has_default_expression();
00766   inline void set_has_update_expression();
00767   inline void clear_has_update_expression();
00768   
00769   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00770   
00771   ::std::string* default_value_;
00772   ::std::string* update_value_;
00773   ::std::string* default_bin_value_;
00774   ::std::string* default_expression_;
00775   ::std::string* update_expression_;
00776   bool default_null_;
00777   
00778   mutable int _cached_size_;
00779   ::google::protobuf::uint32 _has_bits_[(6 + 31) / 32];
00780   
00781   friend void  protobuf_AddDesc_table_2eproto();
00782   friend void protobuf_AssignDesc_table_2eproto();
00783   friend void protobuf_ShutdownFile_table_2eproto();
00784   
00785   void InitAsDefaultInstance();
00786   static Table_Field_FieldOptions* default_instance_;
00787 };
00788 // -------------------------------------------------------------------
00789 
00790 class Table_Field_FieldConstraints : public ::google::protobuf::Message {
00791  public:
00792   Table_Field_FieldConstraints();
00793   virtual ~Table_Field_FieldConstraints();
00794   
00795   Table_Field_FieldConstraints(const Table_Field_FieldConstraints& from);
00796   
00797   inline Table_Field_FieldConstraints& operator=(const Table_Field_FieldConstraints& from) {
00798     CopyFrom(from);
00799     return *this;
00800   }
00801   
00802   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00803     return _unknown_fields_;
00804   }
00805   
00806   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00807     return &_unknown_fields_;
00808   }
00809   
00810   static const ::google::protobuf::Descriptor* descriptor();
00811   static const Table_Field_FieldConstraints& default_instance();
00812   
00813   void Swap(Table_Field_FieldConstraints* other);
00814   
00815   // implements Message ----------------------------------------------
00816   
00817   Table_Field_FieldConstraints* New() const;
00818   void CopyFrom(const ::google::protobuf::Message& from);
00819   void MergeFrom(const ::google::protobuf::Message& from);
00820   void CopyFrom(const Table_Field_FieldConstraints& from);
00821   void MergeFrom(const Table_Field_FieldConstraints& from);
00822   void Clear();
00823   bool IsInitialized() const;
00824   
00825   int ByteSize() const;
00826   bool MergePartialFromCodedStream(
00827       ::google::protobuf::io::CodedInputStream* input);
00828   void SerializeWithCachedSizes(
00829       ::google::protobuf::io::CodedOutputStream* output) const;
00830   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00831   int GetCachedSize() const { return _cached_size_; }
00832   private:
00833   void SharedCtor();
00834   void SharedDtor();
00835   void SetCachedSize(int size) const;
00836   public:
00837   
00838   ::google::protobuf::Metadata GetMetadata() const;
00839   
00840   // nested types ----------------------------------------------------
00841   
00842   // accessors -------------------------------------------------------
00843   
00844   // optional bool is_nullable = 1 [default = true];
00845   inline bool has_is_nullable() const;
00846   inline void clear_is_nullable();
00847   static const int kIsNullableFieldNumber = 1;
00848   inline bool is_nullable() const;
00849   inline void set_is_nullable(bool value);
00850   
00851   // optional bool is_unsigned = 2 [default = false];
00852   inline bool has_is_unsigned() const;
00853   inline void clear_is_unsigned();
00854   static const int kIsUnsignedFieldNumber = 2;
00855   inline bool is_unsigned() const;
00856   inline void set_is_unsigned(bool value);
00857   
00858   // optional bool is_notnull = 3 [default = false];
00859   inline bool has_is_notnull() const;
00860   inline void clear_is_notnull();
00861   static const int kIsNotnullFieldNumber = 3;
00862   inline bool is_notnull() const;
00863   inline void set_is_notnull(bool value);
00864   
00865   // optional bool is_unique = 4 [default = false];
00866   inline bool has_is_unique() const;
00867   inline void clear_is_unique();
00868   static const int kIsUniqueFieldNumber = 4;
00869   inline bool is_unique() const;
00870   inline void set_is_unique(bool value);
00871   
00872   // repeated string expression = 16;
00873   inline int expression_size() const;
00874   inline void clear_expression();
00875   static const int kExpressionFieldNumber = 16;
00876   inline const ::std::string& expression(int index) const;
00877   inline ::std::string* mutable_expression(int index);
00878   inline void set_expression(int index, const ::std::string& value);
00879   inline void set_expression(int index, const char* value);
00880   inline void set_expression(int index, const char* value, size_t size);
00881   inline ::std::string* add_expression();
00882   inline void add_expression(const ::std::string& value);
00883   inline void add_expression(const char* value);
00884   inline void add_expression(const char* value, size_t size);
00885   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& expression() const;
00886   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_expression();
00887   
00888   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.FieldConstraints)
00889  private:
00890   inline void set_has_is_nullable();
00891   inline void clear_has_is_nullable();
00892   inline void set_has_is_unsigned();
00893   inline void clear_has_is_unsigned();
00894   inline void set_has_is_notnull();
00895   inline void clear_has_is_notnull();
00896   inline void set_has_is_unique();
00897   inline void clear_has_is_unique();
00898   
00899   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00900   
00901   ::google::protobuf::RepeatedPtrField< ::std::string> expression_;
00902   bool is_nullable_;
00903   bool is_unsigned_;
00904   bool is_notnull_;
00905   bool is_unique_;
00906   
00907   mutable int _cached_size_;
00908   ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
00909   
00910   friend void  protobuf_AddDesc_table_2eproto();
00911   friend void protobuf_AssignDesc_table_2eproto();
00912   friend void protobuf_ShutdownFile_table_2eproto();
00913   
00914   void InitAsDefaultInstance();
00915   static Table_Field_FieldConstraints* default_instance_;
00916 };
00917 // -------------------------------------------------------------------
00918 
00919 class Table_Field_NumericFieldOptions : public ::google::protobuf::Message {
00920  public:
00921   Table_Field_NumericFieldOptions();
00922   virtual ~Table_Field_NumericFieldOptions();
00923   
00924   Table_Field_NumericFieldOptions(const Table_Field_NumericFieldOptions& from);
00925   
00926   inline Table_Field_NumericFieldOptions& operator=(const Table_Field_NumericFieldOptions& from) {
00927     CopyFrom(from);
00928     return *this;
00929   }
00930   
00931   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00932     return _unknown_fields_;
00933   }
00934   
00935   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00936     return &_unknown_fields_;
00937   }
00938   
00939   static const ::google::protobuf::Descriptor* descriptor();
00940   static const Table_Field_NumericFieldOptions& default_instance();
00941   
00942   void Swap(Table_Field_NumericFieldOptions* other);
00943   
00944   // implements Message ----------------------------------------------
00945   
00946   Table_Field_NumericFieldOptions* New() const;
00947   void CopyFrom(const ::google::protobuf::Message& from);
00948   void MergeFrom(const ::google::protobuf::Message& from);
00949   void CopyFrom(const Table_Field_NumericFieldOptions& from);
00950   void MergeFrom(const Table_Field_NumericFieldOptions& from);
00951   void Clear();
00952   bool IsInitialized() const;
00953   
00954   int ByteSize() const;
00955   bool MergePartialFromCodedStream(
00956       ::google::protobuf::io::CodedInputStream* input);
00957   void SerializeWithCachedSizes(
00958       ::google::protobuf::io::CodedOutputStream* output) const;
00959   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00960   int GetCachedSize() const { return _cached_size_; }
00961   private:
00962   void SharedCtor();
00963   void SharedDtor();
00964   void SetCachedSize(int size) const;
00965   public:
00966   
00967   ::google::protobuf::Metadata GetMetadata() const;
00968   
00969   // nested types ----------------------------------------------------
00970   
00971   // accessors -------------------------------------------------------
00972   
00973   // optional bool is_autoincrement = 1 [default = false];
00974   inline bool has_is_autoincrement() const;
00975   inline void clear_is_autoincrement();
00976   static const int kIsAutoincrementFieldNumber = 1;
00977   inline bool is_autoincrement() const;
00978   inline void set_is_autoincrement(bool value);
00979   
00980   // optional uint32 scale = 2;
00981   inline bool has_scale() const;
00982   inline void clear_scale();
00983   static const int kScaleFieldNumber = 2;
00984   inline ::google::protobuf::uint32 scale() const;
00985   inline void set_scale(::google::protobuf::uint32 value);
00986   
00987   // optional uint32 precision = 3;
00988   inline bool has_precision() const;
00989   inline void clear_precision();
00990   static const int kPrecisionFieldNumber = 3;
00991   inline ::google::protobuf::uint32 precision() const;
00992   inline void set_precision(::google::protobuf::uint32 value);
00993   
00994   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.NumericFieldOptions)
00995  private:
00996   inline void set_has_is_autoincrement();
00997   inline void clear_has_is_autoincrement();
00998   inline void set_has_scale();
00999   inline void clear_has_scale();
01000   inline void set_has_precision();
01001   inline void clear_has_precision();
01002   
01003   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01004   
01005   bool is_autoincrement_;
01006   ::google::protobuf::uint32 scale_;
01007   ::google::protobuf::uint32 precision_;
01008   
01009   mutable int _cached_size_;
01010   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
01011   
01012   friend void  protobuf_AddDesc_table_2eproto();
01013   friend void protobuf_AssignDesc_table_2eproto();
01014   friend void protobuf_ShutdownFile_table_2eproto();
01015   
01016   void InitAsDefaultInstance();
01017   static Table_Field_NumericFieldOptions* default_instance_;
01018 };
01019 // -------------------------------------------------------------------
01020 
01021 class Table_Field_StringFieldOptions : public ::google::protobuf::Message {
01022  public:
01023   Table_Field_StringFieldOptions();
01024   virtual ~Table_Field_StringFieldOptions();
01025   
01026   Table_Field_StringFieldOptions(const Table_Field_StringFieldOptions& from);
01027   
01028   inline Table_Field_StringFieldOptions& operator=(const Table_Field_StringFieldOptions& from) {
01029     CopyFrom(from);
01030     return *this;
01031   }
01032   
01033   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01034     return _unknown_fields_;
01035   }
01036   
01037   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01038     return &_unknown_fields_;
01039   }
01040   
01041   static const ::google::protobuf::Descriptor* descriptor();
01042   static const Table_Field_StringFieldOptions& default_instance();
01043   
01044   void Swap(Table_Field_StringFieldOptions* other);
01045   
01046   // implements Message ----------------------------------------------
01047   
01048   Table_Field_StringFieldOptions* New() const;
01049   void CopyFrom(const ::google::protobuf::Message& from);
01050   void MergeFrom(const ::google::protobuf::Message& from);
01051   void CopyFrom(const Table_Field_StringFieldOptions& from);
01052   void MergeFrom(const Table_Field_StringFieldOptions& from);
01053   void Clear();
01054   bool IsInitialized() const;
01055   
01056   int ByteSize() const;
01057   bool MergePartialFromCodedStream(
01058       ::google::protobuf::io::CodedInputStream* input);
01059   void SerializeWithCachedSizes(
01060       ::google::protobuf::io::CodedOutputStream* output) const;
01061   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01062   int GetCachedSize() const { return _cached_size_; }
01063   private:
01064   void SharedCtor();
01065   void SharedDtor();
01066   void SetCachedSize(int size) const;
01067   public:
01068   
01069   ::google::protobuf::Metadata GetMetadata() const;
01070   
01071   // nested types ----------------------------------------------------
01072   
01073   // accessors -------------------------------------------------------
01074   
01075   // optional bool is_fixed_width = 1 [default = false];
01076   inline bool has_is_fixed_width() const;
01077   inline void clear_is_fixed_width();
01078   static const int kIsFixedWidthFieldNumber = 1;
01079   inline bool is_fixed_width() const;
01080   inline void set_is_fixed_width(bool value);
01081   
01082   // optional uint32 length = 2;
01083   inline bool has_length() const;
01084   inline void clear_length();
01085   static const int kLengthFieldNumber = 2;
01086   inline ::google::protobuf::uint32 length() const;
01087   inline void set_length(::google::protobuf::uint32 value);
01088   
01089   // optional uint32 collation_id = 3;
01090   inline bool has_collation_id() const;
01091   inline void clear_collation_id();
01092   static const int kCollationIdFieldNumber = 3;
01093   inline ::google::protobuf::uint32 collation_id() const;
01094   inline void set_collation_id(::google::protobuf::uint32 value);
01095   
01096   // optional string collation = 4;
01097   inline bool has_collation() const;
01098   inline void clear_collation();
01099   static const int kCollationFieldNumber = 4;
01100   inline const ::std::string& collation() const;
01101   inline void set_collation(const ::std::string& value);
01102   inline void set_collation(const char* value);
01103   inline void set_collation(const char* value, size_t size);
01104   inline ::std::string* mutable_collation();
01105   inline ::std::string* release_collation();
01106   
01107   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.StringFieldOptions)
01108  private:
01109   inline void set_has_is_fixed_width();
01110   inline void clear_has_is_fixed_width();
01111   inline void set_has_length();
01112   inline void clear_has_length();
01113   inline void set_has_collation_id();
01114   inline void clear_has_collation_id();
01115   inline void set_has_collation();
01116   inline void clear_has_collation();
01117   
01118   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01119   
01120   bool is_fixed_width_;
01121   ::google::protobuf::uint32 length_;
01122   ::std::string* collation_;
01123   ::google::protobuf::uint32 collation_id_;
01124   
01125   mutable int _cached_size_;
01126   ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
01127   
01128   friend void  protobuf_AddDesc_table_2eproto();
01129   friend void protobuf_AssignDesc_table_2eproto();
01130   friend void protobuf_ShutdownFile_table_2eproto();
01131   
01132   void InitAsDefaultInstance();
01133   static Table_Field_StringFieldOptions* default_instance_;
01134 };
01135 // -------------------------------------------------------------------
01136 
01137 class Table_Field_EnumerationValues : public ::google::protobuf::Message {
01138  public:
01139   Table_Field_EnumerationValues();
01140   virtual ~Table_Field_EnumerationValues();
01141   
01142   Table_Field_EnumerationValues(const Table_Field_EnumerationValues& from);
01143   
01144   inline Table_Field_EnumerationValues& operator=(const Table_Field_EnumerationValues& from) {
01145     CopyFrom(from);
01146     return *this;
01147   }
01148   
01149   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01150     return _unknown_fields_;
01151   }
01152   
01153   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01154     return &_unknown_fields_;
01155   }
01156   
01157   static const ::google::protobuf::Descriptor* descriptor();
01158   static const Table_Field_EnumerationValues& default_instance();
01159   
01160   void Swap(Table_Field_EnumerationValues* other);
01161   
01162   // implements Message ----------------------------------------------
01163   
01164   Table_Field_EnumerationValues* New() const;
01165   void CopyFrom(const ::google::protobuf::Message& from);
01166   void MergeFrom(const ::google::protobuf::Message& from);
01167   void CopyFrom(const Table_Field_EnumerationValues& from);
01168   void MergeFrom(const Table_Field_EnumerationValues& from);
01169   void Clear();
01170   bool IsInitialized() const;
01171   
01172   int ByteSize() const;
01173   bool MergePartialFromCodedStream(
01174       ::google::protobuf::io::CodedInputStream* input);
01175   void SerializeWithCachedSizes(
01176       ::google::protobuf::io::CodedOutputStream* output) const;
01177   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01178   int GetCachedSize() const { return _cached_size_; }
01179   private:
01180   void SharedCtor();
01181   void SharedDtor();
01182   void SetCachedSize(int size) const;
01183   public:
01184   
01185   ::google::protobuf::Metadata GetMetadata() const;
01186   
01187   // nested types ----------------------------------------------------
01188   
01189   // accessors -------------------------------------------------------
01190   
01191   // optional uint32 collation_id = 2;
01192   inline bool has_collation_id() const;
01193   inline void clear_collation_id();
01194   static const int kCollationIdFieldNumber = 2;
01195   inline ::google::protobuf::uint32 collation_id() const;
01196   inline void set_collation_id(::google::protobuf::uint32 value);
01197   
01198   // optional string collation = 3;
01199   inline bool has_collation() const;
01200   inline void clear_collation();
01201   static const int kCollationFieldNumber = 3;
01202   inline const ::std::string& collation() const;
01203   inline void set_collation(const ::std::string& value);
01204   inline void set_collation(const char* value);
01205   inline void set_collation(const char* value, size_t size);
01206   inline ::std::string* mutable_collation();
01207   inline ::std::string* release_collation();
01208   
01209   // repeated string field_value = 4;
01210   inline int field_value_size() const;
01211   inline void clear_field_value();
01212   static const int kFieldValueFieldNumber = 4;
01213   inline const ::std::string& field_value(int index) const;
01214   inline ::std::string* mutable_field_value(int index);
01215   inline void set_field_value(int index, const ::std::string& value);
01216   inline void set_field_value(int index, const char* value);
01217   inline void set_field_value(int index, const char* value, size_t size);
01218   inline ::std::string* add_field_value();
01219   inline void add_field_value(const ::std::string& value);
01220   inline void add_field_value(const char* value);
01221   inline void add_field_value(const char* value, size_t size);
01222   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& field_value() const;
01223   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_field_value();
01224   
01225   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.EnumerationValues)
01226  private:
01227   inline void set_has_collation_id();
01228   inline void clear_has_collation_id();
01229   inline void set_has_collation();
01230   inline void clear_has_collation();
01231   
01232   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01233   
01234   ::std::string* collation_;
01235   ::google::protobuf::RepeatedPtrField< ::std::string> field_value_;
01236   ::google::protobuf::uint32 collation_id_;
01237   
01238   mutable int _cached_size_;
01239   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
01240   
01241   friend void  protobuf_AddDesc_table_2eproto();
01242   friend void protobuf_AssignDesc_table_2eproto();
01243   friend void protobuf_ShutdownFile_table_2eproto();
01244   
01245   void InitAsDefaultInstance();
01246   static Table_Field_EnumerationValues* default_instance_;
01247 };
01248 // -------------------------------------------------------------------
01249 
01250 class Table_Field_TimeFieldOptions : public ::google::protobuf::Message {
01251  public:
01252   Table_Field_TimeFieldOptions();
01253   virtual ~Table_Field_TimeFieldOptions();
01254   
01255   Table_Field_TimeFieldOptions(const Table_Field_TimeFieldOptions& from);
01256   
01257   inline Table_Field_TimeFieldOptions& operator=(const Table_Field_TimeFieldOptions& from) {
01258     CopyFrom(from);
01259     return *this;
01260   }
01261   
01262   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01263     return _unknown_fields_;
01264   }
01265   
01266   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01267     return &_unknown_fields_;
01268   }
01269   
01270   static const ::google::protobuf::Descriptor* descriptor();
01271   static const Table_Field_TimeFieldOptions& default_instance();
01272   
01273   void Swap(Table_Field_TimeFieldOptions* other);
01274   
01275   // implements Message ----------------------------------------------
01276   
01277   Table_Field_TimeFieldOptions* New() const;
01278   void CopyFrom(const ::google::protobuf::Message& from);
01279   void MergeFrom(const ::google::protobuf::Message& from);
01280   void CopyFrom(const Table_Field_TimeFieldOptions& from);
01281   void MergeFrom(const Table_Field_TimeFieldOptions& from);
01282   void Clear();
01283   bool IsInitialized() const;
01284   
01285   int ByteSize() const;
01286   bool MergePartialFromCodedStream(
01287       ::google::protobuf::io::CodedInputStream* input);
01288   void SerializeWithCachedSizes(
01289       ::google::protobuf::io::CodedOutputStream* output) const;
01290   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01291   int GetCachedSize() const { return _cached_size_; }
01292   private:
01293   void SharedCtor();
01294   void SharedDtor();
01295   void SetCachedSize(int size) const;
01296   public:
01297   
01298   ::google::protobuf::Metadata GetMetadata() const;
01299   
01300   // nested types ----------------------------------------------------
01301   
01302   // accessors -------------------------------------------------------
01303   
01304   // optional bool microseconds = 1;
01305   inline bool has_microseconds() const;
01306   inline void clear_microseconds();
01307   static const int kMicrosecondsFieldNumber = 1;
01308   inline bool microseconds() const;
01309   inline void set_microseconds(bool value);
01310   
01311   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field.TimeFieldOptions)
01312  private:
01313   inline void set_has_microseconds();
01314   inline void clear_has_microseconds();
01315   
01316   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01317   
01318   bool microseconds_;
01319   
01320   mutable int _cached_size_;
01321   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
01322   
01323   friend void  protobuf_AddDesc_table_2eproto();
01324   friend void protobuf_AssignDesc_table_2eproto();
01325   friend void protobuf_ShutdownFile_table_2eproto();
01326   
01327   void InitAsDefaultInstance();
01328   static Table_Field_TimeFieldOptions* default_instance_;
01329 };
01330 // -------------------------------------------------------------------
01331 
01332 class Table_Field : public ::google::protobuf::Message {
01333  public:
01334   Table_Field();
01335   virtual ~Table_Field();
01336   
01337   Table_Field(const Table_Field& from);
01338   
01339   inline Table_Field& operator=(const Table_Field& from) {
01340     CopyFrom(from);
01341     return *this;
01342   }
01343   
01344   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01345     return _unknown_fields_;
01346   }
01347   
01348   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01349     return &_unknown_fields_;
01350   }
01351   
01352   static const ::google::protobuf::Descriptor* descriptor();
01353   static const Table_Field& default_instance();
01354   
01355   void Swap(Table_Field* other);
01356   
01357   // implements Message ----------------------------------------------
01358   
01359   Table_Field* New() const;
01360   void CopyFrom(const ::google::protobuf::Message& from);
01361   void MergeFrom(const ::google::protobuf::Message& from);
01362   void CopyFrom(const Table_Field& from);
01363   void MergeFrom(const Table_Field& from);
01364   void Clear();
01365   bool IsInitialized() const;
01366   
01367   int ByteSize() const;
01368   bool MergePartialFromCodedStream(
01369       ::google::protobuf::io::CodedInputStream* input);
01370   void SerializeWithCachedSizes(
01371       ::google::protobuf::io::CodedOutputStream* output) const;
01372   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01373   int GetCachedSize() const { return _cached_size_; }
01374   private:
01375   void SharedCtor();
01376   void SharedDtor();
01377   void SetCachedSize(int size) const;
01378   public:
01379   
01380   ::google::protobuf::Metadata GetMetadata() const;
01381   
01382   // nested types ----------------------------------------------------
01383   
01384   typedef Table_Field_FieldOptions FieldOptions;
01385   typedef Table_Field_FieldConstraints FieldConstraints;
01386   typedef Table_Field_NumericFieldOptions NumericFieldOptions;
01387   typedef Table_Field_StringFieldOptions StringFieldOptions;
01388   typedef Table_Field_EnumerationValues EnumerationValues;
01389   typedef Table_Field_TimeFieldOptions TimeFieldOptions;
01390   
01391   typedef Table_Field_FieldType FieldType;
01392   static const FieldType DOUBLE = Table_Field_FieldType_DOUBLE;
01393   static const FieldType VARCHAR = Table_Field_FieldType_VARCHAR;
01394   static const FieldType BLOB = Table_Field_FieldType_BLOB;
01395   static const FieldType ENUM = Table_Field_FieldType_ENUM;
01396   static const FieldType INTEGER = Table_Field_FieldType_INTEGER;
01397   static const FieldType BIGINT = Table_Field_FieldType_BIGINT;
01398   static const FieldType DECIMAL = Table_Field_FieldType_DECIMAL;
01399   static const FieldType DATE = Table_Field_FieldType_DATE;
01400   static const FieldType EPOCH = Table_Field_FieldType_EPOCH;
01401   static const FieldType DATETIME = Table_Field_FieldType_DATETIME;
01402   static const FieldType UUID = Table_Field_FieldType_UUID;
01403   static const FieldType TIME = Table_Field_FieldType_TIME;
01404   static const FieldType BOOLEAN = Table_Field_FieldType_BOOLEAN;
01405   static inline bool FieldType_IsValid(int value) {
01406     return Table_Field_FieldType_IsValid(value);
01407   }
01408   static const FieldType FieldType_MIN =
01409     Table_Field_FieldType_FieldType_MIN;
01410   static const FieldType FieldType_MAX =
01411     Table_Field_FieldType_FieldType_MAX;
01412   static const int FieldType_ARRAYSIZE =
01413     Table_Field_FieldType_FieldType_ARRAYSIZE;
01414   static inline const ::google::protobuf::EnumDescriptor*
01415   FieldType_descriptor() {
01416     return Table_Field_FieldType_descriptor();
01417   }
01418   static inline const ::std::string& FieldType_Name(FieldType value) {
01419     return Table_Field_FieldType_Name(value);
01420   }
01421   static inline bool FieldType_Parse(const ::std::string& name,
01422       FieldType* value) {
01423     return Table_Field_FieldType_Parse(name, value);
01424   }
01425   
01426   // accessors -------------------------------------------------------
01427   
01428   // required string name = 1;
01429   inline bool has_name() const;
01430   inline void clear_name();
01431   static const int kNameFieldNumber = 1;
01432   inline const ::std::string& name() const;
01433   inline void set_name(const ::std::string& value);
01434   inline void set_name(const char* value);
01435   inline void set_name(const char* value, size_t size);
01436   inline ::std::string* mutable_name();
01437   inline ::std::string* release_name();
01438   
01439   // required .drizzled.message.Table.Field.FieldType type = 2;
01440   inline bool has_type() const;
01441   inline void clear_type();
01442   static const int kTypeFieldNumber = 2;
01443   inline ::drizzled::message::Table_Field_FieldType type() const;
01444   inline void set_type(::drizzled::message::Table_Field_FieldType value);
01445   
01446   // optional .drizzled.message.Table.Field.FieldOptions options = 4;
01447   inline bool has_options() const;
01448   inline void clear_options();
01449   static const int kOptionsFieldNumber = 4;
01450   inline const ::drizzled::message::Table_Field_FieldOptions& options() const;
01451   inline ::drizzled::message::Table_Field_FieldOptions* mutable_options();
01452   inline ::drizzled::message::Table_Field_FieldOptions* release_options();
01453   
01454   // optional .drizzled.message.Table.Field.FieldConstraints constraints = 5;
01455   inline bool has_constraints() const;
01456   inline void clear_constraints();
01457   static const int kConstraintsFieldNumber = 5;
01458   inline const ::drizzled::message::Table_Field_FieldConstraints& constraints() const;
01459   inline ::drizzled::message::Table_Field_FieldConstraints* mutable_constraints();
01460   inline ::drizzled::message::Table_Field_FieldConstraints* release_constraints();
01461   
01462   // optional .drizzled.message.Table.Field.NumericFieldOptions numeric_options = 6;
01463   inline bool has_numeric_options() const;
01464   inline void clear_numeric_options();
01465   static const int kNumericOptionsFieldNumber = 6;
01466   inline const ::drizzled::message::Table_Field_NumericFieldOptions& numeric_options() const;
01467   inline ::drizzled::message::Table_Field_NumericFieldOptions* mutable_numeric_options();
01468   inline ::drizzled::message::Table_Field_NumericFieldOptions* release_numeric_options();
01469   
01470   // optional .drizzled.message.Table.Field.StringFieldOptions string_options = 7;
01471   inline bool has_string_options() const;
01472   inline void clear_string_options();
01473   static const int kStringOptionsFieldNumber = 7;
01474   inline const ::drizzled::message::Table_Field_StringFieldOptions& string_options() const;
01475   inline ::drizzled::message::Table_Field_StringFieldOptions* mutable_string_options();
01476   inline ::drizzled::message::Table_Field_StringFieldOptions* release_string_options();
01477   
01478   // optional .drizzled.message.Table.Field.TimeFieldOptions time_options = 8;
01479   inline bool has_time_options() const;
01480   inline void clear_time_options();
01481   static const int kTimeOptionsFieldNumber = 8;
01482   inline const ::drizzled::message::Table_Field_TimeFieldOptions& time_options() const;
01483   inline ::drizzled::message::Table_Field_TimeFieldOptions* mutable_time_options();
01484   inline ::drizzled::message::Table_Field_TimeFieldOptions* release_time_options();
01485   
01486   // optional string comment = 16;
01487   inline bool has_comment() const;
01488   inline void clear_comment();
01489   static const int kCommentFieldNumber = 16;
01490   inline const ::std::string& comment() const;
01491   inline void set_comment(const ::std::string& value);
01492   inline void set_comment(const char* value);
01493   inline void set_comment(const char* value, size_t size);
01494   inline ::std::string* mutable_comment();
01495   inline ::std::string* release_comment();
01496   
01497   // optional .drizzled.message.Table.Field.EnumerationValues enumeration_values = 17;
01498   inline bool has_enumeration_values() const;
01499   inline void clear_enumeration_values();
01500   static const int kEnumerationValuesFieldNumber = 17;
01501   inline const ::drizzled::message::Table_Field_EnumerationValues& enumeration_values() const;
01502   inline ::drizzled::message::Table_Field_EnumerationValues* mutable_enumeration_values();
01503   inline ::drizzled::message::Table_Field_EnumerationValues* release_enumeration_values();
01504   
01505   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Field)
01506  private:
01507   inline void set_has_name();
01508   inline void clear_has_name();
01509   inline void set_has_type();
01510   inline void clear_has_type();
01511   inline void set_has_options();
01512   inline void clear_has_options();
01513   inline void set_has_constraints();
01514   inline void clear_has_constraints();
01515   inline void set_has_numeric_options();
01516   inline void clear_has_numeric_options();
01517   inline void set_has_string_options();
01518   inline void clear_has_string_options();
01519   inline void set_has_time_options();
01520   inline void clear_has_time_options();
01521   inline void set_has_comment();
01522   inline void clear_has_comment();
01523   inline void set_has_enumeration_values();
01524   inline void clear_has_enumeration_values();
01525   
01526   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01527   
01528   ::std::string* name_;
01529   ::drizzled::message::Table_Field_FieldOptions* options_;
01530   ::drizzled::message::Table_Field_FieldConstraints* constraints_;
01531   ::drizzled::message::Table_Field_NumericFieldOptions* numeric_options_;
01532   ::drizzled::message::Table_Field_StringFieldOptions* string_options_;
01533   ::drizzled::message::Table_Field_TimeFieldOptions* time_options_;
01534   ::std::string* comment_;
01535   ::drizzled::message::Table_Field_EnumerationValues* enumeration_values_;
01536   int type_;
01537   
01538   mutable int _cached_size_;
01539   ::google::protobuf::uint32 _has_bits_[(9 + 31) / 32];
01540   
01541   friend void  protobuf_AddDesc_table_2eproto();
01542   friend void protobuf_AssignDesc_table_2eproto();
01543   friend void protobuf_ShutdownFile_table_2eproto();
01544   
01545   void InitAsDefaultInstance();
01546   static Table_Field* default_instance_;
01547 };
01548 // -------------------------------------------------------------------
01549 
01550 class Table_Index_IndexPart : public ::google::protobuf::Message {
01551  public:
01552   Table_Index_IndexPart();
01553   virtual ~Table_Index_IndexPart();
01554   
01555   Table_Index_IndexPart(const Table_Index_IndexPart& from);
01556   
01557   inline Table_Index_IndexPart& operator=(const Table_Index_IndexPart& from) {
01558     CopyFrom(from);
01559     return *this;
01560   }
01561   
01562   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01563     return _unknown_fields_;
01564   }
01565   
01566   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01567     return &_unknown_fields_;
01568   }
01569   
01570   static const ::google::protobuf::Descriptor* descriptor();
01571   static const Table_Index_IndexPart& default_instance();
01572   
01573   void Swap(Table_Index_IndexPart* other);
01574   
01575   // implements Message ----------------------------------------------
01576   
01577   Table_Index_IndexPart* New() const;
01578   void CopyFrom(const ::google::protobuf::Message& from);
01579   void MergeFrom(const ::google::protobuf::Message& from);
01580   void CopyFrom(const Table_Index_IndexPart& from);
01581   void MergeFrom(const Table_Index_IndexPart& from);
01582   void Clear();
01583   bool IsInitialized() const;
01584   
01585   int ByteSize() const;
01586   bool MergePartialFromCodedStream(
01587       ::google::protobuf::io::CodedInputStream* input);
01588   void SerializeWithCachedSizes(
01589       ::google::protobuf::io::CodedOutputStream* output) const;
01590   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01591   int GetCachedSize() const { return _cached_size_; }
01592   private:
01593   void SharedCtor();
01594   void SharedDtor();
01595   void SetCachedSize(int size) const;
01596   public:
01597   
01598   ::google::protobuf::Metadata GetMetadata() const;
01599   
01600   // nested types ----------------------------------------------------
01601   
01602   // accessors -------------------------------------------------------
01603   
01604   // required uint32 fieldnr = 1;
01605   inline bool has_fieldnr() const;
01606   inline void clear_fieldnr();
01607   static const int kFieldnrFieldNumber = 1;
01608   inline ::google::protobuf::uint32 fieldnr() const;
01609   inline void set_fieldnr(::google::protobuf::uint32 value);
01610   
01611   // optional uint32 compare_length = 2;
01612   inline bool has_compare_length() const;
01613   inline void clear_compare_length();
01614   static const int kCompareLengthFieldNumber = 2;
01615   inline ::google::protobuf::uint32 compare_length() const;
01616   inline void set_compare_length(::google::protobuf::uint32 value);
01617   
01618   // optional bool in_reverse_order = 3 [default = false];
01619   inline bool has_in_reverse_order() const;
01620   inline void clear_in_reverse_order();
01621   static const int kInReverseOrderFieldNumber = 3;
01622   inline bool in_reverse_order() const;
01623   inline void set_in_reverse_order(bool value);
01624   
01625   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Index.IndexPart)
01626  private:
01627   inline void set_has_fieldnr();
01628   inline void clear_has_fieldnr();
01629   inline void set_has_compare_length();
01630   inline void clear_has_compare_length();
01631   inline void set_has_in_reverse_order();
01632   inline void clear_has_in_reverse_order();
01633   
01634   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01635   
01636   ::google::protobuf::uint32 fieldnr_;
01637   ::google::protobuf::uint32 compare_length_;
01638   bool in_reverse_order_;
01639   
01640   mutable int _cached_size_;
01641   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
01642   
01643   friend void  protobuf_AddDesc_table_2eproto();
01644   friend void protobuf_AssignDesc_table_2eproto();
01645   friend void protobuf_ShutdownFile_table_2eproto();
01646   
01647   void InitAsDefaultInstance();
01648   static Table_Index_IndexPart* default_instance_;
01649 };
01650 // -------------------------------------------------------------------
01651 
01652 class Table_Index_Options : public ::google::protobuf::Message {
01653  public:
01654   Table_Index_Options();
01655   virtual ~Table_Index_Options();
01656   
01657   Table_Index_Options(const Table_Index_Options& from);
01658   
01659   inline Table_Index_Options& operator=(const Table_Index_Options& from) {
01660     CopyFrom(from);
01661     return *this;
01662   }
01663   
01664   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01665     return _unknown_fields_;
01666   }
01667   
01668   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01669     return &_unknown_fields_;
01670   }
01671   
01672   static const ::google::protobuf::Descriptor* descriptor();
01673   static const Table_Index_Options& default_instance();
01674   
01675   void Swap(Table_Index_Options* other);
01676   
01677   // implements Message ----------------------------------------------
01678   
01679   Table_Index_Options* New() const;
01680   void CopyFrom(const ::google::protobuf::Message& from);
01681   void MergeFrom(const ::google::protobuf::Message& from);
01682   void CopyFrom(const Table_Index_Options& from);
01683   void MergeFrom(const Table_Index_Options& from);
01684   void Clear();
01685   bool IsInitialized() const;
01686   
01687   int ByteSize() const;
01688   bool MergePartialFromCodedStream(
01689       ::google::protobuf::io::CodedInputStream* input);
01690   void SerializeWithCachedSizes(
01691       ::google::protobuf::io::CodedOutputStream* output) const;
01692   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01693   int GetCachedSize() const { return _cached_size_; }
01694   private:
01695   void SharedCtor();
01696   void SharedDtor();
01697   void SetCachedSize(int size) const;
01698   public:
01699   
01700   ::google::protobuf::Metadata GetMetadata() const;
01701   
01702   // nested types ----------------------------------------------------
01703   
01704   // accessors -------------------------------------------------------
01705   
01706   // optional bool pack_key = 1;
01707   inline bool has_pack_key() const;
01708   inline void clear_pack_key();
01709   static const int kPackKeyFieldNumber = 1;
01710   inline bool pack_key() const;
01711   inline void set_pack_key(bool value);
01712   
01713   // optional bool binary_pack_key = 2;
01714   inline bool has_binary_pack_key() const;
01715   inline void clear_binary_pack_key();
01716   static const int kBinaryPackKeyFieldNumber = 2;
01717   inline bool binary_pack_key() const;
01718   inline void set_binary_pack_key(bool value);
01719   
01720   // optional bool var_length_key = 3;
01721   inline bool has_var_length_key() const;
01722   inline void clear_var_length_key();
01723   static const int kVarLengthKeyFieldNumber = 3;
01724   inline bool var_length_key() const;
01725   inline void set_var_length_key(bool value);
01726   
01727   // optional bool null_part_key = 4;
01728   inline bool has_null_part_key() const;
01729   inline void clear_null_part_key();
01730   static const int kNullPartKeyFieldNumber = 4;
01731   inline bool null_part_key() const;
01732   inline void set_null_part_key(bool value);
01733   
01734   // optional uint32 key_block_size = 5;
01735   inline bool has_key_block_size() const;
01736   inline void clear_key_block_size();
01737   static const int kKeyBlockSizeFieldNumber = 5;
01738   inline ::google::protobuf::uint32 key_block_size() const;
01739   inline void set_key_block_size(::google::protobuf::uint32 value);
01740   
01741   // optional bool has_partial_segments = 6;
01742   inline bool has_has_partial_segments() const;
01743   inline void clear_has_partial_segments();
01744   static const int kHasPartialSegmentsFieldNumber = 6;
01745   inline bool has_partial_segments() const;
01746   inline void set_has_partial_segments(bool value);
01747   
01748   // optional bool auto_generated_key = 7;
01749   inline bool has_auto_generated_key() const;
01750   inline void clear_auto_generated_key();
01751   static const int kAutoGeneratedKeyFieldNumber = 7;
01752   inline bool auto_generated_key() const;
01753   inline void set_auto_generated_key(bool value);
01754   
01755   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Index.Options)
01756  private:
01757   inline void set_has_pack_key();
01758   inline void clear_has_pack_key();
01759   inline void set_has_binary_pack_key();
01760   inline void clear_has_binary_pack_key();
01761   inline void set_has_var_length_key();
01762   inline void clear_has_var_length_key();
01763   inline void set_has_null_part_key();
01764   inline void clear_has_null_part_key();
01765   inline void set_has_key_block_size();
01766   inline void clear_has_key_block_size();
01767   inline void set_has_has_partial_segments();
01768   inline void clear_has_has_partial_segments();
01769   inline void set_has_auto_generated_key();
01770   inline void clear_has_auto_generated_key();
01771   
01772   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01773   
01774   bool pack_key_;
01775   bool binary_pack_key_;
01776   bool var_length_key_;
01777   bool null_part_key_;
01778   ::google::protobuf::uint32 key_block_size_;
01779   bool has_partial_segments_;
01780   bool auto_generated_key_;
01781   
01782   mutable int _cached_size_;
01783   ::google::protobuf::uint32 _has_bits_[(7 + 31) / 32];
01784   
01785   friend void  protobuf_AddDesc_table_2eproto();
01786   friend void protobuf_AssignDesc_table_2eproto();
01787   friend void protobuf_ShutdownFile_table_2eproto();
01788   
01789   void InitAsDefaultInstance();
01790   static Table_Index_Options* default_instance_;
01791 };
01792 // -------------------------------------------------------------------
01793 
01794 class Table_Index : public ::google::protobuf::Message {
01795  public:
01796   Table_Index();
01797   virtual ~Table_Index();
01798   
01799   Table_Index(const Table_Index& from);
01800   
01801   inline Table_Index& operator=(const Table_Index& from) {
01802     CopyFrom(from);
01803     return *this;
01804   }
01805   
01806   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01807     return _unknown_fields_;
01808   }
01809   
01810   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01811     return &_unknown_fields_;
01812   }
01813   
01814   static const ::google::protobuf::Descriptor* descriptor();
01815   static const Table_Index& default_instance();
01816   
01817   void Swap(Table_Index* other);
01818   
01819   // implements Message ----------------------------------------------
01820   
01821   Table_Index* New() const;
01822   void CopyFrom(const ::google::protobuf::Message& from);
01823   void MergeFrom(const ::google::protobuf::Message& from);
01824   void CopyFrom(const Table_Index& from);
01825   void MergeFrom(const Table_Index& from);
01826   void Clear();
01827   bool IsInitialized() const;
01828   
01829   int ByteSize() const;
01830   bool MergePartialFromCodedStream(
01831       ::google::protobuf::io::CodedInputStream* input);
01832   void SerializeWithCachedSizes(
01833       ::google::protobuf::io::CodedOutputStream* output) const;
01834   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01835   int GetCachedSize() const { return _cached_size_; }
01836   private:
01837   void SharedCtor();
01838   void SharedDtor();
01839   void SetCachedSize(int size) const;
01840   public:
01841   
01842   ::google::protobuf::Metadata GetMetadata() const;
01843   
01844   // nested types ----------------------------------------------------
01845   
01846   typedef Table_Index_IndexPart IndexPart;
01847   typedef Table_Index_Options Options;
01848   
01849   typedef Table_Index_IndexType IndexType;
01850   static const IndexType UNKNOWN_INDEX = Table_Index_IndexType_UNKNOWN_INDEX;
01851   static const IndexType BTREE = Table_Index_IndexType_BTREE;
01852   static const IndexType RTREE = Table_Index_IndexType_RTREE;
01853   static const IndexType HASH = Table_Index_IndexType_HASH;
01854   static const IndexType FULLTEXT = Table_Index_IndexType_FULLTEXT;
01855   static inline bool IndexType_IsValid(int value) {
01856     return Table_Index_IndexType_IsValid(value);
01857   }
01858   static const IndexType IndexType_MIN =
01859     Table_Index_IndexType_IndexType_MIN;
01860   static const IndexType IndexType_MAX =
01861     Table_Index_IndexType_IndexType_MAX;
01862   static const int IndexType_ARRAYSIZE =
01863     Table_Index_IndexType_IndexType_ARRAYSIZE;
01864   static inline const ::google::protobuf::EnumDescriptor*
01865   IndexType_descriptor() {
01866     return Table_Index_IndexType_descriptor();
01867   }
01868   static inline const ::std::string& IndexType_Name(IndexType value) {
01869     return Table_Index_IndexType_Name(value);
01870   }
01871   static inline bool IndexType_Parse(const ::std::string& name,
01872       IndexType* value) {
01873     return Table_Index_IndexType_Parse(name, value);
01874   }
01875   
01876   // accessors -------------------------------------------------------
01877   
01878   // required string name = 1;
01879   inline bool has_name() const;
01880   inline void clear_name();
01881   static const int kNameFieldNumber = 1;
01882   inline const ::std::string& name() const;
01883   inline void set_name(const ::std::string& value);
01884   inline void set_name(const char* value);
01885   inline void set_name(const char* value, size_t size);
01886   inline ::std::string* mutable_name();
01887   inline ::std::string* release_name();
01888   
01889   // required bool is_primary = 2;
01890   inline bool has_is_primary() const;
01891   inline void clear_is_primary();
01892   static const int kIsPrimaryFieldNumber = 2;
01893   inline bool is_primary() const;
01894   inline void set_is_primary(bool value);
01895   
01896   // required bool is_unique = 3;
01897   inline bool has_is_unique() const;
01898   inline void clear_is_unique();
01899   static const int kIsUniqueFieldNumber = 3;
01900   inline bool is_unique() const;
01901   inline void set_is_unique(bool value);
01902   
01903   // required .drizzled.message.Table.Index.IndexType type = 4 [default = UNKNOWN_INDEX];
01904   inline bool has_type() const;
01905   inline void clear_type();
01906   static const int kTypeFieldNumber = 4;
01907   inline ::drizzled::message::Table_Index_IndexType type() const;
01908   inline void set_type(::drizzled::message::Table_Index_IndexType value);
01909   
01910   // required uint32 key_length = 5;
01911   inline bool has_key_length() const;
01912   inline void clear_key_length();
01913   static const int kKeyLengthFieldNumber = 5;
01914   inline ::google::protobuf::uint32 key_length() const;
01915   inline void set_key_length(::google::protobuf::uint32 value);
01916   
01917   // repeated .drizzled.message.Table.Index.IndexPart index_part = 6;
01918   inline int index_part_size() const;
01919   inline void clear_index_part();
01920   static const int kIndexPartFieldNumber = 6;
01921   inline const ::drizzled::message::Table_Index_IndexPart& index_part(int index) const;
01922   inline ::drizzled::message::Table_Index_IndexPart* mutable_index_part(int index);
01923   inline ::drizzled::message::Table_Index_IndexPart* add_index_part();
01924   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart >&
01925       index_part() const;
01926   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart >*
01927       mutable_index_part();
01928   
01929   // optional .drizzled.message.Table.Index.Options options = 7;
01930   inline bool has_options() const;
01931   inline void clear_options();
01932   static const int kOptionsFieldNumber = 7;
01933   inline const ::drizzled::message::Table_Index_Options& options() const;
01934   inline ::drizzled::message::Table_Index_Options* mutable_options();
01935   inline ::drizzled::message::Table_Index_Options* release_options();
01936   
01937   // optional string comment = 8;
01938   inline bool has_comment() const;
01939   inline void clear_comment();
01940   static const int kCommentFieldNumber = 8;
01941   inline const ::std::string& comment() const;
01942   inline void set_comment(const ::std::string& value);
01943   inline void set_comment(const char* value);
01944   inline void set_comment(const char* value, size_t size);
01945   inline ::std::string* mutable_comment();
01946   inline ::std::string* release_comment();
01947   
01948   // @@protoc_insertion_point(class_scope:drizzled.message.Table.Index)
01949  private:
01950   inline void set_has_name();
01951   inline void clear_has_name();
01952   inline void set_has_is_primary();
01953   inline void clear_has_is_primary();
01954   inline void set_has_is_unique();
01955   inline void clear_has_is_unique();
01956   inline void set_has_type();
01957   inline void clear_has_type();
01958   inline void set_has_key_length();
01959   inline void clear_has_key_length();
01960   inline void set_has_options();
01961   inline void clear_has_options();
01962   inline void set_has_comment();
01963   inline void clear_has_comment();
01964   
01965   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01966   
01967   ::std::string* name_;
01968   bool is_primary_;
01969   bool is_unique_;
01970   int type_;
01971   ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart > index_part_;
01972   ::drizzled::message::Table_Index_Options* options_;
01973   ::std::string* comment_;
01974   ::google::protobuf::uint32 key_length_;
01975   
01976   mutable int _cached_size_;
01977   ::google::protobuf::uint32 _has_bits_[(8 + 31) / 32];
01978   
01979   friend void  protobuf_AddDesc_table_2eproto();
01980   friend void protobuf_AssignDesc_table_2eproto();
01981   friend void protobuf_ShutdownFile_table_2eproto();
01982   
01983   void InitAsDefaultInstance();
01984   static Table_Index* default_instance_;
01985 };
01986 // -------------------------------------------------------------------
01987 
01988 class Table : public ::google::protobuf::Message {
01989  public:
01990   Table();
01991   virtual ~Table();
01992   
01993   Table(const Table& from);
01994   
01995   inline Table& operator=(const Table& from) {
01996     CopyFrom(from);
01997     return *this;
01998   }
01999   
02000   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
02001     return _unknown_fields_;
02002   }
02003   
02004   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
02005     return &_unknown_fields_;
02006   }
02007   
02008   static const ::google::protobuf::Descriptor* descriptor();
02009   static const Table& default_instance();
02010   
02011   void Swap(Table* other);
02012   
02013   // implements Message ----------------------------------------------
02014   
02015   Table* New() const;
02016   void CopyFrom(const ::google::protobuf::Message& from);
02017   void MergeFrom(const ::google::protobuf::Message& from);
02018   void CopyFrom(const Table& from);
02019   void MergeFrom(const Table& from);
02020   void Clear();
02021   bool IsInitialized() const;
02022   
02023   int ByteSize() const;
02024   bool MergePartialFromCodedStream(
02025       ::google::protobuf::io::CodedInputStream* input);
02026   void SerializeWithCachedSizes(
02027       ::google::protobuf::io::CodedOutputStream* output) const;
02028   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
02029   int GetCachedSize() const { return _cached_size_; }
02030   private:
02031   void SharedCtor();
02032   void SharedDtor();
02033   void SetCachedSize(int size) const;
02034   public:
02035   
02036   ::google::protobuf::Metadata GetMetadata() const;
02037   
02038   // nested types ----------------------------------------------------
02039   
02040   typedef Table_TableOptions TableOptions;
02041   typedef Table_ForeignKeyConstraint ForeignKeyConstraint;
02042   typedef Table_Field Field;
02043   typedef Table_Index Index;
02044   
02045   typedef Table_TableType TableType;
02046   static const TableType STANDARD = Table_TableType_STANDARD;
02047   static const TableType TEMPORARY = Table_TableType_TEMPORARY;
02048   static const TableType INTERNAL = Table_TableType_INTERNAL;
02049   static const TableType FUNCTION = Table_TableType_FUNCTION;
02050   static inline bool TableType_IsValid(int value) {
02051     return Table_TableType_IsValid(value);
02052   }
02053   static const TableType TableType_MIN =
02054     Table_TableType_TableType_MIN;
02055   static const TableType TableType_MAX =
02056     Table_TableType_TableType_MAX;
02057   static const int TableType_ARRAYSIZE =
02058     Table_TableType_TableType_ARRAYSIZE;
02059   static inline const ::google::protobuf::EnumDescriptor*
02060   TableType_descriptor() {
02061     return Table_TableType_descriptor();
02062   }
02063   static inline const ::std::string& TableType_Name(TableType value) {
02064     return Table_TableType_Name(value);
02065   }
02066   static inline bool TableType_Parse(const ::std::string& name,
02067       TableType* value) {
02068     return Table_TableType_Parse(name, value);
02069   }
02070   
02071   // accessors -------------------------------------------------------
02072   
02073   // required string name = 1;
02074   inline bool has_name() const;
02075   inline void clear_name();
02076   static const int kNameFieldNumber = 1;
02077   inline const ::std::string& name() const;
02078   inline void set_name(const ::std::string& value);
02079   inline void set_name(const char* value);
02080   inline void set_name(const char* value, size_t size);
02081   inline ::std::string* mutable_name();
02082   inline ::std::string* release_name();
02083   
02084   // required string schema = 6;
02085   inline bool has_schema() const;
02086   inline void clear_schema();
02087   static const int kSchemaFieldNumber = 6;
02088   inline const ::std::string& schema() const;
02089   inline void set_schema(const ::std::string& value);
02090   inline void set_schema(const char* value);
02091   inline void set_schema(const char* value, size_t size);
02092   inline ::std::string* mutable_schema();
02093   inline ::std::string* release_schema();
02094   
02095   // required .drizzled.message.Table.TableType type = 5;
02096   inline bool has_type() const;
02097   inline void clear_type();
02098   static const int kTypeFieldNumber = 5;
02099   inline ::drizzled::message::Table_TableType type() const;
02100   inline void set_type(::drizzled::message::Table_TableType value);
02101   
02102   // required .drizzled.message.Engine engine = 2;
02103   inline bool has_engine() const;
02104   inline void clear_engine();
02105   static const int kEngineFieldNumber = 2;
02106   inline const ::drizzled::message::Engine& engine() const;
02107   inline ::drizzled::message::Engine* mutable_engine();
02108   inline ::drizzled::message::Engine* release_engine();
02109   
02110   // repeated .drizzled.message.Table.Field field = 3;
02111   inline int field_size() const;
02112   inline void clear_field();
02113   static const int kFieldFieldNumber = 3;
02114   inline const ::drizzled::message::Table_Field& field(int index) const;
02115   inline ::drizzled::message::Table_Field* mutable_field(int index);
02116   inline ::drizzled::message::Table_Field* add_field();
02117   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >&
02118       field() const;
02119   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >*
02120       mutable_field();
02121   
02122   // repeated .drizzled.message.Table.Index indexes = 4;
02123   inline int indexes_size() const;
02124   inline void clear_indexes();
02125   static const int kIndexesFieldNumber = 4;
02126   inline const ::drizzled::message::Table_Index& indexes(int index) const;
02127   inline ::drizzled::message::Table_Index* mutable_indexes(int index);
02128   inline ::drizzled::message::Table_Index* add_indexes();
02129   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index >&
02130       indexes() const;
02131   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index >*
02132       mutable_indexes();
02133   
02134   // repeated .drizzled.message.Table.ForeignKeyConstraint fk_constraint = 8;
02135   inline int fk_constraint_size() const;
02136   inline void clear_fk_constraint();
02137   static const int kFkConstraintFieldNumber = 8;
02138   inline const ::drizzled::message::Table_ForeignKeyConstraint& fk_constraint(int index) const;
02139   inline ::drizzled::message::Table_ForeignKeyConstraint* mutable_fk_constraint(int index);
02140   inline ::drizzled::message::Table_ForeignKeyConstraint* add_fk_constraint();
02141   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint >&
02142       fk_constraint() const;
02143   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint >*
02144       mutable_fk_constraint();
02145   
02146   // optional .drizzled.message.Table.TableOptions options = 9;
02147   inline bool has_options() const;
02148   inline void clear_options();
02149   static const int kOptionsFieldNumber = 9;
02150   inline const ::drizzled::message::Table_TableOptions& options() const;
02151   inline ::drizzled::message::Table_TableOptions* mutable_options();
02152   inline ::drizzled::message::Table_TableOptions* release_options();
02153   
02154   // required uint64 creation_timestamp = 11 [default = 0];
02155   inline bool has_creation_timestamp() const;
02156   inline void clear_creation_timestamp();
02157   static const int kCreationTimestampFieldNumber = 11;
02158   inline ::google::protobuf::uint64 creation_timestamp() const;
02159   inline void set_creation_timestamp(::google::protobuf::uint64 value);
02160   
02161   // required uint64 update_timestamp = 12 [default = 0];
02162   inline bool has_update_timestamp() const;
02163   inline void clear_update_timestamp();
02164   static const int kUpdateTimestampFieldNumber = 12;
02165   inline ::google::protobuf::uint64 update_timestamp() const;
02166   inline void set_update_timestamp(::google::protobuf::uint64 value);
02167   
02168   // optional string catalog = 13;
02169   inline bool has_catalog() const;
02170   inline void clear_catalog();
02171   static const int kCatalogFieldNumber = 13;
02172   inline const ::std::string& catalog() const;
02173   inline void set_catalog(const ::std::string& value);
02174   inline void set_catalog(const char* value);
02175   inline void set_catalog(const char* value, size_t size);
02176   inline ::std::string* mutable_catalog();
02177   inline ::std::string* release_catalog();
02178   
02179   // optional string uuid = 14;
02180   inline bool has_uuid() const;
02181   inline void clear_uuid();
02182   static const int kUuidFieldNumber = 14;
02183   inline const ::std::string& uuid() const;
02184   inline void set_uuid(const ::std::string& value);
02185   inline void set_uuid(const char* value);
02186   inline void set_uuid(const char* value, size_t size);
02187   inline ::std::string* mutable_uuid();
02188   inline ::std::string* release_uuid();
02189   
02190   // optional uint64 version = 15;
02191   inline bool has_version() const;
02192   inline void clear_version();
02193   static const int kVersionFieldNumber = 15;
02194   inline ::google::protobuf::uint64 version() const;
02195   inline void set_version(::google::protobuf::uint64 value);
02196   
02197   // optional .drizzled.message.ReplicationOptions replication_options = 16;
02198   inline bool has_replication_options() const;
02199   inline void clear_replication_options();
02200   static const int kReplicationOptionsFieldNumber = 16;
02201   inline const ::drizzled::message::ReplicationOptions& replication_options() const;
02202   inline ::drizzled::message::ReplicationOptions* mutable_replication_options();
02203   inline ::drizzled::message::ReplicationOptions* release_replication_options();
02204   
02205   // @@protoc_insertion_point(class_scope:drizzled.message.Table)
02206  private:
02207   inline void set_has_name();
02208   inline void clear_has_name();
02209   inline void set_has_schema();
02210   inline void clear_has_schema();
02211   inline void set_has_type();
02212   inline void clear_has_type();
02213   inline void set_has_engine();
02214   inline void clear_has_engine();
02215   inline void set_has_options();
02216   inline void clear_has_options();
02217   inline void set_has_creation_timestamp();
02218   inline void clear_has_creation_timestamp();
02219   inline void set_has_update_timestamp();
02220   inline void clear_has_update_timestamp();
02221   inline void set_has_catalog();
02222   inline void clear_has_catalog();
02223   inline void set_has_uuid();
02224   inline void clear_has_uuid();
02225   inline void set_has_version();
02226   inline void clear_has_version();
02227   inline void set_has_replication_options();
02228   inline void clear_has_replication_options();
02229   
02230   ::google::protobuf::UnknownFieldSet _unknown_fields_;
02231   
02232   ::std::string* name_;
02233   ::std::string* schema_;
02234   ::drizzled::message::Engine* engine_;
02235   ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field > field_;
02236   ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index > indexes_;
02237   ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint > fk_constraint_;
02238   ::drizzled::message::Table_TableOptions* options_;
02239   ::google::protobuf::uint64 creation_timestamp_;
02240   ::google::protobuf::uint64 update_timestamp_;
02241   ::std::string* catalog_;
02242   ::std::string* uuid_;
02243   ::google::protobuf::uint64 version_;
02244   ::drizzled::message::ReplicationOptions* replication_options_;
02245   int type_;
02246   
02247   mutable int _cached_size_;
02248   ::google::protobuf::uint32 _has_bits_[(14 + 31) / 32];
02249   
02250   friend void  protobuf_AddDesc_table_2eproto();
02251   friend void protobuf_AssignDesc_table_2eproto();
02252   friend void protobuf_ShutdownFile_table_2eproto();
02253   
02254   void InitAsDefaultInstance();
02255   static Table* default_instance_;
02256 };
02257 // -------------------------------------------------------------------
02258 
02259 class AlterTable : public ::google::protobuf::Message {
02260  public:
02261   AlterTable();
02262   virtual ~AlterTable();
02263   
02264   AlterTable(const AlterTable& from);
02265   
02266   inline AlterTable& operator=(const AlterTable& from) {
02267     CopyFrom(from);
02268     return *this;
02269   }
02270   
02271   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
02272     return _unknown_fields_;
02273   }
02274   
02275   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
02276     return &_unknown_fields_;
02277   }
02278   
02279   static const ::google::protobuf::Descriptor* descriptor();
02280   static const AlterTable& default_instance();
02281   
02282   void Swap(AlterTable* other);
02283   
02284   // implements Message ----------------------------------------------
02285   
02286   AlterTable* New() const;
02287   void CopyFrom(const ::google::protobuf::Message& from);
02288   void MergeFrom(const ::google::protobuf::Message& from);
02289   void CopyFrom(const AlterTable& from);
02290   void MergeFrom(const AlterTable& from);
02291   void Clear();
02292   bool IsInitialized() const;
02293   
02294   int ByteSize() const;
02295   bool MergePartialFromCodedStream(
02296       ::google::protobuf::io::CodedInputStream* input);
02297   void SerializeWithCachedSizes(
02298       ::google::protobuf::io::CodedOutputStream* output) const;
02299   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
02300   int GetCachedSize() const { return _cached_size_; }
02301   private:
02302   void SharedCtor();
02303   void SharedDtor();
02304   void SetCachedSize(int size) const;
02305   public:
02306   
02307   ::google::protobuf::Metadata GetMetadata() const;
02308   
02309   // nested types ----------------------------------------------------
02310   
02311   // accessors -------------------------------------------------------
02312   
02313   // repeated .drizzled.message.Table.Field added_field = 1;
02314   inline int added_field_size() const;
02315   inline void clear_added_field();
02316   static const int kAddedFieldFieldNumber = 1;
02317   inline const ::drizzled::message::Table_Field& added_field(int index) const;
02318   inline ::drizzled::message::Table_Field* mutable_added_field(int index);
02319   inline ::drizzled::message::Table_Field* add_added_field();
02320   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >&
02321       added_field() const;
02322   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >*
02323       mutable_added_field();
02324   
02325   // @@protoc_insertion_point(class_scope:drizzled.message.AlterTable)
02326  private:
02327   
02328   ::google::protobuf::UnknownFieldSet _unknown_fields_;
02329   
02330   ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field > added_field_;
02331   
02332   mutable int _cached_size_;
02333   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
02334   
02335   friend void  protobuf_AddDesc_table_2eproto();
02336   friend void protobuf_AssignDesc_table_2eproto();
02337   friend void protobuf_ShutdownFile_table_2eproto();
02338   
02339   void InitAsDefaultInstance();
02340   static AlterTable* default_instance_;
02341 };
02342 // ===================================================================
02343 
02344 
02345 // ===================================================================
02346 
02347 // Table_TableOptions
02348 
02349 // optional bool has_user_set_auto_increment_value = 1;
02350 inline bool Table_TableOptions::has_has_user_set_auto_increment_value() const {
02351   return (_has_bits_[0] & 0x00000001u) != 0;
02352 }
02353 inline void Table_TableOptions::set_has_has_user_set_auto_increment_value() {
02354   _has_bits_[0] |= 0x00000001u;
02355 }
02356 inline void Table_TableOptions::clear_has_has_user_set_auto_increment_value() {
02357   _has_bits_[0] &= ~0x00000001u;
02358 }
02359 inline void Table_TableOptions::clear_has_user_set_auto_increment_value() {
02360   has_user_set_auto_increment_value_ = false;
02361   clear_has_has_user_set_auto_increment_value();
02362 }
02363 inline bool Table_TableOptions::has_user_set_auto_increment_value() const {
02364   return has_user_set_auto_increment_value_;
02365 }
02366 inline void Table_TableOptions::set_has_user_set_auto_increment_value(bool value) {
02367   set_has_has_user_set_auto_increment_value();
02368   has_user_set_auto_increment_value_ = value;
02369 }
02370 
02371 // optional string collation = 2;
02372 inline bool Table_TableOptions::has_collation() const {
02373   return (_has_bits_[0] & 0x00000002u) != 0;
02374 }
02375 inline void Table_TableOptions::set_has_collation() {
02376   _has_bits_[0] |= 0x00000002u;
02377 }
02378 inline void Table_TableOptions::clear_has_collation() {
02379   _has_bits_[0] &= ~0x00000002u;
02380 }
02381 inline void Table_TableOptions::clear_collation() {
02382   if (collation_ != &::google::protobuf::internal::kEmptyString) {
02383     collation_->clear();
02384   }
02385   clear_has_collation();
02386 }
02387 inline const ::std::string& Table_TableOptions::collation() const {
02388   return *collation_;
02389 }
02390 inline void Table_TableOptions::set_collation(const ::std::string& value) {
02391   set_has_collation();
02392   if (collation_ == &::google::protobuf::internal::kEmptyString) {
02393     collation_ = new ::std::string;
02394   }
02395   collation_->assign(value);
02396 }
02397 inline void Table_TableOptions::set_collation(const char* value) {
02398   set_has_collation();
02399   if (collation_ == &::google::protobuf::internal::kEmptyString) {
02400     collation_ = new ::std::string;
02401   }
02402   collation_->assign(value);
02403 }
02404 inline void Table_TableOptions::set_collation(const char* value, size_t size) {
02405   set_has_collation();
02406   if (collation_ == &::google::protobuf::internal::kEmptyString) {
02407     collation_ = new ::std::string;
02408   }
02409   collation_->assign(reinterpret_cast<const char*>(value), size);
02410 }
02411 inline ::std::string* Table_TableOptions::mutable_collation() {
02412   set_has_collation();
02413   if (collation_ == &::google::protobuf::internal::kEmptyString) {
02414     collation_ = new ::std::string;
02415   }
02416   return collation_;
02417 }
02418 inline ::std::string* Table_TableOptions::release_collation() {
02419   clear_has_collation();
02420   if (collation_ == &::google::protobuf::internal::kEmptyString) {
02421     return NULL;
02422   } else {
02423     ::std::string* temp = collation_;
02424     collation_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
02425     return temp;
02426   }
02427 }
02428 
02429 // optional uint32 collation_id = 3;
02430 inline bool Table_TableOptions::has_collation_id() const {
02431   return (_has_bits_[0] & 0x00000004u) != 0;
02432 }
02433 inline void Table_TableOptions::set_has_collation_id() {
02434   _has_bits_[0] |= 0x00000004u;
02435 }
02436 inline void Table_TableOptions::clear_has_collation_id() {
02437   _has_bits_[0] &= ~0x00000004u;
02438 }
02439 inline void Table_TableOptions::clear_collation_id() {
02440   collation_id_ = 0u;
02441   clear_has_collation_id();
02442 }
02443 inline ::google::protobuf::uint32 Table_TableOptions::collation_id() const {
02444   return collation_id_;
02445 }
02446 inline void Table_TableOptions::set_collation_id(::google::protobuf::uint32 value) {
02447   set_has_collation_id();
02448   collation_id_ = value;
02449 }
02450 
02451 // optional string data_file_name = 5;
02452 inline bool Table_TableOptions::has_data_file_name() const {
02453   return (_has_bits_[0] & 0x00000008u) != 0;
02454 }
02455 inline void Table_TableOptions::set_has_data_file_name() {
02456   _has_bits_[0] |= 0x00000008u;
02457 }
02458 inline void Table_TableOptions::clear_has_data_file_name() {
02459   _has_bits_[0] &= ~0x00000008u;
02460 }
02461 inline void Table_TableOptions::clear_data_file_name() {
02462   if (data_file_name_ != &::google::protobuf::internal::kEmptyString) {
02463     data_file_name_->clear();
02464   }
02465   clear_has_data_file_name();
02466 }
02467 inline const ::std::string& Table_TableOptions::data_file_name() const {
02468   return *data_file_name_;
02469 }
02470 inline void Table_TableOptions::set_data_file_name(const ::std::string& value) {
02471   set_has_data_file_name();
02472   if (data_file_name_ == &::google::protobuf::internal::kEmptyString) {
02473     data_file_name_ = new ::std::string;
02474   }
02475   data_file_name_->assign(value);
02476 }
02477 inline void Table_TableOptions::set_data_file_name(const char* value) {
02478   set_has_data_file_name();
02479   if (data_file_name_ == &::google::protobuf::internal::kEmptyString) {
02480     data_file_name_ = new ::std::string;
02481   }
02482   data_file_name_->assign(value);
02483 }
02484 inline void Table_TableOptions::set_data_file_name(const char* value, size_t size) {
02485   set_has_data_file_name();
02486   if (data_file_name_ == &::google::protobuf::internal::kEmptyString) {
02487     data_file_name_ = new ::std::string;
02488   }
02489   data_file_name_->assign(reinterpret_cast<const char*>(value), size);
02490 }
02491 inline ::std::string* Table_TableOptions::mutable_data_file_name() {
02492   set_has_data_file_name();
02493   if (data_file_name_ == &::google::protobuf::internal::kEmptyString) {
02494     data_file_name_ = new ::std::string;
02495   }
02496   return data_file_name_;
02497 }
02498 inline ::std::string* Table_TableOptions::release_data_file_name() {
02499   clear_has_data_file_name();
02500   if (data_file_name_ == &::google::protobuf::internal::kEmptyString) {
02501     return NULL;
02502   } else {
02503     ::std::string* temp = data_file_name_;
02504     data_file_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
02505     return temp;
02506   }
02507 }
02508 
02509 // optional string index_file_name = 6;
02510 inline bool Table_TableOptions::has_index_file_name() const {
02511   return (_has_bits_[0] & 0x00000010u) != 0;
02512 }
02513 inline void Table_TableOptions::set_has_index_file_name() {
02514   _has_bits_[0] |= 0x00000010u;
02515 }
02516 inline void Table_TableOptions::clear_has_index_file_name() {
02517   _has_bits_[0] &= ~0x00000010u;
02518 }
02519 inline void Table_TableOptions::clear_index_file_name() {
02520   if (index_file_name_ != &::google::protobuf::internal::kEmptyString) {
02521     index_file_name_->clear();
02522   }
02523   clear_has_index_file_name();
02524 }
02525 inline const ::std::string& Table_TableOptions::index_file_name() const {
02526   return *index_file_name_;
02527 }
02528 inline void Table_TableOptions::set_index_file_name(const ::std::string& value) {
02529   set_has_index_file_name();
02530   if (index_file_name_ == &::google::protobuf::internal::kEmptyString) {
02531     index_file_name_ = new ::std::string;
02532   }
02533   index_file_name_->assign(value);
02534 }
02535 inline void Table_TableOptions::set_index_file_name(const char* value) {
02536   set_has_index_file_name();
02537   if (index_file_name_ == &::google::protobuf::internal::kEmptyString) {
02538     index_file_name_ = new ::std::string;
02539   }
02540   index_file_name_->assign(value);
02541 }
02542 inline void Table_TableOptions::set_index_file_name(const char* value, size_t size) {
02543   set_has_index_file_name();
02544   if (index_file_name_ == &::google::protobuf::internal::kEmptyString) {
02545     index_file_name_ = new ::std::string;
02546   }
02547   index_file_name_->assign(reinterpret_cast<const char*>(value), size);
02548 }
02549 inline ::std::string* Table_TableOptions::mutable_index_file_name() {
02550   set_has_index_file_name();
02551   if (index_file_name_ == &::google::protobuf::internal::kEmptyString) {
02552     index_file_name_ = new ::std::string;
02553   }
02554   return index_file_name_;
02555 }
02556 inline ::std::string* Table_TableOptions::release_index_file_name() {
02557   clear_has_index_file_name();
02558   if (index_file_name_ == &::google::protobuf::internal::kEmptyString) {
02559     return NULL;
02560   } else {
02561     ::std::string* temp = index_file_name_;
02562     index_file_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
02563     return temp;
02564   }
02565 }
02566 
02567 // optional uint64 max_rows = 7;
02568 inline bool Table_TableOptions::has_max_rows() const {
02569   return (_has_bits_[0] & 0x00000020u) != 0;
02570 }
02571 inline void Table_TableOptions::set_has_max_rows() {
02572   _has_bits_[0] |= 0x00000020u;
02573 }
02574 inline void Table_TableOptions::clear_has_max_rows() {
02575   _has_bits_[0] &= ~0x00000020u;
02576 }
02577 inline void Table_TableOptions::clear_max_rows() {
02578   max_rows_ = GOOGLE_ULONGLONG(0);
02579   clear_has_max_rows();
02580 }
02581 inline ::google::protobuf::uint64 Table_TableOptions::max_rows() const {
02582   return max_rows_;
02583 }
02584 inline void Table_TableOptions::set_max_rows(::google::protobuf::uint64 value) {
02585   set_has_max_rows();
02586   max_rows_ = value;
02587 }
02588 
02589 // optional uint64 min_rows = 8;
02590 inline bool Table_TableOptions::has_min_rows() const {
02591   return (_has_bits_[0] & 0x00000040u) != 0;
02592 }
02593 inline void Table_TableOptions::set_has_min_rows() {
02594   _has_bits_[0] |= 0x00000040u;
02595 }
02596 inline void Table_TableOptions::clear_has_min_rows() {
02597   _has_bits_[0] &= ~0x00000040u;
02598 }
02599 inline void Table_TableOptions::clear_min_rows() {
02600   min_rows_ = GOOGLE_ULONGLONG(0);
02601   clear_has_min_rows();
02602 }
02603 inline ::google::protobuf::uint64 Table_TableOptions::min_rows() const {
02604   return min_rows_;
02605 }
02606 inline void Table_TableOptions::set_min_rows(::google::protobuf::uint64 value) {
02607   set_has_min_rows();
02608   min_rows_ = value;
02609 }
02610 
02611 // optional uint64 auto_increment_value = 9;
02612 inline bool Table_TableOptions::has_auto_increment_value() const {
02613   return (_has_bits_[0] & 0x00000080u) != 0;
02614 }
02615 inline void Table_TableOptions::set_has_auto_increment_value() {
02616   _has_bits_[0] |= 0x00000080u;
02617 }
02618 inline void Table_TableOptions::clear_has_auto_increment_value() {
02619   _has_bits_[0] &= ~0x00000080u;
02620 }
02621 inline void Table_TableOptions::clear_auto_increment_value() {
02622   auto_increment_value_ = GOOGLE_ULONGLONG(0);
02623   clear_has_auto_increment_value();
02624 }
02625 inline ::google::protobuf::uint64 Table_TableOptions::auto_increment_value() const {
02626   return auto_increment_value_;
02627 }
02628 inline void Table_TableOptions::set_auto_increment_value(::google::protobuf::uint64 value) {
02629   set_has_auto_increment_value();
02630   auto_increment_value_ = value;
02631 }
02632 
02633 // optional uint32 avg_row_length = 11;
02634 inline bool Table_TableOptions::has_avg_row_length() const {
02635   return (_has_bits_[0] & 0x00000100u) != 0;
02636 }
02637 inline void Table_TableOptions::set_has_avg_row_length() {
02638   _has_bits_[0] |= 0x00000100u;
02639 }
02640 inline void Table_TableOptions::clear_has_avg_row_length() {
02641   _has_bits_[0] &= ~0x00000100u;
02642 }
02643 inline void Table_TableOptions::clear_avg_row_length() {
02644   avg_row_length_ = 0u;
02645   clear_has_avg_row_length();
02646 }
02647 inline ::google::protobuf::uint32 Table_TableOptions::avg_row_length() const {
02648   return avg_row_length_;
02649 }
02650 inline void Table_TableOptions::set_avg_row_length(::google::protobuf::uint32 value) {
02651   set_has_avg_row_length();
02652   avg_row_length_ = value;
02653 }
02654 
02655 // optional uint32 block_size = 13;
02656 inline bool Table_TableOptions::has_block_size() const {
02657   return (_has_bits_[0] & 0x00000200u) != 0;
02658 }
02659 inline void Table_TableOptions::set_has_block_size() {
02660   _has_bits_[0] |= 0x00000200u;
02661 }
02662 inline void Table_TableOptions::clear_has_block_size() {
02663   _has_bits_[0] &= ~0x00000200u;
02664 }
02665 inline void Table_TableOptions::clear_block_size() {
02666   block_size_ = 0u;
02667   clear_has_block_size();
02668 }
02669 inline ::google::protobuf::uint32 Table_TableOptions::block_size() const {
02670   return block_size_;
02671 }
02672 inline void Table_TableOptions::set_block_size(::google::protobuf::uint32 value) {
02673   set_has_block_size();
02674   block_size_ = value;
02675 }
02676 
02677 // optional string comment = 14;
02678 inline bool Table_TableOptions::has_comment() const {
02679   return (_has_bits_[0] & 0x00000400u) != 0;
02680 }
02681 inline void Table_TableOptions::set_has_comment() {
02682   _has_bits_[0] |= 0x00000400u;
02683 }
02684 inline void Table_TableOptions::clear_has_comment() {
02685   _has_bits_[0] &= ~0x00000400u;
02686 }
02687 inline void Table_TableOptions::clear_comment() {
02688   if (comment_ != &::google::protobuf::internal::kEmptyString) {
02689     comment_->clear();
02690   }
02691   clear_has_comment();
02692 }
02693 inline const ::std::string& Table_TableOptions::comment() const {
02694   return *comment_;
02695 }
02696 inline void Table_TableOptions::set_comment(const ::std::string& value) {
02697   set_has_comment();
02698   if (comment_ == &::google::protobuf::internal::kEmptyString) {
02699     comment_ = new ::std::string;
02700   }
02701   comment_->assign(value);
02702 }
02703 inline void Table_TableOptions::set_comment(const char* value) {
02704   set_has_comment();
02705   if (comment_ == &::google::protobuf::internal::kEmptyString) {
02706     comment_ = new ::std::string;
02707   }
02708   comment_->assign(value);
02709 }
02710 inline void Table_TableOptions::set_comment(const char* value, size_t size) {
02711   set_has_comment();
02712   if (comment_ == &::google::protobuf::internal::kEmptyString) {
02713     comment_ = new ::std::string;
02714   }
02715   comment_->assign(reinterpret_cast<const char*>(value), size);
02716 }
02717 inline ::std::string* Table_TableOptions::mutable_comment() {
02718   set_has_comment();
02719   if (comment_ == &::google::protobuf::internal::kEmptyString) {
02720     comment_ = new ::std::string;
02721   }
02722   return comment_;
02723 }
02724 inline ::std::string* Table_TableOptions::release_comment() {
02725   clear_has_comment();
02726   if (comment_ == &::google::protobuf::internal::kEmptyString) {
02727     return NULL;
02728   } else {
02729     ::std::string* temp = comment_;
02730     comment_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
02731     return temp;
02732   }
02733 }
02734 
02735 // optional bool pack_record = 16;
02736 inline bool Table_TableOptions::has_pack_record() const {
02737   return (_has_bits_[0] & 0x00000800u) != 0;
02738 }
02739 inline void Table_TableOptions::set_has_pack_record() {
02740   _has_bits_[0] |= 0x00000800u;
02741 }
02742 inline void Table_TableOptions::clear_has_pack_record() {
02743   _has_bits_[0] &= ~0x00000800u;
02744 }
02745 inline void Table_TableOptions::clear_pack_record() {
02746   pack_record_ = false;
02747   clear_has_pack_record();
02748 }
02749 inline bool Table_TableOptions::pack_record() const {
02750   return pack_record_;
02751 }
02752 inline void Table_TableOptions::set_pack_record(bool value) {
02753   set_has_pack_record();
02754   pack_record_ = value;
02755 }
02756 
02757 // optional bool checksum = 17;
02758 inline bool Table_TableOptions::has_checksum() const {
02759   return (_has_bits_[0] & 0x00001000u) != 0;
02760 }
02761 inline void Table_TableOptions::set_has_checksum() {
02762   _has_bits_[0] |= 0x00001000u;
02763 }
02764 inline void Table_TableOptions::clear_has_checksum() {
02765   _has_bits_[0] &= ~0x00001000u;
02766 }
02767 inline void Table_TableOptions::clear_checksum() {
02768   checksum_ = false;
02769   clear_has_checksum();
02770 }
02771 inline bool Table_TableOptions::checksum() const {
02772   return checksum_;
02773 }
02774 inline void Table_TableOptions::set_checksum(bool value) {
02775   set_has_checksum();
02776   checksum_ = value;
02777 }
02778 
02779 // optional bool page_checksum = 18;
02780 inline bool Table_TableOptions::has_page_checksum() const {
02781   return (_has_bits_[0] & 0x00002000u) != 0;
02782 }
02783 inline void Table_TableOptions::set_has_page_checksum() {
02784   _has_bits_[0] |= 0x00002000u;
02785 }
02786 inline void Table_TableOptions::clear_has_page_checksum() {
02787   _has_bits_[0] &= ~0x00002000u;
02788 }
02789 inline void Table_TableOptions::clear_page_checksum() {
02790   page_checksum_ = false;
02791   clear_has_page_checksum();
02792 }
02793 inline bool Table_TableOptions::page_checksum() const {
02794   return page_checksum_;
02795 }
02796 inline void Table_TableOptions::set_page_checksum(bool value) {
02797   set_has_page_checksum();
02798   page_checksum_ = value;
02799 }
02800 
02801 // optional bool delay_key_write = 19;
02802 inline bool Table_TableOptions::has_delay_key_write() const {
02803   return (_has_bits_[0] & 0x00004000u) != 0;
02804 }
02805 inline void Table_TableOptions::set_has_delay_key_write() {
02806   _has_bits_[0] |= 0x00004000u;
02807 }
02808 inline void Table_TableOptions::clear_has_delay_key_write() {
02809   _has_bits_[0] &= ~0x00004000u;
02810 }
02811 inline void Table_TableOptions::clear_delay_key_write() {
02812   delay_key_write_ = false;
02813   clear_has_delay_key_write();
02814 }
02815 inline bool Table_TableOptions::delay_key_write() const {
02816   return delay_key_write_;
02817 }
02818 inline void Table_TableOptions::set_delay_key_write(bool value) {
02819   set_has_delay_key_write();
02820   delay_key_write_ = value;
02821 }
02822 
02823 // optional bool dont_replicate = 20;
02824 inline bool Table_TableOptions::has_dont_replicate() const {
02825   return (_has_bits_[0] & 0x00008000u) != 0;
02826 }
02827 inline void Table_TableOptions::set_has_dont_replicate() {
02828   _has_bits_[0] |= 0x00008000u;
02829 }
02830 inline void Table_TableOptions::clear_has_dont_replicate() {
02831   _has_bits_[0] &= ~0x00008000u;
02832 }
02833 inline void Table_TableOptions::clear_dont_replicate() {
02834   dont_replicate_ = false;
02835   clear_has_dont_replicate();
02836 }
02837 inline bool Table_TableOptions::dont_replicate() const {
02838   return dont_replicate_;
02839 }
02840 inline void Table_TableOptions::set_dont_replicate(bool value) {
02841   set_has_dont_replicate();
02842   dont_replicate_ = value;
02843 }
02844 
02845 // -------------------------------------------------------------------
02846 
02847 // Table_ForeignKeyConstraint
02848 
02849 // optional string name = 1;
02850 inline bool Table_ForeignKeyConstraint::has_name() const {
02851   return (_has_bits_[0] & 0x00000001u) != 0;
02852 }
02853 inline void Table_ForeignKeyConstraint::set_has_name() {
02854   _has_bits_[0] |= 0x00000001u;
02855 }
02856 inline void Table_ForeignKeyConstraint::clear_has_name() {
02857   _has_bits_[0] &= ~0x00000001u;
02858 }
02859 inline void Table_ForeignKeyConstraint::clear_name() {
02860   if (name_ != &::google::protobuf::internal::kEmptyString) {
02861     name_->clear();
02862   }
02863   clear_has_name();
02864 }
02865 inline const ::std::string& Table_ForeignKeyConstraint::name() const {
02866   return *name_;
02867 }
02868 inline void Table_ForeignKeyConstraint::set_name(const ::std::string& value) {
02869   set_has_name();
02870   if (name_ == &::google::protobuf::internal::kEmptyString) {
02871     name_ = new ::std::string;
02872   }
02873   name_->assign(value);
02874 }
02875 inline void Table_ForeignKeyConstraint::set_name(const char* value) {
02876   set_has_name();
02877   if (name_ == &::google::protobuf::internal::kEmptyString) {
02878     name_ = new ::std::string;
02879   }
02880   name_->assign(value);
02881 }
02882 inline void Table_ForeignKeyConstraint::set_name(const char* value, size_t size) {
02883   set_has_name();
02884   if (name_ == &::google::protobuf::internal::kEmptyString) {
02885     name_ = new ::std::string;
02886   }
02887   name_->assign(reinterpret_cast<const char*>(value), size);
02888 }
02889 inline ::std::string* Table_ForeignKeyConstraint::mutable_name() {
02890   set_has_name();
02891   if (name_ == &::google::protobuf::internal::kEmptyString) {
02892     name_ = new ::std::string;
02893   }
02894   return name_;
02895 }
02896 inline ::std::string* Table_ForeignKeyConstraint::release_name() {
02897   clear_has_name();
02898   if (name_ == &::google::protobuf::internal::kEmptyString) {
02899     return NULL;
02900   } else {
02901     ::std::string* temp = name_;
02902     name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
02903     return temp;
02904   }
02905 }
02906 
02907 // repeated string column_names = 2;
02908 inline int Table_ForeignKeyConstraint::column_names_size() const {
02909   return column_names_.size();
02910 }
02911 inline void Table_ForeignKeyConstraint::clear_column_names() {
02912   column_names_.Clear();
02913 }
02914 inline const ::std::string& Table_ForeignKeyConstraint::column_names(int index) const {
02915   return column_names_.Get(index);
02916 }
02917 inline ::std::string* Table_ForeignKeyConstraint::mutable_column_names(int index) {
02918   return column_names_.Mutable(index);
02919 }
02920 inline void Table_ForeignKeyConstraint::set_column_names(int index, const ::std::string& value) {
02921   column_names_.Mutable(index)->assign(value);
02922 }
02923 inline void Table_ForeignKeyConstraint::set_column_names(int index, const char* value) {
02924   column_names_.Mutable(index)->assign(value);
02925 }
02926 inline void Table_ForeignKeyConstraint::set_column_names(int index, const char* value, size_t size) {
02927   column_names_.Mutable(index)->assign(
02928     reinterpret_cast<const char*>(value), size);
02929 }
02930 inline ::std::string* Table_ForeignKeyConstraint::add_column_names() {
02931   return column_names_.Add();
02932 }
02933 inline void Table_ForeignKeyConstraint::add_column_names(const ::std::string& value) {
02934   column_names_.Add()->assign(value);
02935 }
02936 inline void Table_ForeignKeyConstraint::add_column_names(const char* value) {
02937   column_names_.Add()->assign(value);
02938 }
02939 inline void Table_ForeignKeyConstraint::add_column_names(const char* value, size_t size) {
02940   column_names_.Add()->assign(reinterpret_cast<const char*>(value), size);
02941 }
02942 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
02943 Table_ForeignKeyConstraint::column_names() const {
02944   return column_names_;
02945 }
02946 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
02947 Table_ForeignKeyConstraint::mutable_column_names() {
02948   return &column_names_;
02949 }
02950 
02951 // required string references_table_name = 3;
02952 inline bool Table_ForeignKeyConstraint::has_references_table_name() const {
02953   return (_has_bits_[0] & 0x00000004u) != 0;
02954 }
02955 inline void Table_ForeignKeyConstraint::set_has_references_table_name() {
02956   _has_bits_[0] |= 0x00000004u;
02957 }
02958 inline void Table_ForeignKeyConstraint::clear_has_references_table_name() {
02959   _has_bits_[0] &= ~0x00000004u;
02960 }
02961 inline void Table_ForeignKeyConstraint::clear_references_table_name() {
02962   if (references_table_name_ != &::google::protobuf::internal::kEmptyString) {
02963     references_table_name_->clear();
02964   }
02965   clear_has_references_table_name();
02966 }
02967 inline const ::std::string& Table_ForeignKeyConstraint::references_table_name() const {
02968   return *references_table_name_;
02969 }
02970 inline void Table_ForeignKeyConstraint::set_references_table_name(const ::std::string& value) {
02971   set_has_references_table_name();
02972   if (references_table_name_ == &::google::protobuf::internal::kEmptyString) {
02973     references_table_name_ = new ::std::string;
02974   }
02975   references_table_name_->assign(value);
02976 }
02977 inline void Table_ForeignKeyConstraint::set_references_table_name(const char* value) {
02978   set_has_references_table_name();
02979   if (references_table_name_ == &::google::protobuf::internal::kEmptyString) {
02980     references_table_name_ = new ::std::string;
02981   }
02982   references_table_name_->assign(value);
02983 }
02984 inline void Table_ForeignKeyConstraint::set_references_table_name(const char* value, size_t size) {
02985   set_has_references_table_name();
02986   if (references_table_name_ == &::google::protobuf::internal::kEmptyString) {
02987     references_table_name_ = new ::std::string;
02988   }
02989   references_table_name_->assign(reinterpret_cast<const char*>(value), size);
02990 }
02991 inline ::std::string* Table_ForeignKeyConstraint::mutable_references_table_name() {
02992   set_has_references_table_name();
02993   if (references_table_name_ == &::google::protobuf::internal::kEmptyString) {
02994     references_table_name_ = new ::std::string;
02995   }
02996   return references_table_name_;
02997 }
02998 inline ::std::string* Table_ForeignKeyConstraint::release_references_table_name() {
02999   clear_has_references_table_name();
03000   if (references_table_name_ == &::google::protobuf::internal::kEmptyString) {
03001     return NULL;
03002   } else {
03003     ::std::string* temp = references_table_name_;
03004     references_table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
03005     return temp;
03006   }
03007 }
03008 
03009 // repeated string references_columns = 4;
03010 inline int Table_ForeignKeyConstraint::references_columns_size() const {
03011   return references_columns_.size();
03012 }
03013 inline void Table_ForeignKeyConstraint::clear_references_columns() {
03014   references_columns_.Clear();
03015 }
03016 inline const ::std::string& Table_ForeignKeyConstraint::references_columns(int index) const {
03017   return references_columns_.Get(index);
03018 }
03019 inline ::std::string* Table_ForeignKeyConstraint::mutable_references_columns(int index) {
03020   return references_columns_.Mutable(index);
03021 }
03022 inline void Table_ForeignKeyConstraint::set_references_columns(int index, const ::std::string& value) {
03023   references_columns_.Mutable(index)->assign(value);
03024 }
03025 inline void Table_ForeignKeyConstraint::set_references_columns(int index, const char* value) {
03026   references_columns_.Mutable(index)->assign(value);
03027 }
03028 inline void Table_ForeignKeyConstraint::set_references_columns(int index, const char* value, size_t size) {
03029   references_columns_.Mutable(index)->assign(
03030     reinterpret_cast<const char*>(value), size);
03031 }
03032 inline ::std::string* Table_ForeignKeyConstraint::add_references_columns() {
03033   return references_columns_.Add();
03034 }
03035 inline void Table_ForeignKeyConstraint::add_references_columns(const ::std::string& value) {
03036   references_columns_.Add()->assign(value);
03037 }
03038 inline void Table_ForeignKeyConstraint::add_references_columns(const char* value) {
03039   references_columns_.Add()->assign(value);
03040 }
03041 inline void Table_ForeignKeyConstraint::add_references_columns(const char* value, size_t size) {
03042   references_columns_.Add()->assign(reinterpret_cast<const char*>(value), size);
03043 }
03044 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
03045 Table_ForeignKeyConstraint::references_columns() const {
03046   return references_columns_;
03047 }
03048 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
03049 Table_ForeignKeyConstraint::mutable_references_columns() {
03050   return &references_columns_;
03051 }
03052 
03053 // required .drizzled.message.Table.ForeignKeyConstraint.ForeignKeyMatchOption match = 5;
03054 inline bool Table_ForeignKeyConstraint::has_match() const {
03055   return (_has_bits_[0] & 0x00000010u) != 0;
03056 }
03057 inline void Table_ForeignKeyConstraint::set_has_match() {
03058   _has_bits_[0] |= 0x00000010u;
03059 }
03060 inline void Table_ForeignKeyConstraint::clear_has_match() {
03061   _has_bits_[0] &= ~0x00000010u;
03062 }
03063 inline void Table_ForeignKeyConstraint::clear_match() {
03064   match_ = 0;
03065   clear_has_match();
03066 }
03067 inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption Table_ForeignKeyConstraint::match() const {
03068   return static_cast< ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption >(match_);
03069 }
03070 inline void Table_ForeignKeyConstraint::set_match(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption value) {
03071   GOOGLE_DCHECK(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption_IsValid(value));
03072   set_has_match();
03073   match_ = value;
03074 }
03075 
03076 // required .drizzled.message.Table.ForeignKeyConstraint.ForeignKeyOption update_option = 6 [default = OPTION_UNDEF];
03077 inline bool Table_ForeignKeyConstraint::has_update_option() const {
03078   return (_has_bits_[0] & 0x00000020u) != 0;
03079 }
03080 inline void Table_ForeignKeyConstraint::set_has_update_option() {
03081   _has_bits_[0] |= 0x00000020u;
03082 }
03083 inline void Table_ForeignKeyConstraint::clear_has_update_option() {
03084   _has_bits_[0] &= ~0x00000020u;
03085 }
03086 inline void Table_ForeignKeyConstraint::clear_update_option() {
03087   update_option_ = 0;
03088   clear_has_update_option();
03089 }
03090 inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption Table_ForeignKeyConstraint::update_option() const {
03091   return static_cast< ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption >(update_option_);
03092 }
03093 inline void Table_ForeignKeyConstraint::set_update_option(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption value) {
03094   GOOGLE_DCHECK(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption_IsValid(value));
03095   set_has_update_option();
03096   update_option_ = value;
03097 }
03098 
03099 // required .drizzled.message.Table.ForeignKeyConstraint.ForeignKeyOption delete_option = 7 [default = OPTION_UNDEF];
03100 inline bool Table_ForeignKeyConstraint::has_delete_option() const {
03101   return (_has_bits_[0] & 0x00000040u) != 0;
03102 }
03103 inline void Table_ForeignKeyConstraint::set_has_delete_option() {
03104   _has_bits_[0] |= 0x00000040u;
03105 }
03106 inline void Table_ForeignKeyConstraint::clear_has_delete_option() {
03107   _has_bits_[0] &= ~0x00000040u;
03108 }
03109 inline void Table_ForeignKeyConstraint::clear_delete_option() {
03110   delete_option_ = 0;
03111   clear_has_delete_option();
03112 }
03113 inline ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption Table_ForeignKeyConstraint::delete_option() const {
03114   return static_cast< ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption >(delete_option_);
03115 }
03116 inline void Table_ForeignKeyConstraint::set_delete_option(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption value) {
03117   GOOGLE_DCHECK(::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption_IsValid(value));
03118   set_has_delete_option();
03119   delete_option_ = value;
03120 }
03121 
03122 // -------------------------------------------------------------------
03123 
03124 // Table_Field_FieldOptions
03125 
03126 // optional string default_value = 1;
03127 inline bool Table_Field_FieldOptions::has_default_value() const {
03128   return (_has_bits_[0] & 0x00000001u) != 0;
03129 }
03130 inline void Table_Field_FieldOptions::set_has_default_value() {
03131   _has_bits_[0] |= 0x00000001u;
03132 }
03133 inline void Table_Field_FieldOptions::clear_has_default_value() {
03134   _has_bits_[0] &= ~0x00000001u;
03135 }
03136 inline void Table_Field_FieldOptions::clear_default_value() {
03137   if (default_value_ != &::google::protobuf::internal::kEmptyString) {
03138     default_value_->clear();
03139   }
03140   clear_has_default_value();
03141 }
03142 inline const ::std::string& Table_Field_FieldOptions::default_value() const {
03143   return *default_value_;
03144 }
03145 inline void Table_Field_FieldOptions::set_default_value(const ::std::string& value) {
03146   set_has_default_value();
03147   if (default_value_ == &::google::protobuf::internal::kEmptyString) {
03148     default_value_ = new ::std::string;
03149   }
03150   default_value_->assign(value);
03151 }
03152 inline void Table_Field_FieldOptions::set_default_value(const char* value) {
03153   set_has_default_value();
03154   if (default_value_ == &::google::protobuf::internal::kEmptyString) {
03155     default_value_ = new ::std::string;
03156   }
03157   default_value_->assign(value);
03158 }
03159 inline void Table_Field_FieldOptions::set_default_value(const char* value, size_t size) {
03160   set_has_default_value();
03161   if (default_value_ == &::google::protobuf::internal::kEmptyString) {
03162     default_value_ = new ::std::string;
03163   }
03164   default_value_->assign(reinterpret_cast<const char*>(value), size);
03165 }
03166 inline ::std::string* Table_Field_FieldOptions::mutable_default_value() {
03167   set_has_default_value();
03168   if (default_value_ == &::google::protobuf::internal::kEmptyString) {
03169     default_value_ = new ::std::string;
03170   }
03171   return default_value_;
03172 }
03173 inline ::std::string* Table_Field_FieldOptions::release_default_value() {
03174   clear_has_default_value();
03175   if (default_value_ == &::google::protobuf::internal::kEmptyString) {
03176     return NULL;
03177   } else {
03178     ::std::string* temp = default_value_;
03179     default_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
03180     return temp;
03181   }
03182 }
03183 
03184 // optional string update_value = 2;
03185 inline bool Table_Field_FieldOptions::has_update_value() const {
03186   return (_has_bits_[0] & 0x00000002u) != 0;
03187 }
03188 inline void Table_Field_FieldOptions::set_has_update_value() {
03189   _has_bits_[0] |= 0x00000002u;
03190 }
03191 inline void Table_Field_FieldOptions::clear_has_update_value() {
03192   _has_bits_[0] &= ~0x00000002u;
03193 }
03194 inline void Table_Field_FieldOptions::clear_update_value() {
03195   if (update_value_ != &::google::protobuf::internal::kEmptyString) {
03196     update_value_->clear();
03197   }
03198   clear_has_update_value();
03199 }
03200 inline const ::std::string& Table_Field_FieldOptions::update_value() const {
03201   return *update_value_;
03202 }
03203 inline void Table_Field_FieldOptions::set_update_value(const ::std::string& value) {
03204   set_has_update_value();
03205   if (update_value_ == &::google::protobuf::internal::kEmptyString) {
03206     update_value_ = new ::std::string;
03207   }
03208   update_value_->assign(value);
03209 }
03210 inline void Table_Field_FieldOptions::set_update_value(const char* value) {
03211   set_has_update_value();
03212   if (update_value_ == &::google::protobuf::internal::kEmptyString) {
03213     update_value_ = new ::std::string;
03214   }
03215   update_value_->assign(value);
03216 }
03217 inline void Table_Field_FieldOptions::set_update_value(const char* value, size_t size) {
03218   set_has_update_value();
03219   if (update_value_ == &::google::protobuf::internal::kEmptyString) {
03220     update_value_ = new ::std::string;
03221   }
03222   update_value_->assign(reinterpret_cast<const char*>(value), size);
03223 }
03224 inline ::std::string* Table_Field_FieldOptions::mutable_update_value() {
03225   set_has_update_value();
03226   if (update_value_ == &::google::protobuf::internal::kEmptyString) {
03227     update_value_ = new ::std::string;
03228   }
03229   return update_value_;
03230 }
03231 inline ::std::string* Table_Field_FieldOptions::release_update_value() {
03232   clear_has_update_value();
03233   if (update_value_ == &::google::protobuf::internal::kEmptyString) {
03234     return NULL;
03235   } else {
03236     ::std::string* temp = update_value_;
03237     update_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
03238     return temp;
03239   }
03240 }
03241 
03242 // optional bool default_null = 3 [default = false];
03243 inline bool Table_Field_FieldOptions::has_default_null() const {
03244   return (_has_bits_[0] & 0x00000004u) != 0;
03245 }
03246 inline void Table_Field_FieldOptions::set_has_default_null() {
03247   _has_bits_[0] |= 0x00000004u;
03248 }
03249 inline void Table_Field_FieldOptions::clear_has_default_null() {
03250   _has_bits_[0] &= ~0x00000004u;
03251 }
03252 inline void Table_Field_FieldOptions::clear_default_null() {
03253   default_null_ = false;
03254   clear_has_default_null();
03255 }
03256 inline bool Table_Field_FieldOptions::default_null() const {
03257   return default_null_;
03258 }
03259 inline void Table_Field_FieldOptions::set_default_null(bool value) {
03260   set_has_default_null();
03261   default_null_ = value;
03262 }
03263 
03264 // optional bytes default_bin_value = 4;
03265 inline bool Table_Field_FieldOptions::has_default_bin_value() const {
03266   return (_has_bits_[0] & 0x00000008u) != 0;
03267 }
03268 inline void Table_Field_FieldOptions::set_has_default_bin_value() {
03269   _has_bits_[0] |= 0x00000008u;
03270 }
03271 inline void Table_Field_FieldOptions::clear_has_default_bin_value() {
03272   _has_bits_[0] &= ~0x00000008u;
03273 }
03274 inline void Table_Field_FieldOptions::clear_default_bin_value() {
03275   if (default_bin_value_ != &::google::protobuf::internal::kEmptyString) {
03276     default_bin_value_->clear();
03277   }
03278   clear_has_default_bin_value();
03279 }
03280 inline const ::std::string& Table_Field_FieldOptions::default_bin_value() const {
03281   return *default_bin_value_;
03282 }
03283 inline void Table_Field_FieldOptions::set_default_bin_value(const ::std::string& value) {
03284   set_has_default_bin_value();
03285   if (default_bin_value_ == &::google::protobuf::internal::kEmptyString) {
03286     default_bin_value_ = new ::std::string;
03287   }
03288   default_bin_value_->assign(value);
03289 }
03290 inline void Table_Field_FieldOptions::set_default_bin_value(const char* value) {
03291   set_has_default_bin_value();
03292   if (default_bin_value_ == &::google::protobuf::internal::kEmptyString) {
03293     default_bin_value_ = new ::std::string;
03294   }
03295   default_bin_value_->assign(value);
03296 }
03297 inline void Table_Field_FieldOptions::set_default_bin_value(const void* value, size_t size) {
03298   set_has_default_bin_value();
03299   if (default_bin_value_ == &::google::protobuf::internal::kEmptyString) {
03300     default_bin_value_ = new ::std::string;
03301   }
03302   default_bin_value_->assign(reinterpret_cast<const char*>(value), size);
03303 }
03304 inline ::std::string* Table_Field_FieldOptions::mutable_default_bin_value() {
03305   set_has_default_bin_value();
03306   if (default_bin_value_ == &::google::protobuf::internal::kEmptyString) {
03307     default_bin_value_ = new ::std::string;
03308   }
03309   return default_bin_value_;
03310 }
03311 inline ::std::string* Table_Field_FieldOptions::release_default_bin_value() {
03312   clear_has_default_bin_value();
03313   if (default_bin_value_ == &::google::protobuf::internal::kEmptyString) {
03314     return NULL;
03315   } else {
03316     ::std::string* temp = default_bin_value_;
03317     default_bin_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
03318     return temp;
03319   }
03320 }
03321 
03322 // optional string default_expression = 5;
03323 inline bool Table_Field_FieldOptions::has_default_expression() const {
03324   return (_has_bits_[0] & 0x00000010u) != 0;
03325 }
03326 inline void Table_Field_FieldOptions::set_has_default_expression() {
03327   _has_bits_[0] |= 0x00000010u;
03328 }
03329 inline void Table_Field_FieldOptions::clear_has_default_expression() {
03330   _has_bits_[0] &= ~0x00000010u;
03331 }
03332 inline void Table_Field_FieldOptions::clear_default_expression() {
03333   if (default_expression_ != &::google::protobuf::internal::kEmptyString) {
03334     default_expression_->clear();
03335   }
03336   clear_has_default_expression();
03337 }
03338 inline const ::std::string& Table_Field_FieldOptions::default_expression() const {
03339   return *default_expression_;
03340 }
03341 inline void Table_Field_FieldOptions::set_default_expression(const ::std::string& value) {
03342   set_has_default_expression();
03343   if (default_expression_ == &::google::protobuf::internal::kEmptyString) {
03344     default_expression_ = new ::std::string;
03345   }
03346   default_expression_->assign(value);
03347 }
03348 inline void Table_Field_FieldOptions::set_default_expression(const char* value) {
03349   set_has_default_expression();
03350   if (default_expression_ == &::google::protobuf::internal::kEmptyString) {
03351     default_expression_ = new ::std::string;
03352   }
03353   default_expression_->assign(value);
03354 }
03355 inline void Table_Field_FieldOptions::set_default_expression(const char* value, size_t size) {
03356   set_has_default_expression();
03357   if (default_expression_ == &::google::protobuf::internal::kEmptyString) {
03358     default_expression_ = new ::std::string;
03359   }
03360   default_expression_->assign(reinterpret_cast<const char*>(value), size);
03361 }
03362 inline ::std::string* Table_Field_FieldOptions::mutable_default_expression() {
03363   set_has_default_expression();
03364   if (default_expression_ == &::google::protobuf::internal::kEmptyString) {
03365     default_expression_ = new ::std::string;
03366   }
03367   return default_expression_;
03368 }
03369 inline ::std::string* Table_Field_FieldOptions::release_default_expression() {
03370   clear_has_default_expression();
03371   if (default_expression_ == &::google::protobuf::internal::kEmptyString) {
03372     return NULL;
03373   } else {
03374     ::std::string* temp = default_expression_;
03375     default_expression_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
03376     return temp;
03377   }
03378 }
03379 
03380 // optional string update_expression = 6;
03381 inline bool Table_Field_FieldOptions::has_update_expression() const {
03382   return (_has_bits_[0] & 0x00000020u) != 0;
03383 }
03384 inline void Table_Field_FieldOptions::set_has_update_expression() {
03385   _has_bits_[0] |= 0x00000020u;
03386 }
03387 inline void Table_Field_FieldOptions::clear_has_update_expression() {
03388   _has_bits_[0] &= ~0x00000020u;
03389 }
03390 inline void Table_Field_FieldOptions::clear_update_expression() {
03391   if (update_expression_ != &::google::protobuf::internal::kEmptyString) {
03392     update_expression_->clear();
03393   }
03394   clear_has_update_expression();
03395 }
03396 inline const ::std::string& Table_Field_FieldOptions::update_expression() const {
03397   return *update_expression_;
03398 }
03399 inline void Table_Field_FieldOptions::set_update_expression(const ::std::string& value) {
03400   set_has_update_expression();
03401   if (update_expression_ == &::google::protobuf::internal::kEmptyString) {
03402     update_expression_ = new ::std::string;
03403   }
03404   update_expression_->assign(value);
03405 }
03406 inline void Table_Field_FieldOptions::set_update_expression(const char* value) {
03407   set_has_update_expression();
03408   if (update_expression_ == &::google::protobuf::internal::kEmptyString) {
03409     update_expression_ = new ::std::string;
03410   }
03411   update_expression_->assign(value);
03412 }
03413 inline void Table_Field_FieldOptions::set_update_expression(const char* value, size_t size) {
03414   set_has_update_expression();
03415   if (update_expression_ == &::google::protobuf::internal::kEmptyString) {
03416     update_expression_ = new ::std::string;
03417   }
03418   update_expression_->assign(reinterpret_cast<const char*>(value), size);
03419 }
03420 inline ::std::string* Table_Field_FieldOptions::mutable_update_expression() {
03421   set_has_update_expression();
03422   if (update_expression_ == &::google::protobuf::internal::kEmptyString) {
03423     update_expression_ = new ::std::string;
03424   }
03425   return update_expression_;
03426 }
03427 inline ::std::string* Table_Field_FieldOptions::release_update_expression() {
03428   clear_has_update_expression();
03429   if (update_expression_ == &::google::protobuf::internal::kEmptyString) {
03430     return NULL;
03431   } else {
03432     ::std::string* temp = update_expression_;
03433     update_expression_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
03434     return temp;
03435   }
03436 }
03437 
03438 // -------------------------------------------------------------------
03439 
03440 // Table_Field_FieldConstraints
03441 
03442 // optional bool is_nullable = 1 [default = true];
03443 inline bool Table_Field_FieldConstraints::has_is_nullable() const {
03444   return (_has_bits_[0] & 0x00000001u) != 0;
03445 }
03446 inline void Table_Field_FieldConstraints::set_has_is_nullable() {
03447   _has_bits_[0] |= 0x00000001u;
03448 }
03449 inline void Table_Field_FieldConstraints::clear_has_is_nullable() {
03450   _has_bits_[0] &= ~0x00000001u;
03451 }
03452 inline void Table_Field_FieldConstraints::clear_is_nullable() {
03453   is_nullable_ = true;
03454   clear_has_is_nullable();
03455 }
03456 inline bool Table_Field_FieldConstraints::is_nullable() const {
03457   return is_nullable_;
03458 }
03459 inline void Table_Field_FieldConstraints::set_is_nullable(bool value) {
03460   set_has_is_nullable();
03461   is_nullable_ = value;
03462 }
03463 
03464 // optional bool is_unsigned = 2 [default = false];
03465 inline bool Table_Field_FieldConstraints::has_is_unsigned() const {
03466   return (_has_bits_[0] & 0x00000002u) != 0;
03467 }
03468 inline void Table_Field_FieldConstraints::set_has_is_unsigned() {
03469   _has_bits_[0] |= 0x00000002u;
03470 }
03471 inline void Table_Field_FieldConstraints::clear_has_is_unsigned() {
03472   _has_bits_[0] &= ~0x00000002u;
03473 }
03474 inline void Table_Field_FieldConstraints::clear_is_unsigned() {
03475   is_unsigned_ = false;
03476   clear_has_is_unsigned();
03477 }
03478 inline bool Table_Field_FieldConstraints::is_unsigned() const {
03479   return is_unsigned_;
03480 }
03481 inline void Table_Field_FieldConstraints::set_is_unsigned(bool value) {
03482   set_has_is_unsigned();
03483   is_unsigned_ = value;
03484 }
03485 
03486 // optional bool is_notnull = 3 [default = false];
03487 inline bool Table_Field_FieldConstraints::has_is_notnull() const {
03488   return (_has_bits_[0] & 0x00000004u) != 0;
03489 }
03490 inline void Table_Field_FieldConstraints::set_has_is_notnull() {
03491   _has_bits_[0] |= 0x00000004u;
03492 }
03493 inline void Table_Field_FieldConstraints::clear_has_is_notnull() {
03494   _has_bits_[0] &= ~0x00000004u;
03495 }
03496 inline void Table_Field_FieldConstraints::clear_is_notnull() {
03497   is_notnull_ = false;
03498   clear_has_is_notnull();
03499 }
03500 inline bool Table_Field_FieldConstraints::is_notnull() const {
03501   return is_notnull_;
03502 }
03503 inline void Table_Field_FieldConstraints::set_is_notnull(bool value) {
03504   set_has_is_notnull();
03505   is_notnull_ = value;
03506 }
03507 
03508 // optional bool is_unique = 4 [default = false];
03509 inline bool Table_Field_FieldConstraints::has_is_unique() const {
03510   return (_has_bits_[0] & 0x00000008u) != 0;
03511 }
03512 inline void Table_Field_FieldConstraints::set_has_is_unique() {
03513   _has_bits_[0] |= 0x00000008u;
03514 }
03515 inline void Table_Field_FieldConstraints::clear_has_is_unique() {
03516   _has_bits_[0] &= ~0x00000008u;
03517 }
03518 inline void Table_Field_FieldConstraints::clear_is_unique() {
03519   is_unique_ = false;
03520   clear_has_is_unique();
03521 }
03522 inline bool Table_Field_FieldConstraints::is_unique() const {
03523   return is_unique_;
03524 }
03525 inline void Table_Field_FieldConstraints::set_is_unique(bool value) {
03526   set_has_is_unique();
03527   is_unique_ = value;
03528 }
03529 
03530 // repeated string expression = 16;
03531 inline int Table_Field_FieldConstraints::expression_size() const {
03532   return expression_.size();
03533 }
03534 inline void Table_Field_FieldConstraints::clear_expression() {
03535   expression_.Clear();
03536 }
03537 inline const ::std::string& Table_Field_FieldConstraints::expression(int index) const {
03538   return expression_.Get(index);
03539 }
03540 inline ::std::string* Table_Field_FieldConstraints::mutable_expression(int index) {
03541   return expression_.Mutable(index);
03542 }
03543 inline void Table_Field_FieldConstraints::set_expression(int index, const ::std::string& value) {
03544   expression_.Mutable(index)->assign(value);
03545 }
03546 inline void Table_Field_FieldConstraints::set_expression(int index, const char* value) {
03547   expression_.Mutable(index)->assign(value);
03548 }
03549 inline void Table_Field_FieldConstraints::set_expression(int index, const char* value, size_t size) {
03550   expression_.Mutable(index)->assign(
03551     reinterpret_cast<const char*>(value), size);
03552 }
03553 inline ::std::string* Table_Field_FieldConstraints::add_expression() {
03554   return expression_.Add();
03555 }
03556 inline void Table_Field_FieldConstraints::add_expression(const ::std::string& value) {
03557   expression_.Add()->assign(value);
03558 }
03559 inline void Table_Field_FieldConstraints::add_expression(const char* value) {
03560   expression_.Add()->assign(value);
03561 }
03562 inline void Table_Field_FieldConstraints::add_expression(const char* value, size_t size) {
03563   expression_.Add()->assign(reinterpret_cast<const char*>(value), size);
03564 }
03565 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
03566 Table_Field_FieldConstraints::expression() const {
03567   return expression_;
03568 }
03569 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
03570 Table_Field_FieldConstraints::mutable_expression() {
03571   return &expression_;
03572 }
03573 
03574 // -------------------------------------------------------------------
03575 
03576 // Table_Field_NumericFieldOptions
03577 
03578 // optional bool is_autoincrement = 1 [default = false];
03579 inline bool Table_Field_NumericFieldOptions::has_is_autoincrement() const {
03580   return (_has_bits_[0] & 0x00000001u) != 0;
03581 }
03582 inline void Table_Field_NumericFieldOptions::set_has_is_autoincrement() {
03583   _has_bits_[0] |= 0x00000001u;
03584 }
03585 inline void Table_Field_NumericFieldOptions::clear_has_is_autoincrement() {
03586   _has_bits_[0] &= ~0x00000001u;
03587 }
03588 inline void Table_Field_NumericFieldOptions::clear_is_autoincrement() {
03589   is_autoincrement_ = false;
03590   clear_has_is_autoincrement();
03591 }
03592 inline bool Table_Field_NumericFieldOptions::is_autoincrement() const {
03593   return is_autoincrement_;
03594 }
03595 inline void Table_Field_NumericFieldOptions::set_is_autoincrement(bool value) {
03596   set_has_is_autoincrement();
03597   is_autoincrement_ = value;
03598 }
03599 
03600 // optional uint32 scale = 2;
03601 inline bool Table_Field_NumericFieldOptions::has_scale() const {
03602   return (_has_bits_[0] & 0x00000002u) != 0;
03603 }
03604 inline void Table_Field_NumericFieldOptions::set_has_scale() {
03605   _has_bits_[0] |= 0x00000002u;
03606 }
03607 inline void Table_Field_NumericFieldOptions::clear_has_scale() {
03608   _has_bits_[0] &= ~0x00000002u;
03609 }
03610 inline void Table_Field_NumericFieldOptions::clear_scale() {
03611   scale_ = 0u;
03612   clear_has_scale();
03613 }
03614 inline ::google::protobuf::uint32 Table_Field_NumericFieldOptions::scale() const {
03615   return scale_;
03616 }
03617 inline void Table_Field_NumericFieldOptions::set_scale(::google::protobuf::uint32 value) {
03618   set_has_scale();
03619   scale_ = value;
03620 }
03621 
03622 // optional uint32 precision = 3;
03623 inline bool Table_Field_NumericFieldOptions::has_precision() const {
03624   return (_has_bits_[0] & 0x00000004u) != 0;
03625 }
03626 inline void Table_Field_NumericFieldOptions::set_has_precision() {
03627   _has_bits_[0] |= 0x00000004u;
03628 }
03629 inline void Table_Field_NumericFieldOptions::clear_has_precision() {
03630   _has_bits_[0] &= ~0x00000004u;
03631 }
03632 inline void Table_Field_NumericFieldOptions::clear_precision() {
03633   precision_ = 0u;
03634   clear_has_precision();
03635 }
03636 inline ::google::protobuf::uint32 Table_Field_NumericFieldOptions::precision() const {
03637   return precision_;
03638 }
03639 inline void Table_Field_NumericFieldOptions::set_precision(::google::protobuf::uint32 value) {
03640   set_has_precision();
03641   precision_ = value;
03642 }
03643 
03644 // -------------------------------------------------------------------
03645 
03646 // Table_Field_StringFieldOptions
03647 
03648 // optional bool is_fixed_width = 1 [default = false];
03649 inline bool Table_Field_StringFieldOptions::has_is_fixed_width() const {
03650   return (_has_bits_[0] & 0x00000001u) != 0;
03651 }
03652 inline void Table_Field_StringFieldOptions::set_has_is_fixed_width() {
03653   _has_bits_[0] |= 0x00000001u;
03654 }
03655 inline void Table_Field_StringFieldOptions::clear_has_is_fixed_width() {
03656   _has_bits_[0] &= ~0x00000001u;
03657 }
03658 inline void Table_Field_StringFieldOptions::clear_is_fixed_width() {
03659   is_fixed_width_ = false;
03660   clear_has_is_fixed_width();
03661 }
03662 inline bool Table_Field_StringFieldOptions::is_fixed_width() const {
03663   return is_fixed_width_;
03664 }
03665 inline void Table_Field_StringFieldOptions::set_is_fixed_width(bool value) {
03666   set_has_is_fixed_width();
03667   is_fixed_width_ = value;
03668 }
03669 
03670 // optional uint32 length = 2;
03671 inline bool Table_Field_StringFieldOptions::has_length() const {
03672   return (_has_bits_[0] & 0x00000002u) != 0;
03673 }
03674 inline void Table_Field_StringFieldOptions::set_has_length() {
03675   _has_bits_[0] |= 0x00000002u;
03676 }
03677 inline void Table_Field_StringFieldOptions::clear_has_length() {
03678   _has_bits_[0] &= ~0x00000002u;
03679 }
03680 inline void Table_Field_StringFieldOptions::clear_length() {
03681   length_ = 0u;
03682   clear_has_length();
03683 }
03684 inline ::google::protobuf::uint32 Table_Field_StringFieldOptions::length() const {
03685   return length_;
03686 }
03687 inline void Table_Field_StringFieldOptions::set_length(::google::protobuf::uint32 value) {
03688   set_has_length();
03689   length_ = value;
03690 }
03691 
03692 // optional uint32 collation_id = 3;
03693 inline bool Table_Field_StringFieldOptions::has_collation_id() const {
03694   return (_has_bits_[0] & 0x00000004u) != 0;
03695 }
03696 inline void Table_Field_StringFieldOptions::set_has_collation_id() {
03697   _has_bits_[0] |= 0x00000004u;
03698 }
03699 inline void Table_Field_StringFieldOptions::clear_has_collation_id() {
03700   _has_bits_[0] &= ~0x00000004u;
03701 }
03702 inline void Table_Field_StringFieldOptions::clear_collation_id() {
03703   collation_id_ = 0u;
03704   clear_has_collation_id();
03705 }
03706 inline ::google::protobuf::uint32 Table_Field_StringFieldOptions::collation_id() const {
03707   return collation_id_;
03708 }
03709 inline void Table_Field_StringFieldOptions::set_collation_id(::google::protobuf::uint32 value) {
03710   set_has_collation_id();
03711   collation_id_ = value;
03712 }
03713 
03714 // optional string collation = 4;
03715 inline bool Table_Field_StringFieldOptions::has_collation() const {
03716   return (_has_bits_[0] & 0x00000008u) != 0;
03717 }
03718 inline void Table_Field_StringFieldOptions::set_has_collation() {
03719   _has_bits_[0] |= 0x00000008u;
03720 }
03721 inline void Table_Field_StringFieldOptions::clear_has_collation() {
03722   _has_bits_[0] &= ~0x00000008u;
03723 }
03724 inline void Table_Field_StringFieldOptions::clear_collation() {
03725   if (collation_ != &::google::protobuf::internal::kEmptyString) {
03726     collation_->clear();
03727   }
03728   clear_has_collation();
03729 }
03730 inline const ::std::string& Table_Field_StringFieldOptions::collation() const {
03731   return *collation_;
03732 }
03733 inline void Table_Field_StringFieldOptions::set_collation(const ::std::string& value) {
03734   set_has_collation();
03735   if (collation_ == &::google::protobuf::internal::kEmptyString) {
03736     collation_ = new ::std::string;
03737   }
03738   collation_->assign(value);
03739 }
03740 inline void Table_Field_StringFieldOptions::set_collation(const char* value) {
03741   set_has_collation();
03742   if (collation_ == &::google::protobuf::internal::kEmptyString) {
03743     collation_ = new ::std::string;
03744   }
03745   collation_->assign(value);
03746 }
03747 inline void Table_Field_StringFieldOptions::set_collation(const char* value, size_t size) {
03748   set_has_collation();
03749   if (collation_ == &::google::protobuf::internal::kEmptyString) {
03750     collation_ = new ::std::string;
03751   }
03752   collation_->assign(reinterpret_cast<const char*>(value), size);
03753 }
03754 inline ::std::string* Table_Field_StringFieldOptions::mutable_collation() {
03755   set_has_collation();
03756   if (collation_ == &::google::protobuf::internal::kEmptyString) {
03757     collation_ = new ::std::string;
03758   }
03759   return collation_;
03760 }
03761 inline ::std::string* Table_Field_StringFieldOptions::release_collation() {
03762   clear_has_collation();
03763   if (collation_ == &::google::protobuf::internal::kEmptyString) {
03764     return NULL;
03765   } else {
03766     ::std::string* temp = collation_;
03767     collation_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
03768     return temp;
03769   }
03770 }
03771 
03772 // -------------------------------------------------------------------
03773 
03774 // Table_Field_EnumerationValues
03775 
03776 // optional uint32 collation_id = 2;
03777 inline bool Table_Field_EnumerationValues::has_collation_id() const {
03778   return (_has_bits_[0] & 0x00000001u) != 0;
03779 }
03780 inline void Table_Field_EnumerationValues::set_has_collation_id() {
03781   _has_bits_[0] |= 0x00000001u;
03782 }
03783 inline void Table_Field_EnumerationValues::clear_has_collation_id() {
03784   _has_bits_[0] &= ~0x00000001u;
03785 }
03786 inline void Table_Field_EnumerationValues::clear_collation_id() {
03787   collation_id_ = 0u;
03788   clear_has_collation_id();
03789 }
03790 inline ::google::protobuf::uint32 Table_Field_EnumerationValues::collation_id() const {
03791   return collation_id_;
03792 }
03793 inline void Table_Field_EnumerationValues::set_collation_id(::google::protobuf::uint32 value) {
03794   set_has_collation_id();
03795   collation_id_ = value;
03796 }
03797 
03798 // optional string collation = 3;
03799 inline bool Table_Field_EnumerationValues::has_collation() const {
03800   return (_has_bits_[0] & 0x00000002u) != 0;
03801 }
03802 inline void Table_Field_EnumerationValues::set_has_collation() {
03803   _has_bits_[0] |= 0x00000002u;
03804 }
03805 inline void Table_Field_EnumerationValues::clear_has_collation() {
03806   _has_bits_[0] &= ~0x00000002u;
03807 }
03808 inline void Table_Field_EnumerationValues::clear_collation() {
03809   if (collation_ != &::google::protobuf::internal::kEmptyString) {
03810     collation_->clear();
03811   }
03812   clear_has_collation();
03813 }
03814 inline const ::std::string& Table_Field_EnumerationValues::collation() const {
03815   return *collation_;
03816 }
03817 inline void Table_Field_EnumerationValues::set_collation(const ::std::string& value) {
03818   set_has_collation();
03819   if (collation_ == &::google::protobuf::internal::kEmptyString) {
03820     collation_ = new ::std::string;
03821   }
03822   collation_->assign(value);
03823 }
03824 inline void Table_Field_EnumerationValues::set_collation(const char* value) {
03825   set_has_collation();
03826   if (collation_ == &::google::protobuf::internal::kEmptyString) {
03827     collation_ = new ::std::string;
03828   }
03829   collation_->assign(value);
03830 }
03831 inline void Table_Field_EnumerationValues::set_collation(const char* value, size_t size) {
03832   set_has_collation();
03833   if (collation_ == &::google::protobuf::internal::kEmptyString) {
03834     collation_ = new ::std::string;
03835   }
03836   collation_->assign(reinterpret_cast<const char*>(value), size);
03837 }
03838 inline ::std::string* Table_Field_EnumerationValues::mutable_collation() {
03839   set_has_collation();
03840   if (collation_ == &::google::protobuf::internal::kEmptyString) {
03841     collation_ = new ::std::string;
03842   }
03843   return collation_;
03844 }
03845 inline ::std::string* Table_Field_EnumerationValues::release_collation() {
03846   clear_has_collation();
03847   if (collation_ == &::google::protobuf::internal::kEmptyString) {
03848     return NULL;
03849   } else {
03850     ::std::string* temp = collation_;
03851     collation_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
03852     return temp;
03853   }
03854 }
03855 
03856 // repeated string field_value = 4;
03857 inline int Table_Field_EnumerationValues::field_value_size() const {
03858   return field_value_.size();
03859 }
03860 inline void Table_Field_EnumerationValues::clear_field_value() {
03861   field_value_.Clear();
03862 }
03863 inline const ::std::string& Table_Field_EnumerationValues::field_value(int index) const {
03864   return field_value_.Get(index);
03865 }
03866 inline ::std::string* Table_Field_EnumerationValues::mutable_field_value(int index) {
03867   return field_value_.Mutable(index);
03868 }
03869 inline void Table_Field_EnumerationValues::set_field_value(int index, const ::std::string& value) {
03870   field_value_.Mutable(index)->assign(value);
03871 }
03872 inline void Table_Field_EnumerationValues::set_field_value(int index, const char* value) {
03873   field_value_.Mutable(index)->assign(value);
03874 }
03875 inline void Table_Field_EnumerationValues::set_field_value(int index, const char* value, size_t size) {
03876   field_value_.Mutable(index)->assign(
03877     reinterpret_cast<const char*>(value), size);
03878 }
03879 inline ::std::string* Table_Field_EnumerationValues::add_field_value() {
03880   return field_value_.Add();
03881 }
03882 inline void Table_Field_EnumerationValues::add_field_value(const ::std::string& value) {
03883   field_value_.Add()->assign(value);
03884 }
03885 inline void Table_Field_EnumerationValues::add_field_value(const char* value) {
03886   field_value_.Add()->assign(value);
03887 }
03888 inline void Table_Field_EnumerationValues::add_field_value(const char* value, size_t size) {
03889   field_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
03890 }
03891 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
03892 Table_Field_EnumerationValues::field_value() const {
03893   return field_value_;
03894 }
03895 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
03896 Table_Field_EnumerationValues::mutable_field_value() {
03897   return &field_value_;
03898 }
03899 
03900 // -------------------------------------------------------------------
03901 
03902 // Table_Field_TimeFieldOptions
03903 
03904 // optional bool microseconds = 1;
03905 inline bool Table_Field_TimeFieldOptions::has_microseconds() const {
03906   return (_has_bits_[0] & 0x00000001u) != 0;
03907 }
03908 inline void Table_Field_TimeFieldOptions::set_has_microseconds() {
03909   _has_bits_[0] |= 0x00000001u;
03910 }
03911 inline void Table_Field_TimeFieldOptions::clear_has_microseconds() {
03912   _has_bits_[0] &= ~0x00000001u;
03913 }
03914 inline void Table_Field_TimeFieldOptions::clear_microseconds() {
03915   microseconds_ = false;
03916   clear_has_microseconds();
03917 }
03918 inline bool Table_Field_TimeFieldOptions::microseconds() const {
03919   return microseconds_;
03920 }
03921 inline void Table_Field_TimeFieldOptions::set_microseconds(bool value) {
03922   set_has_microseconds();
03923   microseconds_ = value;
03924 }
03925 
03926 // -------------------------------------------------------------------
03927 
03928 // Table_Field
03929 
03930 // required string name = 1;
03931 inline bool Table_Field::has_name() const {
03932   return (_has_bits_[0] & 0x00000001u) != 0;
03933 }
03934 inline void Table_Field::set_has_name() {
03935   _has_bits_[0] |= 0x00000001u;
03936 }
03937 inline void Table_Field::clear_has_name() {
03938   _has_bits_[0] &= ~0x00000001u;
03939 }
03940 inline void Table_Field::clear_name() {
03941   if (name_ != &::google::protobuf::internal::kEmptyString) {
03942     name_->clear();
03943   }
03944   clear_has_name();
03945 }
03946 inline const ::std::string& Table_Field::name() const {
03947   return *name_;
03948 }
03949 inline void Table_Field::set_name(const ::std::string& value) {
03950   set_has_name();
03951   if (name_ == &::google::protobuf::internal::kEmptyString) {
03952     name_ = new ::std::string;
03953   }
03954   name_->assign(value);
03955 }
03956 inline void Table_Field::set_name(const char* value) {
03957   set_has_name();
03958   if (name_ == &::google::protobuf::internal::kEmptyString) {
03959     name_ = new ::std::string;
03960   }
03961   name_->assign(value);
03962 }
03963 inline void Table_Field::set_name(const char* value, size_t size) {
03964   set_has_name();
03965   if (name_ == &::google::protobuf::internal::kEmptyString) {
03966     name_ = new ::std::string;
03967   }
03968   name_->assign(reinterpret_cast<const char*>(value), size);
03969 }
03970 inline ::std::string* Table_Field::mutable_name() {
03971   set_has_name();
03972   if (name_ == &::google::protobuf::internal::kEmptyString) {
03973     name_ = new ::std::string;
03974   }
03975   return name_;
03976 }
03977 inline ::std::string* Table_Field::release_name() {
03978   clear_has_name();
03979   if (name_ == &::google::protobuf::internal::kEmptyString) {
03980     return NULL;
03981   } else {
03982     ::std::string* temp = name_;
03983     name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
03984     return temp;
03985   }
03986 }
03987 
03988 // required .drizzled.message.Table.Field.FieldType type = 2;
03989 inline bool Table_Field::has_type() const {
03990   return (_has_bits_[0] & 0x00000002u) != 0;
03991 }
03992 inline void Table_Field::set_has_type() {
03993   _has_bits_[0] |= 0x00000002u;
03994 }
03995 inline void Table_Field::clear_has_type() {
03996   _has_bits_[0] &= ~0x00000002u;
03997 }
03998 inline void Table_Field::clear_type() {
03999   type_ = 0;
04000   clear_has_type();
04001 }
04002 inline ::drizzled::message::Table_Field_FieldType Table_Field::type() const {
04003   return static_cast< ::drizzled::message::Table_Field_FieldType >(type_);
04004 }
04005 inline void Table_Field::set_type(::drizzled::message::Table_Field_FieldType value) {
04006   GOOGLE_DCHECK(::drizzled::message::Table_Field_FieldType_IsValid(value));
04007   set_has_type();
04008   type_ = value;
04009 }
04010 
04011 // optional .drizzled.message.Table.Field.FieldOptions options = 4;
04012 inline bool Table_Field::has_options() const {
04013   return (_has_bits_[0] & 0x00000004u) != 0;
04014 }
04015 inline void Table_Field::set_has_options() {
04016   _has_bits_[0] |= 0x00000004u;
04017 }
04018 inline void Table_Field::clear_has_options() {
04019   _has_bits_[0] &= ~0x00000004u;
04020 }
04021 inline void Table_Field::clear_options() {
04022   if (options_ != NULL) options_->::drizzled::message::Table_Field_FieldOptions::Clear();
04023   clear_has_options();
04024 }
04025 inline const ::drizzled::message::Table_Field_FieldOptions& Table_Field::options() const {
04026   return options_ != NULL ? *options_ : *default_instance_->options_;
04027 }
04028 inline ::drizzled::message::Table_Field_FieldOptions* Table_Field::mutable_options() {
04029   set_has_options();
04030   if (options_ == NULL) options_ = new ::drizzled::message::Table_Field_FieldOptions;
04031   return options_;
04032 }
04033 inline ::drizzled::message::Table_Field_FieldOptions* Table_Field::release_options() {
04034   clear_has_options();
04035   ::drizzled::message::Table_Field_FieldOptions* temp = options_;
04036   options_ = NULL;
04037   return temp;
04038 }
04039 
04040 // optional .drizzled.message.Table.Field.FieldConstraints constraints = 5;
04041 inline bool Table_Field::has_constraints() const {
04042   return (_has_bits_[0] & 0x00000008u) != 0;
04043 }
04044 inline void Table_Field::set_has_constraints() {
04045   _has_bits_[0] |= 0x00000008u;
04046 }
04047 inline void Table_Field::clear_has_constraints() {
04048   _has_bits_[0] &= ~0x00000008u;
04049 }
04050 inline void Table_Field::clear_constraints() {
04051   if (constraints_ != NULL) constraints_->::drizzled::message::Table_Field_FieldConstraints::Clear();
04052   clear_has_constraints();
04053 }
04054 inline const ::drizzled::message::Table_Field_FieldConstraints& Table_Field::constraints() const {
04055   return constraints_ != NULL ? *constraints_ : *default_instance_->constraints_;
04056 }
04057 inline ::drizzled::message::Table_Field_FieldConstraints* Table_Field::mutable_constraints() {
04058   set_has_constraints();
04059   if (constraints_ == NULL) constraints_ = new ::drizzled::message::Table_Field_FieldConstraints;
04060   return constraints_;
04061 }
04062 inline ::drizzled::message::Table_Field_FieldConstraints* Table_Field::release_constraints() {
04063   clear_has_constraints();
04064   ::drizzled::message::Table_Field_FieldConstraints* temp = constraints_;
04065   constraints_ = NULL;
04066   return temp;
04067 }
04068 
04069 // optional .drizzled.message.Table.Field.NumericFieldOptions numeric_options = 6;
04070 inline bool Table_Field::has_numeric_options() const {
04071   return (_has_bits_[0] & 0x00000010u) != 0;
04072 }
04073 inline void Table_Field::set_has_numeric_options() {
04074   _has_bits_[0] |= 0x00000010u;
04075 }
04076 inline void Table_Field::clear_has_numeric_options() {
04077   _has_bits_[0] &= ~0x00000010u;
04078 }
04079 inline void Table_Field::clear_numeric_options() {
04080   if (numeric_options_ != NULL) numeric_options_->::drizzled::message::Table_Field_NumericFieldOptions::Clear();
04081   clear_has_numeric_options();
04082 }
04083 inline const ::drizzled::message::Table_Field_NumericFieldOptions& Table_Field::numeric_options() const {
04084   return numeric_options_ != NULL ? *numeric_options_ : *default_instance_->numeric_options_;
04085 }
04086 inline ::drizzled::message::Table_Field_NumericFieldOptions* Table_Field::mutable_numeric_options() {
04087   set_has_numeric_options();
04088   if (numeric_options_ == NULL) numeric_options_ = new ::drizzled::message::Table_Field_NumericFieldOptions;
04089   return numeric_options_;
04090 }
04091 inline ::drizzled::message::Table_Field_NumericFieldOptions* Table_Field::release_numeric_options() {
04092   clear_has_numeric_options();
04093   ::drizzled::message::Table_Field_NumericFieldOptions* temp = numeric_options_;
04094   numeric_options_ = NULL;
04095   return temp;
04096 }
04097 
04098 // optional .drizzled.message.Table.Field.StringFieldOptions string_options = 7;
04099 inline bool Table_Field::has_string_options() const {
04100   return (_has_bits_[0] & 0x00000020u) != 0;
04101 }
04102 inline void Table_Field::set_has_string_options() {
04103   _has_bits_[0] |= 0x00000020u;
04104 }
04105 inline void Table_Field::clear_has_string_options() {
04106   _has_bits_[0] &= ~0x00000020u;
04107 }
04108 inline void Table_Field::clear_string_options() {
04109   if (string_options_ != NULL) string_options_->::drizzled::message::Table_Field_StringFieldOptions::Clear();
04110   clear_has_string_options();
04111 }
04112 inline const ::drizzled::message::Table_Field_StringFieldOptions& Table_Field::string_options() const {
04113   return string_options_ != NULL ? *string_options_ : *default_instance_->string_options_;
04114 }
04115 inline ::drizzled::message::Table_Field_StringFieldOptions* Table_Field::mutable_string_options() {
04116   set_has_string_options();
04117   if (string_options_ == NULL) string_options_ = new ::drizzled::message::Table_Field_StringFieldOptions;
04118   return string_options_;
04119 }
04120 inline ::drizzled::message::Table_Field_StringFieldOptions* Table_Field::release_string_options() {
04121   clear_has_string_options();
04122   ::drizzled::message::Table_Field_StringFieldOptions* temp = string_options_;
04123   string_options_ = NULL;
04124   return temp;
04125 }
04126 
04127 // optional .drizzled.message.Table.Field.TimeFieldOptions time_options = 8;
04128 inline bool Table_Field::has_time_options() const {
04129   return (_has_bits_[0] & 0x00000040u) != 0;
04130 }
04131 inline void Table_Field::set_has_time_options() {
04132   _has_bits_[0] |= 0x00000040u;
04133 }
04134 inline void Table_Field::clear_has_time_options() {
04135   _has_bits_[0] &= ~0x00000040u;
04136 }
04137 inline void Table_Field::clear_time_options() {
04138   if (time_options_ != NULL) time_options_->::drizzled::message::Table_Field_TimeFieldOptions::Clear();
04139   clear_has_time_options();
04140 }
04141 inline const ::drizzled::message::Table_Field_TimeFieldOptions& Table_Field::time_options() const {
04142   return time_options_ != NULL ? *time_options_ : *default_instance_->time_options_;
04143 }
04144 inline ::drizzled::message::Table_Field_TimeFieldOptions* Table_Field::mutable_time_options() {
04145   set_has_time_options();
04146   if (time_options_ == NULL) time_options_ = new ::drizzled::message::Table_Field_TimeFieldOptions;
04147   return time_options_;
04148 }
04149 inline ::drizzled::message::Table_Field_TimeFieldOptions* Table_Field::release_time_options() {
04150   clear_has_time_options();
04151   ::drizzled::message::Table_Field_TimeFieldOptions* temp = time_options_;
04152   time_options_ = NULL;
04153   return temp;
04154 }
04155 
04156 // optional string comment = 16;
04157 inline bool Table_Field::has_comment() const {
04158   return (_has_bits_[0] & 0x00000080u) != 0;
04159 }
04160 inline void Table_Field::set_has_comment() {
04161   _has_bits_[0] |= 0x00000080u;
04162 }
04163 inline void Table_Field::clear_has_comment() {
04164   _has_bits_[0] &= ~0x00000080u;
04165 }
04166 inline void Table_Field::clear_comment() {
04167   if (comment_ != &::google::protobuf::internal::kEmptyString) {
04168     comment_->clear();
04169   }
04170   clear_has_comment();
04171 }
04172 inline const ::std::string& Table_Field::comment() const {
04173   return *comment_;
04174 }
04175 inline void Table_Field::set_comment(const ::std::string& value) {
04176   set_has_comment();
04177   if (comment_ == &::google::protobuf::internal::kEmptyString) {
04178     comment_ = new ::std::string;
04179   }
04180   comment_->assign(value);
04181 }
04182 inline void Table_Field::set_comment(const char* value) {
04183   set_has_comment();
04184   if (comment_ == &::google::protobuf::internal::kEmptyString) {
04185     comment_ = new ::std::string;
04186   }
04187   comment_->assign(value);
04188 }
04189 inline void Table_Field::set_comment(const char* value, size_t size) {
04190   set_has_comment();
04191   if (comment_ == &::google::protobuf::internal::kEmptyString) {
04192     comment_ = new ::std::string;
04193   }
04194   comment_->assign(reinterpret_cast<const char*>(value), size);
04195 }
04196 inline ::std::string* Table_Field::mutable_comment() {
04197   set_has_comment();
04198   if (comment_ == &::google::protobuf::internal::kEmptyString) {
04199     comment_ = new ::std::string;
04200   }
04201   return comment_;
04202 }
04203 inline ::std::string* Table_Field::release_comment() {
04204   clear_has_comment();
04205   if (comment_ == &::google::protobuf::internal::kEmptyString) {
04206     return NULL;
04207   } else {
04208     ::std::string* temp = comment_;
04209     comment_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
04210     return temp;
04211   }
04212 }
04213 
04214 // optional .drizzled.message.Table.Field.EnumerationValues enumeration_values = 17;
04215 inline bool Table_Field::has_enumeration_values() const {
04216   return (_has_bits_[0] & 0x00000100u) != 0;
04217 }
04218 inline void Table_Field::set_has_enumeration_values() {
04219   _has_bits_[0] |= 0x00000100u;
04220 }
04221 inline void Table_Field::clear_has_enumeration_values() {
04222   _has_bits_[0] &= ~0x00000100u;
04223 }
04224 inline void Table_Field::clear_enumeration_values() {
04225   if (enumeration_values_ != NULL) enumeration_values_->::drizzled::message::Table_Field_EnumerationValues::Clear();
04226   clear_has_enumeration_values();
04227 }
04228 inline const ::drizzled::message::Table_Field_EnumerationValues& Table_Field::enumeration_values() const {
04229   return enumeration_values_ != NULL ? *enumeration_values_ : *default_instance_->enumeration_values_;
04230 }
04231 inline ::drizzled::message::Table_Field_EnumerationValues* Table_Field::mutable_enumeration_values() {
04232   set_has_enumeration_values();
04233   if (enumeration_values_ == NULL) enumeration_values_ = new ::drizzled::message::Table_Field_EnumerationValues;
04234   return enumeration_values_;
04235 }
04236 inline ::drizzled::message::Table_Field_EnumerationValues* Table_Field::release_enumeration_values() {
04237   clear_has_enumeration_values();
04238   ::drizzled::message::Table_Field_EnumerationValues* temp = enumeration_values_;
04239   enumeration_values_ = NULL;
04240   return temp;
04241 }
04242 
04243 // -------------------------------------------------------------------
04244 
04245 // Table_Index_IndexPart
04246 
04247 // required uint32 fieldnr = 1;
04248 inline bool Table_Index_IndexPart::has_fieldnr() const {
04249   return (_has_bits_[0] & 0x00000001u) != 0;
04250 }
04251 inline void Table_Index_IndexPart::set_has_fieldnr() {
04252   _has_bits_[0] |= 0x00000001u;
04253 }
04254 inline void Table_Index_IndexPart::clear_has_fieldnr() {
04255   _has_bits_[0] &= ~0x00000001u;
04256 }
04257 inline void Table_Index_IndexPart::clear_fieldnr() {
04258   fieldnr_ = 0u;
04259   clear_has_fieldnr();
04260 }
04261 inline ::google::protobuf::uint32 Table_Index_IndexPart::fieldnr() const {
04262   return fieldnr_;
04263 }
04264 inline void Table_Index_IndexPart::set_fieldnr(::google::protobuf::uint32 value) {
04265   set_has_fieldnr();
04266   fieldnr_ = value;
04267 }
04268 
04269 // optional uint32 compare_length = 2;
04270 inline bool Table_Index_IndexPart::has_compare_length() const {
04271   return (_has_bits_[0] & 0x00000002u) != 0;
04272 }
04273 inline void Table_Index_IndexPart::set_has_compare_length() {
04274   _has_bits_[0] |= 0x00000002u;
04275 }
04276 inline void Table_Index_IndexPart::clear_has_compare_length() {
04277   _has_bits_[0] &= ~0x00000002u;
04278 }
04279 inline void Table_Index_IndexPart::clear_compare_length() {
04280   compare_length_ = 0u;
04281   clear_has_compare_length();
04282 }
04283 inline ::google::protobuf::uint32 Table_Index_IndexPart::compare_length() const {
04284   return compare_length_;
04285 }
04286 inline void Table_Index_IndexPart::set_compare_length(::google::protobuf::uint32 value) {
04287   set_has_compare_length();
04288   compare_length_ = value;
04289 }
04290 
04291 // optional bool in_reverse_order = 3 [default = false];
04292 inline bool Table_Index_IndexPart::has_in_reverse_order() const {
04293   return (_has_bits_[0] & 0x00000004u) != 0;
04294 }
04295 inline void Table_Index_IndexPart::set_has_in_reverse_order() {
04296   _has_bits_[0] |= 0x00000004u;
04297 }
04298 inline void Table_Index_IndexPart::clear_has_in_reverse_order() {
04299   _has_bits_[0] &= ~0x00000004u;
04300 }
04301 inline void Table_Index_IndexPart::clear_in_reverse_order() {
04302   in_reverse_order_ = false;
04303   clear_has_in_reverse_order();
04304 }
04305 inline bool Table_Index_IndexPart::in_reverse_order() const {
04306   return in_reverse_order_;
04307 }
04308 inline void Table_Index_IndexPart::set_in_reverse_order(bool value) {
04309   set_has_in_reverse_order();
04310   in_reverse_order_ = value;
04311 }
04312 
04313 // -------------------------------------------------------------------
04314 
04315 // Table_Index_Options
04316 
04317 // optional bool pack_key = 1;
04318 inline bool Table_Index_Options::has_pack_key() const {
04319   return (_has_bits_[0] & 0x00000001u) != 0;
04320 }
04321 inline void Table_Index_Options::set_has_pack_key() {
04322   _has_bits_[0] |= 0x00000001u;
04323 }
04324 inline void Table_Index_Options::clear_has_pack_key() {
04325   _has_bits_[0] &= ~0x00000001u;
04326 }
04327 inline void Table_Index_Options::clear_pack_key() {
04328   pack_key_ = false;
04329   clear_has_pack_key();
04330 }
04331 inline bool Table_Index_Options::pack_key() const {
04332   return pack_key_;
04333 }
04334 inline void Table_Index_Options::set_pack_key(bool value) {
04335   set_has_pack_key();
04336   pack_key_ = value;
04337 }
04338 
04339 // optional bool binary_pack_key = 2;
04340 inline bool Table_Index_Options::has_binary_pack_key() const {
04341   return (_has_bits_[0] & 0x00000002u) != 0;
04342 }
04343 inline void Table_Index_Options::set_has_binary_pack_key() {
04344   _has_bits_[0] |= 0x00000002u;
04345 }
04346 inline void Table_Index_Options::clear_has_binary_pack_key() {
04347   _has_bits_[0] &= ~0x00000002u;
04348 }
04349 inline void Table_Index_Options::clear_binary_pack_key() {
04350   binary_pack_key_ = false;
04351   clear_has_binary_pack_key();
04352 }
04353 inline bool Table_Index_Options::binary_pack_key() const {
04354   return binary_pack_key_;
04355 }
04356 inline void Table_Index_Options::set_binary_pack_key(bool value) {
04357   set_has_binary_pack_key();
04358   binary_pack_key_ = value;
04359 }
04360 
04361 // optional bool var_length_key = 3;
04362 inline bool Table_Index_Options::has_var_length_key() const {
04363   return (_has_bits_[0] & 0x00000004u) != 0;
04364 }
04365 inline void Table_Index_Options::set_has_var_length_key() {
04366   _has_bits_[0] |= 0x00000004u;
04367 }
04368 inline void Table_Index_Options::clear_has_var_length_key() {
04369   _has_bits_[0] &= ~0x00000004u;
04370 }
04371 inline void Table_Index_Options::clear_var_length_key() {
04372   var_length_key_ = false;
04373   clear_has_var_length_key();
04374 }
04375 inline bool Table_Index_Options::var_length_key() const {
04376   return var_length_key_;
04377 }
04378 inline void Table_Index_Options::set_var_length_key(bool value) {
04379   set_has_var_length_key();
04380   var_length_key_ = value;
04381 }
04382 
04383 // optional bool null_part_key = 4;
04384 inline bool Table_Index_Options::has_null_part_key() const {
04385   return (_has_bits_[0] & 0x00000008u) != 0;
04386 }
04387 inline void Table_Index_Options::set_has_null_part_key() {
04388   _has_bits_[0] |= 0x00000008u;
04389 }
04390 inline void Table_Index_Options::clear_has_null_part_key() {
04391   _has_bits_[0] &= ~0x00000008u;
04392 }
04393 inline void Table_Index_Options::clear_null_part_key() {
04394   null_part_key_ = false;
04395   clear_has_null_part_key();
04396 }
04397 inline bool Table_Index_Options::null_part_key() const {
04398   return null_part_key_;
04399 }
04400 inline void Table_Index_Options::set_null_part_key(bool value) {
04401   set_has_null_part_key();
04402   null_part_key_ = value;
04403 }
04404 
04405 // optional uint32 key_block_size = 5;
04406 inline bool Table_Index_Options::has_key_block_size() const {
04407   return (_has_bits_[0] & 0x00000010u) != 0;
04408 }
04409 inline void Table_Index_Options::set_has_key_block_size() {
04410   _has_bits_[0] |= 0x00000010u;
04411 }
04412 inline void Table_Index_Options::clear_has_key_block_size() {
04413   _has_bits_[0] &= ~0x00000010u;
04414 }
04415 inline void Table_Index_Options::clear_key_block_size() {
04416   key_block_size_ = 0u;
04417   clear_has_key_block_size();
04418 }
04419 inline ::google::protobuf::uint32 Table_Index_Options::key_block_size() const {
04420   return key_block_size_;
04421 }
04422 inline void Table_Index_Options::set_key_block_size(::google::protobuf::uint32 value) {
04423   set_has_key_block_size();
04424   key_block_size_ = value;
04425 }
04426 
04427 // optional bool has_partial_segments = 6;
04428 inline bool Table_Index_Options::has_has_partial_segments() const {
04429   return (_has_bits_[0] & 0x00000020u) != 0;
04430 }
04431 inline void Table_Index_Options::set_has_has_partial_segments() {
04432   _has_bits_[0] |= 0x00000020u;
04433 }
04434 inline void Table_Index_Options::clear_has_has_partial_segments() {
04435   _has_bits_[0] &= ~0x00000020u;
04436 }
04437 inline void Table_Index_Options::clear_has_partial_segments() {
04438   has_partial_segments_ = false;
04439   clear_has_has_partial_segments();
04440 }
04441 inline bool Table_Index_Options::has_partial_segments() const {
04442   return has_partial_segments_;
04443 }
04444 inline void Table_Index_Options::set_has_partial_segments(bool value) {
04445   set_has_has_partial_segments();
04446   has_partial_segments_ = value;
04447 }
04448 
04449 // optional bool auto_generated_key = 7;
04450 inline bool Table_Index_Options::has_auto_generated_key() const {
04451   return (_has_bits_[0] & 0x00000040u) != 0;
04452 }
04453 inline void Table_Index_Options::set_has_auto_generated_key() {
04454   _has_bits_[0] |= 0x00000040u;
04455 }
04456 inline void Table_Index_Options::clear_has_auto_generated_key() {
04457   _has_bits_[0] &= ~0x00000040u;
04458 }
04459 inline void Table_Index_Options::clear_auto_generated_key() {
04460   auto_generated_key_ = false;
04461   clear_has_auto_generated_key();
04462 }
04463 inline bool Table_Index_Options::auto_generated_key() const {
04464   return auto_generated_key_;
04465 }
04466 inline void Table_Index_Options::set_auto_generated_key(bool value) {
04467   set_has_auto_generated_key();
04468   auto_generated_key_ = value;
04469 }
04470 
04471 // -------------------------------------------------------------------
04472 
04473 // Table_Index
04474 
04475 // required string name = 1;
04476 inline bool Table_Index::has_name() const {
04477   return (_has_bits_[0] & 0x00000001u) != 0;
04478 }
04479 inline void Table_Index::set_has_name() {
04480   _has_bits_[0] |= 0x00000001u;
04481 }
04482 inline void Table_Index::clear_has_name() {
04483   _has_bits_[0] &= ~0x00000001u;
04484 }
04485 inline void Table_Index::clear_name() {
04486   if (name_ != &::google::protobuf::internal::kEmptyString) {
04487     name_->clear();
04488   }
04489   clear_has_name();
04490 }
04491 inline const ::std::string& Table_Index::name() const {
04492   return *name_;
04493 }
04494 inline void Table_Index::set_name(const ::std::string& value) {
04495   set_has_name();
04496   if (name_ == &::google::protobuf::internal::kEmptyString) {
04497     name_ = new ::std::string;
04498   }
04499   name_->assign(value);
04500 }
04501 inline void Table_Index::set_name(const char* value) {
04502   set_has_name();
04503   if (name_ == &::google::protobuf::internal::kEmptyString) {
04504     name_ = new ::std::string;
04505   }
04506   name_->assign(value);
04507 }
04508 inline void Table_Index::set_name(const char* value, size_t size) {
04509   set_has_name();
04510   if (name_ == &::google::protobuf::internal::kEmptyString) {
04511     name_ = new ::std::string;
04512   }
04513   name_->assign(reinterpret_cast<const char*>(value), size);
04514 }
04515 inline ::std::string* Table_Index::mutable_name() {
04516   set_has_name();
04517   if (name_ == &::google::protobuf::internal::kEmptyString) {
04518     name_ = new ::std::string;
04519   }
04520   return name_;
04521 }
04522 inline ::std::string* Table_Index::release_name() {
04523   clear_has_name();
04524   if (name_ == &::google::protobuf::internal::kEmptyString) {
04525     return NULL;
04526   } else {
04527     ::std::string* temp = name_;
04528     name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
04529     return temp;
04530   }
04531 }
04532 
04533 // required bool is_primary = 2;
04534 inline bool Table_Index::has_is_primary() const {
04535   return (_has_bits_[0] & 0x00000002u) != 0;
04536 }
04537 inline void Table_Index::set_has_is_primary() {
04538   _has_bits_[0] |= 0x00000002u;
04539 }
04540 inline void Table_Index::clear_has_is_primary() {
04541   _has_bits_[0] &= ~0x00000002u;
04542 }
04543 inline void Table_Index::clear_is_primary() {
04544   is_primary_ = false;
04545   clear_has_is_primary();
04546 }
04547 inline bool Table_Index::is_primary() const {
04548   return is_primary_;
04549 }
04550 inline void Table_Index::set_is_primary(bool value) {
04551   set_has_is_primary();
04552   is_primary_ = value;
04553 }
04554 
04555 // required bool is_unique = 3;
04556 inline bool Table_Index::has_is_unique() const {
04557   return (_has_bits_[0] & 0x00000004u) != 0;
04558 }
04559 inline void Table_Index::set_has_is_unique() {
04560   _has_bits_[0] |= 0x00000004u;
04561 }
04562 inline void Table_Index::clear_has_is_unique() {
04563   _has_bits_[0] &= ~0x00000004u;
04564 }
04565 inline void Table_Index::clear_is_unique() {
04566   is_unique_ = false;
04567   clear_has_is_unique();
04568 }
04569 inline bool Table_Index::is_unique() const {
04570   return is_unique_;
04571 }
04572 inline void Table_Index::set_is_unique(bool value) {
04573   set_has_is_unique();
04574   is_unique_ = value;
04575 }
04576 
04577 // required .drizzled.message.Table.Index.IndexType type = 4 [default = UNKNOWN_INDEX];
04578 inline bool Table_Index::has_type() const {
04579   return (_has_bits_[0] & 0x00000008u) != 0;
04580 }
04581 inline void Table_Index::set_has_type() {
04582   _has_bits_[0] |= 0x00000008u;
04583 }
04584 inline void Table_Index::clear_has_type() {
04585   _has_bits_[0] &= ~0x00000008u;
04586 }
04587 inline void Table_Index::clear_type() {
04588   type_ = 0;
04589   clear_has_type();
04590 }
04591 inline ::drizzled::message::Table_Index_IndexType Table_Index::type() const {
04592   return static_cast< ::drizzled::message::Table_Index_IndexType >(type_);
04593 }
04594 inline void Table_Index::set_type(::drizzled::message::Table_Index_IndexType value) {
04595   GOOGLE_DCHECK(::drizzled::message::Table_Index_IndexType_IsValid(value));
04596   set_has_type();
04597   type_ = value;
04598 }
04599 
04600 // required uint32 key_length = 5;
04601 inline bool Table_Index::has_key_length() const {
04602   return (_has_bits_[0] & 0x00000010u) != 0;
04603 }
04604 inline void Table_Index::set_has_key_length() {
04605   _has_bits_[0] |= 0x00000010u;
04606 }
04607 inline void Table_Index::clear_has_key_length() {
04608   _has_bits_[0] &= ~0x00000010u;
04609 }
04610 inline void Table_Index::clear_key_length() {
04611   key_length_ = 0u;
04612   clear_has_key_length();
04613 }
04614 inline ::google::protobuf::uint32 Table_Index::key_length() const {
04615   return key_length_;
04616 }
04617 inline void Table_Index::set_key_length(::google::protobuf::uint32 value) {
04618   set_has_key_length();
04619   key_length_ = value;
04620 }
04621 
04622 // repeated .drizzled.message.Table.Index.IndexPart index_part = 6;
04623 inline int Table_Index::index_part_size() const {
04624   return index_part_.size();
04625 }
04626 inline void Table_Index::clear_index_part() {
04627   index_part_.Clear();
04628 }
04629 inline const ::drizzled::message::Table_Index_IndexPart& Table_Index::index_part(int index) const {
04630   return index_part_.Get(index);
04631 }
04632 inline ::drizzled::message::Table_Index_IndexPart* Table_Index::mutable_index_part(int index) {
04633   return index_part_.Mutable(index);
04634 }
04635 inline ::drizzled::message::Table_Index_IndexPart* Table_Index::add_index_part() {
04636   return index_part_.Add();
04637 }
04638 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart >&
04639 Table_Index::index_part() const {
04640   return index_part_;
04641 }
04642 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index_IndexPart >*
04643 Table_Index::mutable_index_part() {
04644   return &index_part_;
04645 }
04646 
04647 // optional .drizzled.message.Table.Index.Options options = 7;
04648 inline bool Table_Index::has_options() const {
04649   return (_has_bits_[0] & 0x00000040u) != 0;
04650 }
04651 inline void Table_Index::set_has_options() {
04652   _has_bits_[0] |= 0x00000040u;
04653 }
04654 inline void Table_Index::clear_has_options() {
04655   _has_bits_[0] &= ~0x00000040u;
04656 }
04657 inline void Table_Index::clear_options() {
04658   if (options_ != NULL) options_->::drizzled::message::Table_Index_Options::Clear();
04659   clear_has_options();
04660 }
04661 inline const ::drizzled::message::Table_Index_Options& Table_Index::options() const {
04662   return options_ != NULL ? *options_ : *default_instance_->options_;
04663 }
04664 inline ::drizzled::message::Table_Index_Options* Table_Index::mutable_options() {
04665   set_has_options();
04666   if (options_ == NULL) options_ = new ::drizzled::message::Table_Index_Options;
04667   return options_;
04668 }
04669 inline ::drizzled::message::Table_Index_Options* Table_Index::release_options() {
04670   clear_has_options();
04671   ::drizzled::message::Table_Index_Options* temp = options_;
04672   options_ = NULL;
04673   return temp;
04674 }
04675 
04676 // optional string comment = 8;
04677 inline bool Table_Index::has_comment() const {
04678   return (_has_bits_[0] & 0x00000080u) != 0;
04679 }
04680 inline void Table_Index::set_has_comment() {
04681   _has_bits_[0] |= 0x00000080u;
04682 }
04683 inline void Table_Index::clear_has_comment() {
04684   _has_bits_[0] &= ~0x00000080u;
04685 }
04686 inline void Table_Index::clear_comment() {
04687   if (comment_ != &::google::protobuf::internal::kEmptyString) {
04688     comment_->clear();
04689   }
04690   clear_has_comment();
04691 }
04692 inline const ::std::string& Table_Index::comment() const {
04693   return *comment_;
04694 }
04695 inline void Table_Index::set_comment(const ::std::string& value) {
04696   set_has_comment();
04697   if (comment_ == &::google::protobuf::internal::kEmptyString) {
04698     comment_ = new ::std::string;
04699   }
04700   comment_->assign(value);
04701 }
04702 inline void Table_Index::set_comment(const char* value) {
04703   set_has_comment();
04704   if (comment_ == &::google::protobuf::internal::kEmptyString) {
04705     comment_ = new ::std::string;
04706   }
04707   comment_->assign(value);
04708 }
04709 inline void Table_Index::set_comment(const char* value, size_t size) {
04710   set_has_comment();
04711   if (comment_ == &::google::protobuf::internal::kEmptyString) {
04712     comment_ = new ::std::string;
04713   }
04714   comment_->assign(reinterpret_cast<const char*>(value), size);
04715 }
04716 inline ::std::string* Table_Index::mutable_comment() {
04717   set_has_comment();
04718   if (comment_ == &::google::protobuf::internal::kEmptyString) {
04719     comment_ = new ::std::string;
04720   }
04721   return comment_;
04722 }
04723 inline ::std::string* Table_Index::release_comment() {
04724   clear_has_comment();
04725   if (comment_ == &::google::protobuf::internal::kEmptyString) {
04726     return NULL;
04727   } else {
04728     ::std::string* temp = comment_;
04729     comment_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
04730     return temp;
04731   }
04732 }
04733 
04734 // -------------------------------------------------------------------
04735 
04736 // Table
04737 
04738 // required string name = 1;
04739 inline bool Table::has_name() const {
04740   return (_has_bits_[0] & 0x00000001u) != 0;
04741 }
04742 inline void Table::set_has_name() {
04743   _has_bits_[0] |= 0x00000001u;
04744 }
04745 inline void Table::clear_has_name() {
04746   _has_bits_[0] &= ~0x00000001u;
04747 }
04748 inline void Table::clear_name() {
04749   if (name_ != &::google::protobuf::internal::kEmptyString) {
04750     name_->clear();
04751   }
04752   clear_has_name();
04753 }
04754 inline const ::std::string& Table::name() const {
04755   return *name_;
04756 }
04757 inline void Table::set_name(const ::std::string& value) {
04758   set_has_name();
04759   if (name_ == &::google::protobuf::internal::kEmptyString) {
04760     name_ = new ::std::string;
04761   }
04762   name_->assign(value);
04763 }
04764 inline void Table::set_name(const char* value) {
04765   set_has_name();
04766   if (name_ == &::google::protobuf::internal::kEmptyString) {
04767     name_ = new ::std::string;
04768   }
04769   name_->assign(value);
04770 }
04771 inline void Table::set_name(const char* value, size_t size) {
04772   set_has_name();
04773   if (name_ == &::google::protobuf::internal::kEmptyString) {
04774     name_ = new ::std::string;
04775   }
04776   name_->assign(reinterpret_cast<const char*>(value), size);
04777 }
04778 inline ::std::string* Table::mutable_name() {
04779   set_has_name();
04780   if (name_ == &::google::protobuf::internal::kEmptyString) {
04781     name_ = new ::std::string;
04782   }
04783   return name_;
04784 }
04785 inline ::std::string* Table::release_name() {
04786   clear_has_name();
04787   if (name_ == &::google::protobuf::internal::kEmptyString) {
04788     return NULL;
04789   } else {
04790     ::std::string* temp = name_;
04791     name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
04792     return temp;
04793   }
04794 }
04795 
04796 // required string schema = 6;
04797 inline bool Table::has_schema() const {
04798   return (_has_bits_[0] & 0x00000002u) != 0;
04799 }
04800 inline void Table::set_has_schema() {
04801   _has_bits_[0] |= 0x00000002u;
04802 }
04803 inline void Table::clear_has_schema() {
04804   _has_bits_[0] &= ~0x00000002u;
04805 }
04806 inline void Table::clear_schema() {
04807   if (schema_ != &::google::protobuf::internal::kEmptyString) {
04808     schema_->clear();
04809   }
04810   clear_has_schema();
04811 }
04812 inline const ::std::string& Table::schema() const {
04813   return *schema_;
04814 }
04815 inline void Table::set_schema(const ::std::string& value) {
04816   set_has_schema();
04817   if (schema_ == &::google::protobuf::internal::kEmptyString) {
04818     schema_ = new ::std::string;
04819   }
04820   schema_->assign(value);
04821 }
04822 inline void Table::set_schema(const char* value) {
04823   set_has_schema();
04824   if (schema_ == &::google::protobuf::internal::kEmptyString) {
04825     schema_ = new ::std::string;
04826   }
04827   schema_->assign(value);
04828 }
04829 inline void Table::set_schema(const char* value, size_t size) {
04830   set_has_schema();
04831   if (schema_ == &::google::protobuf::internal::kEmptyString) {
04832     schema_ = new ::std::string;
04833   }
04834   schema_->assign(reinterpret_cast<const char*>(value), size);
04835 }
04836 inline ::std::string* Table::mutable_schema() {
04837   set_has_schema();
04838   if (schema_ == &::google::protobuf::internal::kEmptyString) {
04839     schema_ = new ::std::string;
04840   }
04841   return schema_;
04842 }
04843 inline ::std::string* Table::release_schema() {
04844   clear_has_schema();
04845   if (schema_ == &::google::protobuf::internal::kEmptyString) {
04846     return NULL;
04847   } else {
04848     ::std::string* temp = schema_;
04849     schema_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
04850     return temp;
04851   }
04852 }
04853 
04854 // required .drizzled.message.Table.TableType type = 5;
04855 inline bool Table::has_type() const {
04856   return (_has_bits_[0] & 0x00000004u) != 0;
04857 }
04858 inline void Table::set_has_type() {
04859   _has_bits_[0] |= 0x00000004u;
04860 }
04861 inline void Table::clear_has_type() {
04862   _has_bits_[0] &= ~0x00000004u;
04863 }
04864 inline void Table::clear_type() {
04865   type_ = 0;
04866   clear_has_type();
04867 }
04868 inline ::drizzled::message::Table_TableType Table::type() const {
04869   return static_cast< ::drizzled::message::Table_TableType >(type_);
04870 }
04871 inline void Table::set_type(::drizzled::message::Table_TableType value) {
04872   GOOGLE_DCHECK(::drizzled::message::Table_TableType_IsValid(value));
04873   set_has_type();
04874   type_ = value;
04875 }
04876 
04877 // required .drizzled.message.Engine engine = 2;
04878 inline bool Table::has_engine() const {
04879   return (_has_bits_[0] & 0x00000008u) != 0;
04880 }
04881 inline void Table::set_has_engine() {
04882   _has_bits_[0] |= 0x00000008u;
04883 }
04884 inline void Table::clear_has_engine() {
04885   _has_bits_[0] &= ~0x00000008u;
04886 }
04887 inline void Table::clear_engine() {
04888   if (engine_ != NULL) engine_->::drizzled::message::Engine::Clear();
04889   clear_has_engine();
04890 }
04891 inline const ::drizzled::message::Engine& Table::engine() const {
04892   return engine_ != NULL ? *engine_ : *default_instance_->engine_;
04893 }
04894 inline ::drizzled::message::Engine* Table::mutable_engine() {
04895   set_has_engine();
04896   if (engine_ == NULL) engine_ = new ::drizzled::message::Engine;
04897   return engine_;
04898 }
04899 inline ::drizzled::message::Engine* Table::release_engine() {
04900   clear_has_engine();
04901   ::drizzled::message::Engine* temp = engine_;
04902   engine_ = NULL;
04903   return temp;
04904 }
04905 
04906 // repeated .drizzled.message.Table.Field field = 3;
04907 inline int Table::field_size() const {
04908   return field_.size();
04909 }
04910 inline void Table::clear_field() {
04911   field_.Clear();
04912 }
04913 inline const ::drizzled::message::Table_Field& Table::field(int index) const {
04914   return field_.Get(index);
04915 }
04916 inline ::drizzled::message::Table_Field* Table::mutable_field(int index) {
04917   return field_.Mutable(index);
04918 }
04919 inline ::drizzled::message::Table_Field* Table::add_field() {
04920   return field_.Add();
04921 }
04922 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >&
04923 Table::field() const {
04924   return field_;
04925 }
04926 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >*
04927 Table::mutable_field() {
04928   return &field_;
04929 }
04930 
04931 // repeated .drizzled.message.Table.Index indexes = 4;
04932 inline int Table::indexes_size() const {
04933   return indexes_.size();
04934 }
04935 inline void Table::clear_indexes() {
04936   indexes_.Clear();
04937 }
04938 inline const ::drizzled::message::Table_Index& Table::indexes(int index) const {
04939   return indexes_.Get(index);
04940 }
04941 inline ::drizzled::message::Table_Index* Table::mutable_indexes(int index) {
04942   return indexes_.Mutable(index);
04943 }
04944 inline ::drizzled::message::Table_Index* Table::add_indexes() {
04945   return indexes_.Add();
04946 }
04947 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index >&
04948 Table::indexes() const {
04949   return indexes_;
04950 }
04951 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Index >*
04952 Table::mutable_indexes() {
04953   return &indexes_;
04954 }
04955 
04956 // repeated .drizzled.message.Table.ForeignKeyConstraint fk_constraint = 8;
04957 inline int Table::fk_constraint_size() const {
04958   return fk_constraint_.size();
04959 }
04960 inline void Table::clear_fk_constraint() {
04961   fk_constraint_.Clear();
04962 }
04963 inline const ::drizzled::message::Table_ForeignKeyConstraint& Table::fk_constraint(int index) const {
04964   return fk_constraint_.Get(index);
04965 }
04966 inline ::drizzled::message::Table_ForeignKeyConstraint* Table::mutable_fk_constraint(int index) {
04967   return fk_constraint_.Mutable(index);
04968 }
04969 inline ::drizzled::message::Table_ForeignKeyConstraint* Table::add_fk_constraint() {
04970   return fk_constraint_.Add();
04971 }
04972 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint >&
04973 Table::fk_constraint() const {
04974   return fk_constraint_;
04975 }
04976 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_ForeignKeyConstraint >*
04977 Table::mutable_fk_constraint() {
04978   return &fk_constraint_;
04979 }
04980 
04981 // optional .drizzled.message.Table.TableOptions options = 9;
04982 inline bool Table::has_options() const {
04983   return (_has_bits_[0] & 0x00000080u) != 0;
04984 }
04985 inline void Table::set_has_options() {
04986   _has_bits_[0] |= 0x00000080u;
04987 }
04988 inline void Table::clear_has_options() {
04989   _has_bits_[0] &= ~0x00000080u;
04990 }
04991 inline void Table::clear_options() {
04992   if (options_ != NULL) options_->::drizzled::message::Table_TableOptions::Clear();
04993   clear_has_options();
04994 }
04995 inline const ::drizzled::message::Table_TableOptions& Table::options() const {
04996   return options_ != NULL ? *options_ : *default_instance_->options_;
04997 }
04998 inline ::drizzled::message::Table_TableOptions* Table::mutable_options() {
04999   set_has_options();
05000   if (options_ == NULL) options_ = new ::drizzled::message::Table_TableOptions;
05001   return options_;
05002 }
05003 inline ::drizzled::message::Table_TableOptions* Table::release_options() {
05004   clear_has_options();
05005   ::drizzled::message::Table_TableOptions* temp = options_;
05006   options_ = NULL;
05007   return temp;
05008 }
05009 
05010 // required uint64 creation_timestamp = 11 [default = 0];
05011 inline bool Table::has_creation_timestamp() const {
05012   return (_has_bits_[0] & 0x00000100u) != 0;
05013 }
05014 inline void Table::set_has_creation_timestamp() {
05015   _has_bits_[0] |= 0x00000100u;
05016 }
05017 inline void Table::clear_has_creation_timestamp() {
05018   _has_bits_[0] &= ~0x00000100u;
05019 }
05020 inline void Table::clear_creation_timestamp() {
05021   creation_timestamp_ = GOOGLE_ULONGLONG(0);
05022   clear_has_creation_timestamp();
05023 }
05024 inline ::google::protobuf::uint64 Table::creation_timestamp() const {
05025   return creation_timestamp_;
05026 }
05027 inline void Table::set_creation_timestamp(::google::protobuf::uint64 value) {
05028   set_has_creation_timestamp();
05029   creation_timestamp_ = value;
05030 }
05031 
05032 // required uint64 update_timestamp = 12 [default = 0];
05033 inline bool Table::has_update_timestamp() const {
05034   return (_has_bits_[0] & 0x00000200u) != 0;
05035 }
05036 inline void Table::set_has_update_timestamp() {
05037   _has_bits_[0] |= 0x00000200u;
05038 }
05039 inline void Table::clear_has_update_timestamp() {
05040   _has_bits_[0] &= ~0x00000200u;
05041 }
05042 inline void Table::clear_update_timestamp() {
05043   update_timestamp_ = GOOGLE_ULONGLONG(0);
05044   clear_has_update_timestamp();
05045 }
05046 inline ::google::protobuf::uint64 Table::update_timestamp() const {
05047   return update_timestamp_;
05048 }
05049 inline void Table::set_update_timestamp(::google::protobuf::uint64 value) {
05050   set_has_update_timestamp();
05051   update_timestamp_ = value;
05052 }
05053 
05054 // optional string catalog = 13;
05055 inline bool Table::has_catalog() const {
05056   return (_has_bits_[0] & 0x00000400u) != 0;
05057 }
05058 inline void Table::set_has_catalog() {
05059   _has_bits_[0] |= 0x00000400u;
05060 }
05061 inline void Table::clear_has_catalog() {
05062   _has_bits_[0] &= ~0x00000400u;
05063 }
05064 inline void Table::clear_catalog() {
05065   if (catalog_ != &::google::protobuf::internal::kEmptyString) {
05066     catalog_->clear();
05067   }
05068   clear_has_catalog();
05069 }
05070 inline const ::std::string& Table::catalog() const {
05071   return *catalog_;
05072 }
05073 inline void Table::set_catalog(const ::std::string& value) {
05074   set_has_catalog();
05075   if (catalog_ == &::google::protobuf::internal::kEmptyString) {
05076     catalog_ = new ::std::string;
05077   }
05078   catalog_->assign(value);
05079 }
05080 inline void Table::set_catalog(const char* value) {
05081   set_has_catalog();
05082   if (catalog_ == &::google::protobuf::internal::kEmptyString) {
05083     catalog_ = new ::std::string;
05084   }
05085   catalog_->assign(value);
05086 }
05087 inline void Table::set_catalog(const char* value, size_t size) {
05088   set_has_catalog();
05089   if (catalog_ == &::google::protobuf::internal::kEmptyString) {
05090     catalog_ = new ::std::string;
05091   }
05092   catalog_->assign(reinterpret_cast<const char*>(value), size);
05093 }
05094 inline ::std::string* Table::mutable_catalog() {
05095   set_has_catalog();
05096   if (catalog_ == &::google::protobuf::internal::kEmptyString) {
05097     catalog_ = new ::std::string;
05098   }
05099   return catalog_;
05100 }
05101 inline ::std::string* Table::release_catalog() {
05102   clear_has_catalog();
05103   if (catalog_ == &::google::protobuf::internal::kEmptyString) {
05104     return NULL;
05105   } else {
05106     ::std::string* temp = catalog_;
05107     catalog_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
05108     return temp;
05109   }
05110 }
05111 
05112 // optional string uuid = 14;
05113 inline bool Table::has_uuid() const {
05114   return (_has_bits_[0] & 0x00000800u) != 0;
05115 }
05116 inline void Table::set_has_uuid() {
05117   _has_bits_[0] |= 0x00000800u;
05118 }
05119 inline void Table::clear_has_uuid() {
05120   _has_bits_[0] &= ~0x00000800u;
05121 }
05122 inline void Table::clear_uuid() {
05123   if (uuid_ != &::google::protobuf::internal::kEmptyString) {
05124     uuid_->clear();
05125   }
05126   clear_has_uuid();
05127 }
05128 inline const ::std::string& Table::uuid() const {
05129   return *uuid_;
05130 }
05131 inline void Table::set_uuid(const ::std::string& value) {
05132   set_has_uuid();
05133   if (uuid_ == &::google::protobuf::internal::kEmptyString) {
05134     uuid_ = new ::std::string;
05135   }
05136   uuid_->assign(value);
05137 }
05138 inline void Table::set_uuid(const char* value) {
05139   set_has_uuid();
05140   if (uuid_ == &::google::protobuf::internal::kEmptyString) {
05141     uuid_ = new ::std::string;
05142   }
05143   uuid_->assign(value);
05144 }
05145 inline void Table::set_uuid(const char* value, size_t size) {
05146   set_has_uuid();
05147   if (uuid_ == &::google::protobuf::internal::kEmptyString) {
05148     uuid_ = new ::std::string;
05149   }
05150   uuid_->assign(reinterpret_cast<const char*>(value), size);
05151 }
05152 inline ::std::string* Table::mutable_uuid() {
05153   set_has_uuid();
05154   if (uuid_ == &::google::protobuf::internal::kEmptyString) {
05155     uuid_ = new ::std::string;
05156   }
05157   return uuid_;
05158 }
05159 inline ::std::string* Table::release_uuid() {
05160   clear_has_uuid();
05161   if (uuid_ == &::google::protobuf::internal::kEmptyString) {
05162     return NULL;
05163   } else {
05164     ::std::string* temp = uuid_;
05165     uuid_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
05166     return temp;
05167   }
05168 }
05169 
05170 // optional uint64 version = 15;
05171 inline bool Table::has_version() const {
05172   return (_has_bits_[0] & 0x00001000u) != 0;
05173 }
05174 inline void Table::set_has_version() {
05175   _has_bits_[0] |= 0x00001000u;
05176 }
05177 inline void Table::clear_has_version() {
05178   _has_bits_[0] &= ~0x00001000u;
05179 }
05180 inline void Table::clear_version() {
05181   version_ = GOOGLE_ULONGLONG(0);
05182   clear_has_version();
05183 }
05184 inline ::google::protobuf::uint64 Table::version() const {
05185   return version_;
05186 }
05187 inline void Table::set_version(::google::protobuf::uint64 value) {
05188   set_has_version();
05189   version_ = value;
05190 }
05191 
05192 // optional .drizzled.message.ReplicationOptions replication_options = 16;
05193 inline bool Table::has_replication_options() const {
05194   return (_has_bits_[0] & 0x00002000u) != 0;
05195 }
05196 inline void Table::set_has_replication_options() {
05197   _has_bits_[0] |= 0x00002000u;
05198 }
05199 inline void Table::clear_has_replication_options() {
05200   _has_bits_[0] &= ~0x00002000u;
05201 }
05202 inline void Table::clear_replication_options() {
05203   if (replication_options_ != NULL) replication_options_->::drizzled::message::ReplicationOptions::Clear();
05204   clear_has_replication_options();
05205 }
05206 inline const ::drizzled::message::ReplicationOptions& Table::replication_options() const {
05207   return replication_options_ != NULL ? *replication_options_ : *default_instance_->replication_options_;
05208 }
05209 inline ::drizzled::message::ReplicationOptions* Table::mutable_replication_options() {
05210   set_has_replication_options();
05211   if (replication_options_ == NULL) replication_options_ = new ::drizzled::message::ReplicationOptions;
05212   return replication_options_;
05213 }
05214 inline ::drizzled::message::ReplicationOptions* Table::release_replication_options() {
05215   clear_has_replication_options();
05216   ::drizzled::message::ReplicationOptions* temp = replication_options_;
05217   replication_options_ = NULL;
05218   return temp;
05219 }
05220 
05221 // -------------------------------------------------------------------
05222 
05223 // AlterTable
05224 
05225 // repeated .drizzled.message.Table.Field added_field = 1;
05226 inline int AlterTable::added_field_size() const {
05227   return added_field_.size();
05228 }
05229 inline void AlterTable::clear_added_field() {
05230   added_field_.Clear();
05231 }
05232 inline const ::drizzled::message::Table_Field& AlterTable::added_field(int index) const {
05233   return added_field_.Get(index);
05234 }
05235 inline ::drizzled::message::Table_Field* AlterTable::mutable_added_field(int index) {
05236   return added_field_.Mutable(index);
05237 }
05238 inline ::drizzled::message::Table_Field* AlterTable::add_added_field() {
05239   return added_field_.Add();
05240 }
05241 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >&
05242 AlterTable::added_field() const {
05243   return added_field_;
05244 }
05245 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Table_Field >*
05246 AlterTable::mutable_added_field() {
05247   return &added_field_;
05248 }
05249 
05250 
05251 // @@protoc_insertion_point(namespace_scope)
05252 
05253 }  // namespace message
05254 }  // namespace drizzled
05255 
05256 #ifndef SWIG
05257 namespace google {
05258 namespace protobuf {
05259 
05260 template <>
05261 inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption>() {
05262   return ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyMatchOption_descriptor();
05263 }
05264 template <>
05265 inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption>() {
05266   return ::drizzled::message::Table_ForeignKeyConstraint_ForeignKeyOption_descriptor();
05267 }
05268 template <>
05269 inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_Field_FieldType>() {
05270   return ::drizzled::message::Table_Field_FieldType_descriptor();
05271 }
05272 template <>
05273 inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_Index_IndexType>() {
05274   return ::drizzled::message::Table_Index_IndexType_descriptor();
05275 }
05276 template <>
05277 inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Table_TableType>() {
05278   return ::drizzled::message::Table_TableType_descriptor();
05279 }
05280 
05281 }  // namespace google
05282 }  // namespace protobuf
05283 #endif  // SWIG
05284 
05285 // @@protoc_insertion_point(global_scope)
05286 
05287 #endif  // PROTOBUF_table_2eproto__INCLUDED