Drizzled Public API Documentation

transaction.pb.h
1 // Generated by the protocol buffer compiler. DO NOT EDIT!
2 // source: transaction.proto
3 
4 #ifndef PROTOBUF_transaction_2eproto__INCLUDED
5 #define PROTOBUF_transaction_2eproto__INCLUDED
6 
7 #include <string>
8 
9 #include <google/protobuf/stubs/common.h>
10 
11 #if GOOGLE_PROTOBUF_VERSION < 2005000
12 #error This file was generated by a newer version of protoc which is
13 #error incompatible with your Protocol Buffer headers. Please update
14 #error your headers.
15 #endif
16 #if 2005000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
17 #error This file was generated by an older version of protoc which is
18 #error incompatible with your Protocol Buffer headers. Please
19 #error regenerate this file with a newer version of protoc.
20 #endif
21 
22 #include <google/protobuf/generated_message_util.h>
23 #include <google/protobuf/message.h>
24 #include <google/protobuf/repeated_field.h>
25 #include <google/protobuf/extension_set.h>
26 #include <google/protobuf/generated_enum_reflection.h>
27 #include <google/protobuf/unknown_field_set.h>
28 #include "table.pb.h"
29 #include "schema.pb.h"
30 #include "event.pb.h"
31 // @@protoc_insertion_point(includes)
32 
33 namespace drizzled {
34 namespace message {
35 
36 // Internal implementation detail -- do not call these.
37 void protobuf_AddDesc_transaction_2eproto();
38 void protobuf_AssignDesc_transaction_2eproto();
39 void protobuf_ShutdownFile_transaction_2eproto();
40 
41 class FieldMetadata;
42 class TableMetadata;
43 class TransactionContext;
44 class InsertRecord;
45 class InsertHeader;
46 class InsertData;
47 class UpdateRecord;
48 class UpdateHeader;
49 class UpdateData;
50 class DeleteRecord;
51 class DeleteHeader;
52 class DeleteData;
53 class TruncateTableStatement;
54 class CreateSchemaStatement;
55 class AlterSchemaStatement;
56 class DropSchemaStatement;
57 class CreateTableStatement;
58 class AlterTableStatement;
59 class DropTableStatement;
60 class SetVariableStatement;
61 class Statement;
62 class Transaction;
63 
64 enum Statement_Type {
65  Statement_Type_ROLLBACK = 0,
66  Statement_Type_INSERT = 1,
67  Statement_Type_DELETE = 2,
68  Statement_Type_UPDATE = 3,
69  Statement_Type_TRUNCATE_TABLE = 4,
70  Statement_Type_CREATE_SCHEMA = 5,
71  Statement_Type_ALTER_SCHEMA = 6,
72  Statement_Type_DROP_SCHEMA = 7,
73  Statement_Type_CREATE_TABLE = 8,
74  Statement_Type_ALTER_TABLE = 9,
75  Statement_Type_DROP_TABLE = 10,
76  Statement_Type_ROLLBACK_STATEMENT = 11,
77  Statement_Type_SET_VARIABLE = 98,
78  Statement_Type_RAW_SQL = 99
79 };
80 bool Statement_Type_IsValid(int value);
81 const Statement_Type Statement_Type_Type_MIN = Statement_Type_ROLLBACK;
82 const Statement_Type Statement_Type_Type_MAX = Statement_Type_RAW_SQL;
83 const int Statement_Type_Type_ARRAYSIZE = Statement_Type_Type_MAX + 1;
84 
85 const ::google::protobuf::EnumDescriptor* Statement_Type_descriptor();
86 inline const ::std::string& Statement_Type_Name(Statement_Type value) {
87  return ::google::protobuf::internal::NameOfEnum(
88  Statement_Type_descriptor(), value);
89 }
90 inline bool Statement_Type_Parse(
91  const ::std::string& name, Statement_Type* value) {
92  return ::google::protobuf::internal::ParseNamedEnum<Statement_Type>(
93  Statement_Type_descriptor(), name, value);
94 }
95 // ===================================================================
96 
97 class FieldMetadata : public ::google::protobuf::Message {
98  public:
99  FieldMetadata();
100  virtual ~FieldMetadata();
101 
102  FieldMetadata(const FieldMetadata& from);
103 
104  inline FieldMetadata& operator=(const FieldMetadata& from) {
105  CopyFrom(from);
106  return *this;
107  }
108 
109  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
110  return _unknown_fields_;
111  }
112 
113  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
114  return &_unknown_fields_;
115  }
116 
117  static const ::google::protobuf::Descriptor* descriptor();
118  static const FieldMetadata& default_instance();
119 
120  void Swap(FieldMetadata* other);
121 
122  // implements Message ----------------------------------------------
123 
124  FieldMetadata* New() const;
125  void CopyFrom(const ::google::protobuf::Message& from);
126  void MergeFrom(const ::google::protobuf::Message& from);
127  void CopyFrom(const FieldMetadata& from);
128  void MergeFrom(const FieldMetadata& from);
129  void Clear();
130  bool IsInitialized() const;
131 
132  int ByteSize() const;
133  bool MergePartialFromCodedStream(
134  ::google::protobuf::io::CodedInputStream* input);
135  void SerializeWithCachedSizes(
136  ::google::protobuf::io::CodedOutputStream* output) const;
137  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
138  int GetCachedSize() const { return _cached_size_; }
139  private:
140  void SharedCtor();
141  void SharedDtor();
142  void SetCachedSize(int size) const;
143  public:
144 
145  ::google::protobuf::Metadata GetMetadata() const;
146 
147  // nested types ----------------------------------------------------
148 
149  // accessors -------------------------------------------------------
150 
151  // required .drizzled.message.Table.Field.FieldType type = 1;
152  inline bool has_type() const;
153  inline void clear_type();
154  static const int kTypeFieldNumber = 1;
155  inline ::drizzled::message::Table_Field_FieldType type() const;
156  inline void set_type(::drizzled::message::Table_Field_FieldType value);
157 
158  // required string name = 2;
159  inline bool has_name() const;
160  inline void clear_name();
161  static const int kNameFieldNumber = 2;
162  inline const ::std::string& name() const;
163  inline void set_name(const ::std::string& value);
164  inline void set_name(const char* value);
165  inline void set_name(const char* value, size_t size);
166  inline ::std::string* mutable_name();
167  inline ::std::string* release_name();
168  inline void set_allocated_name(::std::string* name);
169 
170  // @@protoc_insertion_point(class_scope:drizzled.message.FieldMetadata)
171  private:
172  inline void set_has_type();
173  inline void clear_has_type();
174  inline void set_has_name();
175  inline void clear_has_name();
176 
177  ::google::protobuf::UnknownFieldSet _unknown_fields_;
178 
179  ::std::string* name_;
180  int type_;
181 
182  mutable int _cached_size_;
183  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
184 
185  friend void protobuf_AddDesc_transaction_2eproto();
186  friend void protobuf_AssignDesc_transaction_2eproto();
187  friend void protobuf_ShutdownFile_transaction_2eproto();
188 
189  void InitAsDefaultInstance();
190  static FieldMetadata* default_instance_;
191 };
192 // -------------------------------------------------------------------
193 
194 class TableMetadata : public ::google::protobuf::Message {
195  public:
196  TableMetadata();
197  virtual ~TableMetadata();
198 
199  TableMetadata(const TableMetadata& from);
200 
201  inline TableMetadata& operator=(const TableMetadata& from) {
202  CopyFrom(from);
203  return *this;
204  }
205 
206  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
207  return _unknown_fields_;
208  }
209 
210  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
211  return &_unknown_fields_;
212  }
213 
214  static const ::google::protobuf::Descriptor* descriptor();
215  static const TableMetadata& default_instance();
216 
217  void Swap(TableMetadata* other);
218 
219  // implements Message ----------------------------------------------
220 
221  TableMetadata* New() const;
222  void CopyFrom(const ::google::protobuf::Message& from);
223  void MergeFrom(const ::google::protobuf::Message& from);
224  void CopyFrom(const TableMetadata& from);
225  void MergeFrom(const TableMetadata& from);
226  void Clear();
227  bool IsInitialized() const;
228 
229  int ByteSize() const;
230  bool MergePartialFromCodedStream(
231  ::google::protobuf::io::CodedInputStream* input);
232  void SerializeWithCachedSizes(
233  ::google::protobuf::io::CodedOutputStream* output) const;
234  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
235  int GetCachedSize() const { return _cached_size_; }
236  private:
237  void SharedCtor();
238  void SharedDtor();
239  void SetCachedSize(int size) const;
240  public:
241 
242  ::google::protobuf::Metadata GetMetadata() const;
243 
244  // nested types ----------------------------------------------------
245 
246  // accessors -------------------------------------------------------
247 
248  // required string schema_name = 1;
249  inline bool has_schema_name() const;
250  inline void clear_schema_name();
251  static const int kSchemaNameFieldNumber = 1;
252  inline const ::std::string& schema_name() const;
253  inline void set_schema_name(const ::std::string& value);
254  inline void set_schema_name(const char* value);
255  inline void set_schema_name(const char* value, size_t size);
256  inline ::std::string* mutable_schema_name();
257  inline ::std::string* release_schema_name();
258  inline void set_allocated_schema_name(::std::string* schema_name);
259 
260  // required string table_name = 2;
261  inline bool has_table_name() const;
262  inline void clear_table_name();
263  static const int kTableNameFieldNumber = 2;
264  inline const ::std::string& table_name() const;
265  inline void set_table_name(const ::std::string& value);
266  inline void set_table_name(const char* value);
267  inline void set_table_name(const char* value, size_t size);
268  inline ::std::string* mutable_table_name();
269  inline ::std::string* release_table_name();
270  inline void set_allocated_table_name(::std::string* table_name);
271 
272  // optional string catalog_name = 3;
273  inline bool has_catalog_name() const;
274  inline void clear_catalog_name();
275  static const int kCatalogNameFieldNumber = 3;
276  inline const ::std::string& catalog_name() const;
277  inline void set_catalog_name(const ::std::string& value);
278  inline void set_catalog_name(const char* value);
279  inline void set_catalog_name(const char* value, size_t size);
280  inline ::std::string* mutable_catalog_name();
281  inline ::std::string* release_catalog_name();
282  inline void set_allocated_catalog_name(::std::string* catalog_name);
283 
284  // @@protoc_insertion_point(class_scope:drizzled.message.TableMetadata)
285  private:
286  inline void set_has_schema_name();
287  inline void clear_has_schema_name();
288  inline void set_has_table_name();
289  inline void clear_has_table_name();
290  inline void set_has_catalog_name();
291  inline void clear_has_catalog_name();
292 
293  ::google::protobuf::UnknownFieldSet _unknown_fields_;
294 
295  ::std::string* schema_name_;
296  ::std::string* table_name_;
297  ::std::string* catalog_name_;
298 
299  mutable int _cached_size_;
300  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
301 
302  friend void protobuf_AddDesc_transaction_2eproto();
303  friend void protobuf_AssignDesc_transaction_2eproto();
304  friend void protobuf_ShutdownFile_transaction_2eproto();
305 
306  void InitAsDefaultInstance();
307  static TableMetadata* default_instance_;
308 };
309 // -------------------------------------------------------------------
310 
311 class TransactionContext : public ::google::protobuf::Message {
312  public:
314  virtual ~TransactionContext();
315 
317 
318  inline TransactionContext& operator=(const TransactionContext& from) {
319  CopyFrom(from);
320  return *this;
321  }
322 
323  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
324  return _unknown_fields_;
325  }
326 
327  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
328  return &_unknown_fields_;
329  }
330 
331  static const ::google::protobuf::Descriptor* descriptor();
332  static const TransactionContext& default_instance();
333 
334  void Swap(TransactionContext* other);
335 
336  // implements Message ----------------------------------------------
337 
338  TransactionContext* New() const;
339  void CopyFrom(const ::google::protobuf::Message& from);
340  void MergeFrom(const ::google::protobuf::Message& from);
341  void CopyFrom(const TransactionContext& from);
342  void MergeFrom(const TransactionContext& from);
343  void Clear();
344  bool IsInitialized() const;
345 
346  int ByteSize() const;
347  bool MergePartialFromCodedStream(
348  ::google::protobuf::io::CodedInputStream* input);
349  void SerializeWithCachedSizes(
350  ::google::protobuf::io::CodedOutputStream* output) const;
351  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
352  int GetCachedSize() const { return _cached_size_; }
353  private:
354  void SharedCtor();
355  void SharedDtor();
356  void SetCachedSize(int size) const;
357  public:
358 
359  ::google::protobuf::Metadata GetMetadata() const;
360 
361  // nested types ----------------------------------------------------
362 
363  // accessors -------------------------------------------------------
364 
365  // required uint32 server_id = 1;
366  inline bool has_server_id() const;
367  inline void clear_server_id();
368  static const int kServerIdFieldNumber = 1;
369  inline ::google::protobuf::uint32 server_id() const;
370  inline void set_server_id(::google::protobuf::uint32 value);
371 
372  // required uint64 transaction_id = 2;
373  inline bool has_transaction_id() const;
374  inline void clear_transaction_id();
375  static const int kTransactionIdFieldNumber = 2;
376  inline ::google::protobuf::uint64 transaction_id() const;
377  inline void set_transaction_id(::google::protobuf::uint64 value);
378 
379  // required uint64 start_timestamp = 3;
380  inline bool has_start_timestamp() const;
381  inline void clear_start_timestamp();
382  static const int kStartTimestampFieldNumber = 3;
383  inline ::google::protobuf::uint64 start_timestamp() const;
384  inline void set_start_timestamp(::google::protobuf::uint64 value);
385 
386  // required uint64 end_timestamp = 4;
387  inline bool has_end_timestamp() const;
388  inline void clear_end_timestamp();
389  static const int kEndTimestampFieldNumber = 4;
390  inline ::google::protobuf::uint64 end_timestamp() const;
391  inline void set_end_timestamp(::google::protobuf::uint64 value);
392 
393  // @@protoc_insertion_point(class_scope:drizzled.message.TransactionContext)
394  private:
395  inline void set_has_server_id();
396  inline void clear_has_server_id();
397  inline void set_has_transaction_id();
398  inline void clear_has_transaction_id();
399  inline void set_has_start_timestamp();
400  inline void clear_has_start_timestamp();
401  inline void set_has_end_timestamp();
402  inline void clear_has_end_timestamp();
403 
404  ::google::protobuf::UnknownFieldSet _unknown_fields_;
405 
406  ::google::protobuf::uint64 transaction_id_;
407  ::google::protobuf::uint64 start_timestamp_;
408  ::google::protobuf::uint64 end_timestamp_;
409  ::google::protobuf::uint32 server_id_;
410 
411  mutable int _cached_size_;
412  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
413 
414  friend void protobuf_AddDesc_transaction_2eproto();
415  friend void protobuf_AssignDesc_transaction_2eproto();
416  friend void protobuf_ShutdownFile_transaction_2eproto();
417 
418  void InitAsDefaultInstance();
419  static TransactionContext* default_instance_;
420 };
421 // -------------------------------------------------------------------
422 
423 class InsertRecord : public ::google::protobuf::Message {
424  public:
425  InsertRecord();
426  virtual ~InsertRecord();
427 
428  InsertRecord(const InsertRecord& from);
429 
430  inline InsertRecord& operator=(const InsertRecord& from) {
431  CopyFrom(from);
432  return *this;
433  }
434 
435  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
436  return _unknown_fields_;
437  }
438 
439  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
440  return &_unknown_fields_;
441  }
442 
443  static const ::google::protobuf::Descriptor* descriptor();
444  static const InsertRecord& default_instance();
445 
446  void Swap(InsertRecord* other);
447 
448  // implements Message ----------------------------------------------
449 
450  InsertRecord* New() const;
451  void CopyFrom(const ::google::protobuf::Message& from);
452  void MergeFrom(const ::google::protobuf::Message& from);
453  void CopyFrom(const InsertRecord& from);
454  void MergeFrom(const InsertRecord& from);
455  void Clear();
456  bool IsInitialized() const;
457 
458  int ByteSize() const;
459  bool MergePartialFromCodedStream(
460  ::google::protobuf::io::CodedInputStream* input);
461  void SerializeWithCachedSizes(
462  ::google::protobuf::io::CodedOutputStream* output) const;
463  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
464  int GetCachedSize() const { return _cached_size_; }
465  private:
466  void SharedCtor();
467  void SharedDtor();
468  void SetCachedSize(int size) const;
469  public:
470 
471  ::google::protobuf::Metadata GetMetadata() const;
472 
473  // nested types ----------------------------------------------------
474 
475  // accessors -------------------------------------------------------
476 
477  // repeated bytes insert_value = 1;
478  inline int insert_value_size() const;
479  inline void clear_insert_value();
480  static const int kInsertValueFieldNumber = 1;
481  inline const ::std::string& insert_value(int index) const;
482  inline ::std::string* mutable_insert_value(int index);
483  inline void set_insert_value(int index, const ::std::string& value);
484  inline void set_insert_value(int index, const char* value);
485  inline void set_insert_value(int index, const void* value, size_t size);
486  inline ::std::string* add_insert_value();
487  inline void add_insert_value(const ::std::string& value);
488  inline void add_insert_value(const char* value);
489  inline void add_insert_value(const void* value, size_t size);
490  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& insert_value() const;
491  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_insert_value();
492 
493  // repeated bool is_null = 2;
494  inline int is_null_size() const;
495  inline void clear_is_null();
496  static const int kIsNullFieldNumber = 2;
497  inline bool is_null(int index) const;
498  inline void set_is_null(int index, bool value);
499  inline void add_is_null(bool value);
500  inline const ::google::protobuf::RepeatedField< bool >&
501  is_null() const;
502  inline ::google::protobuf::RepeatedField< bool >*
503  mutable_is_null();
504 
505  // @@protoc_insertion_point(class_scope:drizzled.message.InsertRecord)
506  private:
507 
508  ::google::protobuf::UnknownFieldSet _unknown_fields_;
509 
510  ::google::protobuf::RepeatedPtrField< ::std::string> insert_value_;
511  ::google::protobuf::RepeatedField< bool > is_null_;
512 
513  mutable int _cached_size_;
514  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
515 
516  friend void protobuf_AddDesc_transaction_2eproto();
517  friend void protobuf_AssignDesc_transaction_2eproto();
518  friend void protobuf_ShutdownFile_transaction_2eproto();
519 
520  void InitAsDefaultInstance();
521  static InsertRecord* default_instance_;
522 };
523 // -------------------------------------------------------------------
524 
525 class InsertHeader : public ::google::protobuf::Message {
526  public:
527  InsertHeader();
528  virtual ~InsertHeader();
529 
530  InsertHeader(const InsertHeader& from);
531 
532  inline InsertHeader& operator=(const InsertHeader& from) {
533  CopyFrom(from);
534  return *this;
535  }
536 
537  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
538  return _unknown_fields_;
539  }
540 
541  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
542  return &_unknown_fields_;
543  }
544 
545  static const ::google::protobuf::Descriptor* descriptor();
546  static const InsertHeader& default_instance();
547 
548  void Swap(InsertHeader* other);
549 
550  // implements Message ----------------------------------------------
551 
552  InsertHeader* New() const;
553  void CopyFrom(const ::google::protobuf::Message& from);
554  void MergeFrom(const ::google::protobuf::Message& from);
555  void CopyFrom(const InsertHeader& from);
556  void MergeFrom(const InsertHeader& from);
557  void Clear();
558  bool IsInitialized() const;
559 
560  int ByteSize() const;
561  bool MergePartialFromCodedStream(
562  ::google::protobuf::io::CodedInputStream* input);
563  void SerializeWithCachedSizes(
564  ::google::protobuf::io::CodedOutputStream* output) const;
565  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
566  int GetCachedSize() const { return _cached_size_; }
567  private:
568  void SharedCtor();
569  void SharedDtor();
570  void SetCachedSize(int size) const;
571  public:
572 
573  ::google::protobuf::Metadata GetMetadata() const;
574 
575  // nested types ----------------------------------------------------
576 
577  // accessors -------------------------------------------------------
578 
579  // required .drizzled.message.TableMetadata table_metadata = 1;
580  inline bool has_table_metadata() const;
581  inline void clear_table_metadata();
582  static const int kTableMetadataFieldNumber = 1;
583  inline const ::drizzled::message::TableMetadata& table_metadata() const;
584  inline ::drizzled::message::TableMetadata* mutable_table_metadata();
585  inline ::drizzled::message::TableMetadata* release_table_metadata();
586  inline void set_allocated_table_metadata(::drizzled::message::TableMetadata* table_metadata);
587 
588  // repeated .drizzled.message.FieldMetadata field_metadata = 2;
589  inline int field_metadata_size() const;
590  inline void clear_field_metadata();
591  static const int kFieldMetadataFieldNumber = 2;
592  inline const ::drizzled::message::FieldMetadata& field_metadata(int index) const;
593  inline ::drizzled::message::FieldMetadata* mutable_field_metadata(int index);
594  inline ::drizzled::message::FieldMetadata* add_field_metadata();
595  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
596  field_metadata() const;
597  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
598  mutable_field_metadata();
599 
600  // @@protoc_insertion_point(class_scope:drizzled.message.InsertHeader)
601  private:
602  inline void set_has_table_metadata();
603  inline void clear_has_table_metadata();
604 
605  ::google::protobuf::UnknownFieldSet _unknown_fields_;
606 
607  ::drizzled::message::TableMetadata* table_metadata_;
608  ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata > field_metadata_;
609 
610  mutable int _cached_size_;
611  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
612 
613  friend void protobuf_AddDesc_transaction_2eproto();
614  friend void protobuf_AssignDesc_transaction_2eproto();
615  friend void protobuf_ShutdownFile_transaction_2eproto();
616 
617  void InitAsDefaultInstance();
618  static InsertHeader* default_instance_;
619 };
620 // -------------------------------------------------------------------
621 
622 class InsertData : public ::google::protobuf::Message {
623  public:
624  InsertData();
625  virtual ~InsertData();
626 
627  InsertData(const InsertData& from);
628 
629  inline InsertData& operator=(const InsertData& from) {
630  CopyFrom(from);
631  return *this;
632  }
633 
634  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
635  return _unknown_fields_;
636  }
637 
638  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
639  return &_unknown_fields_;
640  }
641 
642  static const ::google::protobuf::Descriptor* descriptor();
643  static const InsertData& default_instance();
644 
645  void Swap(InsertData* other);
646 
647  // implements Message ----------------------------------------------
648 
649  InsertData* New() const;
650  void CopyFrom(const ::google::protobuf::Message& from);
651  void MergeFrom(const ::google::protobuf::Message& from);
652  void CopyFrom(const InsertData& from);
653  void MergeFrom(const InsertData& from);
654  void Clear();
655  bool IsInitialized() const;
656 
657  int ByteSize() const;
658  bool MergePartialFromCodedStream(
659  ::google::protobuf::io::CodedInputStream* input);
660  void SerializeWithCachedSizes(
661  ::google::protobuf::io::CodedOutputStream* output) const;
662  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
663  int GetCachedSize() const { return _cached_size_; }
664  private:
665  void SharedCtor();
666  void SharedDtor();
667  void SetCachedSize(int size) const;
668  public:
669 
670  ::google::protobuf::Metadata GetMetadata() const;
671 
672  // nested types ----------------------------------------------------
673 
674  // accessors -------------------------------------------------------
675 
676  // required uint32 segment_id = 1;
677  inline bool has_segment_id() const;
678  inline void clear_segment_id();
679  static const int kSegmentIdFieldNumber = 1;
680  inline ::google::protobuf::uint32 segment_id() const;
681  inline void set_segment_id(::google::protobuf::uint32 value);
682 
683  // required bool end_segment = 2;
684  inline bool has_end_segment() const;
685  inline void clear_end_segment();
686  static const int kEndSegmentFieldNumber = 2;
687  inline bool end_segment() const;
688  inline void set_end_segment(bool value);
689 
690  // repeated .drizzled.message.InsertRecord record = 3;
691  inline int record_size() const;
692  inline void clear_record();
693  static const int kRecordFieldNumber = 3;
694  inline const ::drizzled::message::InsertRecord& record(int index) const;
695  inline ::drizzled::message::InsertRecord* mutable_record(int index);
696  inline ::drizzled::message::InsertRecord* add_record();
697  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::InsertRecord >&
698  record() const;
699  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::InsertRecord >*
700  mutable_record();
701 
702  // @@protoc_insertion_point(class_scope:drizzled.message.InsertData)
703  private:
704  inline void set_has_segment_id();
705  inline void clear_has_segment_id();
706  inline void set_has_end_segment();
707  inline void clear_has_end_segment();
708 
709  ::google::protobuf::UnknownFieldSet _unknown_fields_;
710 
711  ::google::protobuf::uint32 segment_id_;
712  bool end_segment_;
713  ::google::protobuf::RepeatedPtrField< ::drizzled::message::InsertRecord > record_;
714 
715  mutable int _cached_size_;
716  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
717 
718  friend void protobuf_AddDesc_transaction_2eproto();
719  friend void protobuf_AssignDesc_transaction_2eproto();
720  friend void protobuf_ShutdownFile_transaction_2eproto();
721 
722  void InitAsDefaultInstance();
723  static InsertData* default_instance_;
724 };
725 // -------------------------------------------------------------------
726 
727 class UpdateRecord : public ::google::protobuf::Message {
728  public:
729  UpdateRecord();
730  virtual ~UpdateRecord();
731 
732  UpdateRecord(const UpdateRecord& from);
733 
734  inline UpdateRecord& operator=(const UpdateRecord& from) {
735  CopyFrom(from);
736  return *this;
737  }
738 
739  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
740  return _unknown_fields_;
741  }
742 
743  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
744  return &_unknown_fields_;
745  }
746 
747  static const ::google::protobuf::Descriptor* descriptor();
748  static const UpdateRecord& default_instance();
749 
750  void Swap(UpdateRecord* other);
751 
752  // implements Message ----------------------------------------------
753 
754  UpdateRecord* New() const;
755  void CopyFrom(const ::google::protobuf::Message& from);
756  void MergeFrom(const ::google::protobuf::Message& from);
757  void CopyFrom(const UpdateRecord& from);
758  void MergeFrom(const UpdateRecord& from);
759  void Clear();
760  bool IsInitialized() const;
761 
762  int ByteSize() const;
763  bool MergePartialFromCodedStream(
764  ::google::protobuf::io::CodedInputStream* input);
765  void SerializeWithCachedSizes(
766  ::google::protobuf::io::CodedOutputStream* output) const;
767  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
768  int GetCachedSize() const { return _cached_size_; }
769  private:
770  void SharedCtor();
771  void SharedDtor();
772  void SetCachedSize(int size) const;
773  public:
774 
775  ::google::protobuf::Metadata GetMetadata() const;
776 
777  // nested types ----------------------------------------------------
778 
779  // accessors -------------------------------------------------------
780 
781  // repeated bytes key_value = 1;
782  inline int key_value_size() const;
783  inline void clear_key_value();
784  static const int kKeyValueFieldNumber = 1;
785  inline const ::std::string& key_value(int index) const;
786  inline ::std::string* mutable_key_value(int index);
787  inline void set_key_value(int index, const ::std::string& value);
788  inline void set_key_value(int index, const char* value);
789  inline void set_key_value(int index, const void* value, size_t size);
790  inline ::std::string* add_key_value();
791  inline void add_key_value(const ::std::string& value);
792  inline void add_key_value(const char* value);
793  inline void add_key_value(const void* value, size_t size);
794  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& key_value() const;
795  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_key_value();
796 
797  // repeated bytes after_value = 2;
798  inline int after_value_size() const;
799  inline void clear_after_value();
800  static const int kAfterValueFieldNumber = 2;
801  inline const ::std::string& after_value(int index) const;
802  inline ::std::string* mutable_after_value(int index);
803  inline void set_after_value(int index, const ::std::string& value);
804  inline void set_after_value(int index, const char* value);
805  inline void set_after_value(int index, const void* value, size_t size);
806  inline ::std::string* add_after_value();
807  inline void add_after_value(const ::std::string& value);
808  inline void add_after_value(const char* value);
809  inline void add_after_value(const void* value, size_t size);
810  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& after_value() const;
811  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_after_value();
812 
813  // repeated bytes before_value = 3;
814  inline int before_value_size() const;
815  inline void clear_before_value();
816  static const int kBeforeValueFieldNumber = 3;
817  inline const ::std::string& before_value(int index) const;
818  inline ::std::string* mutable_before_value(int index);
819  inline void set_before_value(int index, const ::std::string& value);
820  inline void set_before_value(int index, const char* value);
821  inline void set_before_value(int index, const void* value, size_t size);
822  inline ::std::string* add_before_value();
823  inline void add_before_value(const ::std::string& value);
824  inline void add_before_value(const char* value);
825  inline void add_before_value(const void* value, size_t size);
826  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& before_value() const;
827  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_before_value();
828 
829  // repeated bool is_null = 4;
830  inline int is_null_size() const;
831  inline void clear_is_null();
832  static const int kIsNullFieldNumber = 4;
833  inline bool is_null(int index) const;
834  inline void set_is_null(int index, bool value);
835  inline void add_is_null(bool value);
836  inline const ::google::protobuf::RepeatedField< bool >&
837  is_null() const;
838  inline ::google::protobuf::RepeatedField< bool >*
839  mutable_is_null();
840 
841  // @@protoc_insertion_point(class_scope:drizzled.message.UpdateRecord)
842  private:
843 
844  ::google::protobuf::UnknownFieldSet _unknown_fields_;
845 
846  ::google::protobuf::RepeatedPtrField< ::std::string> key_value_;
847  ::google::protobuf::RepeatedPtrField< ::std::string> after_value_;
848  ::google::protobuf::RepeatedPtrField< ::std::string> before_value_;
849  ::google::protobuf::RepeatedField< bool > is_null_;
850 
851  mutable int _cached_size_;
852  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
853 
854  friend void protobuf_AddDesc_transaction_2eproto();
855  friend void protobuf_AssignDesc_transaction_2eproto();
856  friend void protobuf_ShutdownFile_transaction_2eproto();
857 
858  void InitAsDefaultInstance();
859  static UpdateRecord* default_instance_;
860 };
861 // -------------------------------------------------------------------
862 
863 class UpdateHeader : public ::google::protobuf::Message {
864  public:
865  UpdateHeader();
866  virtual ~UpdateHeader();
867 
868  UpdateHeader(const UpdateHeader& from);
869 
870  inline UpdateHeader& operator=(const UpdateHeader& from) {
871  CopyFrom(from);
872  return *this;
873  }
874 
875  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
876  return _unknown_fields_;
877  }
878 
879  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
880  return &_unknown_fields_;
881  }
882 
883  static const ::google::protobuf::Descriptor* descriptor();
884  static const UpdateHeader& default_instance();
885 
886  void Swap(UpdateHeader* other);
887 
888  // implements Message ----------------------------------------------
889 
890  UpdateHeader* New() const;
891  void CopyFrom(const ::google::protobuf::Message& from);
892  void MergeFrom(const ::google::protobuf::Message& from);
893  void CopyFrom(const UpdateHeader& from);
894  void MergeFrom(const UpdateHeader& from);
895  void Clear();
896  bool IsInitialized() const;
897 
898  int ByteSize() const;
899  bool MergePartialFromCodedStream(
900  ::google::protobuf::io::CodedInputStream* input);
901  void SerializeWithCachedSizes(
902  ::google::protobuf::io::CodedOutputStream* output) const;
903  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
904  int GetCachedSize() const { return _cached_size_; }
905  private:
906  void SharedCtor();
907  void SharedDtor();
908  void SetCachedSize(int size) const;
909  public:
910 
911  ::google::protobuf::Metadata GetMetadata() const;
912 
913  // nested types ----------------------------------------------------
914 
915  // accessors -------------------------------------------------------
916 
917  // required .drizzled.message.TableMetadata table_metadata = 1;
918  inline bool has_table_metadata() const;
919  inline void clear_table_metadata();
920  static const int kTableMetadataFieldNumber = 1;
921  inline const ::drizzled::message::TableMetadata& table_metadata() const;
922  inline ::drizzled::message::TableMetadata* mutable_table_metadata();
923  inline ::drizzled::message::TableMetadata* release_table_metadata();
924  inline void set_allocated_table_metadata(::drizzled::message::TableMetadata* table_metadata);
925 
926  // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
927  inline int key_field_metadata_size() const;
928  inline void clear_key_field_metadata();
929  static const int kKeyFieldMetadataFieldNumber = 2;
930  inline const ::drizzled::message::FieldMetadata& key_field_metadata(int index) const;
931  inline ::drizzled::message::FieldMetadata* mutable_key_field_metadata(int index);
932  inline ::drizzled::message::FieldMetadata* add_key_field_metadata();
933  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
934  key_field_metadata() const;
935  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
936  mutable_key_field_metadata();
937 
938  // repeated .drizzled.message.FieldMetadata set_field_metadata = 3;
939  inline int set_field_metadata_size() const;
940  inline void clear_set_field_metadata();
941  static const int kSetFieldMetadataFieldNumber = 3;
942  inline const ::drizzled::message::FieldMetadata& set_field_metadata(int index) const;
943  inline ::drizzled::message::FieldMetadata* mutable_set_field_metadata(int index);
944  inline ::drizzled::message::FieldMetadata* add_set_field_metadata();
945  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
946  set_field_metadata() const;
947  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
948  mutable_set_field_metadata();
949 
950  // @@protoc_insertion_point(class_scope:drizzled.message.UpdateHeader)
951  private:
952  inline void set_has_table_metadata();
953  inline void clear_has_table_metadata();
954 
955  ::google::protobuf::UnknownFieldSet _unknown_fields_;
956 
957  ::drizzled::message::TableMetadata* table_metadata_;
958  ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata > key_field_metadata_;
959  ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata > set_field_metadata_;
960 
961  mutable int _cached_size_;
962  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
963 
964  friend void protobuf_AddDesc_transaction_2eproto();
965  friend void protobuf_AssignDesc_transaction_2eproto();
966  friend void protobuf_ShutdownFile_transaction_2eproto();
967 
968  void InitAsDefaultInstance();
969  static UpdateHeader* default_instance_;
970 };
971 // -------------------------------------------------------------------
972 
973 class UpdateData : public ::google::protobuf::Message {
974  public:
975  UpdateData();
976  virtual ~UpdateData();
977 
978  UpdateData(const UpdateData& from);
979 
980  inline UpdateData& operator=(const UpdateData& from) {
981  CopyFrom(from);
982  return *this;
983  }
984 
985  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
986  return _unknown_fields_;
987  }
988 
989  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
990  return &_unknown_fields_;
991  }
992 
993  static const ::google::protobuf::Descriptor* descriptor();
994  static const UpdateData& default_instance();
995 
996  void Swap(UpdateData* other);
997 
998  // implements Message ----------------------------------------------
999 
1000  UpdateData* New() const;
1001  void CopyFrom(const ::google::protobuf::Message& from);
1002  void MergeFrom(const ::google::protobuf::Message& from);
1003  void CopyFrom(const UpdateData& from);
1004  void MergeFrom(const UpdateData& from);
1005  void Clear();
1006  bool IsInitialized() const;
1007 
1008  int ByteSize() const;
1009  bool MergePartialFromCodedStream(
1010  ::google::protobuf::io::CodedInputStream* input);
1011  void SerializeWithCachedSizes(
1012  ::google::protobuf::io::CodedOutputStream* output) const;
1013  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1014  int GetCachedSize() const { return _cached_size_; }
1015  private:
1016  void SharedCtor();
1017  void SharedDtor();
1018  void SetCachedSize(int size) const;
1019  public:
1020 
1021  ::google::protobuf::Metadata GetMetadata() const;
1022 
1023  // nested types ----------------------------------------------------
1024 
1025  // accessors -------------------------------------------------------
1026 
1027  // required uint32 segment_id = 1;
1028  inline bool has_segment_id() const;
1029  inline void clear_segment_id();
1030  static const int kSegmentIdFieldNumber = 1;
1031  inline ::google::protobuf::uint32 segment_id() const;
1032  inline void set_segment_id(::google::protobuf::uint32 value);
1033 
1034  // required bool end_segment = 2;
1035  inline bool has_end_segment() const;
1036  inline void clear_end_segment();
1037  static const int kEndSegmentFieldNumber = 2;
1038  inline bool end_segment() const;
1039  inline void set_end_segment(bool value);
1040 
1041  // repeated .drizzled.message.UpdateRecord record = 3;
1042  inline int record_size() const;
1043  inline void clear_record();
1044  static const int kRecordFieldNumber = 3;
1045  inline const ::drizzled::message::UpdateRecord& record(int index) const;
1046  inline ::drizzled::message::UpdateRecord* mutable_record(int index);
1047  inline ::drizzled::message::UpdateRecord* add_record();
1048  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::UpdateRecord >&
1049  record() const;
1050  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::UpdateRecord >*
1051  mutable_record();
1052 
1053  // @@protoc_insertion_point(class_scope:drizzled.message.UpdateData)
1054  private:
1055  inline void set_has_segment_id();
1056  inline void clear_has_segment_id();
1057  inline void set_has_end_segment();
1058  inline void clear_has_end_segment();
1059 
1060  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1061 
1062  ::google::protobuf::uint32 segment_id_;
1063  bool end_segment_;
1064  ::google::protobuf::RepeatedPtrField< ::drizzled::message::UpdateRecord > record_;
1065 
1066  mutable int _cached_size_;
1067  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
1068 
1069  friend void protobuf_AddDesc_transaction_2eproto();
1070  friend void protobuf_AssignDesc_transaction_2eproto();
1071  friend void protobuf_ShutdownFile_transaction_2eproto();
1072 
1073  void InitAsDefaultInstance();
1074  static UpdateData* default_instance_;
1075 };
1076 // -------------------------------------------------------------------
1077 
1078 class DeleteRecord : public ::google::protobuf::Message {
1079  public:
1080  DeleteRecord();
1081  virtual ~DeleteRecord();
1082 
1083  DeleteRecord(const DeleteRecord& from);
1084 
1085  inline DeleteRecord& operator=(const DeleteRecord& from) {
1086  CopyFrom(from);
1087  return *this;
1088  }
1089 
1090  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1091  return _unknown_fields_;
1092  }
1093 
1094  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1095  return &_unknown_fields_;
1096  }
1097 
1098  static const ::google::protobuf::Descriptor* descriptor();
1099  static const DeleteRecord& default_instance();
1100 
1101  void Swap(DeleteRecord* other);
1102 
1103  // implements Message ----------------------------------------------
1104 
1105  DeleteRecord* New() const;
1106  void CopyFrom(const ::google::protobuf::Message& from);
1107  void MergeFrom(const ::google::protobuf::Message& from);
1108  void CopyFrom(const DeleteRecord& from);
1109  void MergeFrom(const DeleteRecord& from);
1110  void Clear();
1111  bool IsInitialized() const;
1112 
1113  int ByteSize() const;
1114  bool MergePartialFromCodedStream(
1115  ::google::protobuf::io::CodedInputStream* input);
1116  void SerializeWithCachedSizes(
1117  ::google::protobuf::io::CodedOutputStream* output) const;
1118  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1119  int GetCachedSize() const { return _cached_size_; }
1120  private:
1121  void SharedCtor();
1122  void SharedDtor();
1123  void SetCachedSize(int size) const;
1124  public:
1125 
1126  ::google::protobuf::Metadata GetMetadata() const;
1127 
1128  // nested types ----------------------------------------------------
1129 
1130  // accessors -------------------------------------------------------
1131 
1132  // repeated bytes key_value = 1;
1133  inline int key_value_size() const;
1134  inline void clear_key_value();
1135  static const int kKeyValueFieldNumber = 1;
1136  inline const ::std::string& key_value(int index) const;
1137  inline ::std::string* mutable_key_value(int index);
1138  inline void set_key_value(int index, const ::std::string& value);
1139  inline void set_key_value(int index, const char* value);
1140  inline void set_key_value(int index, const void* value, size_t size);
1141  inline ::std::string* add_key_value();
1142  inline void add_key_value(const ::std::string& value);
1143  inline void add_key_value(const char* value);
1144  inline void add_key_value(const void* value, size_t size);
1145  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& key_value() const;
1146  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_key_value();
1147 
1148  // @@protoc_insertion_point(class_scope:drizzled.message.DeleteRecord)
1149  private:
1150 
1151  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1152 
1153  ::google::protobuf::RepeatedPtrField< ::std::string> key_value_;
1154 
1155  mutable int _cached_size_;
1156  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
1157 
1158  friend void protobuf_AddDesc_transaction_2eproto();
1159  friend void protobuf_AssignDesc_transaction_2eproto();
1160  friend void protobuf_ShutdownFile_transaction_2eproto();
1161 
1162  void InitAsDefaultInstance();
1163  static DeleteRecord* default_instance_;
1164 };
1165 // -------------------------------------------------------------------
1166 
1167 class DeleteHeader : public ::google::protobuf::Message {
1168  public:
1169  DeleteHeader();
1170  virtual ~DeleteHeader();
1171 
1172  DeleteHeader(const DeleteHeader& from);
1173 
1174  inline DeleteHeader& operator=(const DeleteHeader& from) {
1175  CopyFrom(from);
1176  return *this;
1177  }
1178 
1179  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1180  return _unknown_fields_;
1181  }
1182 
1183  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1184  return &_unknown_fields_;
1185  }
1186 
1187  static const ::google::protobuf::Descriptor* descriptor();
1188  static const DeleteHeader& default_instance();
1189 
1190  void Swap(DeleteHeader* other);
1191 
1192  // implements Message ----------------------------------------------
1193 
1194  DeleteHeader* New() const;
1195  void CopyFrom(const ::google::protobuf::Message& from);
1196  void MergeFrom(const ::google::protobuf::Message& from);
1197  void CopyFrom(const DeleteHeader& from);
1198  void MergeFrom(const DeleteHeader& from);
1199  void Clear();
1200  bool IsInitialized() const;
1201 
1202  int ByteSize() const;
1203  bool MergePartialFromCodedStream(
1204  ::google::protobuf::io::CodedInputStream* input);
1205  void SerializeWithCachedSizes(
1206  ::google::protobuf::io::CodedOutputStream* output) const;
1207  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1208  int GetCachedSize() const { return _cached_size_; }
1209  private:
1210  void SharedCtor();
1211  void SharedDtor();
1212  void SetCachedSize(int size) const;
1213  public:
1214 
1215  ::google::protobuf::Metadata GetMetadata() const;
1216 
1217  // nested types ----------------------------------------------------
1218 
1219  // accessors -------------------------------------------------------
1220 
1221  // required .drizzled.message.TableMetadata table_metadata = 1;
1222  inline bool has_table_metadata() const;
1223  inline void clear_table_metadata();
1224  static const int kTableMetadataFieldNumber = 1;
1225  inline const ::drizzled::message::TableMetadata& table_metadata() const;
1226  inline ::drizzled::message::TableMetadata* mutable_table_metadata();
1227  inline ::drizzled::message::TableMetadata* release_table_metadata();
1228  inline void set_allocated_table_metadata(::drizzled::message::TableMetadata* table_metadata);
1229 
1230  // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
1231  inline int key_field_metadata_size() const;
1232  inline void clear_key_field_metadata();
1233  static const int kKeyFieldMetadataFieldNumber = 2;
1234  inline const ::drizzled::message::FieldMetadata& key_field_metadata(int index) const;
1235  inline ::drizzled::message::FieldMetadata* mutable_key_field_metadata(int index);
1236  inline ::drizzled::message::FieldMetadata* add_key_field_metadata();
1237  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
1238  key_field_metadata() const;
1239  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
1240  mutable_key_field_metadata();
1241 
1242  // @@protoc_insertion_point(class_scope:drizzled.message.DeleteHeader)
1243  private:
1244  inline void set_has_table_metadata();
1245  inline void clear_has_table_metadata();
1246 
1247  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1248 
1249  ::drizzled::message::TableMetadata* table_metadata_;
1250  ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata > key_field_metadata_;
1251 
1252  mutable int _cached_size_;
1253  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
1254 
1255  friend void protobuf_AddDesc_transaction_2eproto();
1256  friend void protobuf_AssignDesc_transaction_2eproto();
1257  friend void protobuf_ShutdownFile_transaction_2eproto();
1258 
1259  void InitAsDefaultInstance();
1260  static DeleteHeader* default_instance_;
1261 };
1262 // -------------------------------------------------------------------
1263 
1264 class DeleteData : public ::google::protobuf::Message {
1265  public:
1266  DeleteData();
1267  virtual ~DeleteData();
1268 
1269  DeleteData(const DeleteData& from);
1270 
1271  inline DeleteData& operator=(const DeleteData& from) {
1272  CopyFrom(from);
1273  return *this;
1274  }
1275 
1276  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1277  return _unknown_fields_;
1278  }
1279 
1280  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1281  return &_unknown_fields_;
1282  }
1283 
1284  static const ::google::protobuf::Descriptor* descriptor();
1285  static const DeleteData& default_instance();
1286 
1287  void Swap(DeleteData* other);
1288 
1289  // implements Message ----------------------------------------------
1290 
1291  DeleteData* New() const;
1292  void CopyFrom(const ::google::protobuf::Message& from);
1293  void MergeFrom(const ::google::protobuf::Message& from);
1294  void CopyFrom(const DeleteData& from);
1295  void MergeFrom(const DeleteData& from);
1296  void Clear();
1297  bool IsInitialized() const;
1298 
1299  int ByteSize() const;
1300  bool MergePartialFromCodedStream(
1301  ::google::protobuf::io::CodedInputStream* input);
1302  void SerializeWithCachedSizes(
1303  ::google::protobuf::io::CodedOutputStream* output) const;
1304  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1305  int GetCachedSize() const { return _cached_size_; }
1306  private:
1307  void SharedCtor();
1308  void SharedDtor();
1309  void SetCachedSize(int size) const;
1310  public:
1311 
1312  ::google::protobuf::Metadata GetMetadata() const;
1313 
1314  // nested types ----------------------------------------------------
1315 
1316  // accessors -------------------------------------------------------
1317 
1318  // required uint32 segment_id = 1;
1319  inline bool has_segment_id() const;
1320  inline void clear_segment_id();
1321  static const int kSegmentIdFieldNumber = 1;
1322  inline ::google::protobuf::uint32 segment_id() const;
1323  inline void set_segment_id(::google::protobuf::uint32 value);
1324 
1325  // required bool end_segment = 2;
1326  inline bool has_end_segment() const;
1327  inline void clear_end_segment();
1328  static const int kEndSegmentFieldNumber = 2;
1329  inline bool end_segment() const;
1330  inline void set_end_segment(bool value);
1331 
1332  // repeated .drizzled.message.DeleteRecord record = 3;
1333  inline int record_size() const;
1334  inline void clear_record();
1335  static const int kRecordFieldNumber = 3;
1336  inline const ::drizzled::message::DeleteRecord& record(int index) const;
1337  inline ::drizzled::message::DeleteRecord* mutable_record(int index);
1338  inline ::drizzled::message::DeleteRecord* add_record();
1339  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::DeleteRecord >&
1340  record() const;
1341  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::DeleteRecord >*
1342  mutable_record();
1343 
1344  // @@protoc_insertion_point(class_scope:drizzled.message.DeleteData)
1345  private:
1346  inline void set_has_segment_id();
1347  inline void clear_has_segment_id();
1348  inline void set_has_end_segment();
1349  inline void clear_has_end_segment();
1350 
1351  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1352 
1353  ::google::protobuf::uint32 segment_id_;
1354  bool end_segment_;
1355  ::google::protobuf::RepeatedPtrField< ::drizzled::message::DeleteRecord > record_;
1356 
1357  mutable int _cached_size_;
1358  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
1359 
1360  friend void protobuf_AddDesc_transaction_2eproto();
1361  friend void protobuf_AssignDesc_transaction_2eproto();
1362  friend void protobuf_ShutdownFile_transaction_2eproto();
1363 
1364  void InitAsDefaultInstance();
1365  static DeleteData* default_instance_;
1366 };
1367 // -------------------------------------------------------------------
1368 
1369 class TruncateTableStatement : public ::google::protobuf::Message {
1370  public:
1372  virtual ~TruncateTableStatement();
1373 
1375 
1376  inline TruncateTableStatement& operator=(const TruncateTableStatement& from) {
1377  CopyFrom(from);
1378  return *this;
1379  }
1380 
1381  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1382  return _unknown_fields_;
1383  }
1384 
1385  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1386  return &_unknown_fields_;
1387  }
1388 
1389  static const ::google::protobuf::Descriptor* descriptor();
1390  static const TruncateTableStatement& default_instance();
1391 
1392  void Swap(TruncateTableStatement* other);
1393 
1394  // implements Message ----------------------------------------------
1395 
1396  TruncateTableStatement* New() const;
1397  void CopyFrom(const ::google::protobuf::Message& from);
1398  void MergeFrom(const ::google::protobuf::Message& from);
1399  void CopyFrom(const TruncateTableStatement& from);
1400  void MergeFrom(const TruncateTableStatement& from);
1401  void Clear();
1402  bool IsInitialized() const;
1403 
1404  int ByteSize() const;
1405  bool MergePartialFromCodedStream(
1406  ::google::protobuf::io::CodedInputStream* input);
1407  void SerializeWithCachedSizes(
1408  ::google::protobuf::io::CodedOutputStream* output) const;
1409  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1410  int GetCachedSize() const { return _cached_size_; }
1411  private:
1412  void SharedCtor();
1413  void SharedDtor();
1414  void SetCachedSize(int size) const;
1415  public:
1416 
1417  ::google::protobuf::Metadata GetMetadata() const;
1418 
1419  // nested types ----------------------------------------------------
1420 
1421  // accessors -------------------------------------------------------
1422 
1423  // required .drizzled.message.TableMetadata table_metadata = 1;
1424  inline bool has_table_metadata() const;
1425  inline void clear_table_metadata();
1426  static const int kTableMetadataFieldNumber = 1;
1427  inline const ::drizzled::message::TableMetadata& table_metadata() const;
1428  inline ::drizzled::message::TableMetadata* mutable_table_metadata();
1429  inline ::drizzled::message::TableMetadata* release_table_metadata();
1430  inline void set_allocated_table_metadata(::drizzled::message::TableMetadata* table_metadata);
1431 
1432  // @@protoc_insertion_point(class_scope:drizzled.message.TruncateTableStatement)
1433  private:
1434  inline void set_has_table_metadata();
1435  inline void clear_has_table_metadata();
1436 
1437  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1438 
1439  ::drizzled::message::TableMetadata* table_metadata_;
1440 
1441  mutable int _cached_size_;
1442  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
1443 
1444  friend void protobuf_AddDesc_transaction_2eproto();
1445  friend void protobuf_AssignDesc_transaction_2eproto();
1446  friend void protobuf_ShutdownFile_transaction_2eproto();
1447 
1448  void InitAsDefaultInstance();
1449  static TruncateTableStatement* default_instance_;
1450 };
1451 // -------------------------------------------------------------------
1452 
1453 class CreateSchemaStatement : public ::google::protobuf::Message {
1454  public:
1456  virtual ~CreateSchemaStatement();
1457 
1459 
1460  inline CreateSchemaStatement& operator=(const CreateSchemaStatement& from) {
1461  CopyFrom(from);
1462  return *this;
1463  }
1464 
1465  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1466  return _unknown_fields_;
1467  }
1468 
1469  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1470  return &_unknown_fields_;
1471  }
1472 
1473  static const ::google::protobuf::Descriptor* descriptor();
1474  static const CreateSchemaStatement& default_instance();
1475 
1476  void Swap(CreateSchemaStatement* other);
1477 
1478  // implements Message ----------------------------------------------
1479 
1480  CreateSchemaStatement* New() const;
1481  void CopyFrom(const ::google::protobuf::Message& from);
1482  void MergeFrom(const ::google::protobuf::Message& from);
1483  void CopyFrom(const CreateSchemaStatement& from);
1484  void MergeFrom(const CreateSchemaStatement& from);
1485  void Clear();
1486  bool IsInitialized() const;
1487 
1488  int ByteSize() const;
1489  bool MergePartialFromCodedStream(
1490  ::google::protobuf::io::CodedInputStream* input);
1491  void SerializeWithCachedSizes(
1492  ::google::protobuf::io::CodedOutputStream* output) const;
1493  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1494  int GetCachedSize() const { return _cached_size_; }
1495  private:
1496  void SharedCtor();
1497  void SharedDtor();
1498  void SetCachedSize(int size) const;
1499  public:
1500 
1501  ::google::protobuf::Metadata GetMetadata() const;
1502 
1503  // nested types ----------------------------------------------------
1504 
1505  // accessors -------------------------------------------------------
1506 
1507  // required .drizzled.message.Schema schema = 1;
1508  inline bool has_schema() const;
1509  inline void clear_schema();
1510  static const int kSchemaFieldNumber = 1;
1511  inline const ::drizzled::message::Schema& schema() const;
1512  inline ::drizzled::message::Schema* mutable_schema();
1513  inline ::drizzled::message::Schema* release_schema();
1514  inline void set_allocated_schema(::drizzled::message::Schema* schema);
1515 
1516  // @@protoc_insertion_point(class_scope:drizzled.message.CreateSchemaStatement)
1517  private:
1518  inline void set_has_schema();
1519  inline void clear_has_schema();
1520 
1521  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1522 
1523  ::drizzled::message::Schema* schema_;
1524 
1525  mutable int _cached_size_;
1526  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
1527 
1528  friend void protobuf_AddDesc_transaction_2eproto();
1529  friend void protobuf_AssignDesc_transaction_2eproto();
1530  friend void protobuf_ShutdownFile_transaction_2eproto();
1531 
1532  void InitAsDefaultInstance();
1533  static CreateSchemaStatement* default_instance_;
1534 };
1535 // -------------------------------------------------------------------
1536 
1537 class AlterSchemaStatement : public ::google::protobuf::Message {
1538  public:
1540  virtual ~AlterSchemaStatement();
1541 
1543 
1544  inline AlterSchemaStatement& operator=(const AlterSchemaStatement& from) {
1545  CopyFrom(from);
1546  return *this;
1547  }
1548 
1549  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1550  return _unknown_fields_;
1551  }
1552 
1553  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1554  return &_unknown_fields_;
1555  }
1556 
1557  static const ::google::protobuf::Descriptor* descriptor();
1558  static const AlterSchemaStatement& default_instance();
1559 
1560  void Swap(AlterSchemaStatement* other);
1561 
1562  // implements Message ----------------------------------------------
1563 
1564  AlterSchemaStatement* New() const;
1565  void CopyFrom(const ::google::protobuf::Message& from);
1566  void MergeFrom(const ::google::protobuf::Message& from);
1567  void CopyFrom(const AlterSchemaStatement& from);
1568  void MergeFrom(const AlterSchemaStatement& from);
1569  void Clear();
1570  bool IsInitialized() const;
1571 
1572  int ByteSize() const;
1573  bool MergePartialFromCodedStream(
1574  ::google::protobuf::io::CodedInputStream* input);
1575  void SerializeWithCachedSizes(
1576  ::google::protobuf::io::CodedOutputStream* output) const;
1577  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1578  int GetCachedSize() const { return _cached_size_; }
1579  private:
1580  void SharedCtor();
1581  void SharedDtor();
1582  void SetCachedSize(int size) const;
1583  public:
1584 
1585  ::google::protobuf::Metadata GetMetadata() const;
1586 
1587  // nested types ----------------------------------------------------
1588 
1589  // accessors -------------------------------------------------------
1590 
1591  // required .drizzled.message.Schema before = 1;
1592  inline bool has_before() const;
1593  inline void clear_before();
1594  static const int kBeforeFieldNumber = 1;
1595  inline const ::drizzled::message::Schema& before() const;
1596  inline ::drizzled::message::Schema* mutable_before();
1597  inline ::drizzled::message::Schema* release_before();
1598  inline void set_allocated_before(::drizzled::message::Schema* before);
1599 
1600  // required .drizzled.message.Schema after = 2;
1601  inline bool has_after() const;
1602  inline void clear_after();
1603  static const int kAfterFieldNumber = 2;
1604  inline const ::drizzled::message::Schema& after() const;
1605  inline ::drizzled::message::Schema* mutable_after();
1606  inline ::drizzled::message::Schema* release_after();
1607  inline void set_allocated_after(::drizzled::message::Schema* after);
1608 
1609  // @@protoc_insertion_point(class_scope:drizzled.message.AlterSchemaStatement)
1610  private:
1611  inline void set_has_before();
1612  inline void clear_has_before();
1613  inline void set_has_after();
1614  inline void clear_has_after();
1615 
1616  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1617 
1618  ::drizzled::message::Schema* before_;
1620 
1621  mutable int _cached_size_;
1622  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
1623 
1624  friend void protobuf_AddDesc_transaction_2eproto();
1625  friend void protobuf_AssignDesc_transaction_2eproto();
1626  friend void protobuf_ShutdownFile_transaction_2eproto();
1627 
1628  void InitAsDefaultInstance();
1629  static AlterSchemaStatement* default_instance_;
1630 };
1631 // -------------------------------------------------------------------
1632 
1633 class DropSchemaStatement : public ::google::protobuf::Message {
1634  public:
1636  virtual ~DropSchemaStatement();
1637 
1639 
1640  inline DropSchemaStatement& operator=(const DropSchemaStatement& from) {
1641  CopyFrom(from);
1642  return *this;
1643  }
1644 
1645  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1646  return _unknown_fields_;
1647  }
1648 
1649  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1650  return &_unknown_fields_;
1651  }
1652 
1653  static const ::google::protobuf::Descriptor* descriptor();
1654  static const DropSchemaStatement& default_instance();
1655 
1656  void Swap(DropSchemaStatement* other);
1657 
1658  // implements Message ----------------------------------------------
1659 
1660  DropSchemaStatement* New() const;
1661  void CopyFrom(const ::google::protobuf::Message& from);
1662  void MergeFrom(const ::google::protobuf::Message& from);
1663  void CopyFrom(const DropSchemaStatement& from);
1664  void MergeFrom(const DropSchemaStatement& from);
1665  void Clear();
1666  bool IsInitialized() const;
1667 
1668  int ByteSize() const;
1669  bool MergePartialFromCodedStream(
1670  ::google::protobuf::io::CodedInputStream* input);
1671  void SerializeWithCachedSizes(
1672  ::google::protobuf::io::CodedOutputStream* output) const;
1673  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1674  int GetCachedSize() const { return _cached_size_; }
1675  private:
1676  void SharedCtor();
1677  void SharedDtor();
1678  void SetCachedSize(int size) const;
1679  public:
1680 
1681  ::google::protobuf::Metadata GetMetadata() const;
1682 
1683  // nested types ----------------------------------------------------
1684 
1685  // accessors -------------------------------------------------------
1686 
1687  // required string schema_name = 1;
1688  inline bool has_schema_name() const;
1689  inline void clear_schema_name();
1690  static const int kSchemaNameFieldNumber = 1;
1691  inline const ::std::string& schema_name() const;
1692  inline void set_schema_name(const ::std::string& value);
1693  inline void set_schema_name(const char* value);
1694  inline void set_schema_name(const char* value, size_t size);
1695  inline ::std::string* mutable_schema_name();
1696  inline ::std::string* release_schema_name();
1697  inline void set_allocated_schema_name(::std::string* schema_name);
1698 
1699  // optional string catalog_name = 2;
1700  inline bool has_catalog_name() const;
1701  inline void clear_catalog_name();
1702  static const int kCatalogNameFieldNumber = 2;
1703  inline const ::std::string& catalog_name() const;
1704  inline void set_catalog_name(const ::std::string& value);
1705  inline void set_catalog_name(const char* value);
1706  inline void set_catalog_name(const char* value, size_t size);
1707  inline ::std::string* mutable_catalog_name();
1708  inline ::std::string* release_catalog_name();
1709  inline void set_allocated_catalog_name(::std::string* catalog_name);
1710 
1711  // @@protoc_insertion_point(class_scope:drizzled.message.DropSchemaStatement)
1712  private:
1713  inline void set_has_schema_name();
1714  inline void clear_has_schema_name();
1715  inline void set_has_catalog_name();
1716  inline void clear_has_catalog_name();
1717 
1718  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1719 
1720  ::std::string* schema_name_;
1721  ::std::string* catalog_name_;
1722 
1723  mutable int _cached_size_;
1724  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
1725 
1726  friend void protobuf_AddDesc_transaction_2eproto();
1727  friend void protobuf_AssignDesc_transaction_2eproto();
1728  friend void protobuf_ShutdownFile_transaction_2eproto();
1729 
1730  void InitAsDefaultInstance();
1731  static DropSchemaStatement* default_instance_;
1732 };
1733 // -------------------------------------------------------------------
1734 
1735 class CreateTableStatement : public ::google::protobuf::Message {
1736  public:
1738  virtual ~CreateTableStatement();
1739 
1741 
1742  inline CreateTableStatement& operator=(const CreateTableStatement& from) {
1743  CopyFrom(from);
1744  return *this;
1745  }
1746 
1747  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1748  return _unknown_fields_;
1749  }
1750 
1751  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1752  return &_unknown_fields_;
1753  }
1754 
1755  static const ::google::protobuf::Descriptor* descriptor();
1756  static const CreateTableStatement& default_instance();
1757 
1758  void Swap(CreateTableStatement* other);
1759 
1760  // implements Message ----------------------------------------------
1761 
1762  CreateTableStatement* New() const;
1763  void CopyFrom(const ::google::protobuf::Message& from);
1764  void MergeFrom(const ::google::protobuf::Message& from);
1765  void CopyFrom(const CreateTableStatement& from);
1766  void MergeFrom(const CreateTableStatement& from);
1767  void Clear();
1768  bool IsInitialized() const;
1769 
1770  int ByteSize() const;
1771  bool MergePartialFromCodedStream(
1772  ::google::protobuf::io::CodedInputStream* input);
1773  void SerializeWithCachedSizes(
1774  ::google::protobuf::io::CodedOutputStream* output) const;
1775  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1776  int GetCachedSize() const { return _cached_size_; }
1777  private:
1778  void SharedCtor();
1779  void SharedDtor();
1780  void SetCachedSize(int size) const;
1781  public:
1782 
1783  ::google::protobuf::Metadata GetMetadata() const;
1784 
1785  // nested types ----------------------------------------------------
1786 
1787  // accessors -------------------------------------------------------
1788 
1789  // required .drizzled.message.Table table = 1;
1790  inline bool has_table() const;
1791  inline void clear_table();
1792  static const int kTableFieldNumber = 1;
1793  inline const ::drizzled::message::Table& table() const;
1794  inline ::drizzled::message::Table* mutable_table();
1795  inline ::drizzled::message::Table* release_table();
1796  inline void set_allocated_table(::drizzled::message::Table* table);
1797 
1798  // @@protoc_insertion_point(class_scope:drizzled.message.CreateTableStatement)
1799  private:
1800  inline void set_has_table();
1801  inline void clear_has_table();
1802 
1803  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1804 
1806 
1807  mutable int _cached_size_;
1808  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
1809 
1810  friend void protobuf_AddDesc_transaction_2eproto();
1811  friend void protobuf_AssignDesc_transaction_2eproto();
1812  friend void protobuf_ShutdownFile_transaction_2eproto();
1813 
1814  void InitAsDefaultInstance();
1815  static CreateTableStatement* default_instance_;
1816 };
1817 // -------------------------------------------------------------------
1818 
1819 class AlterTableStatement : public ::google::protobuf::Message {
1820  public:
1822  virtual ~AlterTableStatement();
1823 
1825 
1826  inline AlterTableStatement& operator=(const AlterTableStatement& from) {
1827  CopyFrom(from);
1828  return *this;
1829  }
1830 
1831  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1832  return _unknown_fields_;
1833  }
1834 
1835  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1836  return &_unknown_fields_;
1837  }
1838 
1839  static const ::google::protobuf::Descriptor* descriptor();
1840  static const AlterTableStatement& default_instance();
1841 
1842  void Swap(AlterTableStatement* other);
1843 
1844  // implements Message ----------------------------------------------
1845 
1846  AlterTableStatement* New() const;
1847  void CopyFrom(const ::google::protobuf::Message& from);
1848  void MergeFrom(const ::google::protobuf::Message& from);
1849  void CopyFrom(const AlterTableStatement& from);
1850  void MergeFrom(const AlterTableStatement& from);
1851  void Clear();
1852  bool IsInitialized() const;
1853 
1854  int ByteSize() const;
1855  bool MergePartialFromCodedStream(
1856  ::google::protobuf::io::CodedInputStream* input);
1857  void SerializeWithCachedSizes(
1858  ::google::protobuf::io::CodedOutputStream* output) const;
1859  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1860  int GetCachedSize() const { return _cached_size_; }
1861  private:
1862  void SharedCtor();
1863  void SharedDtor();
1864  void SetCachedSize(int size) const;
1865  public:
1866 
1867  ::google::protobuf::Metadata GetMetadata() const;
1868 
1869  // nested types ----------------------------------------------------
1870 
1871  // accessors -------------------------------------------------------
1872 
1873  // required .drizzled.message.Table before = 1;
1874  inline bool has_before() const;
1875  inline void clear_before();
1876  static const int kBeforeFieldNumber = 1;
1877  inline const ::drizzled::message::Table& before() const;
1878  inline ::drizzled::message::Table* mutable_before();
1879  inline ::drizzled::message::Table* release_before();
1880  inline void set_allocated_before(::drizzled::message::Table* before);
1881 
1882  // required .drizzled.message.Table after = 2;
1883  inline bool has_after() const;
1884  inline void clear_after();
1885  static const int kAfterFieldNumber = 2;
1886  inline const ::drizzled::message::Table& after() const;
1887  inline ::drizzled::message::Table* mutable_after();
1888  inline ::drizzled::message::Table* release_after();
1889  inline void set_allocated_after(::drizzled::message::Table* after);
1890 
1891  // @@protoc_insertion_point(class_scope:drizzled.message.AlterTableStatement)
1892  private:
1893  inline void set_has_before();
1894  inline void clear_has_before();
1895  inline void set_has_after();
1896  inline void clear_has_after();
1897 
1898  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1899 
1900  ::drizzled::message::Table* before_;
1902 
1903  mutable int _cached_size_;
1904  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
1905 
1906  friend void protobuf_AddDesc_transaction_2eproto();
1907  friend void protobuf_AssignDesc_transaction_2eproto();
1908  friend void protobuf_ShutdownFile_transaction_2eproto();
1909 
1910  void InitAsDefaultInstance();
1911  static AlterTableStatement* default_instance_;
1912 };
1913 // -------------------------------------------------------------------
1914 
1915 class DropTableStatement : public ::google::protobuf::Message {
1916  public:
1918  virtual ~DropTableStatement();
1919 
1921 
1922  inline DropTableStatement& operator=(const DropTableStatement& from) {
1923  CopyFrom(from);
1924  return *this;
1925  }
1926 
1927  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
1928  return _unknown_fields_;
1929  }
1930 
1931  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
1932  return &_unknown_fields_;
1933  }
1934 
1935  static const ::google::protobuf::Descriptor* descriptor();
1936  static const DropTableStatement& default_instance();
1937 
1938  void Swap(DropTableStatement* other);
1939 
1940  // implements Message ----------------------------------------------
1941 
1942  DropTableStatement* New() const;
1943  void CopyFrom(const ::google::protobuf::Message& from);
1944  void MergeFrom(const ::google::protobuf::Message& from);
1945  void CopyFrom(const DropTableStatement& from);
1946  void MergeFrom(const DropTableStatement& from);
1947  void Clear();
1948  bool IsInitialized() const;
1949 
1950  int ByteSize() const;
1951  bool MergePartialFromCodedStream(
1952  ::google::protobuf::io::CodedInputStream* input);
1953  void SerializeWithCachedSizes(
1954  ::google::protobuf::io::CodedOutputStream* output) const;
1955  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
1956  int GetCachedSize() const { return _cached_size_; }
1957  private:
1958  void SharedCtor();
1959  void SharedDtor();
1960  void SetCachedSize(int size) const;
1961  public:
1962 
1963  ::google::protobuf::Metadata GetMetadata() const;
1964 
1965  // nested types ----------------------------------------------------
1966 
1967  // accessors -------------------------------------------------------
1968 
1969  // required .drizzled.message.TableMetadata table_metadata = 1;
1970  inline bool has_table_metadata() const;
1971  inline void clear_table_metadata();
1972  static const int kTableMetadataFieldNumber = 1;
1973  inline const ::drizzled::message::TableMetadata& table_metadata() const;
1974  inline ::drizzled::message::TableMetadata* mutable_table_metadata();
1975  inline ::drizzled::message::TableMetadata* release_table_metadata();
1976  inline void set_allocated_table_metadata(::drizzled::message::TableMetadata* table_metadata);
1977 
1978  // optional bool if_exists_clause = 2;
1979  inline bool has_if_exists_clause() const;
1980  inline void clear_if_exists_clause();
1981  static const int kIfExistsClauseFieldNumber = 2;
1982  inline bool if_exists_clause() const;
1983  inline void set_if_exists_clause(bool value);
1984 
1985  // @@protoc_insertion_point(class_scope:drizzled.message.DropTableStatement)
1986  private:
1987  inline void set_has_table_metadata();
1988  inline void clear_has_table_metadata();
1989  inline void set_has_if_exists_clause();
1990  inline void clear_has_if_exists_clause();
1991 
1992  ::google::protobuf::UnknownFieldSet _unknown_fields_;
1993 
1994  ::drizzled::message::TableMetadata* table_metadata_;
1995  bool if_exists_clause_;
1996 
1997  mutable int _cached_size_;
1998  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
1999 
2000  friend void protobuf_AddDesc_transaction_2eproto();
2001  friend void protobuf_AssignDesc_transaction_2eproto();
2002  friend void protobuf_ShutdownFile_transaction_2eproto();
2003 
2004  void InitAsDefaultInstance();
2005  static DropTableStatement* default_instance_;
2006 };
2007 // -------------------------------------------------------------------
2008 
2009 class SetVariableStatement : public ::google::protobuf::Message {
2010  public:
2012  virtual ~SetVariableStatement();
2013 
2015 
2016  inline SetVariableStatement& operator=(const SetVariableStatement& from) {
2017  CopyFrom(from);
2018  return *this;
2019  }
2020 
2021  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2022  return _unknown_fields_;
2023  }
2024 
2025  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2026  return &_unknown_fields_;
2027  }
2028 
2029  static const ::google::protobuf::Descriptor* descriptor();
2030  static const SetVariableStatement& default_instance();
2031 
2032  void Swap(SetVariableStatement* other);
2033 
2034  // implements Message ----------------------------------------------
2035 
2036  SetVariableStatement* New() const;
2037  void CopyFrom(const ::google::protobuf::Message& from);
2038  void MergeFrom(const ::google::protobuf::Message& from);
2039  void CopyFrom(const SetVariableStatement& from);
2040  void MergeFrom(const SetVariableStatement& from);
2041  void Clear();
2042  bool IsInitialized() const;
2043 
2044  int ByteSize() const;
2045  bool MergePartialFromCodedStream(
2046  ::google::protobuf::io::CodedInputStream* input);
2047  void SerializeWithCachedSizes(
2048  ::google::protobuf::io::CodedOutputStream* output) const;
2049  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
2050  int GetCachedSize() const { return _cached_size_; }
2051  private:
2052  void SharedCtor();
2053  void SharedDtor();
2054  void SetCachedSize(int size) const;
2055  public:
2056 
2057  ::google::protobuf::Metadata GetMetadata() const;
2058 
2059  // nested types ----------------------------------------------------
2060 
2061  // accessors -------------------------------------------------------
2062 
2063  // required .drizzled.message.FieldMetadata variable_metadata = 1;
2064  inline bool has_variable_metadata() const;
2065  inline void clear_variable_metadata();
2066  static const int kVariableMetadataFieldNumber = 1;
2067  inline const ::drizzled::message::FieldMetadata& variable_metadata() const;
2068  inline ::drizzled::message::FieldMetadata* mutable_variable_metadata();
2069  inline ::drizzled::message::FieldMetadata* release_variable_metadata();
2070  inline void set_allocated_variable_metadata(::drizzled::message::FieldMetadata* variable_metadata);
2071 
2072  // required bytes variable_value = 2;
2073  inline bool has_variable_value() const;
2074  inline void clear_variable_value();
2075  static const int kVariableValueFieldNumber = 2;
2076  inline const ::std::string& variable_value() const;
2077  inline void set_variable_value(const ::std::string& value);
2078  inline void set_variable_value(const char* value);
2079  inline void set_variable_value(const void* value, size_t size);
2080  inline ::std::string* mutable_variable_value();
2081  inline ::std::string* release_variable_value();
2082  inline void set_allocated_variable_value(::std::string* variable_value);
2083 
2084  // @@protoc_insertion_point(class_scope:drizzled.message.SetVariableStatement)
2085  private:
2086  inline void set_has_variable_metadata();
2087  inline void clear_has_variable_metadata();
2088  inline void set_has_variable_value();
2089  inline void clear_has_variable_value();
2090 
2091  ::google::protobuf::UnknownFieldSet _unknown_fields_;
2092 
2093  ::drizzled::message::FieldMetadata* variable_metadata_;
2094  ::std::string* variable_value_;
2095 
2096  mutable int _cached_size_;
2097  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
2098 
2099  friend void protobuf_AddDesc_transaction_2eproto();
2100  friend void protobuf_AssignDesc_transaction_2eproto();
2101  friend void protobuf_ShutdownFile_transaction_2eproto();
2102 
2103  void InitAsDefaultInstance();
2104  static SetVariableStatement* default_instance_;
2105 };
2106 // -------------------------------------------------------------------
2107 
2108 class Statement : public ::google::protobuf::Message {
2109  public:
2110  Statement();
2111  virtual ~Statement();
2112 
2113  Statement(const Statement& from);
2114 
2115  inline Statement& operator=(const Statement& from) {
2116  CopyFrom(from);
2117  return *this;
2118  }
2119 
2120  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2121  return _unknown_fields_;
2122  }
2123 
2124  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2125  return &_unknown_fields_;
2126  }
2127 
2128  static const ::google::protobuf::Descriptor* descriptor();
2129  static const Statement& default_instance();
2130 
2131  void Swap(Statement* other);
2132 
2133  // implements Message ----------------------------------------------
2134 
2135  Statement* New() const;
2136  void CopyFrom(const ::google::protobuf::Message& from);
2137  void MergeFrom(const ::google::protobuf::Message& from);
2138  void CopyFrom(const Statement& from);
2139  void MergeFrom(const Statement& from);
2140  void Clear();
2141  bool IsInitialized() const;
2142 
2143  int ByteSize() const;
2144  bool MergePartialFromCodedStream(
2145  ::google::protobuf::io::CodedInputStream* input);
2146  void SerializeWithCachedSizes(
2147  ::google::protobuf::io::CodedOutputStream* output) const;
2148  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
2149  int GetCachedSize() const { return _cached_size_; }
2150  private:
2151  void SharedCtor();
2152  void SharedDtor();
2153  void SetCachedSize(int size) const;
2154  public:
2155 
2156  ::google::protobuf::Metadata GetMetadata() const;
2157 
2158  // nested types ----------------------------------------------------
2159 
2160  typedef Statement_Type Type;
2161  static const Type ROLLBACK = Statement_Type_ROLLBACK;
2162  static const Type INSERT = Statement_Type_INSERT;
2163  static const Type DELETE = Statement_Type_DELETE;
2164  static const Type UPDATE = Statement_Type_UPDATE;
2165  static const Type TRUNCATE_TABLE = Statement_Type_TRUNCATE_TABLE;
2166  static const Type CREATE_SCHEMA = Statement_Type_CREATE_SCHEMA;
2167  static const Type ALTER_SCHEMA = Statement_Type_ALTER_SCHEMA;
2168  static const Type DROP_SCHEMA = Statement_Type_DROP_SCHEMA;
2169  static const Type CREATE_TABLE = Statement_Type_CREATE_TABLE;
2170  static const Type ALTER_TABLE = Statement_Type_ALTER_TABLE;
2171  static const Type DROP_TABLE = Statement_Type_DROP_TABLE;
2172  static const Type ROLLBACK_STATEMENT = Statement_Type_ROLLBACK_STATEMENT;
2173  static const Type SET_VARIABLE = Statement_Type_SET_VARIABLE;
2174  static const Type RAW_SQL = Statement_Type_RAW_SQL;
2175  static inline bool Type_IsValid(int value) {
2176  return Statement_Type_IsValid(value);
2177  }
2178  static const Type Type_MIN =
2179  Statement_Type_Type_MIN;
2180  static const Type Type_MAX =
2181  Statement_Type_Type_MAX;
2182  static const int Type_ARRAYSIZE =
2183  Statement_Type_Type_ARRAYSIZE;
2184  static inline const ::google::protobuf::EnumDescriptor*
2185  Type_descriptor() {
2186  return Statement_Type_descriptor();
2187  }
2188  static inline const ::std::string& Type_Name(Type value) {
2189  return Statement_Type_Name(value);
2190  }
2191  static inline bool Type_Parse(const ::std::string& name,
2192  Type* value) {
2193  return Statement_Type_Parse(name, value);
2194  }
2195 
2196  // accessors -------------------------------------------------------
2197 
2198  // required .drizzled.message.Statement.Type type = 1;
2199  inline bool has_type() const;
2200  inline void clear_type();
2201  static const int kTypeFieldNumber = 1;
2202  inline ::drizzled::message::Statement_Type type() const;
2203  inline void set_type(::drizzled::message::Statement_Type value);
2204 
2205  // required uint64 start_timestamp = 2;
2206  inline bool has_start_timestamp() const;
2207  inline void clear_start_timestamp();
2208  static const int kStartTimestampFieldNumber = 2;
2209  inline ::google::protobuf::uint64 start_timestamp() const;
2210  inline void set_start_timestamp(::google::protobuf::uint64 value);
2211 
2212  // required uint64 end_timestamp = 3;
2213  inline bool has_end_timestamp() const;
2214  inline void clear_end_timestamp();
2215  static const int kEndTimestampFieldNumber = 3;
2216  inline ::google::protobuf::uint64 end_timestamp() const;
2217  inline void set_end_timestamp(::google::protobuf::uint64 value);
2218 
2219  // optional string sql = 4;
2220  inline bool has_sql() const;
2221  inline void clear_sql();
2222  static const int kSqlFieldNumber = 4;
2223  inline const ::std::string& sql() const;
2224  inline void set_sql(const ::std::string& value);
2225  inline void set_sql(const char* value);
2226  inline void set_sql(const char* value, size_t size);
2227  inline ::std::string* mutable_sql();
2228  inline ::std::string* release_sql();
2229  inline void set_allocated_sql(::std::string* sql);
2230 
2231  // optional .drizzled.message.InsertHeader insert_header = 5;
2232  inline bool has_insert_header() const;
2233  inline void clear_insert_header();
2234  static const int kInsertHeaderFieldNumber = 5;
2235  inline const ::drizzled::message::InsertHeader& insert_header() const;
2236  inline ::drizzled::message::InsertHeader* mutable_insert_header();
2237  inline ::drizzled::message::InsertHeader* release_insert_header();
2238  inline void set_allocated_insert_header(::drizzled::message::InsertHeader* insert_header);
2239 
2240  // optional .drizzled.message.InsertData insert_data = 6;
2241  inline bool has_insert_data() const;
2242  inline void clear_insert_data();
2243  static const int kInsertDataFieldNumber = 6;
2244  inline const ::drizzled::message::InsertData& insert_data() const;
2245  inline ::drizzled::message::InsertData* mutable_insert_data();
2246  inline ::drizzled::message::InsertData* release_insert_data();
2247  inline void set_allocated_insert_data(::drizzled::message::InsertData* insert_data);
2248 
2249  // optional .drizzled.message.UpdateHeader update_header = 7;
2250  inline bool has_update_header() const;
2251  inline void clear_update_header();
2252  static const int kUpdateHeaderFieldNumber = 7;
2253  inline const ::drizzled::message::UpdateHeader& update_header() const;
2254  inline ::drizzled::message::UpdateHeader* mutable_update_header();
2255  inline ::drizzled::message::UpdateHeader* release_update_header();
2256  inline void set_allocated_update_header(::drizzled::message::UpdateHeader* update_header);
2257 
2258  // optional .drizzled.message.UpdateData update_data = 8;
2259  inline bool has_update_data() const;
2260  inline void clear_update_data();
2261  static const int kUpdateDataFieldNumber = 8;
2262  inline const ::drizzled::message::UpdateData& update_data() const;
2263  inline ::drizzled::message::UpdateData* mutable_update_data();
2264  inline ::drizzled::message::UpdateData* release_update_data();
2265  inline void set_allocated_update_data(::drizzled::message::UpdateData* update_data);
2266 
2267  // optional .drizzled.message.DeleteHeader delete_header = 9;
2268  inline bool has_delete_header() const;
2269  inline void clear_delete_header();
2270  static const int kDeleteHeaderFieldNumber = 9;
2271  inline const ::drizzled::message::DeleteHeader& delete_header() const;
2272  inline ::drizzled::message::DeleteHeader* mutable_delete_header();
2273  inline ::drizzled::message::DeleteHeader* release_delete_header();
2274  inline void set_allocated_delete_header(::drizzled::message::DeleteHeader* delete_header);
2275 
2276  // optional .drizzled.message.DeleteData delete_data = 10;
2277  inline bool has_delete_data() const;
2278  inline void clear_delete_data();
2279  static const int kDeleteDataFieldNumber = 10;
2280  inline const ::drizzled::message::DeleteData& delete_data() const;
2281  inline ::drizzled::message::DeleteData* mutable_delete_data();
2282  inline ::drizzled::message::DeleteData* release_delete_data();
2283  inline void set_allocated_delete_data(::drizzled::message::DeleteData* delete_data);
2284 
2285  // optional .drizzled.message.TruncateTableStatement truncate_table_statement = 11;
2286  inline bool has_truncate_table_statement() const;
2287  inline void clear_truncate_table_statement();
2288  static const int kTruncateTableStatementFieldNumber = 11;
2289  inline const ::drizzled::message::TruncateTableStatement& truncate_table_statement() const;
2290  inline ::drizzled::message::TruncateTableStatement* mutable_truncate_table_statement();
2291  inline ::drizzled::message::TruncateTableStatement* release_truncate_table_statement();
2292  inline void set_allocated_truncate_table_statement(::drizzled::message::TruncateTableStatement* truncate_table_statement);
2293 
2294  // optional .drizzled.message.CreateSchemaStatement create_schema_statement = 12;
2295  inline bool has_create_schema_statement() const;
2296  inline void clear_create_schema_statement();
2297  static const int kCreateSchemaStatementFieldNumber = 12;
2298  inline const ::drizzled::message::CreateSchemaStatement& create_schema_statement() const;
2299  inline ::drizzled::message::CreateSchemaStatement* mutable_create_schema_statement();
2300  inline ::drizzled::message::CreateSchemaStatement* release_create_schema_statement();
2301  inline void set_allocated_create_schema_statement(::drizzled::message::CreateSchemaStatement* create_schema_statement);
2302 
2303  // optional .drizzled.message.DropSchemaStatement drop_schema_statement = 13;
2304  inline bool has_drop_schema_statement() const;
2305  inline void clear_drop_schema_statement();
2306  static const int kDropSchemaStatementFieldNumber = 13;
2307  inline const ::drizzled::message::DropSchemaStatement& drop_schema_statement() const;
2308  inline ::drizzled::message::DropSchemaStatement* mutable_drop_schema_statement();
2309  inline ::drizzled::message::DropSchemaStatement* release_drop_schema_statement();
2310  inline void set_allocated_drop_schema_statement(::drizzled::message::DropSchemaStatement* drop_schema_statement);
2311 
2312  // optional .drizzled.message.AlterSchemaStatement alter_schema_statement = 14;
2313  inline bool has_alter_schema_statement() const;
2314  inline void clear_alter_schema_statement();
2315  static const int kAlterSchemaStatementFieldNumber = 14;
2316  inline const ::drizzled::message::AlterSchemaStatement& alter_schema_statement() const;
2317  inline ::drizzled::message::AlterSchemaStatement* mutable_alter_schema_statement();
2318  inline ::drizzled::message::AlterSchemaStatement* release_alter_schema_statement();
2319  inline void set_allocated_alter_schema_statement(::drizzled::message::AlterSchemaStatement* alter_schema_statement);
2320 
2321  // optional .drizzled.message.CreateTableStatement create_table_statement = 15;
2322  inline bool has_create_table_statement() const;
2323  inline void clear_create_table_statement();
2324  static const int kCreateTableStatementFieldNumber = 15;
2325  inline const ::drizzled::message::CreateTableStatement& create_table_statement() const;
2326  inline ::drizzled::message::CreateTableStatement* mutable_create_table_statement();
2327  inline ::drizzled::message::CreateTableStatement* release_create_table_statement();
2328  inline void set_allocated_create_table_statement(::drizzled::message::CreateTableStatement* create_table_statement);
2329 
2330  // optional .drizzled.message.AlterTableStatement alter_table_statement = 16;
2331  inline bool has_alter_table_statement() const;
2332  inline void clear_alter_table_statement();
2333  static const int kAlterTableStatementFieldNumber = 16;
2334  inline const ::drizzled::message::AlterTableStatement& alter_table_statement() const;
2335  inline ::drizzled::message::AlterTableStatement* mutable_alter_table_statement();
2336  inline ::drizzled::message::AlterTableStatement* release_alter_table_statement();
2337  inline void set_allocated_alter_table_statement(::drizzled::message::AlterTableStatement* alter_table_statement);
2338 
2339  // optional .drizzled.message.DropTableStatement drop_table_statement = 17;
2340  inline bool has_drop_table_statement() const;
2341  inline void clear_drop_table_statement();
2342  static const int kDropTableStatementFieldNumber = 17;
2343  inline const ::drizzled::message::DropTableStatement& drop_table_statement() const;
2344  inline ::drizzled::message::DropTableStatement* mutable_drop_table_statement();
2345  inline ::drizzled::message::DropTableStatement* release_drop_table_statement();
2346  inline void set_allocated_drop_table_statement(::drizzled::message::DropTableStatement* drop_table_statement);
2347 
2348  // optional .drizzled.message.SetVariableStatement set_variable_statement = 18;
2349  inline bool has_set_variable_statement() const;
2350  inline void clear_set_variable_statement();
2351  static const int kSetVariableStatementFieldNumber = 18;
2352  inline const ::drizzled::message::SetVariableStatement& set_variable_statement() const;
2353  inline ::drizzled::message::SetVariableStatement* mutable_set_variable_statement();
2354  inline ::drizzled::message::SetVariableStatement* release_set_variable_statement();
2355  inline void set_allocated_set_variable_statement(::drizzled::message::SetVariableStatement* set_variable_statement);
2356 
2357  // optional string raw_sql_schema = 19;
2358  inline bool has_raw_sql_schema() const;
2359  inline void clear_raw_sql_schema();
2360  static const int kRawSqlSchemaFieldNumber = 19;
2361  inline const ::std::string& raw_sql_schema() const;
2362  inline void set_raw_sql_schema(const ::std::string& value);
2363  inline void set_raw_sql_schema(const char* value);
2364  inline void set_raw_sql_schema(const char* value, size_t size);
2365  inline ::std::string* mutable_raw_sql_schema();
2366  inline ::std::string* release_raw_sql_schema();
2367  inline void set_allocated_raw_sql_schema(::std::string* raw_sql_schema);
2368 
2369  // @@protoc_insertion_point(class_scope:drizzled.message.Statement)
2370  private:
2371  inline void set_has_type();
2372  inline void clear_has_type();
2373  inline void set_has_start_timestamp();
2374  inline void clear_has_start_timestamp();
2375  inline void set_has_end_timestamp();
2376  inline void clear_has_end_timestamp();
2377  inline void set_has_sql();
2378  inline void clear_has_sql();
2379  inline void set_has_insert_header();
2380  inline void clear_has_insert_header();
2381  inline void set_has_insert_data();
2382  inline void clear_has_insert_data();
2383  inline void set_has_update_header();
2384  inline void clear_has_update_header();
2385  inline void set_has_update_data();
2386  inline void clear_has_update_data();
2387  inline void set_has_delete_header();
2388  inline void clear_has_delete_header();
2389  inline void set_has_delete_data();
2390  inline void clear_has_delete_data();
2391  inline void set_has_truncate_table_statement();
2392  inline void clear_has_truncate_table_statement();
2393  inline void set_has_create_schema_statement();
2394  inline void clear_has_create_schema_statement();
2395  inline void set_has_drop_schema_statement();
2396  inline void clear_has_drop_schema_statement();
2397  inline void set_has_alter_schema_statement();
2398  inline void clear_has_alter_schema_statement();
2399  inline void set_has_create_table_statement();
2400  inline void clear_has_create_table_statement();
2401  inline void set_has_alter_table_statement();
2402  inline void clear_has_alter_table_statement();
2403  inline void set_has_drop_table_statement();
2404  inline void clear_has_drop_table_statement();
2405  inline void set_has_set_variable_statement();
2406  inline void clear_has_set_variable_statement();
2407  inline void set_has_raw_sql_schema();
2408  inline void clear_has_raw_sql_schema();
2409 
2410  ::google::protobuf::UnknownFieldSet _unknown_fields_;
2411 
2412  ::google::protobuf::uint64 start_timestamp_;
2413  ::google::protobuf::uint64 end_timestamp_;
2414  ::std::string* sql_;
2415  ::drizzled::message::InsertHeader* insert_header_;
2416  ::drizzled::message::InsertData* insert_data_;
2417  ::drizzled::message::UpdateHeader* update_header_;
2418  ::drizzled::message::UpdateData* update_data_;
2419  ::drizzled::message::DeleteHeader* delete_header_;
2420  ::drizzled::message::DeleteData* delete_data_;
2421  ::drizzled::message::TruncateTableStatement* truncate_table_statement_;
2422  ::drizzled::message::CreateSchemaStatement* create_schema_statement_;
2423  ::drizzled::message::DropSchemaStatement* drop_schema_statement_;
2424  ::drizzled::message::AlterSchemaStatement* alter_schema_statement_;
2425  ::drizzled::message::CreateTableStatement* create_table_statement_;
2426  ::drizzled::message::AlterTableStatement* alter_table_statement_;
2427  ::drizzled::message::DropTableStatement* drop_table_statement_;
2428  ::drizzled::message::SetVariableStatement* set_variable_statement_;
2429  ::std::string* raw_sql_schema_;
2430  int type_;
2431 
2432  mutable int _cached_size_;
2433  ::google::protobuf::uint32 _has_bits_[(19 + 31) / 32];
2434 
2435  friend void protobuf_AddDesc_transaction_2eproto();
2436  friend void protobuf_AssignDesc_transaction_2eproto();
2437  friend void protobuf_ShutdownFile_transaction_2eproto();
2438 
2439  void InitAsDefaultInstance();
2440  static Statement* default_instance_;
2441 };
2442 // -------------------------------------------------------------------
2443 
2444 class Transaction : public ::google::protobuf::Message {
2445  public:
2446  Transaction();
2447  virtual ~Transaction();
2448 
2449  Transaction(const Transaction& from);
2450 
2451  inline Transaction& operator=(const Transaction& from) {
2452  CopyFrom(from);
2453  return *this;
2454  }
2455 
2456  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
2457  return _unknown_fields_;
2458  }
2459 
2460  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
2461  return &_unknown_fields_;
2462  }
2463 
2464  static const ::google::protobuf::Descriptor* descriptor();
2465  static const Transaction& default_instance();
2466 
2467  void Swap(Transaction* other);
2468 
2469  // implements Message ----------------------------------------------
2470 
2471  Transaction* New() const;
2472  void CopyFrom(const ::google::protobuf::Message& from);
2473  void MergeFrom(const ::google::protobuf::Message& from);
2474  void CopyFrom(const Transaction& from);
2475  void MergeFrom(const Transaction& from);
2476  void Clear();
2477  bool IsInitialized() const;
2478 
2479  int ByteSize() const;
2480  bool MergePartialFromCodedStream(
2481  ::google::protobuf::io::CodedInputStream* input);
2482  void SerializeWithCachedSizes(
2483  ::google::protobuf::io::CodedOutputStream* output) const;
2484  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
2485  int GetCachedSize() const { return _cached_size_; }
2486  private:
2487  void SharedCtor();
2488  void SharedDtor();
2489  void SetCachedSize(int size) const;
2490  public:
2491 
2492  ::google::protobuf::Metadata GetMetadata() const;
2493 
2494  // nested types ----------------------------------------------------
2495 
2496  // accessors -------------------------------------------------------
2497 
2498  // required .drizzled.message.TransactionContext transaction_context = 1;
2499  inline bool has_transaction_context() const;
2500  inline void clear_transaction_context();
2501  static const int kTransactionContextFieldNumber = 1;
2502  inline const ::drizzled::message::TransactionContext& transaction_context() const;
2503  inline ::drizzled::message::TransactionContext* mutable_transaction_context();
2504  inline ::drizzled::message::TransactionContext* release_transaction_context();
2505  inline void set_allocated_transaction_context(::drizzled::message::TransactionContext* transaction_context);
2506 
2507  // repeated .drizzled.message.Statement statement = 2;
2508  inline int statement_size() const;
2509  inline void clear_statement();
2510  static const int kStatementFieldNumber = 2;
2511  inline const ::drizzled::message::Statement& statement(int index) const;
2512  inline ::drizzled::message::Statement* mutable_statement(int index);
2513  inline ::drizzled::message::Statement* add_statement();
2514  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Statement >&
2515  statement() const;
2516  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Statement >*
2517  mutable_statement();
2518 
2519  // optional .drizzled.message.Event event = 3;
2520  inline bool has_event() const;
2521  inline void clear_event();
2522  static const int kEventFieldNumber = 3;
2523  inline const ::drizzled::message::Event& event() const;
2524  inline ::drizzled::message::Event* mutable_event();
2525  inline ::drizzled::message::Event* release_event();
2526  inline void set_allocated_event(::drizzled::message::Event* event);
2527 
2528  // optional uint32 segment_id = 4;
2529  inline bool has_segment_id() const;
2530  inline void clear_segment_id();
2531  static const int kSegmentIdFieldNumber = 4;
2532  inline ::google::protobuf::uint32 segment_id() const;
2533  inline void set_segment_id(::google::protobuf::uint32 value);
2534 
2535  // optional bool end_segment = 5;
2536  inline bool has_end_segment() const;
2537  inline void clear_end_segment();
2538  static const int kEndSegmentFieldNumber = 5;
2539  inline bool end_segment() const;
2540  inline void set_end_segment(bool value);
2541 
2542  // @@protoc_insertion_point(class_scope:drizzled.message.Transaction)
2543  private:
2544  inline void set_has_transaction_context();
2545  inline void clear_has_transaction_context();
2546  inline void set_has_event();
2547  inline void clear_has_event();
2548  inline void set_has_segment_id();
2549  inline void clear_has_segment_id();
2550  inline void set_has_end_segment();
2551  inline void clear_has_end_segment();
2552 
2553  ::google::protobuf::UnknownFieldSet _unknown_fields_;
2554 
2555  ::drizzled::message::TransactionContext* transaction_context_;
2556  ::google::protobuf::RepeatedPtrField< ::drizzled::message::Statement > statement_;
2558  ::google::protobuf::uint32 segment_id_;
2559  bool end_segment_;
2560 
2561  mutable int _cached_size_;
2562  ::google::protobuf::uint32 _has_bits_[(5 + 31) / 32];
2563 
2564  friend void protobuf_AddDesc_transaction_2eproto();
2565  friend void protobuf_AssignDesc_transaction_2eproto();
2566  friend void protobuf_ShutdownFile_transaction_2eproto();
2567 
2568  void InitAsDefaultInstance();
2569  static Transaction* default_instance_;
2570 };
2571 // ===================================================================
2572 
2573 
2574 // ===================================================================
2575 
2576 // FieldMetadata
2577 
2578 // required .drizzled.message.Table.Field.FieldType type = 1;
2579 inline bool FieldMetadata::has_type() const {
2580  return (_has_bits_[0] & 0x00000001u) != 0;
2581 }
2582 inline void FieldMetadata::set_has_type() {
2583  _has_bits_[0] |= 0x00000001u;
2584 }
2585 inline void FieldMetadata::clear_has_type() {
2586  _has_bits_[0] &= ~0x00000001u;
2587 }
2588 inline void FieldMetadata::clear_type() {
2589  type_ = 0;
2590  clear_has_type();
2591 }
2592 inline ::drizzled::message::Table_Field_FieldType FieldMetadata::type() const {
2593  return static_cast< ::drizzled::message::Table_Field_FieldType >(type_);
2594 }
2595 inline void FieldMetadata::set_type(::drizzled::message::Table_Field_FieldType value) {
2596  assert(::drizzled::message::Table_Field_FieldType_IsValid(value));
2597  set_has_type();
2598  type_ = value;
2599 }
2600 
2601 // required string name = 2;
2602 inline bool FieldMetadata::has_name() const {
2603  return (_has_bits_[0] & 0x00000002u) != 0;
2604 }
2605 inline void FieldMetadata::set_has_name() {
2606  _has_bits_[0] |= 0x00000002u;
2607 }
2608 inline void FieldMetadata::clear_has_name() {
2609  _has_bits_[0] &= ~0x00000002u;
2610 }
2611 inline void FieldMetadata::clear_name() {
2612  if (name_ != &::google::protobuf::internal::kEmptyString) {
2613  name_->clear();
2614  }
2615  clear_has_name();
2616 }
2617 inline const ::std::string& FieldMetadata::name() const {
2618  return *name_;
2619 }
2620 inline void FieldMetadata::set_name(const ::std::string& value) {
2621  set_has_name();
2622  if (name_ == &::google::protobuf::internal::kEmptyString) {
2623  name_ = new ::std::string;
2624  }
2625  name_->assign(value);
2626 }
2627 inline void FieldMetadata::set_name(const char* value) {
2628  set_has_name();
2629  if (name_ == &::google::protobuf::internal::kEmptyString) {
2630  name_ = new ::std::string;
2631  }
2632  name_->assign(value);
2633 }
2634 inline void FieldMetadata::set_name(const char* value, size_t size) {
2635  set_has_name();
2636  if (name_ == &::google::protobuf::internal::kEmptyString) {
2637  name_ = new ::std::string;
2638  }
2639  name_->assign(reinterpret_cast<const char*>(value), size);
2640 }
2641 inline ::std::string* FieldMetadata::mutable_name() {
2642  set_has_name();
2643  if (name_ == &::google::protobuf::internal::kEmptyString) {
2644  name_ = new ::std::string;
2645  }
2646  return name_;
2647 }
2648 inline ::std::string* FieldMetadata::release_name() {
2649  clear_has_name();
2650  if (name_ == &::google::protobuf::internal::kEmptyString) {
2651  return NULL;
2652  } else {
2653  ::std::string* temp = name_;
2654  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
2655  return temp;
2656  }
2657 }
2658 inline void FieldMetadata::set_allocated_name(::std::string* name) {
2659  if (name_ != &::google::protobuf::internal::kEmptyString) {
2660  delete name_;
2661  }
2662  if (name) {
2663  set_has_name();
2664  name_ = name;
2665  } else {
2666  clear_has_name();
2667  name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
2668  }
2669 }
2670 
2671 // -------------------------------------------------------------------
2672 
2673 // TableMetadata
2674 
2675 // required string schema_name = 1;
2676 inline bool TableMetadata::has_schema_name() const {
2677  return (_has_bits_[0] & 0x00000001u) != 0;
2678 }
2679 inline void TableMetadata::set_has_schema_name() {
2680  _has_bits_[0] |= 0x00000001u;
2681 }
2682 inline void TableMetadata::clear_has_schema_name() {
2683  _has_bits_[0] &= ~0x00000001u;
2684 }
2685 inline void TableMetadata::clear_schema_name() {
2686  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
2687  schema_name_->clear();
2688  }
2689  clear_has_schema_name();
2690 }
2691 inline const ::std::string& TableMetadata::schema_name() const {
2692  return *schema_name_;
2693 }
2694 inline void TableMetadata::set_schema_name(const ::std::string& value) {
2695  set_has_schema_name();
2696  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
2697  schema_name_ = new ::std::string;
2698  }
2699  schema_name_->assign(value);
2700 }
2701 inline void TableMetadata::set_schema_name(const char* value) {
2702  set_has_schema_name();
2703  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
2704  schema_name_ = new ::std::string;
2705  }
2706  schema_name_->assign(value);
2707 }
2708 inline void TableMetadata::set_schema_name(const char* value, size_t size) {
2709  set_has_schema_name();
2710  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
2711  schema_name_ = new ::std::string;
2712  }
2713  schema_name_->assign(reinterpret_cast<const char*>(value), size);
2714 }
2715 inline ::std::string* TableMetadata::mutable_schema_name() {
2716  set_has_schema_name();
2717  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
2718  schema_name_ = new ::std::string;
2719  }
2720  return schema_name_;
2721 }
2722 inline ::std::string* TableMetadata::release_schema_name() {
2723  clear_has_schema_name();
2724  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
2725  return NULL;
2726  } else {
2727  ::std::string* temp = schema_name_;
2728  schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
2729  return temp;
2730  }
2731 }
2732 inline void TableMetadata::set_allocated_schema_name(::std::string* schema_name) {
2733  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
2734  delete schema_name_;
2735  }
2736  if (schema_name) {
2737  set_has_schema_name();
2738  schema_name_ = schema_name;
2739  } else {
2740  clear_has_schema_name();
2741  schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
2742  }
2743 }
2744 
2745 // required string table_name = 2;
2746 inline bool TableMetadata::has_table_name() const {
2747  return (_has_bits_[0] & 0x00000002u) != 0;
2748 }
2749 inline void TableMetadata::set_has_table_name() {
2750  _has_bits_[0] |= 0x00000002u;
2751 }
2752 inline void TableMetadata::clear_has_table_name() {
2753  _has_bits_[0] &= ~0x00000002u;
2754 }
2755 inline void TableMetadata::clear_table_name() {
2756  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
2757  table_name_->clear();
2758  }
2759  clear_has_table_name();
2760 }
2761 inline const ::std::string& TableMetadata::table_name() const {
2762  return *table_name_;
2763 }
2764 inline void TableMetadata::set_table_name(const ::std::string& value) {
2765  set_has_table_name();
2766  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
2767  table_name_ = new ::std::string;
2768  }
2769  table_name_->assign(value);
2770 }
2771 inline void TableMetadata::set_table_name(const char* value) {
2772  set_has_table_name();
2773  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
2774  table_name_ = new ::std::string;
2775  }
2776  table_name_->assign(value);
2777 }
2778 inline void TableMetadata::set_table_name(const char* value, size_t size) {
2779  set_has_table_name();
2780  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
2781  table_name_ = new ::std::string;
2782  }
2783  table_name_->assign(reinterpret_cast<const char*>(value), size);
2784 }
2785 inline ::std::string* TableMetadata::mutable_table_name() {
2786  set_has_table_name();
2787  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
2788  table_name_ = new ::std::string;
2789  }
2790  return table_name_;
2791 }
2792 inline ::std::string* TableMetadata::release_table_name() {
2793  clear_has_table_name();
2794  if (table_name_ == &::google::protobuf::internal::kEmptyString) {
2795  return NULL;
2796  } else {
2797  ::std::string* temp = table_name_;
2798  table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
2799  return temp;
2800  }
2801 }
2802 inline void TableMetadata::set_allocated_table_name(::std::string* table_name) {
2803  if (table_name_ != &::google::protobuf::internal::kEmptyString) {
2804  delete table_name_;
2805  }
2806  if (table_name) {
2807  set_has_table_name();
2808  table_name_ = table_name;
2809  } else {
2810  clear_has_table_name();
2811  table_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
2812  }
2813 }
2814 
2815 // optional string catalog_name = 3;
2816 inline bool TableMetadata::has_catalog_name() const {
2817  return (_has_bits_[0] & 0x00000004u) != 0;
2818 }
2819 inline void TableMetadata::set_has_catalog_name() {
2820  _has_bits_[0] |= 0x00000004u;
2821 }
2822 inline void TableMetadata::clear_has_catalog_name() {
2823  _has_bits_[0] &= ~0x00000004u;
2824 }
2825 inline void TableMetadata::clear_catalog_name() {
2826  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
2827  catalog_name_->clear();
2828  }
2829  clear_has_catalog_name();
2830 }
2831 inline const ::std::string& TableMetadata::catalog_name() const {
2832  return *catalog_name_;
2833 }
2834 inline void TableMetadata::set_catalog_name(const ::std::string& value) {
2835  set_has_catalog_name();
2836  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
2837  catalog_name_ = new ::std::string;
2838  }
2839  catalog_name_->assign(value);
2840 }
2841 inline void TableMetadata::set_catalog_name(const char* value) {
2842  set_has_catalog_name();
2843  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
2844  catalog_name_ = new ::std::string;
2845  }
2846  catalog_name_->assign(value);
2847 }
2848 inline void TableMetadata::set_catalog_name(const char* value, size_t size) {
2849  set_has_catalog_name();
2850  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
2851  catalog_name_ = new ::std::string;
2852  }
2853  catalog_name_->assign(reinterpret_cast<const char*>(value), size);
2854 }
2855 inline ::std::string* TableMetadata::mutable_catalog_name() {
2856  set_has_catalog_name();
2857  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
2858  catalog_name_ = new ::std::string;
2859  }
2860  return catalog_name_;
2861 }
2862 inline ::std::string* TableMetadata::release_catalog_name() {
2863  clear_has_catalog_name();
2864  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
2865  return NULL;
2866  } else {
2867  ::std::string* temp = catalog_name_;
2868  catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
2869  return temp;
2870  }
2871 }
2872 inline void TableMetadata::set_allocated_catalog_name(::std::string* catalog_name) {
2873  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
2874  delete catalog_name_;
2875  }
2876  if (catalog_name) {
2877  set_has_catalog_name();
2878  catalog_name_ = catalog_name;
2879  } else {
2880  clear_has_catalog_name();
2881  catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
2882  }
2883 }
2884 
2885 // -------------------------------------------------------------------
2886 
2887 // TransactionContext
2888 
2889 // required uint32 server_id = 1;
2890 inline bool TransactionContext::has_server_id() const {
2891  return (_has_bits_[0] & 0x00000001u) != 0;
2892 }
2893 inline void TransactionContext::set_has_server_id() {
2894  _has_bits_[0] |= 0x00000001u;
2895 }
2896 inline void TransactionContext::clear_has_server_id() {
2897  _has_bits_[0] &= ~0x00000001u;
2898 }
2899 inline void TransactionContext::clear_server_id() {
2900  server_id_ = 0u;
2901  clear_has_server_id();
2902 }
2903 inline ::google::protobuf::uint32 TransactionContext::server_id() const {
2904  return server_id_;
2905 }
2906 inline void TransactionContext::set_server_id(::google::protobuf::uint32 value) {
2907  set_has_server_id();
2908  server_id_ = value;
2909 }
2910 
2911 // required uint64 transaction_id = 2;
2912 inline bool TransactionContext::has_transaction_id() const {
2913  return (_has_bits_[0] & 0x00000002u) != 0;
2914 }
2915 inline void TransactionContext::set_has_transaction_id() {
2916  _has_bits_[0] |= 0x00000002u;
2917 }
2918 inline void TransactionContext::clear_has_transaction_id() {
2919  _has_bits_[0] &= ~0x00000002u;
2920 }
2921 inline void TransactionContext::clear_transaction_id() {
2922  transaction_id_ = GOOGLE_ULONGLONG(0);
2923  clear_has_transaction_id();
2924 }
2925 inline ::google::protobuf::uint64 TransactionContext::transaction_id() const {
2926  return transaction_id_;
2927 }
2928 inline void TransactionContext::set_transaction_id(::google::protobuf::uint64 value) {
2929  set_has_transaction_id();
2930  transaction_id_ = value;
2931 }
2932 
2933 // required uint64 start_timestamp = 3;
2934 inline bool TransactionContext::has_start_timestamp() const {
2935  return (_has_bits_[0] & 0x00000004u) != 0;
2936 }
2937 inline void TransactionContext::set_has_start_timestamp() {
2938  _has_bits_[0] |= 0x00000004u;
2939 }
2940 inline void TransactionContext::clear_has_start_timestamp() {
2941  _has_bits_[0] &= ~0x00000004u;
2942 }
2943 inline void TransactionContext::clear_start_timestamp() {
2944  start_timestamp_ = GOOGLE_ULONGLONG(0);
2945  clear_has_start_timestamp();
2946 }
2947 inline ::google::protobuf::uint64 TransactionContext::start_timestamp() const {
2948  return start_timestamp_;
2949 }
2950 inline void TransactionContext::set_start_timestamp(::google::protobuf::uint64 value) {
2951  set_has_start_timestamp();
2952  start_timestamp_ = value;
2953 }
2954 
2955 // required uint64 end_timestamp = 4;
2956 inline bool TransactionContext::has_end_timestamp() const {
2957  return (_has_bits_[0] & 0x00000008u) != 0;
2958 }
2959 inline void TransactionContext::set_has_end_timestamp() {
2960  _has_bits_[0] |= 0x00000008u;
2961 }
2962 inline void TransactionContext::clear_has_end_timestamp() {
2963  _has_bits_[0] &= ~0x00000008u;
2964 }
2965 inline void TransactionContext::clear_end_timestamp() {
2966  end_timestamp_ = GOOGLE_ULONGLONG(0);
2967  clear_has_end_timestamp();
2968 }
2969 inline ::google::protobuf::uint64 TransactionContext::end_timestamp() const {
2970  return end_timestamp_;
2971 }
2972 inline void TransactionContext::set_end_timestamp(::google::protobuf::uint64 value) {
2973  set_has_end_timestamp();
2974  end_timestamp_ = value;
2975 }
2976 
2977 // -------------------------------------------------------------------
2978 
2979 // InsertRecord
2980 
2981 // repeated bytes insert_value = 1;
2982 inline int InsertRecord::insert_value_size() const {
2983  return insert_value_.size();
2984 }
2985 inline void InsertRecord::clear_insert_value() {
2986  insert_value_.Clear();
2987 }
2988 inline const ::std::string& InsertRecord::insert_value(int index) const {
2989  return insert_value_.Get(index);
2990 }
2991 inline ::std::string* InsertRecord::mutable_insert_value(int index) {
2992  return insert_value_.Mutable(index);
2993 }
2994 inline void InsertRecord::set_insert_value(int index, const ::std::string& value) {
2995  insert_value_.Mutable(index)->assign(value);
2996 }
2997 inline void InsertRecord::set_insert_value(int index, const char* value) {
2998  insert_value_.Mutable(index)->assign(value);
2999 }
3000 inline void InsertRecord::set_insert_value(int index, const void* value, size_t size) {
3001  insert_value_.Mutable(index)->assign(
3002  reinterpret_cast<const char*>(value), size);
3003 }
3004 inline ::std::string* InsertRecord::add_insert_value() {
3005  return insert_value_.Add();
3006 }
3007 inline void InsertRecord::add_insert_value(const ::std::string& value) {
3008  insert_value_.Add()->assign(value);
3009 }
3010 inline void InsertRecord::add_insert_value(const char* value) {
3011  insert_value_.Add()->assign(value);
3012 }
3013 inline void InsertRecord::add_insert_value(const void* value, size_t size) {
3014  insert_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
3015 }
3016 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
3017 InsertRecord::insert_value() const {
3018  return insert_value_;
3019 }
3020 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
3021 InsertRecord::mutable_insert_value() {
3022  return &insert_value_;
3023 }
3024 
3025 // repeated bool is_null = 2;
3026 inline int InsertRecord::is_null_size() const {
3027  return is_null_.size();
3028 }
3029 inline void InsertRecord::clear_is_null() {
3030  is_null_.Clear();
3031 }
3032 inline bool InsertRecord::is_null(int index) const {
3033  return is_null_.Get(index);
3034 }
3035 inline void InsertRecord::set_is_null(int index, bool value) {
3036  is_null_.Set(index, value);
3037 }
3038 inline void InsertRecord::add_is_null(bool value) {
3039  is_null_.Add(value);
3040 }
3041 inline const ::google::protobuf::RepeatedField< bool >&
3042 InsertRecord::is_null() const {
3043  return is_null_;
3044 }
3045 inline ::google::protobuf::RepeatedField< bool >*
3046 InsertRecord::mutable_is_null() {
3047  return &is_null_;
3048 }
3049 
3050 // -------------------------------------------------------------------
3051 
3052 // InsertHeader
3053 
3054 // required .drizzled.message.TableMetadata table_metadata = 1;
3055 inline bool InsertHeader::has_table_metadata() const {
3056  return (_has_bits_[0] & 0x00000001u) != 0;
3057 }
3058 inline void InsertHeader::set_has_table_metadata() {
3059  _has_bits_[0] |= 0x00000001u;
3060 }
3061 inline void InsertHeader::clear_has_table_metadata() {
3062  _has_bits_[0] &= ~0x00000001u;
3063 }
3064 inline void InsertHeader::clear_table_metadata() {
3065  if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
3066  clear_has_table_metadata();
3067 }
3068 inline const ::drizzled::message::TableMetadata& InsertHeader::table_metadata() const {
3069  return table_metadata_ != NULL ? *table_metadata_ : *default_instance_->table_metadata_;
3070 }
3071 inline ::drizzled::message::TableMetadata* InsertHeader::mutable_table_metadata() {
3072  set_has_table_metadata();
3073  if (table_metadata_ == NULL) table_metadata_ = new ::drizzled::message::TableMetadata;
3074  return table_metadata_;
3075 }
3076 inline ::drizzled::message::TableMetadata* InsertHeader::release_table_metadata() {
3077  clear_has_table_metadata();
3078  ::drizzled::message::TableMetadata* temp = table_metadata_;
3079  table_metadata_ = NULL;
3080  return temp;
3081 }
3082 inline void InsertHeader::set_allocated_table_metadata(::drizzled::message::TableMetadata* table_metadata) {
3083  delete table_metadata_;
3084  table_metadata_ = table_metadata;
3085  if (table_metadata) {
3086  set_has_table_metadata();
3087  } else {
3088  clear_has_table_metadata();
3089  }
3090 }
3091 
3092 // repeated .drizzled.message.FieldMetadata field_metadata = 2;
3093 inline int InsertHeader::field_metadata_size() const {
3094  return field_metadata_.size();
3095 }
3096 inline void InsertHeader::clear_field_metadata() {
3097  field_metadata_.Clear();
3098 }
3099 inline const ::drizzled::message::FieldMetadata& InsertHeader::field_metadata(int index) const {
3100  return field_metadata_.Get(index);
3101 }
3102 inline ::drizzled::message::FieldMetadata* InsertHeader::mutable_field_metadata(int index) {
3103  return field_metadata_.Mutable(index);
3104 }
3105 inline ::drizzled::message::FieldMetadata* InsertHeader::add_field_metadata() {
3106  return field_metadata_.Add();
3107 }
3108 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
3109 InsertHeader::field_metadata() const {
3110  return field_metadata_;
3111 }
3112 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
3113 InsertHeader::mutable_field_metadata() {
3114  return &field_metadata_;
3115 }
3116 
3117 // -------------------------------------------------------------------
3118 
3119 // InsertData
3120 
3121 // required uint32 segment_id = 1;
3122 inline bool InsertData::has_segment_id() const {
3123  return (_has_bits_[0] & 0x00000001u) != 0;
3124 }
3125 inline void InsertData::set_has_segment_id() {
3126  _has_bits_[0] |= 0x00000001u;
3127 }
3128 inline void InsertData::clear_has_segment_id() {
3129  _has_bits_[0] &= ~0x00000001u;
3130 }
3131 inline void InsertData::clear_segment_id() {
3132  segment_id_ = 0u;
3133  clear_has_segment_id();
3134 }
3135 inline ::google::protobuf::uint32 InsertData::segment_id() const {
3136  return segment_id_;
3137 }
3138 inline void InsertData::set_segment_id(::google::protobuf::uint32 value) {
3139  set_has_segment_id();
3140  segment_id_ = value;
3141 }
3142 
3143 // required bool end_segment = 2;
3144 inline bool InsertData::has_end_segment() const {
3145  return (_has_bits_[0] & 0x00000002u) != 0;
3146 }
3147 inline void InsertData::set_has_end_segment() {
3148  _has_bits_[0] |= 0x00000002u;
3149 }
3150 inline void InsertData::clear_has_end_segment() {
3151  _has_bits_[0] &= ~0x00000002u;
3152 }
3153 inline void InsertData::clear_end_segment() {
3154  end_segment_ = false;
3155  clear_has_end_segment();
3156 }
3157 inline bool InsertData::end_segment() const {
3158  return end_segment_;
3159 }
3160 inline void InsertData::set_end_segment(bool value) {
3161  set_has_end_segment();
3162  end_segment_ = value;
3163 }
3164 
3165 // repeated .drizzled.message.InsertRecord record = 3;
3166 inline int InsertData::record_size() const {
3167  return record_.size();
3168 }
3169 inline void InsertData::clear_record() {
3170  record_.Clear();
3171 }
3172 inline const ::drizzled::message::InsertRecord& InsertData::record(int index) const {
3173  return record_.Get(index);
3174 }
3175 inline ::drizzled::message::InsertRecord* InsertData::mutable_record(int index) {
3176  return record_.Mutable(index);
3177 }
3178 inline ::drizzled::message::InsertRecord* InsertData::add_record() {
3179  return record_.Add();
3180 }
3181 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::InsertRecord >&
3182 InsertData::record() const {
3183  return record_;
3184 }
3185 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::InsertRecord >*
3186 InsertData::mutable_record() {
3187  return &record_;
3188 }
3189 
3190 // -------------------------------------------------------------------
3191 
3192 // UpdateRecord
3193 
3194 // repeated bytes key_value = 1;
3195 inline int UpdateRecord::key_value_size() const {
3196  return key_value_.size();
3197 }
3198 inline void UpdateRecord::clear_key_value() {
3199  key_value_.Clear();
3200 }
3201 inline const ::std::string& UpdateRecord::key_value(int index) const {
3202  return key_value_.Get(index);
3203 }
3204 inline ::std::string* UpdateRecord::mutable_key_value(int index) {
3205  return key_value_.Mutable(index);
3206 }
3207 inline void UpdateRecord::set_key_value(int index, const ::std::string& value) {
3208  key_value_.Mutable(index)->assign(value);
3209 }
3210 inline void UpdateRecord::set_key_value(int index, const char* value) {
3211  key_value_.Mutable(index)->assign(value);
3212 }
3213 inline void UpdateRecord::set_key_value(int index, const void* value, size_t size) {
3214  key_value_.Mutable(index)->assign(
3215  reinterpret_cast<const char*>(value), size);
3216 }
3217 inline ::std::string* UpdateRecord::add_key_value() {
3218  return key_value_.Add();
3219 }
3220 inline void UpdateRecord::add_key_value(const ::std::string& value) {
3221  key_value_.Add()->assign(value);
3222 }
3223 inline void UpdateRecord::add_key_value(const char* value) {
3224  key_value_.Add()->assign(value);
3225 }
3226 inline void UpdateRecord::add_key_value(const void* value, size_t size) {
3227  key_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
3228 }
3229 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
3230 UpdateRecord::key_value() const {
3231  return key_value_;
3232 }
3233 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
3234 UpdateRecord::mutable_key_value() {
3235  return &key_value_;
3236 }
3237 
3238 // repeated bytes after_value = 2;
3239 inline int UpdateRecord::after_value_size() const {
3240  return after_value_.size();
3241 }
3242 inline void UpdateRecord::clear_after_value() {
3243  after_value_.Clear();
3244 }
3245 inline const ::std::string& UpdateRecord::after_value(int index) const {
3246  return after_value_.Get(index);
3247 }
3248 inline ::std::string* UpdateRecord::mutable_after_value(int index) {
3249  return after_value_.Mutable(index);
3250 }
3251 inline void UpdateRecord::set_after_value(int index, const ::std::string& value) {
3252  after_value_.Mutable(index)->assign(value);
3253 }
3254 inline void UpdateRecord::set_after_value(int index, const char* value) {
3255  after_value_.Mutable(index)->assign(value);
3256 }
3257 inline void UpdateRecord::set_after_value(int index, const void* value, size_t size) {
3258  after_value_.Mutable(index)->assign(
3259  reinterpret_cast<const char*>(value), size);
3260 }
3261 inline ::std::string* UpdateRecord::add_after_value() {
3262  return after_value_.Add();
3263 }
3264 inline void UpdateRecord::add_after_value(const ::std::string& value) {
3265  after_value_.Add()->assign(value);
3266 }
3267 inline void UpdateRecord::add_after_value(const char* value) {
3268  after_value_.Add()->assign(value);
3269 }
3270 inline void UpdateRecord::add_after_value(const void* value, size_t size) {
3271  after_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
3272 }
3273 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
3274 UpdateRecord::after_value() const {
3275  return after_value_;
3276 }
3277 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
3278 UpdateRecord::mutable_after_value() {
3279  return &after_value_;
3280 }
3281 
3282 // repeated bytes before_value = 3;
3283 inline int UpdateRecord::before_value_size() const {
3284  return before_value_.size();
3285 }
3286 inline void UpdateRecord::clear_before_value() {
3287  before_value_.Clear();
3288 }
3289 inline const ::std::string& UpdateRecord::before_value(int index) const {
3290  return before_value_.Get(index);
3291 }
3292 inline ::std::string* UpdateRecord::mutable_before_value(int index) {
3293  return before_value_.Mutable(index);
3294 }
3295 inline void UpdateRecord::set_before_value(int index, const ::std::string& value) {
3296  before_value_.Mutable(index)->assign(value);
3297 }
3298 inline void UpdateRecord::set_before_value(int index, const char* value) {
3299  before_value_.Mutable(index)->assign(value);
3300 }
3301 inline void UpdateRecord::set_before_value(int index, const void* value, size_t size) {
3302  before_value_.Mutable(index)->assign(
3303  reinterpret_cast<const char*>(value), size);
3304 }
3305 inline ::std::string* UpdateRecord::add_before_value() {
3306  return before_value_.Add();
3307 }
3308 inline void UpdateRecord::add_before_value(const ::std::string& value) {
3309  before_value_.Add()->assign(value);
3310 }
3311 inline void UpdateRecord::add_before_value(const char* value) {
3312  before_value_.Add()->assign(value);
3313 }
3314 inline void UpdateRecord::add_before_value(const void* value, size_t size) {
3315  before_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
3316 }
3317 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
3318 UpdateRecord::before_value() const {
3319  return before_value_;
3320 }
3321 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
3322 UpdateRecord::mutable_before_value() {
3323  return &before_value_;
3324 }
3325 
3326 // repeated bool is_null = 4;
3327 inline int UpdateRecord::is_null_size() const {
3328  return is_null_.size();
3329 }
3330 inline void UpdateRecord::clear_is_null() {
3331  is_null_.Clear();
3332 }
3333 inline bool UpdateRecord::is_null(int index) const {
3334  return is_null_.Get(index);
3335 }
3336 inline void UpdateRecord::set_is_null(int index, bool value) {
3337  is_null_.Set(index, value);
3338 }
3339 inline void UpdateRecord::add_is_null(bool value) {
3340  is_null_.Add(value);
3341 }
3342 inline const ::google::protobuf::RepeatedField< bool >&
3343 UpdateRecord::is_null() const {
3344  return is_null_;
3345 }
3346 inline ::google::protobuf::RepeatedField< bool >*
3347 UpdateRecord::mutable_is_null() {
3348  return &is_null_;
3349 }
3350 
3351 // -------------------------------------------------------------------
3352 
3353 // UpdateHeader
3354 
3355 // required .drizzled.message.TableMetadata table_metadata = 1;
3356 inline bool UpdateHeader::has_table_metadata() const {
3357  return (_has_bits_[0] & 0x00000001u) != 0;
3358 }
3359 inline void UpdateHeader::set_has_table_metadata() {
3360  _has_bits_[0] |= 0x00000001u;
3361 }
3362 inline void UpdateHeader::clear_has_table_metadata() {
3363  _has_bits_[0] &= ~0x00000001u;
3364 }
3365 inline void UpdateHeader::clear_table_metadata() {
3366  if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
3367  clear_has_table_metadata();
3368 }
3369 inline const ::drizzled::message::TableMetadata& UpdateHeader::table_metadata() const {
3370  return table_metadata_ != NULL ? *table_metadata_ : *default_instance_->table_metadata_;
3371 }
3372 inline ::drizzled::message::TableMetadata* UpdateHeader::mutable_table_metadata() {
3373  set_has_table_metadata();
3374  if (table_metadata_ == NULL) table_metadata_ = new ::drizzled::message::TableMetadata;
3375  return table_metadata_;
3376 }
3377 inline ::drizzled::message::TableMetadata* UpdateHeader::release_table_metadata() {
3378  clear_has_table_metadata();
3379  ::drizzled::message::TableMetadata* temp = table_metadata_;
3380  table_metadata_ = NULL;
3381  return temp;
3382 }
3383 inline void UpdateHeader::set_allocated_table_metadata(::drizzled::message::TableMetadata* table_metadata) {
3384  delete table_metadata_;
3385  table_metadata_ = table_metadata;
3386  if (table_metadata) {
3387  set_has_table_metadata();
3388  } else {
3389  clear_has_table_metadata();
3390  }
3391 }
3392 
3393 // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
3394 inline int UpdateHeader::key_field_metadata_size() const {
3395  return key_field_metadata_.size();
3396 }
3397 inline void UpdateHeader::clear_key_field_metadata() {
3398  key_field_metadata_.Clear();
3399 }
3400 inline const ::drizzled::message::FieldMetadata& UpdateHeader::key_field_metadata(int index) const {
3401  return key_field_metadata_.Get(index);
3402 }
3403 inline ::drizzled::message::FieldMetadata* UpdateHeader::mutable_key_field_metadata(int index) {
3404  return key_field_metadata_.Mutable(index);
3405 }
3406 inline ::drizzled::message::FieldMetadata* UpdateHeader::add_key_field_metadata() {
3407  return key_field_metadata_.Add();
3408 }
3409 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
3410 UpdateHeader::key_field_metadata() const {
3411  return key_field_metadata_;
3412 }
3413 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
3414 UpdateHeader::mutable_key_field_metadata() {
3415  return &key_field_metadata_;
3416 }
3417 
3418 // repeated .drizzled.message.FieldMetadata set_field_metadata = 3;
3419 inline int UpdateHeader::set_field_metadata_size() const {
3420  return set_field_metadata_.size();
3421 }
3422 inline void UpdateHeader::clear_set_field_metadata() {
3423  set_field_metadata_.Clear();
3424 }
3425 inline const ::drizzled::message::FieldMetadata& UpdateHeader::set_field_metadata(int index) const {
3426  return set_field_metadata_.Get(index);
3427 }
3428 inline ::drizzled::message::FieldMetadata* UpdateHeader::mutable_set_field_metadata(int index) {
3429  return set_field_metadata_.Mutable(index);
3430 }
3431 inline ::drizzled::message::FieldMetadata* UpdateHeader::add_set_field_metadata() {
3432  return set_field_metadata_.Add();
3433 }
3434 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
3435 UpdateHeader::set_field_metadata() const {
3436  return set_field_metadata_;
3437 }
3438 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
3439 UpdateHeader::mutable_set_field_metadata() {
3440  return &set_field_metadata_;
3441 }
3442 
3443 // -------------------------------------------------------------------
3444 
3445 // UpdateData
3446 
3447 // required uint32 segment_id = 1;
3448 inline bool UpdateData::has_segment_id() const {
3449  return (_has_bits_[0] & 0x00000001u) != 0;
3450 }
3451 inline void UpdateData::set_has_segment_id() {
3452  _has_bits_[0] |= 0x00000001u;
3453 }
3454 inline void UpdateData::clear_has_segment_id() {
3455  _has_bits_[0] &= ~0x00000001u;
3456 }
3457 inline void UpdateData::clear_segment_id() {
3458  segment_id_ = 0u;
3459  clear_has_segment_id();
3460 }
3461 inline ::google::protobuf::uint32 UpdateData::segment_id() const {
3462  return segment_id_;
3463 }
3464 inline void UpdateData::set_segment_id(::google::protobuf::uint32 value) {
3465  set_has_segment_id();
3466  segment_id_ = value;
3467 }
3468 
3469 // required bool end_segment = 2;
3470 inline bool UpdateData::has_end_segment() const {
3471  return (_has_bits_[0] & 0x00000002u) != 0;
3472 }
3473 inline void UpdateData::set_has_end_segment() {
3474  _has_bits_[0] |= 0x00000002u;
3475 }
3476 inline void UpdateData::clear_has_end_segment() {
3477  _has_bits_[0] &= ~0x00000002u;
3478 }
3479 inline void UpdateData::clear_end_segment() {
3480  end_segment_ = false;
3481  clear_has_end_segment();
3482 }
3483 inline bool UpdateData::end_segment() const {
3484  return end_segment_;
3485 }
3486 inline void UpdateData::set_end_segment(bool value) {
3487  set_has_end_segment();
3488  end_segment_ = value;
3489 }
3490 
3491 // repeated .drizzled.message.UpdateRecord record = 3;
3492 inline int UpdateData::record_size() const {
3493  return record_.size();
3494 }
3495 inline void UpdateData::clear_record() {
3496  record_.Clear();
3497 }
3498 inline const ::drizzled::message::UpdateRecord& UpdateData::record(int index) const {
3499  return record_.Get(index);
3500 }
3501 inline ::drizzled::message::UpdateRecord* UpdateData::mutable_record(int index) {
3502  return record_.Mutable(index);
3503 }
3504 inline ::drizzled::message::UpdateRecord* UpdateData::add_record() {
3505  return record_.Add();
3506 }
3507 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::UpdateRecord >&
3508 UpdateData::record() const {
3509  return record_;
3510 }
3511 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::UpdateRecord >*
3512 UpdateData::mutable_record() {
3513  return &record_;
3514 }
3515 
3516 // -------------------------------------------------------------------
3517 
3518 // DeleteRecord
3519 
3520 // repeated bytes key_value = 1;
3521 inline int DeleteRecord::key_value_size() const {
3522  return key_value_.size();
3523 }
3524 inline void DeleteRecord::clear_key_value() {
3525  key_value_.Clear();
3526 }
3527 inline const ::std::string& DeleteRecord::key_value(int index) const {
3528  return key_value_.Get(index);
3529 }
3530 inline ::std::string* DeleteRecord::mutable_key_value(int index) {
3531  return key_value_.Mutable(index);
3532 }
3533 inline void DeleteRecord::set_key_value(int index, const ::std::string& value) {
3534  key_value_.Mutable(index)->assign(value);
3535 }
3536 inline void DeleteRecord::set_key_value(int index, const char* value) {
3537  key_value_.Mutable(index)->assign(value);
3538 }
3539 inline void DeleteRecord::set_key_value(int index, const void* value, size_t size) {
3540  key_value_.Mutable(index)->assign(
3541  reinterpret_cast<const char*>(value), size);
3542 }
3543 inline ::std::string* DeleteRecord::add_key_value() {
3544  return key_value_.Add();
3545 }
3546 inline void DeleteRecord::add_key_value(const ::std::string& value) {
3547  key_value_.Add()->assign(value);
3548 }
3549 inline void DeleteRecord::add_key_value(const char* value) {
3550  key_value_.Add()->assign(value);
3551 }
3552 inline void DeleteRecord::add_key_value(const void* value, size_t size) {
3553  key_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
3554 }
3555 inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
3556 DeleteRecord::key_value() const {
3557  return key_value_;
3558 }
3559 inline ::google::protobuf::RepeatedPtrField< ::std::string>*
3560 DeleteRecord::mutable_key_value() {
3561  return &key_value_;
3562 }
3563 
3564 // -------------------------------------------------------------------
3565 
3566 // DeleteHeader
3567 
3568 // required .drizzled.message.TableMetadata table_metadata = 1;
3569 inline bool DeleteHeader::has_table_metadata() const {
3570  return (_has_bits_[0] & 0x00000001u) != 0;
3571 }
3572 inline void DeleteHeader::set_has_table_metadata() {
3573  _has_bits_[0] |= 0x00000001u;
3574 }
3575 inline void DeleteHeader::clear_has_table_metadata() {
3576  _has_bits_[0] &= ~0x00000001u;
3577 }
3578 inline void DeleteHeader::clear_table_metadata() {
3579  if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
3580  clear_has_table_metadata();
3581 }
3582 inline const ::drizzled::message::TableMetadata& DeleteHeader::table_metadata() const {
3583  return table_metadata_ != NULL ? *table_metadata_ : *default_instance_->table_metadata_;
3584 }
3585 inline ::drizzled::message::TableMetadata* DeleteHeader::mutable_table_metadata() {
3586  set_has_table_metadata();
3587  if (table_metadata_ == NULL) table_metadata_ = new ::drizzled::message::TableMetadata;
3588  return table_metadata_;
3589 }
3590 inline ::drizzled::message::TableMetadata* DeleteHeader::release_table_metadata() {
3591  clear_has_table_metadata();
3592  ::drizzled::message::TableMetadata* temp = table_metadata_;
3593  table_metadata_ = NULL;
3594  return temp;
3595 }
3596 inline void DeleteHeader::set_allocated_table_metadata(::drizzled::message::TableMetadata* table_metadata) {
3597  delete table_metadata_;
3598  table_metadata_ = table_metadata;
3599  if (table_metadata) {
3600  set_has_table_metadata();
3601  } else {
3602  clear_has_table_metadata();
3603  }
3604 }
3605 
3606 // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
3607 inline int DeleteHeader::key_field_metadata_size() const {
3608  return key_field_metadata_.size();
3609 }
3610 inline void DeleteHeader::clear_key_field_metadata() {
3611  key_field_metadata_.Clear();
3612 }
3613 inline const ::drizzled::message::FieldMetadata& DeleteHeader::key_field_metadata(int index) const {
3614  return key_field_metadata_.Get(index);
3615 }
3616 inline ::drizzled::message::FieldMetadata* DeleteHeader::mutable_key_field_metadata(int index) {
3617  return key_field_metadata_.Mutable(index);
3618 }
3619 inline ::drizzled::message::FieldMetadata* DeleteHeader::add_key_field_metadata() {
3620  return key_field_metadata_.Add();
3621 }
3622 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
3623 DeleteHeader::key_field_metadata() const {
3624  return key_field_metadata_;
3625 }
3626 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
3627 DeleteHeader::mutable_key_field_metadata() {
3628  return &key_field_metadata_;
3629 }
3630 
3631 // -------------------------------------------------------------------
3632 
3633 // DeleteData
3634 
3635 // required uint32 segment_id = 1;
3636 inline bool DeleteData::has_segment_id() const {
3637  return (_has_bits_[0] & 0x00000001u) != 0;
3638 }
3639 inline void DeleteData::set_has_segment_id() {
3640  _has_bits_[0] |= 0x00000001u;
3641 }
3642 inline void DeleteData::clear_has_segment_id() {
3643  _has_bits_[0] &= ~0x00000001u;
3644 }
3645 inline void DeleteData::clear_segment_id() {
3646  segment_id_ = 0u;
3647  clear_has_segment_id();
3648 }
3649 inline ::google::protobuf::uint32 DeleteData::segment_id() const {
3650  return segment_id_;
3651 }
3652 inline void DeleteData::set_segment_id(::google::protobuf::uint32 value) {
3653  set_has_segment_id();
3654  segment_id_ = value;
3655 }
3656 
3657 // required bool end_segment = 2;
3658 inline bool DeleteData::has_end_segment() const {
3659  return (_has_bits_[0] & 0x00000002u) != 0;
3660 }
3661 inline void DeleteData::set_has_end_segment() {
3662  _has_bits_[0] |= 0x00000002u;
3663 }
3664 inline void DeleteData::clear_has_end_segment() {
3665  _has_bits_[0] &= ~0x00000002u;
3666 }
3667 inline void DeleteData::clear_end_segment() {
3668  end_segment_ = false;
3669  clear_has_end_segment();
3670 }
3671 inline bool DeleteData::end_segment() const {
3672  return end_segment_;
3673 }
3674 inline void DeleteData::set_end_segment(bool value) {
3675  set_has_end_segment();
3676  end_segment_ = value;
3677 }
3678 
3679 // repeated .drizzled.message.DeleteRecord record = 3;
3680 inline int DeleteData::record_size() const {
3681  return record_.size();
3682 }
3683 inline void DeleteData::clear_record() {
3684  record_.Clear();
3685 }
3686 inline const ::drizzled::message::DeleteRecord& DeleteData::record(int index) const {
3687  return record_.Get(index);
3688 }
3689 inline ::drizzled::message::DeleteRecord* DeleteData::mutable_record(int index) {
3690  return record_.Mutable(index);
3691 }
3692 inline ::drizzled::message::DeleteRecord* DeleteData::add_record() {
3693  return record_.Add();
3694 }
3695 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::DeleteRecord >&
3696 DeleteData::record() const {
3697  return record_;
3698 }
3699 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::DeleteRecord >*
3700 DeleteData::mutable_record() {
3701  return &record_;
3702 }
3703 
3704 // -------------------------------------------------------------------
3705 
3706 // TruncateTableStatement
3707 
3708 // required .drizzled.message.TableMetadata table_metadata = 1;
3709 inline bool TruncateTableStatement::has_table_metadata() const {
3710  return (_has_bits_[0] & 0x00000001u) != 0;
3711 }
3712 inline void TruncateTableStatement::set_has_table_metadata() {
3713  _has_bits_[0] |= 0x00000001u;
3714 }
3715 inline void TruncateTableStatement::clear_has_table_metadata() {
3716  _has_bits_[0] &= ~0x00000001u;
3717 }
3718 inline void TruncateTableStatement::clear_table_metadata() {
3719  if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
3720  clear_has_table_metadata();
3721 }
3722 inline const ::drizzled::message::TableMetadata& TruncateTableStatement::table_metadata() const {
3723  return table_metadata_ != NULL ? *table_metadata_ : *default_instance_->table_metadata_;
3724 }
3725 inline ::drizzled::message::TableMetadata* TruncateTableStatement::mutable_table_metadata() {
3726  set_has_table_metadata();
3727  if (table_metadata_ == NULL) table_metadata_ = new ::drizzled::message::TableMetadata;
3728  return table_metadata_;
3729 }
3730 inline ::drizzled::message::TableMetadata* TruncateTableStatement::release_table_metadata() {
3731  clear_has_table_metadata();
3732  ::drizzled::message::TableMetadata* temp = table_metadata_;
3733  table_metadata_ = NULL;
3734  return temp;
3735 }
3736 inline void TruncateTableStatement::set_allocated_table_metadata(::drizzled::message::TableMetadata* table_metadata) {
3737  delete table_metadata_;
3738  table_metadata_ = table_metadata;
3739  if (table_metadata) {
3740  set_has_table_metadata();
3741  } else {
3742  clear_has_table_metadata();
3743  }
3744 }
3745 
3746 // -------------------------------------------------------------------
3747 
3748 // CreateSchemaStatement
3749 
3750 // required .drizzled.message.Schema schema = 1;
3751 inline bool CreateSchemaStatement::has_schema() const {
3752  return (_has_bits_[0] & 0x00000001u) != 0;
3753 }
3754 inline void CreateSchemaStatement::set_has_schema() {
3755  _has_bits_[0] |= 0x00000001u;
3756 }
3757 inline void CreateSchemaStatement::clear_has_schema() {
3758  _has_bits_[0] &= ~0x00000001u;
3759 }
3760 inline void CreateSchemaStatement::clear_schema() {
3761  if (schema_ != NULL) schema_->::drizzled::message::Schema::Clear();
3762  clear_has_schema();
3763 }
3764 inline const ::drizzled::message::Schema& CreateSchemaStatement::schema() const {
3765  return schema_ != NULL ? *schema_ : *default_instance_->schema_;
3766 }
3767 inline ::drizzled::message::Schema* CreateSchemaStatement::mutable_schema() {
3768  set_has_schema();
3769  if (schema_ == NULL) schema_ = new ::drizzled::message::Schema;
3770  return schema_;
3771 }
3772 inline ::drizzled::message::Schema* CreateSchemaStatement::release_schema() {
3773  clear_has_schema();
3774  ::drizzled::message::Schema* temp = schema_;
3775  schema_ = NULL;
3776  return temp;
3777 }
3778 inline void CreateSchemaStatement::set_allocated_schema(::drizzled::message::Schema* schema) {
3779  delete schema_;
3780  schema_ = schema;
3781  if (schema) {
3782  set_has_schema();
3783  } else {
3784  clear_has_schema();
3785  }
3786 }
3787 
3788 // -------------------------------------------------------------------
3789 
3790 // AlterSchemaStatement
3791 
3792 // required .drizzled.message.Schema before = 1;
3793 inline bool AlterSchemaStatement::has_before() const {
3794  return (_has_bits_[0] & 0x00000001u) != 0;
3795 }
3796 inline void AlterSchemaStatement::set_has_before() {
3797  _has_bits_[0] |= 0x00000001u;
3798 }
3799 inline void AlterSchemaStatement::clear_has_before() {
3800  _has_bits_[0] &= ~0x00000001u;
3801 }
3802 inline void AlterSchemaStatement::clear_before() {
3803  if (before_ != NULL) before_->::drizzled::message::Schema::Clear();
3804  clear_has_before();
3805 }
3806 inline const ::drizzled::message::Schema& AlterSchemaStatement::before() const {
3807  return before_ != NULL ? *before_ : *default_instance_->before_;
3808 }
3809 inline ::drizzled::message::Schema* AlterSchemaStatement::mutable_before() {
3810  set_has_before();
3811  if (before_ == NULL) before_ = new ::drizzled::message::Schema;
3812  return before_;
3813 }
3814 inline ::drizzled::message::Schema* AlterSchemaStatement::release_before() {
3815  clear_has_before();
3816  ::drizzled::message::Schema* temp = before_;
3817  before_ = NULL;
3818  return temp;
3819 }
3820 inline void AlterSchemaStatement::set_allocated_before(::drizzled::message::Schema* before) {
3821  delete before_;
3822  before_ = before;
3823  if (before) {
3824  set_has_before();
3825  } else {
3826  clear_has_before();
3827  }
3828 }
3829 
3830 // required .drizzled.message.Schema after = 2;
3831 inline bool AlterSchemaStatement::has_after() const {
3832  return (_has_bits_[0] & 0x00000002u) != 0;
3833 }
3834 inline void AlterSchemaStatement::set_has_after() {
3835  _has_bits_[0] |= 0x00000002u;
3836 }
3837 inline void AlterSchemaStatement::clear_has_after() {
3838  _has_bits_[0] &= ~0x00000002u;
3839 }
3840 inline void AlterSchemaStatement::clear_after() {
3841  if (after_ != NULL) after_->::drizzled::message::Schema::Clear();
3842  clear_has_after();
3843 }
3844 inline const ::drizzled::message::Schema& AlterSchemaStatement::after() const {
3845  return after_ != NULL ? *after_ : *default_instance_->after_;
3846 }
3847 inline ::drizzled::message::Schema* AlterSchemaStatement::mutable_after() {
3848  set_has_after();
3849  if (after_ == NULL) after_ = new ::drizzled::message::Schema;
3850  return after_;
3851 }
3852 inline ::drizzled::message::Schema* AlterSchemaStatement::release_after() {
3853  clear_has_after();
3854  ::drizzled::message::Schema* temp = after_;
3855  after_ = NULL;
3856  return temp;
3857 }
3858 inline void AlterSchemaStatement::set_allocated_after(::drizzled::message::Schema* after) {
3859  delete after_;
3860  after_ = after;
3861  if (after) {
3862  set_has_after();
3863  } else {
3864  clear_has_after();
3865  }
3866 }
3867 
3868 // -------------------------------------------------------------------
3869 
3870 // DropSchemaStatement
3871 
3872 // required string schema_name = 1;
3873 inline bool DropSchemaStatement::has_schema_name() const {
3874  return (_has_bits_[0] & 0x00000001u) != 0;
3875 }
3876 inline void DropSchemaStatement::set_has_schema_name() {
3877  _has_bits_[0] |= 0x00000001u;
3878 }
3879 inline void DropSchemaStatement::clear_has_schema_name() {
3880  _has_bits_[0] &= ~0x00000001u;
3881 }
3882 inline void DropSchemaStatement::clear_schema_name() {
3883  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
3884  schema_name_->clear();
3885  }
3886  clear_has_schema_name();
3887 }
3888 inline const ::std::string& DropSchemaStatement::schema_name() const {
3889  return *schema_name_;
3890 }
3891 inline void DropSchemaStatement::set_schema_name(const ::std::string& value) {
3892  set_has_schema_name();
3893  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
3894  schema_name_ = new ::std::string;
3895  }
3896  schema_name_->assign(value);
3897 }
3898 inline void DropSchemaStatement::set_schema_name(const char* value) {
3899  set_has_schema_name();
3900  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
3901  schema_name_ = new ::std::string;
3902  }
3903  schema_name_->assign(value);
3904 }
3905 inline void DropSchemaStatement::set_schema_name(const char* value, size_t size) {
3906  set_has_schema_name();
3907  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
3908  schema_name_ = new ::std::string;
3909  }
3910  schema_name_->assign(reinterpret_cast<const char*>(value), size);
3911 }
3912 inline ::std::string* DropSchemaStatement::mutable_schema_name() {
3913  set_has_schema_name();
3914  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
3915  schema_name_ = new ::std::string;
3916  }
3917  return schema_name_;
3918 }
3919 inline ::std::string* DropSchemaStatement::release_schema_name() {
3920  clear_has_schema_name();
3921  if (schema_name_ == &::google::protobuf::internal::kEmptyString) {
3922  return NULL;
3923  } else {
3924  ::std::string* temp = schema_name_;
3925  schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
3926  return temp;
3927  }
3928 }
3929 inline void DropSchemaStatement::set_allocated_schema_name(::std::string* schema_name) {
3930  if (schema_name_ != &::google::protobuf::internal::kEmptyString) {
3931  delete schema_name_;
3932  }
3933  if (schema_name) {
3934  set_has_schema_name();
3935  schema_name_ = schema_name;
3936  } else {
3937  clear_has_schema_name();
3938  schema_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
3939  }
3940 }
3941 
3942 // optional string catalog_name = 2;
3943 inline bool DropSchemaStatement::has_catalog_name() const {
3944  return (_has_bits_[0] & 0x00000002u) != 0;
3945 }
3946 inline void DropSchemaStatement::set_has_catalog_name() {
3947  _has_bits_[0] |= 0x00000002u;
3948 }
3949 inline void DropSchemaStatement::clear_has_catalog_name() {
3950  _has_bits_[0] &= ~0x00000002u;
3951 }
3952 inline void DropSchemaStatement::clear_catalog_name() {
3953  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
3954  catalog_name_->clear();
3955  }
3956  clear_has_catalog_name();
3957 }
3958 inline const ::std::string& DropSchemaStatement::catalog_name() const {
3959  return *catalog_name_;
3960 }
3961 inline void DropSchemaStatement::set_catalog_name(const ::std::string& value) {
3962  set_has_catalog_name();
3963  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
3964  catalog_name_ = new ::std::string;
3965  }
3966  catalog_name_->assign(value);
3967 }
3968 inline void DropSchemaStatement::set_catalog_name(const char* value) {
3969  set_has_catalog_name();
3970  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
3971  catalog_name_ = new ::std::string;
3972  }
3973  catalog_name_->assign(value);
3974 }
3975 inline void DropSchemaStatement::set_catalog_name(const char* value, size_t size) {
3976  set_has_catalog_name();
3977  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
3978  catalog_name_ = new ::std::string;
3979  }
3980  catalog_name_->assign(reinterpret_cast<const char*>(value), size);
3981 }
3982 inline ::std::string* DropSchemaStatement::mutable_catalog_name() {
3983  set_has_catalog_name();
3984  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
3985  catalog_name_ = new ::std::string;
3986  }
3987  return catalog_name_;
3988 }
3989 inline ::std::string* DropSchemaStatement::release_catalog_name() {
3990  clear_has_catalog_name();
3991  if (catalog_name_ == &::google::protobuf::internal::kEmptyString) {
3992  return NULL;
3993  } else {
3994  ::std::string* temp = catalog_name_;
3995  catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
3996  return temp;
3997  }
3998 }
3999 inline void DropSchemaStatement::set_allocated_catalog_name(::std::string* catalog_name) {
4000  if (catalog_name_ != &::google::protobuf::internal::kEmptyString) {
4001  delete catalog_name_;
4002  }
4003  if (catalog_name) {
4004  set_has_catalog_name();
4005  catalog_name_ = catalog_name;
4006  } else {
4007  clear_has_catalog_name();
4008  catalog_name_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
4009  }
4010 }
4011 
4012 // -------------------------------------------------------------------
4013 
4014 // CreateTableStatement
4015 
4016 // required .drizzled.message.Table table = 1;
4017 inline bool CreateTableStatement::has_table() const {
4018  return (_has_bits_[0] & 0x00000001u) != 0;
4019 }
4020 inline void CreateTableStatement::set_has_table() {
4021  _has_bits_[0] |= 0x00000001u;
4022 }
4023 inline void CreateTableStatement::clear_has_table() {
4024  _has_bits_[0] &= ~0x00000001u;
4025 }
4026 inline void CreateTableStatement::clear_table() {
4027  if (table_ != NULL) table_->::drizzled::message::Table::Clear();
4028  clear_has_table();
4029 }
4030 inline const ::drizzled::message::Table& CreateTableStatement::table() const {
4031  return table_ != NULL ? *table_ : *default_instance_->table_;
4032 }
4033 inline ::drizzled::message::Table* CreateTableStatement::mutable_table() {
4034  set_has_table();
4035  if (table_ == NULL) table_ = new ::drizzled::message::Table;
4036  return table_;
4037 }
4038 inline ::drizzled::message::Table* CreateTableStatement::release_table() {
4039  clear_has_table();
4040  ::drizzled::message::Table* temp = table_;
4041  table_ = NULL;
4042  return temp;
4043 }
4044 inline void CreateTableStatement::set_allocated_table(::drizzled::message::Table* table) {
4045  delete table_;
4046  table_ = table;
4047  if (table) {
4048  set_has_table();
4049  } else {
4050  clear_has_table();
4051  }
4052 }
4053 
4054 // -------------------------------------------------------------------
4055 
4056 // AlterTableStatement
4057 
4058 // required .drizzled.message.Table before = 1;
4059 inline bool AlterTableStatement::has_before() const {
4060  return (_has_bits_[0] & 0x00000001u) != 0;
4061 }
4062 inline void AlterTableStatement::set_has_before() {
4063  _has_bits_[0] |= 0x00000001u;
4064 }
4065 inline void AlterTableStatement::clear_has_before() {
4066  _has_bits_[0] &= ~0x00000001u;
4067 }
4068 inline void AlterTableStatement::clear_before() {
4069  if (before_ != NULL) before_->::drizzled::message::Table::Clear();
4070  clear_has_before();
4071 }
4072 inline const ::drizzled::message::Table& AlterTableStatement::before() const {
4073  return before_ != NULL ? *before_ : *default_instance_->before_;
4074 }
4075 inline ::drizzled::message::Table* AlterTableStatement::mutable_before() {
4076  set_has_before();
4077  if (before_ == NULL) before_ = new ::drizzled::message::Table;
4078  return before_;
4079 }
4080 inline ::drizzled::message::Table* AlterTableStatement::release_before() {
4081  clear_has_before();
4082  ::drizzled::message::Table* temp = before_;
4083  before_ = NULL;
4084  return temp;
4085 }
4086 inline void AlterTableStatement::set_allocated_before(::drizzled::message::Table* before) {
4087  delete before_;
4088  before_ = before;
4089  if (before) {
4090  set_has_before();
4091  } else {
4092  clear_has_before();
4093  }
4094 }
4095 
4096 // required .drizzled.message.Table after = 2;
4097 inline bool AlterTableStatement::has_after() const {
4098  return (_has_bits_[0] & 0x00000002u) != 0;
4099 }
4100 inline void AlterTableStatement::set_has_after() {
4101  _has_bits_[0] |= 0x00000002u;
4102 }
4103 inline void AlterTableStatement::clear_has_after() {
4104  _has_bits_[0] &= ~0x00000002u;
4105 }
4106 inline void AlterTableStatement::clear_after() {
4107  if (after_ != NULL) after_->::drizzled::message::Table::Clear();
4108  clear_has_after();
4109 }
4110 inline const ::drizzled::message::Table& AlterTableStatement::after() const {
4111  return after_ != NULL ? *after_ : *default_instance_->after_;
4112 }
4113 inline ::drizzled::message::Table* AlterTableStatement::mutable_after() {
4114  set_has_after();
4115  if (after_ == NULL) after_ = new ::drizzled::message::Table;
4116  return after_;
4117 }
4118 inline ::drizzled::message::Table* AlterTableStatement::release_after() {
4119  clear_has_after();
4120  ::drizzled::message::Table* temp = after_;
4121  after_ = NULL;
4122  return temp;
4123 }
4124 inline void AlterTableStatement::set_allocated_after(::drizzled::message::Table* after) {
4125  delete after_;
4126  after_ = after;
4127  if (after) {
4128  set_has_after();
4129  } else {
4130  clear_has_after();
4131  }
4132 }
4133 
4134 // -------------------------------------------------------------------
4135 
4136 // DropTableStatement
4137 
4138 // required .drizzled.message.TableMetadata table_metadata = 1;
4139 inline bool DropTableStatement::has_table_metadata() const {
4140  return (_has_bits_[0] & 0x00000001u) != 0;
4141 }
4142 inline void DropTableStatement::set_has_table_metadata() {
4143  _has_bits_[0] |= 0x00000001u;
4144 }
4145 inline void DropTableStatement::clear_has_table_metadata() {
4146  _has_bits_[0] &= ~0x00000001u;
4147 }
4148 inline void DropTableStatement::clear_table_metadata() {
4149  if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
4150  clear_has_table_metadata();
4151 }
4152 inline const ::drizzled::message::TableMetadata& DropTableStatement::table_metadata() const {
4153  return table_metadata_ != NULL ? *table_metadata_ : *default_instance_->table_metadata_;
4154 }
4155 inline ::drizzled::message::TableMetadata* DropTableStatement::mutable_table_metadata() {
4156  set_has_table_metadata();
4157  if (table_metadata_ == NULL) table_metadata_ = new ::drizzled::message::TableMetadata;
4158  return table_metadata_;
4159 }
4160 inline ::drizzled::message::TableMetadata* DropTableStatement::release_table_metadata() {
4161  clear_has_table_metadata();
4162  ::drizzled::message::TableMetadata* temp = table_metadata_;
4163  table_metadata_ = NULL;
4164  return temp;
4165 }
4166 inline void DropTableStatement::set_allocated_table_metadata(::drizzled::message::TableMetadata* table_metadata) {
4167  delete table_metadata_;
4168  table_metadata_ = table_metadata;
4169  if (table_metadata) {
4170  set_has_table_metadata();
4171  } else {
4172  clear_has_table_metadata();
4173  }
4174 }
4175 
4176 // optional bool if_exists_clause = 2;
4177 inline bool DropTableStatement::has_if_exists_clause() const {
4178  return (_has_bits_[0] & 0x00000002u) != 0;
4179 }
4180 inline void DropTableStatement::set_has_if_exists_clause() {
4181  _has_bits_[0] |= 0x00000002u;
4182 }
4183 inline void DropTableStatement::clear_has_if_exists_clause() {
4184  _has_bits_[0] &= ~0x00000002u;
4185 }
4186 inline void DropTableStatement::clear_if_exists_clause() {
4187  if_exists_clause_ = false;
4188  clear_has_if_exists_clause();
4189 }
4190 inline bool DropTableStatement::if_exists_clause() const {
4191  return if_exists_clause_;
4192 }
4193 inline void DropTableStatement::set_if_exists_clause(bool value) {
4194  set_has_if_exists_clause();
4195  if_exists_clause_ = value;
4196 }
4197 
4198 // -------------------------------------------------------------------
4199 
4200 // SetVariableStatement
4201 
4202 // required .drizzled.message.FieldMetadata variable_metadata = 1;
4203 inline bool SetVariableStatement::has_variable_metadata() const {
4204  return (_has_bits_[0] & 0x00000001u) != 0;
4205 }
4206 inline void SetVariableStatement::set_has_variable_metadata() {
4207  _has_bits_[0] |= 0x00000001u;
4208 }
4209 inline void SetVariableStatement::clear_has_variable_metadata() {
4210  _has_bits_[0] &= ~0x00000001u;
4211 }
4212 inline void SetVariableStatement::clear_variable_metadata() {
4213  if (variable_metadata_ != NULL) variable_metadata_->::drizzled::message::FieldMetadata::Clear();
4214  clear_has_variable_metadata();
4215 }
4216 inline const ::drizzled::message::FieldMetadata& SetVariableStatement::variable_metadata() const {
4217  return variable_metadata_ != NULL ? *variable_metadata_ : *default_instance_->variable_metadata_;
4218 }
4219 inline ::drizzled::message::FieldMetadata* SetVariableStatement::mutable_variable_metadata() {
4220  set_has_variable_metadata();
4221  if (variable_metadata_ == NULL) variable_metadata_ = new ::drizzled::message::FieldMetadata;
4222  return variable_metadata_;
4223 }
4224 inline ::drizzled::message::FieldMetadata* SetVariableStatement::release_variable_metadata() {
4225  clear_has_variable_metadata();
4226  ::drizzled::message::FieldMetadata* temp = variable_metadata_;
4227  variable_metadata_ = NULL;
4228  return temp;
4229 }
4230 inline void SetVariableStatement::set_allocated_variable_metadata(::drizzled::message::FieldMetadata* variable_metadata) {
4231  delete variable_metadata_;
4232  variable_metadata_ = variable_metadata;
4233  if (variable_metadata) {
4234  set_has_variable_metadata();
4235  } else {
4236  clear_has_variable_metadata();
4237  }
4238 }
4239 
4240 // required bytes variable_value = 2;
4241 inline bool SetVariableStatement::has_variable_value() const {
4242  return (_has_bits_[0] & 0x00000002u) != 0;
4243 }
4244 inline void SetVariableStatement::set_has_variable_value() {
4245  _has_bits_[0] |= 0x00000002u;
4246 }
4247 inline void SetVariableStatement::clear_has_variable_value() {
4248  _has_bits_[0] &= ~0x00000002u;
4249 }
4250 inline void SetVariableStatement::clear_variable_value() {
4251  if (variable_value_ != &::google::protobuf::internal::kEmptyString) {
4252  variable_value_->clear();
4253  }
4254  clear_has_variable_value();
4255 }
4256 inline const ::std::string& SetVariableStatement::variable_value() const {
4257  return *variable_value_;
4258 }
4259 inline void SetVariableStatement::set_variable_value(const ::std::string& value) {
4260  set_has_variable_value();
4261  if (variable_value_ == &::google::protobuf::internal::kEmptyString) {
4262  variable_value_ = new ::std::string;
4263  }
4264  variable_value_->assign(value);
4265 }
4266 inline void SetVariableStatement::set_variable_value(const char* value) {
4267  set_has_variable_value();
4268  if (variable_value_ == &::google::protobuf::internal::kEmptyString) {
4269  variable_value_ = new ::std::string;
4270  }
4271  variable_value_->assign(value);
4272 }
4273 inline void SetVariableStatement::set_variable_value(const void* value, size_t size) {
4274  set_has_variable_value();
4275  if (variable_value_ == &::google::protobuf::internal::kEmptyString) {
4276  variable_value_ = new ::std::string;
4277  }
4278  variable_value_->assign(reinterpret_cast<const char*>(value), size);
4279 }
4280 inline ::std::string* SetVariableStatement::mutable_variable_value() {
4281  set_has_variable_value();
4282  if (variable_value_ == &::google::protobuf::internal::kEmptyString) {
4283  variable_value_ = new ::std::string;
4284  }
4285  return variable_value_;
4286 }
4287 inline ::std::string* SetVariableStatement::release_variable_value() {
4288  clear_has_variable_value();
4289  if (variable_value_ == &::google::protobuf::internal::kEmptyString) {
4290  return NULL;
4291  } else {
4292  ::std::string* temp = variable_value_;
4293  variable_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
4294  return temp;
4295  }
4296 }
4297 inline void SetVariableStatement::set_allocated_variable_value(::std::string* variable_value) {
4298  if (variable_value_ != &::google::protobuf::internal::kEmptyString) {
4299  delete variable_value_;
4300  }
4301  if (variable_value) {
4302  set_has_variable_value();
4303  variable_value_ = variable_value;
4304  } else {
4305  clear_has_variable_value();
4306  variable_value_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
4307  }
4308 }
4309 
4310 // -------------------------------------------------------------------
4311 
4312 // Statement
4313 
4314 // required .drizzled.message.Statement.Type type = 1;
4315 inline bool Statement::has_type() const {
4316  return (_has_bits_[0] & 0x00000001u) != 0;
4317 }
4318 inline void Statement::set_has_type() {
4319  _has_bits_[0] |= 0x00000001u;
4320 }
4321 inline void Statement::clear_has_type() {
4322  _has_bits_[0] &= ~0x00000001u;
4323 }
4324 inline void Statement::clear_type() {
4325  type_ = 0;
4326  clear_has_type();
4327 }
4328 inline ::drizzled::message::Statement_Type Statement::type() const {
4329  return static_cast< ::drizzled::message::Statement_Type >(type_);
4330 }
4331 inline void Statement::set_type(::drizzled::message::Statement_Type value) {
4332  assert(::drizzled::message::Statement_Type_IsValid(value));
4333  set_has_type();
4334  type_ = value;
4335 }
4336 
4337 // required uint64 start_timestamp = 2;
4338 inline bool Statement::has_start_timestamp() const {
4339  return (_has_bits_[0] & 0x00000002u) != 0;
4340 }
4341 inline void Statement::set_has_start_timestamp() {
4342  _has_bits_[0] |= 0x00000002u;
4343 }
4344 inline void Statement::clear_has_start_timestamp() {
4345  _has_bits_[0] &= ~0x00000002u;
4346 }
4347 inline void Statement::clear_start_timestamp() {
4348  start_timestamp_ = GOOGLE_ULONGLONG(0);
4349  clear_has_start_timestamp();
4350 }
4351 inline ::google::protobuf::uint64 Statement::start_timestamp() const {
4352  return start_timestamp_;
4353 }
4354 inline void Statement::set_start_timestamp(::google::protobuf::uint64 value) {
4355  set_has_start_timestamp();
4356  start_timestamp_ = value;
4357 }
4358 
4359 // required uint64 end_timestamp = 3;
4360 inline bool Statement::has_end_timestamp() const {
4361  return (_has_bits_[0] & 0x00000004u) != 0;
4362 }
4363 inline void Statement::set_has_end_timestamp() {
4364  _has_bits_[0] |= 0x00000004u;
4365 }
4366 inline void Statement::clear_has_end_timestamp() {
4367  _has_bits_[0] &= ~0x00000004u;
4368 }
4369 inline void Statement::clear_end_timestamp() {
4370  end_timestamp_ = GOOGLE_ULONGLONG(0);
4371  clear_has_end_timestamp();
4372 }
4373 inline ::google::protobuf::uint64 Statement::end_timestamp() const {
4374  return end_timestamp_;
4375 }
4376 inline void Statement::set_end_timestamp(::google::protobuf::uint64 value) {
4377  set_has_end_timestamp();
4378  end_timestamp_ = value;
4379 }
4380 
4381 // optional string sql = 4;
4382 inline bool Statement::has_sql() const {
4383  return (_has_bits_[0] & 0x00000008u) != 0;
4384 }
4385 inline void Statement::set_has_sql() {
4386  _has_bits_[0] |= 0x00000008u;
4387 }
4388 inline void Statement::clear_has_sql() {
4389  _has_bits_[0] &= ~0x00000008u;
4390 }
4391 inline void Statement::clear_sql() {
4392  if (sql_ != &::google::protobuf::internal::kEmptyString) {
4393  sql_->clear();
4394  }
4395  clear_has_sql();
4396 }
4397 inline const ::std::string& Statement::sql() const {
4398  return *sql_;
4399 }
4400 inline void Statement::set_sql(const ::std::string& value) {
4401  set_has_sql();
4402  if (sql_ == &::google::protobuf::internal::kEmptyString) {
4403  sql_ = new ::std::string;
4404  }
4405  sql_->assign(value);
4406 }
4407 inline void Statement::set_sql(const char* value) {
4408  set_has_sql();
4409  if (sql_ == &::google::protobuf::internal::kEmptyString) {
4410  sql_ = new ::std::string;
4411  }
4412  sql_->assign(value);
4413 }
4414 inline void Statement::set_sql(const char* value, size_t size) {
4415  set_has_sql();
4416  if (sql_ == &::google::protobuf::internal::kEmptyString) {
4417  sql_ = new ::std::string;
4418  }
4419  sql_->assign(reinterpret_cast<const char*>(value), size);
4420 }
4421 inline ::std::string* Statement::mutable_sql() {
4422  set_has_sql();
4423  if (sql_ == &::google::protobuf::internal::kEmptyString) {
4424  sql_ = new ::std::string;
4425  }
4426  return sql_;
4427 }
4428 inline ::std::string* Statement::release_sql() {
4429  clear_has_sql();
4430  if (sql_ == &::google::protobuf::internal::kEmptyString) {
4431  return NULL;
4432  } else {
4433  ::std::string* temp = sql_;
4434  sql_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
4435  return temp;
4436  }
4437 }
4438 inline void Statement::set_allocated_sql(::std::string* sql) {
4439  if (sql_ != &::google::protobuf::internal::kEmptyString) {
4440  delete sql_;
4441  }
4442  if (sql) {
4443  set_has_sql();
4444  sql_ = sql;
4445  } else {
4446  clear_has_sql();
4447  sql_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
4448  }
4449 }
4450 
4451 // optional .drizzled.message.InsertHeader insert_header = 5;
4452 inline bool Statement::has_insert_header() const {
4453  return (_has_bits_[0] & 0x00000010u) != 0;
4454 }
4455 inline void Statement::set_has_insert_header() {
4456  _has_bits_[0] |= 0x00000010u;
4457 }
4458 inline void Statement::clear_has_insert_header() {
4459  _has_bits_[0] &= ~0x00000010u;
4460 }
4461 inline void Statement::clear_insert_header() {
4462  if (insert_header_ != NULL) insert_header_->::drizzled::message::InsertHeader::Clear();
4463  clear_has_insert_header();
4464 }
4465 inline const ::drizzled::message::InsertHeader& Statement::insert_header() const {
4466  return insert_header_ != NULL ? *insert_header_ : *default_instance_->insert_header_;
4467 }
4468 inline ::drizzled::message::InsertHeader* Statement::mutable_insert_header() {
4469  set_has_insert_header();
4470  if (insert_header_ == NULL) insert_header_ = new ::drizzled::message::InsertHeader;
4471  return insert_header_;
4472 }
4473 inline ::drizzled::message::InsertHeader* Statement::release_insert_header() {
4474  clear_has_insert_header();
4475  ::drizzled::message::InsertHeader* temp = insert_header_;
4476  insert_header_ = NULL;
4477  return temp;
4478 }
4479 inline void Statement::set_allocated_insert_header(::drizzled::message::InsertHeader* insert_header) {
4480  delete insert_header_;
4481  insert_header_ = insert_header;
4482  if (insert_header) {
4483  set_has_insert_header();
4484  } else {
4485  clear_has_insert_header();
4486  }
4487 }
4488 
4489 // optional .drizzled.message.InsertData insert_data = 6;
4490 inline bool Statement::has_insert_data() const {
4491  return (_has_bits_[0] & 0x00000020u) != 0;
4492 }
4493 inline void Statement::set_has_insert_data() {
4494  _has_bits_[0] |= 0x00000020u;
4495 }
4496 inline void Statement::clear_has_insert_data() {
4497  _has_bits_[0] &= ~0x00000020u;
4498 }
4499 inline void Statement::clear_insert_data() {
4500  if (insert_data_ != NULL) insert_data_->::drizzled::message::InsertData::Clear();
4501  clear_has_insert_data();
4502 }
4503 inline const ::drizzled::message::InsertData& Statement::insert_data() const {
4504  return insert_data_ != NULL ? *insert_data_ : *default_instance_->insert_data_;
4505 }
4506 inline ::drizzled::message::InsertData* Statement::mutable_insert_data() {
4507  set_has_insert_data();
4508  if (insert_data_ == NULL) insert_data_ = new ::drizzled::message::InsertData;
4509  return insert_data_;
4510 }
4511 inline ::drizzled::message::InsertData* Statement::release_insert_data() {
4512  clear_has_insert_data();
4513  ::drizzled::message::InsertData* temp = insert_data_;
4514  insert_data_ = NULL;
4515  return temp;
4516 }
4517 inline void Statement::set_allocated_insert_data(::drizzled::message::InsertData* insert_data) {
4518  delete insert_data_;
4519  insert_data_ = insert_data;
4520  if (insert_data) {
4521  set_has_insert_data();
4522  } else {
4523  clear_has_insert_data();
4524  }
4525 }
4526 
4527 // optional .drizzled.message.UpdateHeader update_header = 7;
4528 inline bool Statement::has_update_header() const {
4529  return (_has_bits_[0] & 0x00000040u) != 0;
4530 }
4531 inline void Statement::set_has_update_header() {
4532  _has_bits_[0] |= 0x00000040u;
4533 }
4534 inline void Statement::clear_has_update_header() {
4535  _has_bits_[0] &= ~0x00000040u;
4536 }
4537 inline void Statement::clear_update_header() {
4538  if (update_header_ != NULL) update_header_->::drizzled::message::UpdateHeader::Clear();
4539  clear_has_update_header();
4540 }
4541 inline const ::drizzled::message::UpdateHeader& Statement::update_header() const {
4542  return update_header_ != NULL ? *update_header_ : *default_instance_->update_header_;
4543 }
4544 inline ::drizzled::message::UpdateHeader* Statement::mutable_update_header() {
4545  set_has_update_header();
4546  if (update_header_ == NULL) update_header_ = new ::drizzled::message::UpdateHeader;
4547  return update_header_;
4548 }
4549 inline ::drizzled::message::UpdateHeader* Statement::release_update_header() {
4550  clear_has_update_header();
4551  ::drizzled::message::UpdateHeader* temp = update_header_;
4552  update_header_ = NULL;
4553  return temp;
4554 }
4555 inline void Statement::set_allocated_update_header(::drizzled::message::UpdateHeader* update_header) {
4556  delete update_header_;
4557  update_header_ = update_header;
4558  if (update_header) {
4559  set_has_update_header();
4560  } else {
4561  clear_has_update_header();
4562  }
4563 }
4564 
4565 // optional .drizzled.message.UpdateData update_data = 8;
4566 inline bool Statement::has_update_data() const {
4567  return (_has_bits_[0] & 0x00000080u) != 0;
4568 }
4569 inline void Statement::set_has_update_data() {
4570  _has_bits_[0] |= 0x00000080u;
4571 }
4572 inline void Statement::clear_has_update_data() {
4573  _has_bits_[0] &= ~0x00000080u;
4574 }
4575 inline void Statement::clear_update_data() {
4576  if (update_data_ != NULL) update_data_->::drizzled::message::UpdateData::Clear();
4577  clear_has_update_data();
4578 }
4579 inline const ::drizzled::message::UpdateData& Statement::update_data() const {
4580  return update_data_ != NULL ? *update_data_ : *default_instance_->update_data_;
4581 }
4582 inline ::drizzled::message::UpdateData* Statement::mutable_update_data() {
4583  set_has_update_data();
4584  if (update_data_ == NULL) update_data_ = new ::drizzled::message::UpdateData;
4585  return update_data_;
4586 }
4587 inline ::drizzled::message::UpdateData* Statement::release_update_data() {
4588  clear_has_update_data();
4589  ::drizzled::message::UpdateData* temp = update_data_;
4590  update_data_ = NULL;
4591  return temp;
4592 }
4593 inline void Statement::set_allocated_update_data(::drizzled::message::UpdateData* update_data) {
4594  delete update_data_;
4595  update_data_ = update_data;
4596  if (update_data) {
4597  set_has_update_data();
4598  } else {
4599  clear_has_update_data();
4600  }
4601 }
4602 
4603 // optional .drizzled.message.DeleteHeader delete_header = 9;
4604 inline bool Statement::has_delete_header() const {
4605  return (_has_bits_[0] & 0x00000100u) != 0;
4606 }
4607 inline void Statement::set_has_delete_header() {
4608  _has_bits_[0] |= 0x00000100u;
4609 }
4610 inline void Statement::clear_has_delete_header() {
4611  _has_bits_[0] &= ~0x00000100u;
4612 }
4613 inline void Statement::clear_delete_header() {
4614  if (delete_header_ != NULL) delete_header_->::drizzled::message::DeleteHeader::Clear();
4615  clear_has_delete_header();
4616 }
4617 inline const ::drizzled::message::DeleteHeader& Statement::delete_header() const {
4618  return delete_header_ != NULL ? *delete_header_ : *default_instance_->delete_header_;
4619 }
4620 inline ::drizzled::message::DeleteHeader* Statement::mutable_delete_header() {
4621  set_has_delete_header();
4622  if (delete_header_ == NULL) delete_header_ = new ::drizzled::message::DeleteHeader;
4623  return delete_header_;
4624 }
4625 inline ::drizzled::message::DeleteHeader* Statement::release_delete_header() {
4626  clear_has_delete_header();
4627  ::drizzled::message::DeleteHeader* temp = delete_header_;
4628  delete_header_ = NULL;
4629  return temp;
4630 }
4631 inline void Statement::set_allocated_delete_header(::drizzled::message::DeleteHeader* delete_header) {
4632  delete delete_header_;
4633  delete_header_ = delete_header;
4634  if (delete_header) {
4635  set_has_delete_header();
4636  } else {
4637  clear_has_delete_header();
4638  }
4639 }
4640 
4641 // optional .drizzled.message.DeleteData delete_data = 10;
4642 inline bool Statement::has_delete_data() const {
4643  return (_has_bits_[0] & 0x00000200u) != 0;
4644 }
4645 inline void Statement::set_has_delete_data() {
4646  _has_bits_[0] |= 0x00000200u;
4647 }
4648 inline void Statement::clear_has_delete_data() {
4649  _has_bits_[0] &= ~0x00000200u;
4650 }
4651 inline void Statement::clear_delete_data() {
4652  if (delete_data_ != NULL) delete_data_->::drizzled::message::DeleteData::Clear();
4653  clear_has_delete_data();
4654 }
4655 inline const ::drizzled::message::DeleteData& Statement::delete_data() const {
4656  return delete_data_ != NULL ? *delete_data_ : *default_instance_->delete_data_;
4657 }
4658 inline ::drizzled::message::DeleteData* Statement::mutable_delete_data() {
4659  set_has_delete_data();
4660  if (delete_data_ == NULL) delete_data_ = new ::drizzled::message::DeleteData;
4661  return delete_data_;
4662 }
4663 inline ::drizzled::message::DeleteData* Statement::release_delete_data() {
4664  clear_has_delete_data();
4665  ::drizzled::message::DeleteData* temp = delete_data_;
4666  delete_data_ = NULL;
4667  return temp;
4668 }
4669 inline void Statement::set_allocated_delete_data(::drizzled::message::DeleteData* delete_data) {
4670  delete delete_data_;
4671  delete_data_ = delete_data;
4672  if (delete_data) {
4673  set_has_delete_data();
4674  } else {
4675  clear_has_delete_data();
4676  }
4677 }
4678 
4679 // optional .drizzled.message.TruncateTableStatement truncate_table_statement = 11;
4680 inline bool Statement::has_truncate_table_statement() const {
4681  return (_has_bits_[0] & 0x00000400u) != 0;
4682 }
4683 inline void Statement::set_has_truncate_table_statement() {
4684  _has_bits_[0] |= 0x00000400u;
4685 }
4686 inline void Statement::clear_has_truncate_table_statement() {
4687  _has_bits_[0] &= ~0x00000400u;
4688 }
4689 inline void Statement::clear_truncate_table_statement() {
4690  if (truncate_table_statement_ != NULL) truncate_table_statement_->::drizzled::message::TruncateTableStatement::Clear();
4691  clear_has_truncate_table_statement();
4692 }
4693 inline const ::drizzled::message::TruncateTableStatement& Statement::truncate_table_statement() const {
4694  return truncate_table_statement_ != NULL ? *truncate_table_statement_ : *default_instance_->truncate_table_statement_;
4695 }
4696 inline ::drizzled::message::TruncateTableStatement* Statement::mutable_truncate_table_statement() {
4697  set_has_truncate_table_statement();
4698  if (truncate_table_statement_ == NULL) truncate_table_statement_ = new ::drizzled::message::TruncateTableStatement;
4699  return truncate_table_statement_;
4700 }
4701 inline ::drizzled::message::TruncateTableStatement* Statement::release_truncate_table_statement() {
4702  clear_has_truncate_table_statement();
4703  ::drizzled::message::TruncateTableStatement* temp = truncate_table_statement_;
4704  truncate_table_statement_ = NULL;
4705  return temp;
4706 }
4707 inline void Statement::set_allocated_truncate_table_statement(::drizzled::message::TruncateTableStatement* truncate_table_statement) {
4708  delete truncate_table_statement_;
4709  truncate_table_statement_ = truncate_table_statement;
4710  if (truncate_table_statement) {
4711  set_has_truncate_table_statement();
4712  } else {
4713  clear_has_truncate_table_statement();
4714  }
4715 }
4716 
4717 // optional .drizzled.message.CreateSchemaStatement create_schema_statement = 12;
4718 inline bool Statement::has_create_schema_statement() const {
4719  return (_has_bits_[0] & 0x00000800u) != 0;
4720 }
4721 inline void Statement::set_has_create_schema_statement() {
4722  _has_bits_[0] |= 0x00000800u;
4723 }
4724 inline void Statement::clear_has_create_schema_statement() {
4725  _has_bits_[0] &= ~0x00000800u;
4726 }
4727 inline void Statement::clear_create_schema_statement() {
4728  if (create_schema_statement_ != NULL) create_schema_statement_->::drizzled::message::CreateSchemaStatement::Clear();
4729  clear_has_create_schema_statement();
4730 }
4731 inline const ::drizzled::message::CreateSchemaStatement& Statement::create_schema_statement() const {
4732  return create_schema_statement_ != NULL ? *create_schema_statement_ : *default_instance_->create_schema_statement_;
4733 }
4734 inline ::drizzled::message::CreateSchemaStatement* Statement::mutable_create_schema_statement() {
4735  set_has_create_schema_statement();
4736  if (create_schema_statement_ == NULL) create_schema_statement_ = new ::drizzled::message::CreateSchemaStatement;
4737  return create_schema_statement_;
4738 }
4739 inline ::drizzled::message::CreateSchemaStatement* Statement::release_create_schema_statement() {
4740  clear_has_create_schema_statement();
4741  ::drizzled::message::CreateSchemaStatement* temp = create_schema_statement_;
4742  create_schema_statement_ = NULL;
4743  return temp;
4744 }
4745 inline void Statement::set_allocated_create_schema_statement(::drizzled::message::CreateSchemaStatement* create_schema_statement) {
4746  delete create_schema_statement_;
4747  create_schema_statement_ = create_schema_statement;
4748  if (create_schema_statement) {
4749  set_has_create_schema_statement();
4750  } else {
4751  clear_has_create_schema_statement();
4752  }
4753 }
4754 
4755 // optional .drizzled.message.DropSchemaStatement drop_schema_statement = 13;
4756 inline bool Statement::has_drop_schema_statement() const {
4757  return (_has_bits_[0] & 0x00001000u) != 0;
4758 }
4759 inline void Statement::set_has_drop_schema_statement() {
4760  _has_bits_[0] |= 0x00001000u;
4761 }
4762 inline void Statement::clear_has_drop_schema_statement() {
4763  _has_bits_[0] &= ~0x00001000u;
4764 }
4765 inline void Statement::clear_drop_schema_statement() {
4766  if (drop_schema_statement_ != NULL) drop_schema_statement_->::drizzled::message::DropSchemaStatement::Clear();
4767  clear_has_drop_schema_statement();
4768 }
4769 inline const ::drizzled::message::DropSchemaStatement& Statement::drop_schema_statement() const {
4770  return drop_schema_statement_ != NULL ? *drop_schema_statement_ : *default_instance_->drop_schema_statement_;
4771 }
4772 inline ::drizzled::message::DropSchemaStatement* Statement::mutable_drop_schema_statement() {
4773  set_has_drop_schema_statement();
4774  if (drop_schema_statement_ == NULL) drop_schema_statement_ = new ::drizzled::message::DropSchemaStatement;
4775  return drop_schema_statement_;
4776 }
4777 inline ::drizzled::message::DropSchemaStatement* Statement::release_drop_schema_statement() {
4778  clear_has_drop_schema_statement();
4779  ::drizzled::message::DropSchemaStatement* temp = drop_schema_statement_;
4780  drop_schema_statement_ = NULL;
4781  return temp;
4782 }
4783 inline void Statement::set_allocated_drop_schema_statement(::drizzled::message::DropSchemaStatement* drop_schema_statement) {
4784  delete drop_schema_statement_;
4785  drop_schema_statement_ = drop_schema_statement;
4786  if (drop_schema_statement) {
4787  set_has_drop_schema_statement();
4788  } else {
4789  clear_has_drop_schema_statement();
4790  }
4791 }
4792 
4793 // optional .drizzled.message.AlterSchemaStatement alter_schema_statement = 14;
4794 inline bool Statement::has_alter_schema_statement() const {
4795  return (_has_bits_[0] & 0x00002000u) != 0;
4796 }
4797 inline void Statement::set_has_alter_schema_statement() {
4798  _has_bits_[0] |= 0x00002000u;
4799 }
4800 inline void Statement::clear_has_alter_schema_statement() {
4801  _has_bits_[0] &= ~0x00002000u;
4802 }
4803 inline void Statement::clear_alter_schema_statement() {
4804  if (alter_schema_statement_ != NULL) alter_schema_statement_->::drizzled::message::AlterSchemaStatement::Clear();
4805  clear_has_alter_schema_statement();
4806 }
4807 inline const ::drizzled::message::AlterSchemaStatement& Statement::alter_schema_statement() const {
4808  return alter_schema_statement_ != NULL ? *alter_schema_statement_ : *default_instance_->alter_schema_statement_;
4809 }
4810 inline ::drizzled::message::AlterSchemaStatement* Statement::mutable_alter_schema_statement() {
4811  set_has_alter_schema_statement();
4812  if (alter_schema_statement_ == NULL) alter_schema_statement_ = new ::drizzled::message::AlterSchemaStatement;
4813  return alter_schema_statement_;
4814 }
4815 inline ::drizzled::message::AlterSchemaStatement* Statement::release_alter_schema_statement() {
4816  clear_has_alter_schema_statement();
4817  ::drizzled::message::AlterSchemaStatement* temp = alter_schema_statement_;
4818  alter_schema_statement_ = NULL;
4819  return temp;
4820 }
4821 inline void Statement::set_allocated_alter_schema_statement(::drizzled::message::AlterSchemaStatement* alter_schema_statement) {
4822  delete alter_schema_statement_;
4823  alter_schema_statement_ = alter_schema_statement;
4824  if (alter_schema_statement) {
4825  set_has_alter_schema_statement();
4826  } else {
4827  clear_has_alter_schema_statement();
4828  }
4829 }
4830 
4831 // optional .drizzled.message.CreateTableStatement create_table_statement = 15;
4832 inline bool Statement::has_create_table_statement() const {
4833  return (_has_bits_[0] & 0x00004000u) != 0;
4834 }
4835 inline void Statement::set_has_create_table_statement() {
4836  _has_bits_[0] |= 0x00004000u;
4837 }
4838 inline void Statement::clear_has_create_table_statement() {
4839  _has_bits_[0] &= ~0x00004000u;
4840 }
4841 inline void Statement::clear_create_table_statement() {
4842  if (create_table_statement_ != NULL) create_table_statement_->::drizzled::message::CreateTableStatement::Clear();
4843  clear_has_create_table_statement();
4844 }
4845 inline const ::drizzled::message::CreateTableStatement& Statement::create_table_statement() const {
4846  return create_table_statement_ != NULL ? *create_table_statement_ : *default_instance_->create_table_statement_;
4847 }
4848 inline ::drizzled::message::CreateTableStatement* Statement::mutable_create_table_statement() {
4849  set_has_create_table_statement();
4850  if (create_table_statement_ == NULL) create_table_statement_ = new ::drizzled::message::CreateTableStatement;
4851  return create_table_statement_;
4852 }
4853 inline ::drizzled::message::CreateTableStatement* Statement::release_create_table_statement() {
4854  clear_has_create_table_statement();
4855  ::drizzled::message::CreateTableStatement* temp = create_table_statement_;
4856  create_table_statement_ = NULL;
4857  return temp;
4858 }
4859 inline void Statement::set_allocated_create_table_statement(::drizzled::message::CreateTableStatement* create_table_statement) {
4860  delete create_table_statement_;
4861  create_table_statement_ = create_table_statement;
4862  if (create_table_statement) {
4863  set_has_create_table_statement();
4864  } else {
4865  clear_has_create_table_statement();
4866  }
4867 }
4868 
4869 // optional .drizzled.message.AlterTableStatement alter_table_statement = 16;
4870 inline bool Statement::has_alter_table_statement() const {
4871  return (_has_bits_[0] & 0x00008000u) != 0;
4872 }
4873 inline void Statement::set_has_alter_table_statement() {
4874  _has_bits_[0] |= 0x00008000u;
4875 }
4876 inline void Statement::clear_has_alter_table_statement() {
4877  _has_bits_[0] &= ~0x00008000u;
4878 }
4879 inline void Statement::clear_alter_table_statement() {
4880  if (alter_table_statement_ != NULL) alter_table_statement_->::drizzled::message::AlterTableStatement::Clear();
4881  clear_has_alter_table_statement();
4882 }
4883 inline const ::drizzled::message::AlterTableStatement& Statement::alter_table_statement() const {
4884  return alter_table_statement_ != NULL ? *alter_table_statement_ : *default_instance_->alter_table_statement_;
4885 }
4886 inline ::drizzled::message::AlterTableStatement* Statement::mutable_alter_table_statement() {
4887  set_has_alter_table_statement();
4888  if (alter_table_statement_ == NULL) alter_table_statement_ = new ::drizzled::message::AlterTableStatement;
4889  return alter_table_statement_;
4890 }
4891 inline ::drizzled::message::AlterTableStatement* Statement::release_alter_table_statement() {
4892  clear_has_alter_table_statement();
4893  ::drizzled::message::AlterTableStatement* temp = alter_table_statement_;
4894  alter_table_statement_ = NULL;
4895  return temp;
4896 }
4897 inline void Statement::set_allocated_alter_table_statement(::drizzled::message::AlterTableStatement* alter_table_statement) {
4898  delete alter_table_statement_;
4899  alter_table_statement_ = alter_table_statement;
4900  if (alter_table_statement) {
4901  set_has_alter_table_statement();
4902  } else {
4903  clear_has_alter_table_statement();
4904  }
4905 }
4906 
4907 // optional .drizzled.message.DropTableStatement drop_table_statement = 17;
4908 inline bool Statement::has_drop_table_statement() const {
4909  return (_has_bits_[0] & 0x00010000u) != 0;
4910 }
4911 inline void Statement::set_has_drop_table_statement() {
4912  _has_bits_[0] |= 0x00010000u;
4913 }
4914 inline void Statement::clear_has_drop_table_statement() {
4915  _has_bits_[0] &= ~0x00010000u;
4916 }
4917 inline void Statement::clear_drop_table_statement() {
4918  if (drop_table_statement_ != NULL) drop_table_statement_->::drizzled::message::DropTableStatement::Clear();
4919  clear_has_drop_table_statement();
4920 }
4921 inline const ::drizzled::message::DropTableStatement& Statement::drop_table_statement() const {
4922  return drop_table_statement_ != NULL ? *drop_table_statement_ : *default_instance_->drop_table_statement_;
4923 }
4924 inline ::drizzled::message::DropTableStatement* Statement::mutable_drop_table_statement() {
4925  set_has_drop_table_statement();
4926  if (drop_table_statement_ == NULL) drop_table_statement_ = new ::drizzled::message::DropTableStatement;
4927  return drop_table_statement_;
4928 }
4929 inline ::drizzled::message::DropTableStatement* Statement::release_drop_table_statement() {
4930  clear_has_drop_table_statement();
4931  ::drizzled::message::DropTableStatement* temp = drop_table_statement_;
4932  drop_table_statement_ = NULL;
4933  return temp;
4934 }
4935 inline void Statement::set_allocated_drop_table_statement(::drizzled::message::DropTableStatement* drop_table_statement) {
4936  delete drop_table_statement_;
4937  drop_table_statement_ = drop_table_statement;
4938  if (drop_table_statement) {
4939  set_has_drop_table_statement();
4940  } else {
4941  clear_has_drop_table_statement();
4942  }
4943 }
4944 
4945 // optional .drizzled.message.SetVariableStatement set_variable_statement = 18;
4946 inline bool Statement::has_set_variable_statement() const {
4947  return (_has_bits_[0] & 0x00020000u) != 0;
4948 }
4949 inline void Statement::set_has_set_variable_statement() {
4950  _has_bits_[0] |= 0x00020000u;
4951 }
4952 inline void Statement::clear_has_set_variable_statement() {
4953  _has_bits_[0] &= ~0x00020000u;
4954 }
4955 inline void Statement::clear_set_variable_statement() {
4956  if (set_variable_statement_ != NULL) set_variable_statement_->::drizzled::message::SetVariableStatement::Clear();
4957  clear_has_set_variable_statement();
4958 }
4959 inline const ::drizzled::message::SetVariableStatement& Statement::set_variable_statement() const {
4960  return set_variable_statement_ != NULL ? *set_variable_statement_ : *default_instance_->set_variable_statement_;
4961 }
4962 inline ::drizzled::message::SetVariableStatement* Statement::mutable_set_variable_statement() {
4963  set_has_set_variable_statement();
4964  if (set_variable_statement_ == NULL) set_variable_statement_ = new ::drizzled::message::SetVariableStatement;
4965  return set_variable_statement_;
4966 }
4967 inline ::drizzled::message::SetVariableStatement* Statement::release_set_variable_statement() {
4968  clear_has_set_variable_statement();
4969  ::drizzled::message::SetVariableStatement* temp = set_variable_statement_;
4970  set_variable_statement_ = NULL;
4971  return temp;
4972 }
4973 inline void Statement::set_allocated_set_variable_statement(::drizzled::message::SetVariableStatement* set_variable_statement) {
4974  delete set_variable_statement_;
4975  set_variable_statement_ = set_variable_statement;
4976  if (set_variable_statement) {
4977  set_has_set_variable_statement();
4978  } else {
4979  clear_has_set_variable_statement();
4980  }
4981 }
4982 
4983 // optional string raw_sql_schema = 19;
4984 inline bool Statement::has_raw_sql_schema() const {
4985  return (_has_bits_[0] & 0x00040000u) != 0;
4986 }
4987 inline void Statement::set_has_raw_sql_schema() {
4988  _has_bits_[0] |= 0x00040000u;
4989 }
4990 inline void Statement::clear_has_raw_sql_schema() {
4991  _has_bits_[0] &= ~0x00040000u;
4992 }
4993 inline void Statement::clear_raw_sql_schema() {
4994  if (raw_sql_schema_ != &::google::protobuf::internal::kEmptyString) {
4995  raw_sql_schema_->clear();
4996  }
4997  clear_has_raw_sql_schema();
4998 }
4999 inline const ::std::string& Statement::raw_sql_schema() const {
5000  return *raw_sql_schema_;
5001 }
5002 inline void Statement::set_raw_sql_schema(const ::std::string& value) {
5003  set_has_raw_sql_schema();
5004  if (raw_sql_schema_ == &::google::protobuf::internal::kEmptyString) {
5005  raw_sql_schema_ = new ::std::string;
5006  }
5007  raw_sql_schema_->assign(value);
5008 }
5009 inline void Statement::set_raw_sql_schema(const char* value) {
5010  set_has_raw_sql_schema();
5011  if (raw_sql_schema_ == &::google::protobuf::internal::kEmptyString) {
5012  raw_sql_schema_ = new ::std::string;
5013  }
5014  raw_sql_schema_->assign(value);
5015 }
5016 inline void Statement::set_raw_sql_schema(const char* value, size_t size) {
5017  set_has_raw_sql_schema();
5018  if (raw_sql_schema_ == &::google::protobuf::internal::kEmptyString) {
5019  raw_sql_schema_ = new ::std::string;
5020  }
5021  raw_sql_schema_->assign(reinterpret_cast<const char*>(value), size);
5022 }
5023 inline ::std::string* Statement::mutable_raw_sql_schema() {
5024  set_has_raw_sql_schema();
5025  if (raw_sql_schema_ == &::google::protobuf::internal::kEmptyString) {
5026  raw_sql_schema_ = new ::std::string;
5027  }
5028  return raw_sql_schema_;
5029 }
5030 inline ::std::string* Statement::release_raw_sql_schema() {
5031  clear_has_raw_sql_schema();
5032  if (raw_sql_schema_ == &::google::protobuf::internal::kEmptyString) {
5033  return NULL;
5034  } else {
5035  ::std::string* temp = raw_sql_schema_;
5036  raw_sql_schema_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
5037  return temp;
5038  }
5039 }
5040 inline void Statement::set_allocated_raw_sql_schema(::std::string* raw_sql_schema) {
5041  if (raw_sql_schema_ != &::google::protobuf::internal::kEmptyString) {
5042  delete raw_sql_schema_;
5043  }
5044  if (raw_sql_schema) {
5045  set_has_raw_sql_schema();
5046  raw_sql_schema_ = raw_sql_schema;
5047  } else {
5048  clear_has_raw_sql_schema();
5049  raw_sql_schema_ = const_cast< ::std::string*>(&::google::protobuf::internal::kEmptyString);
5050  }
5051 }
5052 
5053 // -------------------------------------------------------------------
5054 
5055 // Transaction
5056 
5057 // required .drizzled.message.TransactionContext transaction_context = 1;
5058 inline bool Transaction::has_transaction_context() const {
5059  return (_has_bits_[0] & 0x00000001u) != 0;
5060 }
5061 inline void Transaction::set_has_transaction_context() {
5062  _has_bits_[0] |= 0x00000001u;
5063 }
5064 inline void Transaction::clear_has_transaction_context() {
5065  _has_bits_[0] &= ~0x00000001u;
5066 }
5067 inline void Transaction::clear_transaction_context() {
5068  if (transaction_context_ != NULL) transaction_context_->::drizzled::message::TransactionContext::Clear();
5069  clear_has_transaction_context();
5070 }
5071 inline const ::drizzled::message::TransactionContext& Transaction::transaction_context() const {
5072  return transaction_context_ != NULL ? *transaction_context_ : *default_instance_->transaction_context_;
5073 }
5074 inline ::drizzled::message::TransactionContext* Transaction::mutable_transaction_context() {
5075  set_has_transaction_context();
5076  if (transaction_context_ == NULL) transaction_context_ = new ::drizzled::message::TransactionContext;
5077  return transaction_context_;
5078 }
5079 inline ::drizzled::message::TransactionContext* Transaction::release_transaction_context() {
5080  clear_has_transaction_context();
5081  ::drizzled::message::TransactionContext* temp = transaction_context_;
5082  transaction_context_ = NULL;
5083  return temp;
5084 }
5085 inline void Transaction::set_allocated_transaction_context(::drizzled::message::TransactionContext* transaction_context) {
5086  delete transaction_context_;
5087  transaction_context_ = transaction_context;
5088  if (transaction_context) {
5089  set_has_transaction_context();
5090  } else {
5091  clear_has_transaction_context();
5092  }
5093 }
5094 
5095 // repeated .drizzled.message.Statement statement = 2;
5096 inline int Transaction::statement_size() const {
5097  return statement_.size();
5098 }
5099 inline void Transaction::clear_statement() {
5100  statement_.Clear();
5101 }
5102 inline const ::drizzled::message::Statement& Transaction::statement(int index) const {
5103  return statement_.Get(index);
5104 }
5105 inline ::drizzled::message::Statement* Transaction::mutable_statement(int index) {
5106  return statement_.Mutable(index);
5107 }
5108 inline ::drizzled::message::Statement* Transaction::add_statement() {
5109  return statement_.Add();
5110 }
5111 inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Statement >&
5112 Transaction::statement() const {
5113  return statement_;
5114 }
5115 inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Statement >*
5116 Transaction::mutable_statement() {
5117  return &statement_;
5118 }
5119 
5120 // optional .drizzled.message.Event event = 3;
5121 inline bool Transaction::has_event() const {
5122  return (_has_bits_[0] & 0x00000004u) != 0;
5123 }
5124 inline void Transaction::set_has_event() {
5125  _has_bits_[0] |= 0x00000004u;
5126 }
5127 inline void Transaction::clear_has_event() {
5128  _has_bits_[0] &= ~0x00000004u;
5129 }
5130 inline void Transaction::clear_event() {
5131  if (event_ != NULL) event_->::drizzled::message::Event::Clear();
5132  clear_has_event();
5133 }
5134 inline const ::drizzled::message::Event& Transaction::event() const {
5135  return event_ != NULL ? *event_ : *default_instance_->event_;
5136 }
5137 inline ::drizzled::message::Event* Transaction::mutable_event() {
5138  set_has_event();
5139  if (event_ == NULL) event_ = new ::drizzled::message::Event;
5140  return event_;
5141 }
5142 inline ::drizzled::message::Event* Transaction::release_event() {
5143  clear_has_event();
5144  ::drizzled::message::Event* temp = event_;
5145  event_ = NULL;
5146  return temp;
5147 }
5148 inline void Transaction::set_allocated_event(::drizzled::message::Event* event) {
5149  delete event_;
5150  event_ = event;
5151  if (event) {
5152  set_has_event();
5153  } else {
5154  clear_has_event();
5155  }
5156 }
5157 
5158 // optional uint32 segment_id = 4;
5159 inline bool Transaction::has_segment_id() const {
5160  return (_has_bits_[0] & 0x00000008u) != 0;
5161 }
5162 inline void Transaction::set_has_segment_id() {
5163  _has_bits_[0] |= 0x00000008u;
5164 }
5165 inline void Transaction::clear_has_segment_id() {
5166  _has_bits_[0] &= ~0x00000008u;
5167 }
5168 inline void Transaction::clear_segment_id() {
5169  segment_id_ = 0u;
5170  clear_has_segment_id();
5171 }
5172 inline ::google::protobuf::uint32 Transaction::segment_id() const {
5173  return segment_id_;
5174 }
5175 inline void Transaction::set_segment_id(::google::protobuf::uint32 value) {
5176  set_has_segment_id();
5177  segment_id_ = value;
5178 }
5179 
5180 // optional bool end_segment = 5;
5181 inline bool Transaction::has_end_segment() const {
5182  return (_has_bits_[0] & 0x00000010u) != 0;
5183 }
5184 inline void Transaction::set_has_end_segment() {
5185  _has_bits_[0] |= 0x00000010u;
5186 }
5187 inline void Transaction::clear_has_end_segment() {
5188  _has_bits_[0] &= ~0x00000010u;
5189 }
5190 inline void Transaction::clear_end_segment() {
5191  end_segment_ = false;
5192  clear_has_end_segment();
5193 }
5194 inline bool Transaction::end_segment() const {
5195  return end_segment_;
5196 }
5197 inline void Transaction::set_end_segment(bool value) {
5198  set_has_end_segment();
5199  end_segment_ = value;
5200 }
5201 
5202 
5203 // @@protoc_insertion_point(namespace_scope)
5204 
5205 } // namespace message
5206 } // namespace drizzled
5207 
5208 #ifndef SWIG
5209 namespace google {
5210 namespace protobuf {
5211 
5212 template <>
5213 inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Statement_Type>() {
5214  return ::drizzled::message::Statement_Type_descriptor();
5215 }
5216 
5217 } // namespace google
5218 } // namespace protobuf
5219 #endif // SWIG
5220 
5221 // @@protoc_insertion_point(global_scope)
5222 
5223 #endif // PROTOBUF_transaction_2eproto__INCLUDED