← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/message/resultset.pb.cc

Added hook points and the interface for the Query Cache plugin

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/message/resultset.pb.cc
 
1
// Generated by the protocol buffer compiler.  DO NOT EDIT!
 
2
 
 
3
#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
 
4
#include "resultset.pb.h"
 
5
#include <google/protobuf/stubs/once.h>
 
6
#include <google/protobuf/io/coded_stream.h>
 
7
#include <google/protobuf/wire_format_lite_inl.h>
 
8
#include <google/protobuf/descriptor.h>
 
9
#include <google/protobuf/reflection_ops.h>
 
10
#include <google/protobuf/wire_format.h>
 
11
 
 
12
namespace drizzled {
 
13
namespace message {
 
14
 
 
15
namespace {
 
16
 
 
17
const ::google::protobuf::Descriptor* SelectRecord_descriptor_ = NULL;
 
18
const ::google::protobuf::internal::GeneratedMessageReflection*
 
19
  SelectRecord_reflection_ = NULL;
 
20
const ::google::protobuf::Descriptor* SelectHeader_descriptor_ = NULL;
 
21
const ::google::protobuf::internal::GeneratedMessageReflection*
 
22
  SelectHeader_reflection_ = NULL;
 
23
const ::google::protobuf::Descriptor* SelectData_descriptor_ = NULL;
 
24
const ::google::protobuf::internal::GeneratedMessageReflection*
 
25
  SelectData_reflection_ = NULL;
 
26
const ::google::protobuf::Descriptor* Resultset_descriptor_ = NULL;
 
27
const ::google::protobuf::internal::GeneratedMessageReflection*
 
28
  Resultset_reflection_ = NULL;
 
29
 
 
30
}  // namespace
 
31
 
 
32
 
 
33
void protobuf_AssignDesc_resultset_2eproto() {
 
34
  protobuf_AddDesc_resultset_2eproto();
 
35
  const ::google::protobuf::FileDescriptor* file =
 
36
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
 
37
      "resultset.proto");
 
38
  GOOGLE_CHECK(file != NULL);
 
39
  SelectRecord_descriptor_ = file->message_type(0);
 
40
  static const int SelectRecord_offsets_[1] = {
 
41
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectRecord, record_value_),
 
42
  };
 
43
  SelectRecord_reflection_ =
 
44
    new ::google::protobuf::internal::GeneratedMessageReflection(
 
45
      SelectRecord_descriptor_,
 
46
      SelectRecord::default_instance_,
 
47
      SelectRecord_offsets_,
 
48
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectRecord, _has_bits_[0]),
 
49
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectRecord, _unknown_fields_),
 
50
      -1,
 
51
      ::google::protobuf::DescriptorPool::generated_pool(),
 
52
      ::google::protobuf::MessageFactory::generated_factory(),
 
53
      sizeof(SelectRecord));
 
54
  SelectHeader_descriptor_ = file->message_type(1);
 
55
  static const int SelectHeader_offsets_[2] = {
 
56
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectHeader, table_metadata_),
 
57
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectHeader, field_metadata_),
 
58
  };
 
59
  SelectHeader_reflection_ =
 
60
    new ::google::protobuf::internal::GeneratedMessageReflection(
 
61
      SelectHeader_descriptor_,
 
62
      SelectHeader::default_instance_,
 
63
      SelectHeader_offsets_,
 
64
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectHeader, _has_bits_[0]),
 
65
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectHeader, _unknown_fields_),
 
66
      -1,
 
67
      ::google::protobuf::DescriptorPool::generated_pool(),
 
68
      ::google::protobuf::MessageFactory::generated_factory(),
 
69
      sizeof(SelectHeader));
 
70
  SelectData_descriptor_ = file->message_type(2);
 
71
  static const int SelectData_offsets_[3] = {
 
72
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectData, segment_id_),
 
73
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectData, end_segment_),
 
74
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectData, record_),
 
75
  };
 
76
  SelectData_reflection_ =
 
77
    new ::google::protobuf::internal::GeneratedMessageReflection(
 
78
      SelectData_descriptor_,
 
79
      SelectData::default_instance_,
 
80
      SelectData_offsets_,
 
81
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectData, _has_bits_[0]),
 
82
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SelectData, _unknown_fields_),
 
83
      -1,
 
84
      ::google::protobuf::DescriptorPool::generated_pool(),
 
85
      ::google::protobuf::MessageFactory::generated_factory(),
 
86
      sizeof(SelectData));
 
87
  Resultset_descriptor_ = file->message_type(3);
 
88
  static const int Resultset_offsets_[5] = {
 
89
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Resultset, key_),
 
90
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Resultset, schema_),
 
91
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Resultset, sql_),
 
92
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Resultset, select_header_),
 
93
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Resultset, select_data_),
 
94
  };
 
95
  Resultset_reflection_ =
 
96
    new ::google::protobuf::internal::GeneratedMessageReflection(
 
97
      Resultset_descriptor_,
 
98
      Resultset::default_instance_,
 
99
      Resultset_offsets_,
 
100
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Resultset, _has_bits_[0]),
 
101
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Resultset, _unknown_fields_),
 
102
      -1,
 
103
      ::google::protobuf::DescriptorPool::generated_pool(),
 
104
      ::google::protobuf::MessageFactory::generated_factory(),
 
105
      sizeof(Resultset));
 
106
}
 
107
 
 
108
namespace {
 
109
 
 
110
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
 
111
inline void protobuf_AssignDescriptorsOnce() {
 
112
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
 
113
                 &protobuf_AssignDesc_resultset_2eproto);
 
114
}
 
115
 
 
116
void protobuf_RegisterTypes(const ::std::string&) {
 
117
  protobuf_AssignDescriptorsOnce();
 
118
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 
119
    SelectRecord_descriptor_, &SelectRecord::default_instance());
 
120
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 
121
    SelectHeader_descriptor_, &SelectHeader::default_instance());
 
122
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 
123
    SelectData_descriptor_, &SelectData::default_instance());
 
124
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
 
125
    Resultset_descriptor_, &Resultset::default_instance());
 
126
}
 
127
 
 
128
}  // namespace
 
129
 
 
130
void protobuf_ShutdownFile_resultset_2eproto() {
 
131
  delete SelectRecord::default_instance_;
 
132
  delete SelectRecord_reflection_;
 
133
  delete SelectHeader::default_instance_;
 
134
  delete SelectHeader_reflection_;
 
135
  delete SelectData::default_instance_;
 
136
  delete SelectData_reflection_;
 
137
  delete Resultset::default_instance_;
 
138
  delete Resultset_reflection_;
 
139
}
 
