← Back to branch summary

~ubuntu-branches/ubuntu/trusty/drizzle/trusty

« back to all changes in this revision

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

  • Committer: Bazaar Package Importer
  • Author(s): Monty Taylor
  • Date: 2010-10-02 14:17:48 UTC
  • mfrom: (1.1.1 upstream)
  • mto: (2.1.17 sid)
  • mto: This revision was merged to the branch mainline in revision 3.
  • Revision ID: james.westby@ubuntu.com-20101002141748-m6vbfbfjhrw1153e
Tags: 2010.09.1802-1
* New upstream release.
* Removed pid-file argument hack.
* Updated GPL-2 address to be new address.
* Directly copy in drizzledump.1 since debian doesn't have sphinx 1.0 yet.
* Link to jquery from libjs-jquery. Add it as a depend.
* Add drizzled.8 symlink to the install files.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/message/transaction.pb.cc
1
 
// Generated by the protocol buffer compiler.  DO NOT EDIT!
2
 
 
3
 
#define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
4
 
#include "transaction.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* FieldMetadata_descriptor_ = NULL;
18
 
const ::google::protobuf::internal::GeneratedMessageReflection*
19
 
  FieldMetadata_reflection_ = NULL;
20
 
const ::google::protobuf::Descriptor* TableMetadata_descriptor_ = NULL;
21
 
const ::google::protobuf::internal::GeneratedMessageReflection*
22
 
  TableMetadata_reflection_ = NULL;
23
 
const ::google::protobuf::Descriptor* TransactionContext_descriptor_ = NULL;
24
 
const ::google::protobuf::internal::GeneratedMessageReflection*
25
 
  TransactionContext_reflection_ = NULL;
26
 
const ::google::protobuf::Descriptor* InsertRecord_descriptor_ = NULL;
27
 
const ::google::protobuf::internal::GeneratedMessageReflection*
28
 
  InsertRecord_reflection_ = NULL;
29
 
const ::google::protobuf::Descriptor* InsertHeader_descriptor_ = NULL;
30
 
const ::google::protobuf::internal::GeneratedMessageReflection*
31
 
  InsertHeader_reflection_ = NULL;
32
 
const ::google::protobuf::Descriptor* InsertData_descriptor_ = NULL;
33
 
const ::google::protobuf::internal::GeneratedMessageReflection*
34
 
  InsertData_reflection_ = NULL;
35
 
const ::google::protobuf::Descriptor* UpdateRecord_descriptor_ = NULL;
36
 
const ::google::protobuf::internal::GeneratedMessageReflection*
37
 
  UpdateRecord_reflection_ = NULL;
38
 
const ::google::protobuf::Descriptor* UpdateHeader_descriptor_ = NULL;
39
 
const ::google::protobuf::internal::GeneratedMessageReflection*
40
 
  UpdateHeader_reflection_ = NULL;
41
 
const ::google::protobuf::Descriptor* UpdateData_descriptor_ = NULL;
42
 
const ::google::protobuf::internal::GeneratedMessageReflection*
43
 
  UpdateData_reflection_ = NULL;
44
 
const ::google::protobuf::Descriptor* DeleteRecord_descriptor_ = NULL;
45
 
const ::google::protobuf::internal::GeneratedMessageReflection*
46
 
  DeleteRecord_reflection_ = NULL;
47
 
const ::google::protobuf::Descriptor* DeleteHeader_descriptor_ = NULL;
48
 
const ::google::protobuf::internal::GeneratedMessageReflection*
49
 
  DeleteHeader_reflection_ = NULL;
50
 
const ::google::protobuf::Descriptor* DeleteData_descriptor_ = NULL;
51
 
const ::google::protobuf::internal::GeneratedMessageReflection*
52
 
  DeleteData_reflection_ = NULL;
53
 
const ::google::protobuf::Descriptor* TruncateTableStatement_descriptor_ = NULL;
54
 
const ::google::protobuf::internal::GeneratedMessageReflection*
55
 
  TruncateTableStatement_reflection_ = NULL;
56
 
const ::google::protobuf::Descriptor* CreateSchemaStatement_descriptor_ = NULL;
57
 
const ::google::protobuf::internal::GeneratedMessageReflection*
58
 
  CreateSchemaStatement_reflection_ = NULL;
59
 
const ::google::protobuf::Descriptor* AlterSchemaStatement_descriptor_ = NULL;
60
 
const ::google::protobuf::internal::GeneratedMessageReflection*
61
 
  AlterSchemaStatement_reflection_ = NULL;
62
 
const ::google::protobuf::Descriptor* DropSchemaStatement_descriptor_ = NULL;
63
 
const ::google::protobuf::internal::GeneratedMessageReflection*
64
 
  DropSchemaStatement_reflection_ = NULL;
65
 
const ::google::protobuf::Descriptor* CreateTableStatement_descriptor_ = NULL;
66
 
const ::google::protobuf::internal::GeneratedMessageReflection*
67
 
  CreateTableStatement_reflection_ = NULL;
68
 
const ::google::protobuf::Descriptor* AlterTableStatement_descriptor_ = NULL;
69
 
const ::google::protobuf::internal::GeneratedMessageReflection*
70
 
  AlterTableStatement_reflection_ = NULL;
71
 
const ::google::protobuf::Descriptor* DropTableStatement_descriptor_ = NULL;
72
 
const ::google::protobuf::internal::GeneratedMessageReflection*
73
 
  DropTableStatement_reflection_ = NULL;
74
 
const ::google::protobuf::Descriptor* SetVariableStatement_descriptor_ = NULL;
75
 
const ::google::protobuf::internal::GeneratedMessageReflection*
76
 
  SetVariableStatement_reflection_ = NULL;
77
 
const ::google::protobuf::Descriptor* Statement_descriptor_ = NULL;
78
 
const ::google::protobuf::internal::GeneratedMessageReflection*
79
 
  Statement_reflection_ = NULL;
80
 
const ::google::protobuf::EnumDescriptor* Statement_Type_descriptor_ = NULL;
81
 
const ::google::protobuf::Descriptor* Transaction_descriptor_ = NULL;
82
 
const ::google::protobuf::internal::GeneratedMessageReflection*
83
 
  Transaction_reflection_ = NULL;
84
 
 
85
 
}  // namespace
86
 
 
87
 
 
88
 
void protobuf_AssignDesc_transaction_2eproto() {
89
 
  protobuf_AddDesc_transaction_2eproto();
90
 
  const ::google::protobuf::FileDescriptor* file =
91
 
    ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
92
 
      "transaction.proto");
93
 
  GOOGLE_CHECK(file != NULL);
94
 
  FieldMetadata_descriptor_ = file->message_type(0);
95
 
  static const int FieldMetadata_offsets_[2] = {
96
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMetadata, type_),
97
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMetadata, name_),
98
 
  };
99
 
  FieldMetadata_reflection_ =
100
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
101
 
      FieldMetadata_descriptor_,
102
 
      FieldMetadata::default_instance_,
103
 
      FieldMetadata_offsets_,
104
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMetadata, _has_bits_[0]),
105
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMetadata, _unknown_fields_),
106
 
      -1,
107
 
      ::google::protobuf::DescriptorPool::generated_pool(),
108
 
      ::google::protobuf::MessageFactory::generated_factory(),
109
 
      sizeof(FieldMetadata));
110
 
  TableMetadata_descriptor_ = file->message_type(1);
111
 
  static const int TableMetadata_offsets_[2] = {
112
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMetadata, schema_name_),
113
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMetadata, table_name_),
114
 
  };
115
 
  TableMetadata_reflection_ =
116
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
117
 
      TableMetadata_descriptor_,
118
 
      TableMetadata::default_instance_,
119
 
      TableMetadata_offsets_,
120
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMetadata, _has_bits_[0]),
121
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMetadata, _unknown_fields_),
122
 
      -1,
123
 
      ::google::protobuf::DescriptorPool::generated_pool(),
124
 
      ::google::protobuf::MessageFactory::generated_factory(),
125
 
      sizeof(TableMetadata));
126
 
  TransactionContext_descriptor_ = file->message_type(2);
127
 
  static const int TransactionContext_offsets_[4] = {
128
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransactionContext, server_id_),
129
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransactionContext, transaction_id_),
130
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransactionContext, start_timestamp_),
131
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransactionContext, end_timestamp_),
132
 
  };
133
 
  TransactionContext_reflection_ =
134
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
135
 
      TransactionContext_descriptor_,
136
 
      TransactionContext::default_instance_,
137
 
      TransactionContext_offsets_,
138
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransactionContext, _has_bits_[0]),
139
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransactionContext, _unknown_fields_),
140
 
      -1,
141
 
      ::google::protobuf::DescriptorPool::generated_pool(),
142
 
      ::google::protobuf::MessageFactory::generated_factory(),
143
 
      sizeof(TransactionContext));
144
 
  InsertRecord_descriptor_ = file->message_type(3);
145
 
  static const int InsertRecord_offsets_[1] = {
146
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertRecord, insert_value_),
147
 
  };
148
 
  InsertRecord_reflection_ =
149
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
150
 
      InsertRecord_descriptor_,
151
 
      InsertRecord::default_instance_,
152
 
      InsertRecord_offsets_,
153
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertRecord, _has_bits_[0]),
154
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertRecord, _unknown_fields_),
155
 
      -1,
156
 
      ::google::protobuf::DescriptorPool::generated_pool(),
157
 
      ::google::protobuf::MessageFactory::generated_factory(),
158
 
      sizeof(InsertRecord));
159
 
  InsertHeader_descriptor_ = file->message_type(4);
160
 
  static const int InsertHeader_offsets_[2] = {
161
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertHeader, table_metadata_),
162
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertHeader, field_metadata_),
163
 
  };
164
 
  InsertHeader_reflection_ =
165
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
166
 
      InsertHeader_descriptor_,
167
 
      InsertHeader::default_instance_,
168
 
      InsertHeader_offsets_,
169
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertHeader, _has_bits_[0]),
170
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertHeader, _unknown_fields_),
171
 
      -1,
172
 
      ::google::protobuf::DescriptorPool::generated_pool(),
173
 
      ::google::protobuf::MessageFactory::generated_factory(),
174
 
      sizeof(InsertHeader));
175
 
  InsertData_descriptor_ = file->message_type(5);
176
 
  static const int InsertData_offsets_[3] = {
177
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertData, segment_id_),
178
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertData, end_segment_),
179
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertData, record_),
180
 
  };
181
 
  InsertData_reflection_ =
182
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
183
 
      InsertData_descriptor_,
184
 
      InsertData::default_instance_,
185
 
      InsertData_offsets_,
186
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertData, _has_bits_[0]),
187
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertData, _unknown_fields_),
188
 
      -1,
189
 
      ::google::protobuf::DescriptorPool::generated_pool(),
190
 
      ::google::protobuf::MessageFactory::generated_factory(),
191
 
      sizeof(InsertData));
192
 
  UpdateRecord_descriptor_ = file->message_type(6);
193
 
  static const int UpdateRecord_offsets_[3] = {
194
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRecord, key_value_),
195
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRecord, after_value_),
196
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRecord, before_value_),
197
 
  };
198
 
  UpdateRecord_reflection_ =
199
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
200
 
      UpdateRecord_descriptor_,
201
 
      UpdateRecord::default_instance_,
202
 
      UpdateRecord_offsets_,
203
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRecord, _has_bits_[0]),
204
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRecord, _unknown_fields_),
205
 
      -1,
206
 
      ::google::protobuf::DescriptorPool::generated_pool(),
207
 
      ::google::protobuf::MessageFactory::generated_factory(),
208
 
      sizeof(UpdateRecord));
209
 
  UpdateHeader_descriptor_ = file->message_type(7);
210
 
  static const int UpdateHeader_offsets_[3] = {
211
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateHeader, table_metadata_),
212
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateHeader, key_field_metadata_),
213
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateHeader, set_field_metadata_),
214
 
  };
215
 
  UpdateHeader_reflection_ =
216
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
217
 
      UpdateHeader_descriptor_,
218
 
      UpdateHeader::default_instance_,
219
 
      UpdateHeader_offsets_,
220
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateHeader, _has_bits_[0]),
221
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateHeader, _unknown_fields_),
222
 
      -1,
223
 
      ::google::protobuf::DescriptorPool::generated_pool(),
224
 
      ::google::protobuf::MessageFactory::generated_factory(),
225
 
      sizeof(UpdateHeader));
226
 
  UpdateData_descriptor_ = file->message_type(8);
227
 
  static const int UpdateData_offsets_[3] = {
228
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateData, segment_id_),
229
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateData, end_segment_),
230
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateData, record_),
231
 
  };
232
 
  UpdateData_reflection_ =
233
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
234
 
      UpdateData_descriptor_,
235
 
      UpdateData::default_instance_,
236
 
      UpdateData_offsets_,
237
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateData, _has_bits_[0]),
238
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateData, _unknown_fields_),
239
 
      -1,
240
 
      ::google::protobuf::DescriptorPool::generated_pool(),
241
 
      ::google::protobuf::MessageFactory::generated_factory(),
242
 
      sizeof(UpdateData));
243
 
  DeleteRecord_descriptor_ = file->message_type(9);
244
 
  static const int DeleteRecord_offsets_[1] = {
245
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteRecord, key_value_),
246
 
  };
247
 
  DeleteRecord_reflection_ =
248
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
249
 
      DeleteRecord_descriptor_,
250
 
      DeleteRecord::default_instance_,
251
 
      DeleteRecord_offsets_,
252
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteRecord, _has_bits_[0]),
253
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteRecord, _unknown_fields_),
254
 
      -1,
255
 
      ::google::protobuf::DescriptorPool::generated_pool(),
256
 
      ::google::protobuf::MessageFactory::generated_factory(),
257
 
      sizeof(DeleteRecord));
258
 
  DeleteHeader_descriptor_ = file->message_type(10);
259
 
  static const int DeleteHeader_offsets_[2] = {
260
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteHeader, table_metadata_),
261
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteHeader, key_field_metadata_),
262
 
  };
263
 
  DeleteHeader_reflection_ =
264
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
265
 
      DeleteHeader_descriptor_,
266
 
      DeleteHeader::default_instance_,
267
 
      DeleteHeader_offsets_,
268
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteHeader, _has_bits_[0]),
269
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteHeader, _unknown_fields_),
270
 
      -1,
271
 
      ::google::protobuf::DescriptorPool::generated_pool(),
272
 
      ::google::protobuf::MessageFactory::generated_factory(),
273
 
      sizeof(DeleteHeader));
274
 
  DeleteData_descriptor_ = file->message_type(11);
275
 
  static const int DeleteData_offsets_[3] = {
276
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteData, segment_id_),
277
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteData, end_segment_),
278
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteData, record_),
279
 
  };
280
 
  DeleteData_reflection_ =
281
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
282
 
      DeleteData_descriptor_,
283
 
      DeleteData::default_instance_,
284
 
      DeleteData_offsets_,
285
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteData, _has_bits_[0]),
286
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteData, _unknown_fields_),
287
 
      -1,
288
 
      ::google::protobuf::DescriptorPool::generated_pool(),
289
 
      ::google::protobuf::MessageFactory::generated_factory(),
290
 
      sizeof(DeleteData));
291
 
  TruncateTableStatement_descriptor_ = file->message_type(12);
292
 
  static const int TruncateTableStatement_offsets_[1] = {
293
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateTableStatement, table_metadata_),
294
 
  };
295
 
  TruncateTableStatement_reflection_ =
296
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
297
 
      TruncateTableStatement_descriptor_,
298
 
      TruncateTableStatement::default_instance_,
299
 
      TruncateTableStatement_offsets_,
300
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateTableStatement, _has_bits_[0]),
301
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateTableStatement, _unknown_fields_),
302
 
      -1,
303
 
      ::google::protobuf::DescriptorPool::generated_pool(),
304
 
      ::google::protobuf::MessageFactory::generated_factory(),
305
 
      sizeof(TruncateTableStatement));
306
 
  CreateSchemaStatement_descriptor_ = file->message_type(13);
307
 
  static const int CreateSchemaStatement_offsets_[1] = {
308
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateSchemaStatement, schema_),
309
 
  };
310
 
  CreateSchemaStatement_reflection_ =
311
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
312
 
      CreateSchemaStatement_descriptor_,
313
 
      CreateSchemaStatement::default_instance_,
314
 
      CreateSchemaStatement_offsets_,
315
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateSchemaStatement, _has_bits_[0]),
316
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateSchemaStatement, _unknown_fields_),
317
 
      -1,
318
 
      ::google::protobuf::DescriptorPool::generated_pool(),
319
 
      ::google::protobuf::MessageFactory::generated_factory(),
320
 
      sizeof(CreateSchemaStatement));
321
 
  AlterSchemaStatement_descriptor_ = file->message_type(14);
322
 
  static const int AlterSchemaStatement_offsets_[2] = {
323
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AlterSchemaStatement, before_),
324
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AlterSchemaStatement, after_),
325
 
  };
326
 
  AlterSchemaStatement_reflection_ =
327
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
328
 
      AlterSchemaStatement_descriptor_,
329
 
      AlterSchemaStatement::default_instance_,
330
 
      AlterSchemaStatement_offsets_,
331
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AlterSchemaStatement, _has_bits_[0]),
332
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AlterSchemaStatement, _unknown_fields_),
333
 
      -1,
334
 
      ::google::protobuf::DescriptorPool::generated_pool(),
335
 
      ::google::protobuf::MessageFactory::generated_factory(),
336
 
      sizeof(AlterSchemaStatement));
337
 
  DropSchemaStatement_descriptor_ = file->message_type(15);
338
 
  static const int DropSchemaStatement_offsets_[1] = {
339
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropSchemaStatement, schema_name_),
340
 
  };
341
 
  DropSchemaStatement_reflection_ =
342
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
343
 
      DropSchemaStatement_descriptor_,
344
 
      DropSchemaStatement::default_instance_,
345
 
      DropSchemaStatement_offsets_,
346
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropSchemaStatement, _has_bits_[0]),
347
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropSchemaStatement, _unknown_fields_),
348
 
      -1,
349
 
      ::google::protobuf::DescriptorPool::generated_pool(),
350
 
      ::google::protobuf::MessageFactory::generated_factory(),
351
 
      sizeof(DropSchemaStatement));
352
 
  CreateTableStatement_descriptor_ = file->message_type(16);
353
 
  static const int CreateTableStatement_offsets_[1] = {
354
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTableStatement, table_),
355
 
  };
356
 
  CreateTableStatement_reflection_ =
357
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
358
 
      CreateTableStatement_descriptor_,
359
 
      CreateTableStatement::default_instance_,
360
 
      CreateTableStatement_offsets_,
361
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTableStatement, _has_bits_[0]),
362
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTableStatement, _unknown_fields_),
363
 
      -1,
364
 
      ::google::protobuf::DescriptorPool::generated_pool(),
365
 
      ::google::protobuf::MessageFactory::generated_factory(),
366
 
      sizeof(CreateTableStatement));
367
 
  AlterTableStatement_descriptor_ = file->message_type(17);
368
 
  static const int AlterTableStatement_offsets_[2] = {
369
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AlterTableStatement, before_),
370
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AlterTableStatement, after_),
371
 
  };
372
 
  AlterTableStatement_reflection_ =
373
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
374
 
      AlterTableStatement_descriptor_,
375
 
      AlterTableStatement::default_instance_,
376
 
      AlterTableStatement_offsets_,
377
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AlterTableStatement, _has_bits_[0]),
378
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AlterTableStatement, _unknown_fields_),
379
 
      -1,
380
 
      ::google::protobuf::DescriptorPool::generated_pool(),
381
 
      ::google::protobuf::MessageFactory::generated_factory(),
382
 
      sizeof(AlterTableStatement));
383
 
  DropTableStatement_descriptor_ = file->message_type(18);
384
 
  static const int DropTableStatement_offsets_[2] = {
385
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropTableStatement, table_metadata_),
386
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropTableStatement, if_exists_clause_),
387
 
  };
388
 
  DropTableStatement_reflection_ =
389
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
390
 
      DropTableStatement_descriptor_,
391
 
      DropTableStatement::default_instance_,
392
 
      DropTableStatement_offsets_,
393
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropTableStatement, _has_bits_[0]),
394
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropTableStatement, _unknown_fields_),
395
 
      -1,
396
 
      ::google::protobuf::DescriptorPool::generated_pool(),
397
 
      ::google::protobuf::MessageFactory::generated_factory(),
398
 
      sizeof(DropTableStatement));
399
 
  SetVariableStatement_descriptor_ = file->message_type(19);
400
 
  static const int SetVariableStatement_offsets_[2] = {
401
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetVariableStatement, variable_metadata_),
402
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetVariableStatement, variable_value_),
403
 
  };
404
 
  SetVariableStatement_reflection_ =
405
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
406
 
      SetVariableStatement_descriptor_,
407
 
      SetVariableStatement::default_instance_,
408
 
      SetVariableStatement_offsets_,
409
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetVariableStatement, _has_bits_[0]),
410
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetVariableStatement, _unknown_fields_),
411
 
      -1,
412
 
      ::google::protobuf::DescriptorPool::generated_pool(),
413
 
      ::google::protobuf::MessageFactory::generated_factory(),
414
 
      sizeof(SetVariableStatement));
415
 
  Statement_descriptor_ = file->message_type(20);
416
 
  static const int Statement_offsets_[18] = {
417
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, type_),
418
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, start_timestamp_),
419
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, end_timestamp_),
420
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, sql_),
421
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, insert_header_),
422
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, insert_data_),
423
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, update_header_),
424
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, update_data_),
425
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, delete_header_),
426
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, delete_data_),
427
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, truncate_table_statement_),
428
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, create_schema_statement_),
429
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, drop_schema_statement_),
430
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, alter_schema_statement_),
431
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, create_table_statement_),
432
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, alter_table_statement_),
433
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, drop_table_statement_),
434
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, set_variable_statement_),
435
 
  };
436
 
  Statement_reflection_ =
437
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
438
 
      Statement_descriptor_,
439
 
      Statement::default_instance_,
440
 
      Statement_offsets_,
441
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, _has_bits_[0]),
442
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, _unknown_fields_),
443
 
      -1,
444
 
      ::google::protobuf::DescriptorPool::generated_pool(),
445
 
      ::google::protobuf::MessageFactory::generated_factory(),
446
 
      sizeof(Statement));
447
 
  Statement_Type_descriptor_ = Statement_descriptor_->enum_type(0);
448
 
  Transaction_descriptor_ = file->message_type(21);
449
 
  static const int Transaction_offsets_[2] = {
450
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Transaction, transaction_context_),
451
 
    GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Transaction, statement_),
452
 
  };
453
 
  Transaction_reflection_ =
454
 
    new ::google::protobuf::internal::GeneratedMessageReflection(
455
 
      Transaction_descriptor_,
456
 
      Transaction::default_instance_,
457
 
      Transaction_offsets_,
458
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Transaction, _has_bits_[0]),
459
 
      GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Transaction, _unknown_fields_),
460
 
      -1,
461
 
      ::google::protobuf::DescriptorPool::generated_pool(),
462
 
      ::google::protobuf::MessageFactory::generated_factory(),
463
 
      sizeof(Transaction));
464
 
}
465
 
 
466
 
namespace {
467
 
 
468
 
GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
469
 
inline void protobuf_AssignDescriptorsOnce() {
470
 
  ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
471
 
                 &protobuf_AssignDesc_transaction_2eproto);
472
 
}
473
 
 
474
 
void protobuf_RegisterTypes(const ::std::string&) {
475
 
  protobuf_AssignDescriptorsOnce();
476
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
477
 
    FieldMetadata_descriptor_, &FieldMetadata::default_instance());
478
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
479
 
    TableMetadata_descriptor_, &TableMetadata::default_instance());
480
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
481
 
    TransactionContext_descriptor_, &TransactionContext::default_instance());
482
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
483
 
    InsertRecord_descriptor_, &InsertRecord::default_instance());
484
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
485
 
    InsertHeader_descriptor_, &InsertHeader::default_instance());
486
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
487
 
    InsertData_descriptor_, &InsertData::default_instance());
488
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
489
 
    UpdateRecord_descriptor_, &UpdateRecord::default_instance());
490
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
491
 
    UpdateHeader_descriptor_, &UpdateHeader::default_instance());
492
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
493
 
    UpdateData_descriptor_, &UpdateData::default_instance());
494
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
495
 
    DeleteRecord_descriptor_, &DeleteRecord::default_instance());
496
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
497
 
    DeleteHeader_descriptor_, &DeleteHeader::default_instance());
498
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
499
 
    DeleteData_descriptor_, &DeleteData::default_instance());
500
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
501
 
    TruncateTableStatement_descriptor_, &TruncateTableStatement::default_instance());
502
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
503
 
    CreateSchemaStatement_descriptor_, &CreateSchemaStatement::default_instance());
504
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
505
 
    AlterSchemaStatement_descriptor_, &AlterSchemaStatement::default_instance());
506
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
507
 
    DropSchemaStatement_descriptor_, &DropSchemaStatement::default_instance());
508
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
509
 
    CreateTableStatement_descriptor_, &CreateTableStatement::default_instance());
510
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
511
 
    AlterTableStatement_descriptor_, &AlterTableStatement::default_instance());
512
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
513
 
    DropTableStatement_descriptor_, &DropTableStatement::default_instance());
514
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
515
 
    SetVariableStatement_descriptor_, &SetVariableStatement::default_instance());
516
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
517
 
    Statement_descriptor_, &Statement::default_instance());
518
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
519
 
    Transaction_descriptor_, &Transaction::default_instance());
520
 
}
521
 
 
522
 
}  // namespace
523
 
 
524
 
void protobuf_ShutdownFile_transaction_2eproto() {
525
 
  delete FieldMetadata::default_instance_;
526
 
  delete FieldMetadata_reflection_;
527
 
  delete TableMetadata::default_instance_;
528
 
  delete TableMetadata_reflection_;
529
 
  delete TransactionContext::default_instance_;
530
 
  delete TransactionContext_reflection_;
531
 
  delete InsertRecord::default_instance_;
532
 
  delete InsertRecord_reflection_;
533
 
  delete InsertHeader::default_instance_;
534
 
  delete InsertHeader_reflection_;
535
 
  delete InsertData::default_instance_;
536
 
  delete InsertData_reflection_;
537
 
  delete UpdateRecord::default_instance_;
538
 
  delete UpdateRecord_reflection_;
539
 
  delete UpdateHeader::default_instance_;
540
 
  delete UpdateHeader_reflection_;
541
 
  delete UpdateData::default_instance_;
542
 
  delete UpdateData_reflection_;
543
 
  delete DeleteRecord::default_instance_;
544
 
  delete DeleteRecord_reflection_;
545
 
  delete DeleteHeader::default_instance_;
546
 
  delete DeleteHeader_reflection_;
547
 
  delete DeleteData::default_instance_;
548
 
  delete DeleteData_reflection_;
549
 
  delete TruncateTableStatement::default_instance_;
550
 
  delete TruncateTableStatement_reflection_;
551
 
  delete CreateSchemaStatement::default_instance_;
552
 
  delete CreateSchemaStatement_reflection_;
553
 
  delete AlterSchemaStatement::default_instance_;
554
 
  delete AlterSchemaStatement_reflection_;
555
 
  delete DropSchemaStatement::default_instance_;
556
 
  delete DropSchemaStatement_reflection_;
557
 
  delete CreateTableStatement::default_instance_;
558
 
  delete CreateTableStatement_reflection_;
559
 
  delete AlterTableStatement::default_instance_;
560
 
  delete AlterTableStatement_reflection_;
561
 
  delete DropTableStatement::default_instance_;
562
 
  delete DropTableStatement_reflection_;
563
 
  delete SetVariableStatement::default_instance_;
564
 
  delete SetVariableStatement_reflection_;
565
 
  delete Statement::default_instance_;
566
 
  delete Statement_reflection_;
567
 
  delete Transaction::default_instance_;
568
 
  delete Transaction_reflection_;
569
 
}
570
 
 
571
 
void protobuf_AddDesc_transaction_2eproto() {
572
 
  static bool already_here = false;
573
 
  if (already_here) return;
574
 
  already_here = true;
575
 
  GOOGLE_PROTOBUF_VERIFY_VERSION;
576
 
 
577
 
  ::drizzled::message::protobuf_AddDesc_table_2eproto();
578
 
  ::drizzled::message::protobuf_AddDesc_schema_2eproto();
579
 
  ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
580
 
    "\n\021transaction.proto\022\020drizzled.message\032\013t"
581
 
    "able.proto\032\014schema.proto\"T\n\rFieldMetadat"
582
 
    "a\0225\n\004type\030\001 \002(\0162\'.drizzled.message.Table"
583
 
    ".Field.FieldType\022\014\n\004name\030\002 \002(\t\"8\n\rTableM"
584
 
    "etadata\022\023\n\013schema_name\030\001 \002(\t\022\022\n\ntable_na"
585
 
    "me\030\002 \002(\t\"o\n\022TransactionContext\022\021\n\tserver"
586
 
    "_id\030\001 \002(\r\022\026\n\016transaction_id\030\002 \002(\004\022\027\n\017sta"
587
 
    "rt_timestamp\030\003 \002(\004\022\025\n\rend_timestamp\030\004 \002("
588
 
    "\004\"$\n\014InsertRecord\022\024\n\014insert_value\030\001 \003(\014\""
589
 
    "\200\001\n\014InsertHeader\0227\n\016table_metadata\030\001 \002(\013"
590
 
    "2\037.drizzled.message.TableMetadata\0227\n\016fie"
591
 
    "ld_metadata\030\002 \003(\0132\037.drizzled.message.Fie"
592
 
    "ldMetadata\"e\n\nInsertData\022\022\n\nsegment_id\030\001"
593
 
    " \002(\r\022\023\n\013end_segment\030\002 \002(\010\022.\n\006record\030\003 \003("
594
 
    "\0132\036.drizzled.message.InsertRecord\"L\n\014Upd"
595
 
    "ateRecord\022\021\n\tkey_value\030\001 \003(\014\022\023\n\013after_va"
596
 
    "lue\030\002 \003(\014\022\024\n\014before_value\030\003 \003(\014\"\301\001\n\014Upda"
597
 
    "teHeader\0227\n\016table_metadata\030\001 \002(\0132\037.drizz"
598
 
    "led.message.TableMetadata\022;\n\022key_field_m"
599
 
    "etadata\030\002 \003(\0132\037.drizzled.message.FieldMe"
600
 
    "tadata\022;\n\022set_field_metadata\030\003 \003(\0132\037.dri"
601
 
    "zzled.message.FieldMetadata\"e\n\nUpdateDat"
602
 
    "a\022\022\n\nsegment_id\030\001 \002(\r\022\023\n\013end_segment\030\002 \002"
603
 
    "(\010\022.\n\006record\030\003 \003(\0132\036.drizzled.message.Up"
604
 
    "dateRecord\"!\n\014DeleteRecord\022\021\n\tkey_value\030"
605
 
    "\001 \003(\014\"\204\001\n\014DeleteHeader\0227\n\016table_metadata"
606
 
    "\030\001 \002(\0132\037.drizzled.message.TableMetadata\022"
607
 
    ";\n\022key_field_metadata\030\002 \003(\0132\037.drizzled.m"
608
 
    "essage.FieldMetadata\"e\n\nDeleteData\022\022\n\nse"
609
 
    "gment_id\030\001 \002(\r\022\023\n\013end_segment\030\002 \002(\010\022.\n\006r"
610
 
    "ecord\030\003 \003(\0132\036.drizzled.message.DeleteRec"
611
 
    "ord\"Q\n\026TruncateTableStatement\0227\n\016table_m"
612
 
    "etadata\030\001 \002(\0132\037.drizzled.message.TableMe"
613
 
    "tadata\"A\n\025CreateSchemaStatement\022(\n\006schem"
614
 
    "a\030\001 \002(\0132\030.drizzled.message.Schema\"i\n\024Alt"
615
 
    "erSchemaStatement\022(\n\006before\030\001 \002(\0132\030.driz"
616
 
    "zled.message.Schema\022\'\n\005after\030\002 \002(\0132\030.dri"
617
 
    "zzled.message.Schema\"*\n\023DropSchemaStatem"
618
 
    "ent\022\023\n\013schema_name\030\001 \002(\t\">\n\024CreateTableS"
619
 
    "tatement\022&\n\005table\030\001 \002(\0132\027.drizzled.messa"
620
 
    "ge.Table\"f\n\023AlterTableStatement\022\'\n\006befor"
621
 
    "e\030\001 \002(\0132\027.drizzled.message.Table\022&\n\005afte"
622
 
    "r\030\002 \002(\0132\027.drizzled.message.Table\"g\n\022Drop"
623
 
    "TableStatement\0227\n\016table_metadata\030\001 \002(\0132\037"
624
 
    ".drizzled.message.TableMetadata\022\030\n\020if_ex"
625
 
    "ists_clause\030\002 \001(\010\"j\n\024SetVariableStatemen"
626
 
    "t\022:\n\021variable_metadata\030\001 \002(\0132\037.drizzled."
627
 
    "message.FieldMetadata\022\026\n\016variable_value\030"
628
 
    "\002 \002(\014\"\313\t\n\tStatement\022.\n\004type\030\001 \002(\0162 .driz"
629
 
    "zled.message.Statement.Type\022\027\n\017start_tim"
630
 
    "estamp\030\002 \002(\004\022\025\n\rend_timestamp\030\003 \002(\004\022\013\n\003s"
631
 
    "ql\030\004 \001(\t\0225\n\rinsert_header\030\005 \001(\0132\036.drizzl"
632
 
    "ed.message.InsertHeader\0221\n\013insert_data\030\006"
633
 
    " \001(\0132\034.drizzled.message.InsertData\0225\n\rup"
634
 
    "date_header\030\007 \001(\0132\036.drizzled.message.Upd"
635
 
    "ateHeader\0221\n\013update_data\030\010 \001(\0132\034.drizzle"
636
 
    "d.message.UpdateData\0225\n\rdelete_header\030\t "
637
 
    "\001(\0132\036.drizzled.message.DeleteHeader\0221\n\013d"
638
 
    "elete_data\030\n \001(\0132\034.drizzled.message.Dele"
639
 
    "teData\022J\n\030truncate_table_statement\030\013 \001(\013"
640
 
    "2(.drizzled.message.TruncateTableStateme"
641
 
    "nt\022H\n\027create_schema_statement\030\014 \001(\0132\'.dr"
642
 
    "izzled.message.CreateSchemaStatement\022D\n\025"
643
 
    "drop_schema_statement\030\r \001(\0132%.drizzled.m"
644
 
    "essage.DropSchemaStatement\022F\n\026alter_sche"
645
 
    "ma_statement\030\016 \001(\0132&.drizzled.message.Al"
646
 
    "terSchemaStatement\022F\n\026create_table_state"
647
 
    "ment\030\017 \001(\0132&.drizzled.message.CreateTabl"
648
 
    "eStatement\022D\n\025alter_table_statement\030\020 \001("
649
 
    "\0132%.drizzled.message.AlterTableStatement"
650
 
    "\022B\n\024drop_table_statement\030\021 \001(\0132$.drizzle"
651
 
    "d.message.DropTableStatement\022F\n\026set_vari"
652
 
    "able_statement\030\022 \001(\0132&.drizzled.message."
653
 
    "SetVariableStatement\"\324\001\n\004Type\022\014\n\010ROLLBAC"
654
 
    "K\020\000\022\n\n\006INSERT\020\001\022\n\n\006DELETE\020\002\022\n\n\006UPDATE\020\003\022"
655
 
    "\022\n\016TRUNCATE_TABLE\020\004\022\021\n\rCREATE_SCHEMA\020\005\022\020"
656
 
    "\n\014ALTER_SCHEMA\020\006\022\017\n\013DROP_SCHEMA\020\007\022\020\n\014CRE"
657
 
    "ATE_TABLE\020\010\022\017\n\013ALTER_TABLE\020\t\022\016\n\nDROP_TAB"
658
 
    "LE\020\n\022\020\n\014SET_VARIABLE\020b\022\013\n\007RAW_SQL\020c\"\200\001\n\013"
659
 
    "Transaction\022A\n\023transaction_context\030\001 \002(\013"
660
 
    "2$.drizzled.message.TransactionContext\022."
661
 
    "\n\tstatement\030\002 \003(\0132\033.drizzled.message.Sta"
662
 
    "tementB\002H\001", 3290);
