00001
00002
00003 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
00004 #include "resultset.pb.h"
00005 #include <google/protobuf/stubs/once.h>
00006 #include <google/protobuf/io/coded_stream.h>
00007 #include <google/protobuf/wire_format_lite_inl.h>
00008 #include <google/protobuf/descriptor.h>
00009 #include <google/protobuf/reflection_ops.h>
00010 #include <google/protobuf/wire_format.h>
00011
00012
00013 namespace drizzled {
00014 namespace message {
00015
00016 namespace {
00017
00018 const ::google::protobuf::Descriptor* FieldMeta_descriptor_ = NULL;
00019 const ::google::protobuf::internal::GeneratedMessageReflection*
00020 FieldMeta_reflection_ = NULL;
00021 const ::google::protobuf::Descriptor* TableMeta_descriptor_ = NULL;
00022 const ::google::protobuf::internal::GeneratedMessageReflection*
00023 TableMeta_reflection_ = NULL;
00024 const ::google::protobuf::Descriptor* SelectRecord_descriptor_ = NULL;
00025 const ::google::protobuf::internal::GeneratedMessageReflection*
00026 SelectRecord_reflection_ = NULL;
00027 const ::google::protobuf::Descriptor* SelectHeader_descriptor_ = NULL;
00028 const ::google::protobuf::internal::GeneratedMessageReflection*
00029 SelectHeader_reflection_ = NULL;
00030 const ::google::protobuf::Descriptor* SelectData_descriptor_ = NULL;
00031 const ::google::protobuf::internal::GeneratedMessageReflection*
00032 SelectData_reflection_ = NULL;
00033 const ::google::protobuf::Descriptor* Resultset_descriptor_ = NULL;
00034 const ::google::protobuf::internal::GeneratedMessageReflection*
00035 Resultset_reflection_ = NULL;
00036
00037 }
00038
00039
00040 void protobuf_AssignDesc_resultset_2eproto() {
00041 protobuf_AddDesc_resultset_2eproto();
00042 const ::google::protobuf::FileDescriptor* file =
00043 ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
00044 "resultset.proto");
00045 GOOGLE_CHECK(file != NULL);
00046 FieldMeta_descriptor_ = file->message_type(0);
00047 static const int FieldMeta_offsets_[5] = {
00048 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMeta, field_name_),
00049 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMeta, field_alias_),
00050 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMeta, table_name_),
00051 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMeta, table_alias_),
00052 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMeta, schema_name_),
00053 };
00054 FieldMeta_reflection_ =
00055 new ::google::protobuf::internal::GeneratedMessageReflection(
00056 FieldMeta_descriptor_,
00057 FieldMeta::default_instance_,
00058 FieldMeta_offsets_,
00059 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMeta, _has_bits_[0]),
00060 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMeta, _unknown_fields_),
00061 -1,
00062 ::google::protobuf::DescriptorPool::generated_pool(),
00063 ::google::protobuf::MessageFactory::generated_factory(),
00064 sizeof(FieldMeta));
00065 TableMeta_descriptor_ = file->message_type(1);
00066 static const int TableMeta_offsets_[3] = {
00067 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMeta, schema_name_),
00068 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMeta, table_name_),
00069 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMeta, table_alias_),
00070 };
00071 TableMeta_reflection_ =
00072 new ::google::protobuf::internal::GeneratedMessageReflection(
00073 TableMeta_descriptor_,
00074 TableMeta::default_instance_,
00075 TableMeta_offsets_,
00076 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMeta, _has_bits_[0]),
00077 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMeta, _unknown_fields_),
00078 -1,
00079 ::google::protobuf::DescriptorPool::generated_pool(),
00080 ::google::protobuf::MessageFactory::generated_factory(),
00081 sizeof(TableMeta));
00082 SelectRecord_descriptor_ = file->message_type(2);
00083 static const int SelectRecord_offsets_[2] = {
00084 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectRecord, record_value_),
00085 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectRecord, is_null_),
00086 };
00087 SelectRecord_reflection_ =
00088 new ::google::protobuf::internal::GeneratedMessageReflection(
00089 SelectRecord_descriptor_,
00090 SelectRecord::default_instance_,
00091 SelectRecord_offsets_,
00092 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectRecord, _has_bits_[0]),
00093 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectRecord, _unknown_fields_),
00094 -1,
00095 ::google::protobuf::DescriptorPool::generated_pool(),
00096 ::google::protobuf::MessageFactory::generated_factory(),
00097 sizeof(SelectRecord));
00098 SelectHeader_descriptor_ = file->message_type(3);
00099 static const int SelectHeader_offsets_[2] = {
00100 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectHeader, table_meta_),
00101 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectHeader, field_meta_),
00102 };
00103 SelectHeader_reflection_ =
00104 new ::google::protobuf::internal::GeneratedMessageReflection(
00105 SelectHeader_descriptor_,
00106 SelectHeader::default_instance_,
00107 SelectHeader_offsets_,
00108 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectHeader, _has_bits_[0]),
00109 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectHeader, _unknown_fields_),
00110 -1,
00111 ::google::protobuf::DescriptorPool::generated_pool(),
00112 ::google::protobuf::MessageFactory::generated_factory(),
00113 sizeof(SelectHeader));
00114 SelectData_descriptor_ = file->message_type(4);
00115 static const int SelectData_offsets_[3] = {
00116 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectData, segment_id_),
00117 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectData, end_segment_),
00118 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectData, record_),
00119 };
00120 SelectData_reflection_ =
00121 new ::google::protobuf::internal::GeneratedMessageReflection(
00122 SelectData_descriptor_,
00123 SelectData::default_instance_,
00124 SelectData_offsets_,
00125 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectData, _has_bits_[0]),
00126 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectData, _unknown_fields_),
00127 -1,
00128 ::google::protobuf::DescriptorPool::generated_pool(),
00129 ::google::protobuf::MessageFactory::generated_factory(),
00130 sizeof(SelectData));
00131 Resultset_descriptor_ = file->message_type(5);
00132 static const int Resultset_offsets_[5] = {
00133 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Resultset, key_),
00134 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Resultset, schema_),
00135 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Resultset, sql_),
00136 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Resultset, select_header_),
00137 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Resultset, select_data_),
00138 };
00139 Resultset_reflection_ =
00140 new ::google::protobuf::internal::GeneratedMessageReflection(
00141 Resultset_descriptor_,
00142 Resultset::default_instance_,
00143 Resultset_offsets_,
00144 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Resultset, _has_bits_[0]),
00145 GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Resultset, _unknown_fields_),
00146 -1,
00147 ::google::protobuf::DescriptorPool::generated_pool(),
00148 ::google::protobuf::MessageFactory::generated_factory(),
00149 sizeof(Resultset));
00150 }
00151
00152 namespace {
00153
00154 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
00155 inline void protobuf_AssignDescriptorsOnce() {
00156 ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
00157 &protobuf_AssignDesc_resultset_2eproto);
00158 }
00159
00160 void protobuf_RegisterTypes(const ::std::string&) {
00161 protobuf_AssignDescriptorsOnce();
00162 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00163 FieldMeta_descriptor_, &FieldMeta::default_instance());
00164 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00165 TableMeta_descriptor_, &TableMeta::default_instance());
00166 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00167 SelectRecord_descriptor_, &SelectRecord::default_instance());
00168 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00169 SelectHeader_descriptor_, &SelectHeader::default_instance());
00170 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00171 SelectData_descriptor_, &SelectData::default_instance());
00172 ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00173 Resultset_descriptor_, &Resultset::default_instance());
00174 }
00175
00176 }
00177
00178 void protobuf_ShutdownFile_resultset_2eproto() {
00179 delete FieldMeta::default_instance_;
00180 delete FieldMeta_reflection_;
00181 delete TableMeta::default_instance_;
00182 delete TableMeta_reflection_;
00183 delete SelectRecord::default_instance_;
00184 delete SelectRecord_reflection_;
00185 delete SelectHeader::default_instance_;
00186 delete SelectHeader_reflection_;
00187 delete SelectData::default_instance_;
00188 delete SelectData_reflection_;
00189 delete Resultset::default_instance_;
00190 delete Resultset_reflection_;
00191 }
00192
00193 void protobuf_AddDesc_resultset_2eproto() {
00194 static bool already_here = false;
00195 if (already_here) return;
00196 already_here = true;
00197 GOOGLE_PROTOBUF_VERIFY_VERSION;
00198
00199 ::drizzled::message::protobuf_AddDesc_table_2eproto();
00200 ::drizzled::message::protobuf_AddDesc_schema_2eproto();
00201 ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
00202 "\n\017resultset.proto\022\020drizzled.message\032\013tab"
00203 "le.proto\032\014schema.proto\"r\n\tFieldMeta\022\022\n\nf"
00204 "ield_name\030\001 \002(\t\022\023\n\013field_alias\030\002 \001(\t\022\022\n\n"
00205 "table_name\030\003 \002(\t\022\023\n\013table_alias\030\004 \001(\t\022\023\n"
00206 "\013schema_name\030\005 \002(\t\"I\n\tTableMeta\022\023\n\013schem"
00207 "a_name\030\001 \002(\t\022\022\n\ntable_name\030\002 \002(\t\022\023\n\013tabl"
00208 "e_alias\030\003 \001(\t\"5\n\014SelectRecord\022\024\n\014record_"
00209 "value\030\001 \003(\014\022\017\n\007is_null\030\002 \003(\010\"p\n\014SelectHe"
00210 "ader\022/\n\ntable_meta\030\001 \003(\0132\033.drizzled.mess"
00211 "age.TableMeta\022/\n\nfield_meta\030\002 \003(\0132\033.driz"
00212 "zled.message.FieldMeta\"e\n\nSelectData\022\022\n\n"
00213 "segment_id\030\001 \002(\r\022\023\n\013end_segment\030\002 \002(\010\022.\n"
00214 "\006record\030\003 \003(\0132\036.drizzled.message.SelectR"
00215 "ecord\"\237\001\n\tResultset\022\013\n\003key\030\001 \002(\t\022\016\n\006sche"
00216 "ma\030\002 \002(\t\022\013\n\003sql\030\003 \001(\t\0225\n\rselect_header\030\004"
00217 " \001(\0132\036.drizzled.message.SelectHeader\0221\n\013"
00218 "select_data\030\005 \001(\0132\034.drizzled.message.Sel"
00219 "ectDataB*\n\024org.drizzle.messagesB\020ResultS"
00220 "etMessageH\001", 731);
00221 ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
00222 "resultset.proto", &protobuf_RegisterTypes);
00223 FieldMeta::default_instance_ = new FieldMeta();
00224 TableMeta::default_instance_ = new TableMeta();
00225 SelectRecord::default_instance_ = new SelectRecord();
00226 SelectHeader::default_instance_ = new SelectHeader();
00227 SelectData::default_instance_ = new SelectData();
00228 Resultset::default_instance_ = new Resultset();
00229 FieldMeta::default_instance_->InitAsDefaultInstance();
00230 TableMeta::default_instance_->InitAsDefaultInstance();
00231 SelectRecord::default_instance_->InitAsDefaultInstance();
00232 SelectHeader::default_instance_->InitAsDefaultInstance();
00233 SelectData::default_instance_->InitAsDefaultInstance();
00234 Resultset::default_instance_->InitAsDefaultInstance();
00235 ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_resultset_2eproto);
00236 }
00237
00238
00239 struct StaticDescriptorInitializer_resultset_2eproto {
00240 StaticDescriptorInitializer_resultset_2eproto() {
00241 protobuf_AddDesc_resultset_2eproto();
00242 }
00243 } static_descriptor_initializer_resultset_2eproto_;
00244
00245
00246
00247
00248 const ::std::string FieldMeta::_default_field_name_;
00249 const ::std::string FieldMeta::_default_field_alias_;
00250 const ::std::string FieldMeta::_default_table_name_;
00251 const ::std::string FieldMeta::_default_table_alias_;
00252 const ::std::string FieldMeta::_default_schema_name_;
00253 #ifndef _MSC_VER
00254 const int FieldMeta::kFieldNameFieldNumber;
00255 const int FieldMeta::kFieldAliasFieldNumber;
00256 const int FieldMeta::kTableNameFieldNumber;
00257 const int FieldMeta::kTableAliasFieldNumber;
00258 const int FieldMeta::kSchemaNameFieldNumber;
00259 #endif // !_MSC_VER
00260
00261 FieldMeta::FieldMeta()
00262 : ::google::protobuf::Message() {
00263 SharedCtor();
00264 }
00265
00266 void FieldMeta::InitAsDefaultInstance() {
00267 }
00268
00269 FieldMeta::FieldMeta(const FieldMeta& from)
00270 : ::google::protobuf::Message() {
00271 SharedCtor();
00272 MergeFrom(from);
00273 }
00274
00275 void FieldMeta::SharedCtor() {
00276 _cached_size_ = 0;
00277 field_name_ = const_cast< ::std::string*>(&_default_field_name_);
00278 field_alias_ = const_cast< ::std::string*>(&_default_field_alias_);
00279 table_name_ = const_cast< ::std::string*>(&_default_table_name_);
00280 table_alias_ = const_cast< ::std::string*>(&_default_table_alias_);
00281 schema_name_ = const_cast< ::std::string*>(&_default_schema_name_);
00282 ::memset(_has_bits_, 0, sizeof(_has_bits_));
00283 }
00284
00285 FieldMeta::~FieldMeta() {
00286 SharedDtor();
00287 }
00288
00289 void FieldMeta::SharedDtor() {
00290 if (field_name_ != &_default_field_name_) {
00291 delete field_name_;
00292 }
00293 if (field_alias_ != &_default_field_alias_) {
00294 delete field_alias_;
00295 }
00296 if (table_name_ != &_default_table_name_) {
00297 delete table_name_;
00298 }
00299 if (table_alias_ != &_default_table_alias_) {
00300 delete table_alias_;
00301 }
00302 if (schema_name_ != &_default_schema_name_) {
00303 delete schema_name_;
00304 }
00305 if (this != default_instance_) {
00306 }
00307 }
00308
00309 void FieldMeta::SetCachedSize(int size) const {
00310 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
00311 _cached_size_ = size;
00312 GOOGLE_SAFE_CONCURRENT_WRITES_END();
00313 }
00314 const ::google::protobuf::Descriptor* FieldMeta::descriptor() {
00315 protobuf_AssignDescriptorsOnce();
00316 return FieldMeta_descriptor_;
00317 }
00318
00319 const FieldMeta& FieldMeta::default_instance() {
00320 if (default_instance_ == NULL) protobuf_AddDesc_resultset_2eproto(); return *default_instance_;
00321 }
00322
00323 FieldMeta* FieldMeta::default_instance_ = NULL;
00324
00325 FieldMeta* FieldMeta::New() const {
00326 return new FieldMeta;
00327 }
00328
00329 void FieldMeta::Clear() {
00330 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00331 if (_has_bit(0)) {
00332 if (field_name_ != &_default_field_name_) {
00333 field_name_->clear();
00334 }
00335 }
00336 if (_has_bit(1)) {
00337 if (field_alias_ != &_default_field_alias_) {
00338 field_alias_->clear();
00339 }
00340 }
00341 if (_has_bit(2)) {
00342 if (table_name_ != &_default_table_name_) {
00343 table_name_->clear();
00344 }
00345 }
00346 if (_has_bit(3)) {
00347 if (table_alias_ != &_default_table_alias_) {
00348 table_alias_->clear();
00349 }
00350 }
00351 if (_has_bit(4)) {
00352 if (schema_name_ != &_default_schema_name_) {
00353 schema_name_->clear();
00354 }
00355 }
00356 }
00357 ::memset(_has_bits_, 0, sizeof(_has_bits_));
00358 mutable_unknown_fields()->Clear();
00359 }
00360
00361 bool FieldMeta::MergePartialFromCodedStream(
00362 ::google::protobuf::io::CodedInputStream* input) {
00363 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
00364 ::google::protobuf::uint32 tag;
00365 while ((tag = input->ReadTag()) != 0) {
00366 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
00367
00368 case 1: {
00369 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00370 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
00371 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
00372 input, this->mutable_field_name()));
00373 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00374 this->field_name().data(), this->field_name().length(),
00375 ::google::protobuf::internal::WireFormat::PARSE);
00376 } else {
00377 goto handle_uninterpreted;
00378 }
00379 if (input->ExpectTag(18)) goto parse_field_alias;
00380 break;
00381 }
00382
00383
00384 case 2: {
00385 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00386 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
00387 parse_field_alias:
00388 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
00389 input, this->mutable_field_alias()));
00390 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00391 this->field_alias().data(), this->field_alias().length(),
00392 ::google::protobuf::internal::WireFormat::PARSE);
00393 } else {
00394 goto handle_uninterpreted;
00395 }
00396 if (input->ExpectTag(26)) goto parse_table_name;
00397 break;
00398 }
00399
00400
00401 case 3: {
00402 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00403 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
00404 parse_table_name:
00405 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
00406 input, this->mutable_table_name()));
00407 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00408 this->table_name().data(), this->table_name().length(),
00409 ::google::protobuf::internal::WireFormat::PARSE);
00410 } else {
00411 goto handle_uninterpreted;
00412 }
00413 if (input->ExpectTag(34)) goto parse_table_alias;
00414 break;
00415 }
00416
00417
00418 case 4: {
00419 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00420 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
00421 parse_table_alias:
00422 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
00423 input, this->mutable_table_alias()));
00424 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00425 this->table_alias().data(), this->table_alias().length(),
00426 ::google::protobuf::internal::WireFormat::PARSE);
00427 } else {
00428 goto handle_uninterpreted;
00429 }
00430 if (input->ExpectTag(42)) goto parse_schema_name;
00431 break;
00432 }
00433
00434
00435 case 5: {
00436 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00437 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
00438 parse_schema_name:
00439 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
00440 input, this->mutable_schema_name()));
00441 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00442 this->schema_name().data(), this->schema_name().length(),
00443 ::google::protobuf::internal::WireFormat::PARSE);
00444 } else {
00445 goto handle_uninterpreted;
00446 }
00447 if (input->ExpectAtEnd()) return true;
00448 break;
00449 }
00450
00451 default: {
00452 handle_uninterpreted:
00453 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00454 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
00455 return true;
00456 }
00457 DO_(::google::protobuf::internal::WireFormat::SkipField(
00458 input, tag, mutable_unknown_fields()));
00459 break;
00460 }
00461 }
00462 }
00463 return true;
00464 #undef DO_
00465 }
00466
00467 void FieldMeta::SerializeWithCachedSizes(
00468 ::google::protobuf::io::CodedOutputStream* output) const {
00469
00470 if (_has_bit(0)) {
00471 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00472 this->field_name().data(), this->field_name().length(),
00473 ::google::protobuf::internal::WireFormat::SERIALIZE);
00474 ::google::protobuf::internal::WireFormatLite::WriteString(
00475 1, this->field_name(), output);
00476 }
00477
00478
00479 if (_has_bit(1)) {
00480 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00481 this->field_alias().data(), this->field_alias().length(),
00482 ::google::protobuf::internal::WireFormat::SERIALIZE);
00483 ::google::protobuf::internal::WireFormatLite::WriteString(
00484 2, this->field_alias(), output);
00485 }
00486
00487
00488 if (_has_bit(2)) {
00489 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00490 this->table_name().data(), this->table_name().length(),
00491 ::google::protobuf::internal::WireFormat::SERIALIZE);
00492 ::google::protobuf::internal::WireFormatLite::WriteString(
00493 3, this->table_name(), output);
00494 }
00495
00496
00497 if (_has_bit(3)) {
00498 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00499 this->table_alias().data(), this->table_alias().length(),
00500 ::google::protobuf::internal::WireFormat::SERIALIZE);
00501 ::google::protobuf::internal::WireFormatLite::WriteString(
00502 4, this->table_alias(), output);
00503 }
00504
00505
00506 if (_has_bit(4)) {
00507 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00508 this->schema_name().data(), this->schema_name().length(),
00509 ::google::protobuf::internal::WireFormat::SERIALIZE);
00510 ::google::protobuf::internal::WireFormatLite::WriteString(
00511 5, this->schema_name(), output);
00512 }
00513
00514 if (!unknown_fields().empty()) {
00515 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
00516 unknown_fields(), output);
00517 }
00518 }
00519
00520 ::google::protobuf::uint8* FieldMeta::SerializeWithCachedSizesToArray(
00521 ::google::protobuf::uint8* target) const {
00522
00523 if (_has_bit(0)) {
00524 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00525 this->field_name().data(), this->field_name().length(),
00526 ::google::protobuf::internal::WireFormat::SERIALIZE);
00527 target =
00528 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
00529 1, this->field_name(), target);
00530 }
00531
00532
00533 if (_has_bit(1)) {
00534 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00535 this->field_alias().data(), this->field_alias().length(),
00536 ::google::protobuf::internal::WireFormat::SERIALIZE);
00537 target =
00538 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
00539 2, this->field_alias(), target);
00540 }
00541
00542
00543 if (_has_bit(2)) {
00544 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00545 this->table_name().data(), this->table_name().length(),
00546 ::google::protobuf::internal::WireFormat::SERIALIZE);
00547 target =
00548 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
00549 3, this->table_name(), target);
00550 }
00551
00552
00553 if (_has_bit(3)) {
00554 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00555 this->table_alias().data(), this->table_alias().length(),
00556 ::google::protobuf::internal::WireFormat::SERIALIZE);
00557 target =
00558 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
00559 4, this->table_alias(), target);
00560 }
00561
00562
00563 if (_has_bit(4)) {
00564 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00565 this->schema_name().data(), this->schema_name().length(),
00566 ::google::protobuf::internal::WireFormat::SERIALIZE);
00567 target =
00568 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
00569 5, this->schema_name(), target);
00570 }
00571
00572 if (!unknown_fields().empty()) {
00573 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
00574 unknown_fields(), target);
00575 }
00576 return target;
00577 }
00578
00579 int FieldMeta::ByteSize() const {
00580 int total_size = 0;
00581
00582 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00583
00584 if (has_field_name()) {
00585 total_size += 1 +
00586 ::google::protobuf::internal::WireFormatLite::StringSize(
00587 this->field_name());
00588 }
00589
00590
00591 if (has_field_alias()) {
00592 total_size += 1 +
00593 ::google::protobuf::internal::WireFormatLite::StringSize(
00594 this->field_alias());
00595 }
00596
00597
00598 if (has_table_name()) {
00599 total_size += 1 +
00600 ::google::protobuf::internal::WireFormatLite::StringSize(
00601 this->table_name());
00602 }
00603
00604
00605 if (has_table_alias()) {
00606 total_size += 1 +
00607 ::google::protobuf::internal::WireFormatLite::StringSize(
00608 this->table_alias());
00609 }
00610
00611
00612 if (has_schema_name()) {
00613 total_size += 1 +
00614 ::google::protobuf::internal::WireFormatLite::StringSize(
00615 this->schema_name());
00616 }
00617
00618 }
00619 if (!unknown_fields().empty()) {
00620 total_size +=
00621 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
00622 unknown_fields());
00623 }
00624 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
00625 _cached_size_ = total_size;
00626 GOOGLE_SAFE_CONCURRENT_WRITES_END();
00627 return total_size;
00628 }
00629
00630 void FieldMeta::MergeFrom(const ::google::protobuf::Message& from) {
00631 GOOGLE_CHECK_NE(&from, this);
00632 const FieldMeta* source =
00633 ::google::protobuf::internal::dynamic_cast_if_available<const FieldMeta*>(
00634 &from);
00635 if (source == NULL) {
00636 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
00637 } else {
00638 MergeFrom(*source);
00639 }
00640 }
00641
00642 void FieldMeta::MergeFrom(const FieldMeta& from) {
00643 GOOGLE_CHECK_NE(&from, this);
00644 if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00645 if (from._has_bit(0)) {
00646 set_field_name(from.field_name());
00647 }
00648 if (from._has_bit(1)) {
00649 set_field_alias(from.field_alias());
00650 }
00651 if (from._has_bit(2)) {
00652 set_table_name(from.table_name());
00653 }
00654 if (from._has_bit(3)) {
00655 set_table_alias(from.table_alias());
00656 }
00657 if (from._has_bit(4)) {
00658 set_schema_name(from.schema_name());
00659 }
00660 }
00661 mutable_unknown_fields()->MergeFrom(from.unknown_fields());
00662 }
00663
00664 void FieldMeta::CopyFrom(const ::google::protobuf::Message& from) {
00665 if (&from == this) return;
00666 Clear();
00667 MergeFrom(from);
00668 }
00669
00670 void FieldMeta::CopyFrom(const FieldMeta& from) {
00671 if (&from == this) return;
00672 Clear();
00673 MergeFrom(from);
00674 }
00675
00676 bool FieldMeta::IsInitialized() const {
00677 if ((_has_bits_[0] & 0x00000015) != 0x00000015) return false;
00678
00679 return true;
00680 }
00681
00682 void FieldMeta::Swap(FieldMeta* other) {
00683 if (other != this) {
00684 std::swap(field_name_, other->field_name_);
00685 std::swap(field_alias_, other->field_alias_);
00686 std::swap(table_name_, other->table_name_);
00687 std::swap(table_alias_, other->table_alias_);
00688 std::swap(schema_name_, other->schema_name_);
00689 std::swap(_has_bits_[0], other->_has_bits_[0]);
00690 _unknown_fields_.Swap(&other->_unknown_fields_);
00691 std::swap(_cached_size_, other->_cached_size_);
00692 }
00693 }
00694
00695 ::google::protobuf::Metadata FieldMeta::GetMetadata() const {
00696 protobuf_AssignDescriptorsOnce();
00697 ::google::protobuf::Metadata metadata;
00698 metadata.descriptor = FieldMeta_descriptor_;
00699 metadata.reflection = FieldMeta_reflection_;
00700 return metadata;
00701 }
00702
00703
00704
00705
00706 const ::std::string TableMeta::_default_schema_name_;
00707 const ::std::string TableMeta::_default_table_name_;
00708 const ::std::string TableMeta::_default_table_alias_;
00709 #ifndef _MSC_VER
00710 const int TableMeta::kSchemaNameFieldNumber;
00711 const int TableMeta::kTableNameFieldNumber;
00712 const int TableMeta::kTableAliasFieldNumber;
00713 #endif // !_MSC_VER
00714
00715 TableMeta::TableMeta()
00716 : ::google::protobuf::Message() {
00717 SharedCtor();
00718 }
00719
00720 void TableMeta::InitAsDefaultInstance() {
00721 }
00722
00723 TableMeta::TableMeta(const TableMeta& from)
00724 : ::google::protobuf::Message() {
00725 SharedCtor();
00726 MergeFrom(from);
00727 }
00728
00729 void TableMeta::SharedCtor() {
00730 _cached_size_ = 0;
00731 schema_name_ = const_cast< ::std::string*>(&_default_schema_name_);
00732 table_name_ = const_cast< ::std::string*>(&_default_table_name_);
00733 table_alias_ = const_cast< ::std::string*>(&_default_table_alias_);
00734 ::memset(_has_bits_, 0, sizeof(_has_bits_));
00735 }
00736
00737 TableMeta::~TableMeta() {
00738 SharedDtor();
00739 }
00740
00741 void TableMeta::SharedDtor() {
00742 if (schema_name_ != &_default_schema_name_) {
00743 delete schema_name_;
00744 }
00745 if (table_name_ != &_default_table_name_) {
00746 delete table_name_;
00747 }
00748 if (table_alias_ != &_default_table_alias_) {
00749 delete table_alias_;
00750 }
00751 if (this != default_instance_) {
00752 }
00753 }
00754
00755 void TableMeta::SetCachedSize(int size) const {
00756 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
00757 _cached_size_ = size;
00758 GOOGLE_SAFE_CONCURRENT_WRITES_END();
00759 }
00760 const ::google::protobuf::Descriptor* TableMeta::descriptor() {
00761 protobuf_AssignDescriptorsOnce();
00762 return TableMeta_descriptor_;
00763 }
00764
00765 const TableMeta& TableMeta::default_instance() {
00766 if (default_instance_ == NULL) protobuf_AddDesc_resultset_2eproto(); return *default_instance_;
00767 }
00768
00769 TableMeta* TableMeta::default_instance_ = NULL;
00770
00771 TableMeta* TableMeta::New() const {
00772 return new TableMeta;
00773 }
00774
00775 void TableMeta::Clear() {
00776 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00777 if (_has_bit(0)) {
00778 if (schema_name_ != &_default_schema_name_) {
00779 schema_name_->clear();
00780 }
00781 }
00782 if (_has_bit(1)) {
00783 if (table_name_ != &_default_table_name_) {
00784 table_name_->clear();
00785 }
00786 }
00787 if (_has_bit(2)) {
00788 if (table_alias_ != &_default_table_alias_) {
00789 table_alias_->clear();
00790 }
00791 }
00792 }
00793 ::memset(_has_bits_, 0, sizeof(_has_bits_));
00794 mutable_unknown_fields()->Clear();
00795 }
00796
00797 bool TableMeta::MergePartialFromCodedStream(
00798 ::google::protobuf::io::CodedInputStream* input) {
00799 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
00800 ::google::protobuf::uint32 tag;
00801 while ((tag = input->ReadTag()) != 0) {
00802 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
00803
00804 case 1: {
00805 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00806 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
00807 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
00808 input, this->mutable_schema_name()));
00809 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00810 this->schema_name().data(), this->schema_name().length(),
00811 ::google::protobuf::internal::WireFormat::PARSE);
00812 } else {
00813 goto handle_uninterpreted;
00814 }
00815 if (input->ExpectTag(18)) goto parse_table_name;
00816 break;
00817 }
00818
00819
00820 case 2: {
00821 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00822 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
00823 parse_table_name:
00824 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
00825 input, this->mutable_table_name()));
00826 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00827 this->table_name().data(), this->table_name().length(),
00828 ::google::protobuf::internal::WireFormat::PARSE);
00829 } else {
00830 goto handle_uninterpreted;
00831 }
00832 if (input->ExpectTag(26)) goto parse_table_alias;
00833 break;
00834 }
00835
00836
00837 case 3: {
00838 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00839 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
00840 parse_table_alias:
00841 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
00842 input, this->mutable_table_alias()));
00843 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00844 this->table_alias().data(), this->table_alias().length(),
00845 ::google::protobuf::internal::WireFormat::PARSE);
00846 } else {
00847 goto handle_uninterpreted;
00848 }
00849 if (input->ExpectAtEnd()) return true;
00850 break;
00851 }
00852
00853 default: {
00854 handle_uninterpreted:
00855 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00856 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
00857 return true;
00858 }
00859 DO_(::google::protobuf::internal::WireFormat::SkipField(
00860 input, tag, mutable_unknown_fields()));
00861 break;
00862 }
00863 }
00864 }
00865 return true;
00866 #undef DO_
00867 }
00868
00869 void TableMeta::SerializeWithCachedSizes(
00870 ::google::protobuf::io::CodedOutputStream* output) const {
00871
00872 if (_has_bit(0)) {
00873 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00874 this->schema_name().data(), this->schema_name().length(),
00875 ::google::protobuf::internal::WireFormat::SERIALIZE);
00876 ::google::protobuf::internal::WireFormatLite::WriteString(
00877 1, this->schema_name(), output);
00878 }
00879
00880
00881 if (_has_bit(1)) {
00882 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00883 this->table_name().data(), this->table_name().length(),
00884 ::google::protobuf::internal::WireFormat::SERIALIZE);
00885 ::google::protobuf::internal::WireFormatLite::WriteString(
00886 2, this->table_name(), output);
00887 }
00888
00889
00890 if (_has_bit(2)) {
00891 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00892 this->table_alias().data(), this->table_alias().length(),
00893 ::google::protobuf::internal::WireFormat::SERIALIZE);
00894 ::google::protobuf::internal::WireFormatLite::WriteString(
00895 3, this->table_alias(), output);
00896 }
00897
00898 if (!unknown_fields().empty()) {
00899 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
00900 unknown_fields(), output);
00901 }
00902 }
00903
00904 ::google::protobuf::uint8* TableMeta::SerializeWithCachedSizesToArray(
00905 ::google::protobuf::uint8* target) const {
00906
00907 if (_has_bit(0)) {
00908 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00909 this->schema_name().data(), this->schema_name().length(),
00910 ::google::protobuf::internal::WireFormat::SERIALIZE);
00911 target =
00912 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
00913 1, this->schema_name(), target);
00914 }
00915
00916
00917 if (_has_bit(1)) {
00918 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00919 this->table_name().data(), this->table_name().length(),
00920 ::google::protobuf::internal::WireFormat::SERIALIZE);
00921 target =
00922 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
00923 2, this->table_name(), target);
00924 }
00925
00926
00927 if (_has_bit(2)) {
00928 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00929 this->table_alias().data(), this->table_alias().length(),
00930 ::google::protobuf::internal::WireFormat::SERIALIZE);
00931 target =
00932 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
00933 3, this->table_alias(), target);
00934 }
00935
00936 if (!unknown_fields().empty()) {
00937 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
00938 unknown_fields(), target);
00939 }
00940 return target;
00941 }
00942
00943 int TableMeta::ByteSize() const {
00944 int total_size = 0;
00945
00946 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00947
00948 if (has_schema_name()) {
00949 total_size += 1 +
00950 ::google::protobuf::internal::WireFormatLite::StringSize(
00951 this->schema_name());
00952 }
00953
00954
00955 if (has_table_name()) {
00956 total_size += 1 +
00957 ::google::protobuf::internal::WireFormatLite::StringSize(
00958 this->table_name());
00959 }
00960
00961
00962 if (has_table_alias()) {
00963 total_size += 1 +
00964 ::google::protobuf::internal::WireFormatLite::StringSize(
00965 this->table_alias());
00966 }
00967
00968 }
00969 if (!unknown_fields().empty()) {
00970 total_size +=
00971 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
00972 unknown_fields());
00973 }
00974 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
00975 _cached_size_ = total_size;
00976 GOOGLE_SAFE_CONCURRENT_WRITES_END();
00977 return total_size;
00978 }
00979
00980 void TableMeta::MergeFrom(const ::google::protobuf::Message& from) {
00981 GOOGLE_CHECK_NE(&from, this);
00982 const TableMeta* source =
00983 ::google::protobuf::internal::dynamic_cast_if_available<const TableMeta*>(
00984 &from);
00985 if (source == NULL) {
00986 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
00987 } else {
00988 MergeFrom(*source);
00989 }
00990 }
00991
00992 void TableMeta::MergeFrom(const TableMeta& from) {
00993 GOOGLE_CHECK_NE(&from, this);
00994 if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00995 if (from._has_bit(0)) {
00996 set_schema_name(from.schema_name());
00997 }
00998 if (from._has_bit(1)) {
00999 set_table_name(from.table_name());
01000 }
01001 if (from._has_bit(2)) {
01002 set_table_alias(from.table_alias());
01003 }
01004 }
01005 mutable_unknown_fields()->MergeFrom(from.unknown_fields());
01006 }
01007
01008 void TableMeta::CopyFrom(const ::google::protobuf::Message& from) {
01009 if (&from == this) return;
01010 Clear();
01011 MergeFrom(from);
01012 }
01013
01014 void TableMeta::CopyFrom(const TableMeta& from) {
01015 if (&from == this) return;
01016 Clear();
01017 MergeFrom(from);
01018 }
01019
01020 bool TableMeta::IsInitialized() const {
01021 if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
01022
01023 return true;
01024 }
01025
01026 void TableMeta::Swap(TableMeta* other) {
01027 if (other != this) {
01028 std::swap(schema_name_, other->schema_name_);
01029 std::swap(table_name_, other->table_name_);
01030 std::swap(table_alias_, other->table_alias_);
01031 std::swap(_has_bits_[0], other->_has_bits_[0]);
01032 _unknown_fields_.Swap(&other->_unknown_fields_);
01033 std::swap(_cached_size_, other->_cached_size_);
01034 }
01035 }
01036
01037 ::google::protobuf::Metadata TableMeta::GetMetadata() const {
01038 protobuf_AssignDescriptorsOnce();
01039 ::google::protobuf::Metadata metadata;
01040 metadata.descriptor = TableMeta_descriptor_;
01041 metadata.reflection = TableMeta_reflection_;
01042 return metadata;
01043 }
01044
01045
01046
01047
01048 #ifndef _MSC_VER
01049 const int SelectRecord::kRecordValueFieldNumber;
01050 const int SelectRecord::kIsNullFieldNumber;
01051 #endif // !_MSC_VER
01052
01053 SelectRecord::SelectRecord()
01054 : ::google::protobuf::Message() {
01055 SharedCtor();
01056 }
01057
01058 void SelectRecord::InitAsDefaultInstance() {
01059 }
01060
01061 SelectRecord::SelectRecord(const SelectRecord& from)
01062 : ::google::protobuf::Message() {
01063 SharedCtor();
01064 MergeFrom(from);
01065 }
01066
01067 void SelectRecord::SharedCtor() {
01068 _cached_size_ = 0;
01069 ::memset(_has_bits_, 0, sizeof(_has_bits_));
01070 }
01071
01072 SelectRecord::~SelectRecord() {
01073 SharedDtor();
01074 }
01075
01076 void SelectRecord::SharedDtor() {
01077 if (this != default_instance_) {
01078 }
01079 }
01080
01081 void SelectRecord::SetCachedSize(int size) const {
01082 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
01083 _cached_size_ = size;
01084 GOOGLE_SAFE_CONCURRENT_WRITES_END();
01085 }
01086 const ::google::protobuf::Descriptor* SelectRecord::descriptor() {
01087 protobuf_AssignDescriptorsOnce();
01088 return SelectRecord_descriptor_;
01089 }
01090
01091 const SelectRecord& SelectRecord::default_instance() {
01092 if (default_instance_ == NULL) protobuf_AddDesc_resultset_2eproto(); return *default_instance_;
01093 }
01094
01095 SelectRecord* SelectRecord::default_instance_ = NULL;
01096
01097 SelectRecord* SelectRecord::New() const {
01098 return new SelectRecord;
01099 }
01100
01101 void SelectRecord::Clear() {
01102 record_value_.Clear();
01103 is_null_.Clear();
01104 ::memset(_has_bits_, 0, sizeof(_has_bits_));
01105 mutable_unknown_fields()->Clear();
01106 }
01107
01108 bool SelectRecord::MergePartialFromCodedStream(
01109 ::google::protobuf::io::CodedInputStream* input) {
01110 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
01111 ::google::protobuf::uint32 tag;
01112 while ((tag = input->ReadTag()) != 0) {
01113 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
01114
01115 case 1: {
01116 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01117 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
01118 parse_record_value:
01119 DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
01120 input, this->add_record_value()));
01121 } else {
01122 goto handle_uninterpreted;
01123 }
01124 if (input->ExpectTag(10)) goto parse_record_value;
01125 if (input->ExpectTag(16)) goto parse_is_null;
01126 break;
01127 }
01128
01129
01130 case 2: {
01131 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01132 ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
01133 parse_is_null:
01134 DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
01135 bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
01136 1, 16, input, this->mutable_is_null())));
01137 } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
01138 == ::google::protobuf::internal::WireFormatLite::
01139 WIRETYPE_LENGTH_DELIMITED) {
01140 DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
01141 bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
01142 input, this->mutable_is_null())));
01143 } else {
01144 goto handle_uninterpreted;
01145 }
01146 if (input->ExpectTag(16)) goto parse_is_null;
01147 if (input->ExpectAtEnd()) return true;
01148 break;
01149 }
01150
01151 default: {
01152 handle_uninterpreted:
01153 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01154 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
01155 return true;
01156 }
01157 DO_(::google::protobuf::internal::WireFormat::SkipField(
01158 input, tag, mutable_unknown_fields()));
01159 break;
01160 }
01161 }
01162 }
01163 return true;
01164 #undef DO_
01165 }
01166
01167 void SelectRecord::SerializeWithCachedSizes(
01168 ::google::protobuf::io::CodedOutputStream* output) const {
01169
01170 for (int i = 0; i < this->record_value_size(); i++) {
01171 ::google::protobuf::internal::WireFormatLite::WriteBytes(
01172 1, this->record_value(i), output);
01173 }
01174
01175
01176 for (int i = 0; i < this->is_null_size(); i++) {
01177 ::google::protobuf::internal::WireFormatLite::WriteBool(
01178 2, this->is_null(i), output);
01179 }
01180
01181 if (!unknown_fields().empty()) {
01182 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
01183 unknown_fields(), output);
01184 }
01185 }
01186
01187 ::google::protobuf::uint8* SelectRecord::SerializeWithCachedSizesToArray(
01188 ::google::protobuf::uint8* target) const {
01189
01190 for (int i = 0; i < this->record_value_size(); i++) {
01191 target = ::google::protobuf::internal::WireFormatLite::
01192 WriteBytesToArray(1, this->record_value(i), target);
01193 }
01194
01195
01196 for (int i = 0; i < this->is_null_size(); i++) {
01197 target = ::google::protobuf::internal::WireFormatLite::
01198 WriteBoolToArray(2, this->is_null(i), target);
01199 }
01200
01201 if (!unknown_fields().empty()) {
01202 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
01203 unknown_fields(), target);
01204 }
01205 return target;
01206 }
01207
01208 int SelectRecord::ByteSize() const {
01209 int total_size = 0;
01210
01211
01212 total_size += 1 * this->record_value_size();
01213 for (int i = 0; i < this->record_value_size(); i++) {
01214 total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
01215 this->record_value(i));
01216 }
01217
01218
01219 {
01220 int data_size = 0;
01221 data_size = 1 * this->is_null_size();
01222 total_size += 1 * this->is_null_size() + data_size;
01223 }
01224
01225 if (!unknown_fields().empty()) {
01226 total_size +=
01227 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
01228 unknown_fields());
01229 }
01230 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
01231 _cached_size_ = total_size;
01232 GOOGLE_SAFE_CONCURRENT_WRITES_END();
01233 return total_size;
01234 }
01235
01236 void SelectRecord::MergeFrom(const ::google::protobuf::Message& from) {
01237 GOOGLE_CHECK_NE(&from, this);
01238 const SelectRecord* source =
01239 ::google::protobuf::internal::dynamic_cast_if_available<const SelectRecord*>(
01240 &from);
01241 if (source == NULL) {
01242 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
01243 } else {
01244 MergeFrom(*source);
01245 }
01246 }
01247
01248 void SelectRecord::MergeFrom(const SelectRecord& from) {
01249 GOOGLE_CHECK_NE(&from, this);
01250 record_value_.MergeFrom(from.record_value_);
01251 is_null_.MergeFrom(from.is_null_);
01252 mutable_unknown_fields()->MergeFrom(from.unknown_fields());
01253 }
01254
01255 void SelectRecord::CopyFrom(const ::google::protobuf::Message& from) {
01256 if (&from == this) return;
01257 Clear();
01258 MergeFrom(from);
01259 }
01260
01261 void SelectRecord::CopyFrom(const SelectRecord& from) {
01262 if (&from == this) return;
01263 Clear();
01264 MergeFrom(from);
01265 }
01266
01267 bool SelectRecord::IsInitialized() const {
01268
01269 return true;
01270 }
01271
01272 void SelectRecord::Swap(SelectRecord* other) {
01273 if (other != this) {
01274 record_value_.Swap(&other->record_value_);
01275 is_null_.Swap(&other->is_null_);
01276 std::swap(_has_bits_[0], other->_has_bits_[0]);
01277 _unknown_fields_.Swap(&other->_unknown_fields_);
01278 std::swap(_cached_size_, other->_cached_size_);
01279 }
01280 }
01281
01282 ::google::protobuf::Metadata SelectRecord::GetMetadata() const {
01283 protobuf_AssignDescriptorsOnce();
01284 ::google::protobuf::Metadata metadata;
01285 metadata.descriptor = SelectRecord_descriptor_;
01286 metadata.reflection = SelectRecord_reflection_;
01287 return metadata;
01288 }
01289
01290
01291
01292
01293 #ifndef _MSC_VER
01294 const int SelectHeader::kTableMetaFieldNumber;
01295 const int SelectHeader::kFieldMetaFieldNumber;
01296 #endif // !_MSC_VER
01297
01298 SelectHeader::SelectHeader()
01299 : ::google::protobuf::Message() {
01300 SharedCtor();
01301 }
01302
01303 void SelectHeader::InitAsDefaultInstance() {
01304 }
01305
01306 SelectHeader::SelectHeader(const SelectHeader& from)
01307 : ::google::protobuf::Message() {
01308 SharedCtor();
01309 MergeFrom(from);
01310 }
01311
01312 void SelectHeader::SharedCtor() {
01313 _cached_size_ = 0;
01314 ::memset(_has_bits_, 0, sizeof(_has_bits_));
01315 }
01316
01317 SelectHeader::~SelectHeader() {
01318 SharedDtor();
01319 }
01320
01321 void SelectHeader::SharedDtor() {
01322 if (this != default_instance_) {
01323 }
01324 }
01325
01326 void SelectHeader::SetCachedSize(int size) const {
01327 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
01328 _cached_size_ = size;
01329 GOOGLE_SAFE_CONCURRENT_WRITES_END();
01330 }
01331 const ::google::protobuf::Descriptor* SelectHeader::descriptor() {
01332 protobuf_AssignDescriptorsOnce();
01333 return SelectHeader_descriptor_;
01334 }
01335
01336 const SelectHeader& SelectHeader::default_instance() {
01337 if (default_instance_ == NULL) protobuf_AddDesc_resultset_2eproto(); return *default_instance_;
01338 }
01339
01340 SelectHeader* SelectHeader::default_instance_ = NULL;
01341
01342 SelectHeader* SelectHeader::New() const {
01343 return new SelectHeader;
01344 }
01345
01346 void SelectHeader::Clear() {
01347 table_meta_.Clear();
01348 field_meta_.Clear();
01349 ::memset(_has_bits_, 0, sizeof(_has_bits_));
01350 mutable_unknown_fields()->Clear();
01351 }
01352
01353 bool SelectHeader::MergePartialFromCodedStream(
01354 ::google::protobuf::io::CodedInputStream* input) {
01355 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
01356 ::google::protobuf::uint32 tag;
01357 while ((tag = input->ReadTag()) != 0) {
01358 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
01359
01360 case 1: {
01361 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01362 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
01363 parse_table_meta:
01364 DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
01365 input, add_table_meta()));
01366 } else {
01367 goto handle_uninterpreted;
01368 }
01369 if (input->ExpectTag(10)) goto parse_table_meta;
01370 if (input->ExpectTag(18)) goto parse_field_meta;
01371 break;
01372 }
01373
01374
01375 case 2: {
01376 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01377 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
01378 parse_field_meta:
01379 DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
01380 input, add_field_meta()));
01381 } else {
01382 goto handle_uninterpreted;
01383 }
01384 if (input->ExpectTag(18)) goto parse_field_meta;
01385 if (input->ExpectAtEnd()) return true;
01386 break;
01387 }
01388
01389 default: {
01390 handle_uninterpreted:
01391 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01392 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
01393 return true;
01394 }
01395 DO_(::google::protobuf::internal::WireFormat::SkipField(
01396 input, tag, mutable_unknown_fields()));
01397 break;
01398 }
01399 }
01400 }
01401 return true;
01402 #undef DO_
01403 }
01404
01405 void SelectHeader::SerializeWithCachedSizes(
01406 ::google::protobuf::io::CodedOutputStream* output) const {
01407
01408 for (int i = 0; i < this->table_meta_size(); i++) {
01409 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
01410 1, this->table_meta(i), output);
01411 }
01412
01413
01414 for (int i = 0; i < this->field_meta_size(); i++) {
01415 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
01416 2, this->field_meta(i), output);
01417 }
01418
01419 if (!unknown_fields().empty()) {
01420 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
01421 unknown_fields(), output);
01422 }
01423 }
01424
01425 ::google::protobuf::uint8* SelectHeader::SerializeWithCachedSizesToArray(
01426 ::google::protobuf::uint8* target) const {
01427
01428 for (int i = 0; i < this->table_meta_size(); i++) {
01429 target = ::google::protobuf::internal::WireFormatLite::
01430 WriteMessageNoVirtualToArray(
01431 1, this->table_meta(i), target);
01432 }
01433
01434
01435 for (int i = 0; i < this->field_meta_size(); i++) {
01436 target = ::google::protobuf::internal::WireFormatLite::
01437 WriteMessageNoVirtualToArray(
01438 2, this->field_meta(i), target);
01439 }
01440
01441 if (!unknown_fields().empty()) {
01442 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
01443 unknown_fields(), target);
01444 }
01445 return target;
01446 }
01447
01448 int SelectHeader::ByteSize() const {
01449 int total_size = 0;
01450
01451
01452 total_size += 1 * this->table_meta_size();
01453 for (int i = 0; i < this->table_meta_size(); i++) {
01454 total_size +=
01455 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
01456 this->table_meta(i));
01457 }
01458
01459
01460 total_size += 1 * this->field_meta_size();
01461 for (int i = 0; i < this->field_meta_size(); i++) {
01462 total_size +=
01463 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
01464 this->field_meta(i));
01465 }
01466
01467 if (!unknown_fields().empty()) {
01468 total_size +=
01469 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
01470 unknown_fields());
01471 }
01472 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
01473 _cached_size_ = total_size;
01474 GOOGLE_SAFE_CONCURRENT_WRITES_END();
01475 return total_size;
01476 }
01477
01478 void SelectHeader::MergeFrom(const ::google::protobuf::Message& from) {
01479 GOOGLE_CHECK_NE(&from, this);
01480 const SelectHeader* source =
01481 ::google::protobuf::internal::dynamic_cast_if_available<const SelectHeader*>(
01482 &from);
01483 if (source == NULL) {
01484 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
01485 } else {
01486 MergeFrom(*source);
01487 }
01488 }
01489
01490 void SelectHeader::MergeFrom(const SelectHeader& from) {
01491 GOOGLE_CHECK_NE(&from, this);
01492 table_meta_.MergeFrom(from.table_meta_);
01493 field_meta_.MergeFrom(from.field_meta_);
01494 mutable_unknown_fields()->MergeFrom(from.unknown_fields());
01495 }
01496
01497 void SelectHeader::CopyFrom(const ::google::protobuf::Message& from) {
01498 if (&from == this) return;
01499 Clear();
01500 MergeFrom(from);
01501 }
01502
01503 void SelectHeader::CopyFrom(const SelectHeader& from) {
01504 if (&from == this) return;
01505 Clear();
01506 MergeFrom(from);
01507 }
01508
01509 bool SelectHeader::IsInitialized() const {
01510
01511 for (int i = 0; i < table_meta_size(); i++) {
01512 if (!this->table_meta(i).IsInitialized()) return false;
01513 }
01514 for (int i = 0; i < field_meta_size(); i++) {
01515 if (!this->field_meta(i).IsInitialized()) return false;
01516 }
01517 return true;
01518 }
01519
01520 void SelectHeader::Swap(SelectHeader* other) {
01521 if (other != this) {
01522 table_meta_.Swap(&other->table_meta_);
01523 field_meta_.Swap(&other->field_meta_);
01524 std::swap(_has_bits_[0], other->_has_bits_[0]);
01525 _unknown_fields_.Swap(&other->_unknown_fields_);
01526 std::swap(_cached_size_, other->_cached_size_);
01527 }
01528 }
01529
01530 ::google::protobuf::Metadata SelectHeader::GetMetadata() const {
01531 protobuf_AssignDescriptorsOnce();
01532 ::google::protobuf::Metadata metadata;
01533 metadata.descriptor = SelectHeader_descriptor_;
01534 metadata.reflection = SelectHeader_reflection_;
01535 return metadata;
01536 }
01537
01538
01539
01540
01541 #ifndef _MSC_VER
01542 const int SelectData::kSegmentIdFieldNumber;
01543 const int SelectData::kEndSegmentFieldNumber;
01544 const int SelectData::kRecordFieldNumber;
01545 #endif // !_MSC_VER
01546
01547 SelectData::SelectData()
01548 : ::google::protobuf::Message() {
01549 SharedCtor();
01550 }
01551
01552 void SelectData::InitAsDefaultInstance() {
01553 }
01554
01555 SelectData::SelectData(const SelectData& from)
01556 : ::google::protobuf::Message() {
01557 SharedCtor();
01558 MergeFrom(from);
01559 }
01560
01561 void SelectData::SharedCtor() {
01562 _cached_size_ = 0;
01563 segment_id_ = 0u;
01564 end_segment_ = false;
01565 ::memset(_has_bits_, 0, sizeof(_has_bits_));
01566 }
01567
01568 SelectData::~SelectData() {
01569 SharedDtor();
01570 }
01571
01572 void SelectData::SharedDtor() {
01573 if (this != default_instance_) {
01574 }
01575 }
01576
01577 void SelectData::SetCachedSize(int size) const {
01578 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
01579 _cached_size_ = size;
01580 GOOGLE_SAFE_CONCURRENT_WRITES_END();
01581 }
01582 const ::google::protobuf::Descriptor* SelectData::descriptor() {
01583 protobuf_AssignDescriptorsOnce();
01584 return SelectData_descriptor_;
01585 }
01586
01587 const SelectData& SelectData::default_instance() {
01588 if (default_instance_ == NULL) protobuf_AddDesc_resultset_2eproto(); return *default_instance_;
01589 }
01590
01591 SelectData* SelectData::default_instance_ = NULL;
01592
01593 SelectData* SelectData::New() const {
01594 return new SelectData;
01595 }
01596
01597 void SelectData::Clear() {
01598 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
01599 segment_id_ = 0u;
01600 end_segment_ = false;
01601 }
01602 record_.Clear();
01603 ::memset(_has_bits_, 0, sizeof(_has_bits_));
01604 mutable_unknown_fields()->Clear();
01605 }
01606
01607 bool SelectData::MergePartialFromCodedStream(
01608 ::google::protobuf::io::CodedInputStream* input) {
01609 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
01610 ::google::protobuf::uint32 tag;
01611 while ((tag = input->ReadTag()) != 0) {
01612 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
01613
01614 case 1: {
01615 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01616 ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
01617 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
01618 ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
01619 input, &segment_id_)));
01620 _set_bit(0);
01621 } else {
01622 goto handle_uninterpreted;
01623 }
01624 if (input->ExpectTag(16)) goto parse_end_segment;
01625 break;
01626 }
01627
01628
01629 case 2: {
01630 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01631 ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
01632 parse_end_segment:
01633 DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
01634 bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
01635 input, &end_segment_)));
01636 _set_bit(1);
01637 } else {
01638 goto handle_uninterpreted;
01639 }
01640 if (input->ExpectTag(26)) goto parse_record;
01641 break;
01642 }
01643
01644
01645 case 3: {
01646 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01647 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
01648 parse_record:
01649 DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
01650 input, add_record()));
01651 } else {
01652 goto handle_uninterpreted;
01653 }
01654 if (input->ExpectTag(26)) goto parse_record;
01655 if (input->ExpectAtEnd()) return true;
01656 break;
01657 }
01658
01659 default: {
01660 handle_uninterpreted:
01661 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01662 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
01663 return true;
01664 }
01665 DO_(::google::protobuf::internal::WireFormat::SkipField(
01666 input, tag, mutable_unknown_fields()));
01667 break;
01668 }
01669 }
01670 }
01671 return true;
01672 #undef DO_
01673 }
01674
01675 void SelectData::SerializeWithCachedSizes(
01676 ::google::protobuf::io::CodedOutputStream* output) const {
01677
01678 if (_has_bit(0)) {
01679 ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->segment_id(), output);
01680 }
01681
01682
01683 if (_has_bit(1)) {
01684 ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->end_segment(), output);
01685 }
01686
01687
01688 for (int i = 0; i < this->record_size(); i++) {
01689 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
01690 3, this->record(i), output);
01691 }
01692
01693 if (!unknown_fields().empty()) {
01694 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
01695 unknown_fields(), output);
01696 }
01697 }
01698
01699 ::google::protobuf::uint8* SelectData::SerializeWithCachedSizesToArray(
01700 ::google::protobuf::uint8* target) const {
01701
01702 if (_has_bit(0)) {
01703 target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->segment_id(), target);
01704 }
01705
01706
01707 if (_has_bit(1)) {
01708 target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->end_segment(), target);
01709 }
01710
01711
01712 for (int i = 0; i < this->record_size(); i++) {
01713 target = ::google::protobuf::internal::WireFormatLite::
01714 WriteMessageNoVirtualToArray(
01715 3, this->record(i), target);
01716 }
01717
01718 if (!unknown_fields().empty()) {
01719 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
01720 unknown_fields(), target);
01721 }
01722 return target;
01723 }
01724
01725 int SelectData::ByteSize() const {
01726 int total_size = 0;
01727
01728 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
01729
01730 if (has_segment_id()) {
01731 total_size += 1 +
01732 ::google::protobuf::internal::WireFormatLite::UInt32Size(
01733 this->segment_id());
01734 }
01735
01736
01737 if (has_end_segment()) {
01738 total_size += 1 + 1;
01739 }
01740
01741 }
01742
01743 total_size += 1 * this->record_size();
01744 for (int i = 0; i < this->record_size(); i++) {
01745 total_size +=
01746 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
01747 this->record(i));
01748 }
01749
01750 if (!unknown_fields().empty()) {
01751 total_size +=
01752 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
01753 unknown_fields());
01754 }
01755 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
01756 _cached_size_ = total_size;
01757 GOOGLE_SAFE_CONCURRENT_WRITES_END();
01758 return total_size;
01759 }
01760
01761 void SelectData::MergeFrom(const ::google::protobuf::Message& from) {
01762 GOOGLE_CHECK_NE(&from, this);
01763 const SelectData* source =
01764 ::google::protobuf::internal::dynamic_cast_if_available<const SelectData*>(
01765 &from);
01766 if (source == NULL) {
01767 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
01768 } else {
01769 MergeFrom(*source);
01770 }
01771 }
01772
01773 void SelectData::MergeFrom(const SelectData& from) {
01774 GOOGLE_CHECK_NE(&from, this);
01775 record_.MergeFrom(from.record_);
01776 if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
01777 if (from._has_bit(0)) {
01778 set_segment_id(from.segment_id());
01779 }
01780 if (from._has_bit(1)) {
01781 set_end_segment(from.end_segment());
01782 }
01783 }
01784 mutable_unknown_fields()->MergeFrom(from.unknown_fields());
01785 }
01786
01787 void SelectData::CopyFrom(const ::google::protobuf::Message& from) {
01788 if (&from == this) return;
01789 Clear();
01790 MergeFrom(from);
01791 }
01792
01793 void SelectData::CopyFrom(const SelectData& from) {
01794 if (&from == this) return;
01795 Clear();
01796 MergeFrom(from);
01797 }
01798
01799 bool SelectData::IsInitialized() const {
01800 if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
01801
01802 return true;
01803 }
01804
01805 void SelectData::Swap(SelectData* other) {
01806 if (other != this) {
01807 std::swap(segment_id_, other->segment_id_);
01808 std::swap(end_segment_, other->end_segment_);
01809 record_.Swap(&other->record_);
01810 std::swap(_has_bits_[0], other->_has_bits_[0]);
01811 _unknown_fields_.Swap(&other->_unknown_fields_);
01812 std::swap(_cached_size_, other->_cached_size_);
01813 }
01814 }
01815
01816 ::google::protobuf::Metadata SelectData::GetMetadata() const {
01817 protobuf_AssignDescriptorsOnce();
01818 ::google::protobuf::Metadata metadata;
01819 metadata.descriptor = SelectData_descriptor_;
01820 metadata.reflection = SelectData_reflection_;
01821 return metadata;
01822 }
01823
01824
01825
01826
01827 const ::std::string Resultset::_default_key_;
01828 const ::std::string Resultset::_default_schema_;
01829 const ::std::string Resultset::_default_sql_;
01830 #ifndef _MSC_VER
01831 const int Resultset::kKeyFieldNumber;
01832 const int Resultset::kSchemaFieldNumber;
01833 const int Resultset::kSqlFieldNumber;
01834 const int Resultset::kSelectHeaderFieldNumber;
01835 const int Resultset::kSelectDataFieldNumber;
01836 #endif // !_MSC_VER
01837
01838 Resultset::Resultset()
01839 : ::google::protobuf::Message() {
01840 SharedCtor();
01841 }
01842
01843 void Resultset::InitAsDefaultInstance() {
01844 select_header_ = const_cast< ::drizzled::message::SelectHeader*>(&::drizzled::message::SelectHeader::default_instance());
01845 select_data_ = const_cast< ::drizzled::message::SelectData*>(&::drizzled::message::SelectData::default_instance());
01846 }
01847
01848 Resultset::Resultset(const Resultset& from)
01849 : ::google::protobuf::Message() {
01850 SharedCtor();
01851 MergeFrom(from);
01852 }
01853
01854 void Resultset::SharedCtor() {
01855 _cached_size_ = 0;
01856 key_ = const_cast< ::std::string*>(&_default_key_);
01857 schema_ = const_cast< ::std::string*>(&_default_schema_);
01858 sql_ = const_cast< ::std::string*>(&_default_sql_);
01859 select_header_ = NULL;
01860 select_data_ = NULL;
01861 ::memset(_has_bits_, 0, sizeof(_has_bits_));
01862 }
01863
01864 Resultset::~Resultset() {
01865 SharedDtor();
01866 }
01867
01868 void Resultset::SharedDtor() {
01869 if (key_ != &_default_key_) {
01870 delete key_;
01871 }
01872 if (schema_ != &_default_schema_) {
01873 delete schema_;
01874 }
01875 if (sql_ != &_default_sql_) {
01876 delete sql_;
01877 }
01878 if (this != default_instance_) {
01879 delete select_header_;
01880 delete select_data_;
01881 }
01882 }
01883
01884 void Resultset::SetCachedSize(int size) const {
01885 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
01886 _cached_size_ = size;
01887 GOOGLE_SAFE_CONCURRENT_WRITES_END();
01888 }
01889 const ::google::protobuf::Descriptor* Resultset::descriptor() {
01890 protobuf_AssignDescriptorsOnce();
01891 return Resultset_descriptor_;
01892 }
01893
01894 const Resultset& Resultset::default_instance() {
01895 if (default_instance_ == NULL) protobuf_AddDesc_resultset_2eproto(); return *default_instance_;
01896 }
01897
01898 Resultset* Resultset::default_instance_ = NULL;
01899
01900 Resultset* Resultset::New() const {
01901 return new Resultset;
01902 }
01903
01904 void Resultset::Clear() {
01905 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
01906 if (_has_bit(0)) {
01907 if (key_ != &_default_key_) {
01908 key_->clear();
01909 }
01910 }
01911 if (_has_bit(1)) {
01912 if (schema_ != &_default_schema_) {
01913 schema_->clear();
01914 }
01915 }
01916 if (_has_bit(2)) {
01917 if (sql_ != &_default_sql_) {
01918 sql_->clear();
01919 }
01920 }
01921 if (_has_bit(3)) {
01922 if (select_header_ != NULL) select_header_->::drizzled::message::SelectHeader::Clear();
01923 }
01924 if (_has_bit(4)) {
01925 if (select_data_ != NULL) select_data_->::drizzled::message::SelectData::Clear();
01926 }
01927 }
01928 ::memset(_has_bits_, 0, sizeof(_has_bits_));
01929 mutable_unknown_fields()->Clear();
01930 }
01931
01932 bool Resultset::MergePartialFromCodedStream(
01933 ::google::protobuf::io::CodedInputStream* input) {
01934 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
01935 ::google::protobuf::uint32 tag;
01936 while ((tag = input->ReadTag()) != 0) {
01937 switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
01938
01939 case 1: {
01940 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01941 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
01942 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
01943 input, this->mutable_key()));
01944 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
01945 this->key().data(), this->key().length(),
01946 ::google::protobuf::internal::WireFormat::PARSE);
01947 } else {
01948 goto handle_uninterpreted;
01949 }
01950 if (input->ExpectTag(18)) goto parse_schema;
01951 break;
01952 }
01953
01954
01955 case 2: {
01956 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01957 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
01958 parse_schema:
01959 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
01960 input, this->mutable_schema()));
01961 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
01962 this->schema().data(), this->schema().length(),
01963 ::google::protobuf::internal::WireFormat::PARSE);
01964 } else {
01965 goto handle_uninterpreted;
01966 }
01967 if (input->ExpectTag(26)) goto parse_sql;
01968 break;
01969 }
01970
01971
01972 case 3: {
01973 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01974 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
01975 parse_sql:
01976 DO_(::google::protobuf::internal::WireFormatLite::ReadString(
01977 input, this->mutable_sql()));
01978 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
01979 this->sql().data(), this->sql().length(),
01980 ::google::protobuf::internal::WireFormat::PARSE);
01981 } else {
01982 goto handle_uninterpreted;
01983 }
01984 if (input->ExpectTag(34)) goto parse_select_header;
01985 break;
01986 }
01987
01988
01989 case 4: {
01990 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01991 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
01992 parse_select_header:
01993 DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
01994 input, mutable_select_header()));
01995 } else {
01996 goto handle_uninterpreted;
01997 }
01998 if (input->ExpectTag(42)) goto parse_select_data;
01999 break;
02000 }
02001
02002
02003 case 5: {
02004 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02005 ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
02006 parse_select_data:
02007 DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
02008 input, mutable_select_data()));
02009 } else {
02010 goto handle_uninterpreted;
02011 }
02012 if (input->ExpectAtEnd()) return true;
02013 break;
02014 }
02015
02016 default: {
02017 handle_uninterpreted:
02018 if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02019 ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
02020 return true;
02021 }
02022 DO_(::google::protobuf::internal::WireFormat::SkipField(
02023 input, tag, mutable_unknown_fields()));
02024 break;
02025 }
02026 }
02027 }
02028 return true;
02029 #undef DO_
02030 }
02031
02032 void Resultset::SerializeWithCachedSizes(
02033 ::google::protobuf::io::CodedOutputStream* output) const {
02034
02035 if (_has_bit(0)) {
02036 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
02037 this->key().data(), this->key().length(),
02038 ::google::protobuf::internal::WireFormat::SERIALIZE);
02039 ::google::protobuf::internal::WireFormatLite::WriteString(
02040 1, this->key(), output);
02041 }
02042
02043
02044 if (_has_bit(1)) {
02045 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
02046 this->schema().data(), this->schema().length(),
02047 ::google::protobuf::internal::WireFormat::SERIALIZE);
02048 ::google::protobuf::internal::WireFormatLite::WriteString(
02049 2, this->schema(), output);
02050 }
02051
02052
02053 if (_has_bit(2)) {
02054 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
02055 this->sql().data(), this->sql().length(),
02056 ::google::protobuf::internal::WireFormat::SERIALIZE);
02057 ::google::protobuf::internal::WireFormatLite::WriteString(
02058 3, this->sql(), output);
02059 }
02060
02061
02062 if (_has_bit(3)) {
02063 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
02064 4, this->select_header(), output);
02065 }
02066
02067
02068 if (_has_bit(4)) {
02069 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
02070 5, this->select_data(), output);
02071 }
02072
02073 if (!unknown_fields().empty()) {
02074 ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
02075 unknown_fields(), output);
02076 }
02077 }
02078
02079 ::google::protobuf::uint8* Resultset::SerializeWithCachedSizesToArray(
02080 ::google::protobuf::uint8* target) const {
02081
02082 if (_has_bit(0)) {
02083 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
02084 this->key().data(), this->key().length(),
02085 ::google::protobuf::internal::WireFormat::SERIALIZE);
02086 target =
02087 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
02088 1, this->key(), target);
02089 }
02090
02091
02092 if (_has_bit(1)) {
02093 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
02094 this->schema().data(), this->schema().length(),
02095 ::google::protobuf::internal::WireFormat::SERIALIZE);
02096 target =
02097 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
02098 2, this->schema(), target);
02099 }
02100
02101
02102 if (_has_bit(2)) {
02103 ::google::protobuf::internal::WireFormat::VerifyUTF8String(
02104 this->sql().data(), this->sql().length(),
02105 ::google::protobuf::internal::WireFormat::SERIALIZE);
02106 target =
02107 ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
02108 3, this->sql(), target);
02109 }
02110
02111
02112 if (_has_bit(3)) {
02113 target = ::google::protobuf::internal::WireFormatLite::
02114 WriteMessageNoVirtualToArray(
02115 4, this->select_header(), target);
02116 }
02117
02118
02119 if (_has_bit(4)) {
02120 target = ::google::protobuf::internal::WireFormatLite::
02121 WriteMessageNoVirtualToArray(
02122 5, this->select_data(), target);
02123 }
02124
02125 if (!unknown_fields().empty()) {
02126 target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
02127 unknown_fields(), target);
02128 }
02129 return target;
02130 }
02131
02132 int Resultset::ByteSize() const {
02133 int total_size = 0;
02134
02135 if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
02136
02137 if (has_key()) {
02138 total_size += 1 +
02139 ::google::protobuf::internal::WireFormatLite::StringSize(
02140 this->key());
02141 }
02142
02143
02144 if (has_schema()) {
02145 total_size += 1 +
02146 ::google::protobuf::internal::WireFormatLite::StringSize(
02147 this->schema());
02148 }
02149
02150
02151 if (has_sql()) {
02152 total_size += 1 +
02153 ::google::protobuf::internal::WireFormatLite::StringSize(
02154 this->sql());
02155 }
02156
02157
02158 if (has_select_header()) {
02159 total_size += 1 +
02160 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
02161 this->select_header());
02162 }
02163
02164
02165 if (has_select_data()) {
02166 total_size += 1 +
02167 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
02168 this->select_data());
02169 }
02170
02171 }
02172 if (!unknown_fields().empty()) {
02173 total_size +=
02174 ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
02175 unknown_fields());
02176 }
02177 GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
02178 _cached_size_ = total_size;
02179 GOOGLE_SAFE_CONCURRENT_WRITES_END();
02180 return total_size;
02181 }
02182
02183 void Resultset::MergeFrom(const ::google::protobuf::Message& from) {
02184 GOOGLE_CHECK_NE(&from, this);
02185 const Resultset* source =
02186 ::google::protobuf::internal::dynamic_cast_if_available<const Resultset*>(
02187 &from);
02188 if (source == NULL) {
02189 ::google::protobuf::internal::ReflectionOps::Merge(from, this);
02190 } else {
02191 MergeFrom(*source);
02192 }
02193 }
02194
02195 void Resultset::MergeFrom(const Resultset& from) {
02196 GOOGLE_CHECK_NE(&from, this);
02197 if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
02198 if (from._has_bit(0)) {
02199 set_key(from.key());
02200 }
02201 if (from._has_bit(1)) {
02202 set_schema(from.schema());
02203 }
02204 if (from._has_bit(2)) {
02205 set_sql(from.sql());
02206 }
02207 if (from._has_bit(3)) {
02208 mutable_select_header()->::drizzled::message::SelectHeader::MergeFrom(from.select_header());
02209 }
02210 if (from._has_bit(4)) {
02211 mutable_select_data()->::drizzled::message::SelectData::MergeFrom(from.select_data());
02212 }
02213 }
02214 mutable_unknown_fields()->MergeFrom(from.unknown_fields());
02215 }
02216
02217 void Resultset::CopyFrom(const ::google::protobuf::Message& from) {
02218 if (&from == this) return;
02219 Clear();
02220 MergeFrom(from);
02221 }
02222
02223 void Resultset::CopyFrom(const Resultset& from) {
02224 if (&from == this) return;
02225 Clear();
02226 MergeFrom(from);
02227 }
02228
02229 bool Resultset::IsInitialized() const {
02230 if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
02231
02232 if (has_select_header()) {
02233 if (!this->select_header().IsInitialized()) return false;
02234 }
02235 if (has_select_data()) {
02236 if (!this->select_data().IsInitialized()) return false;
02237 }
02238 return true;
02239 }
02240
02241 void Resultset::Swap(Resultset* other) {
02242 if (other != this) {
02243 std::swap(key_, other->key_);
02244 std::swap(schema_, other->schema_);
02245 std::swap(sql_, other->sql_);
02246 std::swap(select_header_, other->select_header_);
02247 std::swap(select_data_, other->select_data_);
02248 std::swap(_has_bits_[0], other->_has_bits_[0]);
02249 _unknown_fields_.Swap(&other->_unknown_fields_);
02250 std::swap(_cached_size_, other->_cached_size_);
02251 }
02252 }
02253
02254 ::google::protobuf::Metadata Resultset::GetMetadata() const {
02255 protobuf_AssignDescriptorsOnce();
02256 ::google::protobuf::Metadata metadata;
02257 metadata.descriptor = Resultset_descriptor_;
02258 metadata.reflection = Resultset_reflection_;
02259 return metadata;
02260 }
02261
02262
02263
02264
02265 }
02266 }
02267
02268