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