663
 
  ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
664
 
    "transaction.proto", &protobuf_RegisterTypes);
665
 
  FieldMetadata::default_instance_ = new FieldMetadata();
666
 
  TableMetadata::default_instance_ = new TableMetadata();
667
 
  TransactionContext::default_instance_ = new TransactionContext();
668
 
  InsertRecord::default_instance_ = new InsertRecord();
669
 
  InsertHeader::default_instance_ = new InsertHeader();
670
 
  InsertData::default_instance_ = new InsertData();
671
 
  UpdateRecord::default_instance_ = new UpdateRecord();
672
 
  UpdateHeader::default_instance_ = new UpdateHeader();
673
 
  UpdateData::default_instance_ = new UpdateData();
674
 
  DeleteRecord::default_instance_ = new DeleteRecord();
675
 
  DeleteHeader::default_instance_ = new DeleteHeader();
676
 
  DeleteData::default_instance_ = new DeleteData();
677
 
  TruncateTableStatement::default_instance_ = new TruncateTableStatement();
678
 
  CreateSchemaStatement::default_instance_ = new CreateSchemaStatement();
679
 
  AlterSchemaStatement::default_instance_ = new AlterSchemaStatement();
680
 
  DropSchemaStatement::default_instance_ = new DropSchemaStatement();
681
 
  CreateTableStatement::default_instance_ = new CreateTableStatement();
682
 
  AlterTableStatement::default_instance_ = new AlterTableStatement();
683
 
  DropTableStatement::default_instance_ = new DropTableStatement();
684
 
  SetVariableStatement::default_instance_ = new SetVariableStatement();
685
 
  Statement::default_instance_ = new Statement();
686
 
  Transaction::default_instance_ = new Transaction();
687
 
  FieldMetadata::default_instance_->InitAsDefaultInstance();
688
 
  TableMetadata::default_instance_->InitAsDefaultInstance();
689
 
  TransactionContext::default_instance_->InitAsDefaultInstance();
690
 
  InsertRecord::default_instance_->InitAsDefaultInstance();
691
 
  InsertHeader::default_instance_->InitAsDefaultInstance();
692
 
  InsertData::default_instance_->InitAsDefaultInstance();
693
 
  UpdateRecord::default_instance_->InitAsDefaultInstance();
694
 
  UpdateHeader::default_instance_->InitAsDefaultInstance();
695
 
  UpdateData::default_instance_->InitAsDefaultInstance();
696
 
  DeleteRecord::default_instance_->InitAsDefaultInstance();
697
 
  DeleteHeader::default_instance_->InitAsDefaultInstance();
698
 
  DeleteData::default_instance_->InitAsDefaultInstance();
699
 
  TruncateTableStatement::default_instance_->InitAsDefaultInstance();
700
 
  CreateSchemaStatement::default_instance_->InitAsDefaultInstance();
701
 
  AlterSchemaStatement::default_instance_->InitAsDefaultInstance();
702
 
  DropSchemaStatement::default_instance_->InitAsDefaultInstance();
703
 
  CreateTableStatement::default_instance_->InitAsDefaultInstance();
704
 
  AlterTableStatement::default_instance_->InitAsDefaultInstance();
705
 
  DropTableStatement::default_instance_->InitAsDefaultInstance();
706
 
  SetVariableStatement::default_instance_->InitAsDefaultInstance();
707
 
  Statement::default_instance_->InitAsDefaultInstance();
708
 
  Transaction::default_instance_->InitAsDefaultInstance();
709
 
  ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_transaction_2eproto);
710
 
}
711
 
 
712
 
// Force AddDescriptors() to be called at static initialization time.
713
 
struct StaticDescriptorInitializer_transaction_2eproto {
714
 
  StaticDescriptorInitializer_transaction_2eproto() {
715
 
    protobuf_AddDesc_transaction_2eproto();
716
 
  }
717
 
} static_descriptor_initializer_transaction_2eproto_;
718
 
 
719
 
 
720
 
// ===================================================================
721
 
 
722
 
const ::std::string FieldMetadata::_default_name_;
723
 
#ifndef _MSC_VER
724
 
const int FieldMetadata::kTypeFieldNumber;
725
 
const int FieldMetadata::kNameFieldNumber;
726
 
#endif  // !_MSC_VER
727
 
 
728
 
FieldMetadata::FieldMetadata() {
729
 
  SharedCtor();
730
 
}
731
 
 
732
 
void FieldMetadata::InitAsDefaultInstance() {
733
 
}
734
 
 
735
 
FieldMetadata::FieldMetadata(const FieldMetadata& from) {
736
 
  SharedCtor();
737
 
  MergeFrom(from);
738
 
}
739
 
 
740
 
void FieldMetadata::SharedCtor() {
741
 
  _cached_size_ = 0;
742
 
  type_ = 0;
743
 
  name_ = const_cast< ::std::string*>(&_default_name_);
744
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
745
 
}
746
 
 
747
 
FieldMetadata::~FieldMetadata() {
748
 
  SharedDtor();
749
 
}
750
 
 
751
 
void FieldMetadata::SharedDtor() {
752
 
  if (name_ != &_default_name_) {
753
 
    delete name_;
754
 
  }
755
 
  if (this != default_instance_) {
756
 
  }
757
 
}
758
 
 
759
 
const ::google::protobuf::Descriptor* FieldMetadata::descriptor() {
760
 
  protobuf_AssignDescriptorsOnce();
761
 
  return FieldMetadata_descriptor_;
762
 
}
763
 
 
764
 
const FieldMetadata& FieldMetadata::default_instance() {
765
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
766
 
}
767
 
 
768
 
FieldMetadata* FieldMetadata::default_instance_ = NULL;
769
 
 
770
 
FieldMetadata* FieldMetadata::New() const {
771
 
  return new FieldMetadata;
772
 
}
773
 
 
774
 
void FieldMetadata::Clear() {
775
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
776
 
    type_ = 0;
777
 
    if (_has_bit(1)) {
778
 
      if (name_ != &_default_name_) {
779
 
        name_->clear();
780
 
      }
781
 
    }
782
 
  }
783
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
784
 
  mutable_unknown_fields()->Clear();
785
 
}
786
 
 
787
 
bool FieldMetadata::MergePartialFromCodedStream(
788
 
    ::google::protobuf::io::CodedInputStream* input) {
789
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
790
 
  ::google::protobuf::uint32 tag;
791
 
  while ((tag = input->ReadTag()) != 0) {
792
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
793
 
      // required .drizzled.message.Table.Field.FieldType type = 1;
794
 
      case 1: {
795
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
796
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
797
 
          goto handle_uninterpreted;
798
 
        }
799
 
        int value;
800
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadEnum(input, &value));
801
 
        if (::drizzled::message::Table_Field_FieldType_IsValid(value)) {
802
 
          set_type(static_cast< ::drizzled::message::Table_Field_FieldType >(value));
803
 
        } else {
804
 
          mutable_unknown_fields()->AddVarint(1, value);
805
 
        }
806
 
        if (input->ExpectTag(18)) goto parse_name;
807
 
        break;
808
 
      }
809
 
      
810
 
      // required string name = 2;
811
 
      case 2: {
812
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
813
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
814
 
          goto handle_uninterpreted;
815
 
        }
816
 
       parse_name:
817
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadString(
818
 
              input, this->mutable_name()));
819
 
        ::google::protobuf::internal::WireFormat::VerifyUTF8String(
820
 
          this->name().data(), this->name().length(),
821
 
          ::google::protobuf::internal::WireFormat::PARSE);
822
 
        if (input->ExpectAtEnd()) return true;
823
 
        break;
824
 
      }
825
 
      
826
 
      default: {
827
 
      handle_uninterpreted:
828
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
829
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
830
 
          return true;
831
 
        }
832
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
833
 
              input, tag, mutable_unknown_fields()));
834
 
        break;
835
 
      }
836
 
    }
837
 
  }
838
 
  return true;
839
 
#undef DO_
840
 
}
841
 
 
842
 
void FieldMetadata::SerializeWithCachedSizes(
843
 
    ::google::protobuf::io::CodedOutputStream* output) const {
844
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
845
 
  if (raw_buffer != NULL) {
846
 
    FieldMetadata::SerializeWithCachedSizesToArray(raw_buffer);
847
 
    return;
848
 
  }
849
 
  
850
 
  // required .drizzled.message.Table.Field.FieldType type = 1;
851
 
  if (_has_bit(0)) {
852
 
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
853
 
      1, this->type(), output);
854
 
  }
855
 
  
856
 
  // required string name = 2;
857
 
  if (_has_bit(1)) {
858
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
859
 
      this->name().data(), this->name().length(),
860
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
861
 
    ::google::protobuf::internal::WireFormatLite::WriteString(
862
 
      2, this->name(), output);
863
 
  }
864
 
  
865
 
  if (!unknown_fields().empty()) {
866
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
867
 
        unknown_fields(), output);
868
 
  }
869
 
}
870
 
 
871
 
::google::protobuf::uint8* FieldMetadata::SerializeWithCachedSizesToArray(
872
 
    ::google::protobuf::uint8* target) const {
873
 
  // required .drizzled.message.Table.Field.FieldType type = 1;
874
 
  if (_has_bit(0)) {
875
 
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
876
 
      1, this->type(), target);
877
 
  }
878
 
  
879
 
  // required string name = 2;
880
 
  if (_has_bit(1)) {
881
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
882
 
      this->name().data(), this->name().length(),
883
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
884
 
    target =
885
 
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
886
 
        2, this->name(), target);
887
 
  }
888
 
  
889
 
  if (!unknown_fields().empty()) {
890
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
891
 
        unknown_fields(), target);
892
 
  }
893
 
  return target;
894
 
}
895
 
 
896
 
int FieldMetadata::ByteSize() const {
897
 
  int total_size = 0;
898
 
  
899
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
900
 
    // required .drizzled.message.Table.Field.FieldType type = 1;
901
 
    if (has_type()) {
902
 
      total_size += 1 +
903
 
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
904
 
    }
905
 
    
906
 
    // required string name = 2;
907
 
    if (has_name()) {
908
 
      total_size += 1 +
909
 
        ::google::protobuf::internal::WireFormatLite::StringSize(
910
 
          this->name());
911
 
    }
912
 
    
913
 
  }
914
 
  if (!unknown_fields().empty()) {
915
 
    total_size +=
916
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
917
 
        unknown_fields());
918
 
  }
919
 
  _cached_size_ = total_size;
920
 
  return total_size;
921
 
}
922
 
 
923
 
void FieldMetadata::MergeFrom(const ::google::protobuf::Message& from) {
924
 
  GOOGLE_CHECK_NE(&from, this);
925
 
  const FieldMetadata* source =
926
 
    ::google::protobuf::internal::dynamic_cast_if_available<const FieldMetadata*>(
927
 
      &from);
928
 
  if (source == NULL) {
929
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
930
 
  } else {
931
 
    MergeFrom(*source);
932
 
  }
933
 
}
934
 
 
935
 
void FieldMetadata::MergeFrom(const FieldMetadata& from) {
936
 
  GOOGLE_CHECK_NE(&from, this);
937
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
938
 
    if (from._has_bit(0)) {
939
 
      set_type(from.type());
940
 
    }
941
 
    if (from._has_bit(1)) {
942
 
      set_name(from.name());
943
 
    }
944
 
  }
945
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
946
 
}
947
 
 
948
 
void FieldMetadata::CopyFrom(const ::google::protobuf::Message& from) {
949
 
  if (&from == this) return;
950
 
  Clear();
951
 
  MergeFrom(from);
952
 
}
953
 
 
954
 
void FieldMetadata::CopyFrom(const FieldMetadata& from) {
955
 
  if (&from == this) return;
956
 
  Clear();
957
 
  MergeFrom(from);
958
 
}
959
 
 
960
 
bool FieldMetadata::IsInitialized() const {
961
 
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
962
 
  
963
 
  return true;
964
 
}
965
 
 
966
 
void FieldMetadata::Swap(FieldMetadata* other) {
967
 
  if (other != this) {
968
 
    std::swap(type_, other->type_);
969
 
    std::swap(name_, other->name_);
970
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
971
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
972
 
    std::swap(_cached_size_, other->_cached_size_);
973
 
  }
974
 
}
975
 
 
976
 
::google::protobuf::Metadata FieldMetadata::GetMetadata() const {
977
 
  protobuf_AssignDescriptorsOnce();
978
 
  ::google::protobuf::Metadata metadata;
979
 
  metadata.descriptor = FieldMetadata_descriptor_;
980
 
  metadata.reflection = FieldMetadata_reflection_;
981
 
  return metadata;
982
 
}
983
 
 
984
 
 
985
 
// ===================================================================
986
 
 
987
 
const ::std::string TableMetadata::_default_schema_name_;
988
 
const ::std::string TableMetadata::_default_table_name_;
989
 
#ifndef _MSC_VER
990
 
const int TableMetadata::kSchemaNameFieldNumber;
991
 
const int TableMetadata::kTableNameFieldNumber;
992
 
#endif  // !_MSC_VER
993
 
 
994
 
TableMetadata::TableMetadata() {
995
 
  SharedCtor();
996
 
}
997
 
 
998
 
void TableMetadata::InitAsDefaultInstance() {
999
 
}
1000
 
 
1001
 
TableMetadata::TableMetadata(const TableMetadata& from) {
1002
 
  SharedCtor();
1003
 
  MergeFrom(from);
1004
 
}
1005
 
 
1006
 
void TableMetadata::SharedCtor() {
1007
 
  _cached_size_ = 0;
1008
 
  schema_name_ = const_cast< ::std::string*>(&_default_schema_name_);
1009
 
  table_name_ = const_cast< ::std::string*>(&_default_table_name_);
1010
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
1011
 
}
1012
 
 
1013
 
TableMetadata::~TableMetadata() {
1014
 
  SharedDtor();
1015
 
}
1016
 
 
1017
 
void TableMetadata::SharedDtor() {
1018
 
  if (schema_name_ != &_default_schema_name_) {
1019
 
    delete schema_name_;
1020
 
  }
1021
 
  if (table_name_ != &_default_table_name_) {
1022
 
    delete table_name_;
1023
 
  }
1024
 
  if (this != default_instance_) {
1025
 
  }
1026
 
}
1027
 
 
1028
 
const ::google::protobuf::Descriptor* TableMetadata::descriptor() {
1029
 
  protobuf_AssignDescriptorsOnce();
1030
 
  return TableMetadata_descriptor_;
1031
 
}
1032
 
 
1033
 
const TableMetadata& TableMetadata::default_instance() {
1034
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
1035
 
}
1036
 
 
1037
 
TableMetadata* TableMetadata::default_instance_ = NULL;
1038
 
 
1039
 
TableMetadata* TableMetadata::New() const {
1040
 
  return new TableMetadata;
1041
 
}
1042
 
 
1043
 
void TableMetadata::Clear() {
1044
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1045
 
    if (_has_bit(0)) {
1046
 
      if (schema_name_ != &_default_schema_name_) {
1047
 
        schema_name_->clear();
1048
 
      }
1049
 
    }
1050
 
    if (_has_bit(1)) {
1051
 
      if (table_name_ != &_default_table_name_) {
1052
 
        table_name_->clear();
1053
 
      }
1054
 
    }
1055
 
  }
1056
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
1057
 
  mutable_unknown_fields()->Clear();
1058
 
}
1059
 
 
1060
 
bool TableMetadata::MergePartialFromCodedStream(
1061
 
    ::google::protobuf::io::CodedInputStream* input) {
1062
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
1063
 
  ::google::protobuf::uint32 tag;
1064
 
  while ((tag = input->ReadTag()) != 0) {
1065
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1066
 
      // required string schema_name = 1;
1067
 
      case 1: {
1068
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
1069
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1070
 
          goto handle_uninterpreted;
1071
 
        }
1072
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1073
 
              input, this->mutable_schema_name()));
1074
 
        ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1075
 
          this->schema_name().data(), this->schema_name().length(),
1076
 
          ::google::protobuf::internal::WireFormat::PARSE);
1077
 
        if (input->ExpectTag(18)) goto parse_table_name;
1078
 
        break;
1079
 
      }
1080
 
      
1081
 
      // required string table_name = 2;
1082
 
      case 2: {
1083
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
1084
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1085
 
          goto handle_uninterpreted;
1086
 
        }
1087
 
       parse_table_name:
1088
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadString(
1089
 
              input, this->mutable_table_name()));
1090
 
        ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1091
 
          this->table_name().data(), this->table_name().length(),
1092
 
          ::google::protobuf::internal::WireFormat::PARSE);
1093
 
        if (input->ExpectAtEnd()) return true;
1094
 
        break;
1095
 
      }
1096
 
      
1097
 
      default: {
1098
 
      handle_uninterpreted:
1099
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1100
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
1101
 
          return true;
1102
 
        }
1103
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
1104
 
              input, tag, mutable_unknown_fields()));
1105
 
        break;
1106
 
      }
1107
 
    }
1108
 
  }
1109
 
  return true;
1110
 
#undef DO_
1111
 
}
1112
 
 
1113
 
void TableMetadata::SerializeWithCachedSizes(
1114
 
    ::google::protobuf::io::CodedOutputStream* output) const {
1115
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
1116
 
  if (raw_buffer != NULL) {
1117
 
    TableMetadata::SerializeWithCachedSizesToArray(raw_buffer);
1118
 
    return;
1119
 
  }
1120
 
  
1121
 
  // required string schema_name = 1;
1122
 
  if (_has_bit(0)) {
1123
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1124
 
      this->schema_name().data(), this->schema_name().length(),
1125
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
1126
 
    ::google::protobuf::internal::WireFormatLite::WriteString(
1127
 
      1, this->schema_name(), output);
1128
 
  }
1129
 
  
1130
 
  // required string table_name = 2;
1131
 
  if (_has_bit(1)) {
1132
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1133
 
      this->table_name().data(), this->table_name().length(),
1134
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
1135
 
    ::google::protobuf::internal::WireFormatLite::WriteString(
1136
 
      2, this->table_name(), output);
1137
 
  }
1138
 
  
1139
 
  if (!unknown_fields().empty()) {
1140
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1141
 
        unknown_fields(), output);
1142
 
  }
1143
 
}
1144
 
 
1145
 
::google::protobuf::uint8* TableMetadata::SerializeWithCachedSizesToArray(
1146
 
    ::google::protobuf::uint8* target) const {
1147
 
  // required string schema_name = 1;
1148
 
  if (_has_bit(0)) {
1149
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1150
 
      this->schema_name().data(), this->schema_name().length(),
1151
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
1152
 
    target =
1153
 
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1154
 
        1, this->schema_name(), target);
1155
 
  }
1156
 
  
1157
 
  // required string table_name = 2;
1158
 
  if (_has_bit(1)) {
1159
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
1160
 
      this->table_name().data(), this->table_name().length(),
1161
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
1162
 
    target =
1163
 
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
1164
 
        2, this->table_name(), target);
1165
 
  }
1166
 
  
1167
 
  if (!unknown_fields().empty()) {
1168
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1169
 
        unknown_fields(), target);
1170
 
  }
1171
 
  return target;
1172
 
}
1173
 
 
1174
 
int TableMetadata::ByteSize() const {
1175
 
  int total_size = 0;
1176
 
  
1177
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1178
 
    // required string schema_name = 1;
1179
 
    if (has_schema_name()) {
1180
 
      total_size += 1 +
1181
 
        ::google::protobuf::internal::WireFormatLite::StringSize(
1182
 
          this->schema_name());
1183
 
    }
1184
 
    
1185
 
    // required string table_name = 2;
1186
 
    if (has_table_name()) {
1187
 
      total_size += 1 +
1188
 
        ::google::protobuf::internal::WireFormatLite::StringSize(
1189
 
          this->table_name());
1190
 
    }
1191
 
    
1192
 
  }
1193
 
  if (!unknown_fields().empty()) {
1194
 
    total_size +=
1195
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1196
 
        unknown_fields());
1197
 
  }
1198
 
  _cached_size_ = total_size;
1199
 
  return total_size;
1200
 
}
1201
 
 
1202
 
void TableMetadata::MergeFrom(const ::google::protobuf::Message& from) {
1203
 
  GOOGLE_CHECK_NE(&from, this);
1204
 
  const TableMetadata* source =
1205
 
    ::google::protobuf::internal::dynamic_cast_if_available<const TableMetadata*>(
1206
 
      &from);
1207
 
  if (source == NULL) {
1208
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1209
 
  } else {
1210
 
    MergeFrom(*source);
1211
 
  }
1212
 
}
1213
 
 
1214
 
void TableMetadata::MergeFrom(const TableMetadata& from) {
1215
 
  GOOGLE_CHECK_NE(&from, this);
1216
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1217
 
    if (from._has_bit(0)) {
1218
 
      set_schema_name(from.schema_name());
1219
 
    }
1220
 
    if (from._has_bit(1)) {
1221
 
      set_table_name(from.table_name());
1222
 
    }
1223
 
  }
1224
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1225
 
}
1226
 
 
1227
 
void TableMetadata::CopyFrom(const ::google::protobuf::Message& from) {
1228
 
  if (&from == this) return;
1229
 
  Clear();
1230
 
  MergeFrom(from);
1231
 
}
1232
 
 
1233
 
void TableMetadata::CopyFrom(const TableMetadata& from) {
1234
 
  if (&from == this) return;
1235
 
  Clear();
1236
 
  MergeFrom(from);
1237
 
}
1238
 
 
1239
 
bool TableMetadata::IsInitialized() const {
1240
 
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
1241
 
  
1242
 
  return true;
1243
 
}
1244
 
 
1245
 
void TableMetadata::Swap(TableMetadata* other) {
1246
 
  if (other != this) {
1247
 
    std::swap(schema_name_, other->schema_name_);
1248
 
    std::swap(table_name_, other->table_name_);
1249
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
1250
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
1251
 
    std::swap(_cached_size_, other->_cached_size_);
1252
 
  }
1253
 
}
1254
 
 
1255
 
::google::protobuf::Metadata TableMetadata::GetMetadata() const {
1256
 
  protobuf_AssignDescriptorsOnce();
1257
 
  ::google::protobuf::Metadata metadata;
1258
 
  metadata.descriptor = TableMetadata_descriptor_;
1259
 
  metadata.reflection = TableMetadata_reflection_;
1260
 
  return metadata;
1261
 
}
1262
 
 
1263
 
 
1264
 
// ===================================================================
1265
 
 
1266
 
#ifndef _MSC_VER
1267
 
const int TransactionContext::kServerIdFieldNumber;
1268
 
const int TransactionContext::kTransactionIdFieldNumber;
1269
 
const int TransactionContext::kStartTimestampFieldNumber;
1270
 
const int TransactionContext::kEndTimestampFieldNumber;
1271
 
#endif  // !_MSC_VER
1272
 
 
1273
 
TransactionContext::TransactionContext() {
1274
 
  SharedCtor();
1275
 
}
1276
 
 
1277
 
void TransactionContext::InitAsDefaultInstance() {
1278
 
}
1279
 
 
1280
 
TransactionContext::TransactionContext(const TransactionContext& from) {
1281
 
  SharedCtor();
1282
 
  MergeFrom(from);
1283
 
}
1284
 
 
1285
 
void TransactionContext::SharedCtor() {
1286
 
  _cached_size_ = 0;
1287
 
  server_id_ = 0u;
1288
 
  transaction_id_ = GOOGLE_ULONGLONG(0);
1289
 
  start_timestamp_ = GOOGLE_ULONGLONG(0);
1290
 
  end_timestamp_ = GOOGLE_ULONGLONG(0);
1291
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
1292
 
}
1293
 
 
1294
 
TransactionContext::~TransactionContext() {
1295
 
  SharedDtor();
1296
 
}
1297
 
 
1298
 
void TransactionContext::SharedDtor() {
1299
 
  if (this != default_instance_) {
1300
 
  }
1301
 
}
1302
 
 
1303
 
const ::google::protobuf::Descriptor* TransactionContext::descriptor() {
1304
 
  protobuf_AssignDescriptorsOnce();
1305
 
  return TransactionContext_descriptor_;
1306
 
}
1307
 
 
1308
 
const TransactionContext& TransactionContext::default_instance() {
1309
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
1310
 
}
1311
 
 
1312
 
TransactionContext* TransactionContext::default_instance_ = NULL;
1313
 
 
1314
 
TransactionContext* TransactionContext::New() const {
1315
 
  return new TransactionContext;
1316
 
}
1317
 
 
1318
 
void TransactionContext::Clear() {
1319
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1320
 
    server_id_ = 0u;
1321
 
    transaction_id_ = GOOGLE_ULONGLONG(0);
1322
 
    start_timestamp_ = GOOGLE_ULONGLONG(0);
1323
 
    end_timestamp_ = GOOGLE_ULONGLONG(0);
1324
 
  }
1325
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
1326
 
  mutable_unknown_fields()->Clear();
1327
 
}
1328
 
 
1329
 
bool TransactionContext::MergePartialFromCodedStream(
1330
 
    ::google::protobuf::io::CodedInputStream* input) {
1331
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
1332
 
  ::google::protobuf::uint32 tag;
1333
 
  while ((tag = input->ReadTag()) != 0) {
1334
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1335
 
      // required uint32 server_id = 1;
1336
 
      case 1: {
1337
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
1338
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1339
 
          goto handle_uninterpreted;
1340
 
        }
1341
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadUInt32(
1342
 
              input, &server_id_));
1343
 
        _set_bit(0);
1344
 
        if (input->ExpectTag(16)) goto parse_transaction_id;
1345
 
        break;
1346
 
      }
1347
 
      
1348
 
      // required uint64 transaction_id = 2;
1349
 
      case 2: {
1350
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
1351
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1352
 
          goto handle_uninterpreted;
1353
 
        }
1354
 
       parse_transaction_id:
1355
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadUInt64(
1356
 
              input, &transaction_id_));
1357
 
        _set_bit(1);
1358
 
        if (input->ExpectTag(24)) goto parse_start_timestamp;
1359
 
        break;
1360
 
      }
1361
 
      
1362
 
      // required uint64 start_timestamp = 3;
1363
 
      case 3: {
1364
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
1365
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1366
 
          goto handle_uninterpreted;
1367
 
        }
1368
 
       parse_start_timestamp:
1369
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadUInt64(
1370
 
              input, &start_timestamp_));
1371
 
        _set_bit(2);
1372
 
        if (input->ExpectTag(32)) goto parse_end_timestamp;
1373
 
        break;
1374
 
      }
1375
 
      
1376
 
      // required uint64 end_timestamp = 4;
1377
 
      case 4: {
1378
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
1379
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
1380
 
          goto handle_uninterpreted;
1381
 
        }
1382
 
       parse_end_timestamp:
1383
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadUInt64(
1384
 
              input, &end_timestamp_));
1385
 
        _set_bit(3);
1386
 
        if (input->ExpectAtEnd()) return true;
1387
 
        break;
1388
 
      }
1389
 
      
1390
 
      default: {
1391
 
      handle_uninterpreted:
1392
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1393
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
1394
 
          return true;
1395
 
        }
1396
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
1397
 
              input, tag, mutable_unknown_fields()));
1398
 
        break;
1399
 
      }
1400
 
    }
1401
 
  }
1402
 
  return true;
1403
 
#undef DO_
1404
 
}
1405
 
 
1406
 
void TransactionContext::SerializeWithCachedSizes(
1407
 
    ::google::protobuf::io::CodedOutputStream* output) const {
1408
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
1409
 
  if (raw_buffer != NULL) {
1410
 
    TransactionContext::SerializeWithCachedSizesToArray(raw_buffer);
1411
 
    return;
1412
 
  }
1413
 
  
1414
 
  // required uint32 server_id = 1;
1415
 
  if (_has_bit(0)) {
1416
 
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->server_id(), output);
1417
 
  }
1418
 
  
1419
 
  // required uint64 transaction_id = 2;
1420
 
  if (_has_bit(1)) {
1421
 
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->transaction_id(), output);
1422
 
  }
1423
 
  
1424
 
  // required uint64 start_timestamp = 3;
1425
 
  if (_has_bit(2)) {
1426
 
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->start_timestamp(), output);
1427
 
  }
1428
 
  
1429
 
  // required uint64 end_timestamp = 4;
1430
 
  if (_has_bit(3)) {
1431
 
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->end_timestamp(), output);
1432
 
  }
1433
 
  
1434
 
  if (!unknown_fields().empty()) {
1435
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1436
 
        unknown_fields(), output);
1437
 
  }
1438
 
}
1439
 
 
1440
 
::google::protobuf::uint8* TransactionContext::SerializeWithCachedSizesToArray(
1441
 
    ::google::protobuf::uint8* target) const {
1442
 
  // required uint32 server_id = 1;
1443
 
  if (_has_bit(0)) {
1444
 
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->server_id(), target);
1445
 
  }
1446
 
  
1447
 
  // required uint64 transaction_id = 2;
1448
 
  if (_has_bit(1)) {
1449
 
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->transaction_id(), target);
1450
 
  }
1451
 
  
1452
 
  // required uint64 start_timestamp = 3;
1453
 
  if (_has_bit(2)) {
1454
 
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->start_timestamp(), target);
1455
 
  }
1456
 
  
1457
 
  // required uint64 end_timestamp = 4;
1458
 
  if (_has_bit(3)) {
1459
 
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->end_timestamp(), target);
1460
 
  }
1461
 
  
1462
 
  if (!unknown_fields().empty()) {
1463
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1464
 
        unknown_fields(), target);
1465
 
  }
1466
 
  return target;
1467
 
}
1468
 
 
1469
 
int TransactionContext::ByteSize() const {
1470
 
  int total_size = 0;
1471
 
  
1472
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1473
 
    // required uint32 server_id = 1;
1474
 
    if (has_server_id()) {
1475
 
      total_size += 1 +
1476
 
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
1477
 
          this->server_id());
1478
 
    }
1479
 
    
1480
 
    // required uint64 transaction_id = 2;
1481
 
    if (has_transaction_id()) {
1482
 
      total_size += 1 +
1483
 
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
1484
 
          this->transaction_id());
1485
 
    }
1486
 
    
1487
 
    // required uint64 start_timestamp = 3;
1488
 
    if (has_start_timestamp()) {
1489
 
      total_size += 1 +
1490
 
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
1491
 
          this->start_timestamp());
1492
 
    }
1493
 
    
1494
 
    // required uint64 end_timestamp = 4;
1495
 
    if (has_end_timestamp()) {
1496
 
      total_size += 1 +
1497
 
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
1498
 
          this->end_timestamp());
1499
 
    }
1500
 
    
1501
 
  }
1502
 
  if (!unknown_fields().empty()) {
1503
 
    total_size +=
1504
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1505
 
        unknown_fields());
1506
 
  }
1507
 
  _cached_size_ = total_size;
1508
 
  return total_size;
1509
 
}
1510
 
 
1511
 
void TransactionContext::MergeFrom(const ::google::protobuf::Message& from) {
1512
 
  GOOGLE_CHECK_NE(&from, this);
1513
 
  const TransactionContext* source =
1514
 
    ::google::protobuf::internal::dynamic_cast_if_available<const TransactionContext*>(
1515
 
      &from);
1516
 
  if (source == NULL) {
1517
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1518
 
  } else {
1519
 
    MergeFrom(*source);
1520
 
  }
1521
 
}
1522
 
 
1523
 
void TransactionContext::MergeFrom(const TransactionContext& from) {
1524
 
  GOOGLE_CHECK_NE(&from, this);
1525
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1526
 
    if (from._has_bit(0)) {
1527
 
      set_server_id(from.server_id());
1528
 
    }
1529
 
    if (from._has_bit(1)) {
1530
 
      set_transaction_id(from.transaction_id());
1531
 
    }
1532
 
    if (from._has_bit(2)) {
1533
 
      set_start_timestamp(from.start_timestamp());
1534
 
    }
1535
 
    if (from._has_bit(3)) {
1536
 
      set_end_timestamp(from.end_timestamp());
1537
 
    }
1538
 
  }
1539
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1540
 
}
1541
 
 
1542
 
void TransactionContext::CopyFrom(const ::google::protobuf::Message& from) {
1543
 
  if (&from == this) return;
1544
 
  Clear();
1545
 
  MergeFrom(from);
1546
 
}
1547
 
 
1548
 
void TransactionContext::CopyFrom(const TransactionContext& from) {
1549
 
  if (&from == this) return;
1550
 
  Clear();
1551
 
  MergeFrom(from);
1552
 
}
1553
 
 
1554
 
bool TransactionContext::IsInitialized() const {
1555
 
  if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;
1556
 
  
1557
 
  return true;
1558
 
}
1559
 
 
1560
 
