// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: transaction.proto

#ifndef PROTOBUF_transaction_2eproto__INCLUDED
#define PROTOBUF_transaction_2eproto__INCLUDED

#include <string>

#include <google/protobuf/stubs/common.h>

#if GOOGLE_PROTOBUF_VERSION < 2003000
#error This file was generated by a newer version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please update
#error your headers.
#endif
#if 2003000 < GOOGLE_PROTOBUF_MIN_PROTOC_VERSION
#error This file was generated by an older version of protoc which is
#error incompatible with your Protocol Buffer headers.  Please
#error regenerate this file with a newer version of protoc.
#endif

#include <google/protobuf/generated_message_util.h>
#include <google/protobuf/repeated_field.h>
#include <google/protobuf/extension_set.h>
#include <google/protobuf/generated_message_reflection.h>
#include "table.pb.h"
#include "schema.pb.h"
// @@protoc_insertion_point(includes)

namespace drizzled {
namespace message {

// Internal implementation detail -- do not call these.
void  protobuf_AddDesc_transaction_2eproto();
void protobuf_AssignDesc_transaction_2eproto();
void protobuf_ShutdownFile_transaction_2eproto();

class FieldMetadata;
class TableMetadata;
class TransactionContext;
class InsertRecord;
class InsertHeader;
class InsertData;
class UpdateRecord;
class UpdateHeader;
class UpdateData;
class DeleteRecord;
class DeleteHeader;
class DeleteData;
class TruncateTableStatement;
class CreateSchemaStatement;
class AlterSchemaStatement;
class DropSchemaStatement;
class CreateTableStatement;
class AlterTableStatement;
class DropTableStatement;
class SetVariableStatement;
class Statement;
class Transaction;

enum Statement_Type {
  Statement_Type_ROLLBACK = 0,
  Statement_Type_INSERT = 1,
  Statement_Type_DELETE = 2,
  Statement_Type_UPDATE = 3,
  Statement_Type_TRUNCATE_TABLE = 4,
  Statement_Type_CREATE_SCHEMA = 5,
  Statement_Type_ALTER_SCHEMA = 6,
  Statement_Type_DROP_SCHEMA = 7,
  Statement_Type_CREATE_TABLE = 8,
  Statement_Type_ALTER_TABLE = 9,
  Statement_Type_DROP_TABLE = 10,
  Statement_Type_SET_VARIABLE = 98,
  Statement_Type_RAW_SQL = 99
};
bool Statement_Type_IsValid(int value);
const Statement_Type Statement_Type_Type_MIN = Statement_Type_ROLLBACK;
const Statement_Type Statement_Type_Type_MAX = Statement_Type_RAW_SQL;
const int Statement_Type_Type_ARRAYSIZE = Statement_Type_Type_MAX + 1;

const ::google::protobuf::EnumDescriptor* Statement_Type_descriptor();
inline const ::std::string& Statement_Type_Name(Statement_Type value) {
  return ::google::protobuf::internal::NameOfEnum(
    Statement_Type_descriptor(), value);
}
inline bool Statement_Type_Parse(
    const ::std::string& name, Statement_Type* value) {
  return ::google::protobuf::internal::ParseNamedEnum<Statement_Type>(
    Statement_Type_descriptor(), name, value);
}
// ===================================================================

class FieldMetadata : public ::google::protobuf::Message {
 public:
  FieldMetadata();
  virtual ~FieldMetadata();
  
  FieldMetadata(const FieldMetadata& from);
  
  inline FieldMetadata& operator=(const FieldMetadata& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const FieldMetadata& default_instance();
  
  void Swap(FieldMetadata* other);
  
  // implements Message ----------------------------------------------
  
  FieldMetadata* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const FieldMetadata& from);
  void MergeFrom(const FieldMetadata& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .drizzled.message.Table.Field.FieldType type = 1;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 1;
  inline ::drizzled::message::Table_Field_FieldType type() const;
  inline void set_type(::drizzled::message::Table_Field_FieldType value);
  
  // required string name = 2;
  inline bool has_name() const;
  inline void clear_name();
  static const int kNameFieldNumber = 2;
  inline const ::std::string& name() const;
  inline void set_name(const ::std::string& value);
  inline void set_name(const char* value);
  inline void set_name(const char* value, size_t size);
  inline ::std::string* mutable_name();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.FieldMetadata)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  int type_;
  ::std::string* name_;
  static const ::std::string _default_name_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static FieldMetadata* default_instance_;
};
// -------------------------------------------------------------------

class TableMetadata : public ::google::protobuf::Message {
 public:
  TableMetadata();
  virtual ~TableMetadata();
  
  TableMetadata(const TableMetadata& from);
  
  inline TableMetadata& operator=(const TableMetadata& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const TableMetadata& default_instance();
  
  void Swap(TableMetadata* other);
  
  // implements Message ----------------------------------------------
  
  TableMetadata* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TableMetadata& from);
  void MergeFrom(const TableMetadata& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required string schema_name = 1;
  inline bool has_schema_name() const;
  inline void clear_schema_name();
  static const int kSchemaNameFieldNumber = 1;
  inline const ::std::string& schema_name() const;
  inline void set_schema_name(const ::std::string& value);
  inline void set_schema_name(const char* value);
  inline void set_schema_name(const char* value, size_t size);
  inline ::std::string* mutable_schema_name();
  
  // required string table_name = 2;
  inline bool has_table_name() const;
  inline void clear_table_name();
  static const int kTableNameFieldNumber = 2;
  inline const ::std::string& table_name() const;
  inline void set_table_name(const ::std::string& value);
  inline void set_table_name(const char* value);
  inline void set_table_name(const char* value, size_t size);
  inline ::std::string* mutable_table_name();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.TableMetadata)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* schema_name_;
  static const ::std::string _default_schema_name_;
  ::std::string* table_name_;
  static const ::std::string _default_table_name_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static TableMetadata* default_instance_;
};
// -------------------------------------------------------------------

class TransactionContext : public ::google::protobuf::Message {
 public:
  TransactionContext();
  virtual ~TransactionContext();
  
  TransactionContext(const TransactionContext& from);
  