140
 
 
141
void protobuf_AddDesc_resultset_2eproto() {
 
142
  static bool already_here = false;
 
143
  if (already_here) return;
 
144
  already_here = true;
 
145
  GOOGLE_PROTOBUF_VERIFY_VERSION;
 
146
 
 
147
  ::drizzled::message::protobuf_AddDesc_table_2eproto();
 
148
  ::drizzled::message::protobuf_AddDesc_schema_2eproto();
 
149
  ::drizzled::message::protobuf_AddDesc_transaction_2eproto();
 
150
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
 
151
    "\n\017resultset.proto\022\020drizzled.message\032\013tab"
 
152
    "le.proto\032\014schema.proto\032\021transaction.prot"
 
153
    "o\"$\n\014SelectRecord\022\024\n\014record_value\030\001 \003(\014\""
 
154
    "\200\001\n\014SelectHeader\0227\n\016table_metadata\030\001 \003(\013"
 
155
    "2\037.drizzled.message.TableMetadata\0227\n\016fie"
 
156
    "ld_metadata\030\002 \003(\0132\037.drizzled.message.Fie"
 
157
    "ldMetadata\"e\n\nSelectData\022\022\n\nsegment_id\030\001"
 
158
    " \002(\r\022\023\n\013end_segment\030\002 \002(\010\022.\n\006record\030\003 \003("
 
159
    "\0132\036.drizzled.message.SelectRecord\"\237\001\n\tRe"
 
160
    "sultset\022\013\n\003key\030\001 \002(\t\022\016\n\006schema\030\002 \002(\t\022\013\n\003"
 
161
    "sql\030\003 \001(\t\0225\n\rselect_header\030\004 \001(\0132\036.drizz"
 
162
    "led.message.SelectHeader\0221\n\013select_data\030"
 
163
    "\005 \001(\0132\034.drizzled.message.SelectDataB\002H\001", 519);
 
164
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
 
165
    "resultset.proto", &protobuf_RegisterTypes);
 
166
  SelectRecord::default_instance_ = new SelectRecord();
 
167
  SelectHeader::default_instance_ = new SelectHeader();
 
168
  SelectData::default_instance_ = new SelectData();
 
169
  Resultset::default_instance_ = new Resultset();
 
170
  SelectRecord::default_instance_->InitAsDefaultInstance();
 
171
  SelectHeader::default_instance_->InitAsDefaultInstance();
 
172
  SelectData::default_instance_->InitAsDefaultInstance();
 
173
  Resultset::default_instance_->InitAsDefaultInstance();
 
174
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_resultset_2eproto);
 
175
}
 
176
 
 
177
// Force AddDescriptors() to be called at static initialization time.
 
178
struct StaticDescriptorInitializer_resultset_2eproto {
 
179
  StaticDescriptorInitializer_resultset_2eproto() {
 
180
    protobuf_AddDesc_resultset_2eproto();
 
181
  }
 
182
} static_descriptor_initializer_resultset_2eproto_;
 
183
 
 
184
 
 
185
// ===================================================================
 
186
 
 
187
#ifndef _MSC_VER
 
188
const int SelectRecord::kRecordValueFieldNumber;
 
189
#endif  // !_MSC_VER
 
190
 
 
191
SelectRecord::SelectRecord() {
 
192
  SharedCtor();
 
193
}
 
194
 
 
195
void SelectRecord::InitAsDefaultInstance() {
 
196
}
 
197
 
 
198
SelectRecord::SelectRecord(const SelectRecord& from) {
 
199
  SharedCtor();
 
200
  MergeFrom(from);
 
201
}
 
202
 
 
203
void SelectRecord::SharedCtor() {
 
204
  _cached_size_ = 0;
 
205
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
 
206
}
 
207
 
 
208
SelectRecord::~SelectRecord() {
 
209
  SharedDtor();
 
210
}
 
211
 
 
212
void SelectRecord::SharedDtor() {
 
213
  if (this != default_instance_) {
 
214
  }
 
215
}
 
216
 
 
217
const ::google::protobuf::Descriptor* SelectRecord::descriptor() {
 
218
  protobuf_AssignDescriptorsOnce();
 
219
  return SelectRecord_descriptor_;
 
220
}
 
221
 
 
222
const SelectRecord& SelectRecord::default_instance() {
 
223
  if (default_instance_ == NULL) protobuf_AddDesc_resultset_2eproto();  return *default_instance_;
 
224
}
 
225
 
 
226
SelectRecord* SelectRecord::default_instance_ = NULL;
 
227
 
 
228
SelectRecord* SelectRecord::New() const {
 
229
  return new SelectRecord;
 
230
}
 
231
 
 
232
void SelectRecord::Clear() {
 
233
  record_value_.Clear();
 
234
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
 
235
  mutable_unknown_fields()->Clear();
 
236
}
 
237
 
 
238
bool SelectRecord::MergePartialFromCodedStream(
 
239
    ::google::protobuf::io::CodedInputStream* input) {
 
240
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
 
241
  ::google::protobuf::uint32 tag;
 
242
  while ((tag = input->ReadTag()) != 0) {
 
243
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
 
244
      // repeated bytes record_value = 1;
 
245
      case 1: {
 
246
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
 
247
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 
248
          goto handle_uninterpreted;
 
249
        }
 
250
       parse_record_value:
 
251
        DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
 
252
              input, this->add_record_value()));
 
253
        if (input->ExpectTag(10)) goto parse_record_value;
 
254
        if (input->ExpectAtEnd()) return true;
 
255
        break;
 
256
      }
 
257
      
 
258
      default: {
 
259
      handle_uninterpreted:
 
260
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 
261
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
 
262
          return true;
 
263
        }
 
264
        DO_(::google::protobuf::internal::WireFormat::SkipField(
 
265
              input, tag, mutable_unknown_fields()));
 
266
        break;
 
267
      }
 
268
    }
 
269
  }
 
270
  return true;
 
271
#undef DO_
 
272
}
 
273
 
 
274
void SelectRecord::SerializeWithCachedSizes(
 
275
    ::google::protobuf::io::CodedOutputStream* output) const {
 
276
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
 
277
  if (raw_buffer != NULL) {
 
278
    SelectRecord::SerializeWithCachedSizesToArray(raw_buffer);
 
279
    return;
 
280
  }
 
281
  
 
282
  // repeated bytes record_value = 1;
 
283
  for (int i = 0; i < this->record_value_size(); i++) {
 
284
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
 
285
      1, this->record_value(i), output);
 
286
  }
 
