Drizzled Public API Documentation

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