Drizzled Public API Documentation

resultset.pb.h

00001 // Generated by the protocol buffer compiler.  DO NOT EDIT!
00002 // source: resultset.proto
00003 
00004 #ifndef PROTOBUF_resultset_2eproto__INCLUDED
00005 #define PROTOBUF_resultset_2eproto__INCLUDED
00006 
00007 #include <string>
00008 
00009 #include <google/protobuf/stubs/common.h>
00010 
00011 #if GOOGLE_PROTOBUF_VERSION < 2003000
00012 #error This file was generated by a newer version of protoc which is
00013 #error incompatible with your Protocol Buffer headers.  Please update
00014 #error your headers.
00015 #endif
00016 #if 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
00017 #error This file was generated by an older version of protoc which is
00018 #error incompatible with your Protocol Buffer headers.  Please
00019 #error regenerate this file with a newer version of protoc.
00020 #endif
00021 
00022 #include <google/protobuf/generated_message_util.h>
00023 #include <google/protobuf/repeated_field.h>
00024 #include <google/protobuf/extension_set.h>
00025 #include <google/protobuf/generated_message_reflection.h>
00026 #include "table.pb.h"
00027 #include "schema.pb.h"
00028 // @@protoc_insertion_point(includes)
00029 
00030 namespace drizzled {
00031 namespace message {
00032 
00033 // Internal implementation detail -- do not call these.
00034 void  protobuf_AddDesc_resultset_2eproto();
00035 void protobuf_AssignDesc_resultset_2eproto();
00036 void protobuf_ShutdownFile_resultset_2eproto();
00037 
00038 class FieldMeta;
00039 class TableMeta;
00040 class SelectRecord;
00041 class SelectHeader;
00042 class SelectData;
00043 class Resultset;
00044 
00045 // ===================================================================
00046 
00047 class FieldMeta : public ::google::protobuf::Message {
00048  public:
00049   FieldMeta();
00050   virtual ~FieldMeta();
00051   
00052   FieldMeta(const FieldMeta& from);
00053   
00054   inline FieldMeta& operator=(const FieldMeta& from) {
00055     CopyFrom(from);
00056     return *this;
00057   }
00058   
00059   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00060     return _unknown_fields_;
00061   }
00062   
00063   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00064     return &_unknown_fields_;
00065   }
00066   
00067   static const ::google::protobuf::Descriptor* descriptor();
00068   static const FieldMeta& default_instance();
00069   
00070   void Swap(FieldMeta* other);
00071   
00072   // implements Message ----------------------------------------------
00073   
00074   FieldMeta* New() const;
00075   void CopyFrom(const ::google::protobuf::Message& from);
00076   void MergeFrom(const ::google::protobuf::Message& from);
00077   void CopyFrom(const FieldMeta& from);
00078   void MergeFrom(const FieldMeta& from);
00079   void Clear();
00080   bool IsInitialized() const;
00081   
00082   int ByteSize() const;
00083   bool MergePartialFromCodedStream(
00084       ::google::protobuf::io::CodedInputStream* input);
00085   void SerializeWithCachedSizes(
00086       ::google::protobuf::io::CodedOutputStream* output) const;
00087   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00088   int GetCachedSize() const { return _cached_size_; }
00089   private:
00090   void SharedCtor();
00091   void SharedDtor();
00092   void SetCachedSize(int size) const;
00093   public:
00094   
00095   ::google::protobuf::Metadata GetMetadata() const;
00096   
00097   // nested types ----------------------------------------------------
00098   
00099   // accessors -------------------------------------------------------
00100   
00101   // required string field_name = 1;
00102   inline bool has_field_name() const;
00103   inline void clear_field_name();
00104   static const int kFieldNameFieldNumber = 1;
00105   inline const ::std::string& field_name() const;
00106   inline void set_field_name(const ::std::string& value);
00107   inline void set_field_name(const char* value);
00108   inline void set_field_name(const char* value, size_t size);
00109   inline ::std::string* mutable_field_name();
00110   
00111   // optional string field_alias = 2;
00112   inline bool has_field_alias() const;
00113   inline void clear_field_alias();
00114   static const int kFieldAliasFieldNumber = 2;
00115   inline const ::std::string& field_alias() const;
00116   inline void set_field_alias(const ::std::string& value);
00117   inline void set_field_alias(const char* value);
00118   inline void set_field_alias(const char* value, size_t size);
00119   inline ::std::string* mutable_field_alias();
00120   
00121   // required string table_name = 3;
00122   inline bool has_table_name() const;
00123   inline void clear_table_name();
00124   static const int kTableNameFieldNumber = 3;
00125   inline const ::std::string& table_name() const;
00126   inline void set_table_name(const ::std::string& value);
00127   inline void set_table_name(const char* value);
00128   inline void set_table_name(const char* value, size_t size);
00129   inline ::std::string* mutable_table_name();
00130   
00131   // optional string table_alias = 4;
00132   inline bool has_table_alias() const;
00133   inline void clear_table_alias();
00134   static const int kTableAliasFieldNumber = 4;
00135   inline const ::std::string& table_alias() const;
00136   inline void set_table_alias(const ::std::string& value);
00137   inline void set_table_alias(const char* value);
00138   inline void set_table_alias(const char* value, size_t size);
00139   inline ::std::string* mutable_table_alias();
00140   
00141   // required string schema_name = 5;
00142   inline bool has_schema_name() const;
00143   inline void clear_schema_name();
00144   static const int kSchemaNameFieldNumber = 5;
00145   inline const ::std::string& schema_name() const;
00146   inline void set_schema_name(const ::std::string& value);
00147   inline void set_schema_name(const char* value);
00148   inline void set_schema_name(const char* value, size_t size);
00149   inline ::std::string* mutable_schema_name();
00150   
00151   // @@protoc_insertion_point(class_scope:drizzled.message.FieldMeta)
00152  private:
00153   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00154   mutable int _cached_size_;
00155   
00156   ::std::string* field_name_;
00157   static const ::std::string _default_field_name_;
00158   ::std::string* field_alias_;
00159   static const ::std::string _default_field_alias_;
00160   ::std::string* table_name_;
00161   static const ::std::string _default_table_name_;
00162   ::std::string* table_alias_;
00163   static const ::std::string _default_table_alias_;
00164   ::std::string* schema_name_;
00165   static const ::std::string _default_schema_name_;
00166   friend void  protobuf_AddDesc_resultset_2eproto();
00167   friend void protobuf_AssignDesc_resultset_2eproto();
00168   friend void protobuf_ShutdownFile_resultset_2eproto();
00169   
00170   ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
00171   
00172   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00173   inline bool _has_bit(int index) const {
00174     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00175   }
00176   inline void _set_bit(int index) {
00177     _has_bits_[index / 32] |= (1u << (index % 32));
00178   }
00179   inline void _clear_bit(int index) {
00180     _has_bits_[index / 32] &= ~(1u << (index % 32));
00181   }
00182   
00183   void InitAsDefaultInstance();
00184   static FieldMeta* default_instance_;
00185 };
00186 // -------------------------------------------------------------------
00187 
00188 class TableMeta : public ::google::protobuf::Message {
00189  public:
00190   TableMeta();
00191   virtual ~TableMeta();
00192   
00193   TableMeta(const TableMeta& from);
00194   
00195   inline TableMeta& operator=(const TableMeta& from) {
00196     CopyFrom(from);
00197     return *this;
00198   }
00199   
00200   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00201     return _unknown_fields_;
00202   }
00203   
00204   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00205     return &_unknown_fields_;
00206   }
00207   
00208   static const ::google::protobuf::Descriptor* descriptor();
00209   static const TableMeta& default_instance();
00210   
00211   void Swap(TableMeta* other);
00212   
00213   // implements Message ----------------------------------------------
00214   
00215   TableMeta* New() const;
00216   void CopyFrom(const ::google::protobuf::Message& from);
00217   void MergeFrom(const ::google::protobuf::Message& from);
00218   void CopyFrom(const TableMeta& from);
00219   void MergeFrom(const TableMeta& from);
00220   void Clear();
00221   bool IsInitialized() const;
00222   
00223   int ByteSize() const;
00224   bool MergePartialFromCodedStream(
00225       ::google::protobuf::io::CodedInputStream* input);
00226   void SerializeWithCachedSizes(
00227       ::google::protobuf::io::CodedOutputStream* output) const;
00228   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00229   int GetCachedSize() const { return _cached_size_; }
00230   private:
00231   void SharedCtor();
00232   void SharedDtor();
00233   void SetCachedSize(int size) const;
00234   public:
00235   
00236   ::google::protobuf::Metadata GetMetadata() const;
00237   
00238   // nested types ----------------------------------------------------
00239   
00240   // accessors -------------------------------------------------------
00241   
00242   // required string schema_name = 1;
00243   inline bool has_schema_name() const;
00244   inline void clear_schema_name();
00245   static const int kSchemaNameFieldNumber = 1;
00246   inline const ::std::string& schema_name() const;
00247   inline void set_schema_name(const ::std::string& value);
00248   inline void set_schema_name(const char* value);
00249   inline void set_schema_name(const char* value, size_t size);
00250   inline ::std::string* mutable_schema_name();
00251   
00252   // required string table_name = 2;
00253   inline bool has_table_name() const;
00254   inline void clear_table_name();
00255   static const int kTableNameFieldNumber = 2;
00256   inline const ::std::string& table_name() const;
00257   inline void set_table_name(const ::std::string& value);
00258   inline void set_table_name(const char* value);
00259   inline void set_table_name(const char* value, size_t size);
00260   inline ::std::string* mutable_table_name();
00261   
00262   // optional string table_alias = 3;
00263   inline bool has_table_alias() const;
00264   inline void clear_table_alias();
00265   static const int kTableAliasFieldNumber = 3;
00266   inline const ::std::string& table_alias() const;
00267   inline void set_table_alias(const ::std::string& value);
00268   inline void set_table_alias(const char* value);
00269   inline void set_table_alias(const char* value, size_t size);
00270   inline ::std::string* mutable_table_alias();
00271   
00272   // @@protoc_insertion_point(class_scope:drizzled.message.TableMeta)
00273  private:
00274   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00275   mutable int _cached_size_;
00276   
00277   ::std::string* schema_name_;
00278   static const ::std::string _default_schema_name_;
00279   ::std::string* table_name_;
00280   static const ::std::string _default_table_name_;
00281   ::std::string* table_alias_;
00282   static const ::std::string _default_table_alias_;
00283   friend void  protobuf_AddDesc_resultset_2eproto();
00284   friend void protobuf_AssignDesc_resultset_2eproto();
00285   friend void protobuf_ShutdownFile_resultset_2eproto();
00286   
00287   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
00288   
00289   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00290   inline bool _has_bit(int index) const {
00291     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00292   }
00293   inline void _set_bit(int index) {
00294     _has_bits_[index / 32] |= (1u << (index % 32));
00295   }
00296   inline void _clear_bit(int index) {
00297     _has_bits_[index / 32] &= ~(1u << (index % 32));
00298   }
00299   
00300   void InitAsDefaultInstance();
00301   static TableMeta* default_instance_;
00302 };
00303 // -------------------------------------------------------------------
00304 
00305 class SelectRecord : public ::google::protobuf::Message {
00306  public:
00307   SelectRecord();
00308   virtual ~SelectRecord();
00309   
00310   SelectRecord(const SelectRecord& from);
00311   
00312   inline SelectRecord& operator=(const SelectRecord& 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 SelectRecord& default_instance();
00327   
00328   void Swap(SelectRecord* other);
00329   
00330   // implements Message ----------------------------------------------
00331   
00332   SelectRecord* New() const;
00333   void CopyFrom(const ::google::protobuf::Message& from);
00334   void MergeFrom(const ::google::protobuf::Message& from);
00335   void CopyFrom(const SelectRecord& from);
00336   void MergeFrom(const SelectRecord& 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   // repeated bytes record_value = 1;
00360   inline int record_value_size() const;
00361   inline void clear_record_value();
00362   static const int kRecordValueFieldNumber = 1;
00363   inline const ::std::string& record_value(int index) const;
00364   inline ::std::string* mutable_record_value(int index);
00365   inline void set_record_value(int index, const ::std::string& value);
00366   inline void set_record_value(int index, const char* value);
00367   inline void set_record_value(int index, const void* value, size_t size);
00368   inline ::std::string* add_record_value();
00369   inline void add_record_value(const ::std::string& value);
00370   inline void add_record_value(const char* value);
00371   inline void add_record_value(const void* value, size_t size);
00372   inline const ::google::protobuf::RepeatedPtrField< ::std::string>& record_value() const;
00373   inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_record_value();
00374   
00375   // repeated bool is_null = 2;
00376   inline int is_null_size() const;
00377   inline void clear_is_null();
00378   static const int kIsNullFieldNumber = 2;
00379   inline bool is_null(int index) const;
00380   inline void set_is_null(int index, bool value);
00381   inline void add_is_null(bool value);
00382   inline const ::google::protobuf::RepeatedField< bool >&
00383       is_null() const;
00384   inline ::google::protobuf::RepeatedField< bool >*
00385       mutable_is_null();
00386   
00387   // @@protoc_insertion_point(class_scope:drizzled.message.SelectRecord)
00388  private:
00389   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00390   mutable int _cached_size_;
00391   
00392   ::google::protobuf::RepeatedPtrField< ::std::string> record_value_;
00393   ::google::protobuf::RepeatedField< bool > is_null_;
00394   friend void  protobuf_AddDesc_resultset_2eproto();
00395   friend void protobuf_AssignDesc_resultset_2eproto();
00396   friend void protobuf_ShutdownFile_resultset_2eproto();
00397   
00398   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
00399   
00400   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00401   inline bool _has_bit(int index) const {
00402     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00403   }
00404   inline void _set_bit(int index) {
00405     _has_bits_[index / 32] |= (1u << (index % 32));
00406   }
00407   inline void _clear_bit(int index) {
00408     _has_bits_[index / 32] &= ~(1u << (index % 32));
00409   }
00410   
00411   void InitAsDefaultInstance();
00412   static SelectRecord* default_instance_;
00413 };
00414 // -------------------------------------------------------------------
00415 
00416 class SelectHeader : public ::google::protobuf::Message {
00417  public:
00418   SelectHeader();
00419   virtual ~SelectHeader();
00420   
00421   SelectHeader(const SelectHeader& from);
00422   
00423   inline SelectHeader& operator=(const SelectHeader& from) {
00424     CopyFrom(from);
00425     return *this;
00426   }
00427   
00428   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00429     return _unknown_fields_;
00430   }
00431   
00432   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00433     return &_unknown_fields_;
00434   }
00435   
00436   static const ::google::protobuf::Descriptor* descriptor();
00437   static const SelectHeader& default_instance();
00438   
00439   void Swap(SelectHeader* other);
00440   
00441   // implements Message ----------------------------------------------
00442   
00443   SelectHeader* New() const;
00444   void CopyFrom(const ::google::protobuf::Message& from);
00445   void MergeFrom(const ::google::protobuf::Message& from);
00446   void CopyFrom(const SelectHeader& from);
00447   void MergeFrom(const SelectHeader& from);
00448   void Clear();
00449   bool IsInitialized() const;
00450   
00451   int ByteSize() const;
00452   bool MergePartialFromCodedStream(
00453       ::google::protobuf::io::CodedInputStream* input);
00454   void SerializeWithCachedSizes(
00455       ::google::protobuf::io::CodedOutputStream* output) const;
00456   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00457   int GetCachedSize() const { return _cached_size_; }
00458   private:
00459   void SharedCtor();
00460   void SharedDtor();
00461   void SetCachedSize(int size) const;
00462   public:
00463   
00464   ::google::protobuf::Metadata GetMetadata() const;
00465   
00466   // nested types ----------------------------------------------------
00467   
00468   // accessors -------------------------------------------------------
00469   
00470   // repeated .drizzled.message.TableMeta table_meta = 1;
00471   inline int table_meta_size() const;
00472   inline void clear_table_meta();
00473   static const int kTableMetaFieldNumber = 1;
00474   inline const ::drizzled::message::TableMeta& table_meta(int index) const;
00475   inline ::drizzled::message::TableMeta* mutable_table_meta(int index);
00476   inline ::drizzled::message::TableMeta* add_table_meta();
00477   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::TableMeta >&
00478       table_meta() const;
00479   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::TableMeta >*
00480       mutable_table_meta();
00481   
00482   // repeated .drizzled.message.FieldMeta field_meta = 2;
00483   inline int field_meta_size() const;
00484   inline void clear_field_meta();
00485   static const int kFieldMetaFieldNumber = 2;
00486   inline const ::drizzled::message::FieldMeta& field_meta(int index) const;
00487   inline ::drizzled::message::FieldMeta* mutable_field_meta(int index);
00488   inline ::drizzled::message::FieldMeta* add_field_meta();
00489   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMeta >&
00490       field_meta() const;
00491   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMeta >*
00492       mutable_field_meta();
00493   
00494   // @@protoc_insertion_point(class_scope:drizzled.message.SelectHeader)
00495  private:
00496   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00497   mutable int _cached_size_;
00498   
00499   ::google::protobuf::RepeatedPtrField< ::drizzled::message::TableMeta > table_meta_;
00500   ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMeta > field_meta_;
00501   friend void  protobuf_AddDesc_resultset_2eproto();
00502   friend void protobuf_AssignDesc_resultset_2eproto();
00503   friend void protobuf_ShutdownFile_resultset_2eproto();
00504   
00505   ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
00506   
00507   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00508   inline bool _has_bit(int index) const {
00509     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00510   }
00511   inline void _set_bit(int index) {
00512     _has_bits_[index / 32] |= (1u << (index % 32));
00513   }
00514   inline void _clear_bit(int index) {
00515     _has_bits_[index / 32] &= ~(1u << (index % 32));
00516   }
00517   
00518   void InitAsDefaultInstance();
00519   static SelectHeader* default_instance_;
00520 };
00521 // -------------------------------------------------------------------
00522 
00523 class SelectData : public ::google::protobuf::Message {
00524  public:
00525   SelectData();
00526   virtual ~SelectData();
00527   
00528   SelectData(const SelectData& from);
00529   
00530   inline SelectData& operator=(const SelectData& from) {
00531     CopyFrom(from);
00532     return *this;
00533   }
00534   
00535   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00536     return _unknown_fields_;
00537   }
00538   
00539   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00540     return &_unknown_fields_;
00541   }
00542   
00543   static const ::google::protobuf::Descriptor* descriptor();
00544   static const SelectData& default_instance();
00545   
00546   void Swap(SelectData* other);
00547   
00548   // implements Message ----------------------------------------------
00549   
00550   SelectData* New() const;
00551   void CopyFrom(const ::google::protobuf::Message& from);
00552   void MergeFrom(const ::google::protobuf::Message& from);
00553   void CopyFrom(const SelectData& from);
00554   void MergeFrom(const SelectData& from);
00555   void Clear();
00556   bool IsInitialized() const;
00557   
00558   int ByteSize() const;
00559   bool MergePartialFromCodedStream(
00560       ::google::protobuf::io::CodedInputStream* input);
00561   void SerializeWithCachedSizes(
00562       ::google::protobuf::io::CodedOutputStream* output) const;
00563   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00564   int GetCachedSize() const { return _cached_size_; }
00565   private:
00566   void SharedCtor();
00567   void SharedDtor();
00568   void SetCachedSize(int size) const;
00569   public:
00570   
00571   ::google::protobuf::Metadata GetMetadata() const;
00572   
00573   // nested types ----------------------------------------------------
00574   
00575   // accessors -------------------------------------------------------
00576   
00577   // required uint32 segment_id = 1;
00578   inline bool has_segment_id() const;
00579   inline void clear_segment_id();
00580   static const int kSegmentIdFieldNumber = 1;
00581   inline ::google::protobuf::uint32 segment_id() const;
00582   inline void set_segment_id(::google::protobuf::uint32 value);
00583   
00584   // required bool end_segment = 2;
00585   inline bool has_end_segment() const;
00586   inline void clear_end_segment();
00587   static const int kEndSegmentFieldNumber = 2;
00588   inline bool end_segment() const;
00589   inline void set_end_segment(bool value);
00590   
00591   // repeated .drizzled.message.SelectRecord record = 3;
00592   inline int record_size() const;
00593   inline void clear_record();
00594   static const int kRecordFieldNumber = 3;
00595   inline const ::drizzled::message::SelectRecord& record(int index) const;
00596   inline ::drizzled::message::SelectRecord* mutable_record(int index);
00597   inline ::drizzled::message::SelectRecord* add_record();
00598   inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::SelectRecord >&
00599       record() const;
00600   inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::SelectRecord >*
00601       mutable_record();
00602   
00603   // @@protoc_insertion_point(class_scope:drizzled.message.SelectData)
00604  private:
00605   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00606   mutable int _cached_size_;
00607   
00608   ::google::protobuf::uint32 segment_id_;
00609   bool end_segment_;
00610   ::google::protobuf::RepeatedPtrField< ::drizzled::message::SelectRecord > record_;
00611   friend void  protobuf_AddDesc_resultset_2eproto();
00612   friend void protobuf_AssignDesc_resultset_2eproto();
00613   friend void protobuf_ShutdownFile_resultset_2eproto();
00614   
00615   ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
00616   
00617   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00618   inline bool _has_bit(int index) const {
00619     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00620   }
00621   inline void _set_bit(int index) {
00622     _has_bits_[index / 32] |= (1u << (index % 32));
00623   }
00624   inline void _clear_bit(int index) {
00625     _has_bits_[index / 32] &= ~(1u << (index % 32));
00626   }
00627   
00628   void InitAsDefaultInstance();
00629   static SelectData* default_instance_;
00630 };
00631 // -------------------------------------------------------------------
00632 
00633 class Resultset : public ::google::protobuf::Message {
00634  public:
00635   Resultset();
00636   virtual ~Resultset();
00637   
00638   Resultset(const Resultset& from);
00639   
00640   inline Resultset& operator=(const Resultset& from) {
00641     CopyFrom(from);
00642     return *this;
00643   }
00644   
00645   inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
00646     return _unknown_fields_;
00647   }
00648   
00649   inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
00650     return &_unknown_fields_;
00651   }
00652   
00653   static const ::google::protobuf::Descriptor* descriptor();
00654   static const Resultset& default_instance();
00655   
00656   void Swap(Resultset* other);
00657   
00658   // implements Message ----------------------------------------------
00659   
00660   Resultset* New() const;
00661   void CopyFrom(const ::google::protobuf::Message& from);
00662   void MergeFrom(const ::google::protobuf::Message& from);
00663   void CopyFrom(const Resultset& from);
00664   void MergeFrom(const Resultset& from);
00665   void Clear();
00666   bool IsInitialized() const;
00667   
00668   int ByteSize() const;
00669   bool MergePartialFromCodedStream(
00670       ::google::protobuf::io::CodedInputStream* input);
00671   void SerializeWithCachedSizes(
00672       ::google::protobuf::io::CodedOutputStream* output) const;
00673   ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
00674   int GetCachedSize() const { return _cached_size_; }
00675   private:
00676   void SharedCtor();
00677   void SharedDtor();
00678   void SetCachedSize(int size) const;
00679   public:
00680   
00681   ::google::protobuf::Metadata GetMetadata() const;
00682   
00683   // nested types ----------------------------------------------------
00684   
00685   // accessors -------------------------------------------------------
00686   
00687   // required string key = 1;
00688   inline bool has_key() const;
00689   inline void clear_key();
00690   static const int kKeyFieldNumber = 1;
00691   inline const ::std::string& key() const;
00692   inline void set_key(const ::std::string& value);
00693   inline void set_key(const char* value);
00694   inline void set_key(const char* value, size_t size);
00695   inline ::std::string* mutable_key();
00696   
00697   // required string schema = 2;
00698   inline bool has_schema() const;
00699   inline void clear_schema();
00700   static const int kSchemaFieldNumber = 2;
00701   inline const ::std::string& schema() const;
00702   inline void set_schema(const ::std::string& value);
00703   inline void set_schema(const char* value);
00704   inline void set_schema(const char* value, size_t size);
00705   inline ::std::string* mutable_schema();
00706   
00707   // optional string sql = 3;
00708   inline bool has_sql() const;
00709   inline void clear_sql();
00710   static const int kSqlFieldNumber = 3;
00711   inline const ::std::string& sql() const;
00712   inline void set_sql(const ::std::string& value);
00713   inline void set_sql(const char* value);
00714   inline void set_sql(const char* value, size_t size);
00715   inline ::std::string* mutable_sql();
00716   
00717   // optional .drizzled.message.SelectHeader select_header = 4;
00718   inline bool has_select_header() const;
00719   inline void clear_select_header();
00720   static const int kSelectHeaderFieldNumber = 4;
00721   inline const ::drizzled::message::SelectHeader& select_header() const;
00722   inline ::drizzled::message::SelectHeader* mutable_select_header();
00723   
00724   // optional .drizzled.message.SelectData select_data = 5;
00725   inline bool has_select_data() const;
00726   inline void clear_select_data();
00727   static const int kSelectDataFieldNumber = 5;
00728   inline const ::drizzled::message::SelectData& select_data() const;
00729   inline ::drizzled::message::SelectData* mutable_select_data();
00730   
00731   // @@protoc_insertion_point(class_scope:drizzled.message.Resultset)
00732  private:
00733   ::google::protobuf::UnknownFieldSet _unknown_fields_;
00734   mutable int _cached_size_;
00735   
00736   ::std::string* key_;
00737   static const ::std::string _default_key_;
00738   ::std::string* schema_;
00739   static const ::std::string _default_schema_;
00740   ::std::string* sql_;
00741   static const ::std::string _default_sql_;
00742   ::drizzled::message::SelectHeader* select_header_;
00743   ::drizzled::message::SelectData* select_data_;
00744   friend void  protobuf_AddDesc_resultset_2eproto();
00745   friend void protobuf_AssignDesc_resultset_2eproto();
00746   friend void protobuf_ShutdownFile_resultset_2eproto();
00747   
00748   ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
00749   
00750   // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
00751   inline bool _has_bit(int index) const {
00752     return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
00753   }
00754   inline void _set_bit(int index) {
00755     _has_bits_[index / 32] |= (1u << (index % 32));
00756   }
00757   inline void _clear_bit(int index) {
00758     _has_bits_[index / 32] &= ~(1u << (index % 32));
00759   }
00760   
00761   void InitAsDefaultInstance();
00762   static Resultset* default_instance_;
00763 };
00764 // ===================================================================
00765 
00766 
00767 // ===================================================================
00768 
00769 // FieldMeta
00770 
00771 // required string field_name = 1;
00772 inline bool FieldMeta::has_field_name() const {
00773   return _has_bit(0);
00774 }
00775 inline void FieldMeta::clear_field_name() {
00776   if (field_name_ != &_default_field_name_) {
00777     field_name_->clear();
00778   }
00779   _clear_bit(0);
00780 }
00781 inline const ::std::string& FieldMeta::field_name() const {
00782   return *field_name_;
00783 }
00784 inline void FieldMeta::set_field_name(const ::std::string& value) {
00785   _set_bit(0);
00786   if (field_name_ == &_default_field_name_) {
00787     field_name_ = new ::std::string;
00788   }
00789   field_name_->assign(value);
00790 }
00791 inline void FieldMeta::set_field_name(const char* value) {
00792   _set_bit(0);
00793   if (field_name_ == &_default_field_name_) {
00794     field_name_ = new ::std::string;
00795   }
00796   field_name_->assign(value);
00797 }
00798 inline void FieldMeta::set_field_name(const char* value, size_t size) {
00799   _set_bit(0);
00800   if (field_name_ == &_default_field_name_) {
00801     field_name_ = new ::std::string;
00802   }
00803   field_name_->assign(reinterpret_cast<const char*>(value), size);
00804 }
00805 inline ::std::string* FieldMeta::mutable_field_name() {
00806   _set_bit(0);
00807   if (field_name_ == &_default_field_name_) {
00808     field_name_ = new ::std::string;
00809   }
00810   return field_name_;
00811 }
00812 
00813 // optional string field_alias = 2;
00814 inline bool FieldMeta::has_field_alias() const {
00815   return _has_bit(1);
00816 }
00817 inline void FieldMeta::clear_field_alias() {
00818   if (field_alias_ != &_default_field_alias_) {
00819     field_alias_->clear();
00820   }
00821   _clear_bit(1);
00822 }
00823 inline const ::std::string& FieldMeta::field_alias() const {
00824   return *field_alias_;
00825 }
00826 inline void FieldMeta::set_field_alias(const ::std::string& value) {
00827   _set_bit(1);
00828   if (field_alias_ == &_default_field_alias_) {
00829     field_alias_ = new ::std::string;
00830   }
00831   field_alias_->assign(value);
00832 }
00833 inline void FieldMeta::set_field_alias(const char* value) {
00834   _set_bit(1);
00835   if (field_alias_ == &_default_field_alias_) {
00836     field_alias_ = new ::std::string;
00837   }
00838   field_alias_->assign(value);
00839 }
00840 inline void FieldMeta::set_field_alias(const char* value, size_t size) {
00841   _set_bit(1);
00842   if (field_alias_ == &_default_field_alias_) {
00843     field_alias_ = new ::std::string;
00844   }
00845   field_alias_->assign(reinterpret_cast<const char*>(value), size);
00846 }
00847 inline ::std::string* FieldMeta::mutable_field_alias() {
00848   _set_bit(1);
00849   if (field_alias_ == &_default_field_alias_) {
00850     field_alias_ = new ::std::string;
00851   }
00852   return field_alias_;
00853 }
00854 
00855 // required string table_name = 3;
00856 inline bool FieldMeta::has_table_name() const {
00857   return _has_bit(2);
00858 }
00859 inline void FieldMeta::clear_table_name() {
00860   if (table_name_ != &_default_table_name_) {
00861     table_name_->clear();
00862   }
00863   _clear_bit(2);
00864 }
00865 inline const ::std::string& FieldMeta::table_name() const {
00866   return *table_name_;
00867 }
00868 inline void FieldMeta::set_table_name(const ::std::string& value) {
00869   _set_bit(2);
00870   if (table_name_ == &_default_table_name_) {
00871     table_name_ = new ::std::string;
00872   }
00873   table_name_->assign(value);
00874 }
00875 inline void FieldMeta::set_table_name(const char* value) {
00876   _set_bit(2);
00877   if (table_name_ == &_default_table_name_) {
00878     table_name_ = new ::std::string;
00879   }
00880   table_name_->assign(value);
00881 }
00882 inline void FieldMeta::set_table_name(const char* value, size_t size) {
00883   _set_bit(2);
00884   if (table_name_ == &_default_table_name_) {
00885     table_name_ = new ::std::string;
00886   }
00887   table_name_->assign(reinterpret_cast<const char*>(value), size);
00888 }
00889 inline ::std::string* FieldMeta::mutable_table_name() {
00890   _set_bit(2);
00891   if (table_name_ == &_default_table_name_) {
00892     table_name_ = new ::std::string;
00893   }
00894   return table_name_;
00895 }
00896 
00897 // optional string table_alias = 4;
00898 inline bool FieldMeta::has_table_alias() const {
00899   return _has_bit(3);
00900 }
00901 inline void FieldMeta::clear_table_alias() {
00902   if (table_alias_ != &_default_table_alias_) {
00903     table_alias_->clear();
00904   }
00905   _clear_bit(3);
00906 }
00907 inline const ::std::string& FieldMeta::table_alias() const {
00908   return *table_alias_;
00909 }
00910 inline void FieldMeta::set_table_alias(const ::std::string& value) {
00911   _set_bit(3);
00912   if (table_alias_ == &_default_table_alias_) {
00913     table_alias_ = new ::std::string;
00914   }
00915   table_alias_->assign(value);
00916 }
00917 inline void FieldMeta::set_table_alias(const char* value) {
00918   _set_bit(3);
00919   if (table_alias_ == &_default_table_alias_) {
00920     table_alias_ = new ::std::string;
00921   }
00922   table_alias_->assign(value);
00923 }
00924 inline void FieldMeta::set_table_alias(const char* value, size_t size) {
00925   _set_bit(3);
00926   if (table_alias_ == &_default_table_alias_) {
00927     table_alias_ = new ::std::string;
00928   }
00929   table_alias_->assign(reinterpret_cast<const char*>(value), size);
00930 }
00931 inline ::std::string* FieldMeta::mutable_table_alias() {
00932   _set_bit(3);
00933   if (table_alias_ == &_default_table_alias_) {
00934     table_alias_ = new ::std::string;
00935   }
00936   return table_alias_;
00937 }
00938 
00939 // required string schema_name = 5;
00940 inline bool FieldMeta::has_schema_name() const {
00941   return _has_bit(4);
00942 }
00943 inline void FieldMeta::clear_schema_name() {
00944   if (schema_name_ != &_default_schema_name_) {
00945     schema_name_->clear();
00946   }
00947   _clear_bit(4);
00948 }
00949 inline const ::std::string& FieldMeta::schema_name() const {
00950   return *schema_name_;
00951 }
00952 inline void FieldMeta::set_schema_name(const ::std::string& value) {
00953   _set_bit(4);
00954   if (schema_name_ == &_default_schema_name_) {
00955     schema_name_ = new ::std::string;
00956   }
00957   schema_name_->assign(value);
00958 }
00959 inline void FieldMeta::set_schema_name(const char* value) {
00960   _set_bit(4);
00961   if (schema_name_ == &_default_schema_name_) {
00962     schema_name_ = new ::std::string;
00963   }
00964   schema_name_->assign(value);
00965 }
00966 inline void FieldMeta::set_schema_name(const char* value, size_t size) {
00967   _set_bit(4);
00968   if (schema_name_ == &_default_schema_name_) {
00969     schema_name_ = new ::std::string;
00970   }
00971   schema_name_->assign(reinterpret_cast<const char*>(value), size);
00972 }
00973 inline ::std::string* FieldMeta::mutable_schema_name() {
00974   _set_bit(4);
00975   if (schema_name_ == &_default_schema_name_) {
00976     schema_name_ = new ::std::string;
00977   }
00978   return schema_name_;
00979 }
00980 
00981 // -------------------------------------------------------------------
00982 
00983 // TableMeta
00984 
00985 // required string schema_name = 1;
00986 inline bool TableMeta::has_schema_name() const {
00987   return _has_bit(0);
00988 }
00989 inline void TableMeta::clear_schema_name() {
00990   if (schema_name_ != &_default_schema_name_) {
00991     schema_name_->clear();
00992   }
00993   _clear_bit(0);
00994 }
00995 inline const ::std::string& TableMeta::schema_name() const {
00996   return *schema_name_;
00997 }
00998 inline void TableMeta::set_schema_name(const ::std::string& value) {
00999   _set_bit(0);
01000   if (schema_name_ == &_default_schema_name_) {
01001     schema_name_ = new ::std::string;
01002   }
01003   schema_name_->assign(value);
01004 }
01005 inline void TableMeta::set_schema_name(const char* value) {
01006   _set_bit(0);
01007   if (schema_name_ == &_default_schema_name_) {
01008     schema_name_ = new ::std::string;
01009   }
01010   schema_name_->assign(value);
01011 }
01012 inline void TableMeta::set_schema_name(const char* value, size_t size) {
01013   _set_bit(0);
01014   if (schema_name_ == &_default_schema_name_) {
01015     schema_name_ = new ::std::string;
01016   }
01017   schema_name_->assign(reinterpret_cast<const char*>(value), size);
01018 }
01019 inline ::std::string* TableMeta::mutable_schema_name() {
01020   _set_bit(0);
01021   if (schema_name_ == &_default_schema_name_) {
01022     schema_name_ = new ::std::string;
01023   }
01024   return schema_name_;
01025 }
01026 
01027 // required string table_name = 2;
01028 inline bool TableMeta::has_table_name() const {
01029   return _has_bit(1);
01030 }
01031 inline void TableMeta::clear_table_name() {
01032   if (table_name_ != &_default_table_name_) {
01033     table_name_->clear();
01034   }
01035   _clear_bit(1);
01036 }
01037 inline const ::std::string& TableMeta::table_name() const {
01038   return *table_name_;
01039 }
01040 inline void TableMeta::set_table_name(const ::std::string& value) {
01041   _set_bit(1);
01042   if (table_name_ == &_default_table_name_) {
01043     table_name_ = new ::std::string;
01044   }
01045   table_name_->assign(value);
01046 }
01047 inline void TableMeta::set_table_name(const char* value) {
01048   _set_bit(1);
01049   if (table_name_ == &_default_table_name_) {
01050     table_name_ = new ::std::string;
01051   }
01052   table_name_->assign(value);
01053 }
01054 inline void TableMeta::set_table_name(const char* value, size_t size) {
01055   _set_bit(1);
01056   if (table_name_ == &_default_table_name_) {
01057     table_name_ = new ::std::string;
01058   }
01059   table_name_->assign(reinterpret_cast<const char*>(value), size);
01060 }
01061 inline ::std::string* TableMeta::mutable_table_name() {
01062   _set_bit(1);
01063   if (table_name_ == &_default_table_name_) {
01064     table_name_ = new ::std::string;
01065   }
01066   return table_name_;
01067 }
01068 
01069 // optional string table_alias = 3;
01070 inline bool TableMeta::has_table_alias() const {
01071   return _has_bit(2);
01072 }
01073 inline void TableMeta::clear_table_alias() {
01074   if (table_alias_ != &_default_table_alias_) {
01075     table_alias_->clear();
01076   }
01077   _clear_bit(2);
01078 }
01079 inline const ::std::string& TableMeta::table_alias() const {
01080   return *table_alias_;
01081 }
01082 inline void TableMeta::set_table_alias(const ::std::string& value) {
01083   _set_bit(2);
01084   if (table_alias_ == &_default_table_alias_) {
01085     table_alias_ = new ::std::string;
01086   }
01087   table_alias_->assign(value);
01088 }
01089 inline void TableMeta::set_table_alias(const char* value) {
01090   _set_bit(2);
01091   if (table_alias_ == &_default_table_alias_) {
01092     table_alias_ = new ::std::string;
01093   }
01094   table_alias_->assign(value);
01095 }
01096 inline void TableMeta::set_table_alias(const char* value, size_t size) {
01097   _set_bit(2);
01098   if (table_alias_ == &_default_table_alias_) {
01099     table_alias_ = new ::std::string;
01100   }
01101   table_alias_->assign(reinterpret_cast<const char*>(value), size);
01102 }
01103 inline ::std::string* TableMeta::mutable_table_alias() {
01104   _set_bit(2);
01105   if (table_alias_ == &_default_table_alias_) {
01106     table_alias_ = new ::std::string;
01107   }
01108   return table_alias_;
01109 }
01110 
01111 // -------------------------------------------------------------------
01112 
01113 // SelectRecord
01114 
01115 // repeated bytes record_value = 1;
01116 inline int SelectRecord::record_value_size() const {
01117   return record_value_.size();
01118 }
01119 inline void SelectRecord::clear_record_value() {
01120   record_value_.Clear();
01121 }
01122 inline const ::std::string& SelectRecord::record_value(int index) const {
01123   return record_value_.Get(index);
01124 }
01125 inline ::std::string* SelectRecord::mutable_record_value(int index) {
01126   return record_value_.Mutable(index);
01127 }
01128 inline void SelectRecord::set_record_value(int index, const ::std::string& value) {
01129   record_value_.Mutable(index)->assign(value);
01130 }
01131 inline void SelectRecord::set_record_value(int index, const char* value) {
01132   record_value_.Mutable(index)->assign(value);
01133 }
01134 inline void SelectRecord::set_record_value(int index, const void* value, size_t size) {
01135   record_value_.Mutable(index)->assign(
01136     reinterpret_cast<const char*>(value), size);
01137 }
01138 inline ::std::string* SelectRecord::add_record_value() {
01139   return record_value_.Add();
01140 }
01141 inline void SelectRecord::add_record_value(const ::std::string& value) {
01142   record_value_.Add()->assign(value);
01143 }
01144 inline void SelectRecord::add_record_value(const char* value) {
01145   record_value_.Add()->assign(value);
01146 }
01147 inline void SelectRecord::add_record_value(const void* value, size_t size) {
01148   record_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
01149 }
01150 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
01151 SelectRecord::record_value() const {
01152   return record_value_;
01153 }
01154 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
01155 SelectRecord::mutable_record_value() {
01156   return &record_value_;
01157 }
01158 
01159 // repeated bool is_null = 2;
01160 inline int SelectRecord::is_null_size() const {
01161   return is_null_.size();
01162 }
01163 inline void SelectRecord::clear_is_null() {
01164   is_null_.Clear();
01165 }
01166 inline bool SelectRecord::is_null(int index) const {
01167   return is_null_.Get(index);
01168 }
01169 inline void SelectRecord::set_is_null(int index, bool value) {
01170   is_null_.Set(index, value);
01171 }
01172 inline void SelectRecord::add_is_null(bool value) {
01173   is_null_.Add(value);
01174 }
01175 inline const ::google::protobuf::RepeatedField< bool >&
01176 SelectRecord::is_null() const {
01177   return is_null_;
01178 }
01179 inline ::google::protobuf::RepeatedField< bool >*
01180 SelectRecord::mutable_is_null() {
01181   return &is_null_;
01182 }
01183 
01184 // -------------------------------------------------------------------
01185 
01186 // SelectHeader
01187 
01188 // repeated .drizzled.message.TableMeta table_meta = 1;
01189 inline int SelectHeader::table_meta_size() const {
01190   return table_meta_.size();
01191 }
01192 inline void SelectHeader::clear_table_meta() {
01193   table_meta_.Clear();
01194 }
01195 inline const ::drizzled::message::TableMeta& SelectHeader::table_meta(int index) const {
01196   return table_meta_.Get(index);
01197 }
01198 inline ::drizzled::message::TableMeta* SelectHeader::mutable_table_meta(int index) {
01199   return table_meta_.Mutable(index);
01200 }
01201 inline ::drizzled::message::TableMeta* SelectHeader::add_table_meta() {
01202   return table_meta_.Add();
01203 }
01204 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::TableMeta >&
01205 SelectHeader::table_meta() const {
01206   return table_meta_;
01207 }
01208 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::TableMeta >*
01209 SelectHeader::mutable_table_meta() {
01210   return &table_meta_;
01211 }
01212 
01213 // repeated .drizzled.message.FieldMeta field_meta = 2;
01214 inline int SelectHeader::field_meta_size() const {
01215   return field_meta_.size();
01216 }
01217 inline void SelectHeader::clear_field_meta() {
01218   field_meta_.Clear();
01219 }
01220 inline const ::drizzled::message::FieldMeta& SelectHeader::field_meta(int index) const {
01221   return field_meta_.Get(index);
01222 }
01223 inline ::drizzled::message::FieldMeta* SelectHeader::mutable_field_meta(int index) {
01224   return field_meta_.Mutable(index);
01225 }
01226 inline ::drizzled::message::FieldMeta* SelectHeader::add_field_meta() {
01227   return field_meta_.Add();
01228 }
01229 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMeta >&
01230 SelectHeader::field_meta() const {
01231   return field_meta_;
01232 }
01233 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMeta >*
01234 SelectHeader::mutable_field_meta() {
01235   return &field_meta_;
01236 }
01237 
01238 // -------------------------------------------------------------------
01239 
01240 // SelectData
01241 
01242 // required uint32 segment_id = 1;
01243 inline bool SelectData::has_segment_id() const {
01244   return _has_bit(0);
01245 }
01246 inline void SelectData::clear_segment_id() {
01247   segment_id_ = 0u;
01248   _clear_bit(0);
01249 }
01250 inline ::google::protobuf::uint32 SelectData::segment_id() const {
01251   return segment_id_;
01252 }
01253 inline void SelectData::set_segment_id(::google::protobuf::uint32 value) {
01254   _set_bit(0);
01255   segment_id_ = value;
01256 }
01257 
01258 // required bool end_segment = 2;
01259 inline bool SelectData::has_end_segment() const {
01260   return _has_bit(1);
01261 }
01262 inline void SelectData::clear_end_segment() {
01263   end_segment_ = false;
01264   _clear_bit(1);
01265 }
01266 inline bool SelectData::end_segment() const {
01267   return end_segment_;
01268 }
01269 inline void SelectData::set_end_segment(bool value) {
01270   _set_bit(1);
01271   end_segment_ = value;
01272 }
01273 
01274 // repeated .drizzled.message.SelectRecord record = 3;
01275 inline int SelectData::record_size() const {
01276   return record_.size();
01277 }
01278 inline void SelectData::clear_record() {
01279   record_.Clear();
01280 }
01281 inline const ::drizzled::message::SelectRecord& SelectData::record(int index) const {
01282   return record_.Get(index);
01283 }
01284 inline ::drizzled::message::SelectRecord* SelectData::mutable_record(int index) {
01285   return record_.Mutable(index);
01286 }
01287 inline ::drizzled::message::SelectRecord* SelectData::add_record() {
01288   return record_.Add();
01289 }
01290 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::SelectRecord >&
01291 SelectData::record() const {
01292   return record_;
01293 }
01294 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::SelectRecord >*
01295 SelectData::mutable_record() {
01296   return &record_;
01297 }
01298 
01299 // -------------------------------------------------------------------
01300 
01301 // Resultset
01302 
01303 // required string key = 1;
01304 inline bool Resultset::has_key() const {
01305   return _has_bit(0);
01306 }
01307 inline void Resultset::clear_key() {
01308   if (key_ != &_default_key_) {
01309     key_->clear();
01310   }
01311   _clear_bit(0);
01312 }
01313 inline const ::std::string& Resultset::key() const {
01314   return *key_;
01315 }
01316 inline void Resultset::set_key(const ::std::string& value) {
01317   _set_bit(0);
01318   if (key_ == &_default_key_) {
01319     key_ = new ::std::string;
01320   }
01321   key_->assign(value);
01322 }
01323 inline void Resultset::set_key(const char* value) {
01324   _set_bit(0);
01325   if (key_ == &_default_key_) {
01326     key_ = new ::std::string;
01327   }
01328   key_->assign(value);
01329 }
01330 inline void Resultset::set_key(const char* value, size_t size) {
01331   _set_bit(0);
01332   if (key_ == &_default_key_) {
01333     key_ = new ::std::string;
01334   }
01335   key_->assign(reinterpret_cast<const char*>(value), size);
01336 }
01337 inline ::std::string* Resultset::mutable_key() {
01338   _set_bit(0);
01339   if (key_ == &_default_key_) {
01340     key_ = new ::std::string;
01341   }
01342   return key_;
01343 }
01344 
01345 // required string schema = 2;
01346 inline bool Resultset::has_schema() const {
01347   return _has_bit(1);
01348 }
01349 inline void Resultset::clear_schema() {
01350   if (schema_ != &_default_schema_) {
01351     schema_->clear();
01352   }
01353   _clear_bit(1);
01354 }
01355 inline const ::std::string& Resultset::schema() const {
01356   return *schema_;
01357 }
01358 inline void Resultset::set_schema(const ::std::string& value) {
01359   _set_bit(1);
01360   if (schema_ == &_default_schema_) {
01361     schema_ = new ::std::string;
01362   }
01363   schema_->assign(value);
01364 }
01365 inline void Resultset::set_schema(const char* value) {
01366   _set_bit(1);
01367   if (schema_ == &_default_schema_) {
01368     schema_ = new ::std::string;
01369   }
01370   schema_->assign(value);
01371 }
01372 inline void Resultset::set_schema(const char* value, size_t size) {
01373   _set_bit(1);
01374   if (schema_ == &_default_schema_) {
01375     schema_ = new ::std::string;
01376   }
01377   schema_->assign(reinterpret_cast<const char*>(value), size);
01378 }
01379 inline ::std::string* Resultset::mutable_schema() {
01380   _set_bit(1);
01381   if (schema_ == &_default_schema_) {
01382     schema_ = new ::std::string;
01383   }
01384   return schema_;
01385 }
01386 
01387 // optional string sql = 3;
01388 inline bool Resultset::has_sql() const {
01389   return _has_bit(2);
01390 }
01391 inline void Resultset::clear_sql() {
01392   if (sql_ != &_default_sql_) {
01393     sql_->clear();
01394   }
01395   _clear_bit(2);
01396 }
01397 inline const ::std::string& Resultset::sql() const {
01398   return *sql_;
01399 }
01400 inline void Resultset::set_sql(const ::std::string& value) {
01401   _set_bit(2);
01402   if (sql_ == &_default_sql_) {
01403     sql_ = new ::std::string;
01404   }
01405   sql_->assign(value);
01406 }
01407 inline void Resultset::set_sql(const char* value) {
01408   _set_bit(2);
01409   if (sql_ == &_default_sql_) {
01410     sql_ = new ::std::string;
01411   }
01412   sql_->assign(value);
01413 }
01414 inline void Resultset::set_sql(const char* value, size_t size) {
01415   _set_bit(2);
01416   if (sql_ == &_default_sql_) {
01417     sql_ = new ::std::string;
01418   }
01419   sql_->assign(reinterpret_cast<const char*>(value), size);
01420 }
01421 inline ::std::string* Resultset::mutable_sql() {
01422   _set_bit(2);
01423   if (sql_ == &_default_sql_) {
01424     sql_ = new ::std::string;
01425   }
01426   return sql_;
01427 }
01428 
01429 // optional .drizzled.message.SelectHeader select_header = 4;
01430 inline bool Resultset::has_select_header() const {
01431   return _has_bit(3);
01432 }
01433 inline void Resultset::clear_select_header() {
01434   if (select_header_ != NULL) select_header_->::drizzled::message::SelectHeader::Clear();
01435   _clear_bit(3);
01436 }
01437 inline const ::drizzled::message::SelectHeader& Resultset::select_header() const {
01438   return select_header_ != NULL ? *select_header_ : *default_instance_->select_header_;
01439 }
01440 inline ::drizzled::message::SelectHeader* Resultset::mutable_select_header() {
01441   _set_bit(3);
01442   if (select_header_ == NULL) select_header_ = new ::drizzled::message::SelectHeader;
01443   return select_header_;
01444 }
01445 
01446 // optional .drizzled.message.SelectData select_data = 5;
01447 inline bool Resultset::has_select_data() const {
01448   return _has_bit(4);
01449 }
01450 inline void Resultset::clear_select_data() {
01451   if (select_data_ != NULL) select_data_->::drizzled::message::SelectData::Clear();
01452   _clear_bit(4);
01453 }
01454 inline const ::drizzled::message::SelectData& Resultset::select_data() const {
01455   return select_data_ != NULL ? *select_data_ : *default_instance_->select_data_;
01456 }
01457 inline ::drizzled::message::SelectData* Resultset::mutable_select_data() {
01458   _set_bit(4);
01459   if (select_data_ == NULL) select_data_ = new ::drizzled::message::SelectData;
01460   return select_data_;
01461 }
01462 
01463 
01464 // @@protoc_insertion_point(namespace_scope)
01465 
01466 }  // namespace message
01467 }  // namespace drizzled
01468 
01469 #ifndef SWIG
01470 namespace google {
01471 namespace protobuf {
01472 
01473 
01474 }  // namespace google
01475 }  // namespace protobuf
01476 #endif  // SWIG
01477 
01478 // @@protoc_insertion_point(global_scope)
01479 
01480 #endif  // PROTOBUF_resultset_2eproto__INCLUDED