287
  
 
288
  if (!unknown_fields().empty()) {
 
289
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
 
290
        unknown_fields(), output);
 
291
  }
 
292
}
 
293
 
 
294
::google::protobuf::uint8* SelectRecord::SerializeWithCachedSizesToArray(
 
295
    ::google::protobuf::uint8* target) const {
 
296
  // repeated bytes record_value = 1;
 
297
  for (int i = 0; i < this->record_value_size(); i++) {
 
298
    target = ::google::protobuf::internal::WireFormatLite::
 
299
      WriteBytesToArray(1, this->record_value(i), target);
 
300
  }
 
301
  
 
302
  if (!unknown_fields().empty()) {
 
303
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
 
304
        unknown_fields(), target);
 
305
  }
 
306
  return target;
 
307
}
 
308
 
 
309
int SelectRecord::ByteSize() const {
 
310
  int total_size = 0;
 
311
  
 
312
  // repeated bytes record_value = 1;
 
313
  total_size += 1 * this->record_value_size();
 
314
  for (int i = 0; i < this->record_value_size(); i++) {
 
315
    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
 
316
      this->record_value(i));
 
317
  }
 
318
  
 
319
  if (!unknown_fields().empty()) {
 
320
    total_size +=
 
321
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
 
322
        unknown_fields());
 
323
  }
 
324
  _cached_size_ = total_size;
 
325
  return total_size;
 
326
}
 
327
 
 
328
void SelectRecord::MergeFrom(const ::google::protobuf::Message& from) {
 
329
  GOOGLE_CHECK_NE(&from, this);
 
330
  const SelectRecord* source =
 
331
    ::google::protobuf::internal::dynamic_cast_if_available<const SelectRecord*>(
 
332
      &from);
 
333
  if (source == NULL) {
 
334
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
 
335
  } else {
 
336
    MergeFrom(*source);
 
337
  }
 
338
}
 
339
 
 
340
void SelectRecord::MergeFrom(const SelectRecord& from) {
 
341
  GOOGLE_CHECK_NE(&from, this);
 
342
  record_value_.MergeFrom(from.record_value_);
 
343
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 
344
}
 
345
 
 
346
void SelectRecord::CopyFrom(const ::google::protobuf::Message& from) {
 
347
  if (&from == this) return;
 
348
  Clear();
 
349
  MergeFrom(from);
 
350
}
 
351
 
 
352
void SelectRecord::CopyFrom(const SelectRecord& from) {
 
353
  if (&from == this) return;
 
354
  Clear();
 
355
  MergeFrom(from);
 
356
}
 
357
 
 
358
bool SelectRecord::IsInitialized() const {
 
359
  
 
360
  return true;
 
361
}
 
362
 
 
363
void SelectRecord::Swap(SelectRecord* other) {
 
364
  if (other != this) {
 
365
    record_value_.Swap(&other->record_value_);
 
366
    std::swap(_has_bits_[0], other->_has_bits_[0]);
 
367
    _unknown_fields_.Swap(&other->_unknown_fields_);
 
368
    std::swap(_cached_size_, other->_cached_size_);
 
369
  }
 
370
}
 
371
 
 
372
::google::protobuf::Metadata SelectRecord::GetMetadata() const {
 
373
  protobuf_AssignDescriptorsOnce();
 
374
  ::google::protobuf::Metadata metadata;
 
375
  metadata.descriptor = SelectRecord_descriptor_;
 
376
  metadata.reflection = SelectRecord_reflection_;
 
377
  return metadata;
 
378
}
 
379
 
 
380
 
 
381
// ===================================================================
 
382
 
 
383
#ifndef _MSC_VER
 
384
const int SelectHeader::kTableMetadataFieldNumber;
 
385
const int SelectHeader::kFieldMetadataFieldNumber;
 
386
#endif  // !_MSC_VER
 
387
 
 
388
SelectHeader::SelectHeader() {
 
389
  SharedCtor();
 
390
}
 
391
 
 
392
void SelectHeader::InitAsDefaultInstance() {
 
393
}
 
394
 
 
395
SelectHeader::SelectHeader(const SelectHeader& from) {
 
396
  SharedCtor();
 
397
  MergeFrom(from);
 
398
}
 
399
 
 
400
void SelectHeader::SharedCtor() {
 
401
  _cached_size_ = 0;
 
402
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
 
403
}
 
404
 
 
405
SelectHeader::~SelectHeader() {
 
406
  SharedDtor();
 
407
}
 
408
 
 
409
void SelectHeader::SharedDtor() {
 
410
  if (this != default_instance_) {
 
411
  }
 
412
}
 
413
 
 
414
const ::google::protobuf::Descriptor* SelectHeader::descriptor() {
 
415
  protobuf_AssignDescriptorsOnce();
 
416
  return SelectHeader_descriptor_;
 
417
}
 
418
 
 
419
const SelectHeader& SelectHeader::default_instance() {
 
420
  if (default_instance_ == NULL) protobuf_AddDesc_resultset_2eproto();  return *default_instance_;
 
421
}
 
422
 
 
423
SelectHeader* SelectHeader::default_instance_ = NULL;
 
424
 
 
425
SelectHeader* SelectHeader::New() const {
 
426
  return new SelectHeader;
 
427
}
 
428
 
 
429
void SelectHeader::Clear() {
 
430
  table_metadata_.Clear();
 
431
  field_metadata_.Clear();
 
432
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
 
433
  mutable_unknown_fields()->Clear();
 
434
}
 
435
 
 
436
bool SelectHeader::MergePartialFromCodedStream(
 
437
    ::google::protobuf::io::CodedInputStream* input) {
 
438
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
 
439
  ::google::protobuf::uint32 tag;
 
440
  while ((tag = input->ReadTag()) != 0) {
 
441
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
 
442
      // repeated .drizzled.message.TableMetadata table_metadata = 1;
 
443
      case 1: {
 
444
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
 
445
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 
446
          goto handle_uninterpreted;
 
447
        }
 
448
       parse_table_metadata:
 
449
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
 
450
              input, add_table_metadata()));
 
451
        if (input->ExpectTag(10)) goto parse_table_metadata;
 
452
        if (input->ExpectTag(18)) goto parse_field_metadata;
 
453
        break;
 
454
      }
 
455
      
 
456
      // repeated .drizzled.message.FieldMetadata field_metadata = 2;
 
457
      case 2: {
 
458
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
 
459
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 
460
          goto handle_uninterpreted;
 
461
        }
 