void TransactionContext::Swap(TransactionContext* other) {
1561
 
  if (other != this) {
1562
 
    std::swap(server_id_, other->server_id_);
1563
 
    std::swap(transaction_id_, other->transaction_id_);
1564
 
    std::swap(start_timestamp_, other->start_timestamp_);
1565
 
    std::swap(end_timestamp_, other->end_timestamp_);
1566
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
1567
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
1568
 
    std::swap(_cached_size_, other->_cached_size_);
1569
 
  }
1570
 
}
1571
 
 
1572
 
::google::protobuf::Metadata TransactionContext::GetMetadata() const {
1573
 
  protobuf_AssignDescriptorsOnce();
1574
 
  ::google::protobuf::Metadata metadata;
1575
 
  metadata.descriptor = TransactionContext_descriptor_;
1576
 
  metadata.reflection = TransactionContext_reflection_;
1577
 
  return metadata;
1578
 
}
1579
 
 
1580
 
 
1581
 
// ===================================================================
1582
 
 
1583
 
#ifndef _MSC_VER
1584
 
const int InsertRecord::kInsertValueFieldNumber;
1585
 
#endif  // !_MSC_VER
1586
 
 
1587
 
InsertRecord::InsertRecord() {
1588
 
  SharedCtor();
1589
 
}
1590
 
 
1591
 
void InsertRecord::InitAsDefaultInstance() {
1592
 
}
1593
 
 
1594
 
InsertRecord::InsertRecord(const InsertRecord& from) {
1595
 
  SharedCtor();
1596
 
  MergeFrom(from);
1597
 
}
1598
 
 
1599
 
void InsertRecord::SharedCtor() {
1600
 
  _cached_size_ = 0;
1601
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
1602
 
}
1603
 
 
1604
 
InsertRecord::~InsertRecord() {
1605
 
  SharedDtor();
1606
 
}
1607
 
 
1608
 
void InsertRecord::SharedDtor() {
1609
 
  if (this != default_instance_) {
1610
 
  }
1611
 
}
1612
 
 
1613
 
const ::google::protobuf::Descriptor* InsertRecord::descriptor() {
1614
 
  protobuf_AssignDescriptorsOnce();
1615
 
  return InsertRecord_descriptor_;
1616
 
}
1617
 
 
1618
 
const InsertRecord& InsertRecord::default_instance() {
1619
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
1620
 
}
1621
 
 
1622
 
InsertRecord* InsertRecord::default_instance_ = NULL;
1623
 
 
1624
 
InsertRecord* InsertRecord::New() const {
1625
 
  return new InsertRecord;
1626
 
}
1627
 
 
1628
 
void InsertRecord::Clear() {
1629
 
  insert_value_.Clear();
1630
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
1631
 
  mutable_unknown_fields()->Clear();
1632
 
}
1633
 
 
1634
 
bool InsertRecord::MergePartialFromCodedStream(
1635
 
    ::google::protobuf::io::CodedInputStream* input) {
1636
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
1637
 
  ::google::protobuf::uint32 tag;
1638
 
  while ((tag = input->ReadTag()) != 0) {
1639
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1640
 
      // repeated bytes insert_value = 1;
1641
 
      case 1: {
1642
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
1643
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1644
 
          goto handle_uninterpreted;
1645
 
        }
1646
 
       parse_insert_value:
1647
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
1648
 
              input, this->add_insert_value()));
1649
 
        if (input->ExpectTag(10)) goto parse_insert_value;
1650
 
        if (input->ExpectAtEnd()) return true;
1651
 
        break;
1652
 
      }
1653
 
      
1654
 
      default: {
1655
 
      handle_uninterpreted:
1656
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1657
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
1658
 
          return true;
1659
 
        }
1660
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
1661
 
              input, tag, mutable_unknown_fields()));
1662
 
        break;
1663
 
      }
1664
 
    }
1665
 
  }
1666
 
  return true;
1667
 
#undef DO_
1668
 
}
1669
 
 
1670
 
void InsertRecord::SerializeWithCachedSizes(
1671
 
    ::google::protobuf::io::CodedOutputStream* output) const {
1672
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
1673
 
  if (raw_buffer != NULL) {
1674
 
    InsertRecord::SerializeWithCachedSizesToArray(raw_buffer);
1675
 
    return;
1676
 
  }
1677
 
  
1678
 
  // repeated bytes insert_value = 1;
1679
 
  for (int i = 0; i < this->insert_value_size(); i++) {
1680
 
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
1681
 
      1, this->insert_value(i), output);
1682
 
  }
1683
 
  
1684
 
  if (!unknown_fields().empty()) {
1685
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1686
 
        unknown_fields(), output);
1687
 
  }
1688
 
}
1689
 
 
1690
 
::google::protobuf::uint8* InsertRecord::SerializeWithCachedSizesToArray(
1691
 
    ::google::protobuf::uint8* target) const {
1692
 
  // repeated bytes insert_value = 1;
1693
 
  for (int i = 0; i < this->insert_value_size(); i++) {
1694
 
    target = ::google::protobuf::internal::WireFormatLite::
1695
 
      WriteBytesToArray(1, this->insert_value(i), target);
1696
 
  }
1697
 
  
1698
 
  if (!unknown_fields().empty()) {
1699
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1700
 
        unknown_fields(), target);
1701
 
  }
1702
 
  return target;
1703
 
}
1704
 
 
1705
 
int InsertRecord::ByteSize() const {
1706
 
  int total_size = 0;
1707
 
  
1708
 
  // repeated bytes insert_value = 1;
1709
 
  total_size += 1 * this->insert_value_size();
1710
 
  for (int i = 0; i < this->insert_value_size(); i++) {
1711
 
    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
1712
 
      this->insert_value(i));
1713
 
  }
1714
 
  
1715
 
  if (!unknown_fields().empty()) {
1716
 
    total_size +=
1717
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1718
 
        unknown_fields());
1719
 
  }
1720
 
  _cached_size_ = total_size;
1721
 
  return total_size;
1722
 
}
1723
 
 
1724
 
void InsertRecord::MergeFrom(const ::google::protobuf::Message& from) {
1725
 
  GOOGLE_CHECK_NE(&from, this);
1726
 
  const InsertRecord* source =
1727
 
    ::google::protobuf::internal::dynamic_cast_if_available<const InsertRecord*>(
1728
 
      &from);
1729
 
  if (source == NULL) {
1730
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1731
 
  } else {
1732
 
    MergeFrom(*source);
1733
 
  }
1734
 
}
1735
 
 
1736
 
void InsertRecord::MergeFrom(const InsertRecord& from) {
1737
 
  GOOGLE_CHECK_NE(&from, this);
1738
 
  insert_value_.MergeFrom(from.insert_value_);
1739
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1740
 
}
1741
 
 
1742
 
void InsertRecord::CopyFrom(const ::google::protobuf::Message& from) {
1743
 
  if (&from == this) return;
1744
 
  Clear();
1745
 
  MergeFrom(from);
1746
 
}
1747
 
 
1748
 
void InsertRecord::CopyFrom(const InsertRecord& from) {
1749
 
  if (&from == this) return;
1750
 
  Clear();
1751
 
  MergeFrom(from);
1752
 
}
1753
 
 
1754
 
bool InsertRecord::IsInitialized() const {
1755
 
  
1756
 
  return true;
1757
 
}
1758
 
 
1759
 
void InsertRecord::Swap(InsertRecord* other) {
1760
 
  if (other != this) {
1761
 
    insert_value_.Swap(&other->insert_value_);
1762
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
1763
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
1764
 
    std::swap(_cached_size_, other->_cached_size_);
1765
 
  }
1766
 
}
1767
 
 
1768
 
::google::protobuf::Metadata InsertRecord::GetMetadata() const {
1769
 
  protobuf_AssignDescriptorsOnce();
1770
 
  ::google::protobuf::Metadata metadata;
1771
 
  metadata.descriptor = InsertRecord_descriptor_;
1772
 
  metadata.reflection = InsertRecord_reflection_;
1773
 
  return metadata;
1774
 
}
1775
 
 
1776
 
 
1777
 
// ===================================================================
1778
 
 
1779
 
#ifndef _MSC_VER
1780
 
const int InsertHeader::kTableMetadataFieldNumber;
1781
 
const int InsertHeader::kFieldMetadataFieldNumber;
1782
 
#endif  // !_MSC_VER
1783
 
 
1784
 
InsertHeader::InsertHeader() {
1785
 
  SharedCtor();
1786
 
}
1787
 
 
1788
 
void InsertHeader::InitAsDefaultInstance() {
1789
 
  table_metadata_ = const_cast< ::drizzled::message::TableMetadata*>(&::drizzled::message::TableMetadata::default_instance());
1790
 
}
1791
 
 
1792
 
InsertHeader::InsertHeader(const InsertHeader& from) {
1793
 
  SharedCtor();
1794
 
  MergeFrom(from);
1795
 
}
1796
 
 
1797
 
void InsertHeader::SharedCtor() {
1798
 
  _cached_size_ = 0;
1799
 
  table_metadata_ = NULL;
1800
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
1801
 
}
1802
 
 
1803
 
InsertHeader::~InsertHeader() {
1804
 
  SharedDtor();
1805
 
}
1806
 
 
1807
 
void InsertHeader::SharedDtor() {
1808
 
  if (this != default_instance_) {
1809
 
    delete table_metadata_;
1810
 
  }
1811
 
}
1812
 
 
1813
 
const ::google::protobuf::Descriptor* InsertHeader::descriptor() {
1814
 
  protobuf_AssignDescriptorsOnce();
1815
 
  return InsertHeader_descriptor_;
1816
 
}
1817
 
 
1818
 
const InsertHeader& InsertHeader::default_instance() {
1819
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
1820
 
}
1821
 
 
1822
 
InsertHeader* InsertHeader::default_instance_ = NULL;
1823
 
 
1824
 
InsertHeader* InsertHeader::New() const {
1825
 
  return new InsertHeader;
1826
 
}
1827
 
 
1828
 
void InsertHeader::Clear() {
1829
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1830
 
    if (_has_bit(0)) {
1831
 
      if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
1832
 
    }
1833
 
  }
1834
 
  field_metadata_.Clear();
1835
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
1836
 
  mutable_unknown_fields()->Clear();
1837
 
}
1838
 
 
1839
 
bool InsertHeader::MergePartialFromCodedStream(
1840
 
    ::google::protobuf::io::CodedInputStream* input) {
1841
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
1842
 
  ::google::protobuf::uint32 tag;
1843
 
  while ((tag = input->ReadTag()) != 0) {
1844
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
1845
 
      // required .drizzled.message.TableMetadata table_metadata = 1;
1846
 
      case 1: {
1847
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
1848
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1849
 
          goto handle_uninterpreted;
1850
 
        }
1851
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1852
 
             input, mutable_table_metadata()));
1853
 
        if (input->ExpectTag(18)) goto parse_field_metadata;
1854
 
        break;
1855
 
      }
1856
 
      
1857
 
      // repeated .drizzled.message.FieldMetadata field_metadata = 2;
1858
 
      case 2: {
1859
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
1860
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
1861
 
          goto handle_uninterpreted;
1862
 
        }
1863
 
       parse_field_metadata:
1864
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
1865
 
              input, add_field_metadata()));
1866
 
        if (input->ExpectTag(18)) goto parse_field_metadata;
1867
 
        if (input->ExpectAtEnd()) return true;
1868
 
        break;
1869
 
      }
1870
 
      
1871
 
      default: {
1872
 
      handle_uninterpreted:
1873
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
1874
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
1875
 
          return true;
1876
 
        }
1877
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
1878
 
              input, tag, mutable_unknown_fields()));
1879
 
        break;
1880
 
      }
1881
 
    }
1882
 
  }
1883
 
  return true;
1884
 
#undef DO_
1885
 
}
1886
 
 
1887
 
void InsertHeader::SerializeWithCachedSizes(
1888
 
    ::google::protobuf::io::CodedOutputStream* output) const {
1889
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
1890
 
  if (raw_buffer != NULL) {
1891
 
    InsertHeader::SerializeWithCachedSizesToArray(raw_buffer);
1892
 
    return;
1893
 
  }
1894
 
  
1895
 
  // required .drizzled.message.TableMetadata table_metadata = 1;
1896
 
  if (_has_bit(0)) {
1897
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
1898
 
      1, this->table_metadata(), output);
1899
 
  }
1900
 
  
1901
 
  // repeated .drizzled.message.FieldMetadata field_metadata = 2;
1902
 
  for (int i = 0; i < this->field_metadata_size(); i++) {
1903
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
1904
 
      2, this->field_metadata(i), output);
1905
 
  }
1906
 
  
1907
 
  if (!unknown_fields().empty()) {
1908
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
1909
 
        unknown_fields(), output);
1910
 
  }
1911
 
}
1912
 
 
1913
 
::google::protobuf::uint8* InsertHeader::SerializeWithCachedSizesToArray(
1914
 
    ::google::protobuf::uint8* target) const {
1915
 
  // required .drizzled.message.TableMetadata table_metadata = 1;
1916
 
  if (_has_bit(0)) {
1917
 
    target = ::google::protobuf::internal::WireFormatLite::
1918
 
      WriteMessageNoVirtualToArray(
1919
 
        1, this->table_metadata(), target);
1920
 
  }
1921
 
  
1922
 
  // repeated .drizzled.message.FieldMetadata field_metadata = 2;
1923
 
  for (int i = 0; i < this->field_metadata_size(); i++) {
1924
 
    target = ::google::protobuf::internal::WireFormatLite::
1925
 
      WriteMessageNoVirtualToArray(
1926
 
        2, this->field_metadata(i), target);
1927
 
  }
1928
 
  
1929
 
  if (!unknown_fields().empty()) {
1930
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
1931
 
        unknown_fields(), target);
1932
 
  }
1933
 
  return target;
1934
 
}
1935
 
 
1936
 
int InsertHeader::ByteSize() const {
1937
 
  int total_size = 0;
1938
 
  
1939
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1940
 
    // required .drizzled.message.TableMetadata table_metadata = 1;
1941
 
    if (has_table_metadata()) {
1942
 
      total_size += 1 +
1943
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1944
 
          this->table_metadata());
1945
 
    }
1946
 
    
1947
 
  }
1948
 
  // repeated .drizzled.message.FieldMetadata field_metadata = 2;
1949
 
  total_size += 1 * this->field_metadata_size();
1950
 
  for (int i = 0; i < this->field_metadata_size(); i++) {
1951
 
    total_size +=
1952
 
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
1953
 
        this->field_metadata(i));
1954
 
  }
1955
 
  
1956
 
  if (!unknown_fields().empty()) {
1957
 
    total_size +=
1958
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
1959
 
        unknown_fields());
1960
 
  }
1961
 
  _cached_size_ = total_size;
1962
 
  return total_size;
1963
 
}
1964
 
 
1965
 
void InsertHeader::MergeFrom(const ::google::protobuf::Message& from) {
1966
 
  GOOGLE_CHECK_NE(&from, this);
1967
 
  const InsertHeader* source =
1968
 
    ::google::protobuf::internal::dynamic_cast_if_available<const InsertHeader*>(
1969
 
      &from);
1970
 
  if (source == NULL) {
1971
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
1972
 
  } else {
1973
 
    MergeFrom(*source);
1974
 
  }
1975
 
}
1976
 
 
1977
 
void InsertHeader::MergeFrom(const InsertHeader& from) {
1978
 
  GOOGLE_CHECK_NE(&from, this);
1979
 
  field_metadata_.MergeFrom(from.field_metadata_);
1980
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
1981
 
    if (from._has_bit(0)) {
1982
 
      mutable_table_metadata()->::drizzled::message::TableMetadata::MergeFrom(from.table_metadata());
1983
 
    }
1984
 
  }
1985
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
1986
 
}
1987
 
 
1988
 
void InsertHeader::CopyFrom(const ::google::protobuf::Message& from) {
1989
 
  if (&from == this) return;
1990
 
  Clear();
1991
 
  MergeFrom(from);
1992
 
}
1993
 
 
1994
 
void InsertHeader::CopyFrom(const InsertHeader& from) {
1995
 
  if (&from == this) return;
1996
 
  Clear();
1997
 
  MergeFrom(from);
1998
 
}
1999
 
 
2000
 
bool InsertHeader::IsInitialized() const {
2001
 
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
2002
 
  
2003
 
  if (has_table_metadata()) {
2004
 
    if (!this->table_metadata().IsInitialized()) return false;
2005
 
  }
2006
 
  for (int i = 0; i < field_metadata_size(); i++) {
2007
 
    if (!this->field_metadata(i).IsInitialized()) return false;
2008
 
  }
2009
 
  return true;
2010
 
}
2011
 
 
2012
 
void InsertHeader::Swap(InsertHeader* other) {
2013
 
  if (other != this) {
2014
 
    std::swap(table_metadata_, other->table_metadata_);
2015
 
    field_metadata_.Swap(&other->field_metadata_);
2016
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
2017
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
2018
 
    std::swap(_cached_size_, other->_cached_size_);
2019
 
  }
2020
 
}
2021
 
 
2022
 
::google::protobuf::Metadata InsertHeader::GetMetadata() const {
2023
 
  protobuf_AssignDescriptorsOnce();
2024
 
  ::google::protobuf::Metadata metadata;
2025
 
  metadata.descriptor = InsertHeader_descriptor_;
2026
 
  metadata.reflection = InsertHeader_reflection_;
2027
 
  return metadata;
2028
 
}
2029
 
 
2030
 
 
2031
 
// ===================================================================
2032
 
 
2033
 
#ifndef _MSC_VER
2034
 
const int InsertData::kSegmentIdFieldNumber;
2035
 
const int InsertData::kEndSegmentFieldNumber;
2036
 
const int InsertData::kRecordFieldNumber;
2037
 
#endif  // !_MSC_VER
2038
 
 
2039
 
InsertData::InsertData() {
2040
 
  SharedCtor();
2041
 
}
2042
 
 
2043
 
void InsertData::InitAsDefaultInstance() {
2044
 
}
2045
 
 
2046
 
InsertData::InsertData(const InsertData& from) {
2047
 
  SharedCtor();
2048
 
  MergeFrom(from);
2049
 
}
2050
 
 
2051
 
void InsertData::SharedCtor() {
2052
 
  _cached_size_ = 0;
2053
 
  segment_id_ = 0u;
2054
 
  end_segment_ = false;
2055
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
2056
 
}
2057
 
 
2058
 
InsertData::~InsertData() {
2059
 
  SharedDtor();
2060
 
}
2061
 
 
2062
 
void InsertData::SharedDtor() {
2063
 
  if (this != default_instance_) {
2064
 
  }
2065
 
}
2066
 
 
2067
 
const ::google::protobuf::Descriptor* InsertData::descriptor() {
2068
 
  protobuf_AssignDescriptorsOnce();
2069
 
  return InsertData_descriptor_;
2070
 
}
2071
 
 
2072
 
const InsertData& InsertData::default_instance() {
2073
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
2074
 
}
2075
 
 
2076
 
InsertData* InsertData::default_instance_ = NULL;
2077
 
 
2078
 
InsertData* InsertData::New() const {
2079
 
  return new InsertData;
2080
 
}
2081
 
 
2082
 
void InsertData::Clear() {
2083
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2084
 
    segment_id_ = 0u;
2085
 
    end_segment_ = false;
2086
 
  }
2087
 
  record_.Clear();
2088
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
2089
 
  mutable_unknown_fields()->Clear();
2090
 
}
2091
 
 
2092
 
bool InsertData::MergePartialFromCodedStream(
2093
 
    ::google::protobuf::io::CodedInputStream* input) {
2094
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
2095
 
  ::google::protobuf::uint32 tag;
2096
 
  while ((tag = input->ReadTag()) != 0) {
2097
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
2098
 
      // required uint32 segment_id = 1;
2099
 
      case 1: {
2100
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
2101
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2102
 
          goto handle_uninterpreted;
2103
 
        }
2104
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadUInt32(
2105
 
              input, &segment_id_));
2106
 
        _set_bit(0);
2107
 
        if (input->ExpectTag(16)) goto parse_end_segment;
2108
 
        break;
2109
 
      }
2110
 
      
2111
 
      // required bool end_segment = 2;
2112
 
      case 2: {
2113
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
2114
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2115
 
          goto handle_uninterpreted;
2116
 
        }
2117
 
       parse_end_segment:
2118
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadBool(
2119
 
              input, &end_segment_));
2120
 
        _set_bit(1);
2121
 
        if (input->ExpectTag(26)) goto parse_record;
2122
 
        break;
2123
 
      }
2124
 
      
2125
 
      // repeated .drizzled.message.InsertRecord record = 3;
2126
 
      case 3: {
2127
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
2128
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2129
 
          goto handle_uninterpreted;
2130
 
        }
2131
 
       parse_record:
2132
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
2133
 
              input, add_record()));
2134
 
        if (input->ExpectTag(26)) goto parse_record;
2135
 
        if (input->ExpectAtEnd()) return true;
2136
 
        break;
2137
 
      }
2138
 
      
2139
 
      default: {
2140
 
      handle_uninterpreted:
2141
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2142
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
2143
 
          return true;
2144
 
        }
2145
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
2146
 
              input, tag, mutable_unknown_fields()));
2147
 
        break;
2148
 
      }
2149
 
    }
2150
 
  }
2151
 
  return true;
2152
 
#undef DO_
2153
 
}
2154
 
 
2155
 
void InsertData::SerializeWithCachedSizes(
2156
 
    ::google::protobuf::io::CodedOutputStream* output) const {
2157
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
2158
 
  if (raw_buffer != NULL) {
2159
 
    InsertData::SerializeWithCachedSizesToArray(raw_buffer);
2160
 
    return;
2161
 
  }
2162
 
  
2163
 
  // required uint32 segment_id = 1;
2164
 
  if (_has_bit(0)) {
2165
 
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->segment_id(), output);
2166
 
  }
2167
 
  
2168
 
  // required bool end_segment = 2;
2169
 
  if (_has_bit(1)) {
2170
 
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->end_segment(), output);
2171
 
  }
2172
 
  
2173
 
  // repeated .drizzled.message.InsertRecord record = 3;
2174
 
  for (int i = 0; i < this->record_size(); i++) {
2175
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
2176
 
      3, this->record(i), output);
2177
 
  }
2178
 
  
2179
 
  if (!unknown_fields().empty()) {
2180
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2181
 
        unknown_fields(), output);
2182
 
  }
2183
 
}
2184
 
 
2185
 
::google::protobuf::uint8* InsertData::SerializeWithCachedSizesToArray(
2186
 
    ::google::protobuf::uint8* target) const {
2187
 
  // required uint32 segment_id = 1;
2188
 
  if (_has_bit(0)) {
2189
 
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->segment_id(), target);
2190
 
  }
2191
 
  
2192
 
  // required bool end_segment = 2;
2193
 
  if (_has_bit(1)) {
2194
 
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->end_segment(), target);
2195
 
  }
2196
 
  
2197
 
  // repeated .drizzled.message.InsertRecord record = 3;
2198
 
  for (int i = 0; i < this->record_size(); i++) {
2199
 
    target = ::google::protobuf::internal::WireFormatLite::
2200
 
      WriteMessageNoVirtualToArray(
2201
 
        3, this->record(i), target);
2202
 
  }
2203
 
  
2204
 
  if (!unknown_fields().empty()) {
2205
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2206
 
        unknown_fields(), target);
2207
 
  }
2208
 
  return target;
2209
 
}
2210
 
 
2211
 
int InsertData::ByteSize() const {
2212
 
  int total_size = 0;
2213
 
  
2214
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2215
 
    // required uint32 segment_id = 1;
2216
 
    if (has_segment_id()) {
2217
 
      total_size += 1 +
2218
 
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
2219
 
          this->segment_id());
2220
 
    }
2221
 
    
2222
 
    // required bool end_segment = 2;
2223
 
    if (has_end_segment()) {
2224
 
      total_size += 1 + 1;
2225
 
    }
2226
 
    
2227
 
  }
2228
 
  // repeated .drizzled.message.InsertRecord record = 3;
2229
 
  total_size += 1 * this->record_size();
2230
 
  for (int i = 0; i < this->record_size(); i++) {
2231
 
    total_size +=
2232
 
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
2233
 
        this->record(i));
2234
 
  }
2235
 
  
2236
 
  if (!unknown_fields().empty()) {
2237
 
    total_size +=
2238
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2239
 
        unknown_fields());
2240
 
  }
2241
 
  _cached_size_ = total_size;
2242
 
  return total_size;
2243
 
}
2244
 
 
2245
 
void InsertData::MergeFrom(const ::google::protobuf::Message& from) {
2246
 
  GOOGLE_CHECK_NE(&from, this);
2247
 
  const InsertData* source =
2248
 
    ::google::protobuf::internal::dynamic_cast_if_available<const InsertData*>(
2249
 
      &from);
2250
 
  if (source == NULL) {
2251
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2252
 
  } else {
2253
 
    MergeFrom(*source);
2254
 
  }
2255
 
}
2256
 
 
2257
 
void InsertData::MergeFrom(const InsertData& from) {
2258
 
  GOOGLE_CHECK_NE(&from, this);
2259
 
  record_.MergeFrom(from.record_);
2260
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2261
 
    if (from._has_bit(0)) {
2262
 
      set_segment_id(from.segment_id());
2263
 
    }
2264
 
    if (from._has_bit(1)) {
2265
 
      set_end_segment(from.end_segment());
2266
 
    }
2267
 
  }
2268
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
2269
 
}
2270
 
 
2271
 
void InsertData::CopyFrom(const ::google::protobuf::Message& from) {
2272
 
  if (&from == this) return;
2273
 
  Clear();
2274
 
  MergeFrom(from);
2275
 
}
2276
 
 
2277
 
void InsertData::CopyFrom(const InsertData& from) {
2278
 
  if (&from == this) return;
2279
 
  Clear();
2280
 
  MergeFrom(from);
2281
 
}
2282
 
 
2283
 
bool InsertData::IsInitialized() const {
2284
 
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
2285
 
  
2286
 
  return true;
2287
 
}
2288
 
 
2289
 
void InsertData::Swap(InsertData* other) {
2290
 
  if (other != this) {
2291
 
    std::swap(segment_id_, other->segment_id_);
2292
 
    std::swap(end_segment_, other->end_segment_);
2293
 
    record_.Swap(&other->record_);
2294
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
2295
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
2296
 
    std::swap(_cached_size_, other->_cached_size_);
2297
 
  }
2298
 
}
2299
 
 
2300
 
::google::protobuf::Metadata InsertData::GetMetadata() const {
2301
 
  protobuf_AssignDescriptorsOnce();
2302
 
  ::google::protobuf::Metadata metadata;
2303
 
  metadata.descriptor = InsertData_descriptor_;
2304
 
  metadata.reflection = InsertData_reflection_;
2305
 
  return metadata;
2306
 
}
2307
 
 
2308
 
 
2309
 
// ===================================================================
2310
 
 
2311
 
#ifndef _MSC_VER
2312
 
const int UpdateRecord::kKeyValueFieldNumber;
2313
 
const int UpdateRecord::kAfterValueFieldNumber;
2314
 
const int UpdateRecord::kBeforeValueFieldNumber;
2315
 
#endif  // !_MSC_VER
2316
 
 
2317
 
UpdateRecord::UpdateRecord() {
2318
 
  SharedCtor();
2319
 
}
2320
 
 
2321
 
void UpdateRecord::InitAsDefaultInstance() {
2322
 
}
2323
 
 
2324
 
UpdateRecord::UpdateRecord(const UpdateRecord& from) {
2325
 
  SharedCtor();
2326
 
  MergeFrom(from);
2327
 
}
2328
 
 
2329
 
void UpdateRecord::SharedCtor() {
2330
 
  _cached_size_ = 0;
2331
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
2332
 
}
2333
 
 
2334
 
UpdateRecord::~UpdateRecord() {
2335
 
  SharedDtor();
2336
 
}
2337
 
 
2338
 
void UpdateRecord::SharedDtor() {
2339
 
  if (this != default_instance_) {
2340
 
  }
2341
 
}
2342
 
 
2343
 
const ::google::protobuf::Descriptor* UpdateRecord::descriptor() {
2344
 
  protobuf_AssignDescriptorsOnce();
2345
 
  return UpdateRecord_descriptor_;
2346
 
}
2347
 
 
2348
 
const UpdateRecord& UpdateRecord::default_instance() {
2349
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
2350
 
}
2351
 
 
2352
 
UpdateRecord* UpdateRecord::default_instance_ = NULL;
2353
 
 
2354
 
UpdateRecord* UpdateRecord::New() const {
2355
 
  return new UpdateRecord;
2356
 
}
2357
 
 
2358
 
void UpdateRecord::Clear() {
2359
 
  key_value_.Clear();
2360
 
  after_value_.Clear();
2361
 
  before_value_.Clear();
2362
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
2363
 
  mutable_unknown_fields()->Clear();
2364
 
}
2365
 
 
2366
 
bool UpdateRecord::MergePartialFromCodedStream(
2367
 
    ::google::protobuf::io::CodedInputStream* input) {
2368
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
2369
 
  ::google::protobuf::uint32 tag;
2370
 
  while ((tag = input->ReadTag()) != 0) {
2371
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
2372
 
      // repeated bytes key_value = 1;
2373
 
      case 1: {
2374
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
2375
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2376
 
          goto handle_uninterpreted;
2377
 
        }
2378
 
       parse_key_value:
2379
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
2380
 
              input, this->add_key_value()));
2381
 
        if (input->ExpectTag(10)) goto parse_key_value;
2382
 
        if (input->ExpectTag(18)) goto parse_after_value;
2383
 
        break;
2384
 
      }
2385
 
      
2386
 
      // repeated bytes after_value = 2;
2387
 
      case 2: {
2388
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
2389
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2390
 
          goto handle_uninterpreted;
2391
 
        }
2392
 
       parse_after_value:
2393
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
2394
 
              input, this->add_after_value()));
2395
 
        if (input->ExpectTag(18)) goto parse_after_value;
2396
 
        if (input->ExpectTag(26)) goto parse_before_value;
2397
 
        break;
2398
 
      }
2399
 
      
2400
 
      // repeated bytes before_value = 3;
2401
 
      case 3: {
2402
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
2403
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2404
 
          goto handle_uninterpreted;
2405
 
        }
2406
 
       parse_before_value:
2407
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
2408
 
              input, this->add_before_value()));
2409
 
        if (input->ExpectTag(26)) goto parse_before_value;
2410
 
        if (input->ExpectAtEnd()) return true;
2411
 
        break;
2412
 
      }
2413
 
      
2414
 
      default: {
2415
 
      handle_uninterpreted:
2416
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2417
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
2418
 
          return true;
2419
 
        }
2420
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
2421
 
              input, tag, mutable_unknown_fields()));
2422
 
        break;
2423
 
      }
2424
 
    }
2425
 
  }
2426
 
  return true;
2427
 
#undef DO_
2428
 
}
2429
 
 
2430
 
void UpdateRecord::SerializeWithCachedSizes(
2431
 
    ::google::protobuf::io::CodedOutputStream* output) const {
2432
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
2433
 
  if (raw_buffer != NULL) {
2434
 
    UpdateRecord::SerializeWithCachedSizesToArray(raw_buffer);
2435
 
    return;
2436
 
  }
2437
 
  
2438
 
  // repeated bytes key_value = 1;
2439
 
  for (int i = 0; i < this->key_value_size(); i++) {
2440
 
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
2441
 
      1, this->key_value(i), output);
2442
 
  }
2443
 
  
2444
 
  // repeated bytes after_value = 2;
2445
 
  for (int i = 0; i < this->after_value_size(); i++) {
2446
 
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
2447
 
      2, this->after_value(i), output);
2448
 
  }
2449
 
  
2450
 
  // repeated bytes before_value = 3;
2451
 
  for (int i = 0; i < this->before_value_size(); i++) {
2452
 
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
2453
 
      3, this->before_value(i), output);
2454
 
  }
2455
 
  
2456
 
  if (!unknown_fields().empty()) {
2457
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2458
 
        unknown_fields(), output);
2459
 
  }
2460
 
}
2461
 
 
2462
 
::google::protobuf::uint8* UpdateRecord::SerializeWithCachedSizesToArray(
2463
 
    ::google::protobuf::uint8* target) const {
2464
 
  // repeated bytes key_value = 1;
2465
 
  for (int i = 0; i < this->key_value_size(); i++) {
2466
 
    target = ::google::protobuf::internal::WireFormatLite::
2467
 
      WriteBytesToArray(1, this->key_value(i), target);
2468
 
  }
2469
 
  
2470
 
  // repeated bytes after_value = 2;
2471
 
  for (int i = 0; i < this->after_value_size(); i++) {
2472
 
    target = ::google::protobuf::internal::WireFormatLite::
2473
 
      WriteBytesToArray(2, this->after_value(i), target);
2474
 
  }
2475
 
  
2476
 
  // repeated bytes before_value = 3;
2477
 
  for (int i = 0; i < this->before_value_size(); i++) {
2478
 
    target = ::google::protobuf::internal::WireFormatLite::
2479
 
      WriteBytesToArray(3, this->before_value(i), target);
2480
 
  }
2481
 
  
2482
 
  if (!unknown_fields().empty()) {
2483
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2484
 
        unknown_fields(), target);
2485
 
  }
2486
 
  return target;
2487
 
}
2488
 
 
2489
 
int UpdateRecord::ByteSize() const {
2490
 
  int total_size = 0;
2491
 
  
2492
 
  // repeated bytes key_value = 1;
2493
 
  total_size += 1 * this->key_value_size();
2494
 
  for (int i = 0; i < this->key_value_size(); i++) {
2495
 
    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
2496
 
      this->key_value(i));
2497
 
  }
2498
 
  
2499
 
  // repeated bytes after_value = 2;
2500
 
  total_size += 1 * this->after_value_size();
2501
 
  for (int i = 0; i < this->after_value_size(); i++) {
2502
 
    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
2503
 
      this->after_value(i));
2504
 
  }
2505
 
  
2506
 
  // repeated bytes before_value = 3;
2507
 
  total_size += 1 * this->before_value_size();
2508
 
  for (int i = 0; i < this->before_value_size(); i++) {
2509
 
    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
2510
 
      this->before_value(i));
2511
 
  }
2512
 
  
2513
 
  if (!unknown_fields().empty()) {
2514
 
    total_size +=
2515
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2516
 
        unknown_fields());
2517
 
  }
2518
 
  _cached_size_ = total_size;
2519
 
  return total_size;
2520
 
}
2521
 
 
2522
 
