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