462
       parse_field_metadata:
 
463
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
 
464
              input, add_field_metadata()));
 
465
        if (input->ExpectTag(18)) goto parse_field_metadata;
 
466
        if (input->ExpectAtEnd()) return true;
 
467
        break;
 
468
      }
 
469
      
 
470
      default: {
 
471
      handle_uninterpreted:
 
472
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 
473
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
 
474
          return true;
 
475
        }
 
476
        DO_(::google::protobuf::internal::WireFormat::SkipField(
 
477
              input, tag, mutable_unknown_fields()));
 
478
        break;
 
479
      }
 
480
    }
 
481
  }
 
482
  return true;
 
483
#undef DO_
 
484
}
 
485
 
 
486
void SelectHeader::SerializeWithCachedSizes(
 
487
    ::google::protobuf::io::CodedOutputStream* output) const {
 
488
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
 
489
  if (raw_buffer != NULL) {
 
490
    SelectHeader::SerializeWithCachedSizesToArray(raw_buffer);
 
491
    return;
 
492
  }
 
493
  
 
494
  // repeated .drizzled.message.TableMetadata table_metadata = 1;
 
495
  for (int i = 0; i < this->table_metadata_size(); i++) {
 
496
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
 
497
      1, this->table_metadata(i), output);
 
498
  }
 
499
  
 
500
  // repeated .drizzled.message.FieldMetadata field_metadata = 2;
 
501
  for (int i = 0; i < this->field_metadata_size(); i++) {
 
502
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
 
503
      2, this->field_metadata(i), output);
 
504
  }
 
505
  
 
506
  if (!unknown_fields().empty()) {
 
507
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
 
508
        unknown_fields(), output);
 
509
  }
 
510
}
 
511
 
 
512
::google::protobuf::uint8* SelectHeader::SerializeWithCachedSizesToArray(
 
513
    ::google::protobuf::uint8* target) const {
 
514
  // repeated .drizzled.message.TableMetadata table_metadata = 1;
 
515
  for (int i = 0; i < this->table_metadata_size(); i++) {
 
516
    target = ::google::protobuf::internal::WireFormatLite::
 
517
      WriteMessageNoVirtualToArray(
 
518
        1, this->table_metadata(i), target);
 
519
  }
 
520
  
 
521
  // repeated .drizzled.message.FieldMetadata field_metadata = 2;
 
522
  for (int i = 0; i < this->field_metadata_size(); i++) {
 
523
    target = ::google::protobuf::internal::WireFormatLite::
 
524
      WriteMessageNoVirtualToArray(
 
525
        2, this->field_metadata(i), target);
 
526
  }
 
527
  
 
528
  if (!unknown_fields().empty()) {
 
529
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
 
530
        unknown_fields(), target);
 
531
  }
 
532
  return target;
 
533
}
 
534
 
 
535
int SelectHeader::ByteSize() const {
 
536
  int total_size = 0;
 
537
  
 
538
  // repeated .drizzled.message.TableMetadata table_metadata = 1;
 
539
  total_size += 1 * this->table_metadata_size();
 
540
  for (int i = 0; i < this->table_metadata_size(); i++) {
 
541
    total_size +=
 
542
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
 
543
        this->table_metadata(i));
 
544
  }
 
545
  
 
546
  // repeated .drizzled.message.FieldMetadata field_metadata = 2;
 
547
  total_size += 1 * this->field_metadata_size();
 
548
  for (int i = 0; i < this->field_metadata_size(); i++) {
 
549
    total_size +=
 
550
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
 
551
        this->field_metadata(i));
 
552
  }
 
553
  
 
554
  if (!unknown_fields().empty()) {
 
555
    total_size +=
 
556
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
 
557
        unknown_fields());
 
558
  }
 
559
  _cached_size_ = total_size;
 
560
  return total_size;
 
561
}
 
562
 
 
563
void SelectHeader::MergeFrom(const ::google::protobuf::Message& from) {
 
564
  GOOGLE_CHECK_NE(&from, this);
 
565
  const SelectHeader* source =
 
566
    ::google::protobuf::internal::dynamic_cast_if_available<const SelectHeader*>(
 
567
      &from);
 
568
  if (source == NULL) {
 
569
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
 
570
  } else {
 
571
    MergeFrom(*source);
 
572
  }
 
573
}
 
574
 
 
575
void SelectHeader::MergeFrom(const SelectHeader& from) {
 
576
  GOOGLE_CHECK_NE(&from, this);
 
577
  table_metadata_.MergeFrom(from.table_metadata_);
 
578
  field_metadata_.MergeFrom(from.field_metadata_);
 
579
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 
580
}
 
581
 
 
582
void SelectHeader::CopyFrom(const ::google::protobuf::Message& from) {
 
583
  if (&from == this) return;
 
584
  Clear();
 
585
  MergeFrom(from);
 
586
}
 
587
 
 
588
void SelectHeader::CopyFrom(const SelectHeader& from) {
 
589
  if (&from == this) return;
 
590
  Clear();
 
591
  MergeFrom(from);
 
592
}
 
593
 
 
594
bool SelectHeader::IsInitialized() const {
 
595
  
 
596
  for (int i = 0; i < table_metadata_size(); i++) {
 
597
    if (!this->table_metadata(i).IsInitialized()) return false;
 
598
  }
 
599
  for (int i = 0; i < field_metadata_size(); i++) {
 
600
    if (!this->field_metadata(i).IsInitialized()) return false;
 
601
  }
 
602
  return true;
 
603
}
 
604
 
 
605
void SelectHeader::Swap(SelectHeader* other) {
 
606
  if (other != this) {
 
607
    table_metadata_.Swap(&other->table_metadata_);
 
608
    field_metadata_.Swap(&other->field_metadata_);
 
609
    std::swap(_has_bits_[0], other->_has_bits_[0]);
 
610
    _unknown_fields_.Swap(&other->_unknown_fields_);
 
611
    std::swap(_cached_size_, other->_cached_size_);
 
612
  }
 
613
}
 
614
 
 
615
::google::protobuf::Metadata SelectHeader::GetMetadata() const {
 
616
  protobuf_AssignDescriptorsOnce();
 
617
  ::google::protobuf::Metadata metadata;
 
618
  metadata.descriptor = SelectHeader_descriptor_;
 
619
  metadata.reflection = SelectHeader_reflection_;
 
620
  return metadata;
 
621
}
 
622
 
 
623
 
 
624
// ===================================================================
 
625
 
 
626
#ifndef _MSC_VER
 
627
const int SelectData::kSegmentIdFieldNumber;
 