void UpdateRecord::MergeFrom(const ::google::protobuf::Message& from) {
2523
 
  GOOGLE_CHECK_NE(&from, this);
2524
 
  const UpdateRecord* source =
2525
 
    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateRecord*>(
2526
 
      &from);
2527
 
  if (source == NULL) {
2528
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2529
 
  } else {
2530
 
    MergeFrom(*source);
2531
 
  }
2532
 
}
2533
 
 
2534
 
void UpdateRecord::MergeFrom(const UpdateRecord& from) {
2535
 
  GOOGLE_CHECK_NE(&from, this);
2536
 
  key_value_.MergeFrom(from.key_value_);
2537
 
  after_value_.MergeFrom(from.after_value_);
2538
 
  before_value_.MergeFrom(from.before_value_);
2539
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
2540
 
}
2541
 
 
2542
 
void UpdateRecord::CopyFrom(const ::google::protobuf::Message& from) {
2543
 
  if (&from == this) return;
2544
 
  Clear();
2545
 
  MergeFrom(from);
2546
 
}
2547
 
 
2548
 
void UpdateRecord::CopyFrom(const UpdateRecord& from) {
2549
 
  if (&from == this) return;
2550
 
  Clear();
2551
 
  MergeFrom(from);
2552
 
}
2553
 
 
2554
 
bool UpdateRecord::IsInitialized() const {
2555
 
  
2556
 
  return true;
2557
 
}
2558
 
 
2559
 
void UpdateRecord::Swap(UpdateRecord* other) {
2560
 
  if (other != this) {
2561
 
    key_value_.Swap(&other->key_value_);
2562
 
    after_value_.Swap(&other->after_value_);
2563
 
    before_value_.Swap(&other->before_value_);
2564
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
2565
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
2566
 
    std::swap(_cached_size_, other->_cached_size_);
2567
 
  }
2568
 
}
2569
 
 
2570
 
::google::protobuf::Metadata UpdateRecord::GetMetadata() const {
2571
 
  protobuf_AssignDescriptorsOnce();
2572
 
  ::google::protobuf::Metadata metadata;
2573
 
  metadata.descriptor = UpdateRecord_descriptor_;
2574
 
  metadata.reflection = UpdateRecord_reflection_;
2575
 
  return metadata;
2576
 
}
2577
 
 
2578
 
 
2579
 
// ===================================================================
2580
 
 
2581
 
#ifndef _MSC_VER
2582
 
const int UpdateHeader::kTableMetadataFieldNumber;
2583
 
const int UpdateHeader::kKeyFieldMetadataFieldNumber;
2584
 
const int UpdateHeader::kSetFieldMetadataFieldNumber;
2585
 
#endif  // !_MSC_VER
2586
 
 
2587
 
UpdateHeader::UpdateHeader() {
2588
 
  SharedCtor();
2589
 
}
2590
 
 
2591
 
void UpdateHeader::InitAsDefaultInstance() {
2592
 
  table_metadata_ = const_cast< ::drizzled::message::TableMetadata*>(&::drizzled::message::TableMetadata::default_instance());
2593
 
}
2594
 
 
2595
 
UpdateHeader::UpdateHeader(const UpdateHeader& from) {
2596
 
  SharedCtor();
2597
 
  MergeFrom(from);
2598
 
}
2599
 
 
2600
 
void UpdateHeader::SharedCtor() {
2601
 
  _cached_size_ = 0;
2602
 
  table_metadata_ = NULL;
2603
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
2604
 
}
2605
 
 
2606
 
UpdateHeader::~UpdateHeader() {
2607
 
  SharedDtor();
2608
 
}
2609
 
 
2610
 
void UpdateHeader::SharedDtor() {
2611
 
  if (this != default_instance_) {
2612
 
    delete table_metadata_;
2613
 
  }
2614
 
}
2615
 
 
2616
 
const ::google::protobuf::Descriptor* UpdateHeader::descriptor() {
2617
 
  protobuf_AssignDescriptorsOnce();
2618
 
  return UpdateHeader_descriptor_;
2619
 
}
2620
 
 
2621
 
const UpdateHeader& UpdateHeader::default_instance() {
2622
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
2623
 
}
2624
 
 
2625
 
UpdateHeader* UpdateHeader::default_instance_ = NULL;
2626
 
 
2627
 
UpdateHeader* UpdateHeader::New() const {
2628
 
  return new UpdateHeader;
2629
 
}
2630
 
 
2631
 
void UpdateHeader::Clear() {
2632
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2633
 
    if (_has_bit(0)) {
2634
 
      if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
2635
 
    }
2636
 
  }
2637
 
  key_field_metadata_.Clear();
2638
 
  set_field_metadata_.Clear();
2639
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
2640
 
  mutable_unknown_fields()->Clear();
2641
 
}
2642
 
 
2643
 
bool UpdateHeader::MergePartialFromCodedStream(
2644
 
    ::google::protobuf::io::CodedInputStream* input) {
2645
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
2646
 
  ::google::protobuf::uint32 tag;
2647
 
  while ((tag = input->ReadTag()) != 0) {
2648
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
2649
 
      // required .drizzled.message.TableMetadata table_metadata = 1;
2650
 
      case 1: {
2651
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
2652
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2653
 
          goto handle_uninterpreted;
2654
 
        }
2655
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
2656
 
             input, mutable_table_metadata()));
2657
 
        if (input->ExpectTag(18)) goto parse_key_field_metadata;
2658
 
        break;
2659
 
      }
2660
 
      
2661
 
      // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
2662
 
      case 2: {
2663
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
2664
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2665
 
          goto handle_uninterpreted;
2666
 
        }
2667
 
       parse_key_field_metadata:
2668
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
2669
 
              input, add_key_field_metadata()));
2670
 
        if (input->ExpectTag(18)) goto parse_key_field_metadata;
2671
 
        if (input->ExpectTag(26)) goto parse_set_field_metadata;
2672
 
        break;
2673
 
      }
2674
 
      
2675
 
      // repeated .drizzled.message.FieldMetadata set_field_metadata = 3;
2676
 
      case 3: {
2677
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
2678
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2679
 
          goto handle_uninterpreted;
2680
 
        }
2681
 
       parse_set_field_metadata:
2682
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
2683
 
              input, add_set_field_metadata()));
2684
 
        if (input->ExpectTag(26)) goto parse_set_field_metadata;
2685
 
        if (input->ExpectAtEnd()) return true;
2686
 
        break;
2687
 
      }
2688
 
      
2689
 
      default: {
2690
 
      handle_uninterpreted:
2691
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2692
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
2693
 
          return true;
2694
 
        }
2695
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
2696
 
              input, tag, mutable_unknown_fields()));
2697
 
        break;
2698
 
      }
2699
 
    }
2700
 
  }
2701
 
  return true;
2702
 
#undef DO_
2703
 
}
2704
 
 
2705
 
void UpdateHeader::SerializeWithCachedSizes(
2706
 
    ::google::protobuf::io::CodedOutputStream* output) const {
2707
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
2708
 
  if (raw_buffer != NULL) {
2709
 
    UpdateHeader::SerializeWithCachedSizesToArray(raw_buffer);
2710
 
    return;
2711
 
  }
2712
 
  
2713
 
  // required .drizzled.message.TableMetadata table_metadata = 1;
2714
 
  if (_has_bit(0)) {
2715
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
2716
 
      1, this->table_metadata(), output);
2717
 
  }
2718
 
  
2719
 
  // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
2720
 
  for (int i = 0; i < this->key_field_metadata_size(); i++) {
2721
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
2722
 
      2, this->key_field_metadata(i), output);
2723
 
  }
2724
 
  
2725
 
  // repeated .drizzled.message.FieldMetadata set_field_metadata = 3;
2726
 
  for (int i = 0; i < this->set_field_metadata_size(); i++) {
2727
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
2728
 
      3, this->set_field_metadata(i), output);
2729
 
  }
2730
 
  
2731
 
  if (!unknown_fields().empty()) {
2732
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
2733
 
        unknown_fields(), output);
2734
 
  }
2735
 
}
2736
 
 
2737
 
::google::protobuf::uint8* UpdateHeader::SerializeWithCachedSizesToArray(
2738
 
    ::google::protobuf::uint8* target) const {
2739
 
  // required .drizzled.message.TableMetadata table_metadata = 1;
2740
 
  if (_has_bit(0)) {
2741
 
    target = ::google::protobuf::internal::WireFormatLite::
2742
 
      WriteMessageNoVirtualToArray(
2743
 
        1, this->table_metadata(), target);
2744
 
  }
2745
 
  
2746
 
  // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
2747
 
  for (int i = 0; i < this->key_field_metadata_size(); i++) {
2748
 
    target = ::google::protobuf::internal::WireFormatLite::
2749
 
      WriteMessageNoVirtualToArray(
2750
 
        2, this->key_field_metadata(i), target);
2751
 
  }
2752
 
  
2753
 
  // repeated .drizzled.message.FieldMetadata set_field_metadata = 3;
2754
 
  for (int i = 0; i < this->set_field_metadata_size(); i++) {
2755
 
    target = ::google::protobuf::internal::WireFormatLite::
2756
 
      WriteMessageNoVirtualToArray(
2757
 
        3, this->set_field_metadata(i), target);
2758
 
  }
2759
 
  
2760
 
  if (!unknown_fields().empty()) {
2761
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
2762
 
        unknown_fields(), target);
2763
 
  }
2764
 
  return target;
2765
 
}
2766
 
 
2767
 
int UpdateHeader::ByteSize() const {
2768
 
  int total_size = 0;
2769
 
  
2770
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2771
 
    // required .drizzled.message.TableMetadata table_metadata = 1;
2772
 
    if (has_table_metadata()) {
2773
 
      total_size += 1 +
2774
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
2775
 
          this->table_metadata());
2776
 
    }
2777
 
    
2778
 
  }
2779
 
  // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
2780
 
  total_size += 1 * this->key_field_metadata_size();
2781
 
  for (int i = 0; i < this->key_field_metadata_size(); i++) {
2782
 
    total_size +=
2783
 
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
2784
 
        this->key_field_metadata(i));
2785
 
  }
2786
 
  
2787
 
  // repeated .drizzled.message.FieldMetadata set_field_metadata = 3;
2788
 
  total_size += 1 * this->set_field_metadata_size();
2789
 
  for (int i = 0; i < this->set_field_metadata_size(); i++) {
2790
 
    total_size +=
2791
 
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
2792
 
        this->set_field_metadata(i));
2793
 
  }
2794
 
  
2795
 
  if (!unknown_fields().empty()) {
2796
 
    total_size +=
2797
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
2798
 
        unknown_fields());
2799
 
  }
2800
 
  _cached_size_ = total_size;
2801
 
  return total_size;
2802
 
}
2803
 
 
2804
 
void UpdateHeader::MergeFrom(const ::google::protobuf::Message& from) {
2805
 
  GOOGLE_CHECK_NE(&from, this);
2806
 
  const UpdateHeader* source =
2807
 
    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateHeader*>(
2808
 
      &from);
2809
 
  if (source == NULL) {
2810
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
2811
 
  } else {
2812
 
    MergeFrom(*source);
2813
 
  }
2814
 
}
2815
 
 
2816
 
void UpdateHeader::MergeFrom(const UpdateHeader& from) {
2817
 
  GOOGLE_CHECK_NE(&from, this);
2818
 
  key_field_metadata_.MergeFrom(from.key_field_metadata_);
2819
 
  set_field_metadata_.MergeFrom(from.set_field_metadata_);
2820
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2821
 
    if (from._has_bit(0)) {
2822
 
      mutable_table_metadata()->::drizzled::message::TableMetadata::MergeFrom(from.table_metadata());
2823
 
    }
2824
 
  }
2825
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
2826
 
}
2827
 
 
2828
 
void UpdateHeader::CopyFrom(const ::google::protobuf::Message& from) {
2829
 
  if (&from == this) return;
2830
 
  Clear();
2831
 
  MergeFrom(from);
2832
 
}
2833
 
 
2834
 
void UpdateHeader::CopyFrom(const UpdateHeader& from) {
2835
 
  if (&from == this) return;
2836
 
  Clear();
2837
 
  MergeFrom(from);
2838
 
}
2839
 
 
2840
 
bool UpdateHeader::IsInitialized() const {
2841
 
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
2842
 
  
2843
 
  if (has_table_metadata()) {
2844
 
    if (!this->table_metadata().IsInitialized()) return false;
2845
 
  }
2846
 
  for (int i = 0; i < key_field_metadata_size(); i++) {
2847
 
    if (!this->key_field_metadata(i).IsInitialized()) return false;
2848
 
  }
2849
 
  for (int i = 0; i < set_field_metadata_size(); i++) {
2850
 
    if (!this->set_field_metadata(i).IsInitialized()) return false;
2851
 
  }
2852
 
  return true;
2853
 
}
2854
 
 
2855
 
void UpdateHeader::Swap(UpdateHeader* other) {
2856
 
  if (other != this) {
2857
 
    std::swap(table_metadata_, other->table_metadata_);
2858
 
    key_field_metadata_.Swap(&other->key_field_metadata_);
2859
 
    set_field_metadata_.Swap(&other->set_field_metadata_);
2860
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
2861
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
2862
 
    std::swap(_cached_size_, other->_cached_size_);
2863
 
  }
2864
 
}
2865
 
 
2866
 
::google::protobuf::Metadata UpdateHeader::GetMetadata() const {
2867
 
  protobuf_AssignDescriptorsOnce();
2868
 
  ::google::protobuf::Metadata metadata;
2869
 
  metadata.descriptor = UpdateHeader_descriptor_;
2870
 
  metadata.reflection = UpdateHeader_reflection_;
2871
 
  return metadata;
2872
 
}
2873
 
 
2874
 
 
2875
 
// ===================================================================
2876
 
 
2877
 
#ifndef _MSC_VER
2878
 
const int UpdateData::kSegmentIdFieldNumber;
2879
 
const int UpdateData::kEndSegmentFieldNumber;
2880
 
const int UpdateData::kRecordFieldNumber;
2881
 
#endif  // !_MSC_VER
2882
 
 
2883
 
UpdateData::UpdateData() {
2884
 
  SharedCtor();
2885
 
}
2886
 
 
2887
 
void UpdateData::InitAsDefaultInstance() {
2888
 
}
2889
 
 
2890
 
UpdateData::UpdateData(const UpdateData& from) {
2891
 
  SharedCtor();
2892
 
  MergeFrom(from);
2893
 
}
2894
 
 
2895
 
void UpdateData::SharedCtor() {
2896
 
  _cached_size_ = 0;
2897
 
  segment_id_ = 0u;
2898
 
  end_segment_ = false;
2899
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
2900
 
}
2901
 
 
2902
 
UpdateData::~UpdateData() {
2903
 
  SharedDtor();
2904
 
}
2905
 
 
2906
 
void UpdateData::SharedDtor() {
2907
 
  if (this != default_instance_) {
2908
 
  }
2909
 
}
2910
 
 
2911
 
const ::google::protobuf::Descriptor* UpdateData::descriptor() {
2912
 
  protobuf_AssignDescriptorsOnce();
2913
 
  return UpdateData_descriptor_;
2914
 
}
2915
 
 
2916
 
const UpdateData& UpdateData::default_instance() {
2917
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
2918
 
}
2919
 
 
2920
 
UpdateData* UpdateData::default_instance_ = NULL;
2921
 
 
2922
 
UpdateData* UpdateData::New() const {
2923
 
  return new UpdateData;
2924
 
}
2925
 
 
2926
 
void UpdateData::Clear() {
2927
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
2928
 
    segment_id_ = 0u;
2929
 
    end_segment_ = false;
2930
 
  }
2931
 
  record_.Clear();
2932
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
2933
 
  mutable_unknown_fields()->Clear();
2934
 
}
2935
 
 
2936
 
bool UpdateData::MergePartialFromCodedStream(
2937
 
    ::google::protobuf::io::CodedInputStream* input) {
2938
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
2939
 
  ::google::protobuf::uint32 tag;
2940
 
  while ((tag = input->ReadTag()) != 0) {
2941
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
2942
 
      // required uint32 segment_id = 1;
2943
 
      case 1: {
2944
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
2945
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2946
 
          goto handle_uninterpreted;
2947
 
        }
2948
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadUInt32(
2949
 
              input, &segment_id_));
2950
 
        _set_bit(0);
2951
 
        if (input->ExpectTag(16)) goto parse_end_segment;
2952
 
        break;
2953
 
      }
2954
 
      
2955
 
      // required bool end_segment = 2;
2956
 
      case 2: {
2957
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
2958
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
2959
 
          goto handle_uninterpreted;
2960
 
        }
2961
 
       parse_end_segment:
2962
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadBool(
2963
 
              input, &end_segment_));
2964
 
        _set_bit(1);
2965
 
        if (input->ExpectTag(26)) goto parse_record;
2966
 
        break;
2967
 
      }
2968
 
      
2969
 
      // repeated .drizzled.message.UpdateRecord record = 3;
2970
 
      case 3: {
2971
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
2972
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
2973
 
          goto handle_uninterpreted;
2974
 
        }
2975
 
       parse_record:
2976
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
2977
 
              input, add_record()));
2978
 
        if (input->ExpectTag(26)) goto parse_record;
2979
 
        if (input->ExpectAtEnd()) return true;
2980
 
        break;
2981
 
      }
2982
 
      
2983
 
      default: {
2984
 
      handle_uninterpreted:
2985
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
2986
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
2987
 
          return true;
2988
 
        }
2989
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
2990
 
              input, tag, mutable_unknown_fields()));
2991
 
        break;
2992
 
      }
2993
 
    }
2994
 
  }
2995
 
  return true;
2996
 
#undef DO_
2997
 
}
2998
 
 
2999
 
void UpdateData::SerializeWithCachedSizes(
3000
 
    ::google::protobuf::io::CodedOutputStream* output) const {
3001
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
3002
 
  if (raw_buffer != NULL) {
3003
 
    UpdateData::SerializeWithCachedSizesToArray(raw_buffer);
3004
 
    return;
3005
 
  }
3006
 
  
3007
 
  // required uint32 segment_id = 1;
3008
 
  if (_has_bit(0)) {
3009
 
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->segment_id(), output);
3010
 
  }
3011
 
  
3012
 
  // required bool end_segment = 2;
3013
 
  if (_has_bit(1)) {
3014
 
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->end_segment(), output);
3015
 
  }
3016
 
  
3017
 
  // repeated .drizzled.message.UpdateRecord record = 3;
3018
 
  for (int i = 0; i < this->record_size(); i++) {
3019
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
3020
 
      3, this->record(i), output);
3021
 
  }
3022
 
  
3023
 
  if (!unknown_fields().empty()) {
3024
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
3025
 
        unknown_fields(), output);
3026
 
  }
3027
 
}
3028
 
 
3029
 
::google::protobuf::uint8* UpdateData::SerializeWithCachedSizesToArray(
3030
 
    ::google::protobuf::uint8* target) const {
3031
 
  // required uint32 segment_id = 1;
3032
 
  if (_has_bit(0)) {
3033
 
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->segment_id(), target);
3034
 
  }
3035
 
  
3036
 
  // required bool end_segment = 2;
3037
 
  if (_has_bit(1)) {
3038
 
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->end_segment(), target);
3039
 
  }
3040
 
  
3041
 
  // repeated .drizzled.message.UpdateRecord record = 3;
3042
 
  for (int i = 0; i < this->record_size(); i++) {
3043
 
    target = ::google::protobuf::internal::WireFormatLite::
3044
 
      WriteMessageNoVirtualToArray(
3045
 
        3, this->record(i), target);
3046
 
  }
3047
 
  
3048
 
  if (!unknown_fields().empty()) {
3049
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
3050
 
        unknown_fields(), target);
3051
 
  }
3052
 
  return target;
3053
 
}
3054
 
 
3055
 
int UpdateData::ByteSize() const {
3056
 
  int total_size = 0;
3057
 
  
3058
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3059
 
    // required uint32 segment_id = 1;
3060
 
    if (has_segment_id()) {
3061
 
      total_size += 1 +
3062
 
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
3063
 
          this->segment_id());
3064
 
    }
3065
 
    
3066
 
    // required bool end_segment = 2;
3067
 
    if (has_end_segment()) {
3068
 
      total_size += 1 + 1;
3069
 
    }
3070
 
    
3071
 
  }
3072
 
  // repeated .drizzled.message.UpdateRecord record = 3;
3073
 
  total_size += 1 * this->record_size();
3074
 
  for (int i = 0; i < this->record_size(); i++) {
3075
 
    total_size +=
3076
 
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
3077
 
        this->record(i));
3078
 
  }
3079
 
  
3080
 
  if (!unknown_fields().empty()) {
3081
 
    total_size +=
3082
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
3083
 
        unknown_fields());
3084
 
  }
3085
 
  _cached_size_ = total_size;
3086
 
  return total_size;
3087
 
}
3088
 
 
3089
 
void UpdateData::MergeFrom(const ::google::protobuf::Message& from) {
3090
 
  GOOGLE_CHECK_NE(&from, this);
3091
 
  const UpdateData* source =
3092
 
    ::google::protobuf::internal::dynamic_cast_if_available<const UpdateData*>(
3093
 
      &from);
3094
 
  if (source == NULL) {
3095
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
3096
 
  } else {
3097
 
    MergeFrom(*source);
3098
 
  }
3099
 
}
3100
 
 
3101
 
void UpdateData::MergeFrom(const UpdateData& from) {
3102
 
  GOOGLE_CHECK_NE(&from, this);
3103
 
  record_.MergeFrom(from.record_);
3104
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3105
 
    if (from._has_bit(0)) {
3106
 
      set_segment_id(from.segment_id());
3107
 
    }
3108
 
    if (from._has_bit(1)) {
3109
 
      set_end_segment(from.end_segment());
3110
 
    }
3111
 
  }
3112
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
3113
 
}
3114
 
 
3115
 
void UpdateData::CopyFrom(const ::google::protobuf::Message& from) {
3116
 
  if (&from == this) return;
3117
 
  Clear();
3118
 
  MergeFrom(from);
3119
 
}
3120
 
 
3121
 
void UpdateData::CopyFrom(const UpdateData& from) {
3122
 
  if (&from == this) return;
3123
 
  Clear();
3124
 
  MergeFrom(from);
3125
 
}
3126
 
 
3127
 
bool UpdateData::IsInitialized() const {
3128
 
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
3129
 
  
3130
 
  return true;
3131
 
}
3132
 
 
3133
 
void UpdateData::Swap(UpdateData* other) {
3134
 
  if (other != this) {
3135
 
    std::swap(segment_id_, other->segment_id_);
3136
 
    std::swap(end_segment_, other->end_segment_);
3137
 
    record_.Swap(&other->record_);
3138
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
3139
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
3140
 
    std::swap(_cached_size_, other->_cached_size_);
3141
 
  }
3142
 
}
3143
 
 
3144
 
::google::protobuf::Metadata UpdateData::GetMetadata() const {
3145
 
  protobuf_AssignDescriptorsOnce();
3146
 
  ::google::protobuf::Metadata metadata;
3147
 
  metadata.descriptor = UpdateData_descriptor_;
3148
 
  metadata.reflection = UpdateData_reflection_;
3149
 
  return metadata;
3150
 
}
3151
 
 
3152
 
 
3153
 
// ===================================================================
3154
 
 
3155
 
#ifndef _MSC_VER
3156
 
const int DeleteRecord::kKeyValueFieldNumber;
3157
 
#endif  // !_MSC_VER
3158
 
 
3159
 
DeleteRecord::DeleteRecord() {
3160
 
  SharedCtor();
3161
 
}
3162
 
 
3163
 
void DeleteRecord::InitAsDefaultInstance() {
3164
 
}
3165
 
 
3166
 
DeleteRecord::DeleteRecord(const DeleteRecord& from) {
3167
 
  SharedCtor();
3168
 
  MergeFrom(from);
3169
 
}
3170
 
 
3171
 
void DeleteRecord::SharedCtor() {
3172
 
  _cached_size_ = 0;
3173
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
3174
 
}
3175
 
 
3176
 
DeleteRecord::~DeleteRecord() {
3177
 
  SharedDtor();
3178
 
}
3179
 
 
3180
 
void DeleteRecord::SharedDtor() {
3181
 
  if (this != default_instance_) {
3182
 
  }
3183
 
}
3184
 
 
3185
 
const ::google::protobuf::Descriptor* DeleteRecord::descriptor() {
3186
 
  protobuf_AssignDescriptorsOnce();
3187
 
  return DeleteRecord_descriptor_;
3188
 
}
3189
 
 
3190
 
const DeleteRecord& DeleteRecord::default_instance() {
3191
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
3192
 
}
3193
 
 
3194
 
DeleteRecord* DeleteRecord::default_instance_ = NULL;
3195
 
 
3196
 
DeleteRecord* DeleteRecord::New() const {
3197
 
  return new DeleteRecord;
3198
 
}
3199
 
 
3200
 
void DeleteRecord::Clear() {
3201
 
  key_value_.Clear();
3202
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
3203
 
  mutable_unknown_fields()->Clear();
3204
 
}
3205
 
 
3206
 
bool DeleteRecord::MergePartialFromCodedStream(
3207
 
    ::google::protobuf::io::CodedInputStream* input) {
3208
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
3209
 
  ::google::protobuf::uint32 tag;
3210
 
  while ((tag = input->ReadTag()) != 0) {
3211
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
3212
 
      // repeated bytes key_value = 1;
3213
 
      case 1: {
3214
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
3215
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3216
 
          goto handle_uninterpreted;
3217
 
        }
3218
 
       parse_key_value:
3219
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
3220
 
              input, this->add_key_value()));
3221
 
        if (input->ExpectTag(10)) goto parse_key_value;
3222
 
        if (input->ExpectAtEnd()) return true;
3223
 
        break;
3224
 
      }
3225
 
      
3226
 
      default: {
3227
 
      handle_uninterpreted:
3228
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3229
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
3230
 
          return true;
3231
 
        }
3232
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
3233
 
              input, tag, mutable_unknown_fields()));
3234
 
        break;
3235
 
      }
3236
 
    }
3237
 
  }
3238
 
  return true;
3239
 
#undef DO_
3240
 
}
3241
 
 
3242
 
void DeleteRecord::SerializeWithCachedSizes(
3243
 
    ::google::protobuf::io::CodedOutputStream* output) const {
3244
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
3245
 
  if (raw_buffer != NULL) {
3246
 
    DeleteRecord::SerializeWithCachedSizesToArray(raw_buffer);
3247
 
    return;
3248
 
  }
3249
 
  
3250
 
  // repeated bytes key_value = 1;
3251
 
  for (int i = 0; i < this->key_value_size(); i++) {
3252
 
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
3253
 
      1, this->key_value(i), output);
3254
 
  }
3255
 
  
3256
 
  if (!unknown_fields().empty()) {
3257
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
3258
 
        unknown_fields(), output);
3259
 
  }
3260
 
}
3261
 
 
3262
 
::google::protobuf::uint8* DeleteRecord::SerializeWithCachedSizesToArray(
3263
 
    ::google::protobuf::uint8* target) const {
3264
 
  // repeated bytes key_value = 1;
3265
 
  for (int i = 0; i < this->key_value_size(); i++) {
3266
 
    target = ::google::protobuf::internal::WireFormatLite::
3267
 
      WriteBytesToArray(1, this->key_value(i), target);
3268
 
  }
3269
 
  
3270
 
  if (!unknown_fields().empty()) {
3271
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
3272
 
        unknown_fields(), target);
3273
 
  }
3274
 
  return target;
3275
 
}
3276
 
 
3277
 
int DeleteRecord::ByteSize() const {
3278
 
  int total_size = 0;
3279
 
  
3280
 
  // repeated bytes key_value = 1;
3281
 
  total_size += 1 * this->key_value_size();
3282
 
  for (int i = 0; i < this->key_value_size(); i++) {
3283
 
    total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
3284
 
      this->key_value(i));
3285
 
  }
3286
 
  
3287
 
  if (!unknown_fields().empty()) {
3288
 
    total_size +=
3289
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
3290
 
        unknown_fields());
3291
 
  }
3292
 
  _cached_size_ = total_size;
3293
 
  return total_size;
3294
 
}
3295
 
 
3296
 
void DeleteRecord::MergeFrom(const ::google::protobuf::Message& from) {
3297
 
  GOOGLE_CHECK_NE(&from, this);
3298
 
  const DeleteRecord* source =
3299
 
    ::google::protobuf::internal::dynamic_cast_if_available<const DeleteRecord*>(
3300
 
      &from);
3301
 
  if (source == NULL) {
3302
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
3303
 
  } else {
3304
 
    MergeFrom(*source);
3305
 
  }
3306
 
}
3307
 
 
3308
 
void DeleteRecord::MergeFrom(const DeleteRecord& from) {
3309
 
  GOOGLE_CHECK_NE(&from, this);
3310
 
  key_value_.MergeFrom(from.key_value_);
3311
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
3312
 
}
3313
 
 
3314
 
void DeleteRecord::CopyFrom(const ::google::protobuf::Message& from) {
3315
 
  if (&from == this) return;
3316
 
  Clear();
3317
 
  MergeFrom(from);
3318
 
}
3319
 
 
3320
 
void DeleteRecord::CopyFrom(const DeleteRecord& from) {
3321
 
  if (&from == this) return;
3322
 
  Clear();
3323
 
  MergeFrom(from);
3324
 
}
3325
 
 
3326
 
bool DeleteRecord::IsInitialized() const {
3327
 
  
3328
 
  return true;
3329
 
}
3330
 
 
3331
 
void DeleteRecord::Swap(DeleteRecord* other) {
3332
 
  if (other != this) {
3333
 
    key_value_.Swap(&other->key_value_);
3334
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
3335
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
3336
 
    std::swap(_cached_size_, other->_cached_size_);
3337
 
  }
3338
 
}
3339
 
 
3340
 
::google::protobuf::Metadata DeleteRecord::GetMetadata() const {
3341
 
  protobuf_AssignDescriptorsOnce();
3342
 
  ::google::protobuf::Metadata metadata;
3343
 
  metadata.descriptor = DeleteRecord_descriptor_;
3344
 
  metadata.reflection = DeleteRecord_reflection_;
3345
 
  return metadata;
3346
 
}
3347
 
 
3348
 
 
3349
 
// ===================================================================
3350
 
 
3351
 
#ifndef _MSC_VER
3352
 
const int DeleteHeader::kTableMetadataFieldNumber;
3353
 
const int DeleteHeader::kKeyFieldMetadataFieldNumber;
3354
 
#endif  // !_MSC_VER
3355
 
 
3356
 
DeleteHeader::DeleteHeader() {
3357
 
  SharedCtor();
3358
 
}
3359
 
 
3360
 
void DeleteHeader::InitAsDefaultInstance() {
3361
 
  table_metadata_ = const_cast< ::drizzled::message::TableMetadata*>(&::drizzled::message::TableMetadata::default_instance());
3362
 
}
3363
 
 
3364
 
DeleteHeader::DeleteHeader(const DeleteHeader& from) {
3365
 
  SharedCtor();
3366
 
  MergeFrom(from);
3367
 
}
3368
 
 
3369
 
void DeleteHeader::SharedCtor() {
3370
 
  _cached_size_ = 0;
3371
 
  table_metadata_ = NULL;
3372
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
3373
 
}
3374
 
 
3375
 
DeleteHeader::~DeleteHeader() {
3376
 
  SharedDtor();
3377
 
}
3378
 
 
3379
 
void DeleteHeader::SharedDtor() {
3380
 
  if (this != default_instance_) {
3381
 
    delete table_metadata_;
3382
 
  }
3383
 
}
3384
 
 
3385
 
const ::google::protobuf::Descriptor* DeleteHeader::descriptor() {
3386
 
  protobuf_AssignDescriptorsOnce();
3387
 
  return DeleteHeader_descriptor_;
3388
 
}
3389
 
 
3390
 
const DeleteHeader& DeleteHeader::default_instance() {
3391
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
3392
 
}
3393
 
 
3394
 
DeleteHeader* DeleteHeader::default_instance_ = NULL;
3395
 
 
3396
 
DeleteHeader* DeleteHeader::New() const {
3397
 
  return new DeleteHeader;
3398
 
}
3399
 
 
3400
 
void DeleteHeader::Clear() {
3401
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3402
 
    if (_has_bit(0)) {
3403
 
      if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
3404
 
    }
3405
 
  }
3406
 
  key_field_metadata_.Clear();
3407
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
3408
 
  mutable_unknown_fields()->Clear();
3409
 
}
3410
 
 
3411
 
bool DeleteHeader::MergePartialFromCodedStream(
3412
 
    ::google::protobuf::io::CodedInputStream* input) {
3413
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
3414
 
  ::google::protobuf::uint32 tag;
3415
 
  while ((tag = input->ReadTag()) != 0) {
3416
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
3417
 
      // required .drizzled.message.TableMetadata table_metadata = 1;
3418
 
      case 1: {
3419
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
3420
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3421
 
          goto handle_uninterpreted;
3422
 
        }
3423
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
3424
 
             input, mutable_table_metadata()));
3425
 
        if (input->ExpectTag(18)) goto parse_key_field_metadata;
3426
 
        break;
3427
 
      }
3428
 
      
3429
 
      // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
3430
 
      case 2: {
3431
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
3432
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3433
 
          goto handle_uninterpreted;
3434
 
        }
3435
 
       parse_key_field_metadata:
3436
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
3437
 
              input, add_key_field_metadata()));
3438
 
        if (input->ExpectTag(18)) goto parse_key_field_metadata;
3439
 
        if (input->ExpectAtEnd()) return true;
3440
 
        break;
3441
 
      }
3442
 
      
3443
 
      default: {
3444
 
      handle_uninterpreted:
3445
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3446
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
3447
 
          return true;
3448
 
        }
3449
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
3450
 
              input, tag, mutable_unknown_fields()));
3451
 
        break;
3452
 
      }
3453
 
    }
3454
 
  }
3455
 
  return true;
3456
 
#undef DO_
3457
 
}
3458
 
 
3459
 
void DeleteHeader::SerializeWithCachedSizes(
3460
 
    ::google::protobuf::io::CodedOutputStream* output) const {
3461
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
3462
 
  if (raw_buffer != NULL) {
3463
 
    DeleteHeader::SerializeWithCachedSizesToArray(raw_buffer);
3464
 
    return;
3465
 
  }
3466
 
  
3467
 
  // required .drizzled.message.TableMetadata table_metadata = 1;
3468
 
  if (_has_bit(0)) {
3469
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
3470
 
      1, this->table_metadata(), output);
3471
 
  }
