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