628
const int SelectData::kEndSegmentFieldNumber;
 
629
const int SelectData::kRecordFieldNumber;
 
630
#endif  // !_MSC_VER
 
631
 
 
632
SelectData::SelectData() {
 
633
  SharedCtor();
 
634
}
 
635
 
 
636
void SelectData::InitAsDefaultInstance() {
 
637
}
 
638
 
 
639
SelectData::SelectData(const SelectData& from) {
 
640
  SharedCtor();
 
641
  MergeFrom(from);
 
642
}
 
643
 
 
644
void SelectData::SharedCtor() {
 
645
  _cached_size_ = 0;
 
646
  segment_id_ = 0u;
 
647
  end_segment_ = false;
 
648
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
 
649
}
 
650
 
 
651
SelectData::~SelectData() {
 
652
  SharedDtor();
 
653
}
 
654
 
 
655
void SelectData::SharedDtor() {
 
656
  if (this != default_instance_) {
 
657
  }
 
658
}
 
659
 
 
660
const ::google::protobuf::Descriptor* SelectData::descriptor() {
 
661
  protobuf_AssignDescriptorsOnce();
 
662
  return SelectData_descriptor_;
 
663
}
 
664
 
 
665
const SelectData& SelectData::default_instance() {
 
666
  if (default_instance_ == NULL) protobuf_AddDesc_resultset_2eproto();  return *default_instance_;
 
667
}
 
668
 
 
669
SelectData* SelectData::default_instance_ = NULL;
 
670
 
 
671
SelectData* SelectData::New() const {
 
672
  return new SelectData;
 
673
}
 
674
 
 
675
void SelectData::Clear() {
 
676
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
 
677
    segment_id_ = 0u;
 
678
    end_segment_ = false;
 
679
  }
 
680
  record_.Clear();
 
681
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
 
682
  mutable_unknown_fields()->Clear();
 
683
}
 
684
 
 
685
bool SelectData::MergePartialFromCodedStream(
 
686
    ::google::protobuf::io::CodedInputStream* input) {
 
687
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
 
688
  ::google::protobuf::uint32 tag;
 
689
  while ((tag = input->ReadTag()) != 0) {
 
690
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
 
691
      // required uint32 segment_id = 1;
 
692
      case 1: {
 
693
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
 
694
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
 
695
          goto handle_uninterpreted;
 
696
        }
 
697
        DO_(::google::protobuf::internal::WireFormatLite::ReadUInt32(
 
698
              input, &segment_id_));
 
699
        _set_bit(0);
 
700
        if (input->ExpectTag(16)) goto parse_end_segment;
 
701
        break;
 
702
      }
 
703
      
 
704
      // required bool end_segment = 2;
 
705
      case 2: {
 
706
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
 
707
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
 
708
          goto handle_uninterpreted;
 
709
        }
 
710
       parse_end_segment:
 
711
        DO_(::google::protobuf::internal::WireFormatLite::ReadBool(
 
712
              input, &end_segment_));
 
713
        _set_bit(1);
 
714
        if (input->ExpectTag(26)) goto parse_record;
 
715
        break;
 
716
      }
 
717
      
 
718
      // repeated .drizzled.message.SelectRecord record = 3;
 
719
      case 3: {
 
720
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
 
721
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 
722
          goto handle_uninterpreted;
 
723
        }
 
724
       parse_record:
 
725
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
 
726
              input, add_record()));
 
727
        if (input->ExpectTag(26)) goto parse_record;
 
728
        if (input->ExpectAtEnd()) return true;
 
729
        break;
 
730
      }
 
731
      
 
732
      default: {
 
733
      handle_uninterpreted:
 
734
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 
735
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
 
736
          return true;
 
737
        }
 
738
        DO_(::google::protobuf::internal::WireFormat::SkipField(
 
739
              input, tag, mutable_unknown_fields()));
 
740
        break;
 
741
      }
 
742
    }
 
743
  }
 
744
  return true;
 
745
#undef DO_
 
746
}
 
747
 
 
748
void SelectData::SerializeWithCachedSizes(
 
749
    ::google::protobuf::io::CodedOutputStream* output) const {
 
750
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
 
751
  if (raw_buffer != NULL) {
 
752
    SelectData::SerializeWithCachedSizesToArray(raw_buffer);
 
753
    return;
 
754
  }
 
755
  
 
756
  // required uint32 segment_id = 1;
 
757
  if (_has_bit(0)) {
 
758
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->segment_id(), output);
 
759
  }
 
760
  
 
761
  // required bool end_segment = 2;
 
762
  if (_has_bit(1)) {
 
763
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->end_segment(), output);
 
764
  }
 
765
  
 
766
  // repeated .drizzled.message.SelectRecord record = 3;
 
767
  for (int i = 0; i < this->record_size(); i++) {
 
768
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
 
769
      3, this->record(i), output);
 
770
  }
 
771
  
 
772
  if (!unknown_fields().empty()) {
 
773
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
 
774
        unknown_fields(), output);
 
775
  }
 
776
}
 
777
 
 
778
::google::protobuf::uint8* SelectData::SerializeWithCachedSizesToArray(
 
779
    ::google::protobuf::uint8* target) const {
 
780
  // required uint32 segment_id = 1;
 
781
  if (_has_bit(0)) {
 
782
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->segment_id(), target);
 
783
  }
 
784
  
 
785
  // required bool end_segment = 2;
 
786
  if (_has_bit(1)) {
 
787
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->end_segment(), target);
 
788
  }
 
789
  
 
790
  // repeated .drizzled.message.SelectRecord record = 3;
 
791
  for (int i = 0; i < this->record_size(); i++) {
 
792
    target = ::google::protobuf::internal::WireFormatLite::
 
793
      WriteMessageNoVirtualToArray(
 
794
        3, this->record(i), target);
 
795
  }
 
796
  
 
797
  if (!unknown_fields().empty()) {
 
798
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
 
799
        unknown_fields(), target);
 
800
  }
 
801
  return target;
 
802
}
 
803
 
 
804
int SelectData::ByteSize() const {
 
805
  int total_size = 0;
 
806
  
 
807
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
 
808
    // required uint32 segment_id = 1;
 
809
    if (has_segment_id()) {
 
810
      total_size += 1 +
 
811
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
 
812
          this->segment_id());
 
813
    }
 
814
    
 
815
    // required bool end_segment = 2;
 
816
    if (has_end_segment()) {
 
817
      total_size += 1 + 1;
 
818
    }
 
819
    
 
820
  }
 