3472
 
  
3473
 
  // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
3474
 
  for (int i = 0; i < this->key_field_metadata_size(); i++) {
3475
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
3476
 
      2, this->key_field_metadata(i), output);
3477
 
  }
3478
 
  
3479
 
  if (!unknown_fields().empty()) {
3480
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
3481
 
        unknown_fields(), output);
3482
 
  }
3483
 
}
3484
 
 
3485
 
::google::protobuf::uint8* DeleteHeader::SerializeWithCachedSizesToArray(
3486
 
    ::google::protobuf::uint8* target) const {
3487
 
  // required .drizzled.message.TableMetadata table_metadata = 1;
3488
 
  if (_has_bit(0)) {
3489
 
    target = ::google::protobuf::internal::WireFormatLite::
3490
 
      WriteMessageNoVirtualToArray(
3491
 
        1, this->table_metadata(), target);
3492
 
  }
3493
 
  
3494
 
  // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
3495
 
  for (int i = 0; i < this->key_field_metadata_size(); i++) {
3496
 
    target = ::google::protobuf::internal::WireFormatLite::
3497
 
      WriteMessageNoVirtualToArray(
3498
 
        2, this->key_field_metadata(i), target);
3499
 
  }
3500
 
  
3501
 
  if (!unknown_fields().empty()) {
3502
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
3503
 
        unknown_fields(), target);
3504
 
  }
3505
 
  return target;
3506
 
}
3507
 
 
3508
 
int DeleteHeader::ByteSize() const {
3509
 
  int total_size = 0;
3510
 
  
3511
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3512
 
    // required .drizzled.message.TableMetadata table_metadata = 1;
3513
 
    if (has_table_metadata()) {
3514
 
      total_size += 1 +
3515
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
3516
 
          this->table_metadata());
3517
 
    }
3518
 
    
3519
 
  }
3520
 
  // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
3521
 
  total_size += 1 * this->key_field_metadata_size();
3522
 
  for (int i = 0; i < this->key_field_metadata_size(); i++) {
3523
 
    total_size +=
3524
 
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
3525
 
        this->key_field_metadata(i));
3526
 
  }
3527
 
  
3528
 
  if (!unknown_fields().empty()) {
3529
 
    total_size +=
3530
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
3531
 
        unknown_fields());
3532
 
  }
3533
 
  _cached_size_ = total_size;
3534
 
  return total_size;
3535
 
}
3536
 
 
3537
 
void DeleteHeader::MergeFrom(const ::google::protobuf::Message& from) {
3538
 
  GOOGLE_CHECK_NE(&from, this);
3539
 
  const DeleteHeader* source =
3540
 
    ::google::protobuf::internal::dynamic_cast_if_available<const DeleteHeader*>(
3541
 
      &from);
3542
 
  if (source == NULL) {
3543
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
3544
 
  } else {
3545
 
    MergeFrom(*source);
3546
 
  }
3547
 
}
3548
 
 
3549
 
void DeleteHeader::MergeFrom(const DeleteHeader& from) {
3550
 
  GOOGLE_CHECK_NE(&from, this);
3551
 
  key_field_metadata_.MergeFrom(from.key_field_metadata_);
3552
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3553
 
    if (from._has_bit(0)) {
3554
 
      mutable_table_metadata()->::drizzled::message::TableMetadata::MergeFrom(from.table_metadata());
3555
 
    }
3556
 
  }
3557
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
3558
 
}
3559
 
 
3560
 
void DeleteHeader::CopyFrom(const ::google::protobuf::Message& from) {
3561
 
  if (&from == this) return;
3562
 
  Clear();
3563
 
  MergeFrom(from);
3564
 
}
3565
 
 
3566
 
void DeleteHeader::CopyFrom(const DeleteHeader& from) {
3567
 
  if (&from == this) return;
3568
 
  Clear();
3569
 
  MergeFrom(from);
3570
 
}
3571
 
 
3572
 
bool DeleteHeader::IsInitialized() const {
3573
 
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
3574
 
  
3575
 
  if (has_table_metadata()) {
3576
 
    if (!this->table_metadata().IsInitialized()) return false;
3577
 
  }
3578
 
  for (int i = 0; i < key_field_metadata_size(); i++) {
3579
 
    if (!this->key_field_metadata(i).IsInitialized()) return false;
3580
 
  }
3581
 
  return true;
3582
 
}
3583
 
 
3584
 
void DeleteHeader::Swap(DeleteHeader* other) {
3585
 
  if (other != this) {
3586
 
    std::swap(table_metadata_, other->table_metadata_);
3587
 
    key_field_metadata_.Swap(&other->key_field_metadata_);
3588
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
3589
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
3590
 
    std::swap(_cached_size_, other->_cached_size_);
3591
 
  }
3592
 
}
3593
 
 
3594
 
::google::protobuf::Metadata DeleteHeader::GetMetadata() const {
3595
 
  protobuf_AssignDescriptorsOnce();
3596
 
  ::google::protobuf::Metadata metadata;
3597
 
  metadata.descriptor = DeleteHeader_descriptor_;
3598
 
  metadata.reflection = DeleteHeader_reflection_;
3599
 
  return metadata;
3600
 
}
3601
 
 
3602
 
 
3603
 
// ===================================================================
3604
 
 
3605
 
#ifndef _MSC_VER
3606
 
const int DeleteData::kSegmentIdFieldNumber;
3607
 
const int DeleteData::kEndSegmentFieldNumber;
3608
 
const int DeleteData::kRecordFieldNumber;
3609
 
#endif  // !_MSC_VER
3610
 
 
3611
 
DeleteData::DeleteData() {
3612
 
  SharedCtor();
3613
 
}
3614
 
 
3615
 
void DeleteData::InitAsDefaultInstance() {
3616
 
}
3617
 
 
3618
 
DeleteData::DeleteData(const DeleteData& from) {
3619
 
  SharedCtor();
3620
 
  MergeFrom(from);
3621
 
}
3622
 
 
3623
 
void DeleteData::SharedCtor() {
3624
 
  _cached_size_ = 0;
3625
 
  segment_id_ = 0u;
3626
 
  end_segment_ = false;
3627
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
3628
 
}
3629
 
 
3630
 
DeleteData::~DeleteData() {
3631
 
  SharedDtor();
3632
 
}
3633
 
 
3634
 
void DeleteData::SharedDtor() {
3635
 
  if (this != default_instance_) {
3636
 
  }
3637
 
}
3638
 
 
3639
 
const ::google::protobuf::Descriptor* DeleteData::descriptor() {
3640
 
  protobuf_AssignDescriptorsOnce();
3641
 
  return DeleteData_descriptor_;
3642
 
}
3643
 
 
3644
 
const DeleteData& DeleteData::default_instance() {
3645
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
3646
 
}
3647
 
 
3648
 
DeleteData* DeleteData::default_instance_ = NULL;
3649
 
 
3650
 
DeleteData* DeleteData::New() const {
3651
 
  return new DeleteData;
3652
 
}
3653
 
 
3654
 
void DeleteData::Clear() {
3655
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3656
 
    segment_id_ = 0u;
3657
 
    end_segment_ = false;
3658
 
  }
3659
 
  record_.Clear();
3660
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
3661
 
  mutable_unknown_fields()->Clear();
3662
 
}
3663
 
 
3664
 
bool DeleteData::MergePartialFromCodedStream(
3665
 
    ::google::protobuf::io::CodedInputStream* input) {
3666
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
3667
 
  ::google::protobuf::uint32 tag;
3668
 
  while ((tag = input->ReadTag()) != 0) {
3669
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
3670
 
      // required uint32 segment_id = 1;
3671
 
      case 1: {
3672
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
3673
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
3674
 
          goto handle_uninterpreted;
3675
 
        }
3676
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadUInt32(
3677
 
              input, &segment_id_));
3678
 
        _set_bit(0);
3679
 
        if (input->ExpectTag(16)) goto parse_end_segment;
3680
 
        break;
3681
 
      }
3682
 
      
3683
 
      // required bool end_segment = 2;
3684
 
      case 2: {
3685
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
3686
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
3687
 
          goto handle_uninterpreted;
3688
 
        }
3689
 
       parse_end_segment:
3690
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadBool(
3691
 
              input, &end_segment_));
3692
 
        _set_bit(1);
3693
 
        if (input->ExpectTag(26)) goto parse_record;
3694
 
        break;
3695
 
      }
3696
 
      
3697
 
      // repeated .drizzled.message.DeleteRecord record = 3;
3698
 
      case 3: {
3699
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
3700
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3701
 
          goto handle_uninterpreted;
3702
 
        }
3703
 
       parse_record:
3704
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
3705
 
              input, add_record()));
3706
 
        if (input->ExpectTag(26)) goto parse_record;
3707
 
        if (input->ExpectAtEnd()) return true;
3708
 
        break;
3709
 
      }
3710
 
      
3711
 
      default: {
3712
 
      handle_uninterpreted:
3713
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3714
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
3715
 
          return true;
3716
 
        }
3717
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
3718
 
              input, tag, mutable_unknown_fields()));
3719
 
        break;
3720
 
      }
3721
 
    }
3722
 
  }
3723
 
  return true;
3724
 
#undef DO_
3725
 
}
3726
 
 
3727
 
void DeleteData::SerializeWithCachedSizes(
3728
 
    ::google::protobuf::io::CodedOutputStream* output) const {
3729
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
3730
 
  if (raw_buffer != NULL) {
3731
 
    DeleteData::SerializeWithCachedSizesToArray(raw_buffer);
3732
 
    return;
3733
 
  }
3734
 
  
3735
 
  // required uint32 segment_id = 1;
3736
 
  if (_has_bit(0)) {
3737
 
    ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->segment_id(), output);
3738
 
  }
3739
 
  
3740
 
  // required bool end_segment = 2;
3741
 
  if (_has_bit(1)) {
3742
 
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->end_segment(), output);
3743
 
  }
3744
 
  
3745
 
  // repeated .drizzled.message.DeleteRecord record = 3;
3746
 
  for (int i = 0; i < this->record_size(); i++) {
3747
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
3748
 
      3, this->record(i), output);
3749
 
  }
3750
 
  
3751
 
  if (!unknown_fields().empty()) {
3752
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
3753
 
        unknown_fields(), output);
3754
 
  }
3755
 
}
3756
 
 
3757
 
::google::protobuf::uint8* DeleteData::SerializeWithCachedSizesToArray(
3758
 
    ::google::protobuf::uint8* target) const {
3759
 
  // required uint32 segment_id = 1;
3760
 
  if (_has_bit(0)) {
3761
 
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->segment_id(), target);
3762
 
  }
3763
 
  
3764
 
  // required bool end_segment = 2;
3765
 
  if (_has_bit(1)) {
3766
 
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->end_segment(), target);
3767
 
  }
3768
 
  
3769
 
  // repeated .drizzled.message.DeleteRecord record = 3;
3770
 
  for (int i = 0; i < this->record_size(); i++) {
3771
 
    target = ::google::protobuf::internal::WireFormatLite::
3772
 
      WriteMessageNoVirtualToArray(
3773
 
        3, this->record(i), target);
3774
 
  }
3775
 
  
3776
 
  if (!unknown_fields().empty()) {
3777
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
3778
 
        unknown_fields(), target);
3779
 
  }
3780
 
  return target;
3781
 
}
3782
 
 
3783
 
int DeleteData::ByteSize() const {
3784
 
  int total_size = 0;
3785
 
  
3786
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3787
 
    // required uint32 segment_id = 1;
3788
 
    if (has_segment_id()) {
3789
 
      total_size += 1 +
3790
 
        ::google::protobuf::internal::WireFormatLite::UInt32Size(
3791
 
          this->segment_id());
3792
 
    }
3793
 
    
3794
 
    // required bool end_segment = 2;
3795
 
    if (has_end_segment()) {
3796
 
      total_size += 1 + 1;
3797
 
    }
3798
 
    
3799
 
  }
3800
 
  // repeated .drizzled.message.DeleteRecord record = 3;
3801
 
  total_size += 1 * this->record_size();
3802
 
  for (int i = 0; i < this->record_size(); i++) {
3803
 
    total_size +=
3804
 
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
3805
 
        this->record(i));
3806
 
  }
3807
 
  
3808
 
  if (!unknown_fields().empty()) {
3809
 
    total_size +=
3810
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
3811
 
        unknown_fields());
3812
 
  }
3813
 
  _cached_size_ = total_size;
3814
 
  return total_size;
3815
 
}
3816
 
 
3817
 
void DeleteData::MergeFrom(const ::google::protobuf::Message& from) {
3818
 
  GOOGLE_CHECK_NE(&from, this);
3819
 
  const DeleteData* source =
3820
 
    ::google::protobuf::internal::dynamic_cast_if_available<const DeleteData*>(
3821
 
      &from);
3822
 
  if (source == NULL) {
3823
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
3824
 
  } else {
3825
 
    MergeFrom(*source);
3826
 
  }
3827
 
}
3828
 
 
3829
 
void DeleteData::MergeFrom(const DeleteData& from) {
3830
 
  GOOGLE_CHECK_NE(&from, this);
3831
 
  record_.MergeFrom(from.record_);
3832
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3833
 
    if (from._has_bit(0)) {
3834
 
      set_segment_id(from.segment_id());
3835
 
    }
3836
 
    if (from._has_bit(1)) {
3837
 
      set_end_segment(from.end_segment());
3838
 
    }
3839
 
  }
3840
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
3841
 
}
3842
 
 
3843
 
void DeleteData::CopyFrom(const ::google::protobuf::Message& from) {
3844
 
  if (&from == this) return;
3845
 
  Clear();
3846
 
  MergeFrom(from);
3847
 
}
3848
 
 
3849
 
void DeleteData::CopyFrom(const DeleteData& from) {
3850
 
  if (&from == this) return;
3851
 
  Clear();
3852
 
  MergeFrom(from);
3853
 
}
3854
 
 
3855
 
bool DeleteData::IsInitialized() const {
3856
 
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
3857
 
  
3858
 
  return true;
3859
 
}
3860
 
 
3861
 
void DeleteData::Swap(DeleteData* other) {
3862
 
  if (other != this) {
3863
 
    std::swap(segment_id_, other->segment_id_);
3864
 
    std::swap(end_segment_, other->end_segment_);
3865
 
    record_.Swap(&other->record_);
3866
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
3867
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
3868
 
    std::swap(_cached_size_, other->_cached_size_);
3869
 
  }
3870
 
}
3871
 
 
3872
 
::google::protobuf::Metadata DeleteData::GetMetadata() const {
3873
 
  protobuf_AssignDescriptorsOnce();
3874
 
  ::google::protobuf::Metadata metadata;
3875
 
  metadata.descriptor = DeleteData_descriptor_;
3876
 
  metadata.reflection = DeleteData_reflection_;
3877
 
  return metadata;
3878
 
}
3879
 
 
3880
 
 
3881
 
// ===================================================================
3882
 
 
3883
 
#ifndef _MSC_VER
3884
 
const int TruncateTableStatement::kTableMetadataFieldNumber;
3885
 
#endif  // !_MSC_VER
3886
 
 
3887
 
TruncateTableStatement::TruncateTableStatement() {
3888
 
  SharedCtor();
3889
 
}
3890
 
 
3891
 
void TruncateTableStatement::InitAsDefaultInstance() {
3892
 
  table_metadata_ = const_cast< ::drizzled::message::TableMetadata*>(&::drizzled::message::TableMetadata::default_instance());
3893
 
}
3894
 
 
3895
 
TruncateTableStatement::TruncateTableStatement(const TruncateTableStatement& from) {
3896
 
  SharedCtor();
3897
 
  MergeFrom(from);
3898
 
}
3899
 
 
3900
 
void TruncateTableStatement::SharedCtor() {
3901
 
  _cached_size_ = 0;
3902
 
  table_metadata_ = NULL;
3903
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
3904
 
}
3905
 
 
3906
 
TruncateTableStatement::~TruncateTableStatement() {
3907
 
  SharedDtor();
3908
 
}
3909
 
 
3910
 
void TruncateTableStatement::SharedDtor() {
3911
 
  if (this != default_instance_) {
3912
 
    delete table_metadata_;
3913
 
  }
3914
 
}
3915
 
 
3916
 
const ::google::protobuf::Descriptor* TruncateTableStatement::descriptor() {
3917
 
  protobuf_AssignDescriptorsOnce();
3918
 
  return TruncateTableStatement_descriptor_;
3919
 
}
3920
 
 
3921
 
const TruncateTableStatement& TruncateTableStatement::default_instance() {
3922
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
3923
 
}
3924
 
 
3925
 
TruncateTableStatement* TruncateTableStatement::default_instance_ = NULL;
3926
 
 
3927
 
TruncateTableStatement* TruncateTableStatement::New() const {
3928
 
  return new TruncateTableStatement;
3929
 
}
3930
 
 
3931
 
void TruncateTableStatement::Clear() {
3932
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
3933
 
    if (_has_bit(0)) {
3934
 
      if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
3935
 
    }
3936
 
  }
3937
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
3938
 
  mutable_unknown_fields()->Clear();
3939
 
}
3940
 
 
3941
 
bool TruncateTableStatement::MergePartialFromCodedStream(
3942
 
    ::google::protobuf::io::CodedInputStream* input) {
3943
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
3944
 
  ::google::protobuf::uint32 tag;
3945
 
  while ((tag = input->ReadTag()) != 0) {
3946
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
3947
 
      // required .drizzled.message.TableMetadata table_metadata = 1;
3948
 
      case 1: {
3949
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
3950
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
3951
 
          goto handle_uninterpreted;
3952
 
        }
3953
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
3954
 
             input, mutable_table_metadata()));
3955
 
        if (input->ExpectAtEnd()) return true;
3956
 
        break;
3957
 
      }
3958
 
      
3959
 
      default: {
3960
 
      handle_uninterpreted:
3961
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
3962
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
3963
 
          return true;
3964
 
        }
3965
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
3966
 
              input, tag, mutable_unknown_fields()));
3967
 
        break;
3968
 
      }
3969
 
    }
3970
 
  }
3971
 
  return true;
3972
 
#undef DO_
3973
 
}
3974
 
 
3975
 
void TruncateTableStatement::SerializeWithCachedSizes(
3976
 
    ::google::protobuf::io::CodedOutputStream* output) const {
3977
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
3978
 
  if (raw_buffer != NULL) {
3979
 
    TruncateTableStatement::SerializeWithCachedSizesToArray(raw_buffer);
3980
 
    return;
3981
 
  }
3982
 
  
3983
 
  // required .drizzled.message.TableMetadata table_metadata = 1;
3984
 
  if (_has_bit(0)) {
3985
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
3986
 
      1, this->table_metadata(), output);
3987
 
  }
3988
 
  
3989
 
  if (!unknown_fields().empty()) {
3990
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
3991
 
        unknown_fields(), output);
3992
 
  }
3993
 
}
3994
 
 
3995
 
::google::protobuf::uint8* TruncateTableStatement::SerializeWithCachedSizesToArray(
3996
 
    ::google::protobuf::uint8* target) const {
3997
 
  // required .drizzled.message.TableMetadata table_metadata = 1;
3998
 
  if (_has_bit(0)) {
3999
 
    target = ::google::protobuf::internal::WireFormatLite::
4000
 
      WriteMessageNoVirtualToArray(
4001
 
        1, this->table_metadata(), target);
4002
 
  }
4003
 
  
4004
 
  if (!unknown_fields().empty()) {
4005
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
4006
 
        unknown_fields(), target);
4007
 
  }
4008
 
  return target;
4009
 
}
4010
 
 
4011
 
int TruncateTableStatement::ByteSize() const {
4012
 
  int total_size = 0;
4013
 
  
4014
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4015
 
    // required .drizzled.message.TableMetadata table_metadata = 1;
4016
 
    if (has_table_metadata()) {
4017
 
      total_size += 1 +
4018
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
4019
 
          this->table_metadata());
4020
 
    }
4021
 
    
4022
 
  }
4023
 
  if (!unknown_fields().empty()) {
4024
 
    total_size +=
4025
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
4026
 
        unknown_fields());
4027
 
  }
4028
 
  _cached_size_ = total_size;
4029
 
  return total_size;
4030
 
}
4031
 
 
4032
 
void TruncateTableStatement::MergeFrom(const ::google::protobuf::Message& from) {
4033
 
  GOOGLE_CHECK_NE(&from, this);
4034
 
  const TruncateTableStatement* source =
4035
 
    ::google::protobuf::internal::dynamic_cast_if_available<const TruncateTableStatement*>(
4036
 
      &from);
4037
 
  if (source == NULL) {
4038
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
4039
 
  } else {
4040
 
    MergeFrom(*source);
4041
 
  }
4042
 
}
4043
 
 
4044
 
void TruncateTableStatement::MergeFrom(const TruncateTableStatement& from) {
4045
 
  GOOGLE_CHECK_NE(&from, this);
4046
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4047
 
    if (from._has_bit(0)) {
4048
 
      mutable_table_metadata()->::drizzled::message::TableMetadata::MergeFrom(from.table_metadata());
4049
 
    }
4050
 
  }
4051
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
4052
 
}
4053
 
 
4054
 
void TruncateTableStatement::CopyFrom(const ::google::protobuf::Message& from) {
4055
 
  if (&from == this) return;
4056
 
  Clear();
4057
 
  MergeFrom(from);
4058
 
}
4059
 
 
4060
 
void TruncateTableStatement::CopyFrom(const TruncateTableStatement& from) {
4061
 
  if (&from == this) return;
4062
 
  Clear();
4063
 
  MergeFrom(from);
4064
 
}
4065
 
 
4066
 
bool TruncateTableStatement::IsInitialized() const {
4067
 
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
4068
 
  
4069
 
  if (has_table_metadata()) {
4070
 
    if (!this->table_metadata().IsInitialized()) return false;
4071
 
  }
4072
 
  return true;
4073
 
}
4074
 
 
4075
 
void TruncateTableStatement::Swap(TruncateTableStatement* other) {
4076
 
  if (other != this) {
4077
 
    std::swap(table_metadata_, other->table_metadata_);
4078
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
4079
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
4080
 
    std::swap(_cached_size_, other->_cached_size_);
4081
 
  }
4082
 
}
4083
 
 
4084
 
::google::protobuf::Metadata TruncateTableStatement::GetMetadata() const {
4085
 
  protobuf_AssignDescriptorsOnce();
4086
 
  ::google::protobuf::Metadata metadata;
4087
 
  metadata.descriptor = TruncateTableStatement_descriptor_;
4088
 
  metadata.reflection = TruncateTableStatement_reflection_;
4089
 
  return metadata;
4090
 
}
4091
 
 
4092
 
 
4093
 
// ===================================================================
4094
 
 
4095
 
#ifndef _MSC_VER
4096
 
const int CreateSchemaStatement::kSchemaFieldNumber;
4097
 
#endif  // !_MSC_VER
4098
 
 
4099
 
CreateSchemaStatement::CreateSchemaStatement() {
4100
 
  SharedCtor();
4101
 
}
4102
 
 
4103
 
void CreateSchemaStatement::InitAsDefaultInstance() {
4104
 
  schema_ = const_cast< ::drizzled::message::Schema*>(&::drizzled::message::Schema::default_instance());
4105
 
}
4106
 
 
4107
 
CreateSchemaStatement::CreateSchemaStatement(const CreateSchemaStatement& from) {
4108
 
  SharedCtor();
4109
 
  MergeFrom(from);
4110
 
}
4111
 
 
4112
 
void CreateSchemaStatement::SharedCtor() {
4113
 
  _cached_size_ = 0;
4114
 
  schema_ = NULL;
4115
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
4116
 
}
4117
 
 
4118
 
CreateSchemaStatement::~CreateSchemaStatement() {
4119
 
  SharedDtor();
4120
 
}
4121
 
 
4122
 
void CreateSchemaStatement::SharedDtor() {
4123
 
  if (this != default_instance_) {
4124
 
    delete schema_;
4125
 
  }
4126
 
}
4127
 
 
4128
 
const ::google::protobuf::Descriptor* CreateSchemaStatement::descriptor() {
4129
 
  protobuf_AssignDescriptorsOnce();
4130
 
  return CreateSchemaStatement_descriptor_;
4131
 
}
4132
 
 
4133
 
const CreateSchemaStatement& CreateSchemaStatement::default_instance() {
4134
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
4135
 
}
4136
 
 
4137
 
CreateSchemaStatement* CreateSchemaStatement::default_instance_ = NULL;
4138
 
 
4139
 
CreateSchemaStatement* CreateSchemaStatement::New() const {
4140
 
  return new CreateSchemaStatement;
4141
 
}
4142
 
 
4143
 
void CreateSchemaStatement::Clear() {
4144
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4145
 
    if (_has_bit(0)) {
4146
 
      if (schema_ != NULL) schema_->::drizzled::message::Schema::Clear();
4147
 
    }
4148
 
  }
4149
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
4150
 
  mutable_unknown_fields()->Clear();
4151
 
}
4152
 
 
4153
 
bool CreateSchemaStatement::MergePartialFromCodedStream(
4154
 
    ::google::protobuf::io::CodedInputStream* input) {
4155
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
4156
 
  ::google::protobuf::uint32 tag;
4157
 
  while ((tag = input->ReadTag()) != 0) {
4158
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
4159
 
      // required .drizzled.message.Schema schema = 1;
4160
 
      case 1: {
4161
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
4162
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
4163
 
          goto handle_uninterpreted;
4164
 
        }
4165
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
4166
 
             input, mutable_schema()));
4167
 
        if (input->ExpectAtEnd()) return true;
4168
 
        break;
4169
 
      }
4170
 
      
4171
 
      default: {
4172
 
      handle_uninterpreted:
4173
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4174
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
4175
 
          return true;
4176
 
        }
4177
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
4178
 
              input, tag, mutable_unknown_fields()));
4179
 
        break;
4180
 
      }
4181
 
    }
4182
 
  }
4183
 
  return true;
4184
 
#undef DO_
4185
 
}
4186
 
 
4187
 
void CreateSchemaStatement::SerializeWithCachedSizes(
4188
 
    ::google::protobuf::io::CodedOutputStream* output) const {
4189
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
4190
 
  if (raw_buffer != NULL) {
4191
 
    CreateSchemaStatement::SerializeWithCachedSizesToArray(raw_buffer);
4192
 
    return;
4193
 
  }
4194
 
  
4195
 
  // required .drizzled.message.Schema schema = 1;
4196
 
  if (_has_bit(0)) {
4197
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
4198
 
      1, this->schema(), output);
4199
 
  }
4200
 
  
4201
 
  if (!unknown_fields().empty()) {
4202
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
4203
 
        unknown_fields(), output);
4204
 
  }
4205
 
}
4206
 
 
4207
 
::google::protobuf::uint8* CreateSchemaStatement::SerializeWithCachedSizesToArray(
4208
 
    ::google::protobuf::uint8* target) const {
4209
 
  // required .drizzled.message.Schema schema = 1;
4210
 
  if (_has_bit(0)) {
4211
 
    target = ::google::protobuf::internal::WireFormatLite::
4212
 
      WriteMessageNoVirtualToArray(
4213
 
        1, this->schema(), target);
4214
 
  }
4215
 
  
4216
 
  if (!unknown_fields().empty()) {
4217
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
4218
 
        unknown_fields(), target);
4219
 
  }
4220
 
  return target;
4221
 
}
4222
 
 
4223
 
int CreateSchemaStatement::ByteSize() const {
4224
 
  int total_size = 0;
4225
 
  
4226
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4227
 
    // required .drizzled.message.Schema schema = 1;
4228
 
    if (has_schema()) {
4229
 
      total_size += 1 +
4230
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
4231
 
          this->schema());
4232
 
    }
4233
 
    
4234
 
  }
4235
 
  if (!unknown_fields().empty()) {
4236
 
    total_size +=
4237
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
4238
 
        unknown_fields());
4239
 
  }
4240
 
  _cached_size_ = total_size;
4241
 
  return total_size;
4242
 
}
4243
 
 
4244
 
void CreateSchemaStatement::MergeFrom(const ::google::protobuf::Message& from) {
4245
 
  GOOGLE_CHECK_NE(&from, this);
4246
 
  const CreateSchemaStatement* source =
4247
 
    ::google::protobuf::internal::dynamic_cast_if_available<const CreateSchemaStatement*>(
4248
 
      &from);
4249
 
  if (source == NULL) {
4250
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
4251
 
  } else {
4252
 
    MergeFrom(*source);
4253
 
  }
4254
 
}
4255
 
 
4256
 
void CreateSchemaStatement::MergeFrom(const CreateSchemaStatement& from) {
4257
 
  GOOGLE_CHECK_NE(&from, this);
4258
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4259
 
    if (from._has_bit(0)) {
4260
 
      mutable_schema()->::drizzled::message::Schema::MergeFrom(from.schema());
4261
 
    }
4262
 
  }
4263
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
4264
 
}
4265
 
 
4266
 
void CreateSchemaStatement::CopyFrom(const ::google::protobuf::Message& from) {
4267
 
  if (&from == this) return;
4268
 
  Clear();
4269
 
  MergeFrom(from);
4270
 
}
4271
 
 
4272
 
void CreateSchemaStatement::CopyFrom(const CreateSchemaStatement& from) {
4273
 
  if (&from == this) return;
4274
 
  Clear();
4275
 
  MergeFrom(from);
4276
 
}
4277
 
 
4278
 
bool CreateSchemaStatement::IsInitialized() const {
4279
 
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
4280
 
  
4281
 
  if (has_schema()) {
4282
 
    if (!this->schema().IsInitialized()) return false;
4283
 
  }
4284
 
  return true;
4285
 
}
4286
 
 
4287
 
void CreateSchemaStatement::Swap(CreateSchemaStatement* other) {
4288
 
  if (other != this) {
4289
 
    std::swap(schema_, other->schema_);
4290
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
4291
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
4292
 
    std::swap(_cached_size_, other->_cached_size_);
4293
 
  }
4294
 
}
4295
 
 
4296
 
::google::protobuf::Metadata CreateSchemaStatement::GetMetadata() const {
4297
 
  protobuf_AssignDescriptorsOnce();
4298
 
  ::google::protobuf::Metadata metadata;
4299
 
  metadata.descriptor = CreateSchemaStatement_descriptor_;
4300
 
  metadata.reflection = CreateSchemaStatement_reflection_;
4301
 
  return metadata;
4302
 
}
4303
 
 
4304
 
 
4305
 
// ===================================================================
4306
 
 
4307
 
#ifndef _MSC_VER
4308
 
const int AlterSchemaStatement::kBeforeFieldNumber;
4309
 
const int AlterSchemaStatement::kAfterFieldNumber;
4310
 
#endif  // !_MSC_VER
4311
 
 
4312
 
AlterSchemaStatement::AlterSchemaStatement() {
4313
 
  SharedCtor();
4314
 
}
4315
 
 
4316
 
void AlterSchemaStatement::InitAsDefaultInstance() {
4317
 
  before_ = const_cast< ::drizzled::message::Schema*>(&::drizzled::message::Schema::default_instance());
4318
 
  after_ = const_cast< ::drizzled::message::Schema*>(&::drizzled::message::Schema::default_instance());
4319
 
}
4320
 
 
4321
 
AlterSchemaStatement::AlterSchemaStatement(const AlterSchemaStatement& from) {
4322
 
  SharedCtor();
4323
 
  MergeFrom(from);
4324
 
}
4325
 
 
4326
 
void AlterSchemaStatement::SharedCtor() {
4327
 
  _cached_size_ = 0;
4328
 
  before_ = NULL;
4329
 
  after_ = NULL;
4330
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
4331
 
}
4332
 
 
4333
 
AlterSchemaStatement::~AlterSchemaStatement() {
4334
 
  SharedDtor();
4335
 
}
4336
 
 
4337
 
void AlterSchemaStatement::SharedDtor() {
4338
 
  if (this != default_instance_) {
4339
 
    delete before_;
4340
 
    delete after_;
4341
 
  }
4342
 
}
4343
 
 
4344
 
const ::google::protobuf::Descriptor* AlterSchemaStatement::descriptor() {
4345
 
  protobuf_AssignDescriptorsOnce();
4346
 
  return AlterSchemaStatement_descriptor_;
4347
 
}
4348
 
 
4349
 
const AlterSchemaStatement& AlterSchemaStatement::default_instance() {
4350
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
4351
 
}
4352
 
 
4353
 
AlterSchemaStatement* AlterSchemaStatement::default_instance_ = NULL;
4354
 
 
4355
 
AlterSchemaStatement* AlterSchemaStatement::New() const {
4356
 
  return new AlterSchemaStatement;
4357
 
}
4358
 
 
4359
 
void AlterSchemaStatement::Clear() {
4360
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4361
 
    if (_has_bit(0)) {
4362
 
      if (before_ != NULL) before_->::drizzled::message::Schema::Clear();
4363
 
    }
4364
 
    if (_has_bit(1)) {
4365
 
      if (after_ != NULL) after_->::drizzled::message::Schema::Clear();
4366
 
    }
4367
 
  }
4368
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
4369
 
  mutable_unknown_fields()->Clear();
4370
 
}
4371
 
 
4372
 
bool AlterSchemaStatement::MergePartialFromCodedStream(
4373
 
    ::google::protobuf::io::CodedInputStream* input) {
4374
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
4375
 
  ::google::protobuf::uint32 tag;
4376
 
  while ((tag = input->ReadTag()) != 0) {
4377
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
4378
 
      // required .drizzled.message.Schema before = 1;
4379
 
      case 1: {
4380
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
4381
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
4382
 
          goto handle_uninterpreted;
4383
 
        }
4384
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
4385
 
             input, mutable_before()));
4386
 
        if (input->ExpectTag(18)) goto parse_after;
4387
 
        break;
4388
 
      }
4389
 
      
4390
 
      // required .drizzled.message.Schema after = 2;
4391
 
      case 2: {
4392
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
4393
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
4394
 
          goto handle_uninterpreted;
4395
 
        }
4396
 
       parse_after:
4397
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
4398
 
             input, mutable_after()));
4399
 
        if (input->ExpectAtEnd()) return true;
4400
 
        break;
4401
 
      }
4402
 
      
4403
 
      default: {
4404
 
      handle_uninterpreted:
4405
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4406
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
4407
 
          return true;
4408
 
        }
4409
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
4410
 
              input, tag, mutable_unknown_fields()));
4411
 
        break;
4412
 
      }
4413
 
    }
4414
 
  }
4415
 
  return true;
4416
 
#undef DO_
4417
 
}
4418
 
 
4419
 
