Drizzled Public API Documentation

transaction.pb.h

00001 // Generated by the protocol buffer compiler.  DO NOT EDIT!
00002 // source: transaction.proto
00003 
00004 #ifndef PROTOBUF_transaction_2eproto__INCLUDED
00005 #define PROTOBUF_transaction_2eproto__INCLUDED
00006 
00007 #include <string>
00008 
00009 #include <google/protobuf/stubs/common.h>
00010 
00011 #if GOOGLE_PROTOBUF_VERSION < 2003000
00012 #error This file was generated by a newer version of protoc which is
00013 #error incompatible with your Protocol Buffer headers.  Please update
00014 #error your headers.
00015 #endif
00016 #if 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
00017 #error This file was generated by an older version of protoc which is
00018 #error incompatible with your Protocol Buffer headers.  Please
00019 #error regenerate this file with a newer version of protoc.
00020 #endif
00021 
00022 #include <google/protobuf/generated_message_util.h>
00023 #include <google/protobuf/repeated_field.h>
00024 #include <google/protobuf/extension_set.h>
00025 #include <google/protobuf/generated_message_reflection.h>
00026 #include "table.pb.h"
00027 #include "schema.pb.h"
00028 #include "event.pb.h"
00029 // @@protoc_insertion_point(includes)
00030 
00031 namespace drizzled {
00032 namespace message {
00033 
00034 // Internal implementation detail -- do not call these.
00035 void  protobuf_AddDesc_transaction_2eproto();
00036 void protobuf_AssignDesc_transaction_2eproto();
00037 void protobuf_ShutdownFile_transaction_2eproto();
00038 
00039 class FieldMetadata;
00040 class TableMetadata;
00041 class TransactionContext;
00042 class InsertRecord;
00043 class InsertHeader;
00044 class InsertData;
00045 class UpdateRecord;
00046 class UpdateHeader;
00047 class UpdateData;
00048 class DeleteRecord;
00049 class DeleteHeader;
00050 class DeleteData;
00051 class TruncateTableStatement;
00052 class CreateSchemaStatement;
00053 class AlterSchemaStatement;
00054 class DropSchemaStatement;
00055 class CreateTableStatement;
00056 class AlterTableStatement;
00057 class DropTableStatement;
00058 class SetVariableStatement;
00059 class Statement;
00060 class Transaction;
00061 
00062 enum Statement_Type {
00063   Statement_Type_ROLLBACK = 0,
00064   Statement_Type_INSERT = 1,
00065   Statement_Type_DELETE = 2,
00066   Statement_Type_UPDATE = 3,
00067   Statement_Type_TRUNCATE_TABLE = 4,
00068   Statement_Type_CREATE_SCHEMA = 5,
00069   Statement_Type_ALTER_SCHEMA = 6,
00070   Statement_Type_DROP_SCHEMA = 7,
00071   Statement_Type_CREATE_TABLE = 8,
00072   Statement_Type_ALTER_TABLE = 9,
00073   Statement_Type_DROP_TABLE = 10,
00074   Statement_Type_ROLLBACK_STATEMENT = 11,
00075   Statement_Type_SET_VARIABLE = 98,
00076   Statement_Type_RAW_SQL = 99
00077 };
00078 bool Statement_Type_IsValid(int value);
00079 const Statement_Type Statement_Type_Type_MIN = Statement_Type_ROLLBACK;
00080 const Statement_Type Statement_Type_Type_MAX = Statement_Type_RAW_SQL;
00081 const int Statement_Type_Type_ARRAYSIZE = Statement_Type_Type_MAX + 1;
00082 
00083 const ::google::protobuf::EnumDescriptor* Statement_Type_descriptor();
00084 inline const ::std::string& Statement_Type_Name(Statement_Type value) {
00085   return ::google::protobuf::internal::NameOfEnum(
00086     Statement_Type_descriptor(), value);
00087 }
00088 inline bool Statement_Type_Parse(
00089     const ::std::string& name, Statement_Type* value) {
00090   return ::google::protobuf::internal::ParseNamedEnum<Statement_Type>(
00091     Statement_Type_descriptor(), name, value);
00092 }
00093 // ===================================================================
00094 
00095 class FieldMetadata : public ::google::protobuf::Message {
00096  public:
00097   FieldMetadata();
00098   virtual ~FieldMetadata();
00099   
00100   FieldMetadata(const FieldMetadata& from);
00101   
00102   inline FieldMetadata& operator=(const FieldMetadata& from) {
00103     CopyFrom(from);
00104     return *this;
00105   }
00106   
00107   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00108     return _unknown_fields_;
00109   }
00110   
00111   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00112     return &_unknown_fields_;
00113   }
00114   
00115   static const ::google::protobuf::Descriptor* descriptor();
00116   static const FieldMetadata& default_instance();
00117   
00118   void Swap(FieldMetadata* other);
00119   
00120   // implements Message ----------------------------------------------
00121   
00122   FieldMetadata* New() const;
00123   void CopyFrom(const ::google::protobuf::Message& from);
00124   void MergeFrom(const ::google::protobuf::Message& from);
00125   void CopyFrom(const FieldMetadata& from);
00126   void MergeFrom(const FieldMetadata& from);
00127   void Clear();
00128   bool IsInitialized() const;
00129   
00130   int ByteSize() const;
00131   bool MergePartialFromCodedStream(
00132       ::google::protobuf::io::CodedInputStream* input);
00133   void SerializeWithCachedSizes(
00134       ::google::protobuf::io::CodedOutputStream* output) const;
00135   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00136   int GetCachedSize() const { return _cached_size_; }
00137   private:
00138   void SharedCtor();
00139   void SharedDtor();
00140   void SetCachedSize(int size) const;
00141   public:
00142   
00143   ::google::protobuf::Metadata GetMetadata() const;
00144   
00145   // nested types ----------------------------------------------------
00146   
00147   // accessors -------------------------------------------------------
00148   
00149   // required .drizzled.message.Table.Field.FieldType type = 1;
00150   inline bool has_type() const;
00151   inline void clear_type();
00152   static const int kTypeFieldNumber = 1;
00153   inline ::drizzled::message::Table_Field_FieldType type() const;
00154   inline void set_type(::drizzled::message::Table_Field_FieldType value);
00155   
00156   // required string name = 2;
00157   inline bool has_name() const;
00158   inline void clear_name();
00159   static const int kNameFieldNumber = 2;
00160   inline const ::std::string& name() const;
00161   inline void set_name(const ::std::string& value);
00162   inline void set_name(const char* value);
00163   inline void set_name(const char* value, size_t size);
00164   inline ::std::string* mutable_name();
00165   
00166   // @@protoc_insertion_point(class_scope:drizzled.message.FieldMetadata)
00167  private:
00168   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00169   mutable int _cached_size_;
00170   
00171   int type_;
00172   ::std::string* name_;
00173   static const ::std::string _default_name_;
00174   friend void  protobuf_AddDesc_transaction_2eproto();
00175   friend void protobuf_AssignDesc_transaction_2eproto();
00176   friend void protobuf_ShutdownFile_transaction_2eproto();
00177   
00178   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
00179   
00180   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00181   inline bool _has_bit(int index) const {
00182     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00183   }
00184   inline void _set_bit(int index) {
00185     _has_bits_[index / 32] |= (1u << (index % 32));
00186   }
00187   inline void _clear_bit(int index) {
00188     _has_bits_[index / 32] &= ~(1u << (index % 32));
00189   }
00190   
00191   void InitAsDefaultInstance();
00192   static FieldMetadata* default_instance_;
00193 };
00194 // -------------------------------------------------------------------
00195 
00196 class TableMetadata : public ::google::protobuf::Message {
00197  public:
00198   TableMetadata();
00199   virtual ~TableMetadata();
00200   
00201   TableMetadata(const TableMetadata& from);
00202   
00203   inline TableMetadata& operator=(const TableMetadata& from) {
00204     CopyFrom(from);
00205     return *this;
00206   }
00207   
00208   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00209     return _unknown_fields_;
00210   }
00211   
00212   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00213     return &_unknown_fields_;
00214   }
00215   
00216   static const ::google::protobuf::Descriptor* descriptor();
00217   static const TableMetadata& default_instance();
00218   
00219   void Swap(TableMetadata* other);
00220   
00221   // implements Message ----------------------------------------------
00222   
00223   TableMetadata* New() const;
00224   void CopyFrom(const ::google::protobuf::Message& from);
00225   void MergeFrom(const ::google::protobuf::Message& from);
00226   void CopyFrom(const TableMetadata& from);
00227   void MergeFrom(const TableMetadata& from);
00228   void Clear();
00229   bool IsInitialized() const;
00230   
00231   int ByteSize() const;
00232   bool MergePartialFromCodedStream(
00233       ::google::protobuf::io::CodedInputStream* input);
00234   void SerializeWithCachedSizes(
00235       ::google::protobuf::io::CodedOutputStream* output) const;
00236   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00237   int GetCachedSize() const { return _cached_size_; }
00238   private:
00239   void SharedCtor();
00240   void SharedDtor();
00241   void SetCachedSize(int size) const;
00242   public:
00243   
00244   ::google::protobuf::Metadata GetMetadata() const;
00245   
00246   // nested types ----------------------------------------------------
00247   
00248   // accessors -------------------------------------------------------
00249   
00250   // required string schema_name = 1;
00251   inline bool has_schema_name() const;
00252   inline void clear_schema_name();
00253   static const int kSchemaNameFieldNumber = 1;
00254   inline const ::std::string& schema_name() const;
00255   inline void set_schema_name(const ::std::string& value);
00256   inline void set_schema_name(const char* value);
00257   inline void set_schema_name(const char* value, size_t size);
00258   inline ::std::string* mutable_schema_name();
00259   
00260   // required string table_name = 2;
00261   inline bool has_table_name() const;
00262   inline void clear_table_name();
00263   static const int kTableNameFieldNumber = 2;
00264   inline const ::std::string& table_name() const;
00265   inline void set_table_name(const ::std::string& value);
00266   inline void set_table_name(const char* value);
00267   inline void set_table_name(const char* value, size_t size);
00268   inline ::std::string* mutable_table_name();
00269   
00270   // optional string catalog_name = 3;
00271   inline bool has_catalog_name() const;
00272   inline void clear_catalog_name();
00273   static const int kCatalogNameFieldNumber = 3;
00274   inline const ::std::string& catalog_name() const;
00275   inline void set_catalog_name(const ::std::string& value);
00276   inline void set_catalog_name(const char* value);
00277   inline void set_catalog_name(const char* value, size_t size);
00278   inline ::std::string* mutable_catalog_name();
00279   
00280   // @@protoc_insertion_point(class_scope:drizzled.message.TableMetadata)
00281  private:
00282   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00283   mutable int _cached_size_;
00284   
00285   ::std::string* schema_name_;
00286   static const ::std::string _default_schema_name_;
00287   ::std::string* table_name_;
00288   static const ::std::string _default_table_name_;
00289   ::std::string* catalog_name_;
00290   static const ::std::string _default_catalog_name_;
00291   friend void  protobuf_AddDesc_transaction_2eproto();
00292   friend void protobuf_AssignDesc_transaction_2eproto();
00293   friend void protobuf_ShutdownFile_transaction_2eproto();
00294   
00295   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
00296   
00297   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00298   inline bool _has_bit(int index) const {
00299     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00300   }
00301   inline void _set_bit(int index) {
00302     _has_bits_[index / 32] |= (1u << (index % 32));
00303   }
00304   inline void _clear_bit(int index) {
00305     _has_bits_[index / 32] &= ~(1u << (index % 32));
00306   }
00307   
00308   void InitAsDefaultInstance();
00309   static TableMetadata* default_instance_;
00310 };
00311 // -------------------------------------------------------------------
00312 
00313 class TransactionContext : public ::google::protobuf::Message {
00314  public:
00315   TransactionContext();
00316   virtual ~TransactionContext();
00317   
00318   TransactionContext(const TransactionContext& from);
00319   
00320   inline TransactionContext& operator=(const TransactionContext& from) {
00321     CopyFrom(from);
00322     return *this;
00323   }
00324   
00325   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00326     return _unknown_fields_;
00327   }
00328   
00329   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00330     return &_unknown_fields_;
00331   }
00332   
00333   static const ::google::protobuf::Descriptor* descriptor();
00334   static const TransactionContext& default_instance();
00335   
00336   void Swap(TransactionContext* other);
00337   
00338   // implements Message ----------------------------------------------
00339   
00340   TransactionContext* New() const;
00341   void CopyFrom(const ::google::protobuf::Message& from);
00342   void MergeFrom(const ::google::protobuf::Message& from);
00343   void CopyFrom(const TransactionContext& from);
00344   void MergeFrom(const TransactionContext& from);
00345   void Clear();
00346   bool IsInitialized() const;
00347   
00348   int ByteSize() const;
00349   bool MergePartialFromCodedStream(
00350       ::google::protobuf::io::CodedInputStream* input);
00351   void SerializeWithCachedSizes(
00352       ::google::protobuf::io::CodedOutputStream* output) const;
00353   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00354   int GetCachedSize() const { return _cached_size_; }
00355   private:
00356   void SharedCtor();
00357   void SharedDtor();
00358   void SetCachedSize(int size) const;
00359   public:
00360   
00361   ::google::protobuf::Metadata GetMetadata() const;
00362   
00363   // nested types ----------------------------------------------------
00364   
00365   // accessors -------------------------------------------------------
00366   
00367   // required uint32 server_id = 1;
00368   inline bool has_server_id() const;
00369   inline void clear_server_id();
00370   static const int kServerIdFieldNumber = 1;
00371   inline ::google::protobuf::uint32 server_id() const;
00372   inline void set_server_id(::google::protobuf::uint32 value);
00373   
00374   // required uint64 transaction_id = 2;
00375   inline bool has_transaction_id() const;
00376   inline void clear_transaction_id();
00377   static const int kTransactionIdFieldNumber = 2;
00378   inline ::google::protobuf::uint64 transaction_id() const;
00379   inline void set_transaction_id(::google::protobuf::uint64 value);
00380   
00381   // required uint64 start_timestamp = 3;
00382   inline bool has_start_timestamp() const;
00383   inline void clear_start_timestamp();
00384   static const int kStartTimestampFieldNumber = 3;
00385   inline ::google::protobuf::uint64 start_timestamp() const;
00386   inline void set_start_timestamp(::google::protobuf::uint64 value);
00387   
00388   // required uint64 end_timestamp = 4;
00389   inline bool has_end_timestamp() const;
00390   inline void clear_end_timestamp();
00391   static const int kEndTimestampFieldNumber = 4;
00392   inline ::google::protobuf::uint64 end_timestamp() const;
00393   inline void set_end_timestamp(::google::protobuf::uint64 value);
00394   
00395   // @@protoc_insertion_point(class_scope:drizzled.message.TransactionContext)
00396  private:
00397   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00398   mutable int _cached_size_;
00399   
00400   ::google::protobuf::uint32 server_id_;
00401   ::google::protobuf::uint64 transaction_id_;
00402   ::google::protobuf::uint64 start_timestamp_;
00403   ::google::protobuf::uint64 end_timestamp_;
00404   friend void  protobuf_AddDesc_transaction_2eproto();
00405   friend void protobuf_AssignDesc_transaction_2eproto();
00406   friend void protobuf_ShutdownFile_transaction_2eproto();
00407   
00408   ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
00409   
00410   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00411   inline bool _has_bit(int index) const {
00412     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00413   }
00414   inline void _set_bit(int index) {
00415     _has_bits_[index / 32] |= (1u << (index % 32));
00416   }
00417   inline void _clear_bit(int index) {
00418     _has_bits_[index / 32] &= ~(1u << (index % 32));
00419   }
00420   
00421   void InitAsDefaultInstance();
00422   static TransactionContext* default_instance_;
00423 };
00424 // -------------------------------------------------------------------
00425 
00426 class InsertRecord : public ::google::protobuf::Message {
00427  public:
00428   InsertRecord();
00429   virtual ~InsertRecord();
00430   
00431   InsertRecord(const InsertRecord& from);
00432   
00433   inline InsertRecord& operator=(const InsertRecord& from) {
00434     CopyFrom(from);
00435     return *this;
00436   }
00437   
00438   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00439     return _unknown_fields_;
00440   }
00441   
00442   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00443     return &_unknown_fields_;
00444   }
00445   
00446   static const ::google::protobuf::Descriptor* descriptor();
00447   static const InsertRecord& default_instance();
00448   
00449   void Swap(InsertRecord* other);
00450   
00451   // implements Message ----------------------------------------------
00452   
00453   InsertRecord* New() const;
00454   void CopyFrom(const ::google::protobuf::Message& from);
00455   void MergeFrom(const ::google::protobuf::Message& from);
00456   void CopyFrom(const InsertRecord& from);
00457   void MergeFrom(const InsertRecord& from);
00458   void Clear();
00459   bool IsInitialized() const;
00460   
00461   int ByteSize() const;
00462   bool MergePartialFromCodedStream(
00463       ::google::protobuf::io::CodedInputStream* input);
00464   void SerializeWithCachedSizes(
00465       ::google::protobuf::io::CodedOutputStream* output) const;
00466   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00467   int GetCachedSize() const { return _cached_size_; }
00468   private:
00469   void SharedCtor();
00470   void SharedDtor();
00471   void SetCachedSize(int size) const;
00472   public:
00473   
00474   ::google::protobuf::Metadata GetMetadata() const;
00475   
00476   // nested types ----------------------------------------------------
00477   
00478   // accessors -------------------------------------------------------
00479   
00480   // repeated bytes insert_value = 1;
00481   inline int insert_value_size() const;
00482   inline void clear_insert_value();
00483   static const int kInsertValueFieldNumber = 1;
00484   inline const ::std::string& insert_value(int index) const;
00485   inline ::std::string* mutable_insert_value(int index);
00486   inline void set_insert_value(int index, const ::std::string& value);
00487   inline void set_insert_value(int index, const char* value);
00488   inline void set_insert_value(int index, const void* value, size_t size);
00489   inline ::std::string* add_insert_value();
00490   inline void add_insert_value(const ::std::string& value);
00491   inline void add_insert_value(const char* value);
00492   inline void add_insert_value(const void* value, size_t size);
00493   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& insert_value() const;
00494   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_insert_value();
00495   
00496   // repeated bool is_null = 2;
00497   inline int is_null_size() const;
00498   inline void clear_is_null();
00499   static const int kIsNullFieldNumber = 2;
00500   inline bool is_null(int index) const;
00501   inline void set_is_null(int index, bool value);
00502   inline void add_is_null(bool value);
00503   inline const ::google::protobuf::RepeatedField< bool >&
00504       is_null() const;
00505   inline ::google::protobuf::RepeatedField< bool >*
00506       mutable_is_null();
00507   
00508   // @@protoc_insertion_point(class_scope:drizzled.message.InsertRecord)
00509  private:
00510   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00511   mutable int _cached_size_;
00512   
00513   ::google::protobuf::RepeatedPtrField< ::std::string> insert_value_;
00514   ::google::protobuf::RepeatedField< bool > is_null_;
00515   friend void  protobuf_AddDesc_transaction_2eproto();
00516   friend void protobuf_AssignDesc_transaction_2eproto();
00517   friend void protobuf_ShutdownFile_transaction_2eproto();
00518   
00519   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
00520   
00521   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00522   inline bool _has_bit(int index) const {
00523     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00524   }
00525   inline void _set_bit(int index) {
00526     _has_bits_[index / 32] |= (1u << (index % 32));
00527   }
00528   inline void _clear_bit(int index) {
00529     _has_bits_[index / 32] &= ~(1u << (index % 32));
00530   }
00531   
00532   void InitAsDefaultInstance();
00533   static InsertRecord* default_instance_;
00534 };
00535 // -------------------------------------------------------------------
00536 
00537 class InsertHeader : public ::google::protobuf::Message {
00538  public:
00539   InsertHeader();
00540   virtual ~InsertHeader();
00541   
00542   InsertHeader(const InsertHeader& from);
00543   
00544   inline InsertHeader& operator=(const InsertHeader& from) {
00545     CopyFrom(from);
00546     return *this;
00547   }
00548   
00549   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00550     return _unknown_fields_;
00551   }
00552   
00553   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00554     return &_unknown_fields_;
00555   }
00556   
00557   static const ::google::protobuf::Descriptor* descriptor();
00558   static const InsertHeader& default_instance();
00559   
00560   void Swap(InsertHeader* other);
00561   
00562   // implements Message ----------------------------------------------
00563   
00564   InsertHeader* New() const;
00565   void CopyFrom(const ::google::protobuf::Message& from);
00566   void MergeFrom(const ::google::protobuf::Message& from);
00567   void CopyFrom(const InsertHeader& from);
00568   void MergeFrom(const InsertHeader& from);
00569   void Clear();
00570   bool IsInitialized() const;
00571   
00572   int ByteSize() const;
00573   bool MergePartialFromCodedStream(
00574       ::google::protobuf::io::CodedInputStream* input);
00575   void SerializeWithCachedSizes(
00576       ::google::protobuf::io::CodedOutputStream* output) const;
00577   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00578   int GetCachedSize() const { return _cached_size_; }
00579   private:
00580   void SharedCtor();
00581   void SharedDtor();
00582   void SetCachedSize(int size) const;
00583   public:
00584   
00585   ::google::protobuf::Metadata GetMetadata() const;
00586   
00587   // nested types ----------------------------------------------------
00588   
00589   // accessors -------------------------------------------------------
00590   
00591   // required .drizzled.message.TableMetadata table_metadata = 1;
00592   inline bool has_table_metadata() const;
00593   inline void clear_table_metadata();
00594   static const int kTableMetadataFieldNumber = 1;
00595   inline const ::drizzled::message::TableMetadata& table_metadata() const;
00596   inline ::drizzled::message::TableMetadata* mutable_table_metadata();
00597   
00598   // repeated .drizzled.message.FieldMetadata field_metadata = 2;
00599   inline int field_metadata_size() const;
00600   inline void clear_field_metadata();
00601   static const int kFieldMetadataFieldNumber = 2;
00602   inline const ::drizzled::message::FieldMetadata& field_metadata(int index) const;
00603   inline ::drizzled::message::FieldMetadata* mutable_field_metadata(int index);
00604   inline ::drizzled::message::FieldMetadata* add_field_metadata();
00605   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
00606       field_metadata() const;
00607   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
00608       mutable_field_metadata();
00609   
00610   // @@protoc_insertion_point(class_scope:drizzled.message.InsertHeader)
00611  private:
00612   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00613   mutable int _cached_size_;
00614   
00615   ::drizzled::message::TableMetadata* table_metadata_;
00616   ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata > field_metadata_;
00617   friend void  protobuf_AddDesc_transaction_2eproto();
00618   friend void protobuf_AssignDesc_transaction_2eproto();
00619   friend void protobuf_ShutdownFile_transaction_2eproto();
00620   
00621   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
00622   
00623   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00624   inline bool _has_bit(int index) const {
00625     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00626   }
00627   inline void _set_bit(int index) {
00628     _has_bits_[index / 32] |= (1u << (index % 32));
00629   }
00630   inline void _clear_bit(int index) {
00631     _has_bits_[index / 32] &= ~(1u << (index % 32));
00632   }
00633   
00634   void InitAsDefaultInstance();
00635   static InsertHeader* default_instance_;
00636 };
00637 // -------------------------------------------------------------------
00638 
00639 class InsertData : public ::google::protobuf::Message {
00640  public:
00641   InsertData();
00642   virtual ~InsertData();
00643   
00644   InsertData(const InsertData& from);
00645   
00646   inline InsertData& operator=(const InsertData& from) {
00647     CopyFrom(from);
00648     return *this;
00649   }
00650   
00651   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00652     return _unknown_fields_;
00653   }
00654   
00655   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00656     return &_unknown_fields_;
00657   }
00658   
00659   static const ::google::protobuf::Descriptor* descriptor();
00660   static const InsertData& default_instance();
00661   
00662   void Swap(InsertData* other);
00663   
00664   // implements Message ----------------------------------------------
00665   
00666   InsertData* New() const;
00667   void CopyFrom(const ::google::protobuf::Message& from);
00668   void MergeFrom(const ::google::protobuf::Message& from);
00669   void CopyFrom(const InsertData& from);
00670   void MergeFrom(const InsertData& from);
00671   void Clear();
00672   bool IsInitialized() const;
00673   
00674   int ByteSize() const;
00675   bool MergePartialFromCodedStream(
00676       ::google::protobuf::io::CodedInputStream* input);
00677   void SerializeWithCachedSizes(
00678       ::google::protobuf::io::CodedOutputStream* output) const;
00679   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00680   int GetCachedSize() const { return _cached_size_; }
00681   private:
00682   void SharedCtor();
00683   void SharedDtor();
00684   void SetCachedSize(int size) const;
00685   public:
00686   
00687   ::google::protobuf::Metadata GetMetadata() const;
00688   
00689   // nested types ----------------------------------------------------
00690   
00691   // accessors -------------------------------------------------------
00692   
00693   // required uint32 segment_id = 1;
00694   inline bool has_segment_id() const;
00695   inline void clear_segment_id();
00696   static const int kSegmentIdFieldNumber = 1;
00697   inline ::google::protobuf::uint32 segment_id() const;
00698   inline void set_segment_id(::google::protobuf::uint32 value);
00699   
00700   // required bool end_segment = 2;
00701   inline bool has_end_segment() const;
00702   inline void clear_end_segment();
00703   static const int kEndSegmentFieldNumber = 2;
00704   inline bool end_segment() const;
00705   inline void set_end_segment(bool value);
00706   
00707   // repeated .drizzled.message.InsertRecord record = 3;
00708   inline int record_size() const;
00709   inline void clear_record();
00710   static const int kRecordFieldNumber = 3;
00711   inline const ::drizzled::message::InsertRecord& record(int index) const;
00712   inline ::drizzled::message::InsertRecord* mutable_record(int index);
00713   inline ::drizzled::message::InsertRecord* add_record();
00714   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::InsertRecord >&
00715       record() const;
00716   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::InsertRecord >*
00717       mutable_record();
00718   
00719   // @@protoc_insertion_point(class_scope:drizzled.message.InsertData)
00720  private:
00721   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00722   mutable int _cached_size_;
00723   
00724   ::google::protobuf::uint32 segment_id_;
00725   bool end_segment_;
00726   ::google::protobuf::RepeatedPtrField< ::drizzled::message::InsertRecord > record_;
00727   friend void  protobuf_AddDesc_transaction_2eproto();
00728   friend void protobuf_AssignDesc_transaction_2eproto();
00729   friend void protobuf_ShutdownFile_transaction_2eproto();
00730   
00731   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
00732   
00733   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00734   inline bool _has_bit(int index) const {
00735     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00736   }
00737   inline void _set_bit(int index) {
00738     _has_bits_[index / 32] |= (1u << (index % 32));
00739   }
00740   inline void _clear_bit(int index) {
00741     _has_bits_[index / 32] &= ~(1u << (index % 32));
00742   }
00743   
00744   void InitAsDefaultInstance();
00745   static InsertData* default_instance_;
00746 };
00747 // -------------------------------------------------------------------
00748 
00749 class UpdateRecord : public ::google::protobuf::Message {
00750  public:
00751   UpdateRecord();
00752   virtual ~UpdateRecord();
00753   
00754   UpdateRecord(const UpdateRecord& from);
00755   
00756   inline UpdateRecord& operator=(const UpdateRecord& from) {
00757     CopyFrom(from);
00758     return *this;
00759   }
00760   
00761   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00762     return _unknown_fields_;
00763   }
00764   
00765   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00766     return &_unknown_fields_;
00767   }
00768   
00769   static const ::google::protobuf::Descriptor* descriptor();
00770   static const UpdateRecord& default_instance();
00771   
00772   void Swap(UpdateRecord* other);
00773   
00774   // implements Message ----------------------------------------------
00775   
00776   UpdateRecord* New() const;
00777   void CopyFrom(const ::google::protobuf::Message& from);
00778   void MergeFrom(const ::google::protobuf::Message& from);
00779   void CopyFrom(const UpdateRecord& from);
00780   void MergeFrom(const UpdateRecord& from);
00781   void Clear();
00782   bool IsInitialized() const;
00783   
00784   int ByteSize() const;
00785   bool MergePartialFromCodedStream(
00786       ::google::protobuf::io::CodedInputStream* input);
00787   void SerializeWithCachedSizes(
00788       ::google::protobuf::io::CodedOutputStream* output) const;
00789   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00790   int GetCachedSize() const { return _cached_size_; }
00791   private:
00792   void SharedCtor();
00793   void SharedDtor();
00794   void SetCachedSize(int size) const;
00795   public:
00796   
00797   ::google::protobuf::Metadata GetMetadata() const;
00798   
00799   // nested types ----------------------------------------------------
00800   
00801   // accessors -------------------------------------------------------
00802   
00803   // repeated bytes key_value = 1;
00804   inline int key_value_size() const;
00805   inline void clear_key_value();
00806   static const int kKeyValueFieldNumber = 1;
00807   inline const ::std::string& key_value(int index) const;
00808   inline ::std::string* mutable_key_value(int index);
00809   inline void set_key_value(int index, const ::std::string& value);
00810   inline void set_key_value(int index, const char* value);
00811   inline void set_key_value(int index, const void* value, size_t size);
00812   inline ::std::string* add_key_value();
00813   inline void add_key_value(const ::std::string& value);
00814   inline void add_key_value(const char* value);
00815   inline void add_key_value(const void* value, size_t size);
00816   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& key_value() const;
00817   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_key_value();
00818   
00819   // repeated bytes after_value = 2;
00820   inline int after_value_size() const;
00821   inline void clear_after_value();
00822   static const int kAfterValueFieldNumber = 2;
00823   inline const ::std::string& after_value(int index) const;
00824   inline ::std::string* mutable_after_value(int index);
00825   inline void set_after_value(int index, const ::std::string& value);
00826   inline void set_after_value(int index, const char* value);
00827   inline void set_after_value(int index, const void* value, size_t size);
00828   inline ::std::string* add_after_value();
00829   inline void add_after_value(const ::std::string& value);
00830   inline void add_after_value(const char* value);
00831   inline void add_after_value(const void* value, size_t size);
00832   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& after_value() const;
00833   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_after_value();
00834   
00835   // repeated bytes before_value = 3;
00836   inline int before_value_size() const;
00837   inline void clear_before_value();
00838   static const int kBeforeValueFieldNumber = 3;
00839   inline const ::std::string& before_value(int index) const;
00840   inline ::std::string* mutable_before_value(int index);
00841   inline void set_before_value(int index, const ::std::string& value);
00842   inline void set_before_value(int index, const char* value);
00843   inline void set_before_value(int index, const void* value, size_t size);
00844   inline ::std::string* add_before_value();
00845   inline void add_before_value(const ::std::string& value);
00846   inline void add_before_value(const char* value);
00847   inline void add_before_value(const void* value, size_t size);
00848   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& before_value() const;
00849   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_before_value();
00850   
00851   // repeated bool is_null = 4;
00852   inline int is_null_size() const;
00853   inline void clear_is_null();
00854   static const int kIsNullFieldNumber = 4;
00855   inline bool is_null(int index) const;
00856   inline void set_is_null(int index, bool value);
00857   inline void add_is_null(bool value);
00858   inline const ::google::protobuf::RepeatedField< bool >&
00859       is_null() const;
00860   inline ::google::protobuf::RepeatedField< bool >*
00861       mutable_is_null();
00862   
00863   // @@protoc_insertion_point(class_scope:drizzled.message.UpdateRecord)
00864  private:
00865   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00866   mutable int _cached_size_;
00867   
00868   ::google::protobuf::RepeatedPtrField< ::std::string> key_value_;
00869   ::google::protobuf::RepeatedPtrField< ::std::string> after_value_;
00870   ::google::protobuf::RepeatedPtrField< ::std::string> before_value_;
00871   ::google::protobuf::RepeatedField< bool > is_null_;
00872   friend void  protobuf_AddDesc_transaction_2eproto();
00873   friend void protobuf_AssignDesc_transaction_2eproto();
00874   friend void protobuf_ShutdownFile_transaction_2eproto();
00875   
00876   ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
00877   
00878   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00879   inline bool _has_bit(int index) const {
00880     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00881   }
00882   inline void _set_bit(int index) {
00883     _has_bits_[index / 32] |= (1u << (index % 32));
00884   }
00885   inline void _clear_bit(int index) {
00886     _has_bits_[index / 32] &= ~(1u << (index % 32));
00887   }
00888   
00889   void InitAsDefaultInstance();
00890   static UpdateRecord* default_instance_;
00891 };
00892 // -------------------------------------------------------------------
00893 
00894 class UpdateHeader : public ::google::protobuf::Message {
00895  public:
00896   UpdateHeader();
00897   virtual ~UpdateHeader();
00898   
00899   UpdateHeader(const UpdateHeader& from);
00900   
00901   inline UpdateHeader& operator=(const UpdateHeader& from) {
00902     CopyFrom(from);
00903     return *this;
00904   }
00905   
00906   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00907     return _unknown_fields_;
00908   }
00909   
00910   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00911     return &_unknown_fields_;
00912   }
00913   
00914   static const ::google::protobuf::Descriptor* descriptor();
00915   static const UpdateHeader& default_instance();
00916   
00917   void Swap(UpdateHeader* other);
00918   
00919   // implements Message ----------------------------------------------
00920   
00921   UpdateHeader* New() const;
00922   void CopyFrom(const ::google::protobuf::Message& from);
00923   void MergeFrom(const ::google::protobuf::Message& from);
00924   void CopyFrom(const UpdateHeader& from);
00925   void MergeFrom(const UpdateHeader& from);
00926   void Clear();
00927   bool IsInitialized() const;
00928   
00929   int ByteSize() const;
00930   bool MergePartialFromCodedStream(
00931       ::google::protobuf::io::CodedInputStream* input);
00932   void SerializeWithCachedSizes(
00933       ::google::protobuf::io::CodedOutputStream* output) const;
00934   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00935   int GetCachedSize() const { return _cached_size_; }
00936   private:
00937   void SharedCtor();
00938   void SharedDtor();
00939   void SetCachedSize(int size) const;
00940   public:
00941   
00942   ::google::protobuf::Metadata GetMetadata() const;
00943   
00944   // nested types ----------------------------------------------------
00945   
00946   // accessors -------------------------------------------------------
00947   
00948   // required .drizzled.message.TableMetadata table_metadata = 1;
00949   inline bool has_table_metadata() const;
00950   inline void clear_table_metadata();
00951   static const int kTableMetadataFieldNumber = 1;
00952   inline const ::drizzled::message::TableMetadata& table_metadata() const;
00953   inline ::drizzled::message::TableMetadata* mutable_table_metadata();
00954   
00955   // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
00956   inline int key_field_metadata_size() const;
00957   inline void clear_key_field_metadata();
00958   static const int kKeyFieldMetadataFieldNumber = 2;
00959   inline const ::drizzled::message::FieldMetadata& key_field_metadata(int index) const;
00960   inline ::drizzled::message::FieldMetadata* mutable_key_field_metadata(int index);
00961   inline ::drizzled::message::FieldMetadata* add_key_field_metadata();
00962   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
00963       key_field_metadata() const;
00964   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
00965       mutable_key_field_metadata();
00966   
00967   // repeated .drizzled.message.FieldMetadata set_field_metadata = 3;
00968   inline int set_field_metadata_size() const;
00969   inline void clear_set_field_metadata();
00970   static const int kSetFieldMetadataFieldNumber = 3;
00971   inline const ::drizzled::message::FieldMetadata& set_field_metadata(int index) const;
00972   inline ::drizzled::message::FieldMetadata* mutable_set_field_metadata(int index);
00973   inline ::drizzled::message::FieldMetadata* add_set_field_metadata();
00974   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
00975       set_field_metadata() const;
00976   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
00977       mutable_set_field_metadata();
00978   
00979   // @@protoc_insertion_point(class_scope:drizzled.message.UpdateHeader)
00980  private:
00981   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00982   mutable int _cached_size_;
00983   
00984   ::drizzled::message::TableMetadata* table_metadata_;
00985   ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata > key_field_metadata_;
00986   ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata > set_field_metadata_;
00987   friend void  protobuf_AddDesc_transaction_2eproto();
00988   friend void protobuf_AssignDesc_transaction_2eproto();
00989   friend void protobuf_ShutdownFile_transaction_2eproto();
00990   
00991   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
00992   
00993   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00994   inline bool _has_bit(int index) const {
00995     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00996   }
00997   inline void _set_bit(int index) {
00998     _has_bits_[index / 32] |= (1u << (index % 32));
00999   }
01000   inline void _clear_bit(int index) {
01001     _has_bits_[index / 32] &= ~(1u << (index % 32));
01002   }
01003   
01004   void InitAsDefaultInstance();
01005   static UpdateHeader* default_instance_;
01006 };
01007 // -------------------------------------------------------------------
01008 
01009 class UpdateData : public ::google::protobuf::Message {
01010  public:
01011   UpdateData();
01012   virtual ~UpdateData();
01013   
01014   UpdateData(const UpdateData& from);
01015   
01016   inline UpdateData& operator=(const UpdateData& from) {
01017     CopyFrom(from);
01018     return *this;
01019   }
01020   
01021   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01022     return _unknown_fields_;
01023   }
01024   
01025   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01026     return &_unknown_fields_;
01027   }
01028   
01029   static const ::google::protobuf::Descriptor* descriptor();
01030   static const UpdateData& default_instance();
01031   
01032   void Swap(UpdateData* other);
01033   
01034   // implements Message ----------------------------------------------
01035   
01036   UpdateData* New() const;
01037   void CopyFrom(const ::google::protobuf::Message& from);
01038   void MergeFrom(const ::google::protobuf::Message& from);
01039   void CopyFrom(const UpdateData& from);
01040   void MergeFrom(const UpdateData& from);
01041   void Clear();
01042   bool IsInitialized() const;
01043   
01044   int ByteSize() const;
01045   bool MergePartialFromCodedStream(
01046       ::google::protobuf::io::CodedInputStream* input);
01047   void SerializeWithCachedSizes(
01048       ::google::protobuf::io::CodedOutputStream* output) const;
01049   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01050   int GetCachedSize() const { return _cached_size_; }
01051   private:
01052   void SharedCtor();
01053   void SharedDtor();
01054   void SetCachedSize(int size) const;
01055   public:
01056   
01057   ::google::protobuf::Metadata GetMetadata() const;
01058   
01059   // nested types ----------------------------------------------------
01060   
01061   // accessors -------------------------------------------------------
01062   
01063   // required uint32 segment_id = 1;
01064   inline bool has_segment_id() const;
01065   inline void clear_segment_id();
01066   static const int kSegmentIdFieldNumber = 1;
01067   inline ::google::protobuf::uint32 segment_id() const;
01068   inline void set_segment_id(::google::protobuf::uint32 value);
01069   
01070   // required bool end_segment = 2;
01071   inline bool has_end_segment() const;
01072   inline void clear_end_segment();
01073   static const int kEndSegmentFieldNumber = 2;
01074   inline bool end_segment() const;
01075   inline void set_end_segment(bool value);
01076   
01077   // repeated .drizzled.message.UpdateRecord record = 3;
01078   inline int record_size() const;
01079   inline void clear_record();
01080   static const int kRecordFieldNumber = 3;
01081   inline const ::drizzled::message::UpdateRecord& record(int index) const;
01082   inline ::drizzled::message::UpdateRecord* mutable_record(int index);
01083   inline ::drizzled::message::UpdateRecord* add_record();
01084   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::UpdateRecord >&
01085       record() const;
01086   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::UpdateRecord >*
01087       mutable_record();
01088   
01089   // @@protoc_insertion_point(class_scope:drizzled.message.UpdateData)
01090  private:
01091   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01092   mutable int _cached_size_;
01093   
01094   ::google::protobuf::uint32 segment_id_;
01095   bool end_segment_;
01096   ::google::protobuf::RepeatedPtrField< ::drizzled::message::UpdateRecord > record_;
01097   friend void  protobuf_AddDesc_transaction_2eproto();
01098   friend void protobuf_AssignDesc_transaction_2eproto();
01099   friend void protobuf_ShutdownFile_transaction_2eproto();
01100   
01101   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
01102   
01103   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01104   inline bool _has_bit(int index) const {
01105     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01106   }
01107   inline void _set_bit(int index) {
01108     _has_bits_[index / 32] |= (1u << (index % 32));
01109   }
01110   inline void _clear_bit(int index) {
01111     _has_bits_[index / 32] &= ~(1u << (index % 32));
01112   }
01113   
01114   void InitAsDefaultInstance();
01115   static UpdateData* default_instance_;
01116 };
01117 // -------------------------------------------------------------------
01118 
01119 class DeleteRecord : public ::google::protobuf::Message {
01120  public:
01121   DeleteRecord();
01122   virtual ~DeleteRecord();
01123   
01124   DeleteRecord(const DeleteRecord& from);
01125   
01126   inline DeleteRecord& operator=(const DeleteRecord& from) {
01127     CopyFrom(from);
01128     return *this;
01129   }
01130   
01131   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01132     return _unknown_fields_;
01133   }
01134   
01135   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01136     return &_unknown_fields_;
01137   }
01138   
01139   static const ::google::protobuf::Descriptor* descriptor();
01140   static const DeleteRecord& default_instance();
01141   
01142   void Swap(DeleteRecord* other);
01143   
01144   // implements Message ----------------------------------------------
01145   
01146   DeleteRecord* New() const;
01147   void CopyFrom(const ::google::protobuf::Message& from);
01148   void MergeFrom(const ::google::protobuf::Message& from);
01149   void CopyFrom(const DeleteRecord& from);
01150   void MergeFrom(const DeleteRecord& from);
01151   void Clear();
01152   bool IsInitialized() const;
01153   
01154   int ByteSize() const;
01155   bool MergePartialFromCodedStream(
01156       ::google::protobuf::io::CodedInputStream* input);
01157   void SerializeWithCachedSizes(
01158       ::google::protobuf::io::CodedOutputStream* output) const;
01159   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01160   int GetCachedSize() const { return _cached_size_; }
01161   private:
01162   void SharedCtor();
01163   void SharedDtor();
01164   void SetCachedSize(int size) const;
01165   public:
01166   
01167   ::google::protobuf::Metadata GetMetadata() const;
01168   
01169   // nested types ----------------------------------------------------
01170   
01171   // accessors -------------------------------------------------------
01172   
01173   // repeated bytes key_value = 1;
01174   inline int key_value_size() const;
01175   inline void clear_key_value();
01176   static const int kKeyValueFieldNumber = 1;
01177   inline const ::std::string& key_value(int index) const;
01178   inline ::std::string* mutable_key_value(int index);
01179   inline void set_key_value(int index, const ::std::string& value);
01180   inline void set_key_value(int index, const char* value);
01181   inline void set_key_value(int index, const void* value, size_t size);
01182   inline ::std::string* add_key_value();
01183   inline void add_key_value(const ::std::string& value);
01184   inline void add_key_value(const char* value);
01185   inline void add_key_value(const void* value, size_t size);
01186   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& key_value() const;
01187   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_key_value();
01188   
01189   // @@protoc_insertion_point(class_scope:drizzled.message.DeleteRecord)
01190  private:
01191   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01192   mutable int _cached_size_;
01193   
01194   ::google::protobuf::RepeatedPtrField< ::std::string> key_value_;
01195   friend void  protobuf_AddDesc_transaction_2eproto();
01196   friend void protobuf_AssignDesc_transaction_2eproto();
01197   friend void protobuf_ShutdownFile_transaction_2eproto();
01198   
01199   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
01200   
01201   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01202   inline bool _has_bit(int index) const {
01203     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01204   }
01205   inline void _set_bit(int index) {
01206     _has_bits_[index / 32] |= (1u << (index % 32));
01207   }
01208   inline void _clear_bit(int index) {
01209     _has_bits_[index / 32] &= ~(1u << (index % 32));
01210   }
01211   
01212   void InitAsDefaultInstance();
01213   static DeleteRecord* default_instance_;
01214 };
01215 // -------------------------------------------------------------------
01216 
01217 class DeleteHeader : public ::google::protobuf::Message {
01218  public:
01219   DeleteHeader();
01220   virtual ~DeleteHeader();
01221   
01222   DeleteHeader(const DeleteHeader& from);
01223   
01224   inline DeleteHeader& operator=(const DeleteHeader& from) {
01225     CopyFrom(from);
01226     return *this;
01227   }
01228   
01229   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01230     return _unknown_fields_;
01231   }
01232   
01233   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01234     return &_unknown_fields_;
01235   }
01236   
01237   static const ::google::protobuf::Descriptor* descriptor();
01238   static const DeleteHeader& default_instance();
01239   
01240   void Swap(DeleteHeader* other);
01241   
01242   // implements Message ----------------------------------------------
01243   
01244   DeleteHeader* New() const;
01245   void CopyFrom(const ::google::protobuf::Message& from);
01246   void MergeFrom(const ::google::protobuf::Message& from);
01247   void CopyFrom(const DeleteHeader& from);
01248   void MergeFrom(const DeleteHeader& from);
01249   void Clear();
01250   bool IsInitialized() const;
01251   
01252   int ByteSize() const;
01253   bool MergePartialFromCodedStream(
01254       ::google::protobuf::io::CodedInputStream* input);
01255   void SerializeWithCachedSizes(
01256       ::google::protobuf::io::CodedOutputStream* output) const;
01257   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01258   int GetCachedSize() const { return _cached_size_; }
01259   private:
01260   void SharedCtor();
01261   void SharedDtor();
01262   void SetCachedSize(int size) const;
01263   public:
01264   
01265   ::google::protobuf::Metadata GetMetadata() const;
01266   
01267   // nested types ----------------------------------------------------
01268   
01269   // accessors -------------------------------------------------------
01270   
01271   // required .drizzled.message.TableMetadata table_metadata = 1;
01272   inline bool has_table_metadata() const;
01273   inline void clear_table_metadata();
01274   static const int kTableMetadataFieldNumber = 1;
01275   inline const ::drizzled::message::TableMetadata& table_metadata() const;
01276   inline ::drizzled::message::TableMetadata* mutable_table_metadata();
01277   
01278   // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
01279   inline int key_field_metadata_size() const;
01280   inline void clear_key_field_metadata();
01281   static const int kKeyFieldMetadataFieldNumber = 2;
01282   inline const ::drizzled::message::FieldMetadata& key_field_metadata(int index) const;
01283   inline ::drizzled::message::FieldMetadata* mutable_key_field_metadata(int index);
01284   inline ::drizzled::message::FieldMetadata* add_key_field_metadata();
01285   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
01286       key_field_metadata() const;
01287   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
01288       mutable_key_field_metadata();
01289   
01290   // @@protoc_insertion_point(class_scope:drizzled.message.DeleteHeader)
01291  private:
01292   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01293   mutable int _cached_size_;
01294   
01295   ::drizzled::message::TableMetadata* table_metadata_;
01296   ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata > key_field_metadata_;
01297   friend void  protobuf_AddDesc_transaction_2eproto();
01298   friend void protobuf_AssignDesc_transaction_2eproto();
01299   friend void protobuf_ShutdownFile_transaction_2eproto();
01300   
01301   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
01302   
01303   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01304   inline bool _has_bit(int index) const {
01305     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01306   }
01307   inline void _set_bit(int index) {
01308     _has_bits_[index / 32] |= (1u << (index % 32));
01309   }
01310   inline void _clear_bit(int index) {
01311     _has_bits_[index / 32] &= ~(1u << (index % 32));
01312   }
01313   
01314   void InitAsDefaultInstance();
01315   static DeleteHeader* default_instance_;
01316 };
01317 // -------------------------------------------------------------------
01318 
01319 class DeleteData : public ::google::protobuf::Message {
01320  public:
01321   DeleteData();
01322   virtual ~DeleteData();
01323   
01324   DeleteData(const DeleteData& from);
01325   
01326   inline DeleteData& operator=(const DeleteData& from) {
01327     CopyFrom(from);
01328     return *this;
01329   }
01330   
01331   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01332     return _unknown_fields_;
01333   }
01334   
01335   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01336     return &_unknown_fields_;
01337   }
01338   
01339   static const ::google::protobuf::Descriptor* descriptor();
01340   static const DeleteData& default_instance();
01341   
01342   void Swap(DeleteData* other);
01343   
01344   // implements Message ----------------------------------------------
01345   
01346   DeleteData* New() const;
01347   void CopyFrom(const ::google::protobuf::Message& from);
01348   void MergeFrom(const ::google::protobuf::Message& from);
01349   void CopyFrom(const DeleteData& from);
01350   void MergeFrom(const DeleteData& from);
01351   void Clear();
01352   bool IsInitialized() const;
01353   
01354   int ByteSize() const;
01355   bool MergePartialFromCodedStream(
01356       ::google::protobuf::io::CodedInputStream* input);
01357   void SerializeWithCachedSizes(
01358       ::google::protobuf::io::CodedOutputStream* output) const;
01359   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01360   int GetCachedSize() const { return _cached_size_; }
01361   private:
01362   void SharedCtor();
01363   void SharedDtor();
01364   void SetCachedSize(int size) const;
01365   public:
01366   
01367   ::google::protobuf::Metadata GetMetadata() const;
01368   
01369   // nested types ----------------------------------------------------
01370   
01371   // accessors -------------------------------------------------------
01372   
01373   // required uint32 segment_id = 1;
01374   inline bool has_segment_id() const;
01375   inline void clear_segment_id();
01376   static const int kSegmentIdFieldNumber = 1;
01377   inline ::google::protobuf::uint32 segment_id() const;
01378   inline void set_segment_id(::google::protobuf::uint32 value);
01379   
01380   // required bool end_segment = 2;
01381   inline bool has_end_segment() const;
01382   inline void clear_end_segment();
01383   static const int kEndSegmentFieldNumber = 2;
01384   inline bool end_segment() const;
01385   inline void set_end_segment(bool value);
01386   
01387   // repeated .drizzled.message.DeleteRecord record = 3;
01388   inline int record_size() const;
01389   inline void clear_record();
01390   static const int kRecordFieldNumber = 3;
01391   inline const ::drizzled::message::DeleteRecord& record(int index) const;
01392   inline ::drizzled::message::DeleteRecord* mutable_record(int index);
01393   inline ::drizzled::message::DeleteRecord* add_record();
01394   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::DeleteRecord >&
01395       record() const;
01396   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::DeleteRecord >*
01397       mutable_record();
01398   
01399   // @@protoc_insertion_point(class_scope:drizzled.message.DeleteData)
01400  private:
01401   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01402   mutable int _cached_size_;
01403   
01404   ::google::protobuf::uint32 segment_id_;
01405   bool end_segment_;
01406   ::google::protobuf::RepeatedPtrField< ::drizzled::message::DeleteRecord > record_;
01407   friend void  protobuf_AddDesc_transaction_2eproto();
01408   friend void protobuf_AssignDesc_transaction_2eproto();
01409   friend void protobuf_ShutdownFile_transaction_2eproto();
01410   
01411   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
01412   
01413   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01414   inline bool _has_bit(int index) const {
01415     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01416   }
01417   inline void _set_bit(int index) {
01418     _has_bits_[index / 32] |= (1u << (index % 32));
01419   }
01420   inline void _clear_bit(int index) {
01421     _has_bits_[index / 32] &= ~(1u << (index % 32));
01422   }
01423   
01424   void InitAsDefaultInstance();
01425   static DeleteData* default_instance_;
01426 };
01427 // -------------------------------------------------------------------
01428 
01429 class TruncateTableStatement : public ::google::protobuf::Message {
01430  public:
01431   TruncateTableStatement();
01432   virtual ~TruncateTableStatement();
01433   
01434   TruncateTableStatement(const TruncateTableStatement& from);
01435   
01436   inline TruncateTableStatement& operator=(const TruncateTableStatement& from) {
01437     CopyFrom(from);
01438     return *this;
01439   }
01440   
01441   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01442     return _unknown_fields_;
01443   }
01444   
01445   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01446     return &_unknown_fields_;
01447   }
01448   
01449   static const ::google::protobuf::Descriptor* descriptor();
01450   static const TruncateTableStatement& default_instance();
01451   
01452   void Swap(TruncateTableStatement* other);
01453   
01454   // implements Message ----------------------------------------------
01455   
01456   TruncateTableStatement* New() const;
01457   void CopyFrom(const ::google::protobuf::Message& from);
01458   void MergeFrom(const ::google::protobuf::Message& from);
01459   void CopyFrom(const TruncateTableStatement& from);
01460   void MergeFrom(const TruncateTableStatement& from);
01461   void Clear();
01462   bool IsInitialized() const;
01463   
01464   int ByteSize() const;
01465   bool MergePartialFromCodedStream(
01466       ::google::protobuf::io::CodedInputStream* input);
01467   void SerializeWithCachedSizes(
01468       ::google::protobuf::io::CodedOutputStream* output) const;
01469   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01470   int GetCachedSize() const { return _cached_size_; }
01471   private:
01472   void SharedCtor();
01473   void SharedDtor();
01474   void SetCachedSize(int size) const;
01475   public:
01476   
01477   ::google::protobuf::Metadata GetMetadata() const;
01478   
01479   // nested types ----------------------------------------------------
01480   
01481   // accessors -------------------------------------------------------
01482   
01483   // required .drizzled.message.TableMetadata table_metadata = 1;
01484   inline bool has_table_metadata() const;
01485   inline void clear_table_metadata();
01486   static const int kTableMetadataFieldNumber = 1;
01487   inline const ::drizzled::message::TableMetadata& table_metadata() const;
01488   inline ::drizzled::message::TableMetadata* mutable_table_metadata();
01489   
01490   // @@protoc_insertion_point(class_scope:drizzled.message.TruncateTableStatement)
01491  private:
01492   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01493   mutable int _cached_size_;
01494   
01495   ::drizzled::message::TableMetadata* table_metadata_;
01496   friend void  protobuf_AddDesc_transaction_2eproto();
01497   friend void protobuf_AssignDesc_transaction_2eproto();
01498   friend void protobuf_ShutdownFile_transaction_2eproto();
01499   
01500   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
01501   
01502   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01503   inline bool _has_bit(int index) const {
01504     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01505   }
01506   inline void _set_bit(int index) {
01507     _has_bits_[index / 32] |= (1u << (index % 32));
01508   }
01509   inline void _clear_bit(int index) {
01510     _has_bits_[index / 32] &= ~(1u << (index % 32));
01511   }
01512   
01513   void InitAsDefaultInstance();
01514   static TruncateTableStatement* default_instance_;
01515 };
01516 // -------------------------------------------------------------------
01517 
01518 class CreateSchemaStatement : public ::google::protobuf::Message {
01519  public:
01520   CreateSchemaStatement();
01521   virtual ~CreateSchemaStatement();
01522   
01523   CreateSchemaStatement(const CreateSchemaStatement& from);
01524   
01525   inline CreateSchemaStatement& operator=(const CreateSchemaStatement& from) {
01526     CopyFrom(from);
01527     return *this;
01528   }
01529   
01530   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01531     return _unknown_fields_;
01532   }
01533   
01534   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01535     return &_unknown_fields_;
01536   }
01537   
01538   static const ::google::protobuf::Descriptor* descriptor();
01539   static const CreateSchemaStatement& default_instance();
01540   
01541   void Swap(CreateSchemaStatement* other);
01542   
01543   // implements Message ----------------------------------------------
01544   
01545   CreateSchemaStatement* New() const;
01546   void CopyFrom(const ::google::protobuf::Message& from);
01547   void MergeFrom(const ::google::protobuf::Message& from);
01548   void CopyFrom(const CreateSchemaStatement& from);
01549   void MergeFrom(const CreateSchemaStatement& from);
01550   void Clear();
01551   bool IsInitialized() const;
01552   
01553   int ByteSize() const;
01554   bool MergePartialFromCodedStream(
01555       ::google::protobuf::io::CodedInputStream* input);
01556   void SerializeWithCachedSizes(
01557       ::google::protobuf::io::CodedOutputStream* output) const;
01558   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01559   int GetCachedSize() const { return _cached_size_; }
01560   private:
01561   void SharedCtor();
01562   void SharedDtor();
01563   void SetCachedSize(int size) const;
01564   public:
01565   
01566   ::google::protobuf::Metadata GetMetadata() const;
01567   
01568   // nested types ----------------------------------------------------
01569   
01570   // accessors -------------------------------------------------------
01571   
01572   // required .drizzled.message.Schema schema = 1;
01573   inline bool has_schema() const;
01574   inline void clear_schema();
01575   static const int kSchemaFieldNumber = 1;
01576   inline const ::drizzled::message::Schema& schema() const;
01577   inline ::drizzled::message::Schema* mutable_schema();
01578   
01579   // @@protoc_insertion_point(class_scope:drizzled.message.CreateSchemaStatement)
01580  private:
01581   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01582   mutable int _cached_size_;
01583   
01584   ::drizzled::message::Schema* schema_;
01585   friend void  protobuf_AddDesc_transaction_2eproto();
01586   friend void protobuf_AssignDesc_transaction_2eproto();
01587   friend void protobuf_ShutdownFile_transaction_2eproto();
01588   
01589   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
01590   
01591   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01592   inline bool _has_bit(int index) const {
01593     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01594   }
01595   inline void _set_bit(int index) {
01596     _has_bits_[index / 32] |= (1u << (index % 32));
01597   }
01598   inline void _clear_bit(int index) {
01599     _has_bits_[index / 32] &= ~(1u << (index % 32));
01600   }
01601   
01602   void InitAsDefaultInstance();
01603   static CreateSchemaStatement* default_instance_;
01604 };
01605 // -------------------------------------------------------------------
01606 
01607 class AlterSchemaStatement : public ::google::protobuf::Message {
01608  public:
01609   AlterSchemaStatement();
01610   virtual ~AlterSchemaStatement();
01611   
01612   AlterSchemaStatement(const AlterSchemaStatement& from);
01613   
01614   inline AlterSchemaStatement& operator=(const AlterSchemaStatement& from) {
01615     CopyFrom(from);
01616     return *this;
01617   }
01618   
01619   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01620     return _unknown_fields_;
01621   }
01622   
01623   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01624     return &_unknown_fields_;
01625   }
01626   
01627   static const ::google::protobuf::Descriptor* descriptor();
01628   static const AlterSchemaStatement& default_instance();
01629   
01630   void Swap(AlterSchemaStatement* other);
01631   
01632   // implements Message ----------------------------------------------
01633   
01634   AlterSchemaStatement* New() const;
01635   void CopyFrom(const ::google::protobuf::Message& from);
01636   void MergeFrom(const ::google::protobuf::Message& from);
01637   void CopyFrom(const AlterSchemaStatement& from);
01638   void MergeFrom(const AlterSchemaStatement& from);
01639   void Clear();
01640   bool IsInitialized() const;
01641   
01642   int ByteSize() const;
01643   bool MergePartialFromCodedStream(
01644       ::google::protobuf::io::CodedInputStream* input);
01645   void SerializeWithCachedSizes(
01646       ::google::protobuf::io::CodedOutputStream* output) const;
01647   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01648   int GetCachedSize() const { return _cached_size_; }
01649   private:
01650   void SharedCtor();
01651   void SharedDtor();
01652   void SetCachedSize(int size) const;
01653   public:
01654   
01655   ::google::protobuf::Metadata GetMetadata() const;
01656   
01657   // nested types ----------------------------------------------------
01658   
01659   // accessors -------------------------------------------------------
01660   
01661   // required .drizzled.message.Schema before = 1;
01662   inline bool has_before() const;
01663   inline void clear_before();
01664   static const int kBeforeFieldNumber = 1;
01665   inline const ::drizzled::message::Schema& before() const;
01666   inline ::drizzled::message::Schema* mutable_before();
01667   
01668   // required .drizzled.message.Schema after = 2;
01669   inline bool has_after() const;
01670   inline void clear_after();
01671   static const int kAfterFieldNumber = 2;
01672   inline const ::drizzled::message::Schema& after() const;
01673   inline ::drizzled::message::Schema* mutable_after();
01674   
01675   // @@protoc_insertion_point(class_scope:drizzled.message.AlterSchemaStatement)
01676  private:
01677   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01678   mutable int _cached_size_;
01679   
01680   ::drizzled::message::Schema* before_;
01681   ::drizzled::message::Schema* after_;
01682   friend void  protobuf_AddDesc_transaction_2eproto();
01683   friend void protobuf_AssignDesc_transaction_2eproto();
01684   friend void protobuf_ShutdownFile_transaction_2eproto();
01685   
01686   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
01687   
01688   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01689   inline bool _has_bit(int index) const {
01690     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01691   }
01692   inline void _set_bit(int index) {
01693     _has_bits_[index / 32] |= (1u << (index % 32));
01694   }
01695   inline void _clear_bit(int index) {
01696     _has_bits_[index / 32] &= ~(1u << (index % 32));
01697   }
01698   
01699   void InitAsDefaultInstance();
01700   static AlterSchemaStatement* default_instance_;
01701 };
01702 // -------------------------------------------------------------------
01703 
01704 class DropSchemaStatement : public ::google::protobuf::Message {
01705  public:
01706   DropSchemaStatement();
01707   virtual ~DropSchemaStatement();
01708   
01709   DropSchemaStatement(const DropSchemaStatement& from);
01710   
01711   inline DropSchemaStatement& operator=(const DropSchemaStatement& from) {
01712     CopyFrom(from);
01713     return *this;
01714   }
01715   
01716   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01717     return _unknown_fields_;
01718   }
01719   
01720   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01721     return &_unknown_fields_;
01722   }
01723   
01724   static const ::google::protobuf::Descriptor* descriptor();
01725   static const DropSchemaStatement& default_instance();
01726   
01727   void Swap(DropSchemaStatement* other);
01728   
01729   // implements Message ----------------------------------------------
01730   
01731   DropSchemaStatement* New() const;
01732   void CopyFrom(const ::google::protobuf::Message& from);
01733   void MergeFrom(const ::google::protobuf::Message& from);
01734   void CopyFrom(const DropSchemaStatement& from);
01735   void MergeFrom(const DropSchemaStatement& from);
01736   void Clear();
01737   bool IsInitialized() const;
01738   
01739   int ByteSize() const;
01740   bool MergePartialFromCodedStream(
01741       ::google::protobuf::io::CodedInputStream* input);
01742   void SerializeWithCachedSizes(
01743       ::google::protobuf::io::CodedOutputStream* output) const;
01744   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01745   int GetCachedSize() const { return _cached_size_; }
01746   private:
01747   void SharedCtor();
01748   void SharedDtor();
01749   void SetCachedSize(int size) const;
01750   public:
01751   
01752   ::google::protobuf::Metadata GetMetadata() const;
01753   
01754   // nested types ----------------------------------------------------
01755   
01756   // accessors -------------------------------------------------------
01757   
01758   // required string schema_name = 1;
01759   inline bool has_schema_name() const;
01760   inline void clear_schema_name();
01761   static const int kSchemaNameFieldNumber = 1;
01762   inline const ::std::string& schema_name() const;
01763   inline void set_schema_name(const ::std::string& value);
01764   inline void set_schema_name(const char* value);
01765   inline void set_schema_name(const char* value, size_t size);
01766   inline ::std::string* mutable_schema_name();
01767   
01768   // optional string catalog_name = 2;
01769   inline bool has_catalog_name() const;
01770   inline void clear_catalog_name();
01771   static const int kCatalogNameFieldNumber = 2;
01772   inline const ::std::string& catalog_name() const;
01773   inline void set_catalog_name(const ::std::string& value);
01774   inline void set_catalog_name(const char* value);
01775   inline void set_catalog_name(const char* value, size_t size);
01776   inline ::std::string* mutable_catalog_name();
01777   
01778   // @@protoc_insertion_point(class_scope:drizzled.message.DropSchemaStatement)
01779  private:
01780   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01781   mutable int _cached_size_;
01782   
01783   ::std::string* schema_name_;
01784   static const ::std::string _default_schema_name_;
01785   ::std::string* catalog_name_;
01786   static const ::std::string _default_catalog_name_;
01787   friend void  protobuf_AddDesc_transaction_2eproto();
01788   friend void protobuf_AssignDesc_transaction_2eproto();
01789   friend void protobuf_ShutdownFile_transaction_2eproto();
01790   
01791   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
01792   
01793   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01794   inline bool _has_bit(int index) const {
01795     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01796   }
01797   inline void _set_bit(int index) {
01798     _has_bits_[index / 32] |= (1u << (index % 32));
01799   }
01800   inline void _clear_bit(int index) {
01801     _has_bits_[index / 32] &= ~(1u << (index % 32));
01802   }
01803   
01804   void InitAsDefaultInstance();
01805   static DropSchemaStatement* default_instance_;
01806 };
01807 // -------------------------------------------------------------------
01808 
01809 class CreateTableStatement : public ::google::protobuf::Message {
01810  public:
01811   CreateTableStatement();
01812   virtual ~CreateTableStatement();
01813   
01814   CreateTableStatement(const CreateTableStatement& from);
01815   
01816   inline CreateTableStatement& operator=(const CreateTableStatement& from) {
01817     CopyFrom(from);
01818     return *this;
01819   }
01820   
01821   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01822     return _unknown_fields_;
01823   }
01824   
01825   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01826     return &_unknown_fields_;
01827   }
01828   
01829   static const ::google::protobuf::Descriptor* descriptor();
01830   static const CreateTableStatement& default_instance();
01831   
01832   void Swap(CreateTableStatement* other);
01833   
01834   // implements Message ----------------------------------------------
01835   
01836   CreateTableStatement* New() const;
01837   void CopyFrom(const ::google::protobuf::Message& from);
01838   void MergeFrom(const ::google::protobuf::Message& from);
01839   void CopyFrom(const CreateTableStatement& from);
01840   void MergeFrom(const CreateTableStatement& from);
01841   void Clear();
01842   bool IsInitialized() const;
01843   
01844   int ByteSize() const;
01845   bool MergePartialFromCodedStream(
01846       ::google::protobuf::io::CodedInputStream* input);
01847   void SerializeWithCachedSizes(
01848       ::google::protobuf::io::CodedOutputStream* output) const;
01849   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01850   int GetCachedSize() const { return _cached_size_; }
01851   private:
01852   void SharedCtor();
01853   void SharedDtor();
01854   void SetCachedSize(int size) const;
01855   public:
01856   
01857   ::google::protobuf::Metadata GetMetadata() const;
01858   
01859   // nested types ----------------------------------------------------
01860   
01861   // accessors -------------------------------------------------------
01862   
01863   // required .drizzled.message.Table table = 1;
01864   inline bool has_table() const;
01865   inline void clear_table();
01866   static const int kTableFieldNumber = 1;
01867   inline const ::drizzled::message::Table& table() const;
01868   inline ::drizzled::message::Table* mutable_table();
01869   
01870   // @@protoc_insertion_point(class_scope:drizzled.message.CreateTableStatement)
01871  private:
01872   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01873   mutable int _cached_size_;
01874   
01875   ::drizzled::message::Table* table_;
01876   friend void  protobuf_AddDesc_transaction_2eproto();
01877   friend void protobuf_AssignDesc_transaction_2eproto();
01878   friend void protobuf_ShutdownFile_transaction_2eproto();
01879   
01880   ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
01881   
01882   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01883   inline bool _has_bit(int index) const {
01884     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01885   }
01886   inline void _set_bit(int index) {
01887     _has_bits_[index / 32] |= (1u << (index % 32));
01888   }
01889   inline void _clear_bit(int index) {
01890     _has_bits_[index / 32] &= ~(1u << (index % 32));
01891   }
01892   
01893   void InitAsDefaultInstance();
01894   static CreateTableStatement* default_instance_;
01895 };
01896 // -------------------------------------------------------------------
01897 
01898 class AlterTableStatement : public ::google::protobuf::Message {
01899  public:
01900   AlterTableStatement();
01901   virtual ~AlterTableStatement();
01902   
01903   AlterTableStatement(const AlterTableStatement& from);
01904   
01905   inline AlterTableStatement& operator=(const AlterTableStatement& from) {
01906     CopyFrom(from);
01907     return *this;
01908   }
01909   
01910   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
01911     return _unknown_fields_;
01912   }
01913   
01914   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
01915     return &_unknown_fields_;
01916   }
01917   
01918   static const ::google::protobuf::Descriptor* descriptor();
01919   static const AlterTableStatement& default_instance();
01920   
01921   void Swap(AlterTableStatement* other);
01922   
01923   // implements Message ----------------------------------------------
01924   
01925   AlterTableStatement* New() const;
01926   void CopyFrom(const ::google::protobuf::Message& from);
01927   void MergeFrom(const ::google::protobuf::Message& from);
01928   void CopyFrom(const AlterTableStatement& from);
01929   void MergeFrom(const AlterTableStatement& from);
01930   void Clear();
01931   bool IsInitialized() const;
01932   
01933   int ByteSize() const;
01934   bool MergePartialFromCodedStream(
01935       ::google::protobuf::io::CodedInputStream* input);
01936   void SerializeWithCachedSizes(
01937       ::google::protobuf::io::CodedOutputStream* output) const;
01938   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
01939   int GetCachedSize() const { return _cached_size_; }
01940   private:
01941   void SharedCtor();
01942   void SharedDtor();
01943   void SetCachedSize(int size) const;
01944   public:
01945   
01946   ::google::protobuf::Metadata GetMetadata() const;
01947   
01948   // nested types ----------------------------------------------------
01949   
01950   // accessors -------------------------------------------------------
01951   
01952   // required .drizzled.message.Table before = 1;
01953   inline bool has_before() const;
01954   inline void clear_before();
01955   static const int kBeforeFieldNumber = 1;
01956   inline const ::drizzled::message::Table& before() const;
01957   inline ::drizzled::message::Table* mutable_before();
01958   
01959   // required .drizzled.message.Table after = 2;
01960   inline bool has_after() const;
01961   inline void clear_after();
01962   static const int kAfterFieldNumber = 2;
01963   inline const ::drizzled::message::Table& after() const;
01964   inline ::drizzled::message::Table* mutable_after();
01965   
01966   // @@protoc_insertion_point(class_scope:drizzled.message.AlterTableStatement)
01967  private:
01968   ::google::protobuf::UnknownFieldSet _unknown_fields_;
01969   mutable int _cached_size_;
01970   
01971   ::drizzled::message::Table* before_;
01972   ::drizzled::message::Table* after_;
01973   friend void  protobuf_AddDesc_transaction_2eproto();
01974   friend void protobuf_AssignDesc_transaction_2eproto();
01975   friend void protobuf_ShutdownFile_transaction_2eproto();
01976   
01977   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
01978   
01979   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
01980   inline bool _has_bit(int index) const {
01981     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
01982   }
01983   inline void _set_bit(int index) {
01984     _has_bits_[index / 32] |= (1u << (index % 32));
01985   }
01986   inline void _clear_bit(int index) {
01987     _has_bits_[index / 32] &= ~(1u << (index % 32));
01988   }
01989   
01990   void InitAsDefaultInstance();
01991   static AlterTableStatement* default_instance_;
01992 };
01993 // -------------------------------------------------------------------
01994 
01995 class DropTableStatement : public ::google::protobuf::Message {
01996  public:
01997   DropTableStatement();
01998   virtual ~DropTableStatement();
01999   
02000   DropTableStatement(const DropTableStatement& from);
02001   
02002   inline DropTableStatement& operator=(const DropTableStatement& from) {
02003     CopyFrom(from);
02004     return *this;
02005   }
02006   
02007   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
02008     return _unknown_fields_;
02009   }
02010   
02011   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
02012     return &_unknown_fields_;
02013   }
02014   
02015   static const ::google::protobuf::Descriptor* descriptor();
02016   static const DropTableStatement& default_instance();
02017   
02018   void Swap(DropTableStatement* other);
02019   
02020   // implements Message ----------------------------------------------
02021   
02022   DropTableStatement* New() const;
02023   void CopyFrom(const ::google::protobuf::Message& from);
02024   void MergeFrom(const ::google::protobuf::Message& from);
02025   void CopyFrom(const DropTableStatement& from);
02026   void MergeFrom(const DropTableStatement& from);
02027   void Clear();
02028   bool IsInitialized() const;
02029   
02030   int ByteSize() const;
02031   bool MergePartialFromCodedStream(
02032       ::google::protobuf::io::CodedInputStream* input);
02033   void SerializeWithCachedSizes(
02034       ::google::protobuf::io::CodedOutputStream* output) const;
02035   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
02036   int GetCachedSize() const { return _cached_size_; }
02037   private:
02038   void SharedCtor();
02039   void SharedDtor();
02040   void SetCachedSize(int size) const;
02041   public:
02042   
02043   ::google::protobuf::Metadata GetMetadata() const;
02044   
02045   // nested types ----------------------------------------------------
02046   
02047   // accessors -------------------------------------------------------
02048   
02049   // required .drizzled.message.TableMetadata table_metadata = 1;
02050   inline bool has_table_metadata() const;
02051   inline void clear_table_metadata();
02052   static const int kTableMetadataFieldNumber = 1;
02053   inline const ::drizzled::message::TableMetadata& table_metadata() const;
02054   inline ::drizzled::message::TableMetadata* mutable_table_metadata();
02055   
02056   // optional bool if_exists_clause = 2;
02057   inline bool has_if_exists_clause() const;
02058   inline void clear_if_exists_clause();
02059   static const int kIfExistsClauseFieldNumber = 2;
02060   inline bool if_exists_clause() const;
02061   inline void set_if_exists_clause(bool value);
02062   
02063   // @@protoc_insertion_point(class_scope:drizzled.message.DropTableStatement)
02064  private:
02065   ::google::protobuf::UnknownFieldSet _unknown_fields_;
02066   mutable int _cached_size_;
02067   
02068   ::drizzled::message::TableMetadata* table_metadata_;
02069   bool if_exists_clause_;
02070   friend void  protobuf_AddDesc_transaction_2eproto();
02071   friend void protobuf_AssignDesc_transaction_2eproto();
02072   friend void protobuf_ShutdownFile_transaction_2eproto();
02073   
02074   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
02075   
02076   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
02077   inline bool _has_bit(int index) const {
02078     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
02079   }
02080   inline void _set_bit(int index) {
02081     _has_bits_[index / 32] |= (1u << (index % 32));
02082   }
02083   inline void _clear_bit(int index) {
02084     _has_bits_[index / 32] &= ~(1u << (index % 32));
02085   }
02086   
02087   void InitAsDefaultInstance();
02088   static DropTableStatement* default_instance_;
02089 };
02090 // -------------------------------------------------------------------
02091 
02092 class SetVariableStatement : public ::google::protobuf::Message {
02093  public:
02094   SetVariableStatement();
02095   virtual ~SetVariableStatement();
02096   
02097   SetVariableStatement(const SetVariableStatement& from);
02098   
02099   inline SetVariableStatement& operator=(const SetVariableStatement& from) {
02100     CopyFrom(from);
02101     return *this;
02102   }
02103   
02104   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
02105     return _unknown_fields_;
02106   }
02107   
02108   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
02109     return &_unknown_fields_;
02110   }
02111   
02112   static const ::google::protobuf::Descriptor* descriptor();
02113   static const SetVariableStatement& default_instance();
02114   
02115   void Swap(SetVariableStatement* other);
02116   
02117   // implements Message ----------------------------------------------
02118   
02119   SetVariableStatement* New() const;
02120   void CopyFrom(const ::google::protobuf::Message& from);
02121   void MergeFrom(const ::google::protobuf::Message& from);
02122   void CopyFrom(const SetVariableStatement& from);
02123   void MergeFrom(const SetVariableStatement& from);
02124   void Clear();
02125   bool IsInitialized() const;
02126   
02127   int ByteSize() const;
02128   bool MergePartialFromCodedStream(
02129       ::google::protobuf::io::CodedInputStream* input);
02130   void SerializeWithCachedSizes(
02131       ::google::protobuf::io::CodedOutputStream* output) const;
02132   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
02133   int GetCachedSize() const { return _cached_size_; }
02134   private:
02135   void SharedCtor();
02136   void SharedDtor();
02137   void SetCachedSize(int size) const;
02138   public:
02139   
02140   ::google::protobuf::Metadata GetMetadata() const;
02141   
02142   // nested types ----------------------------------------------------
02143   
02144   // accessors -------------------------------------------------------
02145   
02146   // required .drizzled.message.FieldMetadata variable_metadata = 1;
02147   inline bool has_variable_metadata() const;
02148   inline void clear_variable_metadata();
02149   static const int kVariableMetadataFieldNumber = 1;
02150   inline const ::drizzled::message::FieldMetadata& variable_metadata() const;
02151   inline ::drizzled::message::FieldMetadata* mutable_variable_metadata();
02152   
02153   // required bytes variable_value = 2;
02154   inline bool has_variable_value() const;
02155   inline void clear_variable_value();
02156   static const int kVariableValueFieldNumber = 2;
02157   inline const ::std::string& variable_value() const;
02158   inline void set_variable_value(const ::std::string& value);
02159   inline void set_variable_value(const char* value);
02160   inline void set_variable_value(const void* value, size_t size);
02161   inline ::std::string* mutable_variable_value();
02162   
02163   // @@protoc_insertion_point(class_scope:drizzled.message.SetVariableStatement)
02164  private:
02165   ::google::protobuf::UnknownFieldSet _unknown_fields_;
02166   mutable int _cached_size_;
02167   
02168   ::drizzled::message::FieldMetadata* variable_metadata_;
02169   ::std::string* variable_value_;
02170   static const ::std::string _default_variable_value_;
02171   friend void  protobuf_AddDesc_transaction_2eproto();
02172   friend void protobuf_AssignDesc_transaction_2eproto();
02173   friend void protobuf_ShutdownFile_transaction_2eproto();
02174   
02175   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
02176   
02177   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
02178   inline bool _has_bit(int index) const {
02179     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
02180   }
02181   inline void _set_bit(int index) {
02182     _has_bits_[index / 32] |= (1u << (index % 32));
02183   }
02184   inline void _clear_bit(int index) {
02185     _has_bits_[index / 32] &= ~(1u << (index % 32));
02186   }
02187   
02188   void InitAsDefaultInstance();
02189   static SetVariableStatement* default_instance_;
02190 };
02191 // -------------------------------------------------------------------
02192 
02193 class Statement : public ::google::protobuf::Message {
02194  public:
02195   Statement();
02196   virtual ~Statement();
02197   
02198   Statement(const Statement& from);
02199   
02200   inline Statement& operator=(const Statement& from) {
02201     CopyFrom(from);
02202     return *this;
02203   }
02204   
02205   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
02206     return _unknown_fields_;
02207   }
02208   
02209   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
02210     return &_unknown_fields_;
02211   }
02212   
02213   static const ::google::protobuf::Descriptor* descriptor();
02214   static const Statement& default_instance();
02215   
02216   void Swap(Statement* other);
02217   
02218   // implements Message ----------------------------------------------
02219   
02220   Statement* New() const;
02221   void CopyFrom(const ::google::protobuf::Message& from);
02222   void MergeFrom(const ::google::protobuf::Message& from);
02223   void CopyFrom(const Statement& from);
02224   void MergeFrom(const Statement& from);
02225   void Clear();
02226   bool IsInitialized() const;
02227   
02228   int ByteSize() const;
02229   bool MergePartialFromCodedStream(
02230       ::google::protobuf::io::CodedInputStream* input);
02231   void SerializeWithCachedSizes(
02232       ::google::protobuf::io::CodedOutputStream* output) const;
02233   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
02234   int GetCachedSize() const { return _cached_size_; }
02235   private:
02236   void SharedCtor();
02237   void SharedDtor();
02238   void SetCachedSize(int size) const;
02239   public:
02240   
02241   ::google::protobuf::Metadata GetMetadata() const;
02242   
02243   // nested types ----------------------------------------------------
02244   
02245   typedef Statement_Type Type;
02246   static const Type ROLLBACK = Statement_Type_ROLLBACK;
02247   static const Type INSERT = Statement_Type_INSERT;
02248   static const Type DELETE = Statement_Type_DELETE;
02249   static const Type UPDATE = Statement_Type_UPDATE;
02250   static const Type TRUNCATE_TABLE = Statement_Type_TRUNCATE_TABLE;
02251   static const Type CREATE_SCHEMA = Statement_Type_CREATE_SCHEMA;
02252   static const Type ALTER_SCHEMA = Statement_Type_ALTER_SCHEMA;
02253   static const Type DROP_SCHEMA = Statement_Type_DROP_SCHEMA;
02254   static const Type CREATE_TABLE = Statement_Type_CREATE_TABLE;
02255   static const Type ALTER_TABLE = Statement_Type_ALTER_TABLE;
02256   static const Type DROP_TABLE = Statement_Type_DROP_TABLE;
02257   static const Type ROLLBACK_STATEMENT = Statement_Type_ROLLBACK_STATEMENT;
02258   static const Type SET_VARIABLE = Statement_Type_SET_VARIABLE;
02259   static const Type RAW_SQL = Statement_Type_RAW_SQL;
02260   static inline bool Type_IsValid(int value) {
02261     return Statement_Type_IsValid(value);
02262   }
02263   static const Type Type_MIN =
02264     Statement_Type_Type_MIN;
02265   static const Type Type_MAX =
02266     Statement_Type_Type_MAX;
02267   static const int Type_ARRAYSIZE =
02268     Statement_Type_Type_ARRAYSIZE;
02269   static inline const ::google::protobuf::EnumDescriptor*
02270   Type_descriptor() {
02271     return Statement_Type_descriptor();
02272   }
02273   static inline const ::std::string& Type_Name(Type value) {
02274     return Statement_Type_Name(value);
02275   }
02276   static inline bool Type_Parse(const ::std::string& name,
02277       Type* value) {
02278     return Statement_Type_Parse(name, value);
02279   }
02280   
02281   // accessors -------------------------------------------------------
02282   
02283   // required .drizzled.message.Statement.Type type = 1;
02284   inline bool has_type() const;
02285   inline void clear_type();
02286   static const int kTypeFieldNumber = 1;
02287   inline ::drizzled::message::Statement_Type type() const;
02288   inline void set_type(::drizzled::message::Statement_Type value);
02289   
02290   // required uint64 start_timestamp = 2;
02291   inline bool has_start_timestamp() const;
02292   inline void clear_start_timestamp();
02293   static const int kStartTimestampFieldNumber = 2;
02294   inline ::google::protobuf::uint64 start_timestamp() const;
02295   inline void set_start_timestamp(::google::protobuf::uint64 value);
02296   
02297   // required uint64 end_timestamp = 3;
02298   inline bool has_end_timestamp() const;
02299   inline void clear_end_timestamp();
02300   static const int kEndTimestampFieldNumber = 3;
02301   inline ::google::protobuf::uint64 end_timestamp() const;
02302   inline void set_end_timestamp(::google::protobuf::uint64 value);
02303   
02304   // optional string sql = 4;
02305   inline bool has_sql() const;
02306   inline void clear_sql();
02307   static const int kSqlFieldNumber = 4;
02308   inline const ::std::string& sql() const;
02309   inline void set_sql(const ::std::string& value);
02310   inline void set_sql(const char* value);
02311   inline void set_sql(const char* value, size_t size);
02312   inline ::std::string* mutable_sql();
02313   
02314   // optional .drizzled.message.InsertHeader insert_header = 5;
02315   inline bool has_insert_header() const;
02316   inline void clear_insert_header();
02317   static const int kInsertHeaderFieldNumber = 5;
02318   inline const ::drizzled::message::InsertHeader& insert_header() const;
02319   inline ::drizzled::message::InsertHeader* mutable_insert_header();
02320   
02321   // optional .drizzled.message.InsertData insert_data = 6;
02322   inline bool has_insert_data() const;
02323   inline void clear_insert_data();
02324   static const int kInsertDataFieldNumber = 6;
02325   inline const ::drizzled::message::InsertData& insert_data() const;
02326   inline ::drizzled::message::InsertData* mutable_insert_data();
02327   
02328   // optional .drizzled.message.UpdateHeader update_header = 7;
02329   inline bool has_update_header() const;
02330   inline void clear_update_header();
02331   static const int kUpdateHeaderFieldNumber = 7;
02332   inline const ::drizzled::message::UpdateHeader& update_header() const;
02333   inline ::drizzled::message::UpdateHeader* mutable_update_header();
02334   
02335   // optional .drizzled.message.UpdateData update_data = 8;
02336   inline bool has_update_data() const;
02337   inline void clear_update_data();
02338   static const int kUpdateDataFieldNumber = 8;
02339   inline const ::drizzled::message::UpdateData& update_data() const;
02340   inline ::drizzled::message::UpdateData* mutable_update_data();
02341   
02342   // optional .drizzled.message.DeleteHeader delete_header = 9;
02343   inline bool has_delete_header() const;
02344   inline void clear_delete_header();
02345   static const int kDeleteHeaderFieldNumber = 9;
02346   inline const ::drizzled::message::DeleteHeader& delete_header() const;
02347   inline ::drizzled::message::DeleteHeader* mutable_delete_header();
02348   
02349   // optional .drizzled.message.DeleteData delete_data = 10;
02350   inline bool has_delete_data() const;
02351   inline void clear_delete_data();
02352   static const int kDeleteDataFieldNumber = 10;
02353   inline const ::drizzled::message::DeleteData& delete_data() const;
02354   inline ::drizzled::message::DeleteData* mutable_delete_data();
02355   
02356   // optional .drizzled.message.TruncateTableStatement truncate_table_statement = 11;
02357   inline bool has_truncate_table_statement() const;
02358   inline void clear_truncate_table_statement();
02359   static const int kTruncateTableStatementFieldNumber = 11;
02360   inline const ::drizzled::message::TruncateTableStatement& truncate_table_statement() const;
02361   inline ::drizzled::message::TruncateTableStatement* mutable_truncate_table_statement();
02362   
02363   // optional .drizzled.message.CreateSchemaStatement create_schema_statement = 12;
02364   inline bool has_create_schema_statement() const;
02365   inline void clear_create_schema_statement();
02366   static const int kCreateSchemaStatementFieldNumber = 12;
02367   inline const ::drizzled::message::CreateSchemaStatement& create_schema_statement() const;
02368   inline ::drizzled::message::CreateSchemaStatement* mutable_create_schema_statement();
02369   
02370   // optional .drizzled.message.DropSchemaStatement drop_schema_statement = 13;
02371   inline bool has_drop_schema_statement() const;
02372   inline void clear_drop_schema_statement();
02373   static const int kDropSchemaStatementFieldNumber = 13;
02374   inline const ::drizzled::message::DropSchemaStatement& drop_schema_statement() const;
02375   inline ::drizzled::message::DropSchemaStatement* mutable_drop_schema_statement();
02376   
02377   // optional .drizzled.message.AlterSchemaStatement alter_schema_statement = 14;
02378   inline bool has_alter_schema_statement() const;
02379   inline void clear_alter_schema_statement();
02380   static const int kAlterSchemaStatementFieldNumber = 14;
02381   inline const ::drizzled::message::AlterSchemaStatement& alter_schema_statement() const;
02382   inline ::drizzled::message::AlterSchemaStatement* mutable_alter_schema_statement();
02383   
02384   // optional .drizzled.message.CreateTableStatement create_table_statement = 15;
02385   inline bool has_create_table_statement() const;
02386   inline void clear_create_table_statement();
02387   static const int kCreateTableStatementFieldNumber = 15;
02388   inline const ::drizzled::message::CreateTableStatement& create_table_statement() const;
02389   inline ::drizzled::message::CreateTableStatement* mutable_create_table_statement();
02390   
02391   // optional .drizzled.message.AlterTableStatement alter_table_statement = 16;
02392   inline bool has_alter_table_statement() const;
02393   inline void clear_alter_table_statement();
02394   static const int kAlterTableStatementFieldNumber = 16;
02395   inline const ::drizzled::message::AlterTableStatement& alter_table_statement() const;
02396   inline ::drizzled::message::AlterTableStatement* mutable_alter_table_statement();
02397   
02398   // optional .drizzled.message.DropTableStatement drop_table_statement = 17;
02399   inline bool has_drop_table_statement() const;
02400   inline void clear_drop_table_statement();
02401   static const int kDropTableStatementFieldNumber = 17;
02402   inline const ::drizzled::message::DropTableStatement& drop_table_statement() const;
02403   inline ::drizzled::message::DropTableStatement* mutable_drop_table_statement();
02404   
02405   // optional .drizzled.message.SetVariableStatement set_variable_statement = 18;
02406   inline bool has_set_variable_statement() const;
02407   inline void clear_set_variable_statement();
02408   static const int kSetVariableStatementFieldNumber = 18;
02409   inline const ::drizzled::message::SetVariableStatement& set_variable_statement() const;
02410   inline ::drizzled::message::SetVariableStatement* mutable_set_variable_statement();
02411   
02412   // optional string raw_sql_schema = 19;
02413   inline bool has_raw_sql_schema() const;
02414   inline void clear_raw_sql_schema();
02415   static const int kRawSqlSchemaFieldNumber = 19;
02416   inline const ::std::string& raw_sql_schema() const;
02417   inline void set_raw_sql_schema(const ::std::string& value);
02418   inline void set_raw_sql_schema(const char* value);
02419   inline void set_raw_sql_schema(const char* value, size_t size);
02420   inline ::std::string* mutable_raw_sql_schema();
02421   
02422   // @@protoc_insertion_point(class_scope:drizzled.message.Statement)
02423  private:
02424   ::google::protobuf::UnknownFieldSet _unknown_fields_;
02425   mutable int _cached_size_;
02426   
02427   int type_;
02428   ::google::protobuf::uint64 start_timestamp_;
02429   ::google::protobuf::uint64 end_timestamp_;
02430   ::std::string* sql_;
02431   static const ::std::string _default_sql_;
02432   ::drizzled::message::InsertHeader* insert_header_;
02433   ::drizzled::message::InsertData* insert_data_;
02434   ::drizzled::message::UpdateHeader* update_header_;
02435   ::drizzled::message::UpdateData* update_data_;
02436   ::drizzled::message::DeleteHeader* delete_header_;
02437   ::drizzled::message::DeleteData* delete_data_;
02438   ::drizzled::message::TruncateTableStatement* truncate_table_statement_;
02439   ::drizzled::message::CreateSchemaStatement* create_schema_statement_;
02440   ::drizzled::message::DropSchemaStatement* drop_schema_statement_;
02441   ::drizzled::message::AlterSchemaStatement* alter_schema_statement_;
02442   ::drizzled::message::CreateTableStatement* create_table_statement_;
02443   ::drizzled::message::AlterTableStatement* alter_table_statement_;
02444   ::drizzled::message::DropTableStatement* drop_table_statement_;
02445   ::drizzled::message::SetVariableStatement* set_variable_statement_;
02446   ::std::string* raw_sql_schema_;
02447   static const ::std::string _default_raw_sql_schema_;
02448   friend void  protobuf_AddDesc_transaction_2eproto();
02449   friend void protobuf_AssignDesc_transaction_2eproto();
02450   friend void protobuf_ShutdownFile_transaction_2eproto();
02451   
02452   ::google::protobuf::uint32 _has_bits_[(19 + 31) / 32];
02453   
02454   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
02455   inline bool _has_bit(int index) const {
02456     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
02457   }
02458   inline void _set_bit(int index) {
02459     _has_bits_[index / 32] |= (1u << (index % 32));
02460   }
02461   inline void _clear_bit(int index) {
02462     _has_bits_[index / 32] &= ~(1u << (index % 32));
02463   }
02464   
02465   void InitAsDefaultInstance();
02466   static Statement* default_instance_;
02467 };
02468 // -------------------------------------------------------------------
02469 
02470 class Transaction : public ::google::protobuf::Message {
02471  public:
02472   Transaction();
02473   virtual ~Transaction();
02474   
02475   Transaction(const Transaction& from);
02476   
02477   inline Transaction& operator=(const Transaction& from) {
02478     CopyFrom(from);
02479     return *this;
02480   }
02481   
02482   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
02483     return _unknown_fields_;
02484   }
02485   
02486   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
02487     return &_unknown_fields_;
02488   }
02489   
02490   static const ::google::protobuf::Descriptor* descriptor();
02491   static const Transaction& default_instance();
02492   
02493   void Swap(Transaction* other);
02494   
02495   // implements Message ----------------------------------------------
02496   
02497   Transaction* New() const;
02498   void CopyFrom(const ::google::protobuf::Message& from);
02499   void MergeFrom(const ::google::protobuf::Message& from);
02500   void CopyFrom(const Transaction& from);
02501   void MergeFrom(const Transaction& from);
02502   void Clear();
02503   bool IsInitialized() const;
02504   
02505   int ByteSize() const;
02506   bool MergePartialFromCodedStream(
02507       ::google::protobuf::io::CodedInputStream* input);
02508   void SerializeWithCachedSizes(
02509       ::google::protobuf::io::CodedOutputStream* output) const;
02510   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
02511   int GetCachedSize() const { return _cached_size_; }
02512   private:
02513   void SharedCtor();
02514   void SharedDtor();
02515   void SetCachedSize(int size) const;
02516   public:
02517   
02518   ::google::protobuf::Metadata GetMetadata() const;
02519   
02520   // nested types ----------------------------------------------------
02521   
02522   // accessors -------------------------------------------------------
02523   
02524   // required .drizzled.message.TransactionContext transaction_context = 1;
02525   inline bool has_transaction_context() const;
02526   inline void clear_transaction_context();
02527   static const int kTransactionContextFieldNumber = 1;
02528   inline const ::drizzled::message::TransactionContext& transaction_context() const;
02529   inline ::drizzled::message::TransactionContext* mutable_transaction_context();
02530   
02531   // repeated .drizzled.message.Statement statement = 2;
02532   inline int statement_size() const;
02533   inline void clear_statement();
02534   static const int kStatementFieldNumber = 2;
02535   inline const ::drizzled::message::Statement& statement(int index) const;
02536   inline ::drizzled::message::Statement* mutable_statement(int index);
02537   inline ::drizzled::message::Statement* add_statement();
02538   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Statement >&
02539       statement() const;
02540   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Statement >*
02541       mutable_statement();
02542   
02543   // optional .drizzled.message.Event event = 3;
02544   inline bool has_event() const;
02545   inline void clear_event();
02546   static const int kEventFieldNumber = 3;
02547   inline const ::drizzled::message::Event& event() const;
02548   inline ::drizzled::message::Event* mutable_event();
02549   
02550   // optional uint32 segment_id = 4;
02551   inline bool has_segment_id() const;
02552   inline void clear_segment_id();
02553   static const int kSegmentIdFieldNumber = 4;
02554   inline ::google::protobuf::uint32 segment_id() const;
02555   inline void set_segment_id(::google::protobuf::uint32 value);
02556   
02557   // optional bool end_segment = 5;
02558   inline bool has_end_segment() const;
02559   inline void clear_end_segment();
02560   static const int kEndSegmentFieldNumber = 5;
02561   inline bool end_segment() const;
02562   inline void set_end_segment(bool value);
02563   
02564   // @@protoc_insertion_point(class_scope:drizzled.message.Transaction)
02565  private:
02566   ::google::protobuf::UnknownFieldSet _unknown_fields_;
02567   mutable int _cached_size_;
02568   
02569   ::drizzled::message::TransactionContext* transaction_context_;
02570   ::google::protobuf::RepeatedPtrField< ::drizzled::message::Statement > statement_;
02571   ::drizzled::message::Event* event_;
02572   ::google::protobuf::uint32 segment_id_;
02573   bool end_segment_;
02574   friend void  protobuf_AddDesc_transaction_2eproto();
02575   friend void protobuf_AssignDesc_transaction_2eproto();
02576   friend void protobuf_ShutdownFile_transaction_2eproto();
02577   
02578   ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
02579   
02580   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
02581   inline bool _has_bit(int index) const {
02582     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
02583   }
02584   inline void _set_bit(int index) {
02585     _has_bits_[index / 32] |= (1u << (index % 32));
02586   }
02587   inline void _clear_bit(int index) {
02588     _has_bits_[index / 32] &= ~(1u << (index % 32));
02589   }
02590   
02591   void InitAsDefaultInstance();
02592   static Transaction* default_instance_;
02593 };
02594 // ===================================================================
02595 
02596 
02597 // ===================================================================
02598 
02599 // FieldMetadata
02600 
02601 // required .drizzled.message.Table.Field.FieldType type = 1;
02602 inline bool FieldMetadata::has_type() const {
02603   return _has_bit(0);
02604 }
02605 inline void FieldMetadata::clear_type() {
02606   type_ = 0;
02607   _clear_bit(0);
02608 }
02609 inline ::drizzled::message::Table_Field_FieldType FieldMetadata::type() const {
02610   return static_cast< ::drizzled::message::Table_Field_FieldType >(type_);
02611 }
02612 inline void FieldMetadata::set_type(::drizzled::message::Table_Field_FieldType value) {
02613   GOOGLE_DCHECK(::drizzled::message::Table_Field_FieldType_IsValid(value));
02614   _set_bit(0);
02615   type_ = value;
02616 }
02617 
02618 // required string name = 2;
02619 inline bool FieldMetadata::has_name() const {
02620   return _has_bit(1);
02621 }
02622 inline void FieldMetadata::clear_name() {
02623   if (name_ != &_default_name_) {
02624     name_->clear();
02625   }
02626   _clear_bit(1);
02627 }
02628 inline const ::std::string& FieldMetadata::name() const {
02629   return *name_;
02630 }
02631 inline void FieldMetadata::set_name(const ::std::string& value) {
02632   _set_bit(1);
02633   if (name_ == &_default_name_) {
02634     name_ = new ::std::string;
02635   }
02636   name_->assign(value);
02637 }
02638 inline void FieldMetadata::set_name(const char* value) {
02639   _set_bit(1);
02640   if (name_ == &_default_name_) {
02641     name_ = new ::std::string;
02642   }
02643   name_->assign(value);
02644 }
02645 inline void FieldMetadata::set_name(const char* value, size_t size) {
02646   _set_bit(1);
02647   if (name_ == &_default_name_) {
02648     name_ = new ::std::string;
02649   }
02650   name_->assign(reinterpret_cast<const char*>(value), size);
02651 }
02652 inline ::std::string* FieldMetadata::mutable_name() {
02653   _set_bit(1);
02654   if (name_ == &_default_name_) {
02655     name_ = new ::std::string;
02656   }
02657   return name_;
02658 }
02659 
02660 // -------------------------------------------------------------------
02661 
02662 // TableMetadata
02663 
02664 // required string schema_name = 1;
02665 inline bool TableMetadata::has_schema_name() const {
02666   return _has_bit(0);
02667 }
02668 inline void TableMetadata::clear_schema_name() {
02669   if (schema_name_ != &_default_schema_name_) {
02670     schema_name_->clear();
02671   }
02672   _clear_bit(0);
02673 }
02674 inline const ::std::string& TableMetadata::schema_name() const {
02675   return *schema_name_;
02676 }
02677 inline void TableMetadata::set_schema_name(const ::std::string& value) {
02678   _set_bit(0);
02679   if (schema_name_ == &_default_schema_name_) {
02680     schema_name_ = new ::std::string;
02681   }
02682   schema_name_->assign(value);
02683 }
02684 inline void TableMetadata::set_schema_name(const char* value) {
02685   _set_bit(0);
02686   if (schema_name_ == &_default_schema_name_) {
02687     schema_name_ = new ::std::string;
02688   }
02689   schema_name_->assign(value);
02690 }
02691 inline void TableMetadata::set_schema_name(const char* value, size_t size) {
02692   _set_bit(0);
02693   if (schema_name_ == &_default_schema_name_) {
02694     schema_name_ = new ::std::string;
02695   }
02696   schema_name_->assign(reinterpret_cast<const char*>(value), size);
02697 }
02698 inline ::std::string* TableMetadata::mutable_schema_name() {
02699   _set_bit(0);
02700   if (schema_name_ == &_default_schema_name_) {
02701     schema_name_ = new ::std::string;
02702   }
02703   return schema_name_;
02704 }
02705 
02706 // required string table_name = 2;
02707 inline bool TableMetadata::has_table_name() const {
02708   return _has_bit(1);
02709 }
02710 inline void TableMetadata::clear_table_name() {
02711   if (table_name_ != &_default_table_name_) {
02712     table_name_->clear();
02713   }
02714   _clear_bit(1);
02715 }
02716 inline const ::std::string& TableMetadata::table_name() const {
02717   return *table_name_;
02718 }
02719 inline void TableMetadata::set_table_name(const ::std::string& value) {
02720   _set_bit(1);
02721   if (table_name_ == &_default_table_name_) {
02722     table_name_ = new ::std::string;
02723   }
02724   table_name_->assign(value);
02725 }
02726 inline void TableMetadata::set_table_name(const char* value) {
02727   _set_bit(1);
02728   if (table_name_ == &_default_table_name_) {
02729     table_name_ = new ::std::string;
02730   }
02731   table_name_->assign(value);
02732 }
02733 inline void TableMetadata::set_table_name(const char* value, size_t size) {
02734   _set_bit(1);
02735   if (table_name_ == &_default_table_name_) {
02736     table_name_ = new ::std::string;
02737   }
02738   table_name_->assign(reinterpret_cast<const char*>(value), size);
02739 }
02740 inline ::std::string* TableMetadata::mutable_table_name() {
02741   _set_bit(1);
02742   if (table_name_ == &_default_table_name_) {
02743     table_name_ = new ::std::string;
02744   }
02745   return table_name_;
02746 }
02747 
02748 // optional string catalog_name = 3;
02749 inline bool TableMetadata::has_catalog_name() const {
02750   return _has_bit(2);
02751 }
02752 inline void TableMetadata::clear_catalog_name() {
02753   if (catalog_name_ != &_default_catalog_name_) {
02754     catalog_name_->clear();
02755   }
02756   _clear_bit(2);
02757 }
02758 inline const ::std::string& TableMetadata::catalog_name() const {
02759   return *catalog_name_;
02760 }
02761 inline void TableMetadata::set_catalog_name(const ::std::string& value) {
02762   _set_bit(2);
02763   if (catalog_name_ == &_default_catalog_name_) {
02764     catalog_name_ = new ::std::string;
02765   }
02766   catalog_name_->assign(value);
02767 }
02768 inline void TableMetadata::set_catalog_name(const char* value) {
02769   _set_bit(2);
02770   if (catalog_name_ == &_default_catalog_name_) {
02771     catalog_name_ = new ::std::string;
02772   }
02773   catalog_name_->assign(value);
02774 }
02775 inline void TableMetadata::set_catalog_name(const char* value, size_t size) {
02776   _set_bit(2);
02777   if (catalog_name_ == &_default_catalog_name_) {
02778     catalog_name_ = new ::std::string;
02779   }
02780   catalog_name_->assign(reinterpret_cast<const char*>(value), size);
02781 }
02782 inline ::std::string* TableMetadata::mutable_catalog_name() {
02783   _set_bit(2);
02784   if (catalog_name_ == &_default_catalog_name_) {
02785     catalog_name_ = new ::std::string;
02786   }
02787   return catalog_name_;
02788 }
02789 
02790 // -------------------------------------------------------------------
02791 
02792 // TransactionContext
02793 
02794 // required uint32 server_id = 1;
02795 inline bool TransactionContext::has_server_id() const {
02796   return _has_bit(0);
02797 }
02798 inline void TransactionContext::clear_server_id() {
02799   server_id_ = 0u;
02800   _clear_bit(0);
02801 }
02802 inline ::google::protobuf::uint32 TransactionContext::server_id() const {
02803   return server_id_;
02804 }
02805 inline void TransactionContext::set_server_id(::google::protobuf::uint32 value) {
02806   _set_bit(0);
02807   server_id_ = value;
02808 }
02809 
02810 // required uint64 transaction_id = 2;
02811 inline bool TransactionContext::has_transaction_id() const {
02812   return _has_bit(1);
02813 }
02814 inline void TransactionContext::clear_transaction_id() {
02815   transaction_id_ = GOOGLE_ULONGLONG(0);
02816   _clear_bit(1);
02817 }
02818 inline ::google::protobuf::uint64 TransactionContext::transaction_id() const {
02819   return transaction_id_;
02820 }
02821 inline void TransactionContext::set_transaction_id(::google::protobuf::uint64 value) {
02822   _set_bit(1);
02823   transaction_id_ = value;
02824 }
02825 
02826 // required uint64 start_timestamp = 3;
02827 inline bool TransactionContext::has_start_timestamp() const {
02828   return _has_bit(2);
02829 }
02830 inline void TransactionContext::clear_start_timestamp() {
02831   start_timestamp_ = GOOGLE_ULONGLONG(0);
02832   _clear_bit(2);
02833 }
02834 inline ::google::protobuf::uint64 TransactionContext::start_timestamp() const {
02835   return start_timestamp_;
02836 }
02837 inline void TransactionContext::set_start_timestamp(::google::protobuf::uint64 value) {
02838   _set_bit(2);
02839   start_timestamp_ = value;
02840 }
02841 
02842 // required uint64 end_timestamp = 4;
02843 inline bool TransactionContext::has_end_timestamp() const {
02844   return _has_bit(3);
02845 }
02846 inline void TransactionContext::clear_end_timestamp() {
02847   end_timestamp_ = GOOGLE_ULONGLONG(0);
02848   _clear_bit(3);
02849 }
02850 inline ::google::protobuf::uint64 TransactionContext::end_timestamp() const {
02851   return end_timestamp_;
02852 }
02853 inline void TransactionContext::set_end_timestamp(::google::protobuf::uint64 value) {
02854   _set_bit(3);
02855   end_timestamp_ = value;
02856 }
02857 
02858 // -------------------------------------------------------------------
02859 
02860 // InsertRecord
02861 
02862 // repeated bytes insert_value = 1;
02863 inline int InsertRecord::insert_value_size() const {
02864   return insert_value_.size();
02865 }
02866 inline void InsertRecord::clear_insert_value() {
02867   insert_value_.Clear();
02868 }
02869 inline const ::std::string& InsertRecord::insert_value(int index) const {
02870   return insert_value_.Get(index);
02871 }
02872 inline ::std::string* InsertRecord::mutable_insert_value(int index) {
02873   return insert_value_.Mutable(index);
02874 }
02875 inline void InsertRecord::set_insert_value(int index, const ::std::string& value) {
02876   insert_value_.Mutable(index)->assign(value);
02877 }
02878 inline void InsertRecord::set_insert_value(int index, const char* value) {
02879   insert_value_.Mutable(index)->assign(value);
02880 }
02881 inline void InsertRecord::set_insert_value(int index, const void* value, size_t size) {
02882   insert_value_.Mutable(index)->assign(
02883     reinterpret_cast<const char*>(value), size);
02884 }
02885 inline ::std::string* InsertRecord::add_insert_value() {
02886   return insert_value_.Add();
02887 }
02888 inline void InsertRecord::add_insert_value(const ::std::string& value) {
02889   insert_value_.Add()->assign(value);
02890 }
02891 inline void InsertRecord::add_insert_value(const char* value) {
02892   insert_value_.Add()->assign(value);
02893 }
02894 inline void InsertRecord::add_insert_value(const void* value, size_t size) {
02895   insert_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
02896 }
02897 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
02898 InsertRecord::insert_value() const {
02899   return insert_value_;
02900 }
02901 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
02902 InsertRecord::mutable_insert_value() {
02903   return &insert_value_;
02904 }
02905 
02906 // repeated bool is_null = 2;
02907 inline int InsertRecord::is_null_size() const {
02908   return is_null_.size();
02909 }
02910 inline void InsertRecord::clear_is_null() {
02911   is_null_.Clear();
02912 }
02913 inline bool InsertRecord::is_null(int index) const {
02914   return is_null_.Get(index);
02915 }
02916 inline void InsertRecord::set_is_null(int index, bool value) {
02917   is_null_.Set(index, value);
02918 }
02919 inline void InsertRecord::add_is_null(bool value) {
02920   is_null_.Add(value);
02921 }
02922 inline const ::google::protobuf::RepeatedField< bool >&
02923 InsertRecord::is_null() const {
02924   return is_null_;
02925 }
02926 inline ::google::protobuf::RepeatedField< bool >*
02927 InsertRecord::mutable_is_null() {
02928   return &is_null_;
02929 }
02930 
02931 // -------------------------------------------------------------------
02932 
02933 // InsertHeader
02934 
02935 // required .drizzled.message.TableMetadata table_metadata = 1;
02936 inline bool InsertHeader::has_table_metadata() const {
02937   return _has_bit(0);
02938 }
02939 inline void InsertHeader::clear_table_metadata() {
02940   if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
02941   _clear_bit(0);
02942 }
02943 inline const ::drizzled::message::TableMetadata& InsertHeader::table_metadata() const {
02944   return table_metadata_ != NULL ? *table_metadata_ : *default_instance_->table_metadata_;
02945 }
02946 inline ::drizzled::message::TableMetadata* InsertHeader::mutable_table_metadata() {
02947   _set_bit(0);
02948   if (table_metadata_ == NULL) table_metadata_ = new ::drizzled::message::TableMetadata;
02949   return table_metadata_;
02950 }
02951 
02952 // repeated .drizzled.message.FieldMetadata field_metadata = 2;
02953 inline int InsertHeader::field_metadata_size() const {
02954   return field_metadata_.size();
02955 }
02956 inline void InsertHeader::clear_field_metadata() {
02957   field_metadata_.Clear();
02958 }
02959 inline const ::drizzled::message::FieldMetadata& InsertHeader::field_metadata(int index) const {
02960   return field_metadata_.Get(index);
02961 }
02962 inline ::drizzled::message::FieldMetadata* InsertHeader::mutable_field_metadata(int index) {
02963   return field_metadata_.Mutable(index);
02964 }
02965 inline ::drizzled::message::FieldMetadata* InsertHeader::add_field_metadata() {
02966   return field_metadata_.Add();
02967 }
02968 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
02969 InsertHeader::field_metadata() const {
02970   return field_metadata_;
02971 }
02972 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
02973 InsertHeader::mutable_field_metadata() {
02974   return &field_metadata_;
02975 }
02976 
02977 // -------------------------------------------------------------------
02978 
02979 // InsertData
02980 
02981 // required uint32 segment_id = 1;
02982 inline bool InsertData::has_segment_id() const {
02983   return _has_bit(0);
02984 }
02985 inline void InsertData::clear_segment_id() {
02986   segment_id_ = 0u;
02987   _clear_bit(0);
02988 }
02989 inline ::google::protobuf::uint32 InsertData::segment_id() const {
02990   return segment_id_;
02991 }
02992 inline void InsertData::set_segment_id(::google::protobuf::uint32 value) {
02993   _set_bit(0);
02994   segment_id_ = value;
02995 }
02996 
02997 // required bool end_segment = 2;
02998 inline bool InsertData::has_end_segment() const {
02999   return _has_bit(1);
03000 }
03001 inline void InsertData::clear_end_segment() {
03002   end_segment_ = false;
03003   _clear_bit(1);
03004 }
03005 inline bool InsertData::end_segment() const {
03006   return end_segment_;
03007 }
03008 inline void InsertData::set_end_segment(bool value) {
03009   _set_bit(1);
03010   end_segment_ = value;
03011 }
03012 
03013 // repeated .drizzled.message.InsertRecord record = 3;
03014 inline int InsertData::record_size() const {
03015   return record_.size();
03016 }
03017 inline void InsertData::clear_record() {
03018   record_.Clear();
03019 }
03020 inline const ::drizzled::message::InsertRecord& InsertData::record(int index) const {
03021   return record_.Get(index);
03022 }
03023 inline ::drizzled::message::InsertRecord* InsertData::mutable_record(int index) {
03024   return record_.Mutable(index);
03025 }
03026 inline ::drizzled::message::InsertRecord* InsertData::add_record() {
03027   return record_.Add();
03028 }
03029 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::InsertRecord >&
03030 InsertData::record() const {
03031   return record_;
03032 }
03033 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::InsertRecord >*
03034 InsertData::mutable_record() {
03035   return &record_;
03036 }
03037 
03038 // -------------------------------------------------------------------
03039 
03040 // UpdateRecord
03041 
03042 // repeated bytes key_value = 1;
03043 inline int UpdateRecord::key_value_size() const {
03044   return key_value_.size();
03045 }
03046 inline void UpdateRecord::clear_key_value() {
03047   key_value_.Clear();
03048 }
03049 inline const ::std::string& UpdateRecord::key_value(int index) const {
03050   return key_value_.Get(index);
03051 }
03052 inline ::std::string* UpdateRecord::mutable_key_value(int index) {
03053   return key_value_.Mutable(index);
03054 }
03055 inline void UpdateRecord::set_key_value(int index, const ::std::string& value) {
03056   key_value_.Mutable(index)->assign(value);
03057 }
03058 inline void UpdateRecord::set_key_value(int index, const char* value) {
03059   key_value_.Mutable(index)->assign(value);
03060 }
03061 inline void UpdateRecord::set_key_value(int index, const void* value, size_t size) {
03062   key_value_.Mutable(index)->assign(
03063     reinterpret_cast<const char*>(value), size);
03064 }
03065 inline ::std::string* UpdateRecord::add_key_value() {
03066   return key_value_.Add();
03067 }
03068 inline void UpdateRecord::add_key_value(const ::std::string& value) {
03069   key_value_.Add()->assign(value);
03070 }
03071 inline void UpdateRecord::add_key_value(const char* value) {
03072   key_value_.Add()->assign(value);
03073 }
03074 inline void UpdateRecord::add_key_value(const void* value, size_t size) {
03075   key_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
03076 }
03077 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
03078 UpdateRecord::key_value() const {
03079   return key_value_;
03080 }
03081 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
03082 UpdateRecord::mutable_key_value() {
03083   return &key_value_;
03084 }
03085 
03086 // repeated bytes after_value = 2;
03087 inline int UpdateRecord::after_value_size() const {
03088   return after_value_.size();
03089 }
03090 inline void UpdateRecord::clear_after_value() {
03091   after_value_.Clear();
03092 }
03093 inline const ::std::string& UpdateRecord::after_value(int index) const {
03094   return after_value_.Get(index);
03095 }
03096 inline ::std::string* UpdateRecord::mutable_after_value(int index) {
03097   return after_value_.Mutable(index);
03098 }
03099 inline void UpdateRecord::set_after_value(int index, const ::std::string& value) {
03100   after_value_.Mutable(index)->assign(value);
03101 }
03102 inline void UpdateRecord::set_after_value(int index, const char* value) {
03103   after_value_.Mutable(index)->assign(value);
03104 }
03105 inline void UpdateRecord::set_after_value(int index, const void* value, size_t size) {
03106   after_value_.Mutable(index)->assign(
03107     reinterpret_cast<const char*>(value), size);
03108 }
03109 inline ::std::string* UpdateRecord::add_after_value() {
03110   return after_value_.Add();
03111 }
03112 inline void UpdateRecord::add_after_value(const ::std::string& value) {
03113   after_value_.Add()->assign(value);
03114 }
03115 inline void UpdateRecord::add_after_value(const char* value) {
03116   after_value_.Add()->assign(value);
03117 }
03118 inline void UpdateRecord::add_after_value(const void* value, size_t size) {
03119   after_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
03120 }
03121 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
03122 UpdateRecord::after_value() const {
03123   return after_value_;
03124 }
03125 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
03126 UpdateRecord::mutable_after_value() {
03127   return &after_value_;
03128 }
03129 
03130 // repeated bytes before_value = 3;
03131 inline int UpdateRecord::before_value_size() const {
03132   return before_value_.size();
03133 }
03134 inline void UpdateRecord::clear_before_value() {
03135   before_value_.Clear();
03136 }
03137 inline const ::std::string& UpdateRecord::before_value(int index) const {
03138   return before_value_.Get(index);
03139 }
03140 inline ::std::string* UpdateRecord::mutable_before_value(int index) {
03141   return before_value_.Mutable(index);
03142 }
03143 inline void UpdateRecord::set_before_value(int index, const ::std::string& value) {
03144   before_value_.Mutable(index)->assign(value);
03145 }
03146 inline void UpdateRecord::set_before_value(int index, const char* value) {
03147   before_value_.Mutable(index)->assign(value);
03148 }
03149 inline void UpdateRecord::set_before_value(int index, const void* value, size_t size) {
03150   before_value_.Mutable(index)->assign(
03151     reinterpret_cast<const char*>(value), size);
03152 }
03153 inline ::std::string* UpdateRecord::add_before_value() {
03154   return before_value_.Add();
03155 }
03156 inline void UpdateRecord::add_before_value(const ::std::string& value) {
03157   before_value_.Add()->assign(value);
03158 }
03159 inline void UpdateRecord::add_before_value(const char* value) {
03160   before_value_.Add()->assign(value);
03161 }
03162 inline void UpdateRecord::add_before_value(const void* value, size_t size) {
03163   before_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
03164 }
03165 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
03166 UpdateRecord::before_value() const {
03167   return before_value_;
03168 }
03169 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
03170 UpdateRecord::mutable_before_value() {
03171   return &before_value_;
03172 }
03173 
03174 // repeated bool is_null = 4;
03175 inline int UpdateRecord::is_null_size() const {
03176   return is_null_.size();
03177 }
03178 inline void UpdateRecord::clear_is_null() {
03179   is_null_.Clear();
03180 }
03181 inline bool UpdateRecord::is_null(int index) const {
03182   return is_null_.Get(index);
03183 }
03184 inline void UpdateRecord::set_is_null(int index, bool value) {
03185   is_null_.Set(index, value);
03186 }
03187 inline void UpdateRecord::add_is_null(bool value) {
03188   is_null_.Add(value);
03189 }
03190 inline const ::google::protobuf::RepeatedField< bool >&
03191 UpdateRecord::is_null() const {
03192   return is_null_;
03193 }
03194 inline ::google::protobuf::RepeatedField< bool >*
03195 UpdateRecord::mutable_is_null() {
03196   return &is_null_;
03197 }
03198 
03199 // -------------------------------------------------------------------
03200 
03201 // UpdateHeader
03202 
03203 // required .drizzled.message.TableMetadata table_metadata = 1;
03204 inline bool UpdateHeader::has_table_metadata() const {
03205   return _has_bit(0);
03206 }
03207 inline void UpdateHeader::clear_table_metadata() {
03208   if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
03209   _clear_bit(0);
03210 }
03211 inline const ::drizzled::message::TableMetadata& UpdateHeader::table_metadata() const {
03212   return table_metadata_ != NULL ? *table_metadata_ : *default_instance_->table_metadata_;
03213 }
03214 inline ::drizzled::message::TableMetadata* UpdateHeader::mutable_table_metadata() {
03215   _set_bit(0);
03216   if (table_metadata_ == NULL) table_metadata_ = new ::drizzled::message::TableMetadata;
03217   return table_metadata_;
03218 }
03219 
03220 // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
03221 inline int UpdateHeader::key_field_metadata_size() const {
03222   return key_field_metadata_.size();
03223 }
03224 inline void UpdateHeader::clear_key_field_metadata() {
03225   key_field_metadata_.Clear();
03226 }
03227 inline const ::drizzled::message::FieldMetadata& UpdateHeader::key_field_metadata(int index) const {
03228   return key_field_metadata_.Get(index);
03229 }
03230 inline ::drizzled::message::FieldMetadata* UpdateHeader::mutable_key_field_metadata(int index) {
03231   return key_field_metadata_.Mutable(index);
03232 }
03233 inline ::drizzled::message::FieldMetadata* UpdateHeader::add_key_field_metadata() {
03234   return key_field_metadata_.Add();
03235 }
03236 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
03237 UpdateHeader::key_field_metadata() const {
03238   return key_field_metadata_;
03239 }
03240 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
03241 UpdateHeader::mutable_key_field_metadata() {
03242   return &key_field_metadata_;
03243 }
03244 
03245 // repeated .drizzled.message.FieldMetadata set_field_metadata = 3;
03246 inline int UpdateHeader::set_field_metadata_size() const {
03247   return set_field_metadata_.size();
03248 }
03249 inline void UpdateHeader::clear_set_field_metadata() {
03250   set_field_metadata_.Clear();
03251 }
03252 inline const ::drizzled::message::FieldMetadata& UpdateHeader::set_field_metadata(int index) const {
03253   return set_field_metadata_.Get(index);
03254 }
03255 inline ::drizzled::message::FieldMetadata* UpdateHeader::mutable_set_field_metadata(int index) {
03256   return set_field_metadata_.Mutable(index);
03257 }
03258 inline ::drizzled::message::FieldMetadata* UpdateHeader::add_set_field_metadata() {
03259   return set_field_metadata_.Add();
03260 }
03261 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
03262 UpdateHeader::set_field_metadata() const {
03263   return set_field_metadata_;
03264 }
03265 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
03266 UpdateHeader::mutable_set_field_metadata() {
03267   return &set_field_metadata_;
03268 }
03269 
03270 // -------------------------------------------------------------------
03271 
03272 // UpdateData
03273 
03274 // required uint32 segment_id = 1;
03275 inline bool UpdateData::has_segment_id() const {
03276   return _has_bit(0);
03277 }
03278 inline void UpdateData::clear_segment_id() {
03279   segment_id_ = 0u;
03280   _clear_bit(0);
03281 }
03282 inline ::google::protobuf::uint32 UpdateData::segment_id() const {
03283   return segment_id_;
03284 }
03285 inline void UpdateData::set_segment_id(::google::protobuf::uint32 value) {
03286   _set_bit(0);
03287   segment_id_ = value;
03288 }
03289 
03290 // required bool end_segment = 2;
03291 inline bool UpdateData::has_end_segment() const {
03292   return _has_bit(1);
03293 }
03294 inline void UpdateData::clear_end_segment() {
03295   end_segment_ = false;
03296   _clear_bit(1);
03297 }
03298 inline bool UpdateData::end_segment() const {
03299   return end_segment_;
03300 }
03301 inline void UpdateData::set_end_segment(bool value) {
03302   _set_bit(1);
03303   end_segment_ = value;
03304 }
03305 
03306 // repeated .drizzled.message.UpdateRecord record = 3;
03307 inline int UpdateData::record_size() const {
03308   return record_.size();
03309 }
03310 inline void UpdateData::clear_record() {
03311   record_.Clear();
03312 }
03313 inline const ::drizzled::message::UpdateRecord& UpdateData::record(int index) const {
03314   return record_.Get(index);
03315 }
03316 inline ::drizzled::message::UpdateRecord* UpdateData::mutable_record(int index) {
03317   return record_.Mutable(index);
03318 }
03319 inline ::drizzled::message::UpdateRecord* UpdateData::add_record() {
03320   return record_.Add();
03321 }
03322 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::UpdateRecord >&
03323 UpdateData::record() const {
03324   return record_;
03325 }
03326 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::UpdateRecord >*
03327 UpdateData::mutable_record() {
03328   return &record_;
03329 }
03330 
03331 // -------------------------------------------------------------------
03332 
03333 // DeleteRecord
03334 
03335 // repeated bytes key_value = 1;
03336 inline int DeleteRecord::key_value_size() const {
03337   return key_value_.size();
03338 }
03339 inline void DeleteRecord::clear_key_value() {
03340   key_value_.Clear();
03341 }
03342 inline const ::std::string& DeleteRecord::key_value(int index) const {
03343   return key_value_.Get(index);
03344 }
03345 inline ::std::string* DeleteRecord::mutable_key_value(int index) {
03346   return key_value_.Mutable(index);
03347 }
03348 inline void DeleteRecord::set_key_value(int index, const ::std::string& value) {
03349   key_value_.Mutable(index)->assign(value);
03350 }
03351 inline void DeleteRecord::set_key_value(int index, const char* value) {
03352   key_value_.Mutable(index)->assign(value);
03353 }
03354 inline void DeleteRecord::set_key_value(int index, const void* value, size_t size) {
03355   key_value_.Mutable(index)->assign(
03356     reinterpret_cast<const char*>(value), size);
03357 }
03358 inline ::std::string* DeleteRecord::add_key_value() {
03359   return key_value_.Add();
03360 }
03361 inline void DeleteRecord::add_key_value(const ::std::string& value) {
03362   key_value_.Add()->assign(value);
03363 }
03364 inline void DeleteRecord::add_key_value(const char* value) {
03365   key_value_.Add()->assign(value);
03366 }
03367 inline void DeleteRecord::add_key_value(const void* value, size_t size) {
03368   key_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
03369 }
03370 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
03371 DeleteRecord::key_value() const {
03372   return key_value_;
03373 }
03374 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
03375 DeleteRecord::mutable_key_value() {
03376   return &key_value_;
03377 }
03378 
03379 // -------------------------------------------------------------------
03380 
03381 // DeleteHeader
03382 
03383 // required .drizzled.message.TableMetadata table_metadata = 1;
03384 inline bool DeleteHeader::has_table_metadata() const {
03385   return _has_bit(0);
03386 }
03387 inline void DeleteHeader::clear_table_metadata() {
03388   if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
03389   _clear_bit(0);
03390 }
03391 inline const ::drizzled::message::TableMetadata& DeleteHeader::table_metadata() const {
03392   return table_metadata_ != NULL ? *table_metadata_ : *default_instance_->table_metadata_;
03393 }
03394 inline ::drizzled::message::TableMetadata* DeleteHeader::mutable_table_metadata() {
03395   _set_bit(0);
03396   if (table_metadata_ == NULL) table_metadata_ = new ::drizzled::message::TableMetadata;
03397   return table_metadata_;
03398 }
03399 
03400 // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
03401 inline int DeleteHeader::key_field_metadata_size() const {
03402   return key_field_metadata_.size();
03403 }
03404 inline void DeleteHeader::clear_key_field_metadata() {
03405   key_field_metadata_.Clear();
03406 }
03407 inline const ::drizzled::message::FieldMetadata& DeleteHeader::key_field_metadata(int index) const {
03408   return key_field_metadata_.Get(index);
03409 }
03410 inline ::drizzled::message::FieldMetadata* DeleteHeader::mutable_key_field_metadata(int index) {
03411   return key_field_metadata_.Mutable(index);
03412 }
03413 inline ::drizzled::message::FieldMetadata* DeleteHeader::add_key_field_metadata() {
03414   return key_field_metadata_.Add();
03415 }
03416 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
03417 DeleteHeader::key_field_metadata() const {
03418   return key_field_metadata_;
03419 }
03420 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
03421 DeleteHeader::mutable_key_field_metadata() {
03422   return &key_field_metadata_;
03423 }
03424 
03425 // -------------------------------------------------------------------
03426 
03427 // DeleteData
03428 
03429 // required uint32 segment_id = 1;
03430 inline bool DeleteData::has_segment_id() const {
03431   return _has_bit(0);
03432 }
03433 inline void DeleteData::clear_segment_id() {
03434   segment_id_ = 0u;
03435   _clear_bit(0);
03436 }
03437 inline ::google::protobuf::uint32 DeleteData::segment_id() const {
03438   return segment_id_;
03439 }
03440 inline void DeleteData::set_segment_id(::google::protobuf::uint32 value) {
03441   _set_bit(0);
03442   segment_id_ = value;
03443 }
03444 
03445 // required bool end_segment = 2;
03446 inline bool DeleteData::has_end_segment() const {
03447   return _has_bit(1);
03448 }
03449 inline void DeleteData::clear_end_segment() {
03450   end_segment_ = false;
03451   _clear_bit(1);
03452 }
03453 inline bool DeleteData::end_segment() const {
03454   return end_segment_;
03455 }
03456 inline void DeleteData::set_end_segment(bool value) {
03457   _set_bit(1);
03458   end_segment_ = value;
03459 }
03460 
03461 // repeated .drizzled.message.DeleteRecord record = 3;
03462 inline int DeleteData::record_size() const {
03463   return record_.size();
03464 }
03465 inline void DeleteData::clear_record() {
03466   record_.Clear();
03467 }
03468 inline const ::drizzled::message::DeleteRecord& DeleteData::record(int index) const {
03469   return record_.Get(index);
03470 }
03471 inline ::drizzled::message::DeleteRecord* DeleteData::mutable_record(int index) {
03472   return record_.Mutable(index);
03473 }
03474 inline ::drizzled::message::DeleteRecord* DeleteData::add_record() {
03475   return record_.Add();
03476 }
03477 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::DeleteRecord >&
03478 DeleteData::record() const {
03479   return record_;
03480 }
03481 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::DeleteRecord >*
03482 DeleteData::mutable_record() {
03483   return &record_;
03484 }
03485 
03486 // -------------------------------------------------------------------
03487 
03488 // TruncateTableStatement
03489 
03490 // required .drizzled.message.TableMetadata table_metadata = 1;
03491 inline bool TruncateTableStatement::has_table_metadata() const {
03492   return _has_bit(0);
03493 }
03494 inline void TruncateTableStatement::clear_table_metadata() {
03495   if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
03496   _clear_bit(0);
03497 }
03498 inline const ::drizzled::message::TableMetadata& TruncateTableStatement::table_metadata() const {
03499   return table_metadata_ != NULL ? *table_metadata_ : *default_instance_->table_metadata_;
03500 }
03501 inline ::drizzled::message::TableMetadata* TruncateTableStatement::mutable_table_metadata() {
03502   _set_bit(0);
03503   if (table_metadata_ == NULL) table_metadata_ = new ::drizzled::message::TableMetadata;
03504   return table_metadata_;
03505 }
03506 
03507 // -------------------------------------------------------------------
03508 
03509 // CreateSchemaStatement
03510 
03511 // required .drizzled.message.Schema schema = 1;
03512 inline bool CreateSchemaStatement::has_schema() const {
03513   return _has_bit(0);
03514 }
03515 inline void CreateSchemaStatement::clear_schema() {
03516   if (schema_ != NULL) schema_->::drizzled::message::Schema::Clear();
03517   _clear_bit(0);
03518 }
03519 inline const ::drizzled::message::Schema& CreateSchemaStatement::schema() const {
03520   return schema_ != NULL ? *schema_ : *default_instance_->schema_;
03521 }
03522 inline ::drizzled::message::Schema* CreateSchemaStatement::mutable_schema() {
03523   _set_bit(0);
03524   if (schema_ == NULL) schema_ = new ::drizzled::message::Schema;
03525   return schema_;
03526 }
03527 
03528 // -------------------------------------------------------------------
03529 
03530 // AlterSchemaStatement
03531 
03532 // required .drizzled.message.Schema before = 1;
03533 inline bool AlterSchemaStatement::has_before() const {
03534   return _has_bit(0);
03535 }
03536 inline void AlterSchemaStatement::clear_before() {
03537   if (before_ != NULL) before_->::drizzled::message::Schema::Clear();
03538   _clear_bit(0);
03539 }
03540 inline const ::drizzled::message::Schema& AlterSchemaStatement::before() const {
03541   return before_ != NULL ? *before_ : *default_instance_->before_;
03542 }
03543 inline ::drizzled::message::Schema* AlterSchemaStatement::mutable_before() {
03544   _set_bit(0);
03545   if (before_ == NULL) before_ = new ::drizzled::message::Schema;
03546   return before_;
03547 }
03548 
03549 // required .drizzled.message.Schema after = 2;
03550 inline bool AlterSchemaStatement::has_after() const {
03551   return _has_bit(1);
03552 }
03553 inline void AlterSchemaStatement::clear_after() {
03554   if (after_ != NULL) after_->::drizzled::message::Schema::Clear();
03555   _clear_bit(1);
03556 }
03557 inline const ::drizzled::message::Schema& AlterSchemaStatement::after() const {
03558   return after_ != NULL ? *after_ : *default_instance_->after_;
03559 }
03560 inline ::drizzled::message::Schema* AlterSchemaStatement::mutable_after() {
03561   _set_bit(1);
03562   if (after_ == NULL) after_ = new ::drizzled::message::Schema;
03563   return after_;
03564 }
03565 
03566 // -------------------------------------------------------------------
03567 
03568 // DropSchemaStatement
03569 
03570 // required string schema_name = 1;
03571 inline bool DropSchemaStatement::has_schema_name() const {
03572   return _has_bit(0);
03573 }
03574 inline void DropSchemaStatement::clear_schema_name() {
03575   if (schema_name_ != &_default_schema_name_) {
03576     schema_name_->clear();
03577   }
03578   _clear_bit(0);
03579 }
03580 inline const ::std::string& DropSchemaStatement::schema_name() const {
03581   return *schema_name_;
03582 }
03583 inline void DropSchemaStatement::set_schema_name(const ::std::string& value) {
03584   _set_bit(0);
03585   if (schema_name_ == &_default_schema_name_) {
03586     schema_name_ = new ::std::string;
03587   }
03588   schema_name_->assign(value);
03589 }
03590 inline void DropSchemaStatement::set_schema_name(const char* value) {
03591   _set_bit(0);
03592   if (schema_name_ == &_default_schema_name_) {
03593     schema_name_ = new ::std::string;
03594   }
03595   schema_name_->assign(value);
03596 }
03597 inline void DropSchemaStatement::set_schema_name(const char* value, size_t size) {
03598   _set_bit(0);
03599   if (schema_name_ == &_default_schema_name_) {
03600     schema_name_ = new ::std::string;
03601   }
03602   schema_name_->assign(reinterpret_cast<const char*>(value), size);
03603 }
03604 inline ::std::string* DropSchemaStatement::mutable_schema_name() {
03605   _set_bit(0);
03606   if (schema_name_ == &_default_schema_name_) {
03607     schema_name_ = new ::std::string;
03608   }
03609   return schema_name_;
03610 }
03611 
03612 // optional string catalog_name = 2;
03613 inline bool DropSchemaStatement::has_catalog_name() const {
03614   return _has_bit(1);
03615 }
03616 inline void DropSchemaStatement::clear_catalog_name() {
03617   if (catalog_name_ != &_default_catalog_name_) {
03618     catalog_name_->clear();
03619   }
03620   _clear_bit(1);
03621 }
03622 inline const ::std::string& DropSchemaStatement::catalog_name() const {
03623   return *catalog_name_;
03624 }
03625 inline void DropSchemaStatement::set_catalog_name(const ::std::string& value) {
03626   _set_bit(1);
03627   if (catalog_name_ == &_default_catalog_name_) {
03628     catalog_name_ = new ::std::string;
03629   }
03630   catalog_name_->assign(value);
03631 }
03632 inline void DropSchemaStatement::set_catalog_name(const char* value) {
03633   _set_bit(1);
03634   if (catalog_name_ == &_default_catalog_name_) {
03635     catalog_name_ = new ::std::string;
03636   }
03637   catalog_name_->assign(value);
03638 }
03639 inline void DropSchemaStatement::set_catalog_name(const char* value, size_t size) {
03640   _set_bit(1);
03641   if (catalog_name_ == &_default_catalog_name_) {
03642     catalog_name_ = new ::std::string;
03643   }
03644   catalog_name_->assign(reinterpret_cast<const char*>(value), size);
03645 }
03646 inline ::std::string* DropSchemaStatement::mutable_catalog_name() {
03647   _set_bit(1);
03648   if (catalog_name_ == &_default_catalog_name_) {
03649     catalog_name_ = new ::std::string;
03650   }
03651   return catalog_name_;
03652 }
03653 
03654 // -------------------------------------------------------------------
03655 
03656 // CreateTableStatement
03657 
03658 // required .drizzled.message.Table table = 1;
03659 inline bool CreateTableStatement::has_table() const {
03660   return _has_bit(0);
03661 }
03662 inline void CreateTableStatement::clear_table() {
03663   if (table_ != NULL) table_->::drizzled::message::Table::Clear();
03664   _clear_bit(0);
03665 }
03666 inline const ::drizzled::message::Table& CreateTableStatement::table() const {
03667   return table_ != NULL ? *table_ : *default_instance_->table_;
03668 }
03669 inline ::drizzled::message::Table* CreateTableStatement::mutable_table() {
03670   _set_bit(0);
03671   if (table_ == NULL) table_ = new ::drizzled::message::Table;
03672   return table_;
03673 }
03674 
03675 // -------------------------------------------------------------------
03676 
03677 // AlterTableStatement
03678 
03679 // required .drizzled.message.Table before = 1;
03680 inline bool AlterTableStatement::has_before() const {
03681   return _has_bit(0);
03682 }
03683 inline void AlterTableStatement::clear_before() {
03684   if (before_ != NULL) before_->::drizzled::message::Table::Clear();
03685   _clear_bit(0);
03686 }
03687 inline const ::drizzled::message::Table& AlterTableStatement::before() const {
03688   return before_ != NULL ? *before_ : *default_instance_->before_;
03689 }
03690 inline ::drizzled::message::Table* AlterTableStatement::mutable_before() {
03691   _set_bit(0);
03692   if (before_ == NULL) before_ = new ::drizzled::message::Table;
03693   return before_;
03694 }
03695 
03696 // required .drizzled.message.Table after = 2;
03697 inline bool AlterTableStatement::has_after() const {
03698   return _has_bit(1);
03699 }
03700 inline void AlterTableStatement::clear_after() {
03701   if (after_ != NULL) after_->::drizzled::message::Table::Clear();
03702   _clear_bit(1);
03703 }
03704 inline const ::drizzled::message::Table& AlterTableStatement::after() const {
03705   return after_ != NULL ? *after_ : *default_instance_->after_;
03706 }
03707 inline ::drizzled::message::Table* AlterTableStatement::mutable_after() {
03708   _set_bit(1);
03709   if (after_ == NULL) after_ = new ::drizzled::message::Table;
03710   return after_;
03711 }
03712 
03713 // -------------------------------------------------------------------
03714 
03715 // DropTableStatement
03716 
03717 // required .drizzled.message.TableMetadata table_metadata = 1;
03718 inline bool DropTableStatement::has_table_metadata() const {
03719   return _has_bit(0);
03720 }
03721 inline void DropTableStatement::clear_table_metadata() {
03722   if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
03723   _clear_bit(0);
03724 }
03725 inline const ::drizzled::message::TableMetadata& DropTableStatement::table_metadata() const {
03726   return table_metadata_ != NULL ? *table_metadata_ : *default_instance_->table_metadata_;
03727 }
03728 inline ::drizzled::message::TableMetadata* DropTableStatement::mutable_table_metadata() {
03729   _set_bit(0);
03730   if (table_metadata_ == NULL) table_metadata_ = new ::drizzled::message::TableMetadata;
03731   return table_metadata_;
03732 }
03733 
03734 // optional bool if_exists_clause = 2;
03735 inline bool DropTableStatement::has_if_exists_clause() const {
03736   return _has_bit(1);
03737 }
03738 inline void DropTableStatement::clear_if_exists_clause() {
03739   if_exists_clause_ = false;
03740   _clear_bit(1);
03741 }
03742 inline bool DropTableStatement::if_exists_clause() const {
03743   return if_exists_clause_;
03744 }
03745 inline void DropTableStatement::set_if_exists_clause(bool value) {
03746   _set_bit(1);
03747   if_exists_clause_ = value;
03748 }
03749 
03750 // -------------------------------------------------------------------
03751 
03752 // SetVariableStatement
03753 
03754 // required .drizzled.message.FieldMetadata variable_metadata = 1;
03755 inline bool SetVariableStatement::has_variable_metadata() const {
03756   return _has_bit(0);
03757 }
03758 inline void SetVariableStatement::clear_variable_metadata() {
03759   if (variable_metadata_ != NULL) variable_metadata_->::drizzled::message::FieldMetadata::Clear();
03760   _clear_bit(0);
03761 }
03762 inline const ::drizzled::message::FieldMetadata& SetVariableStatement::variable_metadata() const {
03763   return variable_metadata_ != NULL ? *variable_metadata_ : *default_instance_->variable_metadata_;
03764 }
03765 inline ::drizzled::message::FieldMetadata* SetVariableStatement::mutable_variable_metadata() {
03766   _set_bit(0);
03767   if (variable_metadata_ == NULL) variable_metadata_ = new ::drizzled::message::FieldMetadata;
03768   return variable_metadata_;
03769 }
03770 
03771 // required bytes variable_value = 2;
03772 inline bool SetVariableStatement::has_variable_value() const {
03773   return _has_bit(1);
03774 }
03775 inline void SetVariableStatement::clear_variable_value() {
03776   if (variable_value_ != &_default_variable_value_) {
03777     variable_value_->clear();
03778   }
03779   _clear_bit(1);
03780 }
03781 inline const ::std::string& SetVariableStatement::variable_value() const {
03782   return *variable_value_;
03783 }
03784 inline void SetVariableStatement::set_variable_value(const ::std::string& value) {
03785   _set_bit(1);
03786   if (variable_value_ == &_default_variable_value_) {
03787     variable_value_ = new ::std::string;
03788   }
03789   variable_value_->assign(value);
03790 }
03791 inline void SetVariableStatement::set_variable_value(const char* value) {
03792   _set_bit(1);
03793   if (variable_value_ == &_default_variable_value_) {
03794     variable_value_ = new ::std::string;
03795   }
03796   variable_value_->assign(value);
03797 }
03798 inline void SetVariableStatement::set_variable_value(const void* value, size_t size) {
03799   _set_bit(1);
03800   if (variable_value_ == &_default_variable_value_) {
03801     variable_value_ = new ::std::string;
03802   }
03803   variable_value_->assign(reinterpret_cast<const char*>(value), size);
03804 }
03805 inline ::std::string* SetVariableStatement::mutable_variable_value() {
03806   _set_bit(1);
03807   if (variable_value_ == &_default_variable_value_) {
03808     variable_value_ = new ::std::string;
03809   }
03810   return variable_value_;
03811 }
03812 
03813 // -------------------------------------------------------------------
03814 
03815 // Statement
03816 
03817 // required .drizzled.message.Statement.Type type = 1;
03818 inline bool Statement::has_type() const {
03819   return _has_bit(0);
03820 }
03821 inline void Statement::clear_type() {
03822   type_ = 0;
03823   _clear_bit(0);
03824 }
03825 inline ::drizzled::message::Statement_Type Statement::type() const {
03826   return static_cast< ::drizzled::message::Statement_Type >(type_);
03827 }
03828 inline void Statement::set_type(::drizzled::message::Statement_Type value) {
03829   GOOGLE_DCHECK(::drizzled::message::Statement_Type_IsValid(value));
03830   _set_bit(0);
03831   type_ = value;
03832 }
03833 
03834 // required uint64 start_timestamp = 2;
03835 inline bool Statement::has_start_timestamp() const {
03836   return _has_bit(1);
03837 }
03838 inline void Statement::clear_start_timestamp() {
03839   start_timestamp_ = GOOGLE_ULONGLONG(0);
03840   _clear_bit(1);
03841 }
03842 inline ::google::protobuf::uint64 Statement::start_timestamp() const {
03843   return start_timestamp_;
03844 }
03845 inline void Statement::set_start_timestamp(::google::protobuf::uint64 value) {
03846   _set_bit(1);
03847   start_timestamp_ = value;
03848 }
03849 
03850 // required uint64 end_timestamp = 3;
03851 inline bool Statement::has_end_timestamp() const {
03852   return _has_bit(2);
03853 }
03854 inline void Statement::clear_end_timestamp() {
03855   end_timestamp_ = GOOGLE_ULONGLONG(0);
03856   _clear_bit(2);
03857 }
03858 inline ::google::protobuf::uint64 Statement::end_timestamp() const {
03859   return end_timestamp_;
03860 }
03861 inline void Statement::set_end_timestamp(::google::protobuf::uint64 value) {
03862   _set_bit(2);
03863   end_timestamp_ = value;
03864 }
03865 
03866 // optional string sql = 4;
03867 inline bool Statement::has_sql() const {
03868   return _has_bit(3);
03869 }
03870 inline void Statement::clear_sql() {
03871   if (sql_ != &_default_sql_) {
03872     sql_->clear();
03873   }
03874   _clear_bit(3);
03875 }
03876 inline const ::std::string& Statement::sql() const {
03877   return *sql_;
03878 }
03879 inline void Statement::set_sql(const ::std::string& value) {
03880   _set_bit(3);
03881   if (sql_ == &_default_sql_) {
03882     sql_ = new ::std::string;
03883   }
03884   sql_->assign(value);
03885 }
03886 inline void Statement::set_sql(const char* value) {
03887   _set_bit(3);
03888   if (sql_ == &_default_sql_) {
03889     sql_ = new ::std::string;
03890   }
03891   sql_->assign(value);
03892 }
03893 inline void Statement::set_sql(const char* value, size_t size) {
03894   _set_bit(3);
03895   if (sql_ == &_default_sql_) {
03896     sql_ = new ::std::string;
03897   }
03898   sql_->assign(reinterpret_cast<const char*>(value), size);
03899 }
03900 inline ::std::string* Statement::mutable_sql() {
03901   _set_bit(3);
03902   if (sql_ == &_default_sql_) {
03903     sql_ = new ::std::string;
03904   }
03905   return sql_;
03906 }
03907 
03908 // optional .drizzled.message.InsertHeader insert_header = 5;
03909 inline bool Statement::has_insert_header() const {
03910   return _has_bit(4);
03911 }
03912 inline void Statement::clear_insert_header() {
03913   if (insert_header_ != NULL) insert_header_->::drizzled::message::InsertHeader::Clear();
03914   _clear_bit(4);
03915 }
03916 inline const ::drizzled::message::InsertHeader& Statement::insert_header() const {
03917   return insert_header_ != NULL ? *insert_header_ : *default_instance_->insert_header_;
03918 }
03919 inline ::drizzled::message::InsertHeader* Statement::mutable_insert_header() {
03920   _set_bit(4);
03921   if (insert_header_ == NULL) insert_header_ = new ::drizzled::message::InsertHeader;
03922   return insert_header_;
03923 }
03924 
03925 // optional .drizzled.message.InsertData insert_data = 6;
03926 inline bool Statement::has_insert_data() const {
03927   return _has_bit(5);
03928 }
03929 inline void Statement::clear_insert_data() {
03930   if (insert_data_ != NULL) insert_data_->::drizzled::message::InsertData::Clear();
03931   _clear_bit(5);
03932 }
03933 inline const ::drizzled::message::InsertData& Statement::insert_data() const {
03934   return insert_data_ != NULL ? *insert_data_ : *default_instance_->insert_data_;
03935 }
03936 inline ::drizzled::message::InsertData* Statement::mutable_insert_data() {
03937   _set_bit(5);
03938   if (insert_data_ == NULL) insert_data_ = new ::drizzled::message::InsertData;
03939   return insert_data_;
03940 }
03941 
03942 // optional .drizzled.message.UpdateHeader update_header = 7;
03943 inline bool Statement::has_update_header() const {
03944   return _has_bit(6);
03945 }
03946 inline void Statement::clear_update_header() {
03947   if (update_header_ != NULL) update_header_->::drizzled::message::UpdateHeader::Clear();
03948   _clear_bit(6);
03949 }
03950 inline const ::drizzled::message::UpdateHeader& Statement::update_header() const {
03951   return update_header_ != NULL ? *update_header_ : *default_instance_->update_header_;
03952 }
03953 inline ::drizzled::message::UpdateHeader* Statement::mutable_update_header() {
03954   _set_bit(6);
03955   if (update_header_ == NULL) update_header_ = new ::drizzled::message::UpdateHeader;
03956   return update_header_;
03957 }
03958 
03959 // optional .drizzled.message.UpdateData update_data = 8;
03960 inline bool Statement::has_update_data() const {
03961   return _has_bit(7);
03962 }
03963 inline void Statement::clear_update_data() {
03964   if (update_data_ != NULL) update_data_->::drizzled::message::UpdateData::Clear();
03965   _clear_bit(7);
03966 }
03967 inline const ::drizzled::message::UpdateData& Statement::update_data() const {
03968   return update_data_ != NULL ? *update_data_ : *default_instance_->update_data_;
03969 }
03970 inline ::drizzled::message::UpdateData* Statement::mutable_update_data() {
03971   _set_bit(7);
03972   if (update_data_ == NULL) update_data_ = new ::drizzled::message::UpdateData;
03973   return update_data_;
03974 }
03975 
03976 // optional .drizzled.message.DeleteHeader delete_header = 9;
03977 inline bool Statement::has_delete_header() const {
03978   return _has_bit(8);
03979 }
03980 inline void Statement::clear_delete_header() {
03981   if (delete_header_ != NULL) delete_header_->::drizzled::message::DeleteHeader::Clear();
03982   _clear_bit(8);
03983 }
03984 inline const ::drizzled::message::DeleteHeader& Statement::delete_header() const {
03985   return delete_header_ != NULL ? *delete_header_ : *default_instance_->delete_header_;
03986 }
03987 inline ::drizzled::message::DeleteHeader* Statement::mutable_delete_header() {
03988   _set_bit(8);
03989   if (delete_header_ == NULL) delete_header_ = new ::drizzled::message::DeleteHeader;
03990   return delete_header_;
03991 }
03992 
03993 // optional .drizzled.message.DeleteData delete_data = 10;
03994 inline bool Statement::has_delete_data() const {
03995   return _has_bit(9);
03996 }
03997 inline void Statement::clear_delete_data() {
03998   if (delete_data_ != NULL) delete_data_->::drizzled::message::DeleteData::Clear();
03999   _clear_bit(9);
04000 }
04001 inline const ::drizzled::message::DeleteData& Statement::delete_data() const {
04002   return delete_data_ != NULL ? *delete_data_ : *default_instance_->delete_data_;
04003 }
04004 inline ::drizzled::message::DeleteData* Statement::mutable_delete_data() {
04005   _set_bit(9);
04006   if (delete_data_ == NULL) delete_data_ = new ::drizzled::message::DeleteData;
04007   return delete_data_;
04008 }
04009 
04010 // optional .drizzled.message.TruncateTableStatement truncate_table_statement = 11;
04011 inline bool Statement::has_truncate_table_statement() const {
04012   return _has_bit(10);
04013 }
04014 inline void Statement::clear_truncate_table_statement() {
04015   if (truncate_table_statement_ != NULL) truncate_table_statement_->::drizzled::message::TruncateTableStatement::Clear();
04016   _clear_bit(10);
04017 }
04018 inline const ::drizzled::message::TruncateTableStatement& Statement::truncate_table_statement() const {
04019   return truncate_table_statement_ != NULL ? *truncate_table_statement_ : *default_instance_->truncate_table_statement_;
04020 }
04021 inline ::drizzled::message::TruncateTableStatement* Statement::mutable_truncate_table_statement() {
04022   _set_bit(10);
04023   if (truncate_table_statement_ == NULL) truncate_table_statement_ = new ::drizzled::message::TruncateTableStatement;
04024   return truncate_table_statement_;
04025 }
04026 
04027 // optional .drizzled.message.CreateSchemaStatement create_schema_statement = 12;
04028 inline bool Statement::has_create_schema_statement() const {
04029   return _has_bit(11);
04030 }
04031 inline void Statement::clear_create_schema_statement() {
04032   if (create_schema_statement_ != NULL) create_schema_statement_->::drizzled::message::CreateSchemaStatement::Clear();
04033   _clear_bit(11);
04034 }
04035 inline const ::drizzled::message::CreateSchemaStatement& Statement::create_schema_statement() const {
04036   return create_schema_statement_ != NULL ? *create_schema_statement_ : *default_instance_->create_schema_statement_;
04037 }
04038 inline ::drizzled::message::CreateSchemaStatement* Statement::mutable_create_schema_statement() {
04039   _set_bit(11);
04040   if (create_schema_statement_ == NULL) create_schema_statement_ = new ::drizzled::message::CreateSchemaStatement;
04041   return create_schema_statement_;
04042 }
04043 
04044 // optional .drizzled.message.DropSchemaStatement drop_schema_statement = 13;
04045 inline bool Statement::has_drop_schema_statement() const {
04046   return _has_bit(12);
04047 }
04048 inline void Statement::clear_drop_schema_statement() {
04049   if (drop_schema_statement_ != NULL) drop_schema_statement_->::drizzled::message::DropSchemaStatement::Clear();
04050   _clear_bit(12);
04051 }
04052 inline const ::drizzled::message::DropSchemaStatement& Statement::drop_schema_statement() const {
04053   return drop_schema_statement_ != NULL ? *drop_schema_statement_ : *default_instance_->drop_schema_statement_;
04054 }
04055 inline ::drizzled::message::DropSchemaStatement* Statement::mutable_drop_schema_statement() {
04056   _set_bit(12);
04057   if (drop_schema_statement_ == NULL) drop_schema_statement_ = new ::drizzled::message::DropSchemaStatement;
04058   return drop_schema_statement_;
04059 }
04060 
04061 // optional .drizzled.message.AlterSchemaStatement alter_schema_statement = 14;
04062 inline bool Statement::has_alter_schema_statement() const {
04063   return _has_bit(13);
04064 }
04065 inline void Statement::clear_alter_schema_statement() {
04066   if (alter_schema_statement_ != NULL) alter_schema_statement_->::drizzled::message::AlterSchemaStatement::Clear();
04067   _clear_bit(13);
04068 }
04069 inline const ::drizzled::message::AlterSchemaStatement& Statement::alter_schema_statement() const {
04070   return alter_schema_statement_ != NULL ? *alter_schema_statement_ : *default_instance_->alter_schema_statement_;
04071 }
04072 inline ::drizzled::message::AlterSchemaStatement* Statement::mutable_alter_schema_statement() {
04073   _set_bit(13);
04074   if (alter_schema_statement_ == NULL) alter_schema_statement_ = new ::drizzled::message::AlterSchemaStatement;
04075   return alter_schema_statement_;
04076 }
04077 
04078 // optional .drizzled.message.CreateTableStatement create_table_statement = 15;
04079 inline bool Statement::has_create_table_statement() const {
04080   return _has_bit(14);
04081 }
04082 inline void Statement::clear_create_table_statement() {
04083   if (create_table_statement_ != NULL) create_table_statement_->::drizzled::message::CreateTableStatement::Clear();
04084   _clear_bit(14);
04085 }
04086 inline const ::drizzled::message::CreateTableStatement& Statement::create_table_statement() const {
04087   return create_table_statement_ != NULL ? *create_table_statement_ : *default_instance_->create_table_statement_;
04088 }
04089 inline ::drizzled::message::CreateTableStatement* Statement::mutable_create_table_statement() {
04090   _set_bit(14);
04091   if (create_table_statement_ == NULL) create_table_statement_ = new ::drizzled::message::CreateTableStatement;
04092   return create_table_statement_;
04093 }
04094 
04095 // optional .drizzled.message.AlterTableStatement alter_table_statement = 16;
04096 inline bool Statement::has_alter_table_statement() const {
04097   return _has_bit(15);
04098 }
04099 inline void Statement::clear_alter_table_statement() {
04100   if (alter_table_statement_ != NULL) alter_table_statement_->::drizzled::message::AlterTableStatement::Clear();
04101   _clear_bit(15);
04102 }
04103 inline const ::drizzled::message::AlterTableStatement& Statement::alter_table_statement() const {
04104   return alter_table_statement_ != NULL ? *alter_table_statement_ : *default_instance_->alter_table_statement_;
04105 }
04106 inline ::drizzled::message::AlterTableStatement* Statement::mutable_alter_table_statement() {
04107   _set_bit(15);
04108   if (alter_table_statement_ == NULL) alter_table_statement_ = new ::drizzled::message::AlterTableStatement;
04109   return alter_table_statement_;
04110 }
04111 
04112 // optional .drizzled.message.DropTableStatement drop_table_statement = 17;
04113 inline bool Statement::has_drop_table_statement() const {
04114   return _has_bit(16);
04115 }
04116 inline void Statement::clear_drop_table_statement() {
04117   if (drop_table_statement_ != NULL) drop_table_statement_->::drizzled::message::DropTableStatement::Clear();
04118   _clear_bit(16);
04119 }
04120 inline const ::drizzled::message::DropTableStatement& Statement::drop_table_statement() const {
04121   return drop_table_statement_ != NULL ? *drop_table_statement_ : *default_instance_->drop_table_statement_;
04122 }
04123 inline ::drizzled::message::DropTableStatement* Statement::mutable_drop_table_statement() {
04124   _set_bit(16);
04125   if (drop_table_statement_ == NULL) drop_table_statement_ = new ::drizzled::message::DropTableStatement;
04126   return drop_table_statement_;
04127 }
04128 
04129 // optional .drizzled.message.SetVariableStatement set_variable_statement = 18;
04130 inline bool Statement::has_set_variable_statement() const {
04131   return _has_bit(17);
04132 }
04133 inline void Statement::clear_set_variable_statement() {
04134   if (set_variable_statement_ != NULL) set_variable_statement_->::drizzled::message::SetVariableStatement::Clear();
04135   _clear_bit(17);
04136 }
04137 inline const ::drizzled::message::SetVariableStatement& Statement::set_variable_statement() const {
04138   return set_variable_statement_ != NULL ? *set_variable_statement_ : *default_instance_->set_variable_statement_;
04139 }
04140 inline ::drizzled::message::SetVariableStatement* Statement::mutable_set_variable_statement() {
04141   _set_bit(17);
04142   if (set_variable_statement_ == NULL) set_variable_statement_ = new ::drizzled::message::SetVariableStatement;
04143   return set_variable_statement_;
04144 }
04145 
04146 // optional string raw_sql_schema = 19;
04147 inline bool Statement::has_raw_sql_schema() const {
04148   return _has_bit(18);
04149 }
04150 inline void Statement::clear_raw_sql_schema() {
04151   if (raw_sql_schema_ != &_default_raw_sql_schema_) {
04152     raw_sql_schema_->clear();
04153   }
04154   _clear_bit(18);
04155 }
04156 inline const ::std::string& Statement::raw_sql_schema() const {
04157   return *raw_sql_schema_;
04158 }
04159 inline void Statement::set_raw_sql_schema(const ::std::string& value) {
04160   _set_bit(18);
04161   if (raw_sql_schema_ == &_default_raw_sql_schema_) {
04162     raw_sql_schema_ = new ::std::string;
04163   }
04164   raw_sql_schema_->assign(value);
04165 }
04166 inline void Statement::set_raw_sql_schema(const char* value) {
04167   _set_bit(18);
04168   if (raw_sql_schema_ == &_default_raw_sql_schema_) {
04169     raw_sql_schema_ = new ::std::string;
04170   }
04171   raw_sql_schema_->assign(value);
04172 }
04173 inline void Statement::set_raw_sql_schema(const char* value, size_t size) {
04174   _set_bit(18);
04175   if (raw_sql_schema_ == &_default_raw_sql_schema_) {
04176     raw_sql_schema_ = new ::std::string;
04177   }
04178   raw_sql_schema_->assign(reinterpret_cast<const char*>(value), size);
04179 }
04180 inline ::std::string* Statement::mutable_raw_sql_schema() {
04181   _set_bit(18);
04182   if (raw_sql_schema_ == &_default_raw_sql_schema_) {
04183     raw_sql_schema_ = new ::std::string;
04184   }
04185   return raw_sql_schema_;
04186 }
04187 
04188 // -------------------------------------------------------------------
04189 
04190 // Transaction
04191 
04192 // required .drizzled.message.TransactionContext transaction_context = 1;
04193 inline bool Transaction::has_transaction_context() const {
04194   return _has_bit(0);
04195 }
04196 inline void Transaction::clear_transaction_context() {
04197   if (transaction_context_ != NULL) transaction_context_->::drizzled::message::TransactionContext::Clear();
04198   _clear_bit(0);
04199 }
04200 inline const ::drizzled::message::TransactionContext& Transaction::transaction_context() const {
04201   return transaction_context_ != NULL ? *transaction_context_ : *default_instance_->transaction_context_;
04202 }
04203 inline ::drizzled::message::TransactionContext* Transaction::mutable_transaction_context() {
04204   _set_bit(0);
04205   if (transaction_context_ == NULL) transaction_context_ = new ::drizzled::message::TransactionContext;
04206   return transaction_context_;
04207 }
04208 
04209 // repeated .drizzled.message.Statement statement = 2;
04210 inline int Transaction::statement_size() const {
04211   return statement_.size();
04212 }
04213 inline void Transaction::clear_statement() {
04214   statement_.Clear();
04215 }
04216 inline const ::drizzled::message::Statement& Transaction::statement(int index) const {
04217   return statement_.Get(index);
04218 }
04219 inline ::drizzled::message::Statement* Transaction::mutable_statement(int index) {
04220   return statement_.Mutable(index);
04221 }
04222 inline ::drizzled::message::Statement* Transaction::add_statement() {
04223   return statement_.Add();
04224 }
04225 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Statement >&
04226 Transaction::statement() const {
04227   return statement_;
04228 }
04229 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Statement >*
04230 Transaction::mutable_statement() {
04231   return &statement_;
04232 }
04233 
04234 // optional .drizzled.message.Event event = 3;
04235 inline bool Transaction::has_event() const {
04236   return _has_bit(2);
04237 }
04238 inline void Transaction::clear_event() {
04239   if (event_ != NULL) event_->::drizzled::message::Event::Clear();
04240   _clear_bit(2);
04241 }
04242 inline const ::drizzled::message::Event& Transaction::event() const {
04243   return event_ != NULL ? *event_ : *default_instance_->event_;
04244 }
04245 inline ::drizzled::message::Event* Transaction::mutable_event() {
04246   _set_bit(2);
04247   if (event_ == NULL) event_ = new ::drizzled::message::Event;
04248   return event_;
04249 }
04250 
04251 // optional uint32 segment_id = 4;
04252 inline bool Transaction::has_segment_id() const {
04253   return _has_bit(3);
04254 }
04255 inline void Transaction::clear_segment_id() {
04256   segment_id_ = 0u;
04257   _clear_bit(3);
04258 }
04259 inline ::google::protobuf::uint32 Transaction::segment_id() const {
04260   return segment_id_;
04261 }
04262 inline void Transaction::set_segment_id(::google::protobuf::uint32 value) {
04263   _set_bit(3);
04264   segment_id_ = value;
04265 }
04266 
04267 // optional bool end_segment = 5;
04268 inline bool Transaction::has_end_segment() const {
04269   return _has_bit(4);
04270 }
04271 inline void Transaction::clear_end_segment() {
04272   end_segment_ = false;
04273   _clear_bit(4);
04274 }
04275 inline bool Transaction::end_segment() const {
04276   return end_segment_;
04277 }
04278 inline void Transaction::set_end_segment(bool value) {
04279   _set_bit(4);
04280   end_segment_ = value;
04281 }
04282 
04283 
04284 // @@protoc_insertion_point(namespace_scope)
04285 
04286 }  // namespace message
04287 }  // namespace drizzled
04288 
04289 #ifndef SWIG
04290 namespace google {
04291 namespace protobuf {
04292 
04293 template <>
04294 inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Statement_Type>() {
04295   return ::drizzled::message::Statement_Type_descriptor();
04296 }
04297 
04298 }  // namespace google
04299 }  // namespace protobuf
04300 #endif  // SWIG
04301 
04302 // @@protoc_insertion_point(global_scope)
04303 
04304 #endif  // PROTOBUF_transaction_2eproto__INCLUDED