821
  // repeated .drizzled.message.SelectRecord record = 3;
 
822
  total_size += 1 * this->record_size();
 
823
  for (int i = 0; i < this->record_size(); i++) {
 
824
    total_size +=
 
825
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
 
826
        this->record(i));
 
827
  }
 
828
  
 
829
  if (!unknown_fields().empty()) {
 
830
    total_size +=
 
831
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
 
832
        unknown_fields());
 
833
  }
 
834
  _cached_size_ = total_size;
 
835
  return total_size;
 
836
}
 
837
 
 
838
void SelectData::MergeFrom(const ::google::protobuf::Message& from) {
 
839
  GOOGLE_CHECK_NE(&from, this);
 
840
  const SelectData* source =
 
841
    ::google::protobuf::internal::dynamic_cast_if_available<const SelectData*>(
 
842
      &from);
 
843
  if (source == NULL) {
 
844
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
 
845
  } else {
 
846
    MergeFrom(*source);
 
847
  }
 
848
}
 
849
 
 
850
void SelectData::MergeFrom(const SelectData& from) {
 
851
  GOOGLE_CHECK_NE(&from, this);
 
852
  record_.MergeFrom(from.record_);
 
853
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
 
854
    if (from._has_bit(0)) {
 
855
      set_segment_id(from.segment_id());
 
856
    }
 
857
    if (from._has_bit(1)) {
 
858
      set_end_segment(from.end_segment());
 
859
    }
 
860
  }
 
861
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 
862
}
 
863
 
 
864
void SelectData::CopyFrom(const ::google::protobuf::Message& from) {
 
865
  if (&from == this) return;
 
866
  Clear();
 
867
  MergeFrom(from);
 
868
}
 
869
 
 
870
void SelectData::CopyFrom(const SelectData& from) {
 
871
  if (&from == this) return;
 
872
  Clear();
 
873
  MergeFrom(from);
 
874
}
 
875
 
 
876
bool SelectData::IsInitialized() const {
 
877
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
 
878
  
 
879
  return true;
 
880
}
 
881
 
 
882
void SelectData::Swap(SelectData* other) {
 
883
  if (other != this) {
 
884
    std::swap(segment_id_, other->segment_id_);
 
885
    std::swap(end_segment_, other->end_segment_);
 
886
    record_.Swap(&other->record_);
 
887
    std::swap(_has_bits_[0], other->_has_bits_[0]);
 
888
    _unknown_fields_.Swap(&other->_unknown_fields_);
 
889
    std::swap(_cached_size_, other->_cached_size_);
 
890
  }
 
891
}
 
892
 
 
893
::google::protobuf::Metadata SelectData::GetMetadata() const {
 
894
  protobuf_AssignDescriptorsOnce();
 
895
  ::google::protobuf::Metadata metadata;
 
896
  metadata.descriptor = SelectData_descriptor_;
 
897
  metadata.reflection = SelectData_reflection_;
 
898
  return metadata;
 
899
}
 
900
 
 
901
 
 
902
// ===================================================================
 
903
 
 
904
const ::std::string Resultset::_default_key_;
 
905
const ::std::string Resultset::_default_schema_;
 
906
const ::std::string Resultset::_default_sql_;
 
907
#ifndef _MSC_VER
 
908
const int Resultset::kKeyFieldNumber;
 
909
const int Resultset::kSchemaFieldNumber;
 
910
const int Resultset::kSqlFieldNumber;
 
911
const int Resultset::kSelectHeaderFieldNumber;
 
912
const int Resultset::kSelectDataFieldNumber;
 
913
#endif  // !_MSC_VER
 
914
 
 
915
Resultset::Resultset() {
 
916
  SharedCtor();
 
917
}
 
918
 
 
919
void Resultset::InitAsDefaultInstance() {
 
920
  select_header_ = const_cast< ::drizzled::message::SelectHeader*>(&::drizzled::message::SelectHeader::default_instance());
 
921
  select_data_ = const_cast< ::drizzled::message::SelectData*>(&::drizzled::message::SelectData::default_instance());
 
922
}
 
923
 
 
924
Resultset::Resultset(const Resultset& from) {
 
925
  SharedCtor();
 
926
  MergeFrom(from);
 
927
}
 
928
 
 
929
void Resultset::SharedCtor() {
 
930
  _cached_size_ = 0;
 
931
  key_ = const_cast< ::std::string*>(&_default_key_);
 
932
  schema_ = const_cast< ::std::string*>(&_default_schema_);
 
933
  sql_ = const_cast< ::std::string*>(&_default_sql_);
 
934
  select_header_ = NULL;
 
935
  select_data_ = NULL;
 
936
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
 
937
}
 
938
 
 
939
Resultset::~Resultset() {
 
940
  SharedDtor();
 
941
}
 
942
 
 
943
void Resultset::SharedDtor() {
 
944
  if (key_ != &_default_key_) {
 
945
    delete key_;
 
946
  }
 
947
  if (schema_ != &_default_schema_) {
 
948
    delete schema_;
 
949
  }
 
950
  if (sql_ != &_default_sql_) {
 
951
    delete sql_;
 
952
  }
 
953
  if (this != default_instance_) {
 
954
    delete select_header_;
 
955
    delete select_data_;
 
956
  }
 
957
}
 
958
 
 
959
const ::google::protobuf::Descriptor* Resultset::descriptor() {
 
960
  protobuf_AssignDescriptorsOnce();
 
961
  return Resultset_descriptor_;
 
962
}
 
963
 
 
964
const Resultset& Resultset::default_instance() {
 
965
  if (default_instance_ == NULL) protobuf_AddDesc_resultset_2eproto();  return *default_instance_;
 
966
}
 
967
 
 
968
Resultset* Resultset::default_instance_ = NULL;
 
969
 
 
970
Resultset* Resultset::New() const {
 
971
  return new Resultset;
 
972
}
 
973
 
 
974
void Resultset::Clear() {
 
975
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
 
976
    if (_has_bit(0)) {
 
977
      if (key_ != &_default_key_) {
 
978
        key_->clear();
 
979
      }
 
980
    }
 
981
    if (_has_bit(1)) {
 
982
      if (schema_ != &_default_schema_) {
 
983
        schema_->clear();
 
984
      }
 
985
    }
 
986
    if (_has_bit(2)) {
 
987
      if (sql_ != &_default_sql_) {
 
988
        sql_->clear();
 
989
      }
 
990
    }
 
991
    if (_has_bit(3)) {
 
992
      if (select_header_ != NULL) select_header_->::drizzled::message::SelectHeader::Clear();
 
993
    }
 
994
    if (_has_bit(4)) {
 
995
      if (select_data_ != NULL) select_data_->::drizzled::message::SelectData::Clear();
 
996
    }
 
997
  }
 