void AlterSchemaStatement::SerializeWithCachedSizes(
4420
 
    ::google::protobuf::io::CodedOutputStream* output) const {
4421
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
4422
 
  if (raw_buffer != NULL) {
4423
 
    AlterSchemaStatement::SerializeWithCachedSizesToArray(raw_buffer);
4424
 
    return;
4425
 
  }
4426
 
  
4427
 
  // required .drizzled.message.Schema before = 1;
4428
 
  if (_has_bit(0)) {
4429
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
4430
 
      1, this->before(), output);
4431
 
  }
4432
 
  
4433
 
  // required .drizzled.message.Schema after = 2;
4434
 
  if (_has_bit(1)) {
4435
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
4436
 
      2, this->after(), output);
4437
 
  }
4438
 
  
4439
 
  if (!unknown_fields().empty()) {
4440
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
4441
 
        unknown_fields(), output);
4442
 
  }
4443
 
}
4444
 
 
4445
 
::google::protobuf::uint8* AlterSchemaStatement::SerializeWithCachedSizesToArray(
4446
 
    ::google::protobuf::uint8* target) const {
4447
 
  // required .drizzled.message.Schema before = 1;
4448
 
  if (_has_bit(0)) {
4449
 
    target = ::google::protobuf::internal::WireFormatLite::
4450
 
      WriteMessageNoVirtualToArray(
4451
 
        1, this->before(), target);
4452
 
  }
4453
 
  
4454
 
  // required .drizzled.message.Schema after = 2;
4455
 
  if (_has_bit(1)) {
4456
 
    target = ::google::protobuf::internal::WireFormatLite::
4457
 
      WriteMessageNoVirtualToArray(
4458
 
        2, this->after(), target);
4459
 
  }
4460
 
  
4461
 
  if (!unknown_fields().empty()) {
4462
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
4463
 
        unknown_fields(), target);
4464
 
  }
4465
 
  return target;
4466
 
}
4467
 
 
4468
 
int AlterSchemaStatement::ByteSize() const {
4469
 
  int total_size = 0;
4470
 
  
4471
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4472
 
    // required .drizzled.message.Schema before = 1;
4473
 
    if (has_before()) {
4474
 
      total_size += 1 +
4475
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
4476
 
          this->before());
4477
 
    }
4478
 
    
4479
 
    // required .drizzled.message.Schema after = 2;
4480
 
    if (has_after()) {
4481
 
      total_size += 1 +
4482
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
4483
 
          this->after());
4484
 
    }
4485
 
    
4486
 
  }
4487
 
  if (!unknown_fields().empty()) {
4488
 
    total_size +=
4489
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
4490
 
        unknown_fields());
4491
 
  }
4492
 
  _cached_size_ = total_size;
4493
 
  return total_size;
4494
 
}
4495
 
 
4496
 
void AlterSchemaStatement::MergeFrom(const ::google::protobuf::Message& from) {
4497
 
  GOOGLE_CHECK_NE(&from, this);
4498
 
  const AlterSchemaStatement* source =
4499
 
    ::google::protobuf::internal::dynamic_cast_if_available<const AlterSchemaStatement*>(
4500
 
      &from);
4501
 
  if (source == NULL) {
4502
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
4503
 
  } else {
4504
 
    MergeFrom(*source);
4505
 
  }
4506
 
}
4507
 
 
4508
 
void AlterSchemaStatement::MergeFrom(const AlterSchemaStatement& from) {
4509
 
  GOOGLE_CHECK_NE(&from, this);
4510
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4511
 
    if (from._has_bit(0)) {
4512
 
      mutable_before()->::drizzled::message::Schema::MergeFrom(from.before());
4513
 
    }
4514
 
    if (from._has_bit(1)) {
4515
 
      mutable_after()->::drizzled::message::Schema::MergeFrom(from.after());
4516
 
    }
4517
 
  }
4518
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
4519
 
}
4520
 
 
4521
 
void AlterSchemaStatement::CopyFrom(const ::google::protobuf::Message& from) {
4522
 
  if (&from == this) return;
4523
 
  Clear();
4524
 
  MergeFrom(from);
4525
 
}
4526
 
 
4527
 
void AlterSchemaStatement::CopyFrom(const AlterSchemaStatement& from) {
4528
 
  if (&from == this) return;
4529
 
  Clear();
4530
 
  MergeFrom(from);
4531
 
}
4532
 
 
4533
 
bool AlterSchemaStatement::IsInitialized() const {
4534
 
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
4535
 
  
4536
 
  if (has_before()) {
4537
 
    if (!this->before().IsInitialized()) return false;
4538
 
  }
4539
 
  if (has_after()) {
4540
 
    if (!this->after().IsInitialized()) return false;
4541
 
  }
4542
 
  return true;
4543
 
}
4544
 
 
4545
 
void AlterSchemaStatement::Swap(AlterSchemaStatement* other) {
4546
 
  if (other != this) {
4547
 
    std::swap(before_, other->before_);
4548
 
    std::swap(after_, other->after_);
4549
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
4550
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
4551
 
    std::swap(_cached_size_, other->_cached_size_);
4552
 
  }
4553
 
}
4554
 
 
4555
 
::google::protobuf::Metadata AlterSchemaStatement::GetMetadata() const {
4556
 
  protobuf_AssignDescriptorsOnce();
4557
 
  ::google::protobuf::Metadata metadata;
4558
 
  metadata.descriptor = AlterSchemaStatement_descriptor_;
4559
 
  metadata.reflection = AlterSchemaStatement_reflection_;
4560
 
  return metadata;
4561
 
}
4562
 
 
4563
 
 
4564
 
// ===================================================================
4565
 
 
4566
 
const ::std::string DropSchemaStatement::_default_schema_name_;
4567
 
#ifndef _MSC_VER
4568
 
const int DropSchemaStatement::kSchemaNameFieldNumber;
4569
 
#endif  // !_MSC_VER
4570
 
 
4571
 
DropSchemaStatement::DropSchemaStatement() {
4572
 
  SharedCtor();
4573
 
}
4574
 
 
4575
 
void DropSchemaStatement::InitAsDefaultInstance() {
4576
 
}
4577
 
 
4578
 
DropSchemaStatement::DropSchemaStatement(const DropSchemaStatement& from) {
4579
 
  SharedCtor();
4580
 
  MergeFrom(from);
4581
 
}
4582
 
 
4583
 
void DropSchemaStatement::SharedCtor() {
4584
 
  _cached_size_ = 0;
4585
 
  schema_name_ = const_cast< ::std::string*>(&_default_schema_name_);
4586
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
4587
 
}
4588
 
 
4589
 
DropSchemaStatement::~DropSchemaStatement() {
4590
 
  SharedDtor();
4591
 
}
4592
 
 
4593
 
void DropSchemaStatement::SharedDtor() {
4594
 
  if (schema_name_ != &_default_schema_name_) {
4595
 
    delete schema_name_;
4596
 
  }
4597
 
  if (this != default_instance_) {
4598
 
  }
4599
 
}
4600
 
 
4601
 
const ::google::protobuf::Descriptor* DropSchemaStatement::descriptor() {
4602
 
  protobuf_AssignDescriptorsOnce();
4603
 
  return DropSchemaStatement_descriptor_;
4604
 
}
4605
 
 
4606
 
const DropSchemaStatement& DropSchemaStatement::default_instance() {
4607
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
4608
 
}
4609
 
 
4610
 
DropSchemaStatement* DropSchemaStatement::default_instance_ = NULL;
4611
 
 
4612
 
DropSchemaStatement* DropSchemaStatement::New() const {
4613
 
  return new DropSchemaStatement;
4614
 
}
4615
 
 
4616
 
void DropSchemaStatement::Clear() {
4617
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4618
 
    if (_has_bit(0)) {
4619
 
      if (schema_name_ != &_default_schema_name_) {
4620
 
        schema_name_->clear();
4621
 
      }
4622
 
    }
4623
 
  }
4624
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
4625
 
  mutable_unknown_fields()->Clear();
4626
 
}
4627
 
 
4628
 
bool DropSchemaStatement::MergePartialFromCodedStream(
4629
 
    ::google::protobuf::io::CodedInputStream* input) {
4630
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
4631
 
  ::google::protobuf::uint32 tag;
4632
 
  while ((tag = input->ReadTag()) != 0) {
4633
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
4634
 
      // required string schema_name = 1;
4635
 
      case 1: {
4636
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
4637
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
4638
 
          goto handle_uninterpreted;
4639
 
        }
4640
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadString(
4641
 
              input, this->mutable_schema_name()));
4642
 
        ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4643
 
          this->schema_name().data(), this->schema_name().length(),
4644
 
          ::google::protobuf::internal::WireFormat::PARSE);
4645
 
        if (input->ExpectAtEnd()) return true;
4646
 
        break;
4647
 
      }
4648
 
      
4649
 
      default: {
4650
 
      handle_uninterpreted:
4651
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4652
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
4653
 
          return true;
4654
 
        }
4655
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
4656
 
              input, tag, mutable_unknown_fields()));
4657
 
        break;
4658
 
      }
4659
 
    }
4660
 
  }
4661
 
  return true;
4662
 
#undef DO_
4663
 
}
4664
 
 
4665
 
void DropSchemaStatement::SerializeWithCachedSizes(
4666
 
    ::google::protobuf::io::CodedOutputStream* output) const {
4667
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
4668
 
  if (raw_buffer != NULL) {
4669
 
    DropSchemaStatement::SerializeWithCachedSizesToArray(raw_buffer);
4670
 
    return;
4671
 
  }
4672
 
  
4673
 
  // required string schema_name = 1;
4674
 
  if (_has_bit(0)) {
4675
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4676
 
      this->schema_name().data(), this->schema_name().length(),
4677
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
4678
 
    ::google::protobuf::internal::WireFormatLite::WriteString(
4679
 
      1, this->schema_name(), output);
4680
 
  }
4681
 
  
4682
 
  if (!unknown_fields().empty()) {
4683
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
4684
 
        unknown_fields(), output);
4685
 
  }
4686
 
}
4687
 
 
4688
 
::google::protobuf::uint8* DropSchemaStatement::SerializeWithCachedSizesToArray(
4689
 
    ::google::protobuf::uint8* target) const {
4690
 
  // required string schema_name = 1;
4691
 
  if (_has_bit(0)) {
4692
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
4693
 
      this->schema_name().data(), this->schema_name().length(),
4694
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
4695
 
    target =
4696
 
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
4697
 
        1, this->schema_name(), target);
4698
 
  }
4699
 
  
4700
 
  if (!unknown_fields().empty()) {
4701
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
4702
 
        unknown_fields(), target);
4703
 
  }
4704
 
  return target;
4705
 
}
4706
 
 
4707
 
int DropSchemaStatement::ByteSize() const {
4708
 
  int total_size = 0;
4709
 
  
4710
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4711
 
    // required string schema_name = 1;
4712
 
    if (has_schema_name()) {
4713
 
      total_size += 1 +
4714
 
        ::google::protobuf::internal::WireFormatLite::StringSize(
4715
 
          this->schema_name());
4716
 
    }
4717
 
    
4718
 
  }
4719
 
  if (!unknown_fields().empty()) {
4720
 
    total_size +=
4721
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
4722
 
        unknown_fields());
4723
 
  }
4724
 
  _cached_size_ = total_size;
4725
 
  return total_size;
4726
 
}
4727
 
 
4728
 
void DropSchemaStatement::MergeFrom(const ::google::protobuf::Message& from) {
4729
 
  GOOGLE_CHECK_NE(&from, this);
4730
 
  const DropSchemaStatement* source =
4731
 
    ::google::protobuf::internal::dynamic_cast_if_available<const DropSchemaStatement*>(
4732
 
      &from);
4733
 
  if (source == NULL) {
4734
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
4735
 
  } else {
4736
 
    MergeFrom(*source);
4737
 
  }
4738
 
}
4739
 
 
4740
 
void DropSchemaStatement::MergeFrom(const DropSchemaStatement& from) {
4741
 
  GOOGLE_CHECK_NE(&from, this);
4742
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4743
 
    if (from._has_bit(0)) {
4744
 
      set_schema_name(from.schema_name());
4745
 
    }
4746
 
  }
4747
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
4748
 
}
4749
 
 
4750
 
void DropSchemaStatement::CopyFrom(const ::google::protobuf::Message& from) {
4751
 
  if (&from == this) return;
4752
 
  Clear();
4753
 
  MergeFrom(from);
4754
 
}
4755
 
 
4756
 
void DropSchemaStatement::CopyFrom(const DropSchemaStatement& from) {
4757
 
  if (&from == this) return;
4758
 
  Clear();
4759
 
  MergeFrom(from);
4760
 
}
4761
 
 
4762
 
bool DropSchemaStatement::IsInitialized() const {
4763
 
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
4764
 
  
4765
 
  return true;
4766
 
}
4767
 
 
4768
 
void DropSchemaStatement::Swap(DropSchemaStatement* other) {
4769
 
  if (other != this) {
4770
 
    std::swap(schema_name_, other->schema_name_);
4771
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
4772
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
4773
 
    std::swap(_cached_size_, other->_cached_size_);
4774
 
  }
4775
 
}
4776
 
 
4777
 
::google::protobuf::Metadata DropSchemaStatement::GetMetadata() const {
4778
 
  protobuf_AssignDescriptorsOnce();
4779
 
  ::google::protobuf::Metadata metadata;
4780
 
  metadata.descriptor = DropSchemaStatement_descriptor_;
4781
 
  metadata.reflection = DropSchemaStatement_reflection_;
4782
 
  return metadata;
4783
 
}
4784
 
 
4785
 
 
4786
 
// ===================================================================
4787
 
 
4788
 
#ifndef _MSC_VER
4789
 
const int CreateTableStatement::kTableFieldNumber;
4790
 
#endif  // !_MSC_VER
4791
 
 
4792
 
CreateTableStatement::CreateTableStatement() {
4793
 
  SharedCtor();
4794
 
}
4795
 
 
4796
 
void CreateTableStatement::InitAsDefaultInstance() {
4797
 
  table_ = const_cast< ::drizzled::message::Table*>(&::drizzled::message::Table::default_instance());
4798
 
}
4799
 
 
4800
 
CreateTableStatement::CreateTableStatement(const CreateTableStatement& from) {
4801
 
  SharedCtor();
4802
 
  MergeFrom(from);
4803
 
}
4804
 
 
4805
 
void CreateTableStatement::SharedCtor() {
4806
 
  _cached_size_ = 0;
4807
 
  table_ = NULL;
4808
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
4809
 
}
4810
 
 
4811
 
CreateTableStatement::~CreateTableStatement() {
4812
 
  SharedDtor();
4813
 
}
4814
 
 
4815
 
void CreateTableStatement::SharedDtor() {
4816
 
  if (this != default_instance_) {
4817
 
    delete table_;
4818
 
  }
4819
 
}
4820
 
 
4821
 
const ::google::protobuf::Descriptor* CreateTableStatement::descriptor() {
4822
 
  protobuf_AssignDescriptorsOnce();
4823
 
  return CreateTableStatement_descriptor_;
4824
 
}
4825
 
 
4826
 
const CreateTableStatement& CreateTableStatement::default_instance() {
4827
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
4828
 
}
4829
 
 
4830
 
CreateTableStatement* CreateTableStatement::default_instance_ = NULL;
4831
 
 
4832
 
CreateTableStatement* CreateTableStatement::New() const {
4833
 
  return new CreateTableStatement;
4834
 
}
4835
 
 
4836
 
void CreateTableStatement::Clear() {
4837
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4838
 
    if (_has_bit(0)) {
4839
 
      if (table_ != NULL) table_->::drizzled::message::Table::Clear();
4840
 
    }
4841
 
  }
4842
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
4843
 
  mutable_unknown_fields()->Clear();
4844
 
}
4845
 
 
4846
 
bool CreateTableStatement::MergePartialFromCodedStream(
4847
 
    ::google::protobuf::io::CodedInputStream* input) {
4848
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
4849
 
  ::google::protobuf::uint32 tag;
4850
 
  while ((tag = input->ReadTag()) != 0) {
4851
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
4852
 
      // required .drizzled.message.Table table = 1;
4853
 
      case 1: {
4854
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
4855
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
4856
 
          goto handle_uninterpreted;
4857
 
        }
4858
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
4859
 
             input, mutable_table()));
4860
 
        if (input->ExpectAtEnd()) return true;
4861
 
        break;
4862
 
      }
4863
 
      
4864
 
      default: {
4865
 
      handle_uninterpreted:
4866
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
4867
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
4868
 
          return true;
4869
 
        }
4870
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
4871
 
              input, tag, mutable_unknown_fields()));
4872
 
        break;
4873
 
      }
4874
 
    }
4875
 
  }
4876
 
  return true;
4877
 
#undef DO_
4878
 
}
4879
 
 
4880
 
void CreateTableStatement::SerializeWithCachedSizes(
4881
 
    ::google::protobuf::io::CodedOutputStream* output) const {
4882
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
4883
 
  if (raw_buffer != NULL) {
4884
 
    CreateTableStatement::SerializeWithCachedSizesToArray(raw_buffer);
4885
 
    return;
4886
 
  }
4887
 
  
4888
 
  // required .drizzled.message.Table table = 1;
4889
 
  if (_has_bit(0)) {
4890
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
4891
 
      1, this->table(), output);
4892
 
  }
4893
 
  
4894
 
  if (!unknown_fields().empty()) {
4895
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
4896
 
        unknown_fields(), output);
4897
 
  }
4898
 
}
4899
 
 
4900
 
::google::protobuf::uint8* CreateTableStatement::SerializeWithCachedSizesToArray(
4901
 
    ::google::protobuf::uint8* target) const {
4902
 
  // required .drizzled.message.Table table = 1;
4903
 
  if (_has_bit(0)) {
4904
 
    target = ::google::protobuf::internal::WireFormatLite::
4905
 
      WriteMessageNoVirtualToArray(
4906
 
        1, this->table(), target);
4907
 
  }
4908
 
  
4909
 
  if (!unknown_fields().empty()) {
4910
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
4911
 
        unknown_fields(), target);
4912
 
  }
4913
 
  return target;
4914
 
}
4915
 
 
4916
 
int CreateTableStatement::ByteSize() const {
4917
 
  int total_size = 0;
4918
 
  
4919
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4920
 
    // required .drizzled.message.Table table = 1;
4921
 
    if (has_table()) {
4922
 
      total_size += 1 +
4923
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
4924
 
          this->table());
4925
 
    }
4926
 
    
4927
 
  }
4928
 
  if (!unknown_fields().empty()) {
4929
 
    total_size +=
4930
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
4931
 
        unknown_fields());
4932
 
  }
4933
 
  _cached_size_ = total_size;
4934
 
  return total_size;
4935
 
}
4936
 
 
4937
 
void CreateTableStatement::MergeFrom(const ::google::protobuf::Message& from) {
4938
 
  GOOGLE_CHECK_NE(&from, this);
4939
 
  const CreateTableStatement* source =
4940
 
    ::google::protobuf::internal::dynamic_cast_if_available<const CreateTableStatement*>(
4941
 
      &from);
4942
 
  if (source == NULL) {
4943
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
4944
 
  } else {
4945
 
    MergeFrom(*source);
4946
 
  }
4947
 
}
4948
 
 
4949
 
void CreateTableStatement::MergeFrom(const CreateTableStatement& from) {
4950
 
  GOOGLE_CHECK_NE(&from, this);
4951
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
4952
 
    if (from._has_bit(0)) {
4953
 
      mutable_table()->::drizzled::message::Table::MergeFrom(from.table());
4954
 
    }
4955
 
  }
4956
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
4957
 
}
4958
 
 
4959
 
void CreateTableStatement::CopyFrom(const ::google::protobuf::Message& from) {
4960
 
  if (&from == this) return;
4961
 
  Clear();
4962
 
  MergeFrom(from);
4963
 
}
4964
 
 
4965
 
void CreateTableStatement::CopyFrom(const CreateTableStatement& from) {
4966
 
  if (&from == this) return;
4967
 
  Clear();
4968
 
  MergeFrom(from);
4969
 
}
4970
 
 
4971
 
bool CreateTableStatement::IsInitialized() const {
4972
 
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
4973
 
  
4974
 
  if (has_table()) {
4975
 
    if (!this->table().IsInitialized()) return false;
4976
 
  }
4977
 
  return true;
4978
 
}
4979
 
 
4980
 
void CreateTableStatement::Swap(CreateTableStatement* other) {
4981
 
  if (other != this) {
4982
 
    std::swap(table_, other->table_);
4983
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
4984
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
4985
 
    std::swap(_cached_size_, other->_cached_size_);
4986
 
  }
4987
 
}
4988
 
 
4989
 
::google::protobuf::Metadata CreateTableStatement::GetMetadata() const {
4990
 
  protobuf_AssignDescriptorsOnce();
4991
 
  ::google::protobuf::Metadata metadata;
4992
 
  metadata.descriptor = CreateTableStatement_descriptor_;
4993
 
  metadata.reflection = CreateTableStatement_reflection_;
4994
 
  return metadata;
4995
 
}
4996
 
 
4997
 
 
4998
 
// ===================================================================
4999
 
 
5000
 
#ifndef _MSC_VER
5001
 
const int AlterTableStatement::kBeforeFieldNumber;
5002
 
const int AlterTableStatement::kAfterFieldNumber;
5003
 
#endif  // !_MSC_VER
5004
 
 
5005
 
AlterTableStatement::AlterTableStatement() {
5006
 
  SharedCtor();
5007
 
}
5008
 
 
5009
 
void AlterTableStatement::InitAsDefaultInstance() {
5010
 
  before_ = const_cast< ::drizzled::message::Table*>(&::drizzled::message::Table::default_instance());
5011
 
  after_ = const_cast< ::drizzled::message::Table*>(&::drizzled::message::Table::default_instance());
5012
 
}
5013
 
 
5014
 
AlterTableStatement::AlterTableStatement(const AlterTableStatement& from) {
5015
 
  SharedCtor();
5016
 
  MergeFrom(from);
5017
 
}
5018
 
 
5019
 
void AlterTableStatement::SharedCtor() {
5020
 
  _cached_size_ = 0;
5021
 
  before_ = NULL;
5022
 
  after_ = NULL;
5023
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
5024
 
}
5025
 
 
5026
 
AlterTableStatement::~AlterTableStatement() {
5027
 
  SharedDtor();
5028
 
}
5029
 
 
5030
 
void AlterTableStatement::SharedDtor() {
5031
 
  if (this != default_instance_) {
5032
 
    delete before_;
5033
 
    delete after_;
5034
 
  }
5035
 
}
5036
 
 
5037
 
const ::google::protobuf::Descriptor* AlterTableStatement::descriptor() {
5038
 
  protobuf_AssignDescriptorsOnce();
5039
 
  return AlterTableStatement_descriptor_;
5040
 
}
5041
 
 
5042
 
const AlterTableStatement& AlterTableStatement::default_instance() {
5043
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
5044
 
}
5045
 
 
5046
 
AlterTableStatement* AlterTableStatement::default_instance_ = NULL;
5047
 
 
5048
 
AlterTableStatement* AlterTableStatement::New() const {
5049
 
  return new AlterTableStatement;
5050
 
}
5051
 
 
5052
 
void AlterTableStatement::Clear() {
5053
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5054
 
    if (_has_bit(0)) {
5055
 
      if (before_ != NULL) before_->::drizzled::message::Table::Clear();
5056
 
    }
5057
 
    if (_has_bit(1)) {
5058
 
      if (after_ != NULL) after_->::drizzled::message::Table::Clear();
5059
 
    }
5060
 
  }
5061
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
5062
 
  mutable_unknown_fields()->Clear();
5063
 
}
5064
 
 
5065
 
bool AlterTableStatement::MergePartialFromCodedStream(
5066
 
    ::google::protobuf::io::CodedInputStream* input) {
5067
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
5068
 
  ::google::protobuf::uint32 tag;
5069
 
  while ((tag = input->ReadTag()) != 0) {
5070
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
5071
 
      // required .drizzled.message.Table before = 1;
5072
 
      case 1: {
5073
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
5074
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
5075
 
          goto handle_uninterpreted;
5076
 
        }
5077
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
5078
 
             input, mutable_before()));
5079
 
        if (input->ExpectTag(18)) goto parse_after;
5080
 
        break;
5081
 
      }
5082
 
      
5083
 
      // required .drizzled.message.Table after = 2;
5084
 
      case 2: {
5085
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
5086
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
5087
 
          goto handle_uninterpreted;
5088
 
        }
5089
 
       parse_after:
5090
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
5091
 
             input, mutable_after()));
5092
 
        if (input->ExpectAtEnd()) return true;
5093
 
        break;
5094
 
      }
5095
 
      
5096
 
      default: {
5097
 
      handle_uninterpreted:
5098
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5099
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
5100
 
          return true;
5101
 
        }
5102
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
5103
 
              input, tag, mutable_unknown_fields()));
5104
 
        break;
5105
 
      }
5106
 
    }
5107
 
  }
5108
 
  return true;
5109
 
#undef DO_
5110
 
}
5111
 
 
5112
 
void AlterTableStatement::SerializeWithCachedSizes(
5113
 
    ::google::protobuf::io::CodedOutputStream* output) const {
5114
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
5115
 
  if (raw_buffer != NULL) {
5116
 
    AlterTableStatement::SerializeWithCachedSizesToArray(raw_buffer);
5117
 
    return;
5118
 
  }
5119
 
  
5120
 
  // required .drizzled.message.Table before = 1;
5121
 
  if (_has_bit(0)) {
5122
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
5123
 
      1, this->before(), output);
5124
 
  }
5125
 
  
5126
 
  // required .drizzled.message.Table after = 2;
5127
 
  if (_has_bit(1)) {
5128
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
5129
 
      2, this->after(), output);
5130
 
  }
5131
 
  
5132
 
  if (!unknown_fields().empty()) {
5133
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
5134
 
        unknown_fields(), output);
5135
 
  }
5136
 
}
5137
 
 
5138
 
::google::protobuf::uint8* AlterTableStatement::SerializeWithCachedSizesToArray(
5139
 
    ::google::protobuf::uint8* target) const {
5140
 
  // required .drizzled.message.Table before = 1;
5141
 
  if (_has_bit(0)) {
5142
 
    target = ::google::protobuf::internal::WireFormatLite::
5143
 
      WriteMessageNoVirtualToArray(
5144
 
        1, this->before(), target);
5145
 
  }
5146
 
  
5147
 
  // required .drizzled.message.Table after = 2;
5148
 
  if (_has_bit(1)) {
5149
 
    target = ::google::protobuf::internal::WireFormatLite::
5150
 
      WriteMessageNoVirtualToArray(
5151
 
        2, this->after(), target);
5152
 
  }
5153
 
  
5154
 
  if (!unknown_fields().empty()) {
5155
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
5156
 
        unknown_fields(), target);
5157
 
  }
5158
 
  return target;
5159
 
}
5160
 
 
5161
 
int AlterTableStatement::ByteSize() const {
5162
 
  int total_size = 0;
5163
 
  
5164
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5165
 
    // required .drizzled.message.Table before = 1;
5166
 
    if (has_before()) {
5167
 
      total_size += 1 +
5168
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
5169
 
          this->before());
5170
 
    }
5171
 
    
5172
 
    // required .drizzled.message.Table after = 2;
5173
 
    if (has_after()) {
5174
 
      total_size += 1 +
5175
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
5176
 
          this->after());
5177
 
    }
5178
 
    
5179
 
  }
5180
 
  if (!unknown_fields().empty()) {
5181
 
    total_size +=
5182
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
5183
 
        unknown_fields());
5184
 
  }
5185
 
  _cached_size_ = total_size;
5186
 
  return total_size;
5187
 
}
5188
 
 
5189
 
void AlterTableStatement::MergeFrom(const ::google::protobuf::Message& from) {
5190
 
  GOOGLE_CHECK_NE(&from, this);
5191
 
  const AlterTableStatement* source =
5192
 
    ::google::protobuf::internal::dynamic_cast_if_available<const AlterTableStatement*>(
5193
 
      &from);
5194
 
  if (source == NULL) {
5195
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
5196
 
  } else {
5197
 
    MergeFrom(*source);
5198
 
  }
5199
 
}
5200
 
 
5201
 
void AlterTableStatement::MergeFrom(const AlterTableStatement& from) {
5202
 
  GOOGLE_CHECK_NE(&from, this);
5203
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5204
 
    if (from._has_bit(0)) {
5205
 
      mutable_before()->::drizzled::message::Table::MergeFrom(from.before());
5206
 
    }
5207
 
    if (from._has_bit(1)) {
5208
 
      mutable_after()->::drizzled::message::Table::MergeFrom(from.after());
5209
 
    }
5210
 
  }
5211
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
5212
 
}
5213
 
 
5214
 
void AlterTableStatement::CopyFrom(const ::google::protobuf::Message& from) {
5215
 
  if (&from == this) return;
5216
 
  Clear();
5217
 
  MergeFrom(from);
5218
 
}
5219
 
 
5220
 
void AlterTableStatement::CopyFrom(const AlterTableStatement& from) {
5221
 
  if (&from == this) return;
5222
 
  Clear();
5223
 
  MergeFrom(from);
5224
 
}
5225
 
 
5226
 
bool AlterTableStatement::IsInitialized() const {
5227
 
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
5228
 
  
5229
 
  if (has_before()) {
5230
 
    if (!this->before().IsInitialized()) return false;
5231
 
  }
5232
 
  if (has_after()) {
5233
 
    if (!this->after().IsInitialized()) return false;
5234
 
  }
5235
 
  return true;
5236
 
}
5237
 
 
5238
 
void AlterTableStatement::Swap(AlterTableStatement* other) {
5239
 
  if (other != this) {
5240
 
    std::swap(before_, other->before_);
5241
 
    std::swap(after_, other->after_);
5242
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
5243
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
5244
 
    std::swap(_cached_size_, other->_cached_size_);
5245
 
  }
5246
 
}
5247
 
 
5248
 
::google::protobuf::Metadata AlterTableStatement::GetMetadata() const {
5249
 
  protobuf_AssignDescriptorsOnce();
5250
 
  ::google::protobuf::Metadata metadata;
5251
 
  metadata.descriptor = AlterTableStatement_descriptor_;
5252
 
  metadata.reflection = AlterTableStatement_reflection_;
5253
 
  return metadata;
5254
 
}
5255
 
 
5256
 
 
5257
 
// ===================================================================
5258
 
 
5259
 
#ifndef _MSC_VER
5260
 
const int DropTableStatement::kTableMetadataFieldNumber;
5261
 
const int DropTableStatement::kIfExistsClauseFieldNumber;
5262
 
#endif  // !_MSC_VER
5263
 
 
5264
 
DropTableStatement::DropTableStatement() {
5265
 
  SharedCtor();
5266
 
}
5267
 
 
5268
 
void DropTableStatement::InitAsDefaultInstance() {
5269
 
  table_metadata_ = const_cast< ::drizzled::message::TableMetadata*>(&::drizzled::message::TableMetadata::default_instance());
5270
 
}
5271
 
 
5272
 
DropTableStatement::DropTableStatement(const DropTableStatement& from) {
5273
 
  SharedCtor();
5274
 
  MergeFrom(from);
5275
 
}
5276
 
 
5277
 
void DropTableStatement::SharedCtor() {
5278
 
  _cached_size_ = 0;
5279
 
  table_metadata_ = NULL;
5280
 
  if_exists_clause_ = false;
5281
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
5282
 
}
5283
 
 
5284
 
DropTableStatement::~DropTableStatement() {
5285
 
  SharedDtor();
5286
 
}
5287
 
 
5288
 
void DropTableStatement::SharedDtor() {
5289
 
  if (this != default_instance_) {
5290
 
    delete table_metadata_;
5291
 
  }
5292
 
}
5293
 
 
5294
 
const ::google::protobuf::Descriptor* DropTableStatement::descriptor() {
5295
 
  protobuf_AssignDescriptorsOnce();
5296
 
  return DropTableStatement_descriptor_;
5297
 
}
5298
 
 
5299
 
const DropTableStatement& DropTableStatement::default_instance() {
5300
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
5301
 
}
5302
 
 
5303
 
DropTableStatement* DropTableStatement::default_instance_ = NULL;
5304
 
 
5305
 
DropTableStatement* DropTableStatement::New() const {
5306
 
  return new DropTableStatement;
5307
 
}
5308
 
 
5309
 
void DropTableStatement::Clear() {
5310
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5311
 
    if (_has_bit(0)) {
5312
 
      if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
5313
 
    }
5314
 
    if_exists_clause_ = false;
5315
 
  }
5316
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
5317
 
  mutable_unknown_fields()->Clear();
5318
 
}
5319
 
 
5320
 
bool DropTableStatement::MergePartialFromCodedStream(
5321
 
    ::google::protobuf::io::CodedInputStream* input) {
5322
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
5323
 
  ::google::protobuf::uint32 tag;
5324
 
  while ((tag = input->ReadTag()) != 0) {
5325
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
5326
 
      // required .drizzled.message.TableMetadata table_metadata = 1;
5327
 
      case 1: {
5328
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
5329
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
5330
 
          goto handle_uninterpreted;
5331
 
        }
5332
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
5333
 
             input, mutable_table_metadata()));
5334
 
        if (input->ExpectTag(16)) goto parse_if_exists_clause;
5335
 
        break;
5336
 
      }
5337
 
      
5338
 
      // optional bool if_exists_clause = 2;
5339
 
      case 2: {
5340
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
5341
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
5342
 
          goto handle_uninterpreted;
5343
 
        }
5344
 
       parse_if_exists_clause:
5345
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadBool(
5346
 
              input, &if_exists_clause_));
5347
 
        _set_bit(1);
5348
 
        if (input->ExpectAtEnd()) return true;
5349
 
        break;
5350
 
      }
5351
 
      
5352
 
      default: {
5353
 
      handle_uninterpreted:
5354
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5355
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
5356
 
          return true;
5357
 
        }
5358
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
5359
 
              input, tag, mutable_unknown_fields()));
5360
 
        break;
5361
 
      }
5362
 
    }
5363
 
  }
5364
 
  return true;
5365
 
#undef DO_
5366
 
}
5367
 
 
5368
 
void DropTableStatement::SerializeWithCachedSizes(
5369
 
    ::google::protobuf::io::CodedOutputStream* output) const {
5370
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
5371
 
  if (raw_buffer != NULL) {
5372
 
    DropTableStatement::SerializeWithCachedSizesToArray(raw_buffer);
5373
 
    return;
5374
 
  }
5375
 
  
5376
 
  // required .drizzled.message.TableMetadata table_metadata = 1;
5377
 
  if (_has_bit(0)) {
5378
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
5379
 
      1, this->table_metadata(), output);
5380
 
  }