  inline TransactionContext& operator=(const TransactionContext& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const TransactionContext& default_instance();
  
  void Swap(TransactionContext* other);
  
  // implements Message ----------------------------------------------
  
  TransactionContext* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TransactionContext& from);
  void MergeFrom(const TransactionContext& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required uint32 server_id = 1;
  inline bool has_server_id() const;
  inline void clear_server_id();
  static const int kServerIdFieldNumber = 1;
  inline ::google::protobuf::uint32 server_id() const;
  inline void set_server_id(::google::protobuf::uint32 value);
  
  // required uint64 transaction_id = 2;
  inline bool has_transaction_id() const;
  inline void clear_transaction_id();
  static const int kTransactionIdFieldNumber = 2;
  inline ::google::protobuf::uint64 transaction_id() const;
  inline void set_transaction_id(::google::protobuf::uint64 value);
  
  // required uint64 start_timestamp = 3;
  inline bool has_start_timestamp() const;
  inline void clear_start_timestamp();
  static const int kStartTimestampFieldNumber = 3;
  inline ::google::protobuf::uint64 start_timestamp() const;
  inline void set_start_timestamp(::google::protobuf::uint64 value);
  
  // required uint64 end_timestamp = 4;
  inline bool has_end_timestamp() const;
  inline void clear_end_timestamp();
  static const int kEndTimestampFieldNumber = 4;
  inline ::google::protobuf::uint64 end_timestamp() const;
  inline void set_end_timestamp(::google::protobuf::uint64 value);
  
  // @@protoc_insertion_point(class_scope:drizzled.message.TransactionContext)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::google::protobuf::uint32 server_id_;
  ::google::protobuf::uint64 transaction_id_;
  ::google::protobuf::uint64 start_timestamp_;
  ::google::protobuf::uint64 end_timestamp_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(4 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static TransactionContext* default_instance_;
};
// -------------------------------------------------------------------

class InsertRecord : public ::google::protobuf::Message {
 public:
  InsertRecord();
  virtual ~InsertRecord();
  
  InsertRecord(const InsertRecord& from);
  
  inline InsertRecord& operator=(const InsertRecord& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const InsertRecord& default_instance();
  
  void Swap(InsertRecord* other);
  
  // implements Message ----------------------------------------------
  
  InsertRecord* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const InsertRecord& from);
  void MergeFrom(const InsertRecord& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated bytes insert_value = 1;
  inline int insert_value_size() const;
  inline void clear_insert_value();
  static const int kInsertValueFieldNumber = 1;
  inline const ::std::string& insert_value(int index) const;
  inline ::std::string* mutable_insert_value(int index);
  inline void set_insert_value(int index, const ::std::string& value);
  inline void set_insert_value(int index, const char* value);
  inline void set_insert_value(int index, const void* value, size_t size);
  inline ::std::string* add_insert_value();
  inline void add_insert_value(const ::std::string& value);
  inline void add_insert_value(const char* value);
  inline void add_insert_value(const void* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& insert_value() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_insert_value();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.InsertRecord)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::google::protobuf::RepeatedPtrField< ::std::string> insert_value_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static InsertRecord* default_instance_;
};
// -------------------------------------------------------------------

class InsertHeader : public ::google::protobuf::Message {
 public:
  InsertHeader();
  virtual ~InsertHeader();
  
  InsertHeader(const InsertHeader& from);
  
  inline InsertHeader& operator=(const InsertHeader& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const InsertHeader& default_instance();
  
  void Swap(InsertHeader* other);
  
  // implements Message ----------------------------------------------
  
  InsertHeader* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const InsertHeader& from);
  void MergeFrom(const InsertHeader& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .drizzled.message.TableMetadata table_metadata = 1;
  inline bool has_table_metadata() const;
  inline void clear_table_metadata();
  static const int kTableMetadataFieldNumber = 1;
  inline const ::drizzled::message::TableMetadata& table_metadata() const;
  inline ::drizzled::message::TableMetadata* mutable_table_metadata();
  
  // repeated .drizzled.message.FieldMetadata field_metadata = 2;
  inline int field_metadata_size() const;
  inline void clear_field_metadata();
  static const int kFieldMetadataFieldNumber = 2;
  inline const ::drizzled::message::FieldMetadata& field_metadata(int index) const;
  inline ::drizzled::message::FieldMetadata* mutable_field_metadata(int index);
  inline ::drizzled::message::FieldMetadata* add_field_metadata();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
      field_metadata() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
      mutable_field_metadata();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.InsertHeader)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::drizzled::message::TableMetadata* table_metadata_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata > field_metadata_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static InsertHeader* default_instance_;
};
// -------------------------------------------------------------------

class InsertData : public ::google::protobuf::Message {
 public:
  InsertData();
  virtual ~InsertData();
  
  InsertData(const InsertData& from);
  
  inline InsertData& operator=(const InsertData& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const InsertData& default_instance();
  
  void Swap(InsertData* other);
  
  // implements Message ----------------------------------------------
  
  InsertData* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const InsertData& from);
  void MergeFrom(const InsertData& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required uint32 segment_id = 1;
  inline bool has_segment_id() const;
  inline void clear_segment_id();
  static const int kSegmentIdFieldNumber = 1;
  inline ::google::protobuf::uint32 segment_id() const;
  inline void set_segment_id(::google::protobuf::uint32 value);
  
  // required bool end_segment = 2;
  inline bool has_end_segment() const;
  inline void clear_end_segment();
  static const int kEndSegmentFieldNumber = 2;
  inline bool end_segment() const;
  inline void set_end_segment(bool value);
  
  // repeated .drizzled.message.InsertRecord record = 3;
  inline int record_size() const;
  inline void clear_record();
  static const int kRecordFieldNumber = 3;
  inline const ::drizzled::message::InsertRecord& record(int index) const;
  inline ::drizzled::message::InsertRecord* mutable_record(int index);
  inline ::drizzled::message::InsertRecord* add_record();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::InsertRecord >&
      record() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::InsertRecord >*
      mutable_record();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.InsertData)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::google::protobuf::uint32 segment_id_;
  bool end_segment_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::InsertRecord > record_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static InsertData* default_instance_;
};
// -------------------------------------------------------------------

class UpdateRecord : public ::google::protobuf::Message {
 public:
  UpdateRecord();
  virtual ~UpdateRecord();
  
  UpdateRecord(const UpdateRecord& from);
  
  inline UpdateRecord& operator=(const UpdateRecord& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const UpdateRecord& default_instance();
  
  void Swap(UpdateRecord* other);
  
  // implements Message ----------------------------------------------
  
  UpdateRecord* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const UpdateRecord& from);
  void MergeFrom(const UpdateRecord& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated bytes key_value = 1;
  inline int key_value_size() const;
  inline void clear_key_value();
  static const int kKeyValueFieldNumber = 1;
  inline const ::std::string& key_value(int index) const;
  inline ::std::string* mutable_key_value(int index);
  inline void set_key_value(int index, const ::std::string& value);
  inline void set_key_value(int index, const char* value);
  inline void set_key_value(int index, const void* value, size_t size);
  inline ::std::string* add_key_value();
  inline void add_key_value(const ::std::string& value);
  inline void add_key_value(const char* value);
  inline void add_key_value(const void* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& key_value() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_key_value();
  
  // repeated bytes after_value = 2;
  inline int after_value_size() const;
  inline void clear_after_value();
  static const int kAfterValueFieldNumber = 2;
  inline const ::std::string& after_value(int index) const;
  inline ::std::string* mutable_after_value(int index);
  inline void set_after_value(int index, const ::std::string& value);
  inline void set_after_value(int index, const char* value);
  inline void set_after_value(int index, const void* value, size_t size);
  inline ::std::string* add_after_value();
  inline void add_after_value(const ::std::string& value);
  inline void add_after_value(const char* value);
  inline void add_after_value(const void* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& after_value() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_after_value();
  
  // repeated bytes before_value = 3;
  inline int before_value_size() const;
  inline void clear_before_value();
  static const int kBeforeValueFieldNumber = 3;
  inline const ::std::string& before_value(int index) const;
  inline ::std::string* mutable_before_value(int index);
  inline void set_before_value(int index, const ::std::string& value);
  inline void set_before_value(int index, const char* value);
  inline void set_before_value(int index, const void* value, size_t size);
  inline ::std::string* add_before_value();
  inline void add_before_value(const ::std::string& value);
  inline void add_before_value(const char* value);
  inline void add_before_value(const void* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& before_value() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_before_value();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.UpdateRecord)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::google::protobuf::RepeatedPtrField< ::std::string> key_value_;
  ::google::protobuf::RepeatedPtrField< ::std::string> after_value_;
  ::google::protobuf::RepeatedPtrField< ::std::string> before_value_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static UpdateRecord* default_instance_;
};
// -------------------------------------------------------------------

class UpdateHeader : public ::google::protobuf::Message {
 public:
  UpdateHeader();
  virtual ~UpdateHeader();
  
  UpdateHeader(const UpdateHeader& from);
  
  inline UpdateHeader& operator=(const UpdateHeader& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const UpdateHeader& default_instance();
  
  void Swap(UpdateHeader* other);
  
  // implements Message ----------------------------------------------
  
  UpdateHeader* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const UpdateHeader& from);
  void MergeFrom(const UpdateHeader& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .drizzled.message.TableMetadata table_metadata = 1;
  inline bool has_table_metadata() const;
  inline void clear_table_metadata();
  static const int kTableMetadataFieldNumber = 1;
  inline const ::drizzled::message::TableMetadata& table_metadata() const;
  inline ::drizzled::message::TableMetadata* mutable_table_metadata();
  
  // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
  inline int key_field_metadata_size() const;
  inline void clear_key_field_metadata();
  static const int kKeyFieldMetadataFieldNumber = 2;
  inline const ::drizzled::message::FieldMetadata& key_field_metadata(int index) const;
  inline ::drizzled::message::FieldMetadata* mutable_key_field_metadata(int index);
  inline ::drizzled::message::FieldMetadata* add_key_field_metadata();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
      key_field_metadata() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
      mutable_key_field_metadata();
  
  // repeated .drizzled.message.FieldMetadata set_field_metadata = 3;
  inline int set_field_metadata_size() const;
  inline void clear_set_field_metadata();
  static const int kSetFieldMetadataFieldNumber = 3;
  inline const ::drizzled::message::FieldMetadata& set_field_metadata(int index) const;
  inline ::drizzled::message::FieldMetadata* mutable_set_field_metadata(int index);
  inline ::drizzled::message::FieldMetadata* add_set_field_metadata();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
      set_field_metadata() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
      mutable_set_field_metadata();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.UpdateHeader)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::drizzled::message::TableMetadata* table_metadata_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata > key_field_metadata_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata > set_field_metadata_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static UpdateHeader* default_instance_;
};
// -------------------------------------------------------------------

class UpdateData : public ::google::protobuf::Message {
 public:
  UpdateData();
  virtual ~UpdateData();
  
  UpdateData(const UpdateData& from);
  
  inline UpdateData& operator=(const UpdateData& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const UpdateData& default_instance();
  
  void Swap(UpdateData* other);
  
  // implements Message ----------------------------------------------
  
  UpdateData* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const UpdateData& from);
  void MergeFrom(const UpdateData& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required uint32 segment_id = 1;
  inline bool has_segment_id() const;
  inline void clear_segment_id();
  static const int kSegmentIdFieldNumber = 1;
  inline ::google::protobuf::uint32 segment_id() const;
  inline void set_segment_id(::google::protobuf::uint32 value);
  
  // required bool end_segment = 2;
  inline bool has_end_segment() const;
  inline void clear_end_segment();
  static const int kEndSegmentFieldNumber = 2;
  inline bool end_segment() const;
  inline void set_end_segment(bool value);
  
  // repeated .drizzled.message.UpdateRecord record = 3;
  inline int record_size() const;
  inline void clear_record();
  static const int kRecordFieldNumber = 3;
  inline const ::drizzled::message::UpdateRecord& record(int index) const;
  inline ::drizzled::message::UpdateRecord* mutable_record(int index);
  inline ::drizzled::message::UpdateRecord* add_record();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::UpdateRecord >&
      record() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::UpdateRecord >*
      mutable_record();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.UpdateData)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::google::protobuf::uint32 segment_id_;
  bool end_segment_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::UpdateRecord > record_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static UpdateData* default_instance_;
};
// -------------------------------------------------------------------

class DeleteRecord : public ::google::protobuf::Message {
 public:
  DeleteRecord();
  virtual ~DeleteRecord();
  
  DeleteRecord(const DeleteRecord& from);
  
  inline DeleteRecord& operator=(const DeleteRecord& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const DeleteRecord& default_instance();
  
  void Swap(DeleteRecord* other);
  
  // implements Message ----------------------------------------------
  
  DeleteRecord* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DeleteRecord& from);
  void MergeFrom(const DeleteRecord& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // repeated bytes key_value = 1;
  inline int key_value_size() const;
  inline void clear_key_value();
  static const int kKeyValueFieldNumber = 1;
  inline const ::std::string& key_value(int index) const;
  inline ::std::string* mutable_key_value(int index);
  inline void set_key_value(int index, const ::std::string& value);
  inline void set_key_value(int index, const char* value);
  inline void set_key_value(int index, const void* value, size_t size);
  inline ::std::string* add_key_value();
  inline void add_key_value(const ::std::string& value);
  inline void add_key_value(const char* value);
  inline void add_key_value(const void* value, size_t size);
  inline const ::google::protobuf::RepeatedPtrField< ::std::string>& key_value() const;
  inline ::google::protobuf::RepeatedPtrField< ::std::string>* mutable_key_value();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.DeleteRecord)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::google::protobuf::RepeatedPtrField< ::std::string> key_value_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static DeleteRecord* default_instance_;
};
// -------------------------------------------------------------------

class DeleteHeader : public ::google::protobuf::Message {
 public:
  DeleteHeader();
  virtual ~DeleteHeader();
  
  DeleteHeader(const DeleteHeader& from);
  
  inline DeleteHeader& operator=(const DeleteHeader& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const DeleteHeader& default_instance();
  
  void Swap(DeleteHeader* other);
  
  // implements Message ----------------------------------------------
  
  DeleteHeader* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DeleteHeader& from);
  void MergeFrom(const DeleteHeader& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .drizzled.message.TableMetadata table_metadata = 1;
  inline bool has_table_metadata() const;
  inline void clear_table_metadata();
  static const int kTableMetadataFieldNumber = 1;
  inline const ::drizzled::message::TableMetadata& table_metadata() const;
  inline ::drizzled::message::TableMetadata* mutable_table_metadata();
  
  // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
  inline int key_field_metadata_size() const;
  inline void clear_key_field_metadata();
  static const int kKeyFieldMetadataFieldNumber = 2;
  inline const ::drizzled::message::FieldMetadata& key_field_metadata(int index) const;
  inline ::drizzled::message::FieldMetadata* mutable_key_field_metadata(int index);
  inline ::drizzled::message::FieldMetadata* add_key_field_metadata();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
      key_field_metadata() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
      mutable_key_field_metadata();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.DeleteHeader)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::drizzled::message::TableMetadata* table_metadata_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata > key_field_metadata_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static DeleteHeader* default_instance_;
};
// -------------------------------------------------------------------

class DeleteData : public ::google::protobuf::Message {
 public:
  DeleteData();
  virtual ~DeleteData();
  
  DeleteData(const DeleteData& from);
  
  inline DeleteData& operator=(const DeleteData& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const DeleteData& default_instance();
  
  void Swap(DeleteData* other);
  
  // implements Message ----------------------------------------------
  
  DeleteData* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DeleteData& from);
  void MergeFrom(const DeleteData& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required uint32 segment_id = 1;
  inline bool has_segment_id() const;
  inline void clear_segment_id();
  static const int kSegmentIdFieldNumber = 1;
  inline ::google::protobuf::uint32 segment_id() const;
  inline void set_segment_id(::google::protobuf::uint32 value);
  
  // required bool end_segment = 2;
  inline bool has_end_segment() const;
  inline void clear_end_segment();
  static const int kEndSegmentFieldNumber = 2;
  inline bool end_segment() const;
  inline void set_end_segment(bool value);
  
  // repeated .drizzled.message.DeleteRecord record = 3;
  inline int record_size() const;
  inline void clear_record();
  static const int kRecordFieldNumber = 3;
  inline const ::drizzled::message::DeleteRecord& record(int index) const;
  inline ::drizzled::message::DeleteRecord* mutable_record(int index);
  inline ::drizzled::message::DeleteRecord* add_record();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::DeleteRecord >&
      record() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::DeleteRecord >*
      mutable_record();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.DeleteData)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::google::protobuf::uint32 segment_id_;
  bool end_segment_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::DeleteRecord > record_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(3 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static DeleteData* default_instance_;
};
// -------------------------------------------------------------------

class TruncateTableStatement : public ::google::protobuf::Message {
 public:
  TruncateTableStatement();
  virtual ~TruncateTableStatement();
  
  TruncateTableStatement(const TruncateTableStatement& from);
  
  inline TruncateTableStatement& operator=(const TruncateTableStatement& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const TruncateTableStatement& default_instance();
  
  void Swap(TruncateTableStatement* other);
  
  // implements Message ----------------------------------------------
  
  TruncateTableStatement* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const TruncateTableStatement& from);
  void MergeFrom(const TruncateTableStatement& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .drizzled.message.TableMetadata table_metadata = 1;
  inline bool has_table_metadata() const;
  inline void clear_table_metadata();
  static const int kTableMetadataFieldNumber = 1;
  inline const ::drizzled::message::TableMetadata& table_metadata() const;
  inline ::drizzled::message::TableMetadata* mutable_table_metadata();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.TruncateTableStatement)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::drizzled::message::TableMetadata* table_metadata_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static TruncateTableStatement* default_instance_;
};
// -------------------------------------------------------------------

class CreateSchemaStatement : public ::google::protobuf::Message {
 public:
  CreateSchemaStatement();
  virtual ~CreateSchemaStatement();
  
  CreateSchemaStatement(const CreateSchemaStatement& from);
  
  inline CreateSchemaStatement& operator=(const CreateSchemaStatement& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CreateSchemaStatement& default_instance();
  
  void Swap(CreateSchemaStatement* other);
  
  // implements Message ----------------------------------------------
  
  CreateSchemaStatement* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CreateSchemaStatement& from);
  void MergeFrom(const CreateSchemaStatement& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .drizzled.message.Schema schema = 1;
  inline bool has_schema() const;
  inline void clear_schema();
  static const int kSchemaFieldNumber = 1;
  inline const ::drizzled::message::Schema& schema() const;
  inline ::drizzled::message::Schema* mutable_schema();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.CreateSchemaStatement)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::drizzled::message::Schema* schema_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static CreateSchemaStatement* default_instance_;
};
// -------------------------------------------------------------------

class AlterSchemaStatement : public ::google::protobuf::Message {
 public:
  AlterSchemaStatement();
  virtual ~AlterSchemaStatement();
  
  AlterSchemaStatement(const AlterSchemaStatement& from);
  
  inline AlterSchemaStatement& operator=(const AlterSchemaStatement& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const AlterSchemaStatement& default_instance();
  
  void Swap(AlterSchemaStatement* other);
  
  // implements Message ----------------------------------------------
  
  AlterSchemaStatement* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const AlterSchemaStatement& from);
  void MergeFrom(const AlterSchemaStatement& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .drizzled.message.Schema before = 1;
  inline bool has_before() const;
  inline void clear_before();
  static const int kBeforeFieldNumber = 1;
  inline const ::drizzled::message::Schema& before() const;
  inline ::drizzled::message::Schema* mutable_before();
  
  // required .drizzled.message.Schema after = 2;
  inline bool has_after() const;
  inline void clear_after();
  static const int kAfterFieldNumber = 2;
  inline const ::drizzled::message::Schema& after() const;
  inline ::drizzled::message::Schema* mutable_after();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.AlterSchemaStatement)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::drizzled::message::Schema* before_;
  ::drizzled::message::Schema* after_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static AlterSchemaStatement* default_instance_;
};
// -------------------------------------------------------------------

class DropSchemaStatement : public ::google::protobuf::Message {
 public:
  DropSchemaStatement();
  virtual ~DropSchemaStatement();
  
  DropSchemaStatement(const DropSchemaStatement& from);
  
  inline DropSchemaStatement& operator=(const DropSchemaStatement& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const DropSchemaStatement& default_instance();
  
  void Swap(DropSchemaStatement* other);
  
  // implements Message ----------------------------------------------
  
  DropSchemaStatement* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DropSchemaStatement& from);
  void MergeFrom(const DropSchemaStatement& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required string schema_name = 1;
  inline bool has_schema_name() const;
  inline void clear_schema_name();
  static const int kSchemaNameFieldNumber = 1;
  inline const ::std::string& schema_name() const;
  inline void set_schema_name(const ::std::string& value);
  inline void set_schema_name(const char* value);
  inline void set_schema_name(const char* value, size_t size);
  inline ::std::string* mutable_schema_name();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.DropSchemaStatement)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::std::string* schema_name_;
  static const ::std::string _default_schema_name_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static DropSchemaStatement* default_instance_;
};
// -------------------------------------------------------------------

class CreateTableStatement : public ::google::protobuf::Message {
 public:
  CreateTableStatement();
  virtual ~CreateTableStatement();
  
  CreateTableStatement(const CreateTableStatement& from);
  
  inline CreateTableStatement& operator=(const CreateTableStatement& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const CreateTableStatement& default_instance();
  
  void Swap(CreateTableStatement* other);
  
  // implements Message ----------------------------------------------
  
  CreateTableStatement* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const CreateTableStatement& from);
  void MergeFrom(const CreateTableStatement& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .drizzled.message.Table table = 1;
  inline bool has_table() const;
  inline void clear_table();
  static const int kTableFieldNumber = 1;
  inline const ::drizzled::message::Table& table() const;
  inline ::drizzled::message::Table* mutable_table();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.CreateTableStatement)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::drizzled::message::Table* table_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(1 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static CreateTableStatement* default_instance_;
};
// -------------------------------------------------------------------

class AlterTableStatement : public ::google::protobuf::Message {
 public:
  AlterTableStatement();
  virtual ~AlterTableStatement();
  
  AlterTableStatement(const AlterTableStatement& from);
  
  inline AlterTableStatement& operator=(const AlterTableStatement& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const AlterTableStatement& default_instance();
  
  void Swap(AlterTableStatement* other);
  
  // implements Message ----------------------------------------------
  
  AlterTableStatement* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const AlterTableStatement& from);
  void MergeFrom(const AlterTableStatement& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .drizzled.message.Table before = 1;
  inline bool has_before() const;
  inline void clear_before();
  static const int kBeforeFieldNumber = 1;
  inline const ::drizzled::message::Table& before() const;
  inline ::drizzled::message::Table* mutable_before();
  
  // required .drizzled.message.Table after = 2;
  inline bool has_after() const;
  inline void clear_after();
  static const int kAfterFieldNumber = 2;
  inline const ::drizzled::message::Table& after() const;
  inline ::drizzled::message::Table* mutable_after();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.AlterTableStatement)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::drizzled::message::Table* before_;
  ::drizzled::message::Table* after_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static AlterTableStatement* default_instance_;
};
// -------------------------------------------------------------------

class DropTableStatement : public ::google::protobuf::Message {
 public:
  DropTableStatement();
  virtual ~DropTableStatement();
  
  DropTableStatement(const DropTableStatement& from);
  
  inline DropTableStatement& operator=(const DropTableStatement& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const DropTableStatement& default_instance();
  
  void Swap(DropTableStatement* other);
  
  // implements Message ----------------------------------------------
  
  DropTableStatement* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const DropTableStatement& from);
  void MergeFrom(const DropTableStatement& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .drizzled.message.TableMetadata table_metadata = 1;
  inline bool has_table_metadata() const;
  inline void clear_table_metadata();
  static const int kTableMetadataFieldNumber = 1;
  inline const ::drizzled::message::TableMetadata& table_metadata() const;
  inline ::drizzled::message::TableMetadata* mutable_table_metadata();
  
  // optional bool if_exists_clause = 2;
  inline bool has_if_exists_clause() const;
  inline void clear_if_exists_clause();
  static const int kIfExistsClauseFieldNumber = 2;
  inline bool if_exists_clause() const;
  inline void set_if_exists_clause(bool value);
  
  // @@protoc_insertion_point(class_scope:drizzled.message.DropTableStatement)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::drizzled::message::TableMetadata* table_metadata_;
  bool if_exists_clause_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static DropTableStatement* default_instance_;
};
// -------------------------------------------------------------------

class SetVariableStatement : public ::google::protobuf::Message {
 public:
  SetVariableStatement();
  virtual ~SetVariableStatement();
  
  SetVariableStatement(const SetVariableStatement& from);
  
  inline SetVariableStatement& operator=(const SetVariableStatement& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const SetVariableStatement& default_instance();
  
  void Swap(SetVariableStatement* other);
  
  // implements Message ----------------------------------------------
  
  SetVariableStatement* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const SetVariableStatement& from);
  void MergeFrom(const SetVariableStatement& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .drizzled.message.FieldMetadata variable_metadata = 1;
  inline bool has_variable_metadata() const;
  inline void clear_variable_metadata();
  static const int kVariableMetadataFieldNumber = 1;
  inline const ::drizzled::message::FieldMetadata& variable_metadata() const;
  inline ::drizzled::message::FieldMetadata* mutable_variable_metadata();
  
  // required bytes variable_value = 2;
  inline bool has_variable_value() const;
  inline void clear_variable_value();
  static const int kVariableValueFieldNumber = 2;
  inline const ::std::string& variable_value() const;
  inline void set_variable_value(const ::std::string& value);
  inline void set_variable_value(const char* value);
  inline void set_variable_value(const void* value, size_t size);
  inline ::std::string* mutable_variable_value();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.SetVariableStatement)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::drizzled::message::FieldMetadata* variable_metadata_;
  ::std::string* variable_value_;
  static const ::std::string _default_variable_value_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static SetVariableStatement* default_instance_;
};
// -------------------------------------------------------------------

class Statement : public ::google::protobuf::Message {
 public:
  Statement();
  virtual ~Statement();
  
  Statement(const Statement& from);
  
  inline Statement& operator=(const Statement& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Statement& default_instance();
  
  void Swap(Statement* other);
  
  // implements Message ----------------------------------------------
  
  Statement* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Statement& from);
  void MergeFrom(const Statement& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  typedef Statement_Type Type;
  static const Type ROLLBACK = Statement_Type_ROLLBACK;
  static const Type INSERT = Statement_Type_INSERT;
  static const Type DELETE = Statement_Type_DELETE;
  static const Type UPDATE = Statement_Type_UPDATE;
  static const Type TRUNCATE_TABLE = Statement_Type_TRUNCATE_TABLE;
  static const Type CREATE_SCHEMA = Statement_Type_CREATE_SCHEMA;
  static const Type ALTER_SCHEMA = Statement_Type_ALTER_SCHEMA;
  static const Type DROP_SCHEMA = Statement_Type_DROP_SCHEMA;
  static const Type CREATE_TABLE = Statement_Type_CREATE_TABLE;
  static const Type ALTER_TABLE = Statement_Type_ALTER_TABLE;
  static const Type DROP_TABLE = Statement_Type_DROP_TABLE;
  static const Type SET_VARIABLE = Statement_Type_SET_VARIABLE;
  static const Type RAW_SQL = Statement_Type_RAW_SQL;
  static inline bool Type_IsValid(int value) {
    return Statement_Type_IsValid(value);
  }
  static const Type Type_MIN =
    Statement_Type_Type_MIN;
  static const Type Type_MAX =
    Statement_Type_Type_MAX;
  static const int Type_ARRAYSIZE =
    Statement_Type_Type_ARRAYSIZE;
  static inline const ::google::protobuf::EnumDescriptor*
  Type_descriptor() {
    return Statement_Type_descriptor();
  }
  static inline const ::std::string& Type_Name(Type value) {
    return Statement_Type_Name(value);
  }
  static inline bool Type_Parse(const ::std::string& name,
      Type* value) {
    return Statement_Type_Parse(name, value);
  }
  
  // accessors -------------------------------------------------------
  
  // required .drizzled.message.Statement.Type type = 1;
  inline bool has_type() const;
  inline void clear_type();
  static const int kTypeFieldNumber = 1;
  inline ::drizzled::message::Statement_Type type() const;
  inline void set_type(::drizzled::message::Statement_Type value);
  
  // required uint64 start_timestamp = 2;
  inline bool has_start_timestamp() const;
  inline void clear_start_timestamp();
  static const int kStartTimestampFieldNumber = 2;
  inline ::google::protobuf::uint64 start_timestamp() const;
  inline void set_start_timestamp(::google::protobuf::uint64 value);
  
  // required uint64 end_timestamp = 3;
  inline bool has_end_timestamp() const;
  inline void clear_end_timestamp();
  static const int kEndTimestampFieldNumber = 3;
  inline ::google::protobuf::uint64 end_timestamp() const;
  inline void set_end_timestamp(::google::protobuf::uint64 value);
  
  // optional string sql = 4;
  inline bool has_sql() const;
  inline void clear_sql();
  static const int kSqlFieldNumber = 4;
  inline const ::std::string& sql() const;
  inline void set_sql(const ::std::string& value);
  inline void set_sql(const char* value);
  inline void set_sql(const char* value, size_t size);
  inline ::std::string* mutable_sql();
  
  // optional .drizzled.message.InsertHeader insert_header = 5;
  inline bool has_insert_header() const;
  inline void clear_insert_header();
  static const int kInsertHeaderFieldNumber = 5;
  inline const ::drizzled::message::InsertHeader& insert_header() const;
  inline ::drizzled::message::InsertHeader* mutable_insert_header();
  
  // optional .drizzled.message.InsertData insert_data = 6;
  inline bool has_insert_data() const;
  inline void clear_insert_data();
  static const int kInsertDataFieldNumber = 6;
  inline const ::drizzled::message::InsertData& insert_data() const;
  inline ::drizzled::message::InsertData* mutable_insert_data();
  
  // optional .drizzled.message.UpdateHeader update_header = 7;
  inline bool has_update_header() const;
  inline void clear_update_header();
  static const int kUpdateHeaderFieldNumber = 7;
  inline const ::drizzled::message::UpdateHeader& update_header() const;
  inline ::drizzled::message::UpdateHeader* mutable_update_header();
  
  // optional .drizzled.message.UpdateData update_data = 8;
  inline bool has_update_data() const;
  inline void clear_update_data();
  static const int kUpdateDataFieldNumber = 8;
  inline const ::drizzled::message::UpdateData& update_data() const;
  inline ::drizzled::message::UpdateData* mutable_update_data();
  
  // optional .drizzled.message.DeleteHeader delete_header = 9;
  inline bool has_delete_header() const;
  inline void clear_delete_header();
  static const int kDeleteHeaderFieldNumber = 9;
  inline const ::drizzled::message::DeleteHeader& delete_header() const;
  inline ::drizzled::message::DeleteHeader* mutable_delete_header();
  
  // optional .drizzled.message.DeleteData delete_data = 10;
  inline bool has_delete_data() const;
  inline void clear_delete_data();
  static const int kDeleteDataFieldNumber = 10;
  inline const ::drizzled::message::DeleteData& delete_data() const;
  inline ::drizzled::message::DeleteData* mutable_delete_data();
  
  // optional .drizzled.message.TruncateTableStatement truncate_table_statement = 11;
  inline bool has_truncate_table_statement() const;
  inline void clear_truncate_table_statement();
  static const int kTruncateTableStatementFieldNumber = 11;
  inline const ::drizzled::message::TruncateTableStatement& truncate_table_statement() const;
  inline ::drizzled::message::TruncateTableStatement* mutable_truncate_table_statement();
  
  // optional .drizzled.message.CreateSchemaStatement create_schema_statement = 12;
  inline bool has_create_schema_statement() const;
  inline void clear_create_schema_statement();
  static const int kCreateSchemaStatementFieldNumber = 12;
  inline const ::drizzled::message::CreateSchemaStatement& create_schema_statement() const;
  inline ::drizzled::message::CreateSchemaStatement* mutable_create_schema_statement();
  
  // optional .drizzled.message.DropSchemaStatement drop_schema_statement = 13;
  inline bool has_drop_schema_statement() const;
  inline void clear_drop_schema_statement();
  static const int kDropSchemaStatementFieldNumber = 13;
  inline const ::drizzled::message::DropSchemaStatement& drop_schema_statement() const;
  inline ::drizzled::message::DropSchemaStatement* mutable_drop_schema_statement();
  
  // optional .drizzled.message.AlterSchemaStatement alter_schema_statement = 14;
  inline bool has_alter_schema_statement() const;
  inline void clear_alter_schema_statement();
  static const int kAlterSchemaStatementFieldNumber = 14;
  inline const ::drizzled::message::AlterSchemaStatement& alter_schema_statement() const;
  inline ::drizzled::message::AlterSchemaStatement* mutable_alter_schema_statement();
  
  // optional .drizzled.message.CreateTableStatement create_table_statement = 15;
  inline bool has_create_table_statement() const;
  inline void clear_create_table_statement();
  static const int kCreateTableStatementFieldNumber = 15;
  inline const ::drizzled::message::CreateTableStatement& create_table_statement() const;
  inline ::drizzled::message::CreateTableStatement* mutable_create_table_statement();
  
  // optional .drizzled.message.AlterTableStatement alter_table_statement = 16;
  inline bool has_alter_table_statement() const;
  inline void clear_alter_table_statement();
  static const int kAlterTableStatementFieldNumber = 16;
  inline const ::drizzled::message::AlterTableStatement& alter_table_statement() const;
  inline ::drizzled::message::AlterTableStatement* mutable_alter_table_statement();
  
  // optional .drizzled.message.DropTableStatement drop_table_statement = 17;
  inline bool has_drop_table_statement() const;
  inline void clear_drop_table_statement();
  static const int kDropTableStatementFieldNumber = 17;
  inline const ::drizzled::message::DropTableStatement& drop_table_statement() const;
  inline ::drizzled::message::DropTableStatement* mutable_drop_table_statement();
  
  // optional .drizzled.message.SetVariableStatement set_variable_statement = 18;
  inline bool has_set_variable_statement() const;
  inline void clear_set_variable_statement();
  static const int kSetVariableStatementFieldNumber = 18;
  inline const ::drizzled::message::SetVariableStatement& set_variable_statement() const;
  inline ::drizzled::message::SetVariableStatement* mutable_set_variable_statement();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.Statement)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  int type_;
  ::google::protobuf::uint64 start_timestamp_;
  ::google::protobuf::uint64 end_timestamp_;
  ::std::string* sql_;
  static const ::std::string _default_sql_;
  ::drizzled::message::InsertHeader* insert_header_;
  ::drizzled::message::InsertData* insert_data_;
  ::drizzled::message::UpdateHeader* update_header_;
  ::drizzled::message::UpdateData* update_data_;
  ::drizzled::message::DeleteHeader* delete_header_;
  ::drizzled::message::DeleteData* delete_data_;
  ::drizzled::message::TruncateTableStatement* truncate_table_statement_;
  ::drizzled::message::CreateSchemaStatement* create_schema_statement_;
  ::drizzled::message::DropSchemaStatement* drop_schema_statement_;
  ::drizzled::message::AlterSchemaStatement* alter_schema_statement_;
  ::drizzled::message::CreateTableStatement* create_table_statement_;
  ::drizzled::message::AlterTableStatement* alter_table_statement_;
  ::drizzled::message::DropTableStatement* drop_table_statement_;
  ::drizzled::message::SetVariableStatement* set_variable_statement_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(18 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Statement* default_instance_;
};
// -------------------------------------------------------------------

class Transaction : public ::google::protobuf::Message {
 public:
  Transaction();
  virtual ~Transaction();
  
  Transaction(const Transaction& from);
  
  inline Transaction& operator=(const Transaction& from) {
    CopyFrom(from);
    return *this;
  }
  
  inline const ::google::protobuf::UnknownFieldSet& unknown_fields() const {
    return _unknown_fields_;
  }
  
  inline ::google::protobuf::UnknownFieldSet* mutable_unknown_fields() {
    return &_unknown_fields_;
  }
  
  static const ::google::protobuf::Descriptor* descriptor();
  static const Transaction& default_instance();
  
  void Swap(Transaction* other);
  
  // implements Message ----------------------------------------------
  
  Transaction* New() const;
  void CopyFrom(const ::google::protobuf::Message& from);
  void MergeFrom(const ::google::protobuf::Message& from);
  void CopyFrom(const Transaction& from);
  void MergeFrom(const Transaction& from);
  void Clear();
  bool IsInitialized() const;
  
  int ByteSize() const;
  bool MergePartialFromCodedStream(
      ::google::protobuf::io::CodedInputStream* input);
  void SerializeWithCachedSizes(
      ::google::protobuf::io::CodedOutputStream* output) const;
  ::google::protobuf::uint8* SerializeWithCachedSizesToArray(::google::protobuf::uint8* output) const;
  int GetCachedSize() const { return _cached_size_; }
  private:
  void SharedCtor();
  void SharedDtor();
  void SetCachedSize(int size) const;
  public:
  
  ::google::protobuf::Metadata GetMetadata() const;
  
  // nested types ----------------------------------------------------
  
  // accessors -------------------------------------------------------
  
  // required .drizzled.message.TransactionContext transaction_context = 1;
  inline bool has_transaction_context() const;
  inline void clear_transaction_context();
  static const int kTransactionContextFieldNumber = 1;
  inline const ::drizzled::message::TransactionContext& transaction_context() const;
  inline ::drizzled::message::TransactionContext* mutable_transaction_context();
  
  // repeated .drizzled.message.Statement statement = 2;
  inline int statement_size() const;
  inline void clear_statement();
  static const int kStatementFieldNumber = 2;
  inline const ::drizzled::message::Statement& statement(int index) const;
  inline ::drizzled::message::Statement* mutable_statement(int index);
  inline ::drizzled::message::Statement* add_statement();
  inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Statement >&
      statement() const;
  inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Statement >*
      mutable_statement();
  
  // @@protoc_insertion_point(class_scope:drizzled.message.Transaction)
 private:
  ::google::protobuf::UnknownFieldSet _unknown_fields_;
  mutable int _cached_size_;
  
  ::drizzled::message::TransactionContext* transaction_context_;
  ::google::protobuf::RepeatedPtrField< ::drizzled::message::Statement > statement_;
  friend void  protobuf_AddDesc_transaction_2eproto();
  friend void protobuf_AssignDesc_transaction_2eproto();
  friend void protobuf_ShutdownFile_transaction_2eproto();
  
  ::google::protobuf::uint32 _has_bits_[(2 + 31) / 32];
  
  // WHY DOES & HAVE LOWER PRECEDENCE THAN != !?
  inline bool _has_bit(int index) const {
    return (_has_bits_[index / 32] & (1u << (index % 32))) != 0;
  }
  inline void _set_bit(int index) {
    _has_bits_[index / 32] |= (1u << (index % 32));
  }
  inline void _clear_bit(int index) {
    _has_bits_[index / 32] &= ~(1u << (index % 32));
  }
  
  void InitAsDefaultInstance();
  static Transaction* default_instance_;
};
// ===================================================================


// ===================================================================

// FieldMetadata

// required .drizzled.message.Table.Field.FieldType type = 1;
inline bool FieldMetadata::has_type() const {
  return _has_bit(0);
}
inline void FieldMetadata::clear_type() {
  type_ = 0;
  _clear_bit(0);
}
inline ::drizzled::message::Table_Field_FieldType FieldMetadata::type() const {
  return static_cast< ::drizzled::message::Table_Field_FieldType >(type_);
}
inline void FieldMetadata::set_type(::drizzled::message::Table_Field_FieldType value) {
  GOOGLE_DCHECK(::drizzled::message::Table_Field_FieldType_IsValid(value));
  _set_bit(0);
  type_ = value;
}

// required string name = 2;
inline bool FieldMetadata::has_name() const {
  return _has_bit(1);
}
inline void FieldMetadata::clear_name() {
  if (name_ != &_default_name_) {
    name_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& FieldMetadata::name() const {
  return *name_;
}
inline void FieldMetadata::set_name(const ::std::string& value) {
  _set_bit(1);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void FieldMetadata::set_name(const char* value) {
  _set_bit(1);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(value);
}
inline void FieldMetadata::set_name(const char* value, size_t size) {
  _set_bit(1);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* FieldMetadata::mutable_name() {
  _set_bit(1);
  if (name_ == &_default_name_) {
    name_ = new ::std::string;
  }
  return name_;
}

// -------------------------------------------------------------------

// TableMetadata

// required string schema_name = 1;
inline bool TableMetadata::has_schema_name() const {
  return _has_bit(0);
}
inline void TableMetadata::clear_schema_name() {
  if (schema_name_ != &_default_schema_name_) {
    schema_name_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& TableMetadata::schema_name() const {
  return *schema_name_;
}
inline void TableMetadata::set_schema_name(const ::std::string& value) {
  _set_bit(0);
  if (schema_name_ == &_default_schema_name_) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(value);
}
inline void TableMetadata::set_schema_name(const char* value) {
  _set_bit(0);
  if (schema_name_ == &_default_schema_name_) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(value);
}
inline void TableMetadata::set_schema_name(const char* value, size_t size) {
  _set_bit(0);
  if (schema_name_ == &_default_schema_name_) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TableMetadata::mutable_schema_name() {
  _set_bit(0);
  if (schema_name_ == &_default_schema_name_) {
    schema_name_ = new ::std::string;
  }
  return schema_name_;
}

// required string table_name = 2;
inline bool TableMetadata::has_table_name() const {
  return _has_bit(1);
}
inline void TableMetadata::clear_table_name() {
  if (table_name_ != &_default_table_name_) {
    table_name_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& TableMetadata::table_name() const {
  return *table_name_;
}
inline void TableMetadata::set_table_name(const ::std::string& value) {
  _set_bit(1);
  if (table_name_ == &_default_table_name_) {
    table_name_ = new ::std::string;
  }
  table_name_->assign(value);
}
inline void TableMetadata::set_table_name(const char* value) {
  _set_bit(1);
  if (table_name_ == &_default_table_name_) {
    table_name_ = new ::std::string;
  }
  table_name_->assign(value);
}
inline void TableMetadata::set_table_name(const char* value, size_t size) {
  _set_bit(1);
  if (table_name_ == &_default_table_name_) {
    table_name_ = new ::std::string;
  }
  table_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* TableMetadata::mutable_table_name() {
  _set_bit(1);
  if (table_name_ == &_default_table_name_) {
    table_name_ = new ::std::string;
  }
  return table_name_;
}

// -------------------------------------------------------------------

// TransactionContext

// required uint32 server_id = 1;
inline bool TransactionContext::has_server_id() const {
  return _has_bit(0);
}
inline void TransactionContext::clear_server_id() {
  server_id_ = 0u;
  _clear_bit(0);
}
inline ::google::protobuf::uint32 TransactionContext::server_id() const {
  return server_id_;
}
inline void TransactionContext::set_server_id(::google::protobuf::uint32 value) {
  _set_bit(0);
  server_id_ = value;
}

// required uint64 transaction_id = 2;
inline bool TransactionContext::has_transaction_id() const {
  return _has_bit(1);
}
inline void TransactionContext::clear_transaction_id() {
  transaction_id_ = GOOGLE_ULONGLONG(0);
  _clear_bit(1);
}
inline ::google::protobuf::uint64 TransactionContext::transaction_id() const {
  return transaction_id_;
}
inline void TransactionContext::set_transaction_id(::google::protobuf::uint64 value) {
  _set_bit(1);
  transaction_id_ = value;
}

// required uint64 start_timestamp = 3;
inline bool TransactionContext::has_start_timestamp() const {
  return _has_bit(2);
}
inline void TransactionContext::clear_start_timestamp() {
  start_timestamp_ = GOOGLE_ULONGLONG(0);
  _clear_bit(2);
}
inline ::google::protobuf::uint64 TransactionContext::start_timestamp() const {
  return start_timestamp_;
}
inline void TransactionContext::set_start_timestamp(::google::protobuf::uint64 value) {
  _set_bit(2);
  start_timestamp_ = value;
}

// required uint64 end_timestamp = 4;
inline bool TransactionContext::has_end_timestamp() const {
  return _has_bit(3);
}
inline void TransactionContext::clear_end_timestamp() {
  end_timestamp_ = GOOGLE_ULONGLONG(0);
  _clear_bit(3);
}
inline ::google::protobuf::uint64 TransactionContext::end_timestamp() const {
  return end_timestamp_;
}
inline void TransactionContext::set_end_timestamp(::google::protobuf::uint64 value) {
  _set_bit(3);
  end_timestamp_ = value;
}

// -------------------------------------------------------------------

// InsertRecord

// repeated bytes insert_value = 1;
inline int InsertRecord::insert_value_size() const {
  return insert_value_.size();
}
inline void InsertRecord::clear_insert_value() {
  insert_value_.Clear();
}
inline const ::std::string& InsertRecord::insert_value(int index) const {
  return insert_value_.Get(index);
}
inline ::std::string* InsertRecord::mutable_insert_value(int index) {
  return insert_value_.Mutable(index);
}
inline void InsertRecord::set_insert_value(int index, const ::std::string& value) {
  insert_value_.Mutable(index)->assign(value);
}
inline void InsertRecord::set_insert_value(int index, const char* value) {
  insert_value_.Mutable(index)->assign(value);
}
inline void InsertRecord::set_insert_value(int index, const void* value, size_t size) {
  insert_value_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* InsertRecord::add_insert_value() {
  return insert_value_.Add();
}
inline void InsertRecord::add_insert_value(const ::std::string& value) {
  insert_value_.Add()->assign(value);
}
inline void InsertRecord::add_insert_value(const char* value) {
  insert_value_.Add()->assign(value);
}
inline void InsertRecord::add_insert_value(const void* value, size_t size) {
  insert_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
InsertRecord::insert_value() const {
  return insert_value_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
InsertRecord::mutable_insert_value() {
  return &insert_value_;
}

// -------------------------------------------------------------------

// InsertHeader

// required .drizzled.message.TableMetadata table_metadata = 1;
inline bool InsertHeader::has_table_metadata() const {
  return _has_bit(0);
}
inline void InsertHeader::clear_table_metadata() {
  if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
  _clear_bit(0);
}
inline const ::drizzled::message::TableMetadata& InsertHeader::table_metadata() const {
  return table_metadata_ != NULL ? *table_metadata_ : *default_instance_->table_metadata_;
}
inline ::drizzled::message::TableMetadata* InsertHeader::mutable_table_metadata() {
  _set_bit(0);
  if (table_metadata_ == NULL) table_metadata_ = new ::drizzled::message::TableMetadata;
  return table_metadata_;
}

// repeated .drizzled.message.FieldMetadata field_metadata = 2;
inline int InsertHeader::field_metadata_size() const {
  return field_metadata_.size();
}
inline void InsertHeader::clear_field_metadata() {
  field_metadata_.Clear();
}
inline const ::drizzled::message::FieldMetadata& InsertHeader::field_metadata(int index) const {
  return field_metadata_.Get(index);
}
inline ::drizzled::message::FieldMetadata* InsertHeader::mutable_field_metadata(int index) {
  return field_metadata_.Mutable(index);
}
inline ::drizzled::message::FieldMetadata* InsertHeader::add_field_metadata() {
  return field_metadata_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
InsertHeader::field_metadata() const {
  return field_metadata_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
InsertHeader::mutable_field_metadata() {
  return &field_metadata_;
}

// -------------------------------------------------------------------

// InsertData

// required uint32 segment_id = 1;
inline bool InsertData::has_segment_id() const {
  return _has_bit(0);
}
inline void InsertData::clear_segment_id() {
  segment_id_ = 0u;
  _clear_bit(0);
}
inline ::google::protobuf::uint32 InsertData::segment_id() const {
  return segment_id_;
}
inline void InsertData::set_segment_id(::google::protobuf::uint32 value) {
  _set_bit(0);
  segment_id_ = value;
}

// required bool end_segment = 2;
inline bool InsertData::has_end_segment() const {
  return _has_bit(1);
}
inline void InsertData::clear_end_segment() {
  end_segment_ = false;
  _clear_bit(1);
}
inline bool InsertData::end_segment() const {
  return end_segment_;
}
inline void InsertData::set_end_segment(bool value) {
  _set_bit(1);
  end_segment_ = value;
}

// repeated .drizzled.message.InsertRecord record = 3;
inline int InsertData::record_size() const {
  return record_.size();
}
inline void InsertData::clear_record() {
  record_.Clear();
}
inline const ::drizzled::message::InsertRecord& InsertData::record(int index) const {
  return record_.Get(index);
}
inline ::drizzled::message::InsertRecord* InsertData::mutable_record(int index) {
  return record_.Mutable(index);
}
inline ::drizzled::message::InsertRecord* InsertData::add_record() {
  return record_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::InsertRecord >&
InsertData::record() const {
  return record_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::InsertRecord >*
InsertData::mutable_record() {
  return &record_;
}

// -------------------------------------------------------------------

// UpdateRecord

// repeated bytes key_value = 1;
inline int UpdateRecord::key_value_size() const {
  return key_value_.size();
}
inline void UpdateRecord::clear_key_value() {
  key_value_.Clear();
}
inline const ::std::string& UpdateRecord::key_value(int index) const {
  return key_value_.Get(index);
}
inline ::std::string* UpdateRecord::mutable_key_value(int index) {
  return key_value_.Mutable(index);
}
inline void UpdateRecord::set_key_value(int index, const ::std::string& value) {
  key_value_.Mutable(index)->assign(value);
}
inline void UpdateRecord::set_key_value(int index, const char* value) {
  key_value_.Mutable(index)->assign(value);
}
inline void UpdateRecord::set_key_value(int index, const void* value, size_t size) {
  key_value_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* UpdateRecord::add_key_value() {
  return key_value_.Add();
}
inline void UpdateRecord::add_key_value(const ::std::string& value) {
  key_value_.Add()->assign(value);
}
inline void UpdateRecord::add_key_value(const char* value) {
  key_value_.Add()->assign(value);
}
inline void UpdateRecord::add_key_value(const void* value, size_t size) {
  key_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
UpdateRecord::key_value() const {
  return key_value_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
UpdateRecord::mutable_key_value() {
  return &key_value_;
}

// repeated bytes after_value = 2;
inline int UpdateRecord::after_value_size() const {
  return after_value_.size();
}
inline void UpdateRecord::clear_after_value() {
  after_value_.Clear();
}
inline const ::std::string& UpdateRecord::after_value(int index) const {
  return after_value_.Get(index);
}
inline ::std::string* UpdateRecord::mutable_after_value(int index) {
  return after_value_.Mutable(index);
}
inline void UpdateRecord::set_after_value(int index, const ::std::string& value) {
  after_value_.Mutable(index)->assign(value);
}
inline void UpdateRecord::set_after_value(int index, const char* value) {
  after_value_.Mutable(index)->assign(value);
}
inline void UpdateRecord::set_after_value(int index, const void* value, size_t size) {
  after_value_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* UpdateRecord::add_after_value() {
  return after_value_.Add();
}
inline void UpdateRecord::add_after_value(const ::std::string& value) {
  after_value_.Add()->assign(value);
}
inline void UpdateRecord::add_after_value(const char* value) {
  after_value_.Add()->assign(value);
}
inline void UpdateRecord::add_after_value(const void* value, size_t size) {
  after_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
UpdateRecord::after_value() const {
  return after_value_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
UpdateRecord::mutable_after_value() {
  return &after_value_;
}

// repeated bytes before_value = 3;
inline int UpdateRecord::before_value_size() const {
  return before_value_.size();
}
inline void UpdateRecord::clear_before_value() {
  before_value_.Clear();
}
inline const ::std::string& UpdateRecord::before_value(int index) const {
  return before_value_.Get(index);
}
inline ::std::string* UpdateRecord::mutable_before_value(int index) {
  return before_value_.Mutable(index);
}
inline void UpdateRecord::set_before_value(int index, const ::std::string& value) {
  before_value_.Mutable(index)->assign(value);
}
inline void UpdateRecord::set_before_value(int index, const char* value) {
  before_value_.Mutable(index)->assign(value);
}
inline void UpdateRecord::set_before_value(int index, const void* value, size_t size) {
  before_value_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* UpdateRecord::add_before_value() {
  return before_value_.Add();
}
inline void UpdateRecord::add_before_value(const ::std::string& value) {
  before_value_.Add()->assign(value);
}
inline void UpdateRecord::add_before_value(const char* value) {
  before_value_.Add()->assign(value);
}
inline void UpdateRecord::add_before_value(const void* value, size_t size) {
  before_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
UpdateRecord::before_value() const {
  return before_value_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
UpdateRecord::mutable_before_value() {
  return &before_value_;
}

// -------------------------------------------------------------------

// UpdateHeader

// required .drizzled.message.TableMetadata table_metadata = 1;
inline bool UpdateHeader::has_table_metadata() const {
  return _has_bit(0);
}
inline void UpdateHeader::clear_table_metadata() {
  if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
  _clear_bit(0);
}
inline const ::drizzled::message::TableMetadata& UpdateHeader::table_metadata() const {
  return table_metadata_ != NULL ? *table_metadata_ : *default_instance_->table_metadata_;
}
inline ::drizzled::message::TableMetadata* UpdateHeader::mutable_table_metadata() {
  _set_bit(0);
  if (table_metadata_ == NULL) table_metadata_ = new ::drizzled::message::TableMetadata;
  return table_metadata_;
}

// repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
inline int UpdateHeader::key_field_metadata_size() const {
  return key_field_metadata_.size();
}
inline void UpdateHeader::clear_key_field_metadata() {
  key_field_metadata_.Clear();
}
inline const ::drizzled::message::FieldMetadata& UpdateHeader::key_field_metadata(int index) const {
  return key_field_metadata_.Get(index);
}
inline ::drizzled::message::FieldMetadata* UpdateHeader::mutable_key_field_metadata(int index) {
  return key_field_metadata_.Mutable(index);
}
inline ::drizzled::message::FieldMetadata* UpdateHeader::add_key_field_metadata() {
  return key_field_metadata_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
UpdateHeader::key_field_metadata() const {
  return key_field_metadata_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
UpdateHeader::mutable_key_field_metadata() {
  return &key_field_metadata_;
}

// repeated .drizzled.message.FieldMetadata set_field_metadata = 3;
inline int UpdateHeader::set_field_metadata_size() const {
  return set_field_metadata_.size();
}
inline void UpdateHeader::clear_set_field_metadata() {
  set_field_metadata_.Clear();
}
inline const ::drizzled::message::FieldMetadata& UpdateHeader::set_field_metadata(int index) const {
  return set_field_metadata_.Get(index);
}
inline ::drizzled::message::FieldMetadata* UpdateHeader::mutable_set_field_metadata(int index) {
  return set_field_metadata_.Mutable(index);
}
inline ::drizzled::message::FieldMetadata* UpdateHeader::add_set_field_metadata() {
  return set_field_metadata_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
UpdateHeader::set_field_metadata() const {
  return set_field_metadata_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
UpdateHeader::mutable_set_field_metadata() {
  return &set_field_metadata_;
}

// -------------------------------------------------------------------

// UpdateData

// required uint32 segment_id = 1;
inline bool UpdateData::has_segment_id() const {
  return _has_bit(0);
}
inline void UpdateData::clear_segment_id() {
  segment_id_ = 0u;
  _clear_bit(0);
}
inline ::google::protobuf::uint32 UpdateData::segment_id() const {
  return segment_id_;
}
inline void UpdateData::set_segment_id(::google::protobuf::uint32 value) {
  _set_bit(0);
  segment_id_ = value;
}

// required bool end_segment = 2;
inline bool UpdateData::has_end_segment() const {
  return _has_bit(1);
}
inline void UpdateData::clear_end_segment() {
  end_segment_ = false;
  _clear_bit(1);
}
inline bool UpdateData::end_segment() const {
  return end_segment_;
}
inline void UpdateData::set_end_segment(bool value) {
  _set_bit(1);
  end_segment_ = value;
}

// repeated .drizzled.message.UpdateRecord record = 3;
inline int UpdateData::record_size() const {
  return record_.size();
}
inline void UpdateData::clear_record() {
  record_.Clear();
}
inline const ::drizzled::message::UpdateRecord& UpdateData::record(int index) const {
  return record_.Get(index);
}
inline ::drizzled::message::UpdateRecord* UpdateData::mutable_record(int index) {
  return record_.Mutable(index);
}
inline ::drizzled::message::UpdateRecord* UpdateData::add_record() {
  return record_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::UpdateRecord >&
UpdateData::record() const {
  return record_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::UpdateRecord >*
UpdateData::mutable_record() {
  return &record_;
}

// -------------------------------------------------------------------

// DeleteRecord

// repeated bytes key_value = 1;
inline int DeleteRecord::key_value_size() const {
  return key_value_.size();
}
inline void DeleteRecord::clear_key_value() {
  key_value_.Clear();
}
inline const ::std::string& DeleteRecord::key_value(int index) const {
  return key_value_.Get(index);
}
inline ::std::string* DeleteRecord::mutable_key_value(int index) {
  return key_value_.Mutable(index);
}
inline void DeleteRecord::set_key_value(int index, const ::std::string& value) {
  key_value_.Mutable(index)->assign(value);
}
inline void DeleteRecord::set_key_value(int index, const char* value) {
  key_value_.Mutable(index)->assign(value);
}
inline void DeleteRecord::set_key_value(int index, const void* value, size_t size) {
  key_value_.Mutable(index)->assign(
    reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DeleteRecord::add_key_value() {
  return key_value_.Add();
}
inline void DeleteRecord::add_key_value(const ::std::string& value) {
  key_value_.Add()->assign(value);
}
inline void DeleteRecord::add_key_value(const char* value) {
  key_value_.Add()->assign(value);
}
inline void DeleteRecord::add_key_value(const void* value, size_t size) {
  key_value_.Add()->assign(reinterpret_cast<const char*>(value), size);
}
inline const ::google::protobuf::RepeatedPtrField< ::std::string>&
DeleteRecord::key_value() const {
  return key_value_;
}
inline ::google::protobuf::RepeatedPtrField< ::std::string>*
DeleteRecord::mutable_key_value() {
  return &key_value_;
}

// -------------------------------------------------------------------

// DeleteHeader

// required .drizzled.message.TableMetadata table_metadata = 1;
inline bool DeleteHeader::has_table_metadata() const {
  return _has_bit(0);
}
inline void DeleteHeader::clear_table_metadata() {
  if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
  _clear_bit(0);
}
inline const ::drizzled::message::TableMetadata& DeleteHeader::table_metadata() const {
  return table_metadata_ != NULL ? *table_metadata_ : *default_instance_->table_metadata_;
}
inline ::drizzled::message::TableMetadata* DeleteHeader::mutable_table_metadata() {
  _set_bit(0);
  if (table_metadata_ == NULL) table_metadata_ = new ::drizzled::message::TableMetadata;
  return table_metadata_;
}

// repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
inline int DeleteHeader::key_field_metadata_size() const {
  return key_field_metadata_.size();
}
inline void DeleteHeader::clear_key_field_metadata() {
  key_field_metadata_.Clear();
}
inline const ::drizzled::message::FieldMetadata& DeleteHeader::key_field_metadata(int index) const {
  return key_field_metadata_.Get(index);
}
inline ::drizzled::message::FieldMetadata* DeleteHeader::mutable_key_field_metadata(int index) {
  return key_field_metadata_.Mutable(index);
}
inline ::drizzled::message::FieldMetadata* DeleteHeader::add_key_field_metadata() {
  return key_field_metadata_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >&
DeleteHeader::key_field_metadata() const {
  return key_field_metadata_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::FieldMetadata >*
DeleteHeader::mutable_key_field_metadata() {
  return &key_field_metadata_;
}

// -------------------------------------------------------------------

// DeleteData

// required uint32 segment_id = 1;
inline bool DeleteData::has_segment_id() const {
  return _has_bit(0);
}
inline void DeleteData::clear_segment_id() {
  segment_id_ = 0u;
  _clear_bit(0);
}
inline ::google::protobuf::uint32 DeleteData::segment_id() const {
  return segment_id_;
}
inline void DeleteData::set_segment_id(::google::protobuf::uint32 value) {
  _set_bit(0);
  segment_id_ = value;
}

// required bool end_segment = 2;
inline bool DeleteData::has_end_segment() const {
  return _has_bit(1);
}
inline void DeleteData::clear_end_segment() {
  end_segment_ = false;
  _clear_bit(1);
}
inline bool DeleteData::end_segment() const {
  return end_segment_;
}
inline void DeleteData::set_end_segment(bool value) {
  _set_bit(1);
  end_segment_ = value;
}

// repeated .drizzled.message.DeleteRecord record = 3;
inline int DeleteData::record_size() const {
  return record_.size();
}
inline void DeleteData::clear_record() {
  record_.Clear();
}
inline const ::drizzled::message::DeleteRecord& DeleteData::record(int index) const {
  return record_.Get(index);
}
inline ::drizzled::message::DeleteRecord* DeleteData::mutable_record(int index) {
  return record_.Mutable(index);
}
inline ::drizzled::message::DeleteRecord* DeleteData::add_record() {
  return record_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::DeleteRecord >&
DeleteData::record() const {
  return record_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::DeleteRecord >*
DeleteData::mutable_record() {
  return &record_;
}

// -------------------------------------------------------------------

// TruncateTableStatement

// required .drizzled.message.TableMetadata table_metadata = 1;
inline bool TruncateTableStatement::has_table_metadata() const {
  return _has_bit(0);
}
inline void TruncateTableStatement::clear_table_metadata() {
  if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
  _clear_bit(0);
}
inline const ::drizzled::message::TableMetadata& TruncateTableStatement::table_metadata() const {
  return table_metadata_ != NULL ? *table_metadata_ : *default_instance_->table_metadata_;
}
inline ::drizzled::message::TableMetadata* TruncateTableStatement::mutable_table_metadata() {
  _set_bit(0);
  if (table_metadata_ == NULL) table_metadata_ = new ::drizzled::message::TableMetadata;
  return table_metadata_;
}

// -------------------------------------------------------------------

// CreateSchemaStatement

// required .drizzled.message.Schema schema = 1;
inline bool CreateSchemaStatement::has_schema() const {
  return _has_bit(0);
}
inline void CreateSchemaStatement::clear_schema() {
  if (schema_ != NULL) schema_->::drizzled::message::Schema::Clear();
  _clear_bit(0);
}
inline const ::drizzled::message::Schema& CreateSchemaStatement::schema() const {
  return schema_ != NULL ? *schema_ : *default_instance_->schema_;
}
inline ::drizzled::message::Schema* CreateSchemaStatement::mutable_schema() {
  _set_bit(0);
  if (schema_ == NULL) schema_ = new ::drizzled::message::Schema;
  return schema_;
}

// -------------------------------------------------------------------

// AlterSchemaStatement

// required .drizzled.message.Schema before = 1;
inline bool AlterSchemaStatement::has_before() const {
  return _has_bit(0);
}
inline void AlterSchemaStatement::clear_before() {
  if (before_ != NULL) before_->::drizzled::message::Schema::Clear();
  _clear_bit(0);
}
inline const ::drizzled::message::Schema& AlterSchemaStatement::before() const {
  return before_ != NULL ? *before_ : *default_instance_->before_;
}
inline ::drizzled::message::Schema* AlterSchemaStatement::mutable_before() {
  _set_bit(0);
  if (before_ == NULL) before_ = new ::drizzled::message::Schema;
  return before_;
}

// required .drizzled.message.Schema after = 2;
inline bool AlterSchemaStatement::has_after() const {
  return _has_bit(1);
}
inline void AlterSchemaStatement::clear_after() {
  if (after_ != NULL) after_->::drizzled::message::Schema::Clear();
  _clear_bit(1);
}
inline const ::drizzled::message::Schema& AlterSchemaStatement::after() const {
  return after_ != NULL ? *after_ : *default_instance_->after_;
}
inline ::drizzled::message::Schema* AlterSchemaStatement::mutable_after() {
  _set_bit(1);
  if (after_ == NULL) after_ = new ::drizzled::message::Schema;
  return after_;
}

// -------------------------------------------------------------------

// DropSchemaStatement

// required string schema_name = 1;
inline bool DropSchemaStatement::has_schema_name() const {
  return _has_bit(0);
}
inline void DropSchemaStatement::clear_schema_name() {
  if (schema_name_ != &_default_schema_name_) {
    schema_name_->clear();
  }
  _clear_bit(0);
}
inline const ::std::string& DropSchemaStatement::schema_name() const {
  return *schema_name_;
}
inline void DropSchemaStatement::set_schema_name(const ::std::string& value) {
  _set_bit(0);
  if (schema_name_ == &_default_schema_name_) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(value);
}
inline void DropSchemaStatement::set_schema_name(const char* value) {
  _set_bit(0);
  if (schema_name_ == &_default_schema_name_) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(value);
}
inline void DropSchemaStatement::set_schema_name(const char* value, size_t size) {
  _set_bit(0);
  if (schema_name_ == &_default_schema_name_) {
    schema_name_ = new ::std::string;
  }
  schema_name_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* DropSchemaStatement::mutable_schema_name() {
  _set_bit(0);
  if (schema_name_ == &_default_schema_name_) {
    schema_name_ = new ::std::string;
  }
  return schema_name_;
}

// -------------------------------------------------------------------

// CreateTableStatement

// required .drizzled.message.Table table = 1;
inline bool CreateTableStatement::has_table() const {
  return _has_bit(0);
}
inline void CreateTableStatement::clear_table() {
  if (table_ != NULL) table_->::drizzled::message::Table::Clear();
  _clear_bit(0);
}
inline const ::drizzled::message::Table& CreateTableStatement::table() const {
  return table_ != NULL ? *table_ : *default_instance_->table_;
}
inline ::drizzled::message::Table* CreateTableStatement::mutable_table() {
  _set_bit(0);
  if (table_ == NULL) table_ = new ::drizzled::message::Table;
  return table_;
}

// -------------------------------------------------------------------

// AlterTableStatement

// required .drizzled.message.Table before = 1;
inline bool AlterTableStatement::has_before() const {
  return _has_bit(0);
}
inline void AlterTableStatement::clear_before() {
  if (before_ != NULL) before_->::drizzled::message::Table::Clear();
  _clear_bit(0);
}
inline const ::drizzled::message::Table& AlterTableStatement::before() const {
  return before_ != NULL ? *before_ : *default_instance_->before_;
}
inline ::drizzled::message::Table* AlterTableStatement::mutable_before() {
  _set_bit(0);
  if (before_ == NULL) before_ = new ::drizzled::message::Table;
  return before_;
}

// required .drizzled.message.Table after = 2;
inline bool AlterTableStatement::has_after() const {
  return _has_bit(1);
}
inline void AlterTableStatement::clear_after() {
  if (after_ != NULL) after_->::drizzled::message::Table::Clear();
  _clear_bit(1);
}
inline const ::drizzled::message::Table& AlterTableStatement::after() const {
  return after_ != NULL ? *after_ : *default_instance_->after_;
}
inline ::drizzled::message::Table* AlterTableStatement::mutable_after() {
  _set_bit(1);
  if (after_ == NULL) after_ = new ::drizzled::message::Table;
  return after_;
}

// -------------------------------------------------------------------

// DropTableStatement

// required .drizzled.message.TableMetadata table_metadata = 1;
inline bool DropTableStatement::has_table_metadata() const {
  return _has_bit(0);
}
inline void DropTableStatement::clear_table_metadata() {
  if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
  _clear_bit(0);
}
inline const ::drizzled::message::TableMetadata& DropTableStatement::table_metadata() const {
  return table_metadata_ != NULL ? *table_metadata_ : *default_instance_->table_metadata_;
}
inline ::drizzled::message::TableMetadata* DropTableStatement::mutable_table_metadata() {
  _set_bit(0);
  if (table_metadata_ == NULL) table_metadata_ = new ::drizzled::message::TableMetadata;
  return table_metadata_;
}

// optional bool if_exists_clause = 2;
inline bool DropTableStatement::has_if_exists_clause() const {
  return _has_bit(1);
}
inline void DropTableStatement::clear_if_exists_clause() {
  if_exists_clause_ = false;
  _clear_bit(1);
}
inline bool DropTableStatement::if_exists_clause() const {
  return if_exists_clause_;
}
inline void DropTableStatement::set_if_exists_clause(bool value) {
  _set_bit(1);
  if_exists_clause_ = value;
}

// -------------------------------------------------------------------

// SetVariableStatement

// required .drizzled.message.FieldMetadata variable_metadata = 1;
inline bool SetVariableStatement::has_variable_metadata() const {
  return _has_bit(0);
}
inline void SetVariableStatement::clear_variable_metadata() {
  if (variable_metadata_ != NULL) variable_metadata_->::drizzled::message::FieldMetadata::Clear();
  _clear_bit(0);
}
inline const ::drizzled::message::FieldMetadata& SetVariableStatement::variable_metadata() const {
  return variable_metadata_ != NULL ? *variable_metadata_ : *default_instance_->variable_metadata_;
}
inline ::drizzled::message::FieldMetadata* SetVariableStatement::mutable_variable_metadata() {
  _set_bit(0);
  if (variable_metadata_ == NULL) variable_metadata_ = new ::drizzled::message::FieldMetadata;
  return variable_metadata_;
}

// required bytes variable_value = 2;
inline bool SetVariableStatement::has_variable_value() const {
  return _has_bit(1);
}
inline void SetVariableStatement::clear_variable_value() {
  if (variable_value_ != &_default_variable_value_) {
    variable_value_->clear();
  }
  _clear_bit(1);
}
inline const ::std::string& SetVariableStatement::variable_value() const {
  return *variable_value_;
}
inline void SetVariableStatement::set_variable_value(const ::std::string& value) {
  _set_bit(1);
  if (variable_value_ == &_default_variable_value_) {
    variable_value_ = new ::std::string;
  }
  variable_value_->assign(value);
}
inline void SetVariableStatement::set_variable_value(const char* value) {
  _set_bit(1);
  if (variable_value_ == &_default_variable_value_) {
    variable_value_ = new ::std::string;
  }
  variable_value_->assign(value);
}
inline void SetVariableStatement::set_variable_value(const void* value, size_t size) {
  _set_bit(1);
  if (variable_value_ == &_default_variable_value_) {
    variable_value_ = new ::std::string;
  }
  variable_value_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* SetVariableStatement::mutable_variable_value() {
  _set_bit(1);
  if (variable_value_ == &_default_variable_value_) {
    variable_value_ = new ::std::string;
  }
  return variable_value_;
}

// -------------------------------------------------------------------

// Statement

// required .drizzled.message.Statement.Type type = 1;
inline bool Statement::has_type() const {
  return _has_bit(0);
}
inline void Statement::clear_type() {
  type_ = 0;
  _clear_bit(0);
}
inline ::drizzled::message::Statement_Type Statement::type() const {
  return static_cast< ::drizzled::message::Statement_Type >(type_);
}
inline void Statement::set_type(::drizzled::message::Statement_Type value) {
  GOOGLE_DCHECK(::drizzled::message::Statement_Type_IsValid(value));
  _set_bit(0);
  type_ = value;
}

// required uint64 start_timestamp = 2;
inline bool Statement::has_start_timestamp() const {
  return _has_bit(1);
}
inline void Statement::clear_start_timestamp() {
  start_timestamp_ = GOOGLE_ULONGLONG(0);
  _clear_bit(1);
}
inline ::google::protobuf::uint64 Statement::start_timestamp() const {
  return start_timestamp_;
}
inline void Statement::set_start_timestamp(::google::protobuf::uint64 value) {
  _set_bit(1);
  start_timestamp_ = value;
}

// required uint64 end_timestamp = 3;
inline bool Statement::has_end_timestamp() const {
  return _has_bit(2);
}
inline void Statement::clear_end_timestamp() {
  end_timestamp_ = GOOGLE_ULONGLONG(0);
  _clear_bit(2);
}
inline ::google::protobuf::uint64 Statement::end_timestamp() const {
  return end_timestamp_;
}
inline void Statement::set_end_timestamp(::google::protobuf::uint64 value) {
  _set_bit(2);
  end_timestamp_ = value;
}

// optional string sql = 4;
inline bool Statement::has_sql() const {
  return _has_bit(3);
}
inline void Statement::clear_sql() {
  if (sql_ != &_default_sql_) {
    sql_->clear();
  }
  _clear_bit(3);
}
inline const ::std::string& Statement::sql() const {
  return *sql_;
}
inline void Statement::set_sql(const ::std::string& value) {
  _set_bit(3);
  if (sql_ == &_default_sql_) {
    sql_ = new ::std::string;
  }
  sql_->assign(value);
}
inline void Statement::set_sql(const char* value) {
  _set_bit(3);
  if (sql_ == &_default_sql_) {
    sql_ = new ::std::string;
  }
  sql_->assign(value);
}
inline void Statement::set_sql(const char* value, size_t size) {
  _set_bit(3);
  if (sql_ == &_default_sql_) {
    sql_ = new ::std::string;
  }
  sql_->assign(reinterpret_cast<const char*>(value), size);
}
inline ::std::string* Statement::mutable_sql() {
  _set_bit(3);
  if (sql_ == &_default_sql_) {
    sql_ = new ::std::string;
  }
  return sql_;
}

// optional .drizzled.message.InsertHeader insert_header = 5;
inline bool Statement::has_insert_header() const {
  return _has_bit(4);
}
inline void Statement::clear_insert_header() {
  if (insert_header_ != NULL) insert_header_->::drizzled::message::InsertHeader::Clear();
  _clear_bit(4);
}
inline const ::drizzled::message::InsertHeader& Statement::insert_header() const {
  return insert_header_ != NULL ? *insert_header_ : *default_instance_->insert_header_;
}
inline ::drizzled::message::InsertHeader* Statement::mutable_insert_header() {
  _set_bit(4);
  if (insert_header_ == NULL) insert_header_ = new ::drizzled::message::InsertHeader;
  return insert_header_;
}

// optional .drizzled.message.InsertData insert_data = 6;
inline bool Statement::has_insert_data() const {
  return _has_bit(5);
}
inline void Statement::clear_insert_data() {
  if (insert_data_ != NULL) insert_data_->::drizzled::message::InsertData::Clear();
  _clear_bit(5);
}
inline const ::drizzled::message::InsertData& Statement::insert_data() const {
  return insert_data_ != NULL ? *insert_data_ : *default_instance_->insert_data_;
}
inline ::drizzled::message::InsertData* Statement::mutable_insert_data() {
  _set_bit(5);
  if (insert_data_ == NULL) insert_data_ = new ::drizzled::message::InsertData;
  return insert_data_;
}

// optional .drizzled.message.UpdateHeader update_header = 7;
inline bool Statement::has_update_header() const {
  return _has_bit(6);
}
inline void Statement::clear_update_header() {
  if (update_header_ != NULL) update_header_->::drizzled::message::UpdateHeader::Clear();
  _clear_bit(6);
}
inline const ::drizzled::message::UpdateHeader& Statement::update_header() const {
  return update_header_ != NULL ? *update_header_ : *default_instance_->update_header_;
}
inline ::drizzled::message::UpdateHeader* Statement::mutable_update_header() {
  _set_bit(6);
  if (update_header_ == NULL) update_header_ = new ::drizzled::message::UpdateHeader;
  return update_header_;
}

// optional .drizzled.message.UpdateData update_data = 8;
inline bool Statement::has_update_data() const {
  return _has_bit(7);
}
inline void Statement::clear_update_data() {
  if (update_data_ != NULL) update_data_->::drizzled::message::UpdateData::Clear();
  _clear_bit(7);
}
inline const ::drizzled::message::UpdateData& Statement::update_data() const {
  return update_data_ != NULL ? *update_data_ : *default_instance_->update_data_;
}
inline ::drizzled::message::UpdateData* Statement::mutable_update_data() {
  _set_bit(7);
  if (update_data_ == NULL) update_data_ = new ::drizzled::message::UpdateData;
  return update_data_;
}

// optional .drizzled.message.DeleteHeader delete_header = 9;
inline bool Statement::has_delete_header() const {
  return _has_bit(8);
}
inline void Statement::clear_delete_header() {
  if (delete_header_ != NULL) delete_header_->::drizzled::message::DeleteHeader::Clear();
  _clear_bit(8);
}
inline const ::drizzled::message::DeleteHeader& Statement::delete_header() const {
  return delete_header_ != NULL ? *delete_header_ : *default_instance_->delete_header_;
}
inline ::drizzled::message::DeleteHeader* Statement::mutable_delete_header() {
  _set_bit(8);
  if (delete_header_ == NULL) delete_header_ = new ::drizzled::message::DeleteHeader;
  return delete_header_;
}

// optional .drizzled.message.DeleteData delete_data = 10;
inline bool Statement::has_delete_data() const {
  return _has_bit(9);
}
inline void Statement::clear_delete_data() {
  if (delete_data_ != NULL) delete_data_->::drizzled::message::DeleteData::Clear();
  _clear_bit(9);
}
inline const ::drizzled::message::DeleteData& Statement::delete_data() const {
  return delete_data_ != NULL ? *delete_data_ : *default_instance_->delete_data_;
}
inline ::drizzled::message::DeleteData* Statement::mutable_delete_data() {
  _set_bit(9);
  if (delete_data_ == NULL) delete_data_ = new ::drizzled::message::DeleteData;
  return delete_data_;
}

// optional .drizzled.message.TruncateTableStatement truncate_table_statement = 11;
inline bool Statement::has_truncate_table_statement() const {
  return _has_bit(10);
}
inline void Statement::clear_truncate_table_statement() {
  if (truncate_table_statement_ != NULL) truncate_table_statement_->::drizzled::message::TruncateTableStatement::Clear();
  _clear_bit(10);
}
inline const ::drizzled::message::TruncateTableStatement& Statement::truncate_table_statement() const {
  return truncate_table_statement_ != NULL ? *truncate_table_statement_ : *default_instance_->truncate_table_statement_;
}
inline ::drizzled::message::TruncateTableStatement* Statement::mutable_truncate_table_statement() {
  _set_bit(10);
  if (truncate_table_statement_ == NULL) truncate_table_statement_ = new ::drizzled::message::TruncateTableStatement;
  return truncate_table_statement_;
}

// optional .drizzled.message.CreateSchemaStatement create_schema_statement = 12;
inline bool Statement::has_create_schema_statement() const {
  return _has_bit(11);
}
inline void Statement::clear_create_schema_statement() {
  if (create_schema_statement_ != NULL) create_schema_statement_->::drizzled::message::CreateSchemaStatement::Clear();
  _clear_bit(11);
}
inline const ::drizzled::message::CreateSchemaStatement& Statement::create_schema_statement() const {
  return create_schema_statement_ != NULL ? *create_schema_statement_ : *default_instance_->create_schema_statement_;
}
inline ::drizzled::message::CreateSchemaStatement* Statement::mutable_create_schema_statement() {
  _set_bit(11);
  if (create_schema_statement_ == NULL) create_schema_statement_ = new ::drizzled::message::CreateSchemaStatement;
  return create_schema_statement_;
}

// optional .drizzled.message.DropSchemaStatement drop_schema_statement = 13;
inline bool Statement::has_drop_schema_statement() const {
  return _has_bit(12);
}
inline void Statement::clear_drop_schema_statement() {
  if (drop_schema_statement_ != NULL) drop_schema_statement_->::drizzled::message::DropSchemaStatement::Clear();
  _clear_bit(12);
}
inline const ::drizzled::message::DropSchemaStatement& Statement::drop_schema_statement() const {
  return drop_schema_statement_ != NULL ? *drop_schema_statement_ : *default_instance_->drop_schema_statement_;
}
inline ::drizzled::message::DropSchemaStatement* Statement::mutable_drop_schema_statement() {
  _set_bit(12);
  if (drop_schema_statement_ == NULL) drop_schema_statement_ = new ::drizzled::message::DropSchemaStatement;
  return drop_schema_statement_;
}

// optional .drizzled.message.AlterSchemaStatement alter_schema_statement = 14;
inline bool Statement::has_alter_schema_statement() const {
  return _has_bit(13);
}
inline void Statement::clear_alter_schema_statement() {
  if (alter_schema_statement_ != NULL) alter_schema_statement_->::drizzled::message::AlterSchemaStatement::Clear();
  _clear_bit(13);
}
inline const ::drizzled::message::AlterSchemaStatement& Statement::alter_schema_statement() const {
  return alter_schema_statement_ != NULL ? *alter_schema_statement_ : *default_instance_->alter_schema_statement_;
}
inline ::drizzled::message::AlterSchemaStatement* Statement::mutable_alter_schema_statement() {
  _set_bit(13);
  if (alter_schema_statement_ == NULL) alter_schema_statement_ = new ::drizzled::message::AlterSchemaStatement;
  return alter_schema_statement_;
}

// optional .drizzled.message.CreateTableStatement create_table_statement = 15;
inline bool Statement::has_create_table_statement() const {
  return _has_bit(14);
}
inline void Statement::clear_create_table_statement() {
  if (create_table_statement_ != NULL) create_table_statement_->::drizzled::message::CreateTableStatement::Clear();
  _clear_bit(14);
}
inline const ::drizzled::message::CreateTableStatement& Statement::create_table_statement() const {
  return create_table_statement_ != NULL ? *create_table_statement_ : *default_instance_->create_table_statement_;
}
inline ::drizzled::message::CreateTableStatement* Statement::mutable_create_table_statement() {
  _set_bit(14);
  if (create_table_statement_ == NULL) create_table_statement_ = new ::drizzled::message::CreateTableStatement;
  return create_table_statement_;
}

// optional .drizzled.message.AlterTableStatement alter_table_statement = 16;
inline bool Statement::has_alter_table_statement() const {
  return _has_bit(15);
}
inline void Statement::clear_alter_table_statement() {
  if (alter_table_statement_ != NULL) alter_table_statement_->::drizzled::message::AlterTableStatement::Clear();
  _clear_bit(15);
}
inline const ::drizzled::message::AlterTableStatement& Statement::alter_table_statement() const {
  return alter_table_statement_ != NULL ? *alter_table_statement_ : *default_instance_->alter_table_statement_;
}
inline ::drizzled::message::AlterTableStatement* Statement::mutable_alter_table_statement() {
  _set_bit(15);
  if (alter_table_statement_ == NULL) alter_table_statement_ = new ::drizzled::message::AlterTableStatement;
  return alter_table_statement_;
}

// optional .drizzled.message.DropTableStatement drop_table_statement = 17;
inline bool Statement::has_drop_table_statement() const {
  return _has_bit(16);
}
inline void Statement::clear_drop_table_statement() {
  if (drop_table_statement_ != NULL) drop_table_statement_->::drizzled::message::DropTableStatement::Clear();
  _clear_bit(16);
}
inline const ::drizzled::message::DropTableStatement& Statement::drop_table_statement() const {
  return drop_table_statement_ != NULL ? *drop_table_statement_ : *default_instance_->drop_table_statement_;
}
inline ::drizzled::message::DropTableStatement* Statement::mutable_drop_table_statement() {
  _set_bit(16);
  if (drop_table_statement_ == NULL) drop_table_statement_ = new ::drizzled::message::DropTableStatement;
  return drop_table_statement_;
}

// optional .drizzled.message.SetVariableStatement set_variable_statement = 18;
inline bool Statement::has_set_variable_statement() const {
  return _has_bit(17);
}
inline void Statement::clear_set_variable_statement() {
  if (set_variable_statement_ != NULL) set_variable_statement_->::drizzled::message::SetVariableStatement::Clear();
  _clear_bit(17);
}
inline const ::drizzled::message::SetVariableStatement& Statement::set_variable_statement() const {
  return set_variable_statement_ != NULL ? *set_variable_statement_ : *default_instance_->set_variable_statement_;
}
inline ::drizzled::message::SetVariableStatement* Statement::mutable_set_variable_statement() {
  _set_bit(17);
  if (set_variable_statement_ == NULL) set_variable_statement_ = new ::drizzled::message::SetVariableStatement;
  return set_variable_statement_;
}

// -------------------------------------------------------------------

// Transaction

// required .drizzled.message.TransactionContext transaction_context = 1;
inline bool Transaction::has_transaction_context() const {
  return _has_bit(0);
}
inline void Transaction::clear_transaction_context() {
  if (transaction_context_ != NULL) transaction_context_->::drizzled::message::TransactionContext::Clear();
  _clear_bit(0);
}
inline const ::drizzled::message::TransactionContext& Transaction::transaction_context() const {
  return transaction_context_ != NULL ? *transaction_context_ : *default_instance_->transaction_context_;
}
inline ::drizzled::message::TransactionContext* Transaction::mutable_transaction_context() {
  _set_bit(0);
  if (transaction_context_ == NULL) transaction_context_ = new ::drizzled::message::TransactionContext;
  return transaction_context_;
}

// repeated .drizzled.message.Statement statement = 2;
inline int Transaction::statement_size() const {
  return statement_.size();
}
inline void Transaction::clear_statement() {
  statement_.Clear();
}
inline const ::drizzled::message::Statement& Transaction::statement(int index) const {
  return statement_.Get(index);
}
inline ::drizzled::message::Statement* Transaction::mutable_statement(int index) {
  return statement_.Mutable(index);
}
inline ::drizzled::message::Statement* Transaction::add_statement() {
  return statement_.Add();
}
inline const ::google::protobuf::RepeatedPtrField< ::drizzled::message::Statement >&
Transaction::statement() const {
  return statement_;
}
inline ::google::protobuf::RepeatedPtrField< ::drizzled::message::Statement >*
Transaction::mutable_statement() {
  return &statement_;
}


// @@protoc_insertion_point(namespace_scope)

}  // namespace message
}  // namespace drizzled

#ifndef SWIG
namespace google {
namespace protobuf {

template <>
inline const EnumDescriptor* GetEnumDescriptor< ::drizzled::message::Statement_Type>() {
  return ::drizzled::message::Statement_Type_descriptor();
}

}  // namespace google
}  // namespace protobuf
#endif  // SWIG

// @@protoc_insertion_point(global_scope)

#endif  // PROTOBUF_transaction_2eproto__INCLUDED