998
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
 
999
  mutable_unknown_fields()->Clear();
 
1000
}
 
1001
 
 
1002
bool Resultset::MergePartialFromCodedStream(
 
1003
    ::google::protobuf::io::CodedInputStream* input) {
 
1004
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
 
1005
  ::google::protobuf::uint32 tag;
 
1006
  while ((tag = input->ReadTag()) != 0) {
 
1007
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
 
1008
      // required string key = 1;
 
1009
      case 1: {
 
1010
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
 
1011
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 
1012
          goto handle_uninterpreted;
 
1013
        }
 
1014
        DO_(::google::protobuf::internal::WireFormatLite::ReadString(
 
1015
              input, this->mutable_key()));
 
1016
        ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 
1017
          this->key().data(), this->key().length(),
 
1018
          ::google::protobuf::internal::WireFormat::PARSE);
 
1019
        if (input->ExpectTag(18)) goto parse_schema;
 
1020
        break;
 
1021
      }
 
1022
      
 
1023
      // required string schema = 2;
 
1024
      case 2: {
 
1025
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
 
1026
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 
1027
          goto handle_uninterpreted;
 
1028
        }
 
1029
       parse_schema:
 
1030
        DO_(::google::protobuf::internal::WireFormatLite::ReadString(
 
1031
              input, this->mutable_schema()));
 
1032
        ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 
1033
          this->schema().data(), this->schema().length(),
 
1034
          ::google::protobuf::internal::WireFormat::PARSE);
 
1035
        if (input->ExpectTag(26)) goto parse_sql;
 
1036
        break;
 
1037
      }
 
1038
      
 
1039
      // optional string sql = 3;
 
1040
      case 3: {
 
1041
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
 
1042
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 
1043
          goto handle_uninterpreted;
 
1044
        }
 
1045
       parse_sql:
 
1046
        DO_(::google::protobuf::internal::WireFormatLite::ReadString(
 
1047
              input, this->mutable_sql()));
 
1048
        ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 
1049
          this->sql().data(), this->sql().length(),
 
1050
          ::google::protobuf::internal::WireFormat::PARSE);
 
1051
        if (input->ExpectTag(34)) goto parse_select_header;
 
1052
        break;
 
1053
      }
 
1054
      
 
1055
      // optional .drizzled.message.SelectHeader select_header = 4;
 
1056
      case 4: {
 
1057
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
 
1058
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 
1059
          goto handle_uninterpreted;
 
1060
        }
 
1061
       parse_select_header:
 
1062
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
 
1063
             input, mutable_select_header()));
 
1064
        if (input->ExpectTag(42)) goto parse_select_data;
 
1065
        break;
 
1066
      }
 
1067
      
 
1068
      // optional .drizzled.message.SelectData select_data = 5;
 
1069
      case 5: {
 
1070
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
 
1071
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
 
1072
          goto handle_uninterpreted;
 
1073
        }
 
1074
       parse_select_data:
 
1075
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
 
1076
             input, mutable_select_data()));
 
1077
        if (input->ExpectAtEnd()) return true;
 
1078
        break;
 
1079
      }
 
1080
      
 
1081
      default: {
 
1082
      handle_uninterpreted:
 
1083
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
 
1084
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
 
1085
          return true;
 
1086
        }
 
1087
        DO_(::google::protobuf::internal::WireFormat::SkipField(
 
1088
              input, tag, mutable_unknown_fields()));
 
1089
        break;
 
1090
      }
 
1091
    }
 
1092
  }
 
1093
  return true;
 
1094
#undef DO_
 
1095
}
 
1096
 
 
1097
void Resultset::SerializeWithCachedSizes(
 
1098
    ::google::protobuf::io::CodedOutputStream* output) const {
 
1099
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
 
1100
  if (raw_buffer != NULL) {
 
1101
    Resultset::SerializeWithCachedSizesToArray(raw_buffer);
 
1102
    return;
 
1103
  }
 
1104
  
 
1105
  // required string key = 1;
 
1106
  if (_has_bit(0)) {
 
1107
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 
1108
      this->key().data(), this->key().length(),
 
1109
      ::google::protobuf::internal::WireFormat::SERIALIZE);
 
1110
    ::google::protobuf::internal::WireFormatLite::WriteString(
 
1111
      1, this->key(), output);
 
1112
  }
 
1113
  
 
1114
  // required string schema = 2;
 
1115
  if (_has_bit(1)) {
 
1116
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 
1117
      this->schema().data(), this->schema().length(),
 
1118
      ::google::protobuf::internal::WireFormat::SERIALIZE);
 
1119
    ::google::protobuf::internal::WireFormatLite::WriteString(
 
1120
      2, this->schema(), output);
 
1121
  }
 
1122
  
 
1123
  // optional string sql = 3;
 
1124
  if (_has_bit(2)) {
 
1125
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 
1126
      this->sql().data(), this->sql().length(),
 
1127
      ::google::protobuf::internal::WireFormat::SERIALIZE);
 
1128
    ::google::protobuf::internal::WireFormatLite::WriteString(
 
1129
      3, this->sql(), output);
 
1130
  }
 
1131
  
 
1132
  // optional .drizzled.message.SelectHeader select_header = 4;
 
1133
  if (_has_bit(3)) {
 
1134
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
 
1135
      4, this->select_header(), output);
 
1136
  }
 
1137
  
 
1138
  // optional .drizzled.message.SelectData select_data = 5;
 
1139
  if (_has_bit(4)) {
 
1140
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
 
1141
      5, this->select_data(), output);
 
1142
  }
 
1143
  
 
1144
  if (!unknown_fields().empty()) {
 
1145
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
 
1146
        unknown_fields(), output);
 
1147
  }
 
1148
}
 
1149
 
 
1150
::google::protobuf::uint8* Resultset::SerializeWithCachedSizesToArray(
 
1151
    ::google::protobuf::uint8* target) const {
 
1152
  // required string key = 1;
 
1153
  if (_has_bit(0)) {
 
1154
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 
1155
      this->key().data(), this->key().length(),
 
1156
      ::google::protobuf::internal::WireFormat::SERIALIZE);
 
1157
    target =
 
1158
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
 
1159
        1, this->key(), target);
 
1160
  }
 
1161
  
 
1162
  // required string schema = 2;
 