5381
 
  
5382
 
  // optional bool if_exists_clause = 2;
5383
 
  if (_has_bit(1)) {
5384
 
    ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->if_exists_clause(), output);
5385
 
  }
5386
 
  
5387
 
  if (!unknown_fields().empty()) {
5388
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
5389
 
        unknown_fields(), output);
5390
 
  }
5391
 
}
5392
 
 
5393
 
::google::protobuf::uint8* DropTableStatement::SerializeWithCachedSizesToArray(
5394
 
    ::google::protobuf::uint8* target) const {
5395
 
  // required .drizzled.message.TableMetadata table_metadata = 1;
5396
 
  if (_has_bit(0)) {
5397
 
    target = ::google::protobuf::internal::WireFormatLite::
5398
 
      WriteMessageNoVirtualToArray(
5399
 
        1, this->table_metadata(), target);
5400
 
  }
5401
 
  
5402
 
  // optional bool if_exists_clause = 2;
5403
 
  if (_has_bit(1)) {
5404
 
    target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->if_exists_clause(), target);
5405
 
  }
5406
 
  
5407
 
  if (!unknown_fields().empty()) {
5408
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
5409
 
        unknown_fields(), target);
5410
 
  }
5411
 
  return target;
5412
 
}
5413
 
 
5414
 
int DropTableStatement::ByteSize() const {
5415
 
  int total_size = 0;
5416
 
  
5417
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5418
 
    // required .drizzled.message.TableMetadata table_metadata = 1;
5419
 
    if (has_table_metadata()) {
5420
 
      total_size += 1 +
5421
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
5422
 
          this->table_metadata());
5423
 
    }
5424
 
    
5425
 
    // optional bool if_exists_clause = 2;
5426
 
    if (has_if_exists_clause()) {
5427
 
      total_size += 1 + 1;
5428
 
    }
5429
 
    
5430
 
  }
5431
 
  if (!unknown_fields().empty()) {
5432
 
    total_size +=
5433
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
5434
 
        unknown_fields());
5435
 
  }
5436
 
  _cached_size_ = total_size;
5437
 
  return total_size;
5438
 
}
5439
 
 
5440
 
void DropTableStatement::MergeFrom(const ::google::protobuf::Message& from) {
5441
 
  GOOGLE_CHECK_NE(&from, this);
5442
 
  const DropTableStatement* source =
5443
 
    ::google::protobuf::internal::dynamic_cast_if_available<const DropTableStatement*>(
5444
 
      &from);
5445
 
  if (source == NULL) {
5446
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
5447
 
  } else {
5448
 
    MergeFrom(*source);
5449
 
  }
5450
 
}
5451
 
 
5452
 
void DropTableStatement::MergeFrom(const DropTableStatement& from) {
5453
 
  GOOGLE_CHECK_NE(&from, this);
5454
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5455
 
    if (from._has_bit(0)) {
5456
 
      mutable_table_metadata()->::drizzled::message::TableMetadata::MergeFrom(from.table_metadata());
5457
 
    }
5458
 
    if (from._has_bit(1)) {
5459
 
      set_if_exists_clause(from.if_exists_clause());
5460
 
    }
5461
 
  }
5462
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
5463
 
}
5464
 
 
5465
 
void DropTableStatement::CopyFrom(const ::google::protobuf::Message& from) {
5466
 
  if (&from == this) return;
5467
 
  Clear();
5468
 
  MergeFrom(from);
5469
 
}
5470
 
 
5471
 
void DropTableStatement::CopyFrom(const DropTableStatement& from) {
5472
 
  if (&from == this) return;
5473
 
  Clear();
5474
 
  MergeFrom(from);
5475
 
}
5476
 
 
5477
 
bool DropTableStatement::IsInitialized() const {
5478
 
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
5479
 
  
5480
 
  if (has_table_metadata()) {
5481
 
    if (!this->table_metadata().IsInitialized()) return false;
5482
 
  }
5483
 
  return true;
5484
 
}
5485
 
 
5486
 
void DropTableStatement::Swap(DropTableStatement* other) {
5487
 
  if (other != this) {
5488
 
    std::swap(table_metadata_, other->table_metadata_);
5489
 
    std::swap(if_exists_clause_, other->if_exists_clause_);
5490
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
5491
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
5492
 
    std::swap(_cached_size_, other->_cached_size_);
5493
 
  }
5494
 
}
5495
 
 
5496
 
::google::protobuf::Metadata DropTableStatement::GetMetadata() const {
5497
 
  protobuf_AssignDescriptorsOnce();
5498
 
  ::google::protobuf::Metadata metadata;
5499
 
  metadata.descriptor = DropTableStatement_descriptor_;
5500
 
  metadata.reflection = DropTableStatement_reflection_;
5501
 
  return metadata;
5502
 
}
5503
 
 
5504
 
 
5505
 
// ===================================================================
5506
 
 
5507
 
const ::std::string SetVariableStatement::_default_variable_value_;
5508
 
#ifndef _MSC_VER
5509
 
const int SetVariableStatement::kVariableMetadataFieldNumber;
5510
 
const int SetVariableStatement::kVariableValueFieldNumber;
5511
 
#endif  // !_MSC_VER
5512
 
 
5513
 
SetVariableStatement::SetVariableStatement() {
5514
 
  SharedCtor();
5515
 
}
5516
 
 
5517
 
void SetVariableStatement::InitAsDefaultInstance() {
5518
 
  variable_metadata_ = const_cast< ::drizzled::message::FieldMetadata*>(&::drizzled::message::FieldMetadata::default_instance());
5519
 
}
5520
 
 
5521
 
SetVariableStatement::SetVariableStatement(const SetVariableStatement& from) {
5522
 
  SharedCtor();
5523
 
  MergeFrom(from);
5524
 
}
5525
 
 
5526
 
void SetVariableStatement::SharedCtor() {
5527
 
  _cached_size_ = 0;
5528
 
  variable_metadata_ = NULL;
5529
 
  variable_value_ = const_cast< ::std::string*>(&_default_variable_value_);
5530
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
5531
 
}
5532
 
 
5533
 
SetVariableStatement::~SetVariableStatement() {
5534
 
  SharedDtor();
5535
 
}
5536
 
 
5537
 
void SetVariableStatement::SharedDtor() {
5538
 
  if (variable_value_ != &_default_variable_value_) {
5539
 
    delete variable_value_;
5540
 
  }
5541
 
  if (this != default_instance_) {
5542
 
    delete variable_metadata_;
5543
 
  }
5544
 
}
5545
 
 
5546
 
const ::google::protobuf::Descriptor* SetVariableStatement::descriptor() {
5547
 
  protobuf_AssignDescriptorsOnce();
5548
 
  return SetVariableStatement_descriptor_;
5549
 
}
5550
 
 
5551
 
const SetVariableStatement& SetVariableStatement::default_instance() {
5552
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
5553
 
}
5554
 
 
5555
 
SetVariableStatement* SetVariableStatement::default_instance_ = NULL;
5556
 
 
5557
 
SetVariableStatement* SetVariableStatement::New() const {
5558
 
  return new SetVariableStatement;
5559
 
}
5560
 
 
5561
 
void SetVariableStatement::Clear() {
5562
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5563
 
    if (_has_bit(0)) {
5564
 
      if (variable_metadata_ != NULL) variable_metadata_->::drizzled::message::FieldMetadata::Clear();
5565
 
    }
5566
 
    if (_has_bit(1)) {
5567
 
      if (variable_value_ != &_default_variable_value_) {
5568
 
        variable_value_->clear();
5569
 
      }
5570
 
    }
5571
 
  }
5572
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
5573
 
  mutable_unknown_fields()->Clear();
5574
 
}
5575
 
 
5576
 
bool SetVariableStatement::MergePartialFromCodedStream(
5577
 
    ::google::protobuf::io::CodedInputStream* input) {
5578
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
5579
 
  ::google::protobuf::uint32 tag;
5580
 
  while ((tag = input->ReadTag()) != 0) {
5581
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
5582
 
      // required .drizzled.message.FieldMetadata variable_metadata = 1;
5583
 
      case 1: {
5584
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
5585
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
5586
 
          goto handle_uninterpreted;
5587
 
        }
5588
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
5589
 
             input, mutable_variable_metadata()));
5590
 
        if (input->ExpectTag(18)) goto parse_variable_value;
5591
 
        break;
5592
 
      }
5593
 
      
5594
 
      // required bytes variable_value = 2;
5595
 
      case 2: {
5596
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
5597
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
5598
 
          goto handle_uninterpreted;
5599
 
        }
5600
 
       parse_variable_value:
5601
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
5602
 
              input, this->mutable_variable_value()));
5603
 
        if (input->ExpectAtEnd()) return true;
5604
 
        break;
5605
 
      }
5606
 
      
5607
 
      default: {
5608
 
      handle_uninterpreted:
5609
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
5610
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
5611
 
          return true;
5612
 
        }
5613
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
5614
 
              input, tag, mutable_unknown_fields()));
5615
 
        break;
5616
 
      }
5617
 
    }
5618
 
  }
5619
 
  return true;
5620
 
#undef DO_
5621
 
}
5622
 
 
5623
 
void SetVariableStatement::SerializeWithCachedSizes(
5624
 
    ::google::protobuf::io::CodedOutputStream* output) const {
5625
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
5626
 
  if (raw_buffer != NULL) {
5627
 
    SetVariableStatement::SerializeWithCachedSizesToArray(raw_buffer);
5628
 
    return;
5629
 
  }
5630
 
  
5631
 
  // required .drizzled.message.FieldMetadata variable_metadata = 1;
5632
 
  if (_has_bit(0)) {
5633
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
5634
 
      1, this->variable_metadata(), output);
5635
 
  }
5636
 
  
5637
 
  // required bytes variable_value = 2;
5638
 
  if (_has_bit(1)) {
5639
 
    ::google::protobuf::internal::WireFormatLite::WriteBytes(
5640
 
      2, this->variable_value(), output);
5641
 
  }
5642
 
  
5643
 
  if (!unknown_fields().empty()) {
5644
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
5645
 
        unknown_fields(), output);
5646
 
  }
5647
 
}
5648
 
 
5649
 
::google::protobuf::uint8* SetVariableStatement::SerializeWithCachedSizesToArray(
5650
 
    ::google::protobuf::uint8* target) const {
5651
 
  // required .drizzled.message.FieldMetadata variable_metadata = 1;
5652
 
  if (_has_bit(0)) {
5653
 
    target = ::google::protobuf::internal::WireFormatLite::
5654
 
      WriteMessageNoVirtualToArray(
5655
 
        1, this->variable_metadata(), target);
5656
 
  }
5657
 
  
5658
 
  // required bytes variable_value = 2;
5659
 
  if (_has_bit(1)) {
5660
 
    target =
5661
 
      ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
5662
 
        2, this->variable_value(), target);
5663
 
  }
5664
 
  
5665
 
  if (!unknown_fields().empty()) {
5666
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
5667
 
        unknown_fields(), target);
5668
 
  }
5669
 
  return target;
5670
 
}
5671
 
 
5672
 
int SetVariableStatement::ByteSize() const {
5673
 
  int total_size = 0;
5674
 
  
5675
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5676
 
    // required .drizzled.message.FieldMetadata variable_metadata = 1;
5677
 
    if (has_variable_metadata()) {
5678
 
      total_size += 1 +
5679
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
5680
 
          this->variable_metadata());
5681
 
    }
5682
 
    
5683
 
    // required bytes variable_value = 2;
5684
 
    if (has_variable_value()) {
5685
 
      total_size += 1 +
5686
 
        ::google::protobuf::internal::WireFormatLite::BytesSize(
5687
 
          this->variable_value());
5688
 
    }
5689
 
    
5690
 
  }
5691
 
  if (!unknown_fields().empty()) {
5692
 
    total_size +=
5693
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
5694
 
        unknown_fields());
5695
 
  }
5696
 
  _cached_size_ = total_size;
5697
 
  return total_size;
5698
 
}
5699
 
 
5700
 
void SetVariableStatement::MergeFrom(const ::google::protobuf::Message& from) {
5701
 
  GOOGLE_CHECK_NE(&from, this);
5702
 
  const SetVariableStatement* source =
5703
 
    ::google::protobuf::internal::dynamic_cast_if_available<const SetVariableStatement*>(
5704
 
      &from);
5705
 
  if (source == NULL) {
5706
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
5707
 
  } else {
5708
 
    MergeFrom(*source);
5709
 
  }
5710
 
}
5711
 
 
5712
 
void SetVariableStatement::MergeFrom(const SetVariableStatement& from) {
5713
 
  GOOGLE_CHECK_NE(&from, this);
5714
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5715
 
    if (from._has_bit(0)) {
5716
 
      mutable_variable_metadata()->::drizzled::message::FieldMetadata::MergeFrom(from.variable_metadata());
5717
 
    }
5718
 
    if (from._has_bit(1)) {
5719
 
      set_variable_value(from.variable_value());
5720
 
    }
5721
 
  }
5722
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
5723
 
}
5724
 
 
5725
 
void SetVariableStatement::CopyFrom(const ::google::protobuf::Message& from) {
5726
 
  if (&from == this) return;
5727
 
  Clear();
5728
 
  MergeFrom(from);
5729
 
}
5730
 
 
5731
 
void SetVariableStatement::CopyFrom(const SetVariableStatement& from) {
5732
 
  if (&from == this) return;
5733
 
  Clear();
5734
 
  MergeFrom(from);
5735
 
}
5736
 
 
5737
 
bool SetVariableStatement::IsInitialized() const {
5738
 
  if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
5739
 
  
5740
 
  if (has_variable_metadata()) {
5741
 
    if (!this->variable_metadata().IsInitialized()) return false;
5742
 
  }
5743
 
  return true;
5744
 
}
5745
 
 
5746
 
void SetVariableStatement::Swap(SetVariableStatement* other) {
5747
 
  if (other != this) {
5748
 
    std::swap(variable_metadata_, other->variable_metadata_);
5749
 
    std::swap(variable_value_, other->variable_value_);
5750
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
5751
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
5752
 
    std::swap(_cached_size_, other->_cached_size_);
5753
 
  }
5754
 
}
5755
 
 
5756
 
::google::protobuf::Metadata SetVariableStatement::GetMetadata() const {
5757
 
  protobuf_AssignDescriptorsOnce();
5758
 
  ::google::protobuf::Metadata metadata;
5759
 
  metadata.descriptor = SetVariableStatement_descriptor_;
5760
 
  metadata.reflection = SetVariableStatement_reflection_;
5761
 
  return metadata;
5762
 
}
5763
 
 
5764
 
 
5765
 
// ===================================================================
5766
 
 
5767
 
const ::google::protobuf::EnumDescriptor* Statement_Type_descriptor() {
5768
 
  protobuf_AssignDescriptorsOnce();
5769
 
  return Statement_Type_descriptor_;
5770
 
}
5771
 
bool Statement_Type_IsValid(int value) {
5772
 
  switch(value) {
5773
 
    case 0:
5774
 
    case 1:
5775
 
    case 2:
5776
 
    case 3:
5777
 
    case 4:
5778
 
    case 5:
5779
 
    case 6:
5780
 
    case 7:
5781
 
    case 8:
5782
 
    case 9:
5783
 
    case 10:
5784
 
    case 98:
5785
 
    case 99:
5786
 
      return true;
5787
 
    default:
5788
 
      return false;
5789
 
  }
5790
 
}
5791
 
 
5792
 
#ifndef _MSC_VER
5793
 
const Statement_Type Statement::ROLLBACK;
5794
 
const Statement_Type Statement::INSERT;
5795
 
const Statement_Type Statement::DELETE;
5796
 
const Statement_Type Statement::UPDATE;
5797
 
const Statement_Type Statement::TRUNCATE_TABLE;
5798
 
const Statement_Type Statement::CREATE_SCHEMA;
5799
 
const Statement_Type Statement::ALTER_SCHEMA;
5800
 
const Statement_Type Statement::DROP_SCHEMA;
5801
 
const Statement_Type Statement::CREATE_TABLE;
5802
 
const Statement_Type Statement::ALTER_TABLE;
5803
 
const Statement_Type Statement::DROP_TABLE;
5804
 
const Statement_Type Statement::SET_VARIABLE;
5805
 
const Statement_Type Statement::RAW_SQL;
5806
 
const Statement_Type Statement::Type_MIN;
5807
 
const Statement_Type Statement::Type_MAX;
5808
 
#endif  // _MSC_VER
5809
 
const ::std::string Statement::_default_sql_;
5810
 
#ifndef _MSC_VER
5811
 
const int Statement::kTypeFieldNumber;
5812
 
const int Statement::kStartTimestampFieldNumber;
5813
 
const int Statement::kEndTimestampFieldNumber;
5814
 
const int Statement::kSqlFieldNumber;
5815
 
const int Statement::kInsertHeaderFieldNumber;
5816
 
const int Statement::kInsertDataFieldNumber;
5817
 
const int Statement::kUpdateHeaderFieldNumber;
5818
 
const int Statement::kUpdateDataFieldNumber;
5819
 
const int Statement::kDeleteHeaderFieldNumber;
5820
 
const int Statement::kDeleteDataFieldNumber;
5821
 
const int Statement::kTruncateTableStatementFieldNumber;
5822
 
const int Statement::kCreateSchemaStatementFieldNumber;
5823
 
const int Statement::kDropSchemaStatementFieldNumber;
5824
 
const int Statement::kAlterSchemaStatementFieldNumber;
5825
 
const int Statement::kCreateTableStatementFieldNumber;
5826
 
const int Statement::kAlterTableStatementFieldNumber;
5827
 
const int Statement::kDropTableStatementFieldNumber;
5828
 
const int Statement::kSetVariableStatementFieldNumber;
5829
 
#endif  // !_MSC_VER
5830
 
 
5831
 
Statement::Statement() {
5832
 
  SharedCtor();
5833
 
}
5834
 
 
5835
 
void Statement::InitAsDefaultInstance() {
5836
 
  insert_header_ = const_cast< ::drizzled::message::InsertHeader*>(&::drizzled::message::InsertHeader::default_instance());
5837
 
  insert_data_ = const_cast< ::drizzled::message::InsertData*>(&::drizzled::message::InsertData::default_instance());
5838
 
  update_header_ = const_cast< ::drizzled::message::UpdateHeader*>(&::drizzled::message::UpdateHeader::default_instance());
5839
 
  update_data_ = const_cast< ::drizzled::message::UpdateData*>(&::drizzled::message::UpdateData::default_instance());
5840
 
  delete_header_ = const_cast< ::drizzled::message::DeleteHeader*>(&::drizzled::message::DeleteHeader::default_instance());
5841
 
  delete_data_ = const_cast< ::drizzled::message::DeleteData*>(&::drizzled::message::DeleteData::default_instance());
5842
 
  truncate_table_statement_ = const_cast< ::drizzled::message::TruncateTableStatement*>(&::drizzled::message::TruncateTableStatement::default_instance());
5843
 
  create_schema_statement_ = const_cast< ::drizzled::message::CreateSchemaStatement*>(&::drizzled::message::CreateSchemaStatement::default_instance());
5844
 
  drop_schema_statement_ = const_cast< ::drizzled::message::DropSchemaStatement*>(&::drizzled::message::DropSchemaStatement::default_instance());
5845
 
  alter_schema_statement_ = const_cast< ::drizzled::message::AlterSchemaStatement*>(&::drizzled::message::AlterSchemaStatement::default_instance());
5846
 
  create_table_statement_ = const_cast< ::drizzled::message::CreateTableStatement*>(&::drizzled::message::CreateTableStatement::default_instance());
5847
 
  alter_table_statement_ = const_cast< ::drizzled::message::AlterTableStatement*>(&::drizzled::message::AlterTableStatement::default_instance());
5848
 
  drop_table_statement_ = const_cast< ::drizzled::message::DropTableStatement*>(&::drizzled::message::DropTableStatement::default_instance());
5849
 
  set_variable_statement_ = const_cast< ::drizzled::message::SetVariableStatement*>(&::drizzled::message::SetVariableStatement::default_instance());
5850
 
}
5851
 
 
5852
 
Statement::Statement(const Statement& from) {
5853
 
  SharedCtor();
5854
 
  MergeFrom(from);
5855
 
}
5856
 
 
5857
 
void Statement::SharedCtor() {
5858
 
  _cached_size_ = 0;
5859
 
  type_ = 0;
5860
 
  start_timestamp_ = GOOGLE_ULONGLONG(0);
5861
 
  end_timestamp_ = GOOGLE_ULONGLONG(0);
5862
 
  sql_ = const_cast< ::std::string*>(&_default_sql_);
5863
 
  insert_header_ = NULL;
5864
 
  insert_data_ = NULL;
5865
 
  update_header_ = NULL;
5866
 
  update_data_ = NULL;
5867
 
  delete_header_ = NULL;
5868
 
  delete_data_ = NULL;
5869
 
  truncate_table_statement_ = NULL;
5870
 
  create_schema_statement_ = NULL;
5871
 
  drop_schema_statement_ = NULL;
5872
 
  alter_schema_statement_ = NULL;
5873
 
  create_table_statement_ = NULL;
5874
 
  alter_table_statement_ = NULL;
5875
 
  drop_table_statement_ = NULL;
5876
 
  set_variable_statement_ = NULL;
5877
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
5878
 
}
5879
 
 
5880
 
Statement::~Statement() {
5881
 
  SharedDtor();
5882
 
}
5883
 
 
5884
 
void Statement::SharedDtor() {
5885
 
  if (sql_ != &_default_sql_) {
5886
 
    delete sql_;
5887
 
  }
5888
 
  if (this != default_instance_) {
5889
 
    delete insert_header_;
5890
 
    delete insert_data_;
5891
 
    delete update_header_;
5892
 
    delete update_data_;
5893
 
    delete delete_header_;
5894
 
    delete delete_data_;
5895
 
    delete truncate_table_statement_;
5896
 
    delete create_schema_statement_;
5897
 
    delete drop_schema_statement_;
5898
 
    delete alter_schema_statement_;
5899
 
    delete create_table_statement_;
5900
 
    delete alter_table_statement_;
5901
 
    delete drop_table_statement_;
5902
 
    delete set_variable_statement_;
5903
 
  }
5904
 
}
5905
 
 
5906
 
const ::google::protobuf::Descriptor* Statement::descriptor() {
5907
 
  protobuf_AssignDescriptorsOnce();
5908
 
  return Statement_descriptor_;
5909
 
}
5910
 
 
5911
 
const Statement& Statement::default_instance() {
5912
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
5913
 
}
5914
 
 
5915
 
Statement* Statement::default_instance_ = NULL;
5916
 
 
5917
 
Statement* Statement::New() const {
5918
 
  return new Statement;
5919
 
}
5920
 
 
5921
 
void Statement::Clear() {
5922
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
5923
 
    type_ = 0;
5924
 
    start_timestamp_ = GOOGLE_ULONGLONG(0);
5925
 
    end_timestamp_ = GOOGLE_ULONGLONG(0);
5926
 
    if (_has_bit(3)) {
5927
 
      if (sql_ != &_default_sql_) {
5928
 
        sql_->clear();
5929
 
      }
5930
 
    }
5931
 
    if (_has_bit(4)) {
5932
 
      if (insert_header_ != NULL) insert_header_->::drizzled::message::InsertHeader::Clear();
5933
 
    }
5934
 
    if (_has_bit(5)) {
5935
 
      if (insert_data_ != NULL) insert_data_->::drizzled::message::InsertData::Clear();
5936
 
    }
5937
 
    if (_has_bit(6)) {
5938
 
      if (update_header_ != NULL) update_header_->::drizzled::message::UpdateHeader::Clear();
5939
 
    }
5940
 
    if (_has_bit(7)) {
5941
 
      if (update_data_ != NULL) update_data_->::drizzled::message::UpdateData::Clear();
5942
 
    }
5943
 
  }
5944
 
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
5945
 
    if (_has_bit(8)) {
5946
 
      if (delete_header_ != NULL) delete_header_->::drizzled::message::DeleteHeader::Clear();
5947
 
    }
5948
 
    if (_has_bit(9)) {
5949
 
      if (delete_data_ != NULL) delete_data_->::drizzled::message::DeleteData::Clear();
5950
 
    }
5951
 
    if (_has_bit(10)) {
5952
 
      if (truncate_table_statement_ != NULL) truncate_table_statement_->::drizzled::message::TruncateTableStatement::Clear();
5953
 
    }
5954
 
    if (_has_bit(11)) {
5955
 
      if (create_schema_statement_ != NULL) create_schema_statement_->::drizzled::message::CreateSchemaStatement::Clear();
5956
 
    }
5957
 
    if (_has_bit(12)) {
5958
 
      if (drop_schema_statement_ != NULL) drop_schema_statement_->::drizzled::message::DropSchemaStatement::Clear();
5959
 
    }
5960
 
    if (_has_bit(13)) {
5961
 
      if (alter_schema_statement_ != NULL) alter_schema_statement_->::drizzled::message::AlterSchemaStatement::Clear();
5962
 
    }
5963
 
    if (_has_bit(14)) {
5964
 
      if (create_table_statement_ != NULL) create_table_statement_->::drizzled::message::CreateTableStatement::Clear();
5965
 
    }
5966
 
    if (_has_bit(15)) {
5967
 
      if (alter_table_statement_ != NULL) alter_table_statement_->::drizzled::message::AlterTableStatement::Clear();
5968
 
    }
5969
 
  }
5970
 
  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
5971
 
    if (_has_bit(16)) {
5972
 
      if (drop_table_statement_ != NULL) drop_table_statement_->::drizzled::message::DropTableStatement::Clear();
5973
 
    }
5974
 
    if (_has_bit(17)) {
5975
 
      if (set_variable_statement_ != NULL) set_variable_statement_->::drizzled::message::SetVariableStatement::Clear();
5976
 
    }
5977
 
  }
5978
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
5979
 
  mutable_unknown_fields()->Clear();
5980
 
}
5981
 
 
5982
 
bool Statement::MergePartialFromCodedStream(
5983
 
    ::google::protobuf::io::CodedInputStream* input) {
5984
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
5985
 
  ::google::protobuf::uint32 tag;
5986
 
  while ((tag = input->ReadTag()) != 0) {
5987
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
5988
 
      // required .drizzled.message.Statement.Type type = 1;
5989
 
      case 1: {
5990
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
5991
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
5992
 
          goto handle_uninterpreted;
5993
 
        }
5994
 
        int value;
5995
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadEnum(input, &value));
5996
 
        if (::drizzled::message::Statement_Type_IsValid(value)) {
5997
 
          set_type(static_cast< ::drizzled::message::Statement_Type >(value));
5998
 
        } else {
5999
 
          mutable_unknown_fields()->AddVarint(1, value);
6000
 
        }
6001
 
        if (input->ExpectTag(16)) goto parse_start_timestamp;
6002
 
        break;
6003
 
      }
6004
 
      
6005
 
      // required uint64 start_timestamp = 2;
6006
 
      case 2: {
6007
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6008
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
6009
 
          goto handle_uninterpreted;
6010
 
        }
6011
 
       parse_start_timestamp:
6012
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadUInt64(
6013
 
              input, &start_timestamp_));
6014
 
        _set_bit(1);
6015
 
        if (input->ExpectTag(24)) goto parse_end_timestamp;
6016
 
        break;
6017
 
      }
6018
 
      
6019
 
      // required uint64 end_timestamp = 3;
6020
 
      case 3: {
6021
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6022
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
6023
 
          goto handle_uninterpreted;
6024
 
        }
6025
 
       parse_end_timestamp:
6026
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadUInt64(
6027
 
              input, &end_timestamp_));
6028
 
        _set_bit(2);
6029
 
        if (input->ExpectTag(34)) goto parse_sql;
6030
 
        break;
6031
 
      }
6032
 
      
6033
 
      // optional string sql = 4;
6034
 
      case 4: {
6035
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6036
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6037
 
          goto handle_uninterpreted;
6038
 
        }
6039
 
       parse_sql:
6040
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadString(
6041
 
              input, this->mutable_sql()));
6042
 
        ::google::protobuf::internal::WireFormat::VerifyUTF8String(
6043
 
          this->sql().data(), this->sql().length(),
6044
 
          ::google::protobuf::internal::WireFormat::PARSE);
6045
 
        if (input->ExpectTag(42)) goto parse_insert_header;
6046
 
        break;
6047
 
      }
6048
 
      
6049
 
      // optional .drizzled.message.InsertHeader insert_header = 5;
6050
 
      case 5: {
6051
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6052
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6053
 
          goto handle_uninterpreted;
6054
 
        }
6055
 
       parse_insert_header:
6056
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6057
 
             input, mutable_insert_header()));
6058
 
        if (input->ExpectTag(50)) goto parse_insert_data;
6059
 
        break;
6060
 
      }
6061
 
      
6062
 
      // optional .drizzled.message.InsertData insert_data = 6;
6063
 
      case 6: {
6064
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6065
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6066
 
          goto handle_uninterpreted;
6067
 
        }
6068
 
       parse_insert_data:
6069
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6070
 
             input, mutable_insert_data()));
6071
 
        if (input->ExpectTag(58)) goto parse_update_header;
6072
 
        break;
6073
 
      }
6074
 
      
6075
 
      // optional .drizzled.message.UpdateHeader update_header = 7;
6076
 
      case 7: {
6077
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6078
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6079
 
          goto handle_uninterpreted;
6080
 
        }
6081
 
       parse_update_header:
6082
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6083
 
             input, mutable_update_header()));
6084
 
        if (input->ExpectTag(66)) goto parse_update_data;
6085
 
        break;
6086
 
      }
6087
 
      
6088
 
      // optional .drizzled.message.UpdateData update_data = 8;
6089
 
      case 8: {
6090
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6091
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6092
 
          goto handle_uninterpreted;
6093
 
        }
6094
 
       parse_update_data:
6095
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6096
 
             input, mutable_update_data()));
6097
 
        if (input->ExpectTag(74)) goto parse_delete_header;
6098
 
        break;
6099
 
      }
6100
 
      
6101
 
      // optional .drizzled.message.DeleteHeader delete_header = 9;
6102
 
      case 9: {
6103
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6104
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6105
 
          goto handle_uninterpreted;
6106
 
        }
6107
 
       parse_delete_header:
6108
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6109
 
             input, mutable_delete_header()));
6110
 
        if (input->ExpectTag(82)) goto parse_delete_data;
6111
 
        break;
6112
 
      }
6113
 
      
6114
 
      // optional .drizzled.message.DeleteData delete_data = 10;
6115
 
      case 10: {
6116
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6117
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6118
 
          goto handle_uninterpreted;
6119
 
        }
6120
 
       parse_delete_data:
6121
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6122
 
             input, mutable_delete_data()));
6123
 
        if (input->ExpectTag(90)) goto parse_truncate_table_statement;
6124
 
        break;
6125
 
      }
6126
 
      
6127
 
      // optional .drizzled.message.TruncateTableStatement truncate_table_statement = 11;
6128
 
      case 11: {
6129
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6130
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6131
 
          goto handle_uninterpreted;
6132
 
        }
6133
 
       parse_truncate_table_statement:
6134
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6135
 
             input, mutable_truncate_table_statement()));
6136
 
        if (input->ExpectTag(98)) goto parse_create_schema_statement;
6137
 
        break;
6138
 
      }
6139
 
      
6140
 
      // optional .drizzled.message.CreateSchemaStatement create_schema_statement = 12;
6141
 
      case 12: {
6142
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6143
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6144
 
          goto handle_uninterpreted;
6145
 
        }
6146
 
       parse_create_schema_statement:
6147
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6148
 
             input, mutable_create_schema_statement()));
6149
 
        if (input->ExpectTag(106)) goto parse_drop_schema_statement;
6150
 
        break;
6151
 
      }
6152
 
      
6153
 
      // optional .drizzled.message.DropSchemaStatement drop_schema_statement = 13;
6154
 
      case 13: {
6155
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6156
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6157
 
          goto handle_uninterpreted;
6158
 
        }
6159
 
       parse_drop_schema_statement:
6160
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6161
 
             input, mutable_drop_schema_statement()));
6162
 
        if (input->ExpectTag(114)) goto parse_alter_schema_statement;
6163
 
        break;
6164
 
      }
6165
 
      
6166
 
      // optional .drizzled.message.AlterSchemaStatement alter_schema_statement = 14;
6167
 
      case 14: {
6168
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6169
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6170
 
          goto handle_uninterpreted;
6171
 
        }
6172
 
       parse_alter_schema_statement:
6173
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6174
 
             input, mutable_alter_schema_statement()));
6175
 
        if (input->ExpectTag(122)) goto parse_create_table_statement;
6176
 
        break;
6177
 
      }
6178
 
      
6179
 
      // optional .drizzled.message.CreateTableStatement create_table_statement = 15;
6180
 
      case 15: {
6181
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6182
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6183
 
          goto handle_uninterpreted;
6184
 
        }
6185
 
       parse_create_table_statement:
6186
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6187
 
             input, mutable_create_table_statement()));
6188
 
        if (input->ExpectTag(130)) goto parse_alter_table_statement;
6189
 
        break;
6190
 
      }
6191
 
      
6192
 
      // optional .drizzled.message.AlterTableStatement alter_table_statement = 16;
6193
 
      case 16: {
6194
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6195
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6196
 
          goto handle_uninterpreted;
6197
 
        }
6198
 
       parse_alter_table_statement:
6199
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6200
 
             input, mutable_alter_table_statement()));
6201
 
        if (input->ExpectTag(138)) goto parse_drop_table_statement;
6202
 
        break;
6203
 
      }
6204
 
      
6205
 
      // optional .drizzled.message.DropTableStatement drop_table_statement = 17;
6206
 
      case 17: {
6207
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6208
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6209
 
          goto handle_uninterpreted;
6210
 
        }
6211
 
       parse_drop_table_statement:
6212
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6213
 
             input, mutable_drop_table_statement()));
6214
 
        if (input->ExpectTag(146)) goto parse_set_variable_statement;
6215
 
        break;
6216
 
      }
6217
 
      
6218
 
      // optional .drizzled.message.SetVariableStatement set_variable_statement = 18;
6219
 
      case 18: {
6220
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6221
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6222
 
          goto handle_uninterpreted;
6223
 
        }
6224
 
       parse_set_variable_statement:
6225
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6226
 
             input, mutable_set_variable_statement()));
6227
 
        if (input->ExpectAtEnd()) return true;
6228
 
        break;
6229
 
      }
