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