1163
  if (_has_bit(1)) {
 
1164
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 
1165
      this->schema().data(), this->schema().length(),
 
1166
      ::google::protobuf::internal::WireFormat::SERIALIZE);
 
1167
    target =
 
1168
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
 
1169
        2, this->schema(), target);
 
1170
  }
 
1171
  
 
1172
  // optional string sql = 3;
 
1173
  if (_has_bit(2)) {
 
1174
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
 
1175
      this->sql().data(), this->sql().length(),
 
1176
      ::google::protobuf::internal::WireFormat::SERIALIZE);
 
1177
    target =
 
1178
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
 
1179
        3, this->sql(), target);
 
1180
  }
 
1181
  
 
1182
  // optional .drizzled.message.SelectHeader select_header = 4;
 
1183
  if (_has_bit(3)) {
 
1184
    target = ::google::protobuf::internal::WireFormatLite::
 
1185
      WriteMessageNoVirtualToArray(
 
1186
        4, this->select_header(), target);
 
1187
  }
 
1188
  
 
1189
  // optional .drizzled.message.SelectData select_data = 5;
 
1190
  if (_has_bit(4)) {
 
1191
    target = ::google::protobuf::internal::WireFormatLite::
 
1192
      WriteMessageNoVirtualToArray(
 
1193
        5, this->select_data(), target);
 
1194
  }
 
1195
  
 
1196
  if (!unknown_fields().empty()) {
 
1197
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
 
1198
        unknown_fields(), target);
 
1199
  }
 
1200
  return target;
 
1201
}
 
1202
 
 
1203
int Resultset::ByteSize() const {
 
1204
  int total_size = 0;
 
1205
  
 
1206
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
 
1207
    // required string key = 1;
 
1208
    if (has_key()) {
 
1209
      total_size += 1 +
 
1210
        ::google::protobuf::internal::WireFormatLite::StringSize(
 
1211
          this->key());
 
1212
    }
 
1213
    
 
1214
    // required string schema = 2;
 
1215
    if (has_schema()) {
 
1216
      total_size += 1 +
 
1217
        ::google::protobuf::internal::WireFormatLite::StringSize(
 
1218
          this->schema());
 
1219
    }
 
1220
    
 
1221
    // optional string sql = 3;
 
1222
    if (has_sql()) {
 
1223
      total_size += 1 +
 
1224
        ::google::protobuf::internal::WireFormatLite::StringSize(
 
1225
          this->sql());
 
1226
    }
 
1227
    
 
1228
    // optional .drizzled.message.SelectHeader select_header = 4;
 
1229
    if (has_select_header()) {
 
1230
      total_size += 1 +
 
1231
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
 
1232
          this->select_header());
 
1233
    }
 
1234
    
 
1235
    // optional .drizzled.message.SelectData select_data = 5;
 
1236
    if (has_select_data()) {
 
1237
      total_size += 1 +
 
1238
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
 
1239
          this->select_data());
 
1240
    }
 
1241
    
 
1242
  }
 
1243
  if (!unknown_fields().empty()) {
 
1244
    total_size +=
 
1245
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
 
1246
        unknown_fields());
 
1247
  }
 
1248
  _cached_size_ = total_size;
 
1249
  return total_size;
 
1250
}
 
1251
 
 
1252
void Resultset::MergeFrom(const ::google::protobuf::Message& from) {
 
1253
  GOOGLE_CHECK_NE(&from, this);
 
1254
  const Resultset* source =
 
1255
    ::google::protobuf::internal::dynamic_cast_if_available<const Resultset*>(
 
1256
      &from);
 
1257
  if (source == NULL) {
 
1258
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
 
1259
  } else {
 
1260
    MergeFrom(*source);
 
1261
  }
 
1262
}
 
1263
 
 
1264
void Resultset::MergeFrom(const Resultset& from) {
 
1265
  GOOGLE_CHECK_NE(&from, this);
 
1266
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
 
1267
    if (from._has_bit(0)) {
 
1268
      set_key(from.key());
 
1269
    }
 
1270
    if (from._has_bit(1)) {
 
1271
      set_schema(from.schema());
 
1272
    }
 
1273
    if (from._has_bit(2)) {
 
1274
      set_sql(from.sql());
 
1275
    }
 
1276
    if (from._has_bit(3)) {
 
1277
      mutable_select_header()->::drizzled::message::SelectHeader::MergeFrom(from.select_header());
 
1278
    }
 
1279
    if (from._has_bit(4)) {
 
1280
      mutable_select_data()->::drizzled::message::SelectData::MergeFrom(from.select_data());
 
1281
    }
 
1282
  }
 
1283
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
 
1284
}
 
1285
 
 
1286
void Resultset::CopyFrom(const ::google::protobuf::Message& from) {
 
1287
  if (&from == this) return;
 
1288
  Clear();
 
1289
  MergeFrom(from);
 
1290
}
 
1291
 
 
1292
void Resultset::CopyFrom(const Resultset& from) {
 
1293
  if (&from == this) return;
 
1294
  Clear();
 
1295
  MergeFrom(from);
 
1296
}
 
1297
 
 
1298
bool Resultset::IsInitialized() const {
 
1299
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
 
1300
  
 
1301
  if (has_select_header()) {
 
1302
    if (!this->select_header().IsInitialized()) return false;
 
1303
  }
 
1304
  if (has_select_data()) {
 
1305
    if (!this->select_data().IsInitialized()) return false;
 
1306
  }
 
1307
  return true;
 
1308
}
 
1309
 
 
1310
void Resultset::Swap(Resultset* other) {
 
1311
  if (other != this) {
 
1312
    std::swap(key_, other->key_);
 
1313
    std::swap(schema_, other->schema_);
 
1314
    std::swap(sql_, other->sql_);
 
1315
    std::swap(select_header_, other->select_header_);
 
1316
    std::swap(select_data_, other->select_data_);
 
1317
    std::swap(_has_bits_[0], other->_has_bits_[0]);
 
1318
    _unknown_fields_.Swap(&other->_unknown_fields_);
 
1319
    std::swap(_cached_size_, other->_cached_size_);
 
1320
  }
 
1321
}
 
1322
 
 
1323
::google::protobuf::Metadata Resultset::GetMetadata() const {
 
1324
  protobuf_AssignDescriptorsOnce();
 
1325
  ::google::protobuf::Metadata metadata;
 
1326
  metadata.descriptor = Resultset_descriptor_;
 
1327
  metadata.reflection = Resultset_reflection_;
 
1328
  return metadata;
 
1329
}
 
1330
 
 
1331
 
 
1332
}  // namespace message
 
1333
}  // namespace drizzled