6230
 
      
6231
 
      default: {
6232
 
      handle_uninterpreted:
6233
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6234
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
6235
 
          return true;
6236
 
        }
6237
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
6238
 
              input, tag, mutable_unknown_fields()));
6239
 
        break;
6240
 
      }
6241
 
    }
6242
 
  }
6243
 
  return true;
6244
 
#undef DO_
6245
 
}
6246
 
 
6247
 
void Statement::SerializeWithCachedSizes(
6248
 
    ::google::protobuf::io::CodedOutputStream* output) const {
6249
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
6250
 
  if (raw_buffer != NULL) {
6251
 
    Statement::SerializeWithCachedSizesToArray(raw_buffer);
6252
 
    return;
6253
 
  }
6254
 
  
6255
 
  // required .drizzled.message.Statement.Type type = 1;
6256
 
  if (_has_bit(0)) {
6257
 
    ::google::protobuf::internal::WireFormatLite::WriteEnum(
6258
 
      1, this->type(), output);
6259
 
  }
6260
 
  
6261
 
  // required uint64 start_timestamp = 2;
6262
 
  if (_has_bit(1)) {
6263
 
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->start_timestamp(), output);
6264
 
  }
6265
 
  
6266
 
  // required uint64 end_timestamp = 3;
6267
 
  if (_has_bit(2)) {
6268
 
    ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->end_timestamp(), output);
6269
 
  }
6270
 
  
6271
 
  // optional string sql = 4;
6272
 
  if (_has_bit(3)) {
6273
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
6274
 
      this->sql().data(), this->sql().length(),
6275
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
6276
 
    ::google::protobuf::internal::WireFormatLite::WriteString(
6277
 
      4, this->sql(), output);
6278
 
  }
6279
 
  
6280
 
  // optional .drizzled.message.InsertHeader insert_header = 5;
6281
 
  if (_has_bit(4)) {
6282
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
6283
 
      5, this->insert_header(), output);
6284
 
  }
6285
 
  
6286
 
  // optional .drizzled.message.InsertData insert_data = 6;
6287
 
  if (_has_bit(5)) {
6288
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
6289
 
      6, this->insert_data(), output);
6290
 
  }
6291
 
  
6292
 
  // optional .drizzled.message.UpdateHeader update_header = 7;
6293
 
  if (_has_bit(6)) {
6294
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
6295
 
      7, this->update_header(), output);
6296
 
  }
6297
 
  
6298
 
  // optional .drizzled.message.UpdateData update_data = 8;
6299
 
  if (_has_bit(7)) {
6300
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
6301
 
      8, this->update_data(), output);
6302
 
  }
6303
 
  
6304
 
  // optional .drizzled.message.DeleteHeader delete_header = 9;
6305
 
  if (_has_bit(8)) {
6306
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
6307
 
      9, this->delete_header(), output);
6308
 
  }
6309
 
  
6310
 
  // optional .drizzled.message.DeleteData delete_data = 10;
6311
 
  if (_has_bit(9)) {
6312
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
6313
 
      10, this->delete_data(), output);
6314
 
  }
6315
 
  
6316
 
  // optional .drizzled.message.TruncateTableStatement truncate_table_statement = 11;
6317
 
  if (_has_bit(10)) {
6318
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
6319
 
      11, this->truncate_table_statement(), output);
6320
 
  }
6321
 
  
6322
 
  // optional .drizzled.message.CreateSchemaStatement create_schema_statement = 12;
6323
 
  if (_has_bit(11)) {
6324
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
6325
 
      12, this->create_schema_statement(), output);
6326
 
  }
6327
 
  
6328
 
  // optional .drizzled.message.DropSchemaStatement drop_schema_statement = 13;
6329
 
  if (_has_bit(12)) {
6330
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
6331
 
      13, this->drop_schema_statement(), output);
6332
 
  }
6333
 
  
6334
 
  // optional .drizzled.message.AlterSchemaStatement alter_schema_statement = 14;
6335
 
  if (_has_bit(13)) {
6336
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
6337
 
      14, this->alter_schema_statement(), output);
6338
 
  }
6339
 
  
6340
 
  // optional .drizzled.message.CreateTableStatement create_table_statement = 15;
6341
 
  if (_has_bit(14)) {
6342
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
6343
 
      15, this->create_table_statement(), output);
6344
 
  }
6345
 
  
6346
 
  // optional .drizzled.message.AlterTableStatement alter_table_statement = 16;
6347
 
  if (_has_bit(15)) {
6348
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
6349
 
      16, this->alter_table_statement(), output);
6350
 
  }
6351
 
  
6352
 
  // optional .drizzled.message.DropTableStatement drop_table_statement = 17;
6353
 
  if (_has_bit(16)) {
6354
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
6355
 
      17, this->drop_table_statement(), output);
6356
 
  }
6357
 
  
6358
 
  // optional .drizzled.message.SetVariableStatement set_variable_statement = 18;
6359
 
  if (_has_bit(17)) {
6360
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
6361
 
      18, this->set_variable_statement(), output);
6362
 
  }
6363
 
  
6364
 
  if (!unknown_fields().empty()) {
6365
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
6366
 
        unknown_fields(), output);
6367
 
  }
6368
 
}
6369
 
 
6370
 
::google::protobuf::uint8* Statement::SerializeWithCachedSizesToArray(
6371
 
    ::google::protobuf::uint8* target) const {
6372
 
  // required .drizzled.message.Statement.Type type = 1;
6373
 
  if (_has_bit(0)) {
6374
 
    target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
6375
 
      1, this->type(), target);
6376
 
  }
6377
 
  
6378
 
  // required uint64 start_timestamp = 2;
6379
 
  if (_has_bit(1)) {
6380
 
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->start_timestamp(), target);
6381
 
  }
6382
 
  
6383
 
  // required uint64 end_timestamp = 3;
6384
 
  if (_has_bit(2)) {
6385
 
    target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->end_timestamp(), target);
6386
 
  }
6387
 
  
6388
 
  // optional string sql = 4;
6389
 
  if (_has_bit(3)) {
6390
 
    ::google::protobuf::internal::WireFormat::VerifyUTF8String(
6391
 
      this->sql().data(), this->sql().length(),
6392
 
      ::google::protobuf::internal::WireFormat::SERIALIZE);
6393
 
    target =
6394
 
      ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
6395
 
        4, this->sql(), target);
6396
 
  }
6397
 
  
6398
 
  // optional .drizzled.message.InsertHeader insert_header = 5;
6399
 
  if (_has_bit(4)) {
6400
 
    target = ::google::protobuf::internal::WireFormatLite::
6401
 
      WriteMessageNoVirtualToArray(
6402
 
        5, this->insert_header(), target);
6403
 
  }
6404
 
  
6405
 
  // optional .drizzled.message.InsertData insert_data = 6;
6406
 
  if (_has_bit(5)) {
6407
 
    target = ::google::protobuf::internal::WireFormatLite::
6408
 
      WriteMessageNoVirtualToArray(
6409
 
        6, this->insert_data(), target);
6410
 
  }
6411
 
  
6412
 
  // optional .drizzled.message.UpdateHeader update_header = 7;
6413
 
  if (_has_bit(6)) {
6414
 
    target = ::google::protobuf::internal::WireFormatLite::
6415
 
      WriteMessageNoVirtualToArray(
6416
 
        7, this->update_header(), target);
6417
 
  }
6418
 
  
6419
 
  // optional .drizzled.message.UpdateData update_data = 8;
6420
 
  if (_has_bit(7)) {
6421
 
    target = ::google::protobuf::internal::WireFormatLite::
6422
 
      WriteMessageNoVirtualToArray(
6423
 
        8, this->update_data(), target);
6424
 
  }
6425
 
  
6426
 
  // optional .drizzled.message.DeleteHeader delete_header = 9;
6427
 
  if (_has_bit(8)) {
6428
 
    target = ::google::protobuf::internal::WireFormatLite::
6429
 
      WriteMessageNoVirtualToArray(
6430
 
        9, this->delete_header(), target);
6431
 
  }
6432
 
  
6433
 
  // optional .drizzled.message.DeleteData delete_data = 10;
6434
 
  if (_has_bit(9)) {
6435
 
    target = ::google::protobuf::internal::WireFormatLite::
6436
 
      WriteMessageNoVirtualToArray(
6437
 
        10, this->delete_data(), target);
6438
 
  }
6439
 
  
6440
 
  // optional .drizzled.message.TruncateTableStatement truncate_table_statement = 11;
6441
 
  if (_has_bit(10)) {
6442
 
    target = ::google::protobuf::internal::WireFormatLite::
6443
 
      WriteMessageNoVirtualToArray(
6444
 
        11, this->truncate_table_statement(), target);
6445
 
  }
6446
 
  
6447
 
  // optional .drizzled.message.CreateSchemaStatement create_schema_statement = 12;
6448
 
  if (_has_bit(11)) {
6449
 
    target = ::google::protobuf::internal::WireFormatLite::
6450
 
      WriteMessageNoVirtualToArray(
6451
 
        12, this->create_schema_statement(), target);
6452
 
  }
6453
 
  
6454
 
  // optional .drizzled.message.DropSchemaStatement drop_schema_statement = 13;
6455
 
  if (_has_bit(12)) {
6456
 
    target = ::google::protobuf::internal::WireFormatLite::
6457
 
      WriteMessageNoVirtualToArray(
6458
 
        13, this->drop_schema_statement(), target);
6459
 
  }
6460
 
  
6461
 
  // optional .drizzled.message.AlterSchemaStatement alter_schema_statement = 14;
6462
 
  if (_has_bit(13)) {
6463
 
    target = ::google::protobuf::internal::WireFormatLite::
6464
 
      WriteMessageNoVirtualToArray(
6465
 
        14, this->alter_schema_statement(), target);
6466
 
  }
6467
 
  
6468
 
  // optional .drizzled.message.CreateTableStatement create_table_statement = 15;
6469
 
  if (_has_bit(14)) {
6470
 
    target = ::google::protobuf::internal::WireFormatLite::
6471
 
      WriteMessageNoVirtualToArray(
6472
 
        15, this->create_table_statement(), target);
6473
 
  }
6474
 
  
6475
 
  // optional .drizzled.message.AlterTableStatement alter_table_statement = 16;
6476
 
  if (_has_bit(15)) {
6477
 
    target = ::google::protobuf::internal::WireFormatLite::
6478
 
      WriteMessageNoVirtualToArray(
6479
 
        16, this->alter_table_statement(), target);
6480
 
  }
6481
 
  
6482
 
  // optional .drizzled.message.DropTableStatement drop_table_statement = 17;
6483
 
  if (_has_bit(16)) {
6484
 
    target = ::google::protobuf::internal::WireFormatLite::
6485
 
      WriteMessageNoVirtualToArray(
6486
 
        17, this->drop_table_statement(), target);
6487
 
  }
6488
 
  
6489
 
  // optional .drizzled.message.SetVariableStatement set_variable_statement = 18;
6490
 
  if (_has_bit(17)) {
6491
 
    target = ::google::protobuf::internal::WireFormatLite::
6492
 
      WriteMessageNoVirtualToArray(
6493
 
        18, this->set_variable_statement(), target);
6494
 
  }
6495
 
  
6496
 
  if (!unknown_fields().empty()) {
6497
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
6498
 
        unknown_fields(), target);
6499
 
  }
6500
 
  return target;
6501
 
}
6502
 
 
6503
 
int Statement::ByteSize() const {
6504
 
  int total_size = 0;
6505
 
  
6506
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6507
 
    // required .drizzled.message.Statement.Type type = 1;
6508
 
    if (has_type()) {
6509
 
      total_size += 1 +
6510
 
        ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
6511
 
    }
6512
 
    
6513
 
    // required uint64 start_timestamp = 2;
6514
 
    if (has_start_timestamp()) {
6515
 
      total_size += 1 +
6516
 
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
6517
 
          this->start_timestamp());
6518
 
    }
6519
 
    
6520
 
    // required uint64 end_timestamp = 3;
6521
 
    if (has_end_timestamp()) {
6522
 
      total_size += 1 +
6523
 
        ::google::protobuf::internal::WireFormatLite::UInt64Size(
6524
 
          this->end_timestamp());
6525
 
    }
6526
 
    
6527
 
    // optional string sql = 4;
6528
 
    if (has_sql()) {
6529
 
      total_size += 1 +
6530
 
        ::google::protobuf::internal::WireFormatLite::StringSize(
6531
 
          this->sql());
6532
 
    }
6533
 
    
6534
 
    // optional .drizzled.message.InsertHeader insert_header = 5;
6535
 
    if (has_insert_header()) {
6536
 
      total_size += 1 +
6537
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6538
 
          this->insert_header());
6539
 
    }
6540
 
    
6541
 
    // optional .drizzled.message.InsertData insert_data = 6;
6542
 
    if (has_insert_data()) {
6543
 
      total_size += 1 +
6544
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6545
 
          this->insert_data());
6546
 
    }
6547
 
    
6548
 
    // optional .drizzled.message.UpdateHeader update_header = 7;
6549
 
    if (has_update_header()) {
6550
 
      total_size += 1 +
6551
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6552
 
          this->update_header());
6553
 
    }
6554
 
    
6555
 
    // optional .drizzled.message.UpdateData update_data = 8;
6556
 
    if (has_update_data()) {
6557
 
      total_size += 1 +
6558
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6559
 
          this->update_data());
6560
 
    }
6561
 
    
6562
 
  }
6563
 
  if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
6564
 
    // optional .drizzled.message.DeleteHeader delete_header = 9;
6565
 
    if (has_delete_header()) {
6566
 
      total_size += 1 +
6567
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6568
 
          this->delete_header());
6569
 
    }
6570
 
    
6571
 
    // optional .drizzled.message.DeleteData delete_data = 10;
6572
 
    if (has_delete_data()) {
6573
 
      total_size += 1 +
6574
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6575
 
          this->delete_data());
6576
 
    }
6577
 
    
6578
 
    // optional .drizzled.message.TruncateTableStatement truncate_table_statement = 11;
6579
 
    if (has_truncate_table_statement()) {
6580
 
      total_size += 1 +
6581
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6582
 
          this->truncate_table_statement());
6583
 
    }
6584
 
    
6585
 
    // optional .drizzled.message.CreateSchemaStatement create_schema_statement = 12;
6586
 
    if (has_create_schema_statement()) {
6587
 
      total_size += 1 +
6588
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6589
 
          this->create_schema_statement());
6590
 
    }
6591
 
    
6592
 
    // optional .drizzled.message.DropSchemaStatement drop_schema_statement = 13;
6593
 
    if (has_drop_schema_statement()) {
6594
 
      total_size += 1 +
6595
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6596
 
          this->drop_schema_statement());
6597
 
    }
6598
 
    
6599
 
    // optional .drizzled.message.AlterSchemaStatement alter_schema_statement = 14;
6600
 
    if (has_alter_schema_statement()) {
6601
 
      total_size += 1 +
6602
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6603
 
          this->alter_schema_statement());
6604
 
    }
6605
 
    
6606
 
    // optional .drizzled.message.CreateTableStatement create_table_statement = 15;
6607
 
    if (has_create_table_statement()) {
6608
 
      total_size += 1 +
6609
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6610
 
          this->create_table_statement());
6611
 
    }
6612
 
    
6613
 
    // optional .drizzled.message.AlterTableStatement alter_table_statement = 16;
6614
 
    if (has_alter_table_statement()) {
6615
 
      total_size += 2 +
6616
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6617
 
          this->alter_table_statement());
6618
 
    }
6619
 
    
6620
 
  }
6621
 
  if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
6622
 
    // optional .drizzled.message.DropTableStatement drop_table_statement = 17;
6623
 
    if (has_drop_table_statement()) {
6624
 
      total_size += 2 +
6625
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6626
 
          this->drop_table_statement());
6627
 
    }
6628
 
    
6629
 
    // optional .drizzled.message.SetVariableStatement set_variable_statement = 18;
6630
 
    if (has_set_variable_statement()) {
6631
 
      total_size += 2 +
6632
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6633
 
          this->set_variable_statement());
6634
 
    }
6635
 
    
6636
 
  }
6637
 
  if (!unknown_fields().empty()) {
6638
 
    total_size +=
6639
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
6640
 
        unknown_fields());
6641
 
  }
6642
 
  _cached_size_ = total_size;
6643
 
  return total_size;
6644
 
}
6645
 
 
6646
 
void Statement::MergeFrom(const ::google::protobuf::Message& from) {
6647
 
  GOOGLE_CHECK_NE(&from, this);
6648
 
  const Statement* source =
6649
 
    ::google::protobuf::internal::dynamic_cast_if_available<const Statement*>(
6650
 
      &from);
6651
 
  if (source == NULL) {
6652
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
6653
 
  } else {
6654
 
    MergeFrom(*source);
6655
 
  }
6656
 
}
6657
 
 
6658
 
void Statement::MergeFrom(const Statement& from) {
6659
 
  GOOGLE_CHECK_NE(&from, this);
6660
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6661
 
    if (from._has_bit(0)) {
6662
 
      set_type(from.type());
6663
 
    }
6664
 
    if (from._has_bit(1)) {
6665
 
      set_start_timestamp(from.start_timestamp());
6666
 
    }
6667
 
    if (from._has_bit(2)) {
6668
 
      set_end_timestamp(from.end_timestamp());
6669
 
    }
6670
 
    if (from._has_bit(3)) {
6671
 
      set_sql(from.sql());
6672
 
    }
6673
 
    if (from._has_bit(4)) {
6674
 
      mutable_insert_header()->::drizzled::message::InsertHeader::MergeFrom(from.insert_header());
6675
 
    }
6676
 
    if (from._has_bit(5)) {
6677
 
      mutable_insert_data()->::drizzled::message::InsertData::MergeFrom(from.insert_data());
6678
 
    }
6679
 
    if (from._has_bit(6)) {
6680
 
      mutable_update_header()->::drizzled::message::UpdateHeader::MergeFrom(from.update_header());
6681
 
    }
6682
 
    if (from._has_bit(7)) {
6683
 
      mutable_update_data()->::drizzled::message::UpdateData::MergeFrom(from.update_data());
6684
 
    }
6685
 
  }
6686
 
  if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
6687
 
    if (from._has_bit(8)) {
6688
 
      mutable_delete_header()->::drizzled::message::DeleteHeader::MergeFrom(from.delete_header());
6689
 
    }
6690
 
    if (from._has_bit(9)) {
6691
 
      mutable_delete_data()->::drizzled::message::DeleteData::MergeFrom(from.delete_data());
6692
 
    }
6693
 
    if (from._has_bit(10)) {
6694
 
      mutable_truncate_table_statement()->::drizzled::message::TruncateTableStatement::MergeFrom(from.truncate_table_statement());
6695
 
    }
6696
 
    if (from._has_bit(11)) {
6697
 
      mutable_create_schema_statement()->::drizzled::message::CreateSchemaStatement::MergeFrom(from.create_schema_statement());
6698
 
    }
6699
 
    if (from._has_bit(12)) {
6700
 
      mutable_drop_schema_statement()->::drizzled::message::DropSchemaStatement::MergeFrom(from.drop_schema_statement());
6701
 
    }
6702
 
    if (from._has_bit(13)) {
6703
 
      mutable_alter_schema_statement()->::drizzled::message::AlterSchemaStatement::MergeFrom(from.alter_schema_statement());
6704
 
    }
6705
 
    if (from._has_bit(14)) {
6706
 
      mutable_create_table_statement()->::drizzled::message::CreateTableStatement::MergeFrom(from.create_table_statement());
6707
 
    }
6708
 
    if (from._has_bit(15)) {
6709
 
      mutable_alter_table_statement()->::drizzled::message::AlterTableStatement::MergeFrom(from.alter_table_statement());
6710
 
    }
6711
 
  }
6712
 
  if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
6713
 
    if (from._has_bit(16)) {
6714
 
      mutable_drop_table_statement()->::drizzled::message::DropTableStatement::MergeFrom(from.drop_table_statement());
6715
 
    }
6716
 
    if (from._has_bit(17)) {
6717
 
      mutable_set_variable_statement()->::drizzled::message::SetVariableStatement::MergeFrom(from.set_variable_statement());
6718
 
    }
6719
 
  }
6720
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
6721
 
}
6722
 
 
6723
 
void Statement::CopyFrom(const ::google::protobuf::Message& from) {
6724
 
  if (&from == this) return;
6725
 
  Clear();
6726
 
  MergeFrom(from);
6727
 
}
6728
 
 
6729
 
void Statement::CopyFrom(const Statement& from) {
6730
 
  if (&from == this) return;
6731
 
  Clear();
6732
 
  MergeFrom(from);
6733
 
}
6734
 
 
6735
 
bool Statement::IsInitialized() const {
6736
 
  if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
6737
 
  
6738
 
  if (has_insert_header()) {
6739
 
    if (!this->insert_header().IsInitialized()) return false;
6740
 
  }
6741
 
  if (has_insert_data()) {
6742
 
    if (!this->insert_data().IsInitialized()) return false;
6743
 
  }
6744
 
  if (has_update_header()) {
6745
 
    if (!this->update_header().IsInitialized()) return false;
6746
 
  }
6747
 
  if (has_update_data()) {
6748
 
    if (!this->update_data().IsInitialized()) return false;
6749
 
  }
6750
 
  if (has_delete_header()) {
6751
 
    if (!this->delete_header().IsInitialized()) return false;
6752
 
  }
6753
 
  if (has_delete_data()) {
6754
 
    if (!this->delete_data().IsInitialized()) return false;
6755
 
  }
6756
 
  if (has_truncate_table_statement()) {
6757
 
    if (!this->truncate_table_statement().IsInitialized()) return false;
6758
 
  }
6759
 
  if (has_create_schema_statement()) {
6760
 
    if (!this->create_schema_statement().IsInitialized()) return false;
6761
 
  }
6762
 
  if (has_drop_schema_statement()) {
6763
 
    if (!this->drop_schema_statement().IsInitialized()) return false;
6764
 
  }
6765
 
  if (has_alter_schema_statement()) {
6766
 
    if (!this->alter_schema_statement().IsInitialized()) return false;
6767
 
  }
6768
 
  if (has_create_table_statement()) {
6769
 
    if (!this->create_table_statement().IsInitialized()) return false;
6770
 
  }
6771
 
  if (has_alter_table_statement()) {
6772
 
    if (!this->alter_table_statement().IsInitialized()) return false;
6773
 
  }
6774
 
  if (has_drop_table_statement()) {
6775
 
    if (!this->drop_table_statement().IsInitialized()) return false;
6776
 
  }
6777
 
  if (has_set_variable_statement()) {
6778
 
    if (!this->set_variable_statement().IsInitialized()) return false;
6779
 
  }
6780
 
  return true;
6781
 
}
6782
 
 
6783
 
void Statement::Swap(Statement* other) {
6784
 
  if (other != this) {
6785
 
    std::swap(type_, other->type_);
6786
 
    std::swap(start_timestamp_, other->start_timestamp_);
6787
 
    std::swap(end_timestamp_, other->end_timestamp_);
6788
 
    std::swap(sql_, other->sql_);
6789
 
    std::swap(insert_header_, other->insert_header_);
6790
 
    std::swap(insert_data_, other->insert_data_);
6791
 
    std::swap(update_header_, other->update_header_);
6792
 
    std::swap(update_data_, other->update_data_);
6793
 
    std::swap(delete_header_, other->delete_header_);
6794
 
    std::swap(delete_data_, other->delete_data_);
6795
 
    std::swap(truncate_table_statement_, other->truncate_table_statement_);
6796
 
    std::swap(create_schema_statement_, other->create_schema_statement_);
6797
 
    std::swap(drop_schema_statement_, other->drop_schema_statement_);
6798
 
    std::swap(alter_schema_statement_, other->alter_schema_statement_);
6799
 
    std::swap(create_table_statement_, other->create_table_statement_);
6800
 
    std::swap(alter_table_statement_, other->alter_table_statement_);
6801
 
    std::swap(drop_table_statement_, other->drop_table_statement_);
6802
 
    std::swap(set_variable_statement_, other->set_variable_statement_);
6803
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
6804
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
6805
 
    std::swap(_cached_size_, other->_cached_size_);
6806
 
  }
6807
 
}
6808
 
 
6809
 
::google::protobuf::Metadata Statement::GetMetadata() const {
6810
 
  protobuf_AssignDescriptorsOnce();
6811
 
  ::google::protobuf::Metadata metadata;
6812
 
  metadata.descriptor = Statement_descriptor_;
6813
 
  metadata.reflection = Statement_reflection_;
6814
 
  return metadata;
6815
 
}
6816
 
 
6817
 
 
6818
 
// ===================================================================
6819
 
 
6820
 
#ifndef _MSC_VER
6821
 
const int Transaction::kTransactionContextFieldNumber;
6822
 
const int Transaction::kStatementFieldNumber;
6823
 
#endif  // !_MSC_VER
6824
 
 
6825
 
Transaction::Transaction() {
6826
 
  SharedCtor();
6827
 
}
6828
 
 
6829
 
void Transaction::InitAsDefaultInstance() {
6830
 
  transaction_context_ = const_cast< ::drizzled::message::TransactionContext*>(&::drizzled::message::TransactionContext::default_instance());
6831
 
}
6832
 
 
6833
 
Transaction::Transaction(const Transaction& from) {
6834
 
  SharedCtor();
6835
 
  MergeFrom(from);
6836
 
}
6837
 
 
6838
 
void Transaction::SharedCtor() {
6839
 
  _cached_size_ = 0;
6840
 
  transaction_context_ = NULL;
6841
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
6842
 
}
6843
 
 
6844
 
Transaction::~Transaction() {
6845
 
  SharedDtor();
6846
 
}
6847
 
 
6848
 
void Transaction::SharedDtor() {
6849
 
  if (this != default_instance_) {
6850
 
    delete transaction_context_;
6851
 
  }
6852
 
}
6853
 
 
6854
 
const ::google::protobuf::Descriptor* Transaction::descriptor() {
6855
 
  protobuf_AssignDescriptorsOnce();
6856
 
  return Transaction_descriptor_;
6857
 
}
6858
 
 
6859
 
const Transaction& Transaction::default_instance() {
6860
 
  if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
6861
 
}
6862
 
 
6863
 
Transaction* Transaction::default_instance_ = NULL;
6864
 
 
6865
 
Transaction* Transaction::New() const {
6866
 
  return new Transaction;
6867
 
}
6868
 
 
6869
 
void Transaction::Clear() {
6870
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6871
 
    if (_has_bit(0)) {
6872
 
      if (transaction_context_ != NULL) transaction_context_->::drizzled::message::TransactionContext::Clear();
6873
 
    }
6874
 
  }
6875
 
  statement_.Clear();
6876
 
  ::memset(_has_bits_, 0, sizeof(_has_bits_));
6877
 
  mutable_unknown_fields()->Clear();
6878
 
}
6879
 
 
6880
 
bool Transaction::MergePartialFromCodedStream(
6881
 
    ::google::protobuf::io::CodedInputStream* input) {
6882
 
#define DO_(EXPRESSION) if (!(EXPRESSION)) return false
6883
 
  ::google::protobuf::uint32 tag;
6884
 
  while ((tag = input->ReadTag()) != 0) {
6885
 
    switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
6886
 
      // required .drizzled.message.TransactionContext transaction_context = 1;
6887
 
      case 1: {
6888
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6889
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6890
 
          goto handle_uninterpreted;
6891
 
        }
6892
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6893
 
             input, mutable_transaction_context()));
6894
 
        if (input->ExpectTag(18)) goto parse_statement;
6895
 
        break;
6896
 
      }
6897
 
      
6898
 
      // repeated .drizzled.message.Statement statement = 2;
6899
 
      case 2: {
6900
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) !=
6901
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
6902
 
          goto handle_uninterpreted;
6903
 
        }
6904
 
       parse_statement:
6905
 
        DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
6906
 
              input, add_statement()));
6907
 
        if (input->ExpectTag(18)) goto parse_statement;
6908
 
        if (input->ExpectAtEnd()) return true;
6909
 
        break;
6910
 
      }
6911
 
      
6912
 
      default: {
6913
 
      handle_uninterpreted:
6914
 
        if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
6915
 
            ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
6916
 
          return true;
6917
 
        }
6918
 
        DO_(::google::protobuf::internal::WireFormat::SkipField(
6919
 
              input, tag, mutable_unknown_fields()));
6920
 
        break;
6921
 
      }
6922
 
    }
6923
 
  }
6924
 
  return true;
6925
 
#undef DO_
6926
 
}
6927
 
 
6928
 
void Transaction::SerializeWithCachedSizes(
6929
 
    ::google::protobuf::io::CodedOutputStream* output) const {
6930
 
  ::google::protobuf::uint8* raw_buffer = output->GetDirectBufferForNBytesAndAdvance(_cached_size_);
6931
 
  if (raw_buffer != NULL) {
6932
 
    Transaction::SerializeWithCachedSizesToArray(raw_buffer);
6933
 
    return;
6934
 
  }
6935
 
  
6936
 
  // required .drizzled.message.TransactionContext transaction_context = 1;
6937
 
  if (_has_bit(0)) {
6938
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
6939
 
      1, this->transaction_context(), output);
6940
 
  }
6941
 
  
6942
 
  // repeated .drizzled.message.Statement statement = 2;
6943
 
  for (int i = 0; i < this->statement_size(); i++) {
6944
 
    ::google::protobuf::internal::WireFormatLite::WriteMessageNoVirtual(
6945
 
      2, this->statement(i), output);
6946
 
  }
6947
 
  
6948
 
  if (!unknown_fields().empty()) {
6949
 
    ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
6950
 
        unknown_fields(), output);
6951
 
  }
6952
 
}
6953
 
 
6954
 
::google::protobuf::uint8* Transaction::SerializeWithCachedSizesToArray(
6955
 
    ::google::protobuf::uint8* target) const {
6956
 
  // required .drizzled.message.TransactionContext transaction_context = 1;
6957
 
  if (_has_bit(0)) {
6958
 
    target = ::google::protobuf::internal::WireFormatLite::
6959
 
      WriteMessageNoVirtualToArray(
6960
 
        1, this->transaction_context(), target);
6961
 
  }
6962
 
  
6963
 
  // repeated .drizzled.message.Statement statement = 2;
6964
 
  for (int i = 0; i < this->statement_size(); i++) {
6965
 
    target = ::google::protobuf::internal::WireFormatLite::
6966
 
      WriteMessageNoVirtualToArray(
6967
 
        2, this->statement(i), target);
6968
 
  }
6969
 
  
6970
 
  if (!unknown_fields().empty()) {
6971
 
    target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
6972
 
        unknown_fields(), target);
6973
 
  }
6974
 
  return target;
6975
 
}
6976
 
 
6977
 
int Transaction::ByteSize() const {
6978
 
  int total_size = 0;
6979
 
  
6980
 
  if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
6981
 
    // required .drizzled.message.TransactionContext transaction_context = 1;
6982
 
    if (has_transaction_context()) {
6983
 
      total_size += 1 +
6984
 
        ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6985
 
          this->transaction_context());
6986
 
    }
6987
 
    
6988
 
  }
6989
 
  // repeated .drizzled.message.Statement statement = 2;
6990
 
  total_size += 1 * this->statement_size();
6991
 
  for (int i = 0; i < this->statement_size(); i++) {
6992
 
    total_size +=
6993
 
      ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
6994
 
        this->statement(i));
6995
 
  }
6996
 
  
6997
 
  if (!unknown_fields().empty()) {
6998
 
    total_size +=
6999
 
      ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
7000
 
        unknown_fields());
7001
 
  }
7002
 
  _cached_size_ = total_size;
7003
 
  return total_size;
7004
 
}
7005
 
 
7006
 
void Transaction::MergeFrom(const ::google::protobuf::Message& from) {
7007
 
  GOOGLE_CHECK_NE(&from, this);
7008
 
  const Transaction* source =
7009
 
    ::google::protobuf::internal::dynamic_cast_if_available<const Transaction*>(
7010
 
      &from);
7011
 
  if (source == NULL) {
7012
 
    ::google::protobuf::internal::ReflectionOps::Merge(from, this);
7013
 
  } else {
7014
 
    MergeFrom(*source);
7015
 
  }
7016
 
}
7017
 
 
7018
 
void Transaction::MergeFrom(const Transaction& from) {
7019
 
  GOOGLE_CHECK_NE(&from, this);
7020
 
  statement_.MergeFrom(from.statement_);
7021
 
  if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
7022
 
    if (from._has_bit(0)) {
7023
 
      mutable_transaction_context()->::drizzled::message::TransactionContext::MergeFrom(from.transaction_context());
7024
 
    }
7025
 
  }
7026
 
  mutable_unknown_fields()->MergeFrom(from.unknown_fields());
7027
 
}
7028
 
 
7029
 
void Transaction::CopyFrom(const ::google::protobuf::Message& from) {
7030
 
  if (&from == this) return;
7031
 
  Clear();
7032
 
  MergeFrom(from);
7033
 
}
7034
 
 
7035
 
void Transaction::CopyFrom(const Transaction& from) {
7036
 
  if (&from == this) return;
7037
 
  Clear();
7038
 
  MergeFrom(from);
7039
 
}
7040
 
 
7041
 
bool Transaction::IsInitialized() const {
7042
 
  if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
7043
 
  
7044
 
  if (has_transaction_context()) {
7045
 
    if (!this->transaction_context().IsInitialized()) return false;
7046
 
  }
7047
 
  for (int i = 0; i < statement_size(); i++) {
7048
 
    if (!this->statement(i).IsInitialized()) return false;
7049
 
  }
7050
 
  return true;
7051
 
}
7052
 
 
7053
 
void Transaction::Swap(Transaction* other) {
7054
 
  if (other != this) {
7055
 
    std::swap(transaction_context_, other->transaction_context_);
7056
 
    statement_.Swap(&other->statement_);
7057
 
    std::swap(_has_bits_[0], other->_has_bits_[0]);
7058
 
    _unknown_fields_.Swap(&other->_unknown_fields_);
7059
 
    std::swap(_cached_size_, other->_cached_size_);
7060
 
  }
7061
 
}
7062
 
 
7063
 
::google::protobuf::Metadata Transaction::GetMetadata() const {
7064
 
  protobuf_AssignDescriptorsOnce();
7065
 
  ::google::protobuf::Metadata metadata;
7066
 
  metadata.descriptor = Transaction_descriptor_;
7067
 
  metadata.reflection = Transaction_reflection_;
7068
 
  return metadata;
7069
 
}
7070
 
 
7071
 
 
7072
 
}  // namespace message
7073
 
}  // namespace drizzled