Drizzled Public API Documentation

transaction.pb.cc

00001 // Generated by the protocol buffer compiler.  DO NOT EDIT!
00002 
00003 #define INTERNAL_SUPPRESS_PROTOBUF_FIELD_DEPRECATION
00004 #include "transaction.pb.h"
00005 #include <google/protobuf/stubs/once.h>
00006 #include <google/protobuf/io/coded_stream.h>
00007 #include <google/protobuf/wire_format_lite_inl.h>
00008 #include <google/protobuf/descriptor.h>
00009 #include <google/protobuf/reflection_ops.h>
00010 #include <google/protobuf/wire_format.h>
00011 // @@protoc_insertion_point(includes)
00012 
00013 namespace drizzled {
00014 namespace message {
00015 
00016 namespace {
00017 
00018 const ::google::protobuf::Descriptor* FieldMetadata_descriptor_ = NULL;
00019 const ::google::protobuf::internal::GeneratedMessageReflection*
00020   FieldMetadata_reflection_ = NULL;
00021 const ::google::protobuf::Descriptor* TableMetadata_descriptor_ = NULL;
00022 const ::google::protobuf::internal::GeneratedMessageReflection*
00023   TableMetadata_reflection_ = NULL;
00024 const ::google::protobuf::Descriptor* TransactionContext_descriptor_ = NULL;
00025 const ::google::protobuf::internal::GeneratedMessageReflection*
00026   TransactionContext_reflection_ = NULL;
00027 const ::google::protobuf::Descriptor* InsertRecord_descriptor_ = NULL;
00028 const ::google::protobuf::internal::GeneratedMessageReflection*
00029   InsertRecord_reflection_ = NULL;
00030 const ::google::protobuf::Descriptor* InsertHeader_descriptor_ = NULL;
00031 const ::google::protobuf::internal::GeneratedMessageReflection*
00032   InsertHeader_reflection_ = NULL;
00033 const ::google::protobuf::Descriptor* InsertData_descriptor_ = NULL;
00034 const ::google::protobuf::internal::GeneratedMessageReflection*
00035   InsertData_reflection_ = NULL;
00036 const ::google::protobuf::Descriptor* UpdateRecord_descriptor_ = NULL;
00037 const ::google::protobuf::internal::GeneratedMessageReflection*
00038   UpdateRecord_reflection_ = NULL;
00039 const ::google::protobuf::Descriptor* UpdateHeader_descriptor_ = NULL;
00040 const ::google::protobuf::internal::GeneratedMessageReflection*
00041   UpdateHeader_reflection_ = NULL;
00042 const ::google::protobuf::Descriptor* UpdateData_descriptor_ = NULL;
00043 const ::google::protobuf::internal::GeneratedMessageReflection*
00044   UpdateData_reflection_ = NULL;
00045 const ::google::protobuf::Descriptor* DeleteRecord_descriptor_ = NULL;
00046 const ::google::protobuf::internal::GeneratedMessageReflection*
00047   DeleteRecord_reflection_ = NULL;
00048 const ::google::protobuf::Descriptor* DeleteHeader_descriptor_ = NULL;
00049 const ::google::protobuf::internal::GeneratedMessageReflection*
00050   DeleteHeader_reflection_ = NULL;
00051 const ::google::protobuf::Descriptor* DeleteData_descriptor_ = NULL;
00052 const ::google::protobuf::internal::GeneratedMessageReflection*
00053   DeleteData_reflection_ = NULL;
00054 const ::google::protobuf::Descriptor* TruncateTableStatement_descriptor_ = NULL;
00055 const ::google::protobuf::internal::GeneratedMessageReflection*
00056   TruncateTableStatement_reflection_ = NULL;
00057 const ::google::protobuf::Descriptor* CreateSchemaStatement_descriptor_ = NULL;
00058 const ::google::protobuf::internal::GeneratedMessageReflection*
00059   CreateSchemaStatement_reflection_ = NULL;
00060 const ::google::protobuf::Descriptor* AlterSchemaStatement_descriptor_ = NULL;
00061 const ::google::protobuf::internal::GeneratedMessageReflection*
00062   AlterSchemaStatement_reflection_ = NULL;
00063 const ::google::protobuf::Descriptor* DropSchemaStatement_descriptor_ = NULL;
00064 const ::google::protobuf::internal::GeneratedMessageReflection*
00065   DropSchemaStatement_reflection_ = NULL;
00066 const ::google::protobuf::Descriptor* CreateTableStatement_descriptor_ = NULL;
00067 const ::google::protobuf::internal::GeneratedMessageReflection*
00068   CreateTableStatement_reflection_ = NULL;
00069 const ::google::protobuf::Descriptor* AlterTableStatement_descriptor_ = NULL;
00070 const ::google::protobuf::internal::GeneratedMessageReflection*
00071   AlterTableStatement_reflection_ = NULL;
00072 const ::google::protobuf::Descriptor* DropTableStatement_descriptor_ = NULL;
00073 const ::google::protobuf::internal::GeneratedMessageReflection*
00074   DropTableStatement_reflection_ = NULL;
00075 const ::google::protobuf::Descriptor* SetVariableStatement_descriptor_ = NULL;
00076 const ::google::protobuf::internal::GeneratedMessageReflection*
00077   SetVariableStatement_reflection_ = NULL;
00078 const ::google::protobuf::Descriptor* Statement_descriptor_ = NULL;
00079 const ::google::protobuf::internal::GeneratedMessageReflection*
00080   Statement_reflection_ = NULL;
00081 const ::google::protobuf::EnumDescriptor* Statement_Type_descriptor_ = NULL;
00082 const ::google::protobuf::Descriptor* Transaction_descriptor_ = NULL;
00083 const ::google::protobuf::internal::GeneratedMessageReflection*
00084   Transaction_reflection_ = NULL;
00085 
00086 }  // namespace
00087 
00088 
00089 void protobuf_AssignDesc_transaction_2eproto() {
00090   protobuf_AddDesc_transaction_2eproto();
00091   const ::google::protobuf::FileDescriptor* file =
00092     ::google::protobuf::DescriptorPool::generated_pool()->FindFileByName(
00093       "transaction.proto");
00094   GOOGLE_CHECK(file != NULL);
00095   FieldMetadata_descriptor_ = file->message_type(0);
00096   static const int FieldMetadata_offsets_[2] = {
00097     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMetadata, type_),
00098     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMetadata, name_),
00099   };
00100   FieldMetadata_reflection_ =
00101     new ::google::protobuf::internal::GeneratedMessageReflection(
00102       FieldMetadata_descriptor_,
00103       FieldMetadata::default_instance_,
00104       FieldMetadata_offsets_,
00105       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMetadata, _has_bits_[0]),
00106       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(FieldMetadata, _unknown_fields_),
00107       -1,
00108       ::google::protobuf::DescriptorPool::generated_pool(),
00109       ::google::protobuf::MessageFactory::generated_factory(),
00110       sizeof(FieldMetadata));
00111   TableMetadata_descriptor_ = file->message_type(1);
00112   static const int TableMetadata_offsets_[3] = {
00113     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMetadata, schema_name_),
00114     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMetadata, table_name_),
00115     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMetadata, catalog_name_),
00116   };
00117   TableMetadata_reflection_ =
00118     new ::google::protobuf::internal::GeneratedMessageReflection(
00119       TableMetadata_descriptor_,
00120       TableMetadata::default_instance_,
00121       TableMetadata_offsets_,
00122       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMetadata, _has_bits_[0]),
00123       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TableMetadata, _unknown_fields_),
00124       -1,
00125       ::google::protobuf::DescriptorPool::generated_pool(),
00126       ::google::protobuf::MessageFactory::generated_factory(),
00127       sizeof(TableMetadata));
00128   TransactionContext_descriptor_ = file->message_type(2);
00129   static const int TransactionContext_offsets_[4] = {
00130     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransactionContext, server_id_),
00131     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransactionContext, transaction_id_),
00132     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransactionContext, start_timestamp_),
00133     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransactionContext, end_timestamp_),
00134   };
00135   TransactionContext_reflection_ =
00136     new ::google::protobuf::internal::GeneratedMessageReflection(
00137       TransactionContext_descriptor_,
00138       TransactionContext::default_instance_,
00139       TransactionContext_offsets_,
00140       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransactionContext, _has_bits_[0]),
00141       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TransactionContext, _unknown_fields_),
00142       -1,
00143       ::google::protobuf::DescriptorPool::generated_pool(),
00144       ::google::protobuf::MessageFactory::generated_factory(),
00145       sizeof(TransactionContext));
00146   InsertRecord_descriptor_ = file->message_type(3);
00147   static const int InsertRecord_offsets_[2] = {
00148     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertRecord, insert_value_),
00149     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertRecord, is_null_),
00150   };
00151   InsertRecord_reflection_ =
00152     new ::google::protobuf::internal::GeneratedMessageReflection(
00153       InsertRecord_descriptor_,
00154       InsertRecord::default_instance_,
00155       InsertRecord_offsets_,
00156       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertRecord, _has_bits_[0]),
00157       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertRecord, _unknown_fields_),
00158       -1,
00159       ::google::protobuf::DescriptorPool::generated_pool(),
00160       ::google::protobuf::MessageFactory::generated_factory(),
00161       sizeof(InsertRecord));
00162   InsertHeader_descriptor_ = file->message_type(4);
00163   static const int InsertHeader_offsets_[2] = {
00164     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertHeader, table_metadata_),
00165     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertHeader, field_metadata_),
00166   };
00167   InsertHeader_reflection_ =
00168     new ::google::protobuf::internal::GeneratedMessageReflection(
00169       InsertHeader_descriptor_,
00170       InsertHeader::default_instance_,
00171       InsertHeader_offsets_,
00172       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertHeader, _has_bits_[0]),
00173       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertHeader, _unknown_fields_),
00174       -1,
00175       ::google::protobuf::DescriptorPool::generated_pool(),
00176       ::google::protobuf::MessageFactory::generated_factory(),
00177       sizeof(InsertHeader));
00178   InsertData_descriptor_ = file->message_type(5);
00179   static const int InsertData_offsets_[3] = {
00180     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertData, segment_id_),
00181     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertData, end_segment_),
00182     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertData, record_),
00183   };
00184   InsertData_reflection_ =
00185     new ::google::protobuf::internal::GeneratedMessageReflection(
00186       InsertData_descriptor_,
00187       InsertData::default_instance_,
00188       InsertData_offsets_,
00189       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertData, _has_bits_[0]),
00190       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(InsertData, _unknown_fields_),
00191       -1,
00192       ::google::protobuf::DescriptorPool::generated_pool(),
00193       ::google::protobuf::MessageFactory::generated_factory(),
00194       sizeof(InsertData));
00195   UpdateRecord_descriptor_ = file->message_type(6);
00196   static const int UpdateRecord_offsets_[4] = {
00197     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRecord, key_value_),
00198     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRecord, after_value_),
00199     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRecord, before_value_),
00200     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRecord, is_null_),
00201   };
00202   UpdateRecord_reflection_ =
00203     new ::google::protobuf::internal::GeneratedMessageReflection(
00204       UpdateRecord_descriptor_,
00205       UpdateRecord::default_instance_,
00206       UpdateRecord_offsets_,
00207       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRecord, _has_bits_[0]),
00208       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateRecord, _unknown_fields_),
00209       -1,
00210       ::google::protobuf::DescriptorPool::generated_pool(),
00211       ::google::protobuf::MessageFactory::generated_factory(),
00212       sizeof(UpdateRecord));
00213   UpdateHeader_descriptor_ = file->message_type(7);
00214   static const int UpdateHeader_offsets_[3] = {
00215     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateHeader, table_metadata_),
00216     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateHeader, key_field_metadata_),
00217     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateHeader, set_field_metadata_),
00218   };
00219   UpdateHeader_reflection_ =
00220     new ::google::protobuf::internal::GeneratedMessageReflection(
00221       UpdateHeader_descriptor_,
00222       UpdateHeader::default_instance_,
00223       UpdateHeader_offsets_,
00224       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateHeader, _has_bits_[0]),
00225       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateHeader, _unknown_fields_),
00226       -1,
00227       ::google::protobuf::DescriptorPool::generated_pool(),
00228       ::google::protobuf::MessageFactory::generated_factory(),
00229       sizeof(UpdateHeader));
00230   UpdateData_descriptor_ = file->message_type(8);
00231   static const int UpdateData_offsets_[3] = {
00232     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateData, segment_id_),
00233     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateData, end_segment_),
00234     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateData, record_),
00235   };
00236   UpdateData_reflection_ =
00237     new ::google::protobuf::internal::GeneratedMessageReflection(
00238       UpdateData_descriptor_,
00239       UpdateData::default_instance_,
00240       UpdateData_offsets_,
00241       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateData, _has_bits_[0]),
00242       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(UpdateData, _unknown_fields_),
00243       -1,
00244       ::google::protobuf::DescriptorPool::generated_pool(),
00245       ::google::protobuf::MessageFactory::generated_factory(),
00246       sizeof(UpdateData));
00247   DeleteRecord_descriptor_ = file->message_type(9);
00248   static const int DeleteRecord_offsets_[1] = {
00249     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteRecord, key_value_),
00250   };
00251   DeleteRecord_reflection_ =
00252     new ::google::protobuf::internal::GeneratedMessageReflection(
00253       DeleteRecord_descriptor_,
00254       DeleteRecord::default_instance_,
00255       DeleteRecord_offsets_,
00256       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteRecord, _has_bits_[0]),
00257       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteRecord, _unknown_fields_),
00258       -1,
00259       ::google::protobuf::DescriptorPool::generated_pool(),
00260       ::google::protobuf::MessageFactory::generated_factory(),
00261       sizeof(DeleteRecord));
00262   DeleteHeader_descriptor_ = file->message_type(10);
00263   static const int DeleteHeader_offsets_[2] = {
00264     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteHeader, table_metadata_),
00265     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteHeader, key_field_metadata_),
00266   };
00267   DeleteHeader_reflection_ =
00268     new ::google::protobuf::internal::GeneratedMessageReflection(
00269       DeleteHeader_descriptor_,
00270       DeleteHeader::default_instance_,
00271       DeleteHeader_offsets_,
00272       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteHeader, _has_bits_[0]),
00273       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteHeader, _unknown_fields_),
00274       -1,
00275       ::google::protobuf::DescriptorPool::generated_pool(),
00276       ::google::protobuf::MessageFactory::generated_factory(),
00277       sizeof(DeleteHeader));
00278   DeleteData_descriptor_ = file->message_type(11);
00279   static const int DeleteData_offsets_[3] = {
00280     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteData, segment_id_),
00281     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteData, end_segment_),
00282     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteData, record_),
00283   };
00284   DeleteData_reflection_ =
00285     new ::google::protobuf::internal::GeneratedMessageReflection(
00286       DeleteData_descriptor_,
00287       DeleteData::default_instance_,
00288       DeleteData_offsets_,
00289       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteData, _has_bits_[0]),
00290       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DeleteData, _unknown_fields_),
00291       -1,
00292       ::google::protobuf::DescriptorPool::generated_pool(),
00293       ::google::protobuf::MessageFactory::generated_factory(),
00294       sizeof(DeleteData));
00295   TruncateTableStatement_descriptor_ = file->message_type(12);
00296   static const int TruncateTableStatement_offsets_[1] = {
00297     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateTableStatement, table_metadata_),
00298   };
00299   TruncateTableStatement_reflection_ =
00300     new ::google::protobuf::internal::GeneratedMessageReflection(
00301       TruncateTableStatement_descriptor_,
00302       TruncateTableStatement::default_instance_,
00303       TruncateTableStatement_offsets_,
00304       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateTableStatement, _has_bits_[0]),
00305       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(TruncateTableStatement, _unknown_fields_),
00306       -1,
00307       ::google::protobuf::DescriptorPool::generated_pool(),
00308       ::google::protobuf::MessageFactory::generated_factory(),
00309       sizeof(TruncateTableStatement));
00310   CreateSchemaStatement_descriptor_ = file->message_type(13);
00311   static const int CreateSchemaStatement_offsets_[1] = {
00312     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateSchemaStatement, schema_),
00313   };
00314   CreateSchemaStatement_reflection_ =
00315     new ::google::protobuf::internal::GeneratedMessageReflection(
00316       CreateSchemaStatement_descriptor_,
00317       CreateSchemaStatement::default_instance_,
00318       CreateSchemaStatement_offsets_,
00319       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateSchemaStatement, _has_bits_[0]),
00320       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateSchemaStatement, _unknown_fields_),
00321       -1,
00322       ::google::protobuf::DescriptorPool::generated_pool(),
00323       ::google::protobuf::MessageFactory::generated_factory(),
00324       sizeof(CreateSchemaStatement));
00325   AlterSchemaStatement_descriptor_ = file->message_type(14);
00326   static const int AlterSchemaStatement_offsets_[2] = {
00327     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AlterSchemaStatement, before_),
00328     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AlterSchemaStatement, after_),
00329   };
00330   AlterSchemaStatement_reflection_ =
00331     new ::google::protobuf::internal::GeneratedMessageReflection(
00332       AlterSchemaStatement_descriptor_,
00333       AlterSchemaStatement::default_instance_,
00334       AlterSchemaStatement_offsets_,
00335       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AlterSchemaStatement, _has_bits_[0]),
00336       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AlterSchemaStatement, _unknown_fields_),
00337       -1,
00338       ::google::protobuf::DescriptorPool::generated_pool(),
00339       ::google::protobuf::MessageFactory::generated_factory(),
00340       sizeof(AlterSchemaStatement));
00341   DropSchemaStatement_descriptor_ = file->message_type(15);
00342   static const int DropSchemaStatement_offsets_[2] = {
00343     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropSchemaStatement, schema_name_),
00344     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropSchemaStatement, catalog_name_),
00345   };
00346   DropSchemaStatement_reflection_ =
00347     new ::google::protobuf::internal::GeneratedMessageReflection(
00348       DropSchemaStatement_descriptor_,
00349       DropSchemaStatement::default_instance_,
00350       DropSchemaStatement_offsets_,
00351       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropSchemaStatement, _has_bits_[0]),
00352       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropSchemaStatement, _unknown_fields_),
00353       -1,
00354       ::google::protobuf::DescriptorPool::generated_pool(),
00355       ::google::protobuf::MessageFactory::generated_factory(),
00356       sizeof(DropSchemaStatement));
00357   CreateTableStatement_descriptor_ = file->message_type(16);
00358   static const int CreateTableStatement_offsets_[1] = {
00359     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTableStatement, table_),
00360   };
00361   CreateTableStatement_reflection_ =
00362     new ::google::protobuf::internal::GeneratedMessageReflection(
00363       CreateTableStatement_descriptor_,
00364       CreateTableStatement::default_instance_,
00365       CreateTableStatement_offsets_,
00366       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTableStatement, _has_bits_[0]),
00367       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(CreateTableStatement, _unknown_fields_),
00368       -1,
00369       ::google::protobuf::DescriptorPool::generated_pool(),
00370       ::google::protobuf::MessageFactory::generated_factory(),
00371       sizeof(CreateTableStatement));
00372   AlterTableStatement_descriptor_ = file->message_type(17);
00373   static const int AlterTableStatement_offsets_[2] = {
00374     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AlterTableStatement, before_),
00375     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AlterTableStatement, after_),
00376   };
00377   AlterTableStatement_reflection_ =
00378     new ::google::protobuf::internal::GeneratedMessageReflection(
00379       AlterTableStatement_descriptor_,
00380       AlterTableStatement::default_instance_,
00381       AlterTableStatement_offsets_,
00382       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AlterTableStatement, _has_bits_[0]),
00383       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(AlterTableStatement, _unknown_fields_),
00384       -1,
00385       ::google::protobuf::DescriptorPool::generated_pool(),
00386       ::google::protobuf::MessageFactory::generated_factory(),
00387       sizeof(AlterTableStatement));
00388   DropTableStatement_descriptor_ = file->message_type(18);
00389   static const int DropTableStatement_offsets_[2] = {
00390     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropTableStatement, table_metadata_),
00391     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropTableStatement, if_exists_clause_),
00392   };
00393   DropTableStatement_reflection_ =
00394     new ::google::protobuf::internal::GeneratedMessageReflection(
00395       DropTableStatement_descriptor_,
00396       DropTableStatement::default_instance_,
00397       DropTableStatement_offsets_,
00398       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropTableStatement, _has_bits_[0]),
00399       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(DropTableStatement, _unknown_fields_),
00400       -1,
00401       ::google::protobuf::DescriptorPool::generated_pool(),
00402       ::google::protobuf::MessageFactory::generated_factory(),
00403       sizeof(DropTableStatement));
00404   SetVariableStatement_descriptor_ = file->message_type(19);
00405   static const int SetVariableStatement_offsets_[2] = {
00406     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetVariableStatement, variable_metadata_),
00407     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetVariableStatement, variable_value_),
00408   };
00409   SetVariableStatement_reflection_ =
00410     new ::google::protobuf::internal::GeneratedMessageReflection(
00411       SetVariableStatement_descriptor_,
00412       SetVariableStatement::default_instance_,
00413       SetVariableStatement_offsets_,
00414       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetVariableStatement, _has_bits_[0]),
00415       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(SetVariableStatement, _unknown_fields_),
00416       -1,
00417       ::google::protobuf::DescriptorPool::generated_pool(),
00418       ::google::protobuf::MessageFactory::generated_factory(),
00419       sizeof(SetVariableStatement));
00420   Statement_descriptor_ = file->message_type(20);
00421   static const int Statement_offsets_[19] = {
00422     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, type_),
00423     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, start_timestamp_),
00424     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, end_timestamp_),
00425     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, sql_),
00426     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, insert_header_),
00427     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, insert_data_),
00428     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, update_header_),
00429     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, update_data_),
00430     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, delete_header_),
00431     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, delete_data_),
00432     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, truncate_table_statement_),
00433     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, create_schema_statement_),
00434     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, drop_schema_statement_),
00435     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, alter_schema_statement_),
00436     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, create_table_statement_),
00437     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, alter_table_statement_),
00438     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, drop_table_statement_),
00439     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, set_variable_statement_),
00440     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, raw_sql_schema_),
00441   };
00442   Statement_reflection_ =
00443     new ::google::protobuf::internal::GeneratedMessageReflection(
00444       Statement_descriptor_,
00445       Statement::default_instance_,
00446       Statement_offsets_,
00447       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, _has_bits_[0]),
00448       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Statement, _unknown_fields_),
00449       -1,
00450       ::google::protobuf::DescriptorPool::generated_pool(),
00451       ::google::protobuf::MessageFactory::generated_factory(),
00452       sizeof(Statement));
00453   Statement_Type_descriptor_ = Statement_descriptor_->enum_type(0);
00454   Transaction_descriptor_ = file->message_type(21);
00455   static const int Transaction_offsets_[5] = {
00456     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Transaction, transaction_context_),
00457     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Transaction, statement_),
00458     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Transaction, event_),
00459     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Transaction, segment_id_),
00460     GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Transaction, end_segment_),
00461   };
00462   Transaction_reflection_ =
00463     new ::google::protobuf::internal::GeneratedMessageReflection(
00464       Transaction_descriptor_,
00465       Transaction::default_instance_,
00466       Transaction_offsets_,
00467       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Transaction, _has_bits_[0]),
00468       GOOGLE_PROTOBUF_GENERATED_MESSAGE_FIELD_OFFSET(Transaction, _unknown_fields_),
00469       -1,
00470       ::google::protobuf::DescriptorPool::generated_pool(),
00471       ::google::protobuf::MessageFactory::generated_factory(),
00472       sizeof(Transaction));
00473 }
00474 
00475 namespace {
00476 
00477 GOOGLE_PROTOBUF_DECLARE_ONCE(protobuf_AssignDescriptors_once_);
00478 inline void protobuf_AssignDescriptorsOnce() {
00479   ::google::protobuf::GoogleOnceInit(&protobuf_AssignDescriptors_once_,
00480                  &protobuf_AssignDesc_transaction_2eproto);
00481 }
00482 
00483 void protobuf_RegisterTypes(const ::std::string&) {
00484   protobuf_AssignDescriptorsOnce();
00485   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00486     FieldMetadata_descriptor_, &FieldMetadata::default_instance());
00487   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00488     TableMetadata_descriptor_, &TableMetadata::default_instance());
00489   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00490     TransactionContext_descriptor_, &TransactionContext::default_instance());
00491   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00492     InsertRecord_descriptor_, &InsertRecord::default_instance());
00493   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00494     InsertHeader_descriptor_, &InsertHeader::default_instance());
00495   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00496     InsertData_descriptor_, &InsertData::default_instance());
00497   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00498     UpdateRecord_descriptor_, &UpdateRecord::default_instance());
00499   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00500     UpdateHeader_descriptor_, &UpdateHeader::default_instance());
00501   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00502     UpdateData_descriptor_, &UpdateData::default_instance());
00503   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00504     DeleteRecord_descriptor_, &DeleteRecord::default_instance());
00505   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00506     DeleteHeader_descriptor_, &DeleteHeader::default_instance());
00507   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00508     DeleteData_descriptor_, &DeleteData::default_instance());
00509   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00510     TruncateTableStatement_descriptor_, &TruncateTableStatement::default_instance());
00511   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00512     CreateSchemaStatement_descriptor_, &CreateSchemaStatement::default_instance());
00513   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00514     AlterSchemaStatement_descriptor_, &AlterSchemaStatement::default_instance());
00515   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00516     DropSchemaStatement_descriptor_, &DropSchemaStatement::default_instance());
00517   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00518     CreateTableStatement_descriptor_, &CreateTableStatement::default_instance());
00519   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00520     AlterTableStatement_descriptor_, &AlterTableStatement::default_instance());
00521   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00522     DropTableStatement_descriptor_, &DropTableStatement::default_instance());
00523   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00524     SetVariableStatement_descriptor_, &SetVariableStatement::default_instance());
00525   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00526     Statement_descriptor_, &Statement::default_instance());
00527   ::google::protobuf::MessageFactory::InternalRegisterGeneratedMessage(
00528     Transaction_descriptor_, &Transaction::default_instance());
00529 }
00530 
00531 }  // namespace
00532 
00533 void protobuf_ShutdownFile_transaction_2eproto() {
00534   delete FieldMetadata::default_instance_;
00535   delete FieldMetadata_reflection_;
00536   delete TableMetadata::default_instance_;
00537   delete TableMetadata_reflection_;
00538   delete TransactionContext::default_instance_;
00539   delete TransactionContext_reflection_;
00540   delete InsertRecord::default_instance_;
00541   delete InsertRecord_reflection_;
00542   delete InsertHeader::default_instance_;
00543   delete InsertHeader_reflection_;
00544   delete InsertData::default_instance_;
00545   delete InsertData_reflection_;
00546   delete UpdateRecord::default_instance_;
00547   delete UpdateRecord_reflection_;
00548   delete UpdateHeader::default_instance_;
00549   delete UpdateHeader_reflection_;
00550   delete UpdateData::default_instance_;
00551   delete UpdateData_reflection_;
00552   delete DeleteRecord::default_instance_;
00553   delete DeleteRecord_reflection_;
00554   delete DeleteHeader::default_instance_;
00555   delete DeleteHeader_reflection_;
00556   delete DeleteData::default_instance_;
00557   delete DeleteData_reflection_;
00558   delete TruncateTableStatement::default_instance_;
00559   delete TruncateTableStatement_reflection_;
00560   delete CreateSchemaStatement::default_instance_;
00561   delete CreateSchemaStatement_reflection_;
00562   delete AlterSchemaStatement::default_instance_;
00563   delete AlterSchemaStatement_reflection_;
00564   delete DropSchemaStatement::default_instance_;
00565   delete DropSchemaStatement_reflection_;
00566   delete CreateTableStatement::default_instance_;
00567   delete CreateTableStatement_reflection_;
00568   delete AlterTableStatement::default_instance_;
00569   delete AlterTableStatement_reflection_;
00570   delete DropTableStatement::default_instance_;
00571   delete DropTableStatement_reflection_;
00572   delete SetVariableStatement::default_instance_;
00573   delete SetVariableStatement_reflection_;
00574   delete Statement::default_instance_;
00575   delete Statement_reflection_;
00576   delete Transaction::default_instance_;
00577   delete Transaction_reflection_;
00578 }
00579 
00580 void protobuf_AddDesc_transaction_2eproto() {
00581   static bool already_here = false;
00582   if (already_here) return;
00583   already_here = true;
00584   GOOGLE_PROTOBUF_VERIFY_VERSION;
00585 
00586   ::drizzled::message::protobuf_AddDesc_table_2eproto();
00587   ::drizzled::message::protobuf_AddDesc_schema_2eproto();
00588   ::drizzled::message::protobuf_AddDesc_event_2eproto();
00589   ::google::protobuf::DescriptorPool::InternalAddGeneratedFile(
00590     "\n\021transaction.proto\022\020drizzled.message\032\013t"
00591     "able.proto\032\014schema.proto\032\013event.proto\"T\n"
00592     "\rFieldMetadata\0225\n\004type\030\001 \002(\0162\'.drizzled."
00593     "message.Table.Field.FieldType\022\014\n\004name\030\002 "
00594     "\002(\t\"N\n\rTableMetadata\022\023\n\013schema_name\030\001 \002("
00595     "\t\022\022\n\ntable_name\030\002 \002(\t\022\024\n\014catalog_name\030\003 "
00596     "\001(\t\"o\n\022TransactionContext\022\021\n\tserver_id\030\001"
00597     " \002(\r\022\026\n\016transaction_id\030\002 \002(\004\022\027\n\017start_ti"
00598     "mestamp\030\003 \002(\004\022\025\n\rend_timestamp\030\004 \002(\004\"5\n\014"
00599     "InsertRecord\022\024\n\014insert_value\030\001 \003(\014\022\017\n\007is"
00600     "_null\030\002 \003(\010\"\200\001\n\014InsertHeader\0227\n\016table_me"
00601     "tadata\030\001 \002(\0132\037.drizzled.message.TableMet"
00602     "adata\0227\n\016field_metadata\030\002 \003(\0132\037.drizzled"
00603     ".message.FieldMetadata\"e\n\nInsertData\022\022\n\n"
00604     "segment_id\030\001 \002(\r\022\023\n\013end_segment\030\002 \002(\010\022.\n"
00605     "\006record\030\003 \003(\0132\036.drizzled.message.InsertR"
00606     "ecord\"]\n\014UpdateRecord\022\021\n\tkey_value\030\001 \003(\014"
00607     "\022\023\n\013after_value\030\002 \003(\014\022\024\n\014before_value\030\003 "
00608     "\003(\014\022\017\n\007is_null\030\004 \003(\010\"\301\001\n\014UpdateHeader\0227\n"
00609     "\016table_metadata\030\001 \002(\0132\037.drizzled.message"
00610     ".TableMetadata\022;\n\022key_field_metadata\030\002 \003"
00611     "(\0132\037.drizzled.message.FieldMetadata\022;\n\022s"
00612     "et_field_metadata\030\003 \003(\0132\037.drizzled.messa"
00613     "ge.FieldMetadata\"e\n\nUpdateData\022\022\n\nsegmen"
00614     "t_id\030\001 \002(\r\022\023\n\013end_segment\030\002 \002(\010\022.\n\006recor"
00615     "d\030\003 \003(\0132\036.drizzled.message.UpdateRecord\""
00616     "!\n\014DeleteRecord\022\021\n\tkey_value\030\001 \003(\014\"\204\001\n\014D"
00617     "eleteHeader\0227\n\016table_metadata\030\001 \002(\0132\037.dr"
00618     "izzled.message.TableMetadata\022;\n\022key_fiel"
00619     "d_metadata\030\002 \003(\0132\037.drizzled.message.Fiel"
00620     "dMetadata\"e\n\nDeleteData\022\022\n\nsegment_id\030\001 "
00621     "\002(\r\022\023\n\013end_segment\030\002 \002(\010\022.\n\006record\030\003 \003(\013"
00622     "2\036.drizzled.message.DeleteRecord\"Q\n\026Trun"
00623     "cateTableStatement\0227\n\016table_metadata\030\001 \002"
00624     "(\0132\037.drizzled.message.TableMetadata\"A\n\025C"
00625     "reateSchemaStatement\022(\n\006schema\030\001 \002(\0132\030.d"
00626     "rizzled.message.Schema\"i\n\024AlterSchemaSta"
00627     "tement\022(\n\006before\030\001 \002(\0132\030.drizzled.messag"
00628     "e.Schema\022\'\n\005after\030\002 \002(\0132\030.drizzled.messa"
00629     "ge.Schema\"@\n\023DropSchemaStatement\022\023\n\013sche"
00630     "ma_name\030\001 \002(\t\022\024\n\014catalog_name\030\002 \001(\t\">\n\024C"
00631     "reateTableStatement\022&\n\005table\030\001 \002(\0132\027.dri"
00632     "zzled.message.Table\"f\n\023AlterTableStateme"
00633     "nt\022\'\n\006before\030\001 \002(\0132\027.drizzled.message.Ta"
00634     "ble\022&\n\005after\030\002 \002(\0132\027.drizzled.message.Ta"
00635     "ble\"g\n\022DropTableStatement\0227\n\016table_metad"
00636     "ata\030\001 \002(\0132\037.drizzled.message.TableMetada"
00637     "ta\022\030\n\020if_exists_clause\030\002 \001(\010\"j\n\024SetVaria"
00638     "bleStatement\022:\n\021variable_metadata\030\001 \002(\0132"
00639     "\037.drizzled.message.FieldMetadata\022\026\n\016vari"
00640     "able_value\030\002 \002(\014\"\373\t\n\tStatement\022.\n\004type\030\001"
00641     " \002(\0162 .drizzled.message.Statement.Type\022\027"
00642     "\n\017start_timestamp\030\002 \002(\004\022\025\n\rend_timestamp"
00643     "\030\003 \002(\004\022\013\n\003sql\030\004 \001(\t\0225\n\rinsert_header\030\005 \001"
00644     "(\0132\036.drizzled.message.InsertHeader\0221\n\013in"
00645     "sert_data\030\006 \001(\0132\034.drizzled.message.Inser"
00646     "tData\0225\n\rupdate_header\030\007 \001(\0132\036.drizzled."
00647     "message.UpdateHeader\0221\n\013update_data\030\010 \001("
00648     "\0132\034.drizzled.message.UpdateData\0225\n\rdelet"
00649     "e_header\030\t \001(\0132\036.drizzled.message.Delete"
00650     "Header\0221\n\013delete_data\030\n \001(\0132\034.drizzled.m"
00651     "essage.DeleteData\022J\n\030truncate_table_stat"
00652     "ement\030\013 \001(\0132(.drizzled.message.TruncateT"
00653     "ableStatement\022H\n\027create_schema_statement"
00654     "\030\014 \001(\0132\'.drizzled.message.CreateSchemaSt"
00655     "atement\022D\n\025drop_schema_statement\030\r \001(\0132%"
00656     ".drizzled.message.DropSchemaStatement\022F\n"
00657     "\026alter_schema_statement\030\016 \001(\0132&.drizzled"
00658     ".message.AlterSchemaStatement\022F\n\026create_"
00659     "table_statement\030\017 \001(\0132&.drizzled.message"
00660     ".CreateTableStatement\022D\n\025alter_table_sta"
00661     "tement\030\020 \001(\0132%.drizzled.message.AlterTab"
00662     "leStatement\022B\n\024drop_table_statement\030\021 \001("
00663     "\0132$.drizzled.message.DropTableStatement\022"
00664     "F\n\026set_variable_statement\030\022 \001(\0132&.drizzl"
00665     "ed.message.SetVariableStatement\022\026\n\016raw_s"
00666     "ql_schema\030\023 \001(\t\"\354\001\n\004Type\022\014\n\010ROLLBACK\020\000\022\n"
00667     "\n\006INSERT\020\001\022\n\n\006DELETE\020\002\022\n\n\006UPDATE\020\003\022\022\n\016TR"
00668     "UNCATE_TABLE\020\004\022\021\n\rCREATE_SCHEMA\020\005\022\020\n\014ALT"
00669     "ER_SCHEMA\020\006\022\017\n\013DROP_SCHEMA\020\007\022\020\n\014CREATE_T"
00670     "ABLE\020\010\022\017\n\013ALTER_TABLE\020\t\022\016\n\nDROP_TABLE\020\n\022"
00671     "\026\n\022ROLLBACK_STATEMENT\020\013\022\020\n\014SET_VARIABLE\020"
00672     "b\022\013\n\007RAW_SQL\020c\"\321\001\n\013Transaction\022A\n\023transa"
00673     "ction_context\030\001 \002(\0132$.drizzled.message.T"
00674     "ransactionContext\022.\n\tstatement\030\002 \003(\0132\033.d"
00675     "rizzled.message.Statement\022&\n\005event\030\003 \001(\013"
00676     "2\027.drizzled.message.Event\022\022\n\nsegment_id\030"
00677     "\004 \001(\r\022\023\n\013end_segment\030\005 \001(\010B,\n\024org.drizzl"
00678     "e.messagesB\022TransactionMessageH\001", 3552);
00679   ::google::protobuf::MessageFactory::InternalRegisterGeneratedFile(
00680     "transaction.proto", &protobuf_RegisterTypes);
00681   FieldMetadata::default_instance_ = new FieldMetadata();
00682   TableMetadata::default_instance_ = new TableMetadata();
00683   TransactionContext::default_instance_ = new TransactionContext();
00684   InsertRecord::default_instance_ = new InsertRecord();
00685   InsertHeader::default_instance_ = new InsertHeader();
00686   InsertData::default_instance_ = new InsertData();
00687   UpdateRecord::default_instance_ = new UpdateRecord();
00688   UpdateHeader::default_instance_ = new UpdateHeader();
00689   UpdateData::default_instance_ = new UpdateData();
00690   DeleteRecord::default_instance_ = new DeleteRecord();
00691   DeleteHeader::default_instance_ = new DeleteHeader();
00692   DeleteData::default_instance_ = new DeleteData();
00693   TruncateTableStatement::default_instance_ = new TruncateTableStatement();
00694   CreateSchemaStatement::default_instance_ = new CreateSchemaStatement();
00695   AlterSchemaStatement::default_instance_ = new AlterSchemaStatement();
00696   DropSchemaStatement::default_instance_ = new DropSchemaStatement();
00697   CreateTableStatement::default_instance_ = new CreateTableStatement();
00698   AlterTableStatement::default_instance_ = new AlterTableStatement();
00699   DropTableStatement::default_instance_ = new DropTableStatement();
00700   SetVariableStatement::default_instance_ = new SetVariableStatement();
00701   Statement::default_instance_ = new Statement();
00702   Transaction::default_instance_ = new Transaction();
00703   FieldMetadata::default_instance_->InitAsDefaultInstance();
00704   TableMetadata::default_instance_->InitAsDefaultInstance();
00705   TransactionContext::default_instance_->InitAsDefaultInstance();
00706   InsertRecord::default_instance_->InitAsDefaultInstance();
00707   InsertHeader::default_instance_->InitAsDefaultInstance();
00708   InsertData::default_instance_->InitAsDefaultInstance();
00709   UpdateRecord::default_instance_->InitAsDefaultInstance();
00710   UpdateHeader::default_instance_->InitAsDefaultInstance();
00711   UpdateData::default_instance_->InitAsDefaultInstance();
00712   DeleteRecord::default_instance_->InitAsDefaultInstance();
00713   DeleteHeader::default_instance_->InitAsDefaultInstance();
00714   DeleteData::default_instance_->InitAsDefaultInstance();
00715   TruncateTableStatement::default_instance_->InitAsDefaultInstance();
00716   CreateSchemaStatement::default_instance_->InitAsDefaultInstance();
00717   AlterSchemaStatement::default_instance_->InitAsDefaultInstance();
00718   DropSchemaStatement::default_instance_->InitAsDefaultInstance();
00719   CreateTableStatement::default_instance_->InitAsDefaultInstance();
00720   AlterTableStatement::default_instance_->InitAsDefaultInstance();
00721   DropTableStatement::default_instance_->InitAsDefaultInstance();
00722   SetVariableStatement::default_instance_->InitAsDefaultInstance();
00723   Statement::default_instance_->InitAsDefaultInstance();
00724   Transaction::default_instance_->InitAsDefaultInstance();
00725   ::google::protobuf::internal::OnShutdown(&protobuf_ShutdownFile_transaction_2eproto);
00726 }
00727 
00728 // Force AddDescriptors() to be called at static initialization time.
00729 struct StaticDescriptorInitializer_transaction_2eproto {
00730   StaticDescriptorInitializer_transaction_2eproto() {
00731     protobuf_AddDesc_transaction_2eproto();
00732   }
00733 } static_descriptor_initializer_transaction_2eproto_;
00734 
00735 
00736 // ===================================================================
00737 
00738 const ::std::string FieldMetadata::_default_name_;
00739 #ifndef _MSC_VER
00740 const int FieldMetadata::kTypeFieldNumber;
00741 const int FieldMetadata::kNameFieldNumber;
00742 #endif  // !_MSC_VER
00743 
00744 FieldMetadata::FieldMetadata()
00745   : ::google::protobuf::Message() {
00746   SharedCtor();
00747 }
00748 
00749 void FieldMetadata::InitAsDefaultInstance() {
00750 }
00751 
00752 FieldMetadata::FieldMetadata(const FieldMetadata& from)
00753   : ::google::protobuf::Message() {
00754   SharedCtor();
00755   MergeFrom(from);
00756 }
00757 
00758 void FieldMetadata::SharedCtor() {
00759   _cached_size_ = 0;
00760   type_ = 0;
00761   name_ = const_cast< ::std::string*>(&_default_name_);
00762   ::memset(_has_bits_, 0, sizeof(_has_bits_));
00763 }
00764 
00765 FieldMetadata::~FieldMetadata() {
00766   SharedDtor();
00767 }
00768 
00769 void FieldMetadata::SharedDtor() {
00770   if (name_ != &_default_name_) {
00771     delete name_;
00772   }
00773   if (this != default_instance_) {
00774   }
00775 }
00776 
00777 void FieldMetadata::SetCachedSize(int size) const {
00778   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
00779   _cached_size_ = size;
00780   GOOGLE_SAFE_CONCURRENT_WRITES_END();
00781 }
00782 const ::google::protobuf::Descriptor* FieldMetadata::descriptor() {
00783   protobuf_AssignDescriptorsOnce();
00784   return FieldMetadata_descriptor_;
00785 }
00786 
00787 const FieldMetadata& FieldMetadata::default_instance() {
00788   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
00789 }
00790 
00791 FieldMetadata* FieldMetadata::default_instance_ = NULL;
00792 
00793 FieldMetadata* FieldMetadata::New() const {
00794   return new FieldMetadata;
00795 }
00796 
00797 void FieldMetadata::Clear() {
00798   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00799     type_ = 0;
00800     if (_has_bit(1)) {
00801       if (name_ != &_default_name_) {
00802         name_->clear();
00803       }
00804     }
00805   }
00806   ::memset(_has_bits_, 0, sizeof(_has_bits_));
00807   mutable_unknown_fields()->Clear();
00808 }
00809 
00810 bool FieldMetadata::MergePartialFromCodedStream(
00811     ::google::protobuf::io::CodedInputStream* input) {
00812 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
00813   ::google::protobuf::uint32 tag;
00814   while ((tag = input->ReadTag()) != 0) {
00815     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
00816       // required .drizzled.message.Table.Field.FieldType type = 1;
00817       case 1: {
00818         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00819             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
00820           int value;
00821           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
00822                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
00823                  input, &value)));
00824           if (::drizzled::message::Table_Field_FieldType_IsValid(value)) {
00825             set_type(static_cast< ::drizzled::message::Table_Field_FieldType >(value));
00826           } else {
00827             mutable_unknown_fields()->AddVarint(1, value);
00828           }
00829         } else {
00830           goto handle_uninterpreted;
00831         }
00832         if (input->ExpectTag(18)) goto parse_name;
00833         break;
00834       }
00835       
00836       // required string name = 2;
00837       case 2: {
00838         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00839             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
00840          parse_name:
00841           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
00842                 input, this->mutable_name()));
00843           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00844             this->name().data(), this->name().length(),
00845             ::google::protobuf::internal::WireFormat::PARSE);
00846         } else {
00847           goto handle_uninterpreted;
00848         }
00849         if (input->ExpectAtEnd()) return true;
00850         break;
00851       }
00852       
00853       default: {
00854       handle_uninterpreted:
00855         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
00856             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
00857           return true;
00858         }
00859         DO_(::google::protobuf::internal::WireFormat::SkipField(
00860               input, tag, mutable_unknown_fields()));
00861         break;
00862       }
00863     }
00864   }
00865   return true;
00866 #undef DO_
00867 }
00868 
00869 void FieldMetadata::SerializeWithCachedSizes(
00870     ::google::protobuf::io::CodedOutputStream* output) const {
00871   // required .drizzled.message.Table.Field.FieldType type = 1;
00872   if (_has_bit(0)) {
00873     ::google::protobuf::internal::WireFormatLite::WriteEnum(
00874       1, this->type(), output);
00875   }
00876   
00877   // required string name = 2;
00878   if (_has_bit(1)) {
00879     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00880       this->name().data(), this->name().length(),
00881       ::google::protobuf::internal::WireFormat::SERIALIZE);
00882     ::google::protobuf::internal::WireFormatLite::WriteString(
00883       2, this->name(), output);
00884   }
00885   
00886   if (!unknown_fields().empty()) {
00887     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
00888         unknown_fields(), output);
00889   }
00890 }
00891 
00892 ::google::protobuf::uint8* FieldMetadata::SerializeWithCachedSizesToArray(
00893     ::google::protobuf::uint8* target) const {
00894   // required .drizzled.message.Table.Field.FieldType type = 1;
00895   if (_has_bit(0)) {
00896     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
00897       1, this->type(), target);
00898   }
00899   
00900   // required string name = 2;
00901   if (_has_bit(1)) {
00902     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
00903       this->name().data(), this->name().length(),
00904       ::google::protobuf::internal::WireFormat::SERIALIZE);
00905     target =
00906       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
00907         2, this->name(), target);
00908   }
00909   
00910   if (!unknown_fields().empty()) {
00911     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
00912         unknown_fields(), target);
00913   }
00914   return target;
00915 }
00916 
00917 int FieldMetadata::ByteSize() const {
00918   int total_size = 0;
00919   
00920   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00921     // required .drizzled.message.Table.Field.FieldType type = 1;
00922     if (has_type()) {
00923       total_size += 1 +
00924         ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
00925     }
00926     
00927     // required string name = 2;
00928     if (has_name()) {
00929       total_size += 1 +
00930         ::google::protobuf::internal::WireFormatLite::StringSize(
00931           this->name());
00932     }
00933     
00934   }
00935   if (!unknown_fields().empty()) {
00936     total_size +=
00937       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
00938         unknown_fields());
00939   }
00940   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
00941   _cached_size_ = total_size;
00942   GOOGLE_SAFE_CONCURRENT_WRITES_END();
00943   return total_size;
00944 }
00945 
00946 void FieldMetadata::MergeFrom(const ::google::protobuf::Message& from) {
00947   GOOGLE_CHECK_NE(&from, this);
00948   const FieldMetadata* source =
00949     ::google::protobuf::internal::dynamic_cast_if_available<const FieldMetadata*>(
00950       &from);
00951   if (source == NULL) {
00952     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
00953   } else {
00954     MergeFrom(*source);
00955   }
00956 }
00957 
00958 void FieldMetadata::MergeFrom(const FieldMetadata& from) {
00959   GOOGLE_CHECK_NE(&from, this);
00960   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
00961     if (from._has_bit(0)) {
00962       set_type(from.type());
00963     }
00964     if (from._has_bit(1)) {
00965       set_name(from.name());
00966     }
00967   }
00968   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
00969 }
00970 
00971 void FieldMetadata::CopyFrom(const ::google::protobuf::Message& from) {
00972   if (&from == this) return;
00973   Clear();
00974   MergeFrom(from);
00975 }
00976 
00977 void FieldMetadata::CopyFrom(const FieldMetadata& from) {
00978   if (&from == this) return;
00979   Clear();
00980   MergeFrom(from);
00981 }
00982 
00983 bool FieldMetadata::IsInitialized() const {
00984   if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
00985   
00986   return true;
00987 }
00988 
00989 void FieldMetadata::Swap(FieldMetadata* other) {
00990   if (other != this) {
00991     std::swap(type_, other->type_);
00992     std::swap(name_, other->name_);
00993     std::swap(_has_bits_[0], other->_has_bits_[0]);
00994     _unknown_fields_.Swap(&other->_unknown_fields_);
00995     std::swap(_cached_size_, other->_cached_size_);
00996   }
00997 }
00998 
00999 ::google::protobuf::Metadata FieldMetadata::GetMetadata() const {
01000   protobuf_AssignDescriptorsOnce();
01001   ::google::protobuf::Metadata metadata;
01002   metadata.descriptor = FieldMetadata_descriptor_;
01003   metadata.reflection = FieldMetadata_reflection_;
01004   return metadata;
01005 }
01006 
01007 
01008 // ===================================================================
01009 
01010 const ::std::string TableMetadata::_default_schema_name_;
01011 const ::std::string TableMetadata::_default_table_name_;
01012 const ::std::string TableMetadata::_default_catalog_name_;
01013 #ifndef _MSC_VER
01014 const int TableMetadata::kSchemaNameFieldNumber;
01015 const int TableMetadata::kTableNameFieldNumber;
01016 const int TableMetadata::kCatalogNameFieldNumber;
01017 #endif  // !_MSC_VER
01018 
01019 TableMetadata::TableMetadata()
01020   : ::google::protobuf::Message() {
01021   SharedCtor();
01022 }
01023 
01024 void TableMetadata::InitAsDefaultInstance() {
01025 }
01026 
01027 TableMetadata::TableMetadata(const TableMetadata& from)
01028   : ::google::protobuf::Message() {
01029   SharedCtor();
01030   MergeFrom(from);
01031 }
01032 
01033 void TableMetadata::SharedCtor() {
01034   _cached_size_ = 0;
01035   schema_name_ = const_cast< ::std::string*>(&_default_schema_name_);
01036   table_name_ = const_cast< ::std::string*>(&_default_table_name_);
01037   catalog_name_ = const_cast< ::std::string*>(&_default_catalog_name_);
01038   ::memset(_has_bits_, 0, sizeof(_has_bits_));
01039 }
01040 
01041 TableMetadata::~TableMetadata() {
01042   SharedDtor();
01043 }
01044 
01045 void TableMetadata::SharedDtor() {
01046   if (schema_name_ != &_default_schema_name_) {
01047     delete schema_name_;
01048   }
01049   if (table_name_ != &_default_table_name_) {
01050     delete table_name_;
01051   }
01052   if (catalog_name_ != &_default_catalog_name_) {
01053     delete catalog_name_;
01054   }
01055   if (this != default_instance_) {
01056   }
01057 }
01058 
01059 void TableMetadata::SetCachedSize(int size) const {
01060   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
01061   _cached_size_ = size;
01062   GOOGLE_SAFE_CONCURRENT_WRITES_END();
01063 }
01064 const ::google::protobuf::Descriptor* TableMetadata::descriptor() {
01065   protobuf_AssignDescriptorsOnce();
01066   return TableMetadata_descriptor_;
01067 }
01068 
01069 const TableMetadata& TableMetadata::default_instance() {
01070   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
01071 }
01072 
01073 TableMetadata* TableMetadata::default_instance_ = NULL;
01074 
01075 TableMetadata* TableMetadata::New() const {
01076   return new TableMetadata;
01077 }
01078 
01079 void TableMetadata::Clear() {
01080   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
01081     if (_has_bit(0)) {
01082       if (schema_name_ != &_default_schema_name_) {
01083         schema_name_->clear();
01084       }
01085     }
01086     if (_has_bit(1)) {
01087       if (table_name_ != &_default_table_name_) {
01088         table_name_->clear();
01089       }
01090     }
01091     if (_has_bit(2)) {
01092       if (catalog_name_ != &_default_catalog_name_) {
01093         catalog_name_->clear();
01094       }
01095     }
01096   }
01097   ::memset(_has_bits_, 0, sizeof(_has_bits_));
01098   mutable_unknown_fields()->Clear();
01099 }
01100 
01101 bool TableMetadata::MergePartialFromCodedStream(
01102     ::google::protobuf::io::CodedInputStream* input) {
01103 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
01104   ::google::protobuf::uint32 tag;
01105   while ((tag = input->ReadTag()) != 0) {
01106     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
01107       // required string schema_name = 1;
01108       case 1: {
01109         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01110             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
01111           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
01112                 input, this->mutable_schema_name()));
01113           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
01114             this->schema_name().data(), this->schema_name().length(),
01115             ::google::protobuf::internal::WireFormat::PARSE);
01116         } else {
01117           goto handle_uninterpreted;
01118         }
01119         if (input->ExpectTag(18)) goto parse_table_name;
01120         break;
01121       }
01122       
01123       // required string table_name = 2;
01124       case 2: {
01125         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01126             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
01127          parse_table_name:
01128           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
01129                 input, this->mutable_table_name()));
01130           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
01131             this->table_name().data(), this->table_name().length(),
01132             ::google::protobuf::internal::WireFormat::PARSE);
01133         } else {
01134           goto handle_uninterpreted;
01135         }
01136         if (input->ExpectTag(26)) goto parse_catalog_name;
01137         break;
01138       }
01139       
01140       // optional string catalog_name = 3;
01141       case 3: {
01142         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01143             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
01144          parse_catalog_name:
01145           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
01146                 input, this->mutable_catalog_name()));
01147           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
01148             this->catalog_name().data(), this->catalog_name().length(),
01149             ::google::protobuf::internal::WireFormat::PARSE);
01150         } else {
01151           goto handle_uninterpreted;
01152         }
01153         if (input->ExpectAtEnd()) return true;
01154         break;
01155       }
01156       
01157       default: {
01158       handle_uninterpreted:
01159         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01160             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
01161           return true;
01162         }
01163         DO_(::google::protobuf::internal::WireFormat::SkipField(
01164               input, tag, mutable_unknown_fields()));
01165         break;
01166       }
01167     }
01168   }
01169   return true;
01170 #undef DO_
01171 }
01172 
01173 void TableMetadata::SerializeWithCachedSizes(
01174     ::google::protobuf::io::CodedOutputStream* output) const {
01175   // required string schema_name = 1;
01176   if (_has_bit(0)) {
01177     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
01178       this->schema_name().data(), this->schema_name().length(),
01179       ::google::protobuf::internal::WireFormat::SERIALIZE);
01180     ::google::protobuf::internal::WireFormatLite::WriteString(
01181       1, this->schema_name(), output);
01182   }
01183   
01184   // required string table_name = 2;
01185   if (_has_bit(1)) {
01186     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
01187       this->table_name().data(), this->table_name().length(),
01188       ::google::protobuf::internal::WireFormat::SERIALIZE);
01189     ::google::protobuf::internal::WireFormatLite::WriteString(
01190       2, this->table_name(), output);
01191   }
01192   
01193   // optional string catalog_name = 3;
01194   if (_has_bit(2)) {
01195     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
01196       this->catalog_name().data(), this->catalog_name().length(),
01197       ::google::protobuf::internal::WireFormat::SERIALIZE);
01198     ::google::protobuf::internal::WireFormatLite::WriteString(
01199       3, this->catalog_name(), output);
01200   }
01201   
01202   if (!unknown_fields().empty()) {
01203     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
01204         unknown_fields(), output);
01205   }
01206 }
01207 
01208 ::google::protobuf::uint8* TableMetadata::SerializeWithCachedSizesToArray(
01209     ::google::protobuf::uint8* target) const {
01210   // required string schema_name = 1;
01211   if (_has_bit(0)) {
01212     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
01213       this->schema_name().data(), this->schema_name().length(),
01214       ::google::protobuf::internal::WireFormat::SERIALIZE);
01215     target =
01216       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
01217         1, this->schema_name(), target);
01218   }
01219   
01220   // required string table_name = 2;
01221   if (_has_bit(1)) {
01222     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
01223       this->table_name().data(), this->table_name().length(),
01224       ::google::protobuf::internal::WireFormat::SERIALIZE);
01225     target =
01226       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
01227         2, this->table_name(), target);
01228   }
01229   
01230   // optional string catalog_name = 3;
01231   if (_has_bit(2)) {
01232     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
01233       this->catalog_name().data(), this->catalog_name().length(),
01234       ::google::protobuf::internal::WireFormat::SERIALIZE);
01235     target =
01236       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
01237         3, this->catalog_name(), target);
01238   }
01239   
01240   if (!unknown_fields().empty()) {
01241     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
01242         unknown_fields(), target);
01243   }
01244   return target;
01245 }
01246 
01247 int TableMetadata::ByteSize() const {
01248   int total_size = 0;
01249   
01250   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
01251     // required string schema_name = 1;
01252     if (has_schema_name()) {
01253       total_size += 1 +
01254         ::google::protobuf::internal::WireFormatLite::StringSize(
01255           this->schema_name());
01256     }
01257     
01258     // required string table_name = 2;
01259     if (has_table_name()) {
01260       total_size += 1 +
01261         ::google::protobuf::internal::WireFormatLite::StringSize(
01262           this->table_name());
01263     }
01264     
01265     // optional string catalog_name = 3;
01266     if (has_catalog_name()) {
01267       total_size += 1 +
01268         ::google::protobuf::internal::WireFormatLite::StringSize(
01269           this->catalog_name());
01270     }
01271     
01272   }
01273   if (!unknown_fields().empty()) {
01274     total_size +=
01275       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
01276         unknown_fields());
01277   }
01278   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
01279   _cached_size_ = total_size;
01280   GOOGLE_SAFE_CONCURRENT_WRITES_END();
01281   return total_size;
01282 }
01283 
01284 void TableMetadata::MergeFrom(const ::google::protobuf::Message& from) {
01285   GOOGLE_CHECK_NE(&from, this);
01286   const TableMetadata* source =
01287     ::google::protobuf::internal::dynamic_cast_if_available<const TableMetadata*>(
01288       &from);
01289   if (source == NULL) {
01290     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
01291   } else {
01292     MergeFrom(*source);
01293   }
01294 }
01295 
01296 void TableMetadata::MergeFrom(const TableMetadata& from) {
01297   GOOGLE_CHECK_NE(&from, this);
01298   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
01299     if (from._has_bit(0)) {
01300       set_schema_name(from.schema_name());
01301     }
01302     if (from._has_bit(1)) {
01303       set_table_name(from.table_name());
01304     }
01305     if (from._has_bit(2)) {
01306       set_catalog_name(from.catalog_name());
01307     }
01308   }
01309   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
01310 }
01311 
01312 void TableMetadata::CopyFrom(const ::google::protobuf::Message& from) {
01313   if (&from == this) return;
01314   Clear();
01315   MergeFrom(from);
01316 }
01317 
01318 void TableMetadata::CopyFrom(const TableMetadata& from) {
01319   if (&from == this) return;
01320   Clear();
01321   MergeFrom(from);
01322 }
01323 
01324 bool TableMetadata::IsInitialized() const {
01325   if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
01326   
01327   return true;
01328 }
01329 
01330 void TableMetadata::Swap(TableMetadata* other) {
01331   if (other != this) {
01332     std::swap(schema_name_, other->schema_name_);
01333     std::swap(table_name_, other->table_name_);
01334     std::swap(catalog_name_, other->catalog_name_);
01335     std::swap(_has_bits_[0], other->_has_bits_[0]);
01336     _unknown_fields_.Swap(&other->_unknown_fields_);
01337     std::swap(_cached_size_, other->_cached_size_);
01338   }
01339 }
01340 
01341 ::google::protobuf::Metadata TableMetadata::GetMetadata() const {
01342   protobuf_AssignDescriptorsOnce();
01343   ::google::protobuf::Metadata metadata;
01344   metadata.descriptor = TableMetadata_descriptor_;
01345   metadata.reflection = TableMetadata_reflection_;
01346   return metadata;
01347 }
01348 
01349 
01350 // ===================================================================
01351 
01352 #ifndef _MSC_VER
01353 const int TransactionContext::kServerIdFieldNumber;
01354 const int TransactionContext::kTransactionIdFieldNumber;
01355 const int TransactionContext::kStartTimestampFieldNumber;
01356 const int TransactionContext::kEndTimestampFieldNumber;
01357 #endif  // !_MSC_VER
01358 
01359 TransactionContext::TransactionContext()
01360   : ::google::protobuf::Message() {
01361   SharedCtor();
01362 }
01363 
01364 void TransactionContext::InitAsDefaultInstance() {
01365 }
01366 
01367 TransactionContext::TransactionContext(const TransactionContext& from)
01368   : ::google::protobuf::Message() {
01369   SharedCtor();
01370   MergeFrom(from);
01371 }
01372 
01373 void TransactionContext::SharedCtor() {
01374   _cached_size_ = 0;
01375   server_id_ = 0u;
01376   transaction_id_ = GOOGLE_ULONGLONG(0);
01377   start_timestamp_ = GOOGLE_ULONGLONG(0);
01378   end_timestamp_ = GOOGLE_ULONGLONG(0);
01379   ::memset(_has_bits_, 0, sizeof(_has_bits_));
01380 }
01381 
01382 TransactionContext::~TransactionContext() {
01383   SharedDtor();
01384 }
01385 
01386 void TransactionContext::SharedDtor() {
01387   if (this != default_instance_) {
01388   }
01389 }
01390 
01391 void TransactionContext::SetCachedSize(int size) const {
01392   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
01393   _cached_size_ = size;
01394   GOOGLE_SAFE_CONCURRENT_WRITES_END();
01395 }
01396 const ::google::protobuf::Descriptor* TransactionContext::descriptor() {
01397   protobuf_AssignDescriptorsOnce();
01398   return TransactionContext_descriptor_;
01399 }
01400 
01401 const TransactionContext& TransactionContext::default_instance() {
01402   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
01403 }
01404 
01405 TransactionContext* TransactionContext::default_instance_ = NULL;
01406 
01407 TransactionContext* TransactionContext::New() const {
01408   return new TransactionContext;
01409 }
01410 
01411 void TransactionContext::Clear() {
01412   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
01413     server_id_ = 0u;
01414     transaction_id_ = GOOGLE_ULONGLONG(0);
01415     start_timestamp_ = GOOGLE_ULONGLONG(0);
01416     end_timestamp_ = GOOGLE_ULONGLONG(0);
01417   }
01418   ::memset(_has_bits_, 0, sizeof(_has_bits_));
01419   mutable_unknown_fields()->Clear();
01420 }
01421 
01422 bool TransactionContext::MergePartialFromCodedStream(
01423     ::google::protobuf::io::CodedInputStream* input) {
01424 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
01425   ::google::protobuf::uint32 tag;
01426   while ((tag = input->ReadTag()) != 0) {
01427     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
01428       // required uint32 server_id = 1;
01429       case 1: {
01430         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01431             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
01432           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
01433                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
01434                  input, &server_id_)));
01435           _set_bit(0);
01436         } else {
01437           goto handle_uninterpreted;
01438         }
01439         if (input->ExpectTag(16)) goto parse_transaction_id;
01440         break;
01441       }
01442       
01443       // required uint64 transaction_id = 2;
01444       case 2: {
01445         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01446             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
01447          parse_transaction_id:
01448           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
01449                    ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
01450                  input, &transaction_id_)));
01451           _set_bit(1);
01452         } else {
01453           goto handle_uninterpreted;
01454         }
01455         if (input->ExpectTag(24)) goto parse_start_timestamp;
01456         break;
01457       }
01458       
01459       // required uint64 start_timestamp = 3;
01460       case 3: {
01461         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01462             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
01463          parse_start_timestamp:
01464           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
01465                    ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
01466                  input, &start_timestamp_)));
01467           _set_bit(2);
01468         } else {
01469           goto handle_uninterpreted;
01470         }
01471         if (input->ExpectTag(32)) goto parse_end_timestamp;
01472         break;
01473       }
01474       
01475       // required uint64 end_timestamp = 4;
01476       case 4: {
01477         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01478             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
01479          parse_end_timestamp:
01480           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
01481                    ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
01482                  input, &end_timestamp_)));
01483           _set_bit(3);
01484         } else {
01485           goto handle_uninterpreted;
01486         }
01487         if (input->ExpectAtEnd()) return true;
01488         break;
01489       }
01490       
01491       default: {
01492       handle_uninterpreted:
01493         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01494             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
01495           return true;
01496         }
01497         DO_(::google::protobuf::internal::WireFormat::SkipField(
01498               input, tag, mutable_unknown_fields()));
01499         break;
01500       }
01501     }
01502   }
01503   return true;
01504 #undef DO_
01505 }
01506 
01507 void TransactionContext::SerializeWithCachedSizes(
01508     ::google::protobuf::io::CodedOutputStream* output) const {
01509   // required uint32 server_id = 1;
01510   if (_has_bit(0)) {
01511     ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->server_id(), output);
01512   }
01513   
01514   // required uint64 transaction_id = 2;
01515   if (_has_bit(1)) {
01516     ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->transaction_id(), output);
01517   }
01518   
01519   // required uint64 start_timestamp = 3;
01520   if (_has_bit(2)) {
01521     ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->start_timestamp(), output);
01522   }
01523   
01524   // required uint64 end_timestamp = 4;
01525   if (_has_bit(3)) {
01526     ::google::protobuf::internal::WireFormatLite::WriteUInt64(4, this->end_timestamp(), output);
01527   }
01528   
01529   if (!unknown_fields().empty()) {
01530     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
01531         unknown_fields(), output);
01532   }
01533 }
01534 
01535 ::google::protobuf::uint8* TransactionContext::SerializeWithCachedSizesToArray(
01536     ::google::protobuf::uint8* target) const {
01537   // required uint32 server_id = 1;
01538   if (_has_bit(0)) {
01539     target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->server_id(), target);
01540   }
01541   
01542   // required uint64 transaction_id = 2;
01543   if (_has_bit(1)) {
01544     target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->transaction_id(), target);
01545   }
01546   
01547   // required uint64 start_timestamp = 3;
01548   if (_has_bit(2)) {
01549     target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->start_timestamp(), target);
01550   }
01551   
01552   // required uint64 end_timestamp = 4;
01553   if (_has_bit(3)) {
01554     target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(4, this->end_timestamp(), target);
01555   }
01556   
01557   if (!unknown_fields().empty()) {
01558     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
01559         unknown_fields(), target);
01560   }
01561   return target;
01562 }
01563 
01564 int TransactionContext::ByteSize() const {
01565   int total_size = 0;
01566   
01567   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
01568     // required uint32 server_id = 1;
01569     if (has_server_id()) {
01570       total_size += 1 +
01571         ::google::protobuf::internal::WireFormatLite::UInt32Size(
01572           this->server_id());
01573     }
01574     
01575     // required uint64 transaction_id = 2;
01576     if (has_transaction_id()) {
01577       total_size += 1 +
01578         ::google::protobuf::internal::WireFormatLite::UInt64Size(
01579           this->transaction_id());
01580     }
01581     
01582     // required uint64 start_timestamp = 3;
01583     if (has_start_timestamp()) {
01584       total_size += 1 +
01585         ::google::protobuf::internal::WireFormatLite::UInt64Size(
01586           this->start_timestamp());
01587     }
01588     
01589     // required uint64 end_timestamp = 4;
01590     if (has_end_timestamp()) {
01591       total_size += 1 +
01592         ::google::protobuf::internal::WireFormatLite::UInt64Size(
01593           this->end_timestamp());
01594     }
01595     
01596   }
01597   if (!unknown_fields().empty()) {
01598     total_size +=
01599       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
01600         unknown_fields());
01601   }
01602   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
01603   _cached_size_ = total_size;
01604   GOOGLE_SAFE_CONCURRENT_WRITES_END();
01605   return total_size;
01606 }
01607 
01608 void TransactionContext::MergeFrom(const ::google::protobuf::Message& from) {
01609   GOOGLE_CHECK_NE(&from, this);
01610   const TransactionContext* source =
01611     ::google::protobuf::internal::dynamic_cast_if_available<const TransactionContext*>(
01612       &from);
01613   if (source == NULL) {
01614     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
01615   } else {
01616     MergeFrom(*source);
01617   }
01618 }
01619 
01620 void TransactionContext::MergeFrom(const TransactionContext& from) {
01621   GOOGLE_CHECK_NE(&from, this);
01622   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
01623     if (from._has_bit(0)) {
01624       set_server_id(from.server_id());
01625     }
01626     if (from._has_bit(1)) {
01627       set_transaction_id(from.transaction_id());
01628     }
01629     if (from._has_bit(2)) {
01630       set_start_timestamp(from.start_timestamp());
01631     }
01632     if (from._has_bit(3)) {
01633       set_end_timestamp(from.end_timestamp());
01634     }
01635   }
01636   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
01637 }
01638 
01639 void TransactionContext::CopyFrom(const ::google::protobuf::Message& from) {
01640   if (&from == this) return;
01641   Clear();
01642   MergeFrom(from);
01643 }
01644 
01645 void TransactionContext::CopyFrom(const TransactionContext& from) {
01646   if (&from == this) return;
01647   Clear();
01648   MergeFrom(from);
01649 }
01650 
01651 bool TransactionContext::IsInitialized() const {
01652   if ((_has_bits_[0] & 0x0000000f) != 0x0000000f) return false;
01653   
01654   return true;
01655 }
01656 
01657 void TransactionContext::Swap(TransactionContext* other) {
01658   if (other != this) {
01659     std::swap(server_id_, other->server_id_);
01660     std::swap(transaction_id_, other->transaction_id_);
01661     std::swap(start_timestamp_, other->start_timestamp_);
01662     std::swap(end_timestamp_, other->end_timestamp_);
01663     std::swap(_has_bits_[0], other->_has_bits_[0]);
01664     _unknown_fields_.Swap(&other->_unknown_fields_);
01665     std::swap(_cached_size_, other->_cached_size_);
01666   }
01667 }
01668 
01669 ::google::protobuf::Metadata TransactionContext::GetMetadata() const {
01670   protobuf_AssignDescriptorsOnce();
01671   ::google::protobuf::Metadata metadata;
01672   metadata.descriptor = TransactionContext_descriptor_;
01673   metadata.reflection = TransactionContext_reflection_;
01674   return metadata;
01675 }
01676 
01677 
01678 // ===================================================================
01679 
01680 #ifndef _MSC_VER
01681 const int InsertRecord::kInsertValueFieldNumber;
01682 const int InsertRecord::kIsNullFieldNumber;
01683 #endif  // !_MSC_VER
01684 
01685 InsertRecord::InsertRecord()
01686   : ::google::protobuf::Message() {
01687   SharedCtor();
01688 }
01689 
01690 void InsertRecord::InitAsDefaultInstance() {
01691 }
01692 
01693 InsertRecord::InsertRecord(const InsertRecord& from)
01694   : ::google::protobuf::Message() {
01695   SharedCtor();
01696   MergeFrom(from);
01697 }
01698 
01699 void InsertRecord::SharedCtor() {
01700   _cached_size_ = 0;
01701   ::memset(_has_bits_, 0, sizeof(_has_bits_));
01702 }
01703 
01704 InsertRecord::~InsertRecord() {
01705   SharedDtor();
01706 }
01707 
01708 void InsertRecord::SharedDtor() {
01709   if (this != default_instance_) {
01710   }
01711 }
01712 
01713 void InsertRecord::SetCachedSize(int size) const {
01714   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
01715   _cached_size_ = size;
01716   GOOGLE_SAFE_CONCURRENT_WRITES_END();
01717 }
01718 const ::google::protobuf::Descriptor* InsertRecord::descriptor() {
01719   protobuf_AssignDescriptorsOnce();
01720   return InsertRecord_descriptor_;
01721 }
01722 
01723 const InsertRecord& InsertRecord::default_instance() {
01724   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
01725 }
01726 
01727 InsertRecord* InsertRecord::default_instance_ = NULL;
01728 
01729 InsertRecord* InsertRecord::New() const {
01730   return new InsertRecord;
01731 }
01732 
01733 void InsertRecord::Clear() {
01734   insert_value_.Clear();
01735   is_null_.Clear();
01736   ::memset(_has_bits_, 0, sizeof(_has_bits_));
01737   mutable_unknown_fields()->Clear();
01738 }
01739 
01740 bool InsertRecord::MergePartialFromCodedStream(
01741     ::google::protobuf::io::CodedInputStream* input) {
01742 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
01743   ::google::protobuf::uint32 tag;
01744   while ((tag = input->ReadTag()) != 0) {
01745     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
01746       // repeated bytes insert_value = 1;
01747       case 1: {
01748         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01749             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
01750          parse_insert_value:
01751           DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
01752                 input, this->add_insert_value()));
01753         } else {
01754           goto handle_uninterpreted;
01755         }
01756         if (input->ExpectTag(10)) goto parse_insert_value;
01757         if (input->ExpectTag(16)) goto parse_is_null;
01758         break;
01759       }
01760       
01761       // repeated bool is_null = 2;
01762       case 2: {
01763         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01764             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
01765          parse_is_null:
01766           DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
01767                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
01768                  1, 16, input, this->mutable_is_null())));
01769         } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
01770                    == ::google::protobuf::internal::WireFormatLite::
01771                       WIRETYPE_LENGTH_DELIMITED) {
01772           DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
01773                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
01774                  input, this->mutable_is_null())));
01775         } else {
01776           goto handle_uninterpreted;
01777         }
01778         if (input->ExpectTag(16)) goto parse_is_null;
01779         if (input->ExpectAtEnd()) return true;
01780         break;
01781       }
01782       
01783       default: {
01784       handle_uninterpreted:
01785         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
01786             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
01787           return true;
01788         }
01789         DO_(::google::protobuf::internal::WireFormat::SkipField(
01790               input, tag, mutable_unknown_fields()));
01791         break;
01792       }
01793     }
01794   }
01795   return true;
01796 #undef DO_
01797 }
01798 
01799 void InsertRecord::SerializeWithCachedSizes(
01800     ::google::protobuf::io::CodedOutputStream* output) const {
01801   // repeated bytes insert_value = 1;
01802   for (int i = 0; i < this->insert_value_size(); i++) {
01803     ::google::protobuf::internal::WireFormatLite::WriteBytes(
01804       1, this->insert_value(i), output);
01805   }
01806   
01807   // repeated bool is_null = 2;
01808   for (int i = 0; i < this->is_null_size(); i++) {
01809     ::google::protobuf::internal::WireFormatLite::WriteBool(
01810       2, this->is_null(i), output);
01811   }
01812   
01813   if (!unknown_fields().empty()) {
01814     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
01815         unknown_fields(), output);
01816   }
01817 }
01818 
01819 ::google::protobuf::uint8* InsertRecord::SerializeWithCachedSizesToArray(
01820     ::google::protobuf::uint8* target) const {
01821   // repeated bytes insert_value = 1;
01822   for (int i = 0; i < this->insert_value_size(); i++) {
01823     target = ::google::protobuf::internal::WireFormatLite::
01824       WriteBytesToArray(1, this->insert_value(i), target);
01825   }
01826   
01827   // repeated bool is_null = 2;
01828   for (int i = 0; i < this->is_null_size(); i++) {
01829     target = ::google::protobuf::internal::WireFormatLite::
01830       WriteBoolToArray(2, this->is_null(i), target);
01831   }
01832   
01833   if (!unknown_fields().empty()) {
01834     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
01835         unknown_fields(), target);
01836   }
01837   return target;
01838 }
01839 
01840 int InsertRecord::ByteSize() const {
01841   int total_size = 0;
01842   
01843   // repeated bytes insert_value = 1;
01844   total_size += 1 * this->insert_value_size();
01845   for (int i = 0; i < this->insert_value_size(); i++) {
01846     total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
01847       this->insert_value(i));
01848   }
01849   
01850   // repeated bool is_null = 2;
01851   {
01852     int data_size = 0;
01853     data_size = 1 * this->is_null_size();
01854     total_size += 1 * this->is_null_size() + data_size;
01855   }
01856   
01857   if (!unknown_fields().empty()) {
01858     total_size +=
01859       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
01860         unknown_fields());
01861   }
01862   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
01863   _cached_size_ = total_size;
01864   GOOGLE_SAFE_CONCURRENT_WRITES_END();
01865   return total_size;
01866 }
01867 
01868 void InsertRecord::MergeFrom(const ::google::protobuf::Message& from) {
01869   GOOGLE_CHECK_NE(&from, this);
01870   const InsertRecord* source =
01871     ::google::protobuf::internal::dynamic_cast_if_available<const InsertRecord*>(
01872       &from);
01873   if (source == NULL) {
01874     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
01875   } else {
01876     MergeFrom(*source);
01877   }
01878 }
01879 
01880 void InsertRecord::MergeFrom(const InsertRecord& from) {
01881   GOOGLE_CHECK_NE(&from, this);
01882   insert_value_.MergeFrom(from.insert_value_);
01883   is_null_.MergeFrom(from.is_null_);
01884   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
01885 }
01886 
01887 void InsertRecord::CopyFrom(const ::google::protobuf::Message& from) {
01888   if (&from == this) return;
01889   Clear();
01890   MergeFrom(from);
01891 }
01892 
01893 void InsertRecord::CopyFrom(const InsertRecord& from) {
01894   if (&from == this) return;
01895   Clear();
01896   MergeFrom(from);
01897 }
01898 
01899 bool InsertRecord::IsInitialized() const {
01900   
01901   return true;
01902 }
01903 
01904 void InsertRecord::Swap(InsertRecord* other) {
01905   if (other != this) {
01906     insert_value_.Swap(&other->insert_value_);
01907     is_null_.Swap(&other->is_null_);
01908     std::swap(_has_bits_[0], other->_has_bits_[0]);
01909     _unknown_fields_.Swap(&other->_unknown_fields_);
01910     std::swap(_cached_size_, other->_cached_size_);
01911   }
01912 }
01913 
01914 ::google::protobuf::Metadata InsertRecord::GetMetadata() const {
01915   protobuf_AssignDescriptorsOnce();
01916   ::google::protobuf::Metadata metadata;
01917   metadata.descriptor = InsertRecord_descriptor_;
01918   metadata.reflection = InsertRecord_reflection_;
01919   return metadata;
01920 }
01921 
01922 
01923 // ===================================================================
01924 
01925 #ifndef _MSC_VER
01926 const int InsertHeader::kTableMetadataFieldNumber;
01927 const int InsertHeader::kFieldMetadataFieldNumber;
01928 #endif  // !_MSC_VER
01929 
01930 InsertHeader::InsertHeader()
01931   : ::google::protobuf::Message() {
01932   SharedCtor();
01933 }
01934 
01935 void InsertHeader::InitAsDefaultInstance() {
01936   table_metadata_ = const_cast< ::drizzled::message::TableMetadata*>(&::drizzled::message::TableMetadata::default_instance());
01937 }
01938 
01939 InsertHeader::InsertHeader(const InsertHeader& from)
01940   : ::google::protobuf::Message() {
01941   SharedCtor();
01942   MergeFrom(from);
01943 }
01944 
01945 void InsertHeader::SharedCtor() {
01946   _cached_size_ = 0;
01947   table_metadata_ = NULL;
01948   ::memset(_has_bits_, 0, sizeof(_has_bits_));
01949 }
01950 
01951 InsertHeader::~InsertHeader() {
01952   SharedDtor();
01953 }
01954 
01955 void InsertHeader::SharedDtor() {
01956   if (this != default_instance_) {
01957     delete table_metadata_;
01958   }
01959 }
01960 
01961 void InsertHeader::SetCachedSize(int size) const {
01962   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
01963   _cached_size_ = size;
01964   GOOGLE_SAFE_CONCURRENT_WRITES_END();
01965 }
01966 const ::google::protobuf::Descriptor* InsertHeader::descriptor() {
01967   protobuf_AssignDescriptorsOnce();
01968   return InsertHeader_descriptor_;
01969 }
01970 
01971 const InsertHeader& InsertHeader::default_instance() {
01972   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
01973 }
01974 
01975 InsertHeader* InsertHeader::default_instance_ = NULL;
01976 
01977 InsertHeader* InsertHeader::New() const {
01978   return new InsertHeader;
01979 }
01980 
01981 void InsertHeader::Clear() {
01982   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
01983     if (_has_bit(0)) {
01984       if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
01985     }
01986   }
01987   field_metadata_.Clear();
01988   ::memset(_has_bits_, 0, sizeof(_has_bits_));
01989   mutable_unknown_fields()->Clear();
01990 }
01991 
01992 bool InsertHeader::MergePartialFromCodedStream(
01993     ::google::protobuf::io::CodedInputStream* input) {
01994 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
01995   ::google::protobuf::uint32 tag;
01996   while ((tag = input->ReadTag()) != 0) {
01997     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
01998       // required .drizzled.message.TableMetadata table_metadata = 1;
01999       case 1: {
02000         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02001             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
02002           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
02003                input, mutable_table_metadata()));
02004         } else {
02005           goto handle_uninterpreted;
02006         }
02007         if (input->ExpectTag(18)) goto parse_field_metadata;
02008         break;
02009       }
02010       
02011       // repeated .drizzled.message.FieldMetadata field_metadata = 2;
02012       case 2: {
02013         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02014             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
02015          parse_field_metadata:
02016           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
02017                 input, add_field_metadata()));
02018         } else {
02019           goto handle_uninterpreted;
02020         }
02021         if (input->ExpectTag(18)) goto parse_field_metadata;
02022         if (input->ExpectAtEnd()) return true;
02023         break;
02024       }
02025       
02026       default: {
02027       handle_uninterpreted:
02028         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02029             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
02030           return true;
02031         }
02032         DO_(::google::protobuf::internal::WireFormat::SkipField(
02033               input, tag, mutable_unknown_fields()));
02034         break;
02035       }
02036     }
02037   }
02038   return true;
02039 #undef DO_
02040 }
02041 
02042 void InsertHeader::SerializeWithCachedSizes(
02043     ::google::protobuf::io::CodedOutputStream* output) const {
02044   // required .drizzled.message.TableMetadata table_metadata = 1;
02045   if (_has_bit(0)) {
02046     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
02047       1, this->table_metadata(), output);
02048   }
02049   
02050   // repeated .drizzled.message.FieldMetadata field_metadata = 2;
02051   for (int i = 0; i < this->field_metadata_size(); i++) {
02052     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
02053       2, this->field_metadata(i), output);
02054   }
02055   
02056   if (!unknown_fields().empty()) {
02057     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
02058         unknown_fields(), output);
02059   }
02060 }
02061 
02062 ::google::protobuf::uint8* InsertHeader::SerializeWithCachedSizesToArray(
02063     ::google::protobuf::uint8* target) const {
02064   // required .drizzled.message.TableMetadata table_metadata = 1;
02065   if (_has_bit(0)) {
02066     target = ::google::protobuf::internal::WireFormatLite::
02067       WriteMessageNoVirtualToArray(
02068         1, this->table_metadata(), target);
02069   }
02070   
02071   // repeated .drizzled.message.FieldMetadata field_metadata = 2;
02072   for (int i = 0; i < this->field_metadata_size(); i++) {
02073     target = ::google::protobuf::internal::WireFormatLite::
02074       WriteMessageNoVirtualToArray(
02075         2, this->field_metadata(i), target);
02076   }
02077   
02078   if (!unknown_fields().empty()) {
02079     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
02080         unknown_fields(), target);
02081   }
02082   return target;
02083 }
02084 
02085 int InsertHeader::ByteSize() const {
02086   int total_size = 0;
02087   
02088   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
02089     // required .drizzled.message.TableMetadata table_metadata = 1;
02090     if (has_table_metadata()) {
02091       total_size += 1 +
02092         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
02093           this->table_metadata());
02094     }
02095     
02096   }
02097   // repeated .drizzled.message.FieldMetadata field_metadata = 2;
02098   total_size += 1 * this->field_metadata_size();
02099   for (int i = 0; i < this->field_metadata_size(); i++) {
02100     total_size +=
02101       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
02102         this->field_metadata(i));
02103   }
02104   
02105   if (!unknown_fields().empty()) {
02106     total_size +=
02107       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
02108         unknown_fields());
02109   }
02110   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
02111   _cached_size_ = total_size;
02112   GOOGLE_SAFE_CONCURRENT_WRITES_END();
02113   return total_size;
02114 }
02115 
02116 void InsertHeader::MergeFrom(const ::google::protobuf::Message& from) {
02117   GOOGLE_CHECK_NE(&from, this);
02118   const InsertHeader* source =
02119     ::google::protobuf::internal::dynamic_cast_if_available<const InsertHeader*>(
02120       &from);
02121   if (source == NULL) {
02122     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
02123   } else {
02124     MergeFrom(*source);
02125   }
02126 }
02127 
02128 void InsertHeader::MergeFrom(const InsertHeader& from) {
02129   GOOGLE_CHECK_NE(&from, this);
02130   field_metadata_.MergeFrom(from.field_metadata_);
02131   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
02132     if (from._has_bit(0)) {
02133       mutable_table_metadata()->::drizzled::message::TableMetadata::MergeFrom(from.table_metadata());
02134     }
02135   }
02136   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
02137 }
02138 
02139 void InsertHeader::CopyFrom(const ::google::protobuf::Message& from) {
02140   if (&from == this) return;
02141   Clear();
02142   MergeFrom(from);
02143 }
02144 
02145 void InsertHeader::CopyFrom(const InsertHeader& from) {
02146   if (&from == this) return;
02147   Clear();
02148   MergeFrom(from);
02149 }
02150 
02151 bool InsertHeader::IsInitialized() const {
02152   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
02153   
02154   if (has_table_metadata()) {
02155     if (!this->table_metadata().IsInitialized()) return false;
02156   }
02157   for (int i = 0; i < field_metadata_size(); i++) {
02158     if (!this->field_metadata(i).IsInitialized()) return false;
02159   }
02160   return true;
02161 }
02162 
02163 void InsertHeader::Swap(InsertHeader* other) {
02164   if (other != this) {
02165     std::swap(table_metadata_, other->table_metadata_);
02166     field_metadata_.Swap(&other->field_metadata_);
02167     std::swap(_has_bits_[0], other->_has_bits_[0]);
02168     _unknown_fields_.Swap(&other->_unknown_fields_);
02169     std::swap(_cached_size_, other->_cached_size_);
02170   }
02171 }
02172 
02173 ::google::protobuf::Metadata InsertHeader::GetMetadata() const {
02174   protobuf_AssignDescriptorsOnce();
02175   ::google::protobuf::Metadata metadata;
02176   metadata.descriptor = InsertHeader_descriptor_;
02177   metadata.reflection = InsertHeader_reflection_;
02178   return metadata;
02179 }
02180 
02181 
02182 // ===================================================================
02183 
02184 #ifndef _MSC_VER
02185 const int InsertData::kSegmentIdFieldNumber;
02186 const int InsertData::kEndSegmentFieldNumber;
02187 const int InsertData::kRecordFieldNumber;
02188 #endif  // !_MSC_VER
02189 
02190 InsertData::InsertData()
02191   : ::google::protobuf::Message() {
02192   SharedCtor();
02193 }
02194 
02195 void InsertData::InitAsDefaultInstance() {
02196 }
02197 
02198 InsertData::InsertData(const InsertData& from)
02199   : ::google::protobuf::Message() {
02200   SharedCtor();
02201   MergeFrom(from);
02202 }
02203 
02204 void InsertData::SharedCtor() {
02205   _cached_size_ = 0;
02206   segment_id_ = 0u;
02207   end_segment_ = false;
02208   ::memset(_has_bits_, 0, sizeof(_has_bits_));
02209 }
02210 
02211 InsertData::~InsertData() {
02212   SharedDtor();
02213 }
02214 
02215 void InsertData::SharedDtor() {
02216   if (this != default_instance_) {
02217   }
02218 }
02219 
02220 void InsertData::SetCachedSize(int size) const {
02221   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
02222   _cached_size_ = size;
02223   GOOGLE_SAFE_CONCURRENT_WRITES_END();
02224 }
02225 const ::google::protobuf::Descriptor* InsertData::descriptor() {
02226   protobuf_AssignDescriptorsOnce();
02227   return InsertData_descriptor_;
02228 }
02229 
02230 const InsertData& InsertData::default_instance() {
02231   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
02232 }
02233 
02234 InsertData* InsertData::default_instance_ = NULL;
02235 
02236 InsertData* InsertData::New() const {
02237   return new InsertData;
02238 }
02239 
02240 void InsertData::Clear() {
02241   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
02242     segment_id_ = 0u;
02243     end_segment_ = false;
02244   }
02245   record_.Clear();
02246   ::memset(_has_bits_, 0, sizeof(_has_bits_));
02247   mutable_unknown_fields()->Clear();
02248 }
02249 
02250 bool InsertData::MergePartialFromCodedStream(
02251     ::google::protobuf::io::CodedInputStream* input) {
02252 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
02253   ::google::protobuf::uint32 tag;
02254   while ((tag = input->ReadTag()) != 0) {
02255     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
02256       // required uint32 segment_id = 1;
02257       case 1: {
02258         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02259             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
02260           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
02261                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
02262                  input, &segment_id_)));
02263           _set_bit(0);
02264         } else {
02265           goto handle_uninterpreted;
02266         }
02267         if (input->ExpectTag(16)) goto parse_end_segment;
02268         break;
02269       }
02270       
02271       // required bool end_segment = 2;
02272       case 2: {
02273         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02274             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
02275          parse_end_segment:
02276           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
02277                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
02278                  input, &end_segment_)));
02279           _set_bit(1);
02280         } else {
02281           goto handle_uninterpreted;
02282         }
02283         if (input->ExpectTag(26)) goto parse_record;
02284         break;
02285       }
02286       
02287       // repeated .drizzled.message.InsertRecord record = 3;
02288       case 3: {
02289         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02290             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
02291          parse_record:
02292           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
02293                 input, add_record()));
02294         } else {
02295           goto handle_uninterpreted;
02296         }
02297         if (input->ExpectTag(26)) goto parse_record;
02298         if (input->ExpectAtEnd()) return true;
02299         break;
02300       }
02301       
02302       default: {
02303       handle_uninterpreted:
02304         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02305             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
02306           return true;
02307         }
02308         DO_(::google::protobuf::internal::WireFormat::SkipField(
02309               input, tag, mutable_unknown_fields()));
02310         break;
02311       }
02312     }
02313   }
02314   return true;
02315 #undef DO_
02316 }
02317 
02318 void InsertData::SerializeWithCachedSizes(
02319     ::google::protobuf::io::CodedOutputStream* output) const {
02320   // required uint32 segment_id = 1;
02321   if (_has_bit(0)) {
02322     ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->segment_id(), output);
02323   }
02324   
02325   // required bool end_segment = 2;
02326   if (_has_bit(1)) {
02327     ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->end_segment(), output);
02328   }
02329   
02330   // repeated .drizzled.message.InsertRecord record = 3;
02331   for (int i = 0; i < this->record_size(); i++) {
02332     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
02333       3, this->record(i), output);
02334   }
02335   
02336   if (!unknown_fields().empty()) {
02337     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
02338         unknown_fields(), output);
02339   }
02340 }
02341 
02342 ::google::protobuf::uint8* InsertData::SerializeWithCachedSizesToArray(
02343     ::google::protobuf::uint8* target) const {
02344   // required uint32 segment_id = 1;
02345   if (_has_bit(0)) {
02346     target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->segment_id(), target);
02347   }
02348   
02349   // required bool end_segment = 2;
02350   if (_has_bit(1)) {
02351     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->end_segment(), target);
02352   }
02353   
02354   // repeated .drizzled.message.InsertRecord record = 3;
02355   for (int i = 0; i < this->record_size(); i++) {
02356     target = ::google::protobuf::internal::WireFormatLite::
02357       WriteMessageNoVirtualToArray(
02358         3, this->record(i), target);
02359   }
02360   
02361   if (!unknown_fields().empty()) {
02362     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
02363         unknown_fields(), target);
02364   }
02365   return target;
02366 }
02367 
02368 int InsertData::ByteSize() const {
02369   int total_size = 0;
02370   
02371   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
02372     // required uint32 segment_id = 1;
02373     if (has_segment_id()) {
02374       total_size += 1 +
02375         ::google::protobuf::internal::WireFormatLite::UInt32Size(
02376           this->segment_id());
02377     }
02378     
02379     // required bool end_segment = 2;
02380     if (has_end_segment()) {
02381       total_size += 1 + 1;
02382     }
02383     
02384   }
02385   // repeated .drizzled.message.InsertRecord record = 3;
02386   total_size += 1 * this->record_size();
02387   for (int i = 0; i < this->record_size(); i++) {
02388     total_size +=
02389       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
02390         this->record(i));
02391   }
02392   
02393   if (!unknown_fields().empty()) {
02394     total_size +=
02395       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
02396         unknown_fields());
02397   }
02398   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
02399   _cached_size_ = total_size;
02400   GOOGLE_SAFE_CONCURRENT_WRITES_END();
02401   return total_size;
02402 }
02403 
02404 void InsertData::MergeFrom(const ::google::protobuf::Message& from) {
02405   GOOGLE_CHECK_NE(&from, this);
02406   const InsertData* source =
02407     ::google::protobuf::internal::dynamic_cast_if_available<const InsertData*>(
02408       &from);
02409   if (source == NULL) {
02410     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
02411   } else {
02412     MergeFrom(*source);
02413   }
02414 }
02415 
02416 void InsertData::MergeFrom(const InsertData& from) {
02417   GOOGLE_CHECK_NE(&from, this);
02418   record_.MergeFrom(from.record_);
02419   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
02420     if (from._has_bit(0)) {
02421       set_segment_id(from.segment_id());
02422     }
02423     if (from._has_bit(1)) {
02424       set_end_segment(from.end_segment());
02425     }
02426   }
02427   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
02428 }
02429 
02430 void InsertData::CopyFrom(const ::google::protobuf::Message& from) {
02431   if (&from == this) return;
02432   Clear();
02433   MergeFrom(from);
02434 }
02435 
02436 void InsertData::CopyFrom(const InsertData& from) {
02437   if (&from == this) return;
02438   Clear();
02439   MergeFrom(from);
02440 }
02441 
02442 bool InsertData::IsInitialized() const {
02443   if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
02444   
02445   return true;
02446 }
02447 
02448 void InsertData::Swap(InsertData* other) {
02449   if (other != this) {
02450     std::swap(segment_id_, other->segment_id_);
02451     std::swap(end_segment_, other->end_segment_);
02452     record_.Swap(&other->record_);
02453     std::swap(_has_bits_[0], other->_has_bits_[0]);
02454     _unknown_fields_.Swap(&other->_unknown_fields_);
02455     std::swap(_cached_size_, other->_cached_size_);
02456   }
02457 }
02458 
02459 ::google::protobuf::Metadata InsertData::GetMetadata() const {
02460   protobuf_AssignDescriptorsOnce();
02461   ::google::protobuf::Metadata metadata;
02462   metadata.descriptor = InsertData_descriptor_;
02463   metadata.reflection = InsertData_reflection_;
02464   return metadata;
02465 }
02466 
02467 
02468 // ===================================================================
02469 
02470 #ifndef _MSC_VER
02471 const int UpdateRecord::kKeyValueFieldNumber;
02472 const int UpdateRecord::kAfterValueFieldNumber;
02473 const int UpdateRecord::kBeforeValueFieldNumber;
02474 const int UpdateRecord::kIsNullFieldNumber;
02475 #endif  // !_MSC_VER
02476 
02477 UpdateRecord::UpdateRecord()
02478   : ::google::protobuf::Message() {
02479   SharedCtor();
02480 }
02481 
02482 void UpdateRecord::InitAsDefaultInstance() {
02483 }
02484 
02485 UpdateRecord::UpdateRecord(const UpdateRecord& from)
02486   : ::google::protobuf::Message() {
02487   SharedCtor();
02488   MergeFrom(from);
02489 }
02490 
02491 void UpdateRecord::SharedCtor() {
02492   _cached_size_ = 0;
02493   ::memset(_has_bits_, 0, sizeof(_has_bits_));
02494 }
02495 
02496 UpdateRecord::~UpdateRecord() {
02497   SharedDtor();
02498 }
02499 
02500 void UpdateRecord::SharedDtor() {
02501   if (this != default_instance_) {
02502   }
02503 }
02504 
02505 void UpdateRecord::SetCachedSize(int size) const {
02506   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
02507   _cached_size_ = size;
02508   GOOGLE_SAFE_CONCURRENT_WRITES_END();
02509 }
02510 const ::google::protobuf::Descriptor* UpdateRecord::descriptor() {
02511   protobuf_AssignDescriptorsOnce();
02512   return UpdateRecord_descriptor_;
02513 }
02514 
02515 const UpdateRecord& UpdateRecord::default_instance() {
02516   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
02517 }
02518 
02519 UpdateRecord* UpdateRecord::default_instance_ = NULL;
02520 
02521 UpdateRecord* UpdateRecord::New() const {
02522   return new UpdateRecord;
02523 }
02524 
02525 void UpdateRecord::Clear() {
02526   key_value_.Clear();
02527   after_value_.Clear();
02528   before_value_.Clear();
02529   is_null_.Clear();
02530   ::memset(_has_bits_, 0, sizeof(_has_bits_));
02531   mutable_unknown_fields()->Clear();
02532 }
02533 
02534 bool UpdateRecord::MergePartialFromCodedStream(
02535     ::google::protobuf::io::CodedInputStream* input) {
02536 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
02537   ::google::protobuf::uint32 tag;
02538   while ((tag = input->ReadTag()) != 0) {
02539     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
02540       // repeated bytes key_value = 1;
02541       case 1: {
02542         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02543             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
02544          parse_key_value:
02545           DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
02546                 input, this->add_key_value()));
02547         } else {
02548           goto handle_uninterpreted;
02549         }
02550         if (input->ExpectTag(10)) goto parse_key_value;
02551         if (input->ExpectTag(18)) goto parse_after_value;
02552         break;
02553       }
02554       
02555       // repeated bytes after_value = 2;
02556       case 2: {
02557         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02558             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
02559          parse_after_value:
02560           DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
02561                 input, this->add_after_value()));
02562         } else {
02563           goto handle_uninterpreted;
02564         }
02565         if (input->ExpectTag(18)) goto parse_after_value;
02566         if (input->ExpectTag(26)) goto parse_before_value;
02567         break;
02568       }
02569       
02570       // repeated bytes before_value = 3;
02571       case 3: {
02572         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02573             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
02574          parse_before_value:
02575           DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
02576                 input, this->add_before_value()));
02577         } else {
02578           goto handle_uninterpreted;
02579         }
02580         if (input->ExpectTag(26)) goto parse_before_value;
02581         if (input->ExpectTag(32)) goto parse_is_null;
02582         break;
02583       }
02584       
02585       // repeated bool is_null = 4;
02586       case 4: {
02587         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02588             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
02589          parse_is_null:
02590           DO_((::google::protobuf::internal::WireFormatLite::ReadRepeatedPrimitive<
02591                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
02592                  1, 32, input, this->mutable_is_null())));
02593         } else if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag)
02594                    == ::google::protobuf::internal::WireFormatLite::
02595                       WIRETYPE_LENGTH_DELIMITED) {
02596           DO_((::google::protobuf::internal::WireFormatLite::ReadPackedPrimitiveNoInline<
02597                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
02598                  input, this->mutable_is_null())));
02599         } else {
02600           goto handle_uninterpreted;
02601         }
02602         if (input->ExpectTag(32)) goto parse_is_null;
02603         if (input->ExpectAtEnd()) return true;
02604         break;
02605       }
02606       
02607       default: {
02608       handle_uninterpreted:
02609         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02610             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
02611           return true;
02612         }
02613         DO_(::google::protobuf::internal::WireFormat::SkipField(
02614               input, tag, mutable_unknown_fields()));
02615         break;
02616       }
02617     }
02618   }
02619   return true;
02620 #undef DO_
02621 }
02622 
02623 void UpdateRecord::SerializeWithCachedSizes(
02624     ::google::protobuf::io::CodedOutputStream* output) const {
02625   // repeated bytes key_value = 1;
02626   for (int i = 0; i < this->key_value_size(); i++) {
02627     ::google::protobuf::internal::WireFormatLite::WriteBytes(
02628       1, this->key_value(i), output);
02629   }
02630   
02631   // repeated bytes after_value = 2;
02632   for (int i = 0; i < this->after_value_size(); i++) {
02633     ::google::protobuf::internal::WireFormatLite::WriteBytes(
02634       2, this->after_value(i), output);
02635   }
02636   
02637   // repeated bytes before_value = 3;
02638   for (int i = 0; i < this->before_value_size(); i++) {
02639     ::google::protobuf::internal::WireFormatLite::WriteBytes(
02640       3, this->before_value(i), output);
02641   }
02642   
02643   // repeated bool is_null = 4;
02644   for (int i = 0; i < this->is_null_size(); i++) {
02645     ::google::protobuf::internal::WireFormatLite::WriteBool(
02646       4, this->is_null(i), output);
02647   }
02648   
02649   if (!unknown_fields().empty()) {
02650     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
02651         unknown_fields(), output);
02652   }
02653 }
02654 
02655 ::google::protobuf::uint8* UpdateRecord::SerializeWithCachedSizesToArray(
02656     ::google::protobuf::uint8* target) const {
02657   // repeated bytes key_value = 1;
02658   for (int i = 0; i < this->key_value_size(); i++) {
02659     target = ::google::protobuf::internal::WireFormatLite::
02660       WriteBytesToArray(1, this->key_value(i), target);
02661   }
02662   
02663   // repeated bytes after_value = 2;
02664   for (int i = 0; i < this->after_value_size(); i++) {
02665     target = ::google::protobuf::internal::WireFormatLite::
02666       WriteBytesToArray(2, this->after_value(i), target);
02667   }
02668   
02669   // repeated bytes before_value = 3;
02670   for (int i = 0; i < this->before_value_size(); i++) {
02671     target = ::google::protobuf::internal::WireFormatLite::
02672       WriteBytesToArray(3, this->before_value(i), target);
02673   }
02674   
02675   // repeated bool is_null = 4;
02676   for (int i = 0; i < this->is_null_size(); i++) {
02677     target = ::google::protobuf::internal::WireFormatLite::
02678       WriteBoolToArray(4, this->is_null(i), target);
02679   }
02680   
02681   if (!unknown_fields().empty()) {
02682     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
02683         unknown_fields(), target);
02684   }
02685   return target;
02686 }
02687 
02688 int UpdateRecord::ByteSize() const {
02689   int total_size = 0;
02690   
02691   // repeated bytes key_value = 1;
02692   total_size += 1 * this->key_value_size();
02693   for (int i = 0; i < this->key_value_size(); i++) {
02694     total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
02695       this->key_value(i));
02696   }
02697   
02698   // repeated bytes after_value = 2;
02699   total_size += 1 * this->after_value_size();
02700   for (int i = 0; i < this->after_value_size(); i++) {
02701     total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
02702       this->after_value(i));
02703   }
02704   
02705   // repeated bytes before_value = 3;
02706   total_size += 1 * this->before_value_size();
02707   for (int i = 0; i < this->before_value_size(); i++) {
02708     total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
02709       this->before_value(i));
02710   }
02711   
02712   // repeated bool is_null = 4;
02713   {
02714     int data_size = 0;
02715     data_size = 1 * this->is_null_size();
02716     total_size += 1 * this->is_null_size() + data_size;
02717   }
02718   
02719   if (!unknown_fields().empty()) {
02720     total_size +=
02721       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
02722         unknown_fields());
02723   }
02724   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
02725   _cached_size_ = total_size;
02726   GOOGLE_SAFE_CONCURRENT_WRITES_END();
02727   return total_size;
02728 }
02729 
02730 void UpdateRecord::MergeFrom(const ::google::protobuf::Message& from) {
02731   GOOGLE_CHECK_NE(&from, this);
02732   const UpdateRecord* source =
02733     ::google::protobuf::internal::dynamic_cast_if_available<const UpdateRecord*>(
02734       &from);
02735   if (source == NULL) {
02736     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
02737   } else {
02738     MergeFrom(*source);
02739   }
02740 }
02741 
02742 void UpdateRecord::MergeFrom(const UpdateRecord& from) {
02743   GOOGLE_CHECK_NE(&from, this);
02744   key_value_.MergeFrom(from.key_value_);
02745   after_value_.MergeFrom(from.after_value_);
02746   before_value_.MergeFrom(from.before_value_);
02747   is_null_.MergeFrom(from.is_null_);
02748   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
02749 }
02750 
02751 void UpdateRecord::CopyFrom(const ::google::protobuf::Message& from) {
02752   if (&from == this) return;
02753   Clear();
02754   MergeFrom(from);
02755 }
02756 
02757 void UpdateRecord::CopyFrom(const UpdateRecord& from) {
02758   if (&from == this) return;
02759   Clear();
02760   MergeFrom(from);
02761 }
02762 
02763 bool UpdateRecord::IsInitialized() const {
02764   
02765   return true;
02766 }
02767 
02768 void UpdateRecord::Swap(UpdateRecord* other) {
02769   if (other != this) {
02770     key_value_.Swap(&other->key_value_);
02771     after_value_.Swap(&other->after_value_);
02772     before_value_.Swap(&other->before_value_);
02773     is_null_.Swap(&other->is_null_);
02774     std::swap(_has_bits_[0], other->_has_bits_[0]);
02775     _unknown_fields_.Swap(&other->_unknown_fields_);
02776     std::swap(_cached_size_, other->_cached_size_);
02777   }
02778 }
02779 
02780 ::google::protobuf::Metadata UpdateRecord::GetMetadata() const {
02781   protobuf_AssignDescriptorsOnce();
02782   ::google::protobuf::Metadata metadata;
02783   metadata.descriptor = UpdateRecord_descriptor_;
02784   metadata.reflection = UpdateRecord_reflection_;
02785   return metadata;
02786 }
02787 
02788 
02789 // ===================================================================
02790 
02791 #ifndef _MSC_VER
02792 const int UpdateHeader::kTableMetadataFieldNumber;
02793 const int UpdateHeader::kKeyFieldMetadataFieldNumber;
02794 const int UpdateHeader::kSetFieldMetadataFieldNumber;
02795 #endif  // !_MSC_VER
02796 
02797 UpdateHeader::UpdateHeader()
02798   : ::google::protobuf::Message() {
02799   SharedCtor();
02800 }
02801 
02802 void UpdateHeader::InitAsDefaultInstance() {
02803   table_metadata_ = const_cast< ::drizzled::message::TableMetadata*>(&::drizzled::message::TableMetadata::default_instance());
02804 }
02805 
02806 UpdateHeader::UpdateHeader(const UpdateHeader& from)
02807   : ::google::protobuf::Message() {
02808   SharedCtor();
02809   MergeFrom(from);
02810 }
02811 
02812 void UpdateHeader::SharedCtor() {
02813   _cached_size_ = 0;
02814   table_metadata_ = NULL;
02815   ::memset(_has_bits_, 0, sizeof(_has_bits_));
02816 }
02817 
02818 UpdateHeader::~UpdateHeader() {
02819   SharedDtor();
02820 }
02821 
02822 void UpdateHeader::SharedDtor() {
02823   if (this != default_instance_) {
02824     delete table_metadata_;
02825   }
02826 }
02827 
02828 void UpdateHeader::SetCachedSize(int size) const {
02829   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
02830   _cached_size_ = size;
02831   GOOGLE_SAFE_CONCURRENT_WRITES_END();
02832 }
02833 const ::google::protobuf::Descriptor* UpdateHeader::descriptor() {
02834   protobuf_AssignDescriptorsOnce();
02835   return UpdateHeader_descriptor_;
02836 }
02837 
02838 const UpdateHeader& UpdateHeader::default_instance() {
02839   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
02840 }
02841 
02842 UpdateHeader* UpdateHeader::default_instance_ = NULL;
02843 
02844 UpdateHeader* UpdateHeader::New() const {
02845   return new UpdateHeader;
02846 }
02847 
02848 void UpdateHeader::Clear() {
02849   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
02850     if (_has_bit(0)) {
02851       if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
02852     }
02853   }
02854   key_field_metadata_.Clear();
02855   set_field_metadata_.Clear();
02856   ::memset(_has_bits_, 0, sizeof(_has_bits_));
02857   mutable_unknown_fields()->Clear();
02858 }
02859 
02860 bool UpdateHeader::MergePartialFromCodedStream(
02861     ::google::protobuf::io::CodedInputStream* input) {
02862 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
02863   ::google::protobuf::uint32 tag;
02864   while ((tag = input->ReadTag()) != 0) {
02865     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
02866       // required .drizzled.message.TableMetadata table_metadata = 1;
02867       case 1: {
02868         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02869             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
02870           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
02871                input, mutable_table_metadata()));
02872         } else {
02873           goto handle_uninterpreted;
02874         }
02875         if (input->ExpectTag(18)) goto parse_key_field_metadata;
02876         break;
02877       }
02878       
02879       // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
02880       case 2: {
02881         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02882             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
02883          parse_key_field_metadata:
02884           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
02885                 input, add_key_field_metadata()));
02886         } else {
02887           goto handle_uninterpreted;
02888         }
02889         if (input->ExpectTag(18)) goto parse_key_field_metadata;
02890         if (input->ExpectTag(26)) goto parse_set_field_metadata;
02891         break;
02892       }
02893       
02894       // repeated .drizzled.message.FieldMetadata set_field_metadata = 3;
02895       case 3: {
02896         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02897             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
02898          parse_set_field_metadata:
02899           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
02900                 input, add_set_field_metadata()));
02901         } else {
02902           goto handle_uninterpreted;
02903         }
02904         if (input->ExpectTag(26)) goto parse_set_field_metadata;
02905         if (input->ExpectAtEnd()) return true;
02906         break;
02907       }
02908       
02909       default: {
02910       handle_uninterpreted:
02911         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
02912             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
02913           return true;
02914         }
02915         DO_(::google::protobuf::internal::WireFormat::SkipField(
02916               input, tag, mutable_unknown_fields()));
02917         break;
02918       }
02919     }
02920   }
02921   return true;
02922 #undef DO_
02923 }
02924 
02925 void UpdateHeader::SerializeWithCachedSizes(
02926     ::google::protobuf::io::CodedOutputStream* output) const {
02927   // required .drizzled.message.TableMetadata table_metadata = 1;
02928   if (_has_bit(0)) {
02929     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
02930       1, this->table_metadata(), output);
02931   }
02932   
02933   // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
02934   for (int i = 0; i < this->key_field_metadata_size(); i++) {
02935     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
02936       2, this->key_field_metadata(i), output);
02937   }
02938   
02939   // repeated .drizzled.message.FieldMetadata set_field_metadata = 3;
02940   for (int i = 0; i < this->set_field_metadata_size(); i++) {
02941     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
02942       3, this->set_field_metadata(i), output);
02943   }
02944   
02945   if (!unknown_fields().empty()) {
02946     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
02947         unknown_fields(), output);
02948   }
02949 }
02950 
02951 ::google::protobuf::uint8* UpdateHeader::SerializeWithCachedSizesToArray(
02952     ::google::protobuf::uint8* target) const {
02953   // required .drizzled.message.TableMetadata table_metadata = 1;
02954   if (_has_bit(0)) {
02955     target = ::google::protobuf::internal::WireFormatLite::
02956       WriteMessageNoVirtualToArray(
02957         1, this->table_metadata(), target);
02958   }
02959   
02960   // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
02961   for (int i = 0; i < this->key_field_metadata_size(); i++) {
02962     target = ::google::protobuf::internal::WireFormatLite::
02963       WriteMessageNoVirtualToArray(
02964         2, this->key_field_metadata(i), target);
02965   }
02966   
02967   // repeated .drizzled.message.FieldMetadata set_field_metadata = 3;
02968   for (int i = 0; i < this->set_field_metadata_size(); i++) {
02969     target = ::google::protobuf::internal::WireFormatLite::
02970       WriteMessageNoVirtualToArray(
02971         3, this->set_field_metadata(i), target);
02972   }
02973   
02974   if (!unknown_fields().empty()) {
02975     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
02976         unknown_fields(), target);
02977   }
02978   return target;
02979 }
02980 
02981 int UpdateHeader::ByteSize() const {
02982   int total_size = 0;
02983   
02984   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
02985     // required .drizzled.message.TableMetadata table_metadata = 1;
02986     if (has_table_metadata()) {
02987       total_size += 1 +
02988         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
02989           this->table_metadata());
02990     }
02991     
02992   }
02993   // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
02994   total_size += 1 * this->key_field_metadata_size();
02995   for (int i = 0; i < this->key_field_metadata_size(); i++) {
02996     total_size +=
02997       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
02998         this->key_field_metadata(i));
02999   }
03000   
03001   // repeated .drizzled.message.FieldMetadata set_field_metadata = 3;
03002   total_size += 1 * this->set_field_metadata_size();
03003   for (int i = 0; i < this->set_field_metadata_size(); i++) {
03004     total_size +=
03005       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
03006         this->set_field_metadata(i));
03007   }
03008   
03009   if (!unknown_fields().empty()) {
03010     total_size +=
03011       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
03012         unknown_fields());
03013   }
03014   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
03015   _cached_size_ = total_size;
03016   GOOGLE_SAFE_CONCURRENT_WRITES_END();
03017   return total_size;
03018 }
03019 
03020 void UpdateHeader::MergeFrom(const ::google::protobuf::Message& from) {
03021   GOOGLE_CHECK_NE(&from, this);
03022   const UpdateHeader* source =
03023     ::google::protobuf::internal::dynamic_cast_if_available<const UpdateHeader*>(
03024       &from);
03025   if (source == NULL) {
03026     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
03027   } else {
03028     MergeFrom(*source);
03029   }
03030 }
03031 
03032 void UpdateHeader::MergeFrom(const UpdateHeader& from) {
03033   GOOGLE_CHECK_NE(&from, this);
03034   key_field_metadata_.MergeFrom(from.key_field_metadata_);
03035   set_field_metadata_.MergeFrom(from.set_field_metadata_);
03036   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
03037     if (from._has_bit(0)) {
03038       mutable_table_metadata()->::drizzled::message::TableMetadata::MergeFrom(from.table_metadata());
03039     }
03040   }
03041   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
03042 }
03043 
03044 void UpdateHeader::CopyFrom(const ::google::protobuf::Message& from) {
03045   if (&from == this) return;
03046   Clear();
03047   MergeFrom(from);
03048 }
03049 
03050 void UpdateHeader::CopyFrom(const UpdateHeader& from) {
03051   if (&from == this) return;
03052   Clear();
03053   MergeFrom(from);
03054 }
03055 
03056 bool UpdateHeader::IsInitialized() const {
03057   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
03058   
03059   if (has_table_metadata()) {
03060     if (!this->table_metadata().IsInitialized()) return false;
03061   }
03062   for (int i = 0; i < key_field_metadata_size(); i++) {
03063     if (!this->key_field_metadata(i).IsInitialized()) return false;
03064   }
03065   for (int i = 0; i < set_field_metadata_size(); i++) {
03066     if (!this->set_field_metadata(i).IsInitialized()) return false;
03067   }
03068   return true;
03069 }
03070 
03071 void UpdateHeader::Swap(UpdateHeader* other) {
03072   if (other != this) {
03073     std::swap(table_metadata_, other->table_metadata_);
03074     key_field_metadata_.Swap(&other->key_field_metadata_);
03075     set_field_metadata_.Swap(&other->set_field_metadata_);
03076     std::swap(_has_bits_[0], other->_has_bits_[0]);
03077     _unknown_fields_.Swap(&other->_unknown_fields_);
03078     std::swap(_cached_size_, other->_cached_size_);
03079   }
03080 }
03081 
03082 ::google::protobuf::Metadata UpdateHeader::GetMetadata() const {
03083   protobuf_AssignDescriptorsOnce();
03084   ::google::protobuf::Metadata metadata;
03085   metadata.descriptor = UpdateHeader_descriptor_;
03086   metadata.reflection = UpdateHeader_reflection_;
03087   return metadata;
03088 }
03089 
03090 
03091 // ===================================================================
03092 
03093 #ifndef _MSC_VER
03094 const int UpdateData::kSegmentIdFieldNumber;
03095 const int UpdateData::kEndSegmentFieldNumber;
03096 const int UpdateData::kRecordFieldNumber;
03097 #endif  // !_MSC_VER
03098 
03099 UpdateData::UpdateData()
03100   : ::google::protobuf::Message() {
03101   SharedCtor();
03102 }
03103 
03104 void UpdateData::InitAsDefaultInstance() {
03105 }
03106 
03107 UpdateData::UpdateData(const UpdateData& from)
03108   : ::google::protobuf::Message() {
03109   SharedCtor();
03110   MergeFrom(from);
03111 }
03112 
03113 void UpdateData::SharedCtor() {
03114   _cached_size_ = 0;
03115   segment_id_ = 0u;
03116   end_segment_ = false;
03117   ::memset(_has_bits_, 0, sizeof(_has_bits_));
03118 }
03119 
03120 UpdateData::~UpdateData() {
03121   SharedDtor();
03122 }
03123 
03124 void UpdateData::SharedDtor() {
03125   if (this != default_instance_) {
03126   }
03127 }
03128 
03129 void UpdateData::SetCachedSize(int size) const {
03130   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
03131   _cached_size_ = size;
03132   GOOGLE_SAFE_CONCURRENT_WRITES_END();
03133 }
03134 const ::google::protobuf::Descriptor* UpdateData::descriptor() {
03135   protobuf_AssignDescriptorsOnce();
03136   return UpdateData_descriptor_;
03137 }
03138 
03139 const UpdateData& UpdateData::default_instance() {
03140   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
03141 }
03142 
03143 UpdateData* UpdateData::default_instance_ = NULL;
03144 
03145 UpdateData* UpdateData::New() const {
03146   return new UpdateData;
03147 }
03148 
03149 void UpdateData::Clear() {
03150   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
03151     segment_id_ = 0u;
03152     end_segment_ = false;
03153   }
03154   record_.Clear();
03155   ::memset(_has_bits_, 0, sizeof(_has_bits_));
03156   mutable_unknown_fields()->Clear();
03157 }
03158 
03159 bool UpdateData::MergePartialFromCodedStream(
03160     ::google::protobuf::io::CodedInputStream* input) {
03161 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
03162   ::google::protobuf::uint32 tag;
03163   while ((tag = input->ReadTag()) != 0) {
03164     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
03165       // required uint32 segment_id = 1;
03166       case 1: {
03167         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
03168             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
03169           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
03170                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
03171                  input, &segment_id_)));
03172           _set_bit(0);
03173         } else {
03174           goto handle_uninterpreted;
03175         }
03176         if (input->ExpectTag(16)) goto parse_end_segment;
03177         break;
03178       }
03179       
03180       // required bool end_segment = 2;
03181       case 2: {
03182         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
03183             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
03184          parse_end_segment:
03185           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
03186                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
03187                  input, &end_segment_)));
03188           _set_bit(1);
03189         } else {
03190           goto handle_uninterpreted;
03191         }
03192         if (input->ExpectTag(26)) goto parse_record;
03193         break;
03194       }
03195       
03196       // repeated .drizzled.message.UpdateRecord record = 3;
03197       case 3: {
03198         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
03199             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
03200          parse_record:
03201           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
03202                 input, add_record()));
03203         } else {
03204           goto handle_uninterpreted;
03205         }
03206         if (input->ExpectTag(26)) goto parse_record;
03207         if (input->ExpectAtEnd()) return true;
03208         break;
03209       }
03210       
03211       default: {
03212       handle_uninterpreted:
03213         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
03214             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
03215           return true;
03216         }
03217         DO_(::google::protobuf::internal::WireFormat::SkipField(
03218               input, tag, mutable_unknown_fields()));
03219         break;
03220       }
03221     }
03222   }
03223   return true;
03224 #undef DO_
03225 }
03226 
03227 void UpdateData::SerializeWithCachedSizes(
03228     ::google::protobuf::io::CodedOutputStream* output) const {
03229   // required uint32 segment_id = 1;
03230   if (_has_bit(0)) {
03231     ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->segment_id(), output);
03232   }
03233   
03234   // required bool end_segment = 2;
03235   if (_has_bit(1)) {
03236     ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->end_segment(), output);
03237   }
03238   
03239   // repeated .drizzled.message.UpdateRecord record = 3;
03240   for (int i = 0; i < this->record_size(); i++) {
03241     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
03242       3, this->record(i), output);
03243   }
03244   
03245   if (!unknown_fields().empty()) {
03246     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
03247         unknown_fields(), output);
03248   }
03249 }
03250 
03251 ::google::protobuf::uint8* UpdateData::SerializeWithCachedSizesToArray(
03252     ::google::protobuf::uint8* target) const {
03253   // required uint32 segment_id = 1;
03254   if (_has_bit(0)) {
03255     target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->segment_id(), target);
03256   }
03257   
03258   // required bool end_segment = 2;
03259   if (_has_bit(1)) {
03260     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->end_segment(), target);
03261   }
03262   
03263   // repeated .drizzled.message.UpdateRecord record = 3;
03264   for (int i = 0; i < this->record_size(); i++) {
03265     target = ::google::protobuf::internal::WireFormatLite::
03266       WriteMessageNoVirtualToArray(
03267         3, this->record(i), target);
03268   }
03269   
03270   if (!unknown_fields().empty()) {
03271     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
03272         unknown_fields(), target);
03273   }
03274   return target;
03275 }
03276 
03277 int UpdateData::ByteSize() const {
03278   int total_size = 0;
03279   
03280   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
03281     // required uint32 segment_id = 1;
03282     if (has_segment_id()) {
03283       total_size += 1 +
03284         ::google::protobuf::internal::WireFormatLite::UInt32Size(
03285           this->segment_id());
03286     }
03287     
03288     // required bool end_segment = 2;
03289     if (has_end_segment()) {
03290       total_size += 1 + 1;
03291     }
03292     
03293   }
03294   // repeated .drizzled.message.UpdateRecord record = 3;
03295   total_size += 1 * this->record_size();
03296   for (int i = 0; i < this->record_size(); i++) {
03297     total_size +=
03298       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
03299         this->record(i));
03300   }
03301   
03302   if (!unknown_fields().empty()) {
03303     total_size +=
03304       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
03305         unknown_fields());
03306   }
03307   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
03308   _cached_size_ = total_size;
03309   GOOGLE_SAFE_CONCURRENT_WRITES_END();
03310   return total_size;
03311 }
03312 
03313 void UpdateData::MergeFrom(const ::google::protobuf::Message& from) {
03314   GOOGLE_CHECK_NE(&from, this);
03315   const UpdateData* source =
03316     ::google::protobuf::internal::dynamic_cast_if_available<const UpdateData*>(
03317       &from);
03318   if (source == NULL) {
03319     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
03320   } else {
03321     MergeFrom(*source);
03322   }
03323 }
03324 
03325 void UpdateData::MergeFrom(const UpdateData& from) {
03326   GOOGLE_CHECK_NE(&from, this);
03327   record_.MergeFrom(from.record_);
03328   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
03329     if (from._has_bit(0)) {
03330       set_segment_id(from.segment_id());
03331     }
03332     if (from._has_bit(1)) {
03333       set_end_segment(from.end_segment());
03334     }
03335   }
03336   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
03337 }
03338 
03339 void UpdateData::CopyFrom(const ::google::protobuf::Message& from) {
03340   if (&from == this) return;
03341   Clear();
03342   MergeFrom(from);
03343 }
03344 
03345 void UpdateData::CopyFrom(const UpdateData& from) {
03346   if (&from == this) return;
03347   Clear();
03348   MergeFrom(from);
03349 }
03350 
03351 bool UpdateData::IsInitialized() const {
03352   if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
03353   
03354   return true;
03355 }
03356 
03357 void UpdateData::Swap(UpdateData* other) {
03358   if (other != this) {
03359     std::swap(segment_id_, other->segment_id_);
03360     std::swap(end_segment_, other->end_segment_);
03361     record_.Swap(&other->record_);
03362     std::swap(_has_bits_[0], other->_has_bits_[0]);
03363     _unknown_fields_.Swap(&other->_unknown_fields_);
03364     std::swap(_cached_size_, other->_cached_size_);
03365   }
03366 }
03367 
03368 ::google::protobuf::Metadata UpdateData::GetMetadata() const {
03369   protobuf_AssignDescriptorsOnce();
03370   ::google::protobuf::Metadata metadata;
03371   metadata.descriptor = UpdateData_descriptor_;
03372   metadata.reflection = UpdateData_reflection_;
03373   return metadata;
03374 }
03375 
03376 
03377 // ===================================================================
03378 
03379 #ifndef _MSC_VER
03380 const int DeleteRecord::kKeyValueFieldNumber;
03381 #endif  // !_MSC_VER
03382 
03383 DeleteRecord::DeleteRecord()
03384   : ::google::protobuf::Message() {
03385   SharedCtor();
03386 }
03387 
03388 void DeleteRecord::InitAsDefaultInstance() {
03389 }
03390 
03391 DeleteRecord::DeleteRecord(const DeleteRecord& from)
03392   : ::google::protobuf::Message() {
03393   SharedCtor();
03394   MergeFrom(from);
03395 }
03396 
03397 void DeleteRecord::SharedCtor() {
03398   _cached_size_ = 0;
03399   ::memset(_has_bits_, 0, sizeof(_has_bits_));
03400 }
03401 
03402 DeleteRecord::~DeleteRecord() {
03403   SharedDtor();
03404 }
03405 
03406 void DeleteRecord::SharedDtor() {
03407   if (this != default_instance_) {
03408   }
03409 }
03410 
03411 void DeleteRecord::SetCachedSize(int size) const {
03412   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
03413   _cached_size_ = size;
03414   GOOGLE_SAFE_CONCURRENT_WRITES_END();
03415 }
03416 const ::google::protobuf::Descriptor* DeleteRecord::descriptor() {
03417   protobuf_AssignDescriptorsOnce();
03418   return DeleteRecord_descriptor_;
03419 }
03420 
03421 const DeleteRecord& DeleteRecord::default_instance() {
03422   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
03423 }
03424 
03425 DeleteRecord* DeleteRecord::default_instance_ = NULL;
03426 
03427 DeleteRecord* DeleteRecord::New() const {
03428   return new DeleteRecord;
03429 }
03430 
03431 void DeleteRecord::Clear() {
03432   key_value_.Clear();
03433   ::memset(_has_bits_, 0, sizeof(_has_bits_));
03434   mutable_unknown_fields()->Clear();
03435 }
03436 
03437 bool DeleteRecord::MergePartialFromCodedStream(
03438     ::google::protobuf::io::CodedInputStream* input) {
03439 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
03440   ::google::protobuf::uint32 tag;
03441   while ((tag = input->ReadTag()) != 0) {
03442     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
03443       // repeated bytes key_value = 1;
03444       case 1: {
03445         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
03446             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
03447          parse_key_value:
03448           DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
03449                 input, this->add_key_value()));
03450         } else {
03451           goto handle_uninterpreted;
03452         }
03453         if (input->ExpectTag(10)) goto parse_key_value;
03454         if (input->ExpectAtEnd()) return true;
03455         break;
03456       }
03457       
03458       default: {
03459       handle_uninterpreted:
03460         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
03461             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
03462           return true;
03463         }
03464         DO_(::google::protobuf::internal::WireFormat::SkipField(
03465               input, tag, mutable_unknown_fields()));
03466         break;
03467       }
03468     }
03469   }
03470   return true;
03471 #undef DO_
03472 }
03473 
03474 void DeleteRecord::SerializeWithCachedSizes(
03475     ::google::protobuf::io::CodedOutputStream* output) const {
03476   // repeated bytes key_value = 1;
03477   for (int i = 0; i < this->key_value_size(); i++) {
03478     ::google::protobuf::internal::WireFormatLite::WriteBytes(
03479       1, this->key_value(i), output);
03480   }
03481   
03482   if (!unknown_fields().empty()) {
03483     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
03484         unknown_fields(), output);
03485   }
03486 }
03487 
03488 ::google::protobuf::uint8* DeleteRecord::SerializeWithCachedSizesToArray(
03489     ::google::protobuf::uint8* target) const {
03490   // repeated bytes key_value = 1;
03491   for (int i = 0; i < this->key_value_size(); i++) {
03492     target = ::google::protobuf::internal::WireFormatLite::
03493       WriteBytesToArray(1, this->key_value(i), target);
03494   }
03495   
03496   if (!unknown_fields().empty()) {
03497     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
03498         unknown_fields(), target);
03499   }
03500   return target;
03501 }
03502 
03503 int DeleteRecord::ByteSize() const {
03504   int total_size = 0;
03505   
03506   // repeated bytes key_value = 1;
03507   total_size += 1 * this->key_value_size();
03508   for (int i = 0; i < this->key_value_size(); i++) {
03509     total_size += ::google::protobuf::internal::WireFormatLite::BytesSize(
03510       this->key_value(i));
03511   }
03512   
03513   if (!unknown_fields().empty()) {
03514     total_size +=
03515       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
03516         unknown_fields());
03517   }
03518   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
03519   _cached_size_ = total_size;
03520   GOOGLE_SAFE_CONCURRENT_WRITES_END();
03521   return total_size;
03522 }
03523 
03524 void DeleteRecord::MergeFrom(const ::google::protobuf::Message& from) {
03525   GOOGLE_CHECK_NE(&from, this);
03526   const DeleteRecord* source =
03527     ::google::protobuf::internal::dynamic_cast_if_available<const DeleteRecord*>(
03528       &from);
03529   if (source == NULL) {
03530     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
03531   } else {
03532     MergeFrom(*source);
03533   }
03534 }
03535 
03536 void DeleteRecord::MergeFrom(const DeleteRecord& from) {
03537   GOOGLE_CHECK_NE(&from, this);
03538   key_value_.MergeFrom(from.key_value_);
03539   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
03540 }
03541 
03542 void DeleteRecord::CopyFrom(const ::google::protobuf::Message& from) {
03543   if (&from == this) return;
03544   Clear();
03545   MergeFrom(from);
03546 }
03547 
03548 void DeleteRecord::CopyFrom(const DeleteRecord& from) {
03549   if (&from == this) return;
03550   Clear();
03551   MergeFrom(from);
03552 }
03553 
03554 bool DeleteRecord::IsInitialized() const {
03555   
03556   return true;
03557 }
03558 
03559 void DeleteRecord::Swap(DeleteRecord* other) {
03560   if (other != this) {
03561     key_value_.Swap(&other->key_value_);
03562     std::swap(_has_bits_[0], other->_has_bits_[0]);
03563     _unknown_fields_.Swap(&other->_unknown_fields_);
03564     std::swap(_cached_size_, other->_cached_size_);
03565   }
03566 }
03567 
03568 ::google::protobuf::Metadata DeleteRecord::GetMetadata() const {
03569   protobuf_AssignDescriptorsOnce();
03570   ::google::protobuf::Metadata metadata;
03571   metadata.descriptor = DeleteRecord_descriptor_;
03572   metadata.reflection = DeleteRecord_reflection_;
03573   return metadata;
03574 }
03575 
03576 
03577 // ===================================================================
03578 
03579 #ifndef _MSC_VER
03580 const int DeleteHeader::kTableMetadataFieldNumber;
03581 const int DeleteHeader::kKeyFieldMetadataFieldNumber;
03582 #endif  // !_MSC_VER
03583 
03584 DeleteHeader::DeleteHeader()
03585   : ::google::protobuf::Message() {
03586   SharedCtor();
03587 }
03588 
03589 void DeleteHeader::InitAsDefaultInstance() {
03590   table_metadata_ = const_cast< ::drizzled::message::TableMetadata*>(&::drizzled::message::TableMetadata::default_instance());
03591 }
03592 
03593 DeleteHeader::DeleteHeader(const DeleteHeader& from)
03594   : ::google::protobuf::Message() {
03595   SharedCtor();
03596   MergeFrom(from);
03597 }
03598 
03599 void DeleteHeader::SharedCtor() {
03600   _cached_size_ = 0;
03601   table_metadata_ = NULL;
03602   ::memset(_has_bits_, 0, sizeof(_has_bits_));
03603 }
03604 
03605 DeleteHeader::~DeleteHeader() {
03606   SharedDtor();
03607 }
03608 
03609 void DeleteHeader::SharedDtor() {
03610   if (this != default_instance_) {
03611     delete table_metadata_;
03612   }
03613 }
03614 
03615 void DeleteHeader::SetCachedSize(int size) const {
03616   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
03617   _cached_size_ = size;
03618   GOOGLE_SAFE_CONCURRENT_WRITES_END();
03619 }
03620 const ::google::protobuf::Descriptor* DeleteHeader::descriptor() {
03621   protobuf_AssignDescriptorsOnce();
03622   return DeleteHeader_descriptor_;
03623 }
03624 
03625 const DeleteHeader& DeleteHeader::default_instance() {
03626   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
03627 }
03628 
03629 DeleteHeader* DeleteHeader::default_instance_ = NULL;
03630 
03631 DeleteHeader* DeleteHeader::New() const {
03632   return new DeleteHeader;
03633 }
03634 
03635 void DeleteHeader::Clear() {
03636   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
03637     if (_has_bit(0)) {
03638       if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
03639     }
03640   }
03641   key_field_metadata_.Clear();
03642   ::memset(_has_bits_, 0, sizeof(_has_bits_));
03643   mutable_unknown_fields()->Clear();
03644 }
03645 
03646 bool DeleteHeader::MergePartialFromCodedStream(
03647     ::google::protobuf::io::CodedInputStream* input) {
03648 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
03649   ::google::protobuf::uint32 tag;
03650   while ((tag = input->ReadTag()) != 0) {
03651     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
03652       // required .drizzled.message.TableMetadata table_metadata = 1;
03653       case 1: {
03654         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
03655             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
03656           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
03657                input, mutable_table_metadata()));
03658         } else {
03659           goto handle_uninterpreted;
03660         }
03661         if (input->ExpectTag(18)) goto parse_key_field_metadata;
03662         break;
03663       }
03664       
03665       // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
03666       case 2: {
03667         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
03668             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
03669          parse_key_field_metadata:
03670           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
03671                 input, add_key_field_metadata()));
03672         } else {
03673           goto handle_uninterpreted;
03674         }
03675         if (input->ExpectTag(18)) goto parse_key_field_metadata;
03676         if (input->ExpectAtEnd()) return true;
03677         break;
03678       }
03679       
03680       default: {
03681       handle_uninterpreted:
03682         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
03683             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
03684           return true;
03685         }
03686         DO_(::google::protobuf::internal::WireFormat::SkipField(
03687               input, tag, mutable_unknown_fields()));
03688         break;
03689       }
03690     }
03691   }
03692   return true;
03693 #undef DO_
03694 }
03695 
03696 void DeleteHeader::SerializeWithCachedSizes(
03697     ::google::protobuf::io::CodedOutputStream* output) const {
03698   // required .drizzled.message.TableMetadata table_metadata = 1;
03699   if (_has_bit(0)) {
03700     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
03701       1, this->table_metadata(), output);
03702   }
03703   
03704   // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
03705   for (int i = 0; i < this->key_field_metadata_size(); i++) {
03706     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
03707       2, this->key_field_metadata(i), output);
03708   }
03709   
03710   if (!unknown_fields().empty()) {
03711     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
03712         unknown_fields(), output);
03713   }
03714 }
03715 
03716 ::google::protobuf::uint8* DeleteHeader::SerializeWithCachedSizesToArray(
03717     ::google::protobuf::uint8* target) const {
03718   // required .drizzled.message.TableMetadata table_metadata = 1;
03719   if (_has_bit(0)) {
03720     target = ::google::protobuf::internal::WireFormatLite::
03721       WriteMessageNoVirtualToArray(
03722         1, this->table_metadata(), target);
03723   }
03724   
03725   // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
03726   for (int i = 0; i < this->key_field_metadata_size(); i++) {
03727     target = ::google::protobuf::internal::WireFormatLite::
03728       WriteMessageNoVirtualToArray(
03729         2, this->key_field_metadata(i), target);
03730   }
03731   
03732   if (!unknown_fields().empty()) {
03733     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
03734         unknown_fields(), target);
03735   }
03736   return target;
03737 }
03738 
03739 int DeleteHeader::ByteSize() const {
03740   int total_size = 0;
03741   
03742   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
03743     // required .drizzled.message.TableMetadata table_metadata = 1;
03744     if (has_table_metadata()) {
03745       total_size += 1 +
03746         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
03747           this->table_metadata());
03748     }
03749     
03750   }
03751   // repeated .drizzled.message.FieldMetadata key_field_metadata = 2;
03752   total_size += 1 * this->key_field_metadata_size();
03753   for (int i = 0; i < this->key_field_metadata_size(); i++) {
03754     total_size +=
03755       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
03756         this->key_field_metadata(i));
03757   }
03758   
03759   if (!unknown_fields().empty()) {
03760     total_size +=
03761       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
03762         unknown_fields());
03763   }
03764   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
03765   _cached_size_ = total_size;
03766   GOOGLE_SAFE_CONCURRENT_WRITES_END();
03767   return total_size;
03768 }
03769 
03770 void DeleteHeader::MergeFrom(const ::google::protobuf::Message& from) {
03771   GOOGLE_CHECK_NE(&from, this);
03772   const DeleteHeader* source =
03773     ::google::protobuf::internal::dynamic_cast_if_available<const DeleteHeader*>(
03774       &from);
03775   if (source == NULL) {
03776     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
03777   } else {
03778     MergeFrom(*source);
03779   }
03780 }
03781 
03782 void DeleteHeader::MergeFrom(const DeleteHeader& from) {
03783   GOOGLE_CHECK_NE(&from, this);
03784   key_field_metadata_.MergeFrom(from.key_field_metadata_);
03785   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
03786     if (from._has_bit(0)) {
03787       mutable_table_metadata()->::drizzled::message::TableMetadata::MergeFrom(from.table_metadata());
03788     }
03789   }
03790   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
03791 }
03792 
03793 void DeleteHeader::CopyFrom(const ::google::protobuf::Message& from) {
03794   if (&from == this) return;
03795   Clear();
03796   MergeFrom(from);
03797 }
03798 
03799 void DeleteHeader::CopyFrom(const DeleteHeader& from) {
03800   if (&from == this) return;
03801   Clear();
03802   MergeFrom(from);
03803 }
03804 
03805 bool DeleteHeader::IsInitialized() const {
03806   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
03807   
03808   if (has_table_metadata()) {
03809     if (!this->table_metadata().IsInitialized()) return false;
03810   }
03811   for (int i = 0; i < key_field_metadata_size(); i++) {
03812     if (!this->key_field_metadata(i).IsInitialized()) return false;
03813   }
03814   return true;
03815 }
03816 
03817 void DeleteHeader::Swap(DeleteHeader* other) {
03818   if (other != this) {
03819     std::swap(table_metadata_, other->table_metadata_);
03820     key_field_metadata_.Swap(&other->key_field_metadata_);
03821     std::swap(_has_bits_[0], other->_has_bits_[0]);
03822     _unknown_fields_.Swap(&other->_unknown_fields_);
03823     std::swap(_cached_size_, other->_cached_size_);
03824   }
03825 }
03826 
03827 ::google::protobuf::Metadata DeleteHeader::GetMetadata() const {
03828   protobuf_AssignDescriptorsOnce();
03829   ::google::protobuf::Metadata metadata;
03830   metadata.descriptor = DeleteHeader_descriptor_;
03831   metadata.reflection = DeleteHeader_reflection_;
03832   return metadata;
03833 }
03834 
03835 
03836 // ===================================================================
03837 
03838 #ifndef _MSC_VER
03839 const int DeleteData::kSegmentIdFieldNumber;
03840 const int DeleteData::kEndSegmentFieldNumber;
03841 const int DeleteData::kRecordFieldNumber;
03842 #endif  // !_MSC_VER
03843 
03844 DeleteData::DeleteData()
03845   : ::google::protobuf::Message() {
03846   SharedCtor();
03847 }
03848 
03849 void DeleteData::InitAsDefaultInstance() {
03850 }
03851 
03852 DeleteData::DeleteData(const DeleteData& from)
03853   : ::google::protobuf::Message() {
03854   SharedCtor();
03855   MergeFrom(from);
03856 }
03857 
03858 void DeleteData::SharedCtor() {
03859   _cached_size_ = 0;
03860   segment_id_ = 0u;
03861   end_segment_ = false;
03862   ::memset(_has_bits_, 0, sizeof(_has_bits_));
03863 }
03864 
03865 DeleteData::~DeleteData() {
03866   SharedDtor();
03867 }
03868 
03869 void DeleteData::SharedDtor() {
03870   if (this != default_instance_) {
03871   }
03872 }
03873 
03874 void DeleteData::SetCachedSize(int size) const {
03875   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
03876   _cached_size_ = size;
03877   GOOGLE_SAFE_CONCURRENT_WRITES_END();
03878 }
03879 const ::google::protobuf::Descriptor* DeleteData::descriptor() {
03880   protobuf_AssignDescriptorsOnce();
03881   return DeleteData_descriptor_;
03882 }
03883 
03884 const DeleteData& DeleteData::default_instance() {
03885   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
03886 }
03887 
03888 DeleteData* DeleteData::default_instance_ = NULL;
03889 
03890 DeleteData* DeleteData::New() const {
03891   return new DeleteData;
03892 }
03893 
03894 void DeleteData::Clear() {
03895   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
03896     segment_id_ = 0u;
03897     end_segment_ = false;
03898   }
03899   record_.Clear();
03900   ::memset(_has_bits_, 0, sizeof(_has_bits_));
03901   mutable_unknown_fields()->Clear();
03902 }
03903 
03904 bool DeleteData::MergePartialFromCodedStream(
03905     ::google::protobuf::io::CodedInputStream* input) {
03906 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
03907   ::google::protobuf::uint32 tag;
03908   while ((tag = input->ReadTag()) != 0) {
03909     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
03910       // required uint32 segment_id = 1;
03911       case 1: {
03912         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
03913             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
03914           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
03915                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
03916                  input, &segment_id_)));
03917           _set_bit(0);
03918         } else {
03919           goto handle_uninterpreted;
03920         }
03921         if (input->ExpectTag(16)) goto parse_end_segment;
03922         break;
03923       }
03924       
03925       // required bool end_segment = 2;
03926       case 2: {
03927         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
03928             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
03929          parse_end_segment:
03930           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
03931                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
03932                  input, &end_segment_)));
03933           _set_bit(1);
03934         } else {
03935           goto handle_uninterpreted;
03936         }
03937         if (input->ExpectTag(26)) goto parse_record;
03938         break;
03939       }
03940       
03941       // repeated .drizzled.message.DeleteRecord record = 3;
03942       case 3: {
03943         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
03944             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
03945          parse_record:
03946           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
03947                 input, add_record()));
03948         } else {
03949           goto handle_uninterpreted;
03950         }
03951         if (input->ExpectTag(26)) goto parse_record;
03952         if (input->ExpectAtEnd()) return true;
03953         break;
03954       }
03955       
03956       default: {
03957       handle_uninterpreted:
03958         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
03959             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
03960           return true;
03961         }
03962         DO_(::google::protobuf::internal::WireFormat::SkipField(
03963               input, tag, mutable_unknown_fields()));
03964         break;
03965       }
03966     }
03967   }
03968   return true;
03969 #undef DO_
03970 }
03971 
03972 void DeleteData::SerializeWithCachedSizes(
03973     ::google::protobuf::io::CodedOutputStream* output) const {
03974   // required uint32 segment_id = 1;
03975   if (_has_bit(0)) {
03976     ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->segment_id(), output);
03977   }
03978   
03979   // required bool end_segment = 2;
03980   if (_has_bit(1)) {
03981     ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->end_segment(), output);
03982   }
03983   
03984   // repeated .drizzled.message.DeleteRecord record = 3;
03985   for (int i = 0; i < this->record_size(); i++) {
03986     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
03987       3, this->record(i), output);
03988   }
03989   
03990   if (!unknown_fields().empty()) {
03991     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
03992         unknown_fields(), output);
03993   }
03994 }
03995 
03996 ::google::protobuf::uint8* DeleteData::SerializeWithCachedSizesToArray(
03997     ::google::protobuf::uint8* target) const {
03998   // required uint32 segment_id = 1;
03999   if (_has_bit(0)) {
04000     target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->segment_id(), target);
04001   }
04002   
04003   // required bool end_segment = 2;
04004   if (_has_bit(1)) {
04005     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->end_segment(), target);
04006   }
04007   
04008   // repeated .drizzled.message.DeleteRecord record = 3;
04009   for (int i = 0; i < this->record_size(); i++) {
04010     target = ::google::protobuf::internal::WireFormatLite::
04011       WriteMessageNoVirtualToArray(
04012         3, this->record(i), target);
04013   }
04014   
04015   if (!unknown_fields().empty()) {
04016     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
04017         unknown_fields(), target);
04018   }
04019   return target;
04020 }
04021 
04022 int DeleteData::ByteSize() const {
04023   int total_size = 0;
04024   
04025   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
04026     // required uint32 segment_id = 1;
04027     if (has_segment_id()) {
04028       total_size += 1 +
04029         ::google::protobuf::internal::WireFormatLite::UInt32Size(
04030           this->segment_id());
04031     }
04032     
04033     // required bool end_segment = 2;
04034     if (has_end_segment()) {
04035       total_size += 1 + 1;
04036     }
04037     
04038   }
04039   // repeated .drizzled.message.DeleteRecord record = 3;
04040   total_size += 1 * this->record_size();
04041   for (int i = 0; i < this->record_size(); i++) {
04042     total_size +=
04043       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
04044         this->record(i));
04045   }
04046   
04047   if (!unknown_fields().empty()) {
04048     total_size +=
04049       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
04050         unknown_fields());
04051   }
04052   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
04053   _cached_size_ = total_size;
04054   GOOGLE_SAFE_CONCURRENT_WRITES_END();
04055   return total_size;
04056 }
04057 
04058 void DeleteData::MergeFrom(const ::google::protobuf::Message& from) {
04059   GOOGLE_CHECK_NE(&from, this);
04060   const DeleteData* source =
04061     ::google::protobuf::internal::dynamic_cast_if_available<const DeleteData*>(
04062       &from);
04063   if (source == NULL) {
04064     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
04065   } else {
04066     MergeFrom(*source);
04067   }
04068 }
04069 
04070 void DeleteData::MergeFrom(const DeleteData& from) {
04071   GOOGLE_CHECK_NE(&from, this);
04072   record_.MergeFrom(from.record_);
04073   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
04074     if (from._has_bit(0)) {
04075       set_segment_id(from.segment_id());
04076     }
04077     if (from._has_bit(1)) {
04078       set_end_segment(from.end_segment());
04079     }
04080   }
04081   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
04082 }
04083 
04084 void DeleteData::CopyFrom(const ::google::protobuf::Message& from) {
04085   if (&from == this) return;
04086   Clear();
04087   MergeFrom(from);
04088 }
04089 
04090 void DeleteData::CopyFrom(const DeleteData& from) {
04091   if (&from == this) return;
04092   Clear();
04093   MergeFrom(from);
04094 }
04095 
04096 bool DeleteData::IsInitialized() const {
04097   if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
04098   
04099   return true;
04100 }
04101 
04102 void DeleteData::Swap(DeleteData* other) {
04103   if (other != this) {
04104     std::swap(segment_id_, other->segment_id_);
04105     std::swap(end_segment_, other->end_segment_);
04106     record_.Swap(&other->record_);
04107     std::swap(_has_bits_[0], other->_has_bits_[0]);
04108     _unknown_fields_.Swap(&other->_unknown_fields_);
04109     std::swap(_cached_size_, other->_cached_size_);
04110   }
04111 }
04112 
04113 ::google::protobuf::Metadata DeleteData::GetMetadata() const {
04114   protobuf_AssignDescriptorsOnce();
04115   ::google::protobuf::Metadata metadata;
04116   metadata.descriptor = DeleteData_descriptor_;
04117   metadata.reflection = DeleteData_reflection_;
04118   return metadata;
04119 }
04120 
04121 
04122 // ===================================================================
04123 
04124 #ifndef _MSC_VER
04125 const int TruncateTableStatement::kTableMetadataFieldNumber;
04126 #endif  // !_MSC_VER
04127 
04128 TruncateTableStatement::TruncateTableStatement()
04129   : ::google::protobuf::Message() {
04130   SharedCtor();
04131 }
04132 
04133 void TruncateTableStatement::InitAsDefaultInstance() {
04134   table_metadata_ = const_cast< ::drizzled::message::TableMetadata*>(&::drizzled::message::TableMetadata::default_instance());
04135 }
04136 
04137 TruncateTableStatement::TruncateTableStatement(const TruncateTableStatement& from)
04138   : ::google::protobuf::Message() {
04139   SharedCtor();
04140   MergeFrom(from);
04141 }
04142 
04143 void TruncateTableStatement::SharedCtor() {
04144   _cached_size_ = 0;
04145   table_metadata_ = NULL;
04146   ::memset(_has_bits_, 0, sizeof(_has_bits_));
04147 }
04148 
04149 TruncateTableStatement::~TruncateTableStatement() {
04150   SharedDtor();
04151 }
04152 
04153 void TruncateTableStatement::SharedDtor() {
04154   if (this != default_instance_) {
04155     delete table_metadata_;
04156   }
04157 }
04158 
04159 void TruncateTableStatement::SetCachedSize(int size) const {
04160   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
04161   _cached_size_ = size;
04162   GOOGLE_SAFE_CONCURRENT_WRITES_END();
04163 }
04164 const ::google::protobuf::Descriptor* TruncateTableStatement::descriptor() {
04165   protobuf_AssignDescriptorsOnce();
04166   return TruncateTableStatement_descriptor_;
04167 }
04168 
04169 const TruncateTableStatement& TruncateTableStatement::default_instance() {
04170   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
04171 }
04172 
04173 TruncateTableStatement* TruncateTableStatement::default_instance_ = NULL;
04174 
04175 TruncateTableStatement* TruncateTableStatement::New() const {
04176   return new TruncateTableStatement;
04177 }
04178 
04179 void TruncateTableStatement::Clear() {
04180   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
04181     if (_has_bit(0)) {
04182       if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
04183     }
04184   }
04185   ::memset(_has_bits_, 0, sizeof(_has_bits_));
04186   mutable_unknown_fields()->Clear();
04187 }
04188 
04189 bool TruncateTableStatement::MergePartialFromCodedStream(
04190     ::google::protobuf::io::CodedInputStream* input) {
04191 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
04192   ::google::protobuf::uint32 tag;
04193   while ((tag = input->ReadTag()) != 0) {
04194     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
04195       // required .drizzled.message.TableMetadata table_metadata = 1;
04196       case 1: {
04197         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
04198             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
04199           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
04200                input, mutable_table_metadata()));
04201         } else {
04202           goto handle_uninterpreted;
04203         }
04204         if (input->ExpectAtEnd()) return true;
04205         break;
04206       }
04207       
04208       default: {
04209       handle_uninterpreted:
04210         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
04211             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
04212           return true;
04213         }
04214         DO_(::google::protobuf::internal::WireFormat::SkipField(
04215               input, tag, mutable_unknown_fields()));
04216         break;
04217       }
04218     }
04219   }
04220   return true;
04221 #undef DO_
04222 }
04223 
04224 void TruncateTableStatement::SerializeWithCachedSizes(
04225     ::google::protobuf::io::CodedOutputStream* output) const {
04226   // required .drizzled.message.TableMetadata table_metadata = 1;
04227   if (_has_bit(0)) {
04228     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
04229       1, this->table_metadata(), output);
04230   }
04231   
04232   if (!unknown_fields().empty()) {
04233     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
04234         unknown_fields(), output);
04235   }
04236 }
04237 
04238 ::google::protobuf::uint8* TruncateTableStatement::SerializeWithCachedSizesToArray(
04239     ::google::protobuf::uint8* target) const {
04240   // required .drizzled.message.TableMetadata table_metadata = 1;
04241   if (_has_bit(0)) {
04242     target = ::google::protobuf::internal::WireFormatLite::
04243       WriteMessageNoVirtualToArray(
04244         1, this->table_metadata(), target);
04245   }
04246   
04247   if (!unknown_fields().empty()) {
04248     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
04249         unknown_fields(), target);
04250   }
04251   return target;
04252 }
04253 
04254 int TruncateTableStatement::ByteSize() const {
04255   int total_size = 0;
04256   
04257   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
04258     // required .drizzled.message.TableMetadata table_metadata = 1;
04259     if (has_table_metadata()) {
04260       total_size += 1 +
04261         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
04262           this->table_metadata());
04263     }
04264     
04265   }
04266   if (!unknown_fields().empty()) {
04267     total_size +=
04268       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
04269         unknown_fields());
04270   }
04271   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
04272   _cached_size_ = total_size;
04273   GOOGLE_SAFE_CONCURRENT_WRITES_END();
04274   return total_size;
04275 }
04276 
04277 void TruncateTableStatement::MergeFrom(const ::google::protobuf::Message& from) {
04278   GOOGLE_CHECK_NE(&from, this);
04279   const TruncateTableStatement* source =
04280     ::google::protobuf::internal::dynamic_cast_if_available<const TruncateTableStatement*>(
04281       &from);
04282   if (source == NULL) {
04283     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
04284   } else {
04285     MergeFrom(*source);
04286   }
04287 }
04288 
04289 void TruncateTableStatement::MergeFrom(const TruncateTableStatement& from) {
04290   GOOGLE_CHECK_NE(&from, this);
04291   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
04292     if (from._has_bit(0)) {
04293       mutable_table_metadata()->::drizzled::message::TableMetadata::MergeFrom(from.table_metadata());
04294     }
04295   }
04296   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
04297 }
04298 
04299 void TruncateTableStatement::CopyFrom(const ::google::protobuf::Message& from) {
04300   if (&from == this) return;
04301   Clear();
04302   MergeFrom(from);
04303 }
04304 
04305 void TruncateTableStatement::CopyFrom(const TruncateTableStatement& from) {
04306   if (&from == this) return;
04307   Clear();
04308   MergeFrom(from);
04309 }
04310 
04311 bool TruncateTableStatement::IsInitialized() const {
04312   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
04313   
04314   if (has_table_metadata()) {
04315     if (!this->table_metadata().IsInitialized()) return false;
04316   }
04317   return true;
04318 }
04319 
04320 void TruncateTableStatement::Swap(TruncateTableStatement* other) {
04321   if (other != this) {
04322     std::swap(table_metadata_, other->table_metadata_);
04323     std::swap(_has_bits_[0], other->_has_bits_[0]);
04324     _unknown_fields_.Swap(&other->_unknown_fields_);
04325     std::swap(_cached_size_, other->_cached_size_);
04326   }
04327 }
04328 
04329 ::google::protobuf::Metadata TruncateTableStatement::GetMetadata() const {
04330   protobuf_AssignDescriptorsOnce();
04331   ::google::protobuf::Metadata metadata;
04332   metadata.descriptor = TruncateTableStatement_descriptor_;
04333   metadata.reflection = TruncateTableStatement_reflection_;
04334   return metadata;
04335 }
04336 
04337 
04338 // ===================================================================
04339 
04340 #ifndef _MSC_VER
04341 const int CreateSchemaStatement::kSchemaFieldNumber;
04342 #endif  // !_MSC_VER
04343 
04344 CreateSchemaStatement::CreateSchemaStatement()
04345   : ::google::protobuf::Message() {
04346   SharedCtor();
04347 }
04348 
04349 void CreateSchemaStatement::InitAsDefaultInstance() {
04350   schema_ = const_cast< ::drizzled::message::Schema*>(&::drizzled::message::Schema::default_instance());
04351 }
04352 
04353 CreateSchemaStatement::CreateSchemaStatement(const CreateSchemaStatement& from)
04354   : ::google::protobuf::Message() {
04355   SharedCtor();
04356   MergeFrom(from);
04357 }
04358 
04359 void CreateSchemaStatement::SharedCtor() {
04360   _cached_size_ = 0;
04361   schema_ = NULL;
04362   ::memset(_has_bits_, 0, sizeof(_has_bits_));
04363 }
04364 
04365 CreateSchemaStatement::~CreateSchemaStatement() {
04366   SharedDtor();
04367 }
04368 
04369 void CreateSchemaStatement::SharedDtor() {
04370   if (this != default_instance_) {
04371     delete schema_;
04372   }
04373 }
04374 
04375 void CreateSchemaStatement::SetCachedSize(int size) const {
04376   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
04377   _cached_size_ = size;
04378   GOOGLE_SAFE_CONCURRENT_WRITES_END();
04379 }
04380 const ::google::protobuf::Descriptor* CreateSchemaStatement::descriptor() {
04381   protobuf_AssignDescriptorsOnce();
04382   return CreateSchemaStatement_descriptor_;
04383 }
04384 
04385 const CreateSchemaStatement& CreateSchemaStatement::default_instance() {
04386   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
04387 }
04388 
04389 CreateSchemaStatement* CreateSchemaStatement::default_instance_ = NULL;
04390 
04391 CreateSchemaStatement* CreateSchemaStatement::New() const {
04392   return new CreateSchemaStatement;
04393 }
04394 
04395 void CreateSchemaStatement::Clear() {
04396   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
04397     if (_has_bit(0)) {
04398       if (schema_ != NULL) schema_->::drizzled::message::Schema::Clear();
04399     }
04400   }
04401   ::memset(_has_bits_, 0, sizeof(_has_bits_));
04402   mutable_unknown_fields()->Clear();
04403 }
04404 
04405 bool CreateSchemaStatement::MergePartialFromCodedStream(
04406     ::google::protobuf::io::CodedInputStream* input) {
04407 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
04408   ::google::protobuf::uint32 tag;
04409   while ((tag = input->ReadTag()) != 0) {
04410     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
04411       // required .drizzled.message.Schema schema = 1;
04412       case 1: {
04413         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
04414             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
04415           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
04416                input, mutable_schema()));
04417         } else {
04418           goto handle_uninterpreted;
04419         }
04420         if (input->ExpectAtEnd()) return true;
04421         break;
04422       }
04423       
04424       default: {
04425       handle_uninterpreted:
04426         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
04427             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
04428           return true;
04429         }
04430         DO_(::google::protobuf::internal::WireFormat::SkipField(
04431               input, tag, mutable_unknown_fields()));
04432         break;
04433       }
04434     }
04435   }
04436   return true;
04437 #undef DO_
04438 }
04439 
04440 void CreateSchemaStatement::SerializeWithCachedSizes(
04441     ::google::protobuf::io::CodedOutputStream* output) const {
04442   // required .drizzled.message.Schema schema = 1;
04443   if (_has_bit(0)) {
04444     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
04445       1, this->schema(), output);
04446   }
04447   
04448   if (!unknown_fields().empty()) {
04449     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
04450         unknown_fields(), output);
04451   }
04452 }
04453 
04454 ::google::protobuf::uint8* CreateSchemaStatement::SerializeWithCachedSizesToArray(
04455     ::google::protobuf::uint8* target) const {
04456   // required .drizzled.message.Schema schema = 1;
04457   if (_has_bit(0)) {
04458     target = ::google::protobuf::internal::WireFormatLite::
04459       WriteMessageNoVirtualToArray(
04460         1, this->schema(), target);
04461   }
04462   
04463   if (!unknown_fields().empty()) {
04464     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
04465         unknown_fields(), target);
04466   }
04467   return target;
04468 }
04469 
04470 int CreateSchemaStatement::ByteSize() const {
04471   int total_size = 0;
04472   
04473   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
04474     // required .drizzled.message.Schema schema = 1;
04475     if (has_schema()) {
04476       total_size += 1 +
04477         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
04478           this->schema());
04479     }
04480     
04481   }
04482   if (!unknown_fields().empty()) {
04483     total_size +=
04484       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
04485         unknown_fields());
04486   }
04487   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
04488   _cached_size_ = total_size;
04489   GOOGLE_SAFE_CONCURRENT_WRITES_END();
04490   return total_size;
04491 }
04492 
04493 void CreateSchemaStatement::MergeFrom(const ::google::protobuf::Message& from) {
04494   GOOGLE_CHECK_NE(&from, this);
04495   const CreateSchemaStatement* source =
04496     ::google::protobuf::internal::dynamic_cast_if_available<const CreateSchemaStatement*>(
04497       &from);
04498   if (source == NULL) {
04499     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
04500   } else {
04501     MergeFrom(*source);
04502   }
04503 }
04504 
04505 void CreateSchemaStatement::MergeFrom(const CreateSchemaStatement& from) {
04506   GOOGLE_CHECK_NE(&from, this);
04507   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
04508     if (from._has_bit(0)) {
04509       mutable_schema()->::drizzled::message::Schema::MergeFrom(from.schema());
04510     }
04511   }
04512   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
04513 }
04514 
04515 void CreateSchemaStatement::CopyFrom(const ::google::protobuf::Message& from) {
04516   if (&from == this) return;
04517   Clear();
04518   MergeFrom(from);
04519 }
04520 
04521 void CreateSchemaStatement::CopyFrom(const CreateSchemaStatement& from) {
04522   if (&from == this) return;
04523   Clear();
04524   MergeFrom(from);
04525 }
04526 
04527 bool CreateSchemaStatement::IsInitialized() const {
04528   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
04529   
04530   if (has_schema()) {
04531     if (!this->schema().IsInitialized()) return false;
04532   }
04533   return true;
04534 }
04535 
04536 void CreateSchemaStatement::Swap(CreateSchemaStatement* other) {
04537   if (other != this) {
04538     std::swap(schema_, other->schema_);
04539     std::swap(_has_bits_[0], other->_has_bits_[0]);
04540     _unknown_fields_.Swap(&other->_unknown_fields_);
04541     std::swap(_cached_size_, other->_cached_size_);
04542   }
04543 }
04544 
04545 ::google::protobuf::Metadata CreateSchemaStatement::GetMetadata() const {
04546   protobuf_AssignDescriptorsOnce();
04547   ::google::protobuf::Metadata metadata;
04548   metadata.descriptor = CreateSchemaStatement_descriptor_;
04549   metadata.reflection = CreateSchemaStatement_reflection_;
04550   return metadata;
04551 }
04552 
04553 
04554 // ===================================================================
04555 
04556 #ifndef _MSC_VER
04557 const int AlterSchemaStatement::kBeforeFieldNumber;
04558 const int AlterSchemaStatement::kAfterFieldNumber;
04559 #endif  // !_MSC_VER
04560 
04561 AlterSchemaStatement::AlterSchemaStatement()
04562   : ::google::protobuf::Message() {
04563   SharedCtor();
04564 }
04565 
04566 void AlterSchemaStatement::InitAsDefaultInstance() {
04567   before_ = const_cast< ::drizzled::message::Schema*>(&::drizzled::message::Schema::default_instance());
04568   after_ = const_cast< ::drizzled::message::Schema*>(&::drizzled::message::Schema::default_instance());
04569 }
04570 
04571 AlterSchemaStatement::AlterSchemaStatement(const AlterSchemaStatement& from)
04572   : ::google::protobuf::Message() {
04573   SharedCtor();
04574   MergeFrom(from);
04575 }
04576 
04577 void AlterSchemaStatement::SharedCtor() {
04578   _cached_size_ = 0;
04579   before_ = NULL;
04580   after_ = NULL;
04581   ::memset(_has_bits_, 0, sizeof(_has_bits_));
04582 }
04583 
04584 AlterSchemaStatement::~AlterSchemaStatement() {
04585   SharedDtor();
04586 }
04587 
04588 void AlterSchemaStatement::SharedDtor() {
04589   if (this != default_instance_) {
04590     delete before_;
04591     delete after_;
04592   }
04593 }
04594 
04595 void AlterSchemaStatement::SetCachedSize(int size) const {
04596   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
04597   _cached_size_ = size;
04598   GOOGLE_SAFE_CONCURRENT_WRITES_END();
04599 }
04600 const ::google::protobuf::Descriptor* AlterSchemaStatement::descriptor() {
04601   protobuf_AssignDescriptorsOnce();
04602   return AlterSchemaStatement_descriptor_;
04603 }
04604 
04605 const AlterSchemaStatement& AlterSchemaStatement::default_instance() {
04606   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
04607 }
04608 
04609 AlterSchemaStatement* AlterSchemaStatement::default_instance_ = NULL;
04610 
04611 AlterSchemaStatement* AlterSchemaStatement::New() const {
04612   return new AlterSchemaStatement;
04613 }
04614 
04615 void AlterSchemaStatement::Clear() {
04616   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
04617     if (_has_bit(0)) {
04618       if (before_ != NULL) before_->::drizzled::message::Schema::Clear();
04619     }
04620     if (_has_bit(1)) {
04621       if (after_ != NULL) after_->::drizzled::message::Schema::Clear();
04622     }
04623   }
04624   ::memset(_has_bits_, 0, sizeof(_has_bits_));
04625   mutable_unknown_fields()->Clear();
04626 }
04627 
04628 bool AlterSchemaStatement::MergePartialFromCodedStream(
04629     ::google::protobuf::io::CodedInputStream* input) {
04630 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
04631   ::google::protobuf::uint32 tag;
04632   while ((tag = input->ReadTag()) != 0) {
04633     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
04634       // required .drizzled.message.Schema before = 1;
04635       case 1: {
04636         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
04637             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
04638           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
04639                input, mutable_before()));
04640         } else {
04641           goto handle_uninterpreted;
04642         }
04643         if (input->ExpectTag(18)) goto parse_after;
04644         break;
04645       }
04646       
04647       // required .drizzled.message.Schema after = 2;
04648       case 2: {
04649         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
04650             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
04651          parse_after:
04652           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
04653                input, mutable_after()));
04654         } else {
04655           goto handle_uninterpreted;
04656         }
04657         if (input->ExpectAtEnd()) return true;
04658         break;
04659       }
04660       
04661       default: {
04662       handle_uninterpreted:
04663         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
04664             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
04665           return true;
04666         }
04667         DO_(::google::protobuf::internal::WireFormat::SkipField(
04668               input, tag, mutable_unknown_fields()));
04669         break;
04670       }
04671     }
04672   }
04673   return true;
04674 #undef DO_
04675 }
04676 
04677 void AlterSchemaStatement::SerializeWithCachedSizes(
04678     ::google::protobuf::io::CodedOutputStream* output) const {
04679   // required .drizzled.message.Schema before = 1;
04680   if (_has_bit(0)) {
04681     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
04682       1, this->before(), output);
04683   }
04684   
04685   // required .drizzled.message.Schema after = 2;
04686   if (_has_bit(1)) {
04687     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
04688       2, this->after(), output);
04689   }
04690   
04691   if (!unknown_fields().empty()) {
04692     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
04693         unknown_fields(), output);
04694   }
04695 }
04696 
04697 ::google::protobuf::uint8* AlterSchemaStatement::SerializeWithCachedSizesToArray(
04698     ::google::protobuf::uint8* target) const {
04699   // required .drizzled.message.Schema before = 1;
04700   if (_has_bit(0)) {
04701     target = ::google::protobuf::internal::WireFormatLite::
04702       WriteMessageNoVirtualToArray(
04703         1, this->before(), target);
04704   }
04705   
04706   // required .drizzled.message.Schema after = 2;
04707   if (_has_bit(1)) {
04708     target = ::google::protobuf::internal::WireFormatLite::
04709       WriteMessageNoVirtualToArray(
04710         2, this->after(), target);
04711   }
04712   
04713   if (!unknown_fields().empty()) {
04714     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
04715         unknown_fields(), target);
04716   }
04717   return target;
04718 }
04719 
04720 int AlterSchemaStatement::ByteSize() const {
04721   int total_size = 0;
04722   
04723   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
04724     // required .drizzled.message.Schema before = 1;
04725     if (has_before()) {
04726       total_size += 1 +
04727         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
04728           this->before());
04729     }
04730     
04731     // required .drizzled.message.Schema after = 2;
04732     if (has_after()) {
04733       total_size += 1 +
04734         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
04735           this->after());
04736     }
04737     
04738   }
04739   if (!unknown_fields().empty()) {
04740     total_size +=
04741       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
04742         unknown_fields());
04743   }
04744   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
04745   _cached_size_ = total_size;
04746   GOOGLE_SAFE_CONCURRENT_WRITES_END();
04747   return total_size;
04748 }
04749 
04750 void AlterSchemaStatement::MergeFrom(const ::google::protobuf::Message& from) {
04751   GOOGLE_CHECK_NE(&from, this);
04752   const AlterSchemaStatement* source =
04753     ::google::protobuf::internal::dynamic_cast_if_available<const AlterSchemaStatement*>(
04754       &from);
04755   if (source == NULL) {
04756     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
04757   } else {
04758     MergeFrom(*source);
04759   }
04760 }
04761 
04762 void AlterSchemaStatement::MergeFrom(const AlterSchemaStatement& from) {
04763   GOOGLE_CHECK_NE(&from, this);
04764   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
04765     if (from._has_bit(0)) {
04766       mutable_before()->::drizzled::message::Schema::MergeFrom(from.before());
04767     }
04768     if (from._has_bit(1)) {
04769       mutable_after()->::drizzled::message::Schema::MergeFrom(from.after());
04770     }
04771   }
04772   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
04773 }
04774 
04775 void AlterSchemaStatement::CopyFrom(const ::google::protobuf::Message& from) {
04776   if (&from == this) return;
04777   Clear();
04778   MergeFrom(from);
04779 }
04780 
04781 void AlterSchemaStatement::CopyFrom(const AlterSchemaStatement& from) {
04782   if (&from == this) return;
04783   Clear();
04784   MergeFrom(from);
04785 }
04786 
04787 bool AlterSchemaStatement::IsInitialized() const {
04788   if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
04789   
04790   if (has_before()) {
04791     if (!this->before().IsInitialized()) return false;
04792   }
04793   if (has_after()) {
04794     if (!this->after().IsInitialized()) return false;
04795   }
04796   return true;
04797 }
04798 
04799 void AlterSchemaStatement::Swap(AlterSchemaStatement* other) {
04800   if (other != this) {
04801     std::swap(before_, other->before_);
04802     std::swap(after_, other->after_);
04803     std::swap(_has_bits_[0], other->_has_bits_[0]);
04804     _unknown_fields_.Swap(&other->_unknown_fields_);
04805     std::swap(_cached_size_, other->_cached_size_);
04806   }
04807 }
04808 
04809 ::google::protobuf::Metadata AlterSchemaStatement::GetMetadata() const {
04810   protobuf_AssignDescriptorsOnce();
04811   ::google::protobuf::Metadata metadata;
04812   metadata.descriptor = AlterSchemaStatement_descriptor_;
04813   metadata.reflection = AlterSchemaStatement_reflection_;
04814   return metadata;
04815 }
04816 
04817 
04818 // ===================================================================
04819 
04820 const ::std::string DropSchemaStatement::_default_schema_name_;
04821 const ::std::string DropSchemaStatement::_default_catalog_name_;
04822 #ifndef _MSC_VER
04823 const int DropSchemaStatement::kSchemaNameFieldNumber;
04824 const int DropSchemaStatement::kCatalogNameFieldNumber;
04825 #endif  // !_MSC_VER
04826 
04827 DropSchemaStatement::DropSchemaStatement()
04828   : ::google::protobuf::Message() {
04829   SharedCtor();
04830 }
04831 
04832 void DropSchemaStatement::InitAsDefaultInstance() {
04833 }
04834 
04835 DropSchemaStatement::DropSchemaStatement(const DropSchemaStatement& from)
04836   : ::google::protobuf::Message() {
04837   SharedCtor();
04838   MergeFrom(from);
04839 }
04840 
04841 void DropSchemaStatement::SharedCtor() {
04842   _cached_size_ = 0;
04843   schema_name_ = const_cast< ::std::string*>(&_default_schema_name_);
04844   catalog_name_ = const_cast< ::std::string*>(&_default_catalog_name_);
04845   ::memset(_has_bits_, 0, sizeof(_has_bits_));
04846 }
04847 
04848 DropSchemaStatement::~DropSchemaStatement() {
04849   SharedDtor();
04850 }
04851 
04852 void DropSchemaStatement::SharedDtor() {
04853   if (schema_name_ != &_default_schema_name_) {
04854     delete schema_name_;
04855   }
04856   if (catalog_name_ != &_default_catalog_name_) {
04857     delete catalog_name_;
04858   }
04859   if (this != default_instance_) {
04860   }
04861 }
04862 
04863 void DropSchemaStatement::SetCachedSize(int size) const {
04864   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
04865   _cached_size_ = size;
04866   GOOGLE_SAFE_CONCURRENT_WRITES_END();
04867 }
04868 const ::google::protobuf::Descriptor* DropSchemaStatement::descriptor() {
04869   protobuf_AssignDescriptorsOnce();
04870   return DropSchemaStatement_descriptor_;
04871 }
04872 
04873 const DropSchemaStatement& DropSchemaStatement::default_instance() {
04874   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
04875 }
04876 
04877 DropSchemaStatement* DropSchemaStatement::default_instance_ = NULL;
04878 
04879 DropSchemaStatement* DropSchemaStatement::New() const {
04880   return new DropSchemaStatement;
04881 }
04882 
04883 void DropSchemaStatement::Clear() {
04884   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
04885     if (_has_bit(0)) {
04886       if (schema_name_ != &_default_schema_name_) {
04887         schema_name_->clear();
04888       }
04889     }
04890     if (_has_bit(1)) {
04891       if (catalog_name_ != &_default_catalog_name_) {
04892         catalog_name_->clear();
04893       }
04894     }
04895   }
04896   ::memset(_has_bits_, 0, sizeof(_has_bits_));
04897   mutable_unknown_fields()->Clear();
04898 }
04899 
04900 bool DropSchemaStatement::MergePartialFromCodedStream(
04901     ::google::protobuf::io::CodedInputStream* input) {
04902 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
04903   ::google::protobuf::uint32 tag;
04904   while ((tag = input->ReadTag()) != 0) {
04905     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
04906       // required string schema_name = 1;
04907       case 1: {
04908         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
04909             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
04910           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
04911                 input, this->mutable_schema_name()));
04912           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
04913             this->schema_name().data(), this->schema_name().length(),
04914             ::google::protobuf::internal::WireFormat::PARSE);
04915         } else {
04916           goto handle_uninterpreted;
04917         }
04918         if (input->ExpectTag(18)) goto parse_catalog_name;
04919         break;
04920       }
04921       
04922       // optional string catalog_name = 2;
04923       case 2: {
04924         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
04925             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
04926          parse_catalog_name:
04927           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
04928                 input, this->mutable_catalog_name()));
04929           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
04930             this->catalog_name().data(), this->catalog_name().length(),
04931             ::google::protobuf::internal::WireFormat::PARSE);
04932         } else {
04933           goto handle_uninterpreted;
04934         }
04935         if (input->ExpectAtEnd()) return true;
04936         break;
04937       }
04938       
04939       default: {
04940       handle_uninterpreted:
04941         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
04942             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
04943           return true;
04944         }
04945         DO_(::google::protobuf::internal::WireFormat::SkipField(
04946               input, tag, mutable_unknown_fields()));
04947         break;
04948       }
04949     }
04950   }
04951   return true;
04952 #undef DO_
04953 }
04954 
04955 void DropSchemaStatement::SerializeWithCachedSizes(
04956     ::google::protobuf::io::CodedOutputStream* output) const {
04957   // required string schema_name = 1;
04958   if (_has_bit(0)) {
04959     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
04960       this->schema_name().data(), this->schema_name().length(),
04961       ::google::protobuf::internal::WireFormat::SERIALIZE);
04962     ::google::protobuf::internal::WireFormatLite::WriteString(
04963       1, this->schema_name(), output);
04964   }
04965   
04966   // optional string catalog_name = 2;
04967   if (_has_bit(1)) {
04968     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
04969       this->catalog_name().data(), this->catalog_name().length(),
04970       ::google::protobuf::internal::WireFormat::SERIALIZE);
04971     ::google::protobuf::internal::WireFormatLite::WriteString(
04972       2, this->catalog_name(), output);
04973   }
04974   
04975   if (!unknown_fields().empty()) {
04976     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
04977         unknown_fields(), output);
04978   }
04979 }
04980 
04981 ::google::protobuf::uint8* DropSchemaStatement::SerializeWithCachedSizesToArray(
04982     ::google::protobuf::uint8* target) const {
04983   // required string schema_name = 1;
04984   if (_has_bit(0)) {
04985     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
04986       this->schema_name().data(), this->schema_name().length(),
04987       ::google::protobuf::internal::WireFormat::SERIALIZE);
04988     target =
04989       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
04990         1, this->schema_name(), target);
04991   }
04992   
04993   // optional string catalog_name = 2;
04994   if (_has_bit(1)) {
04995     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
04996       this->catalog_name().data(), this->catalog_name().length(),
04997       ::google::protobuf::internal::WireFormat::SERIALIZE);
04998     target =
04999       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
05000         2, this->catalog_name(), target);
05001   }
05002   
05003   if (!unknown_fields().empty()) {
05004     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
05005         unknown_fields(), target);
05006   }
05007   return target;
05008 }
05009 
05010 int DropSchemaStatement::ByteSize() const {
05011   int total_size = 0;
05012   
05013   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
05014     // required string schema_name = 1;
05015     if (has_schema_name()) {
05016       total_size += 1 +
05017         ::google::protobuf::internal::WireFormatLite::StringSize(
05018           this->schema_name());
05019     }
05020     
05021     // optional string catalog_name = 2;
05022     if (has_catalog_name()) {
05023       total_size += 1 +
05024         ::google::protobuf::internal::WireFormatLite::StringSize(
05025           this->catalog_name());
05026     }
05027     
05028   }
05029   if (!unknown_fields().empty()) {
05030     total_size +=
05031       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
05032         unknown_fields());
05033   }
05034   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
05035   _cached_size_ = total_size;
05036   GOOGLE_SAFE_CONCURRENT_WRITES_END();
05037   return total_size;
05038 }
05039 
05040 void DropSchemaStatement::MergeFrom(const ::google::protobuf::Message& from) {
05041   GOOGLE_CHECK_NE(&from, this);
05042   const DropSchemaStatement* source =
05043     ::google::protobuf::internal::dynamic_cast_if_available<const DropSchemaStatement*>(
05044       &from);
05045   if (source == NULL) {
05046     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
05047   } else {
05048     MergeFrom(*source);
05049   }
05050 }
05051 
05052 void DropSchemaStatement::MergeFrom(const DropSchemaStatement& from) {
05053   GOOGLE_CHECK_NE(&from, this);
05054   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
05055     if (from._has_bit(0)) {
05056       set_schema_name(from.schema_name());
05057     }
05058     if (from._has_bit(1)) {
05059       set_catalog_name(from.catalog_name());
05060     }
05061   }
05062   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
05063 }
05064 
05065 void DropSchemaStatement::CopyFrom(const ::google::protobuf::Message& from) {
05066   if (&from == this) return;
05067   Clear();
05068   MergeFrom(from);
05069 }
05070 
05071 void DropSchemaStatement::CopyFrom(const DropSchemaStatement& from) {
05072   if (&from == this) return;
05073   Clear();
05074   MergeFrom(from);
05075 }
05076 
05077 bool DropSchemaStatement::IsInitialized() const {
05078   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
05079   
05080   return true;
05081 }
05082 
05083 void DropSchemaStatement::Swap(DropSchemaStatement* other) {
05084   if (other != this) {
05085     std::swap(schema_name_, other->schema_name_);
05086     std::swap(catalog_name_, other->catalog_name_);
05087     std::swap(_has_bits_[0], other->_has_bits_[0]);
05088     _unknown_fields_.Swap(&other->_unknown_fields_);
05089     std::swap(_cached_size_, other->_cached_size_);
05090   }
05091 }
05092 
05093 ::google::protobuf::Metadata DropSchemaStatement::GetMetadata() const {
05094   protobuf_AssignDescriptorsOnce();
05095   ::google::protobuf::Metadata metadata;
05096   metadata.descriptor = DropSchemaStatement_descriptor_;
05097   metadata.reflection = DropSchemaStatement_reflection_;
05098   return metadata;
05099 }
05100 
05101 
05102 // ===================================================================
05103 
05104 #ifndef _MSC_VER
05105 const int CreateTableStatement::kTableFieldNumber;
05106 #endif  // !_MSC_VER
05107 
05108 CreateTableStatement::CreateTableStatement()
05109   : ::google::protobuf::Message() {
05110   SharedCtor();
05111 }
05112 
05113 void CreateTableStatement::InitAsDefaultInstance() {
05114   table_ = const_cast< ::drizzled::message::Table*>(&::drizzled::message::Table::default_instance());
05115 }
05116 
05117 CreateTableStatement::CreateTableStatement(const CreateTableStatement& from)
05118   : ::google::protobuf::Message() {
05119   SharedCtor();
05120   MergeFrom(from);
05121 }
05122 
05123 void CreateTableStatement::SharedCtor() {
05124   _cached_size_ = 0;
05125   table_ = NULL;
05126   ::memset(_has_bits_, 0, sizeof(_has_bits_));
05127 }
05128 
05129 CreateTableStatement::~CreateTableStatement() {
05130   SharedDtor();
05131 }
05132 
05133 void CreateTableStatement::SharedDtor() {
05134   if (this != default_instance_) {
05135     delete table_;
05136   }
05137 }
05138 
05139 void CreateTableStatement::SetCachedSize(int size) const {
05140   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
05141   _cached_size_ = size;
05142   GOOGLE_SAFE_CONCURRENT_WRITES_END();
05143 }
05144 const ::google::protobuf::Descriptor* CreateTableStatement::descriptor() {
05145   protobuf_AssignDescriptorsOnce();
05146   return CreateTableStatement_descriptor_;
05147 }
05148 
05149 const CreateTableStatement& CreateTableStatement::default_instance() {
05150   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
05151 }
05152 
05153 CreateTableStatement* CreateTableStatement::default_instance_ = NULL;
05154 
05155 CreateTableStatement* CreateTableStatement::New() const {
05156   return new CreateTableStatement;
05157 }
05158 
05159 void CreateTableStatement::Clear() {
05160   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
05161     if (_has_bit(0)) {
05162       if (table_ != NULL) table_->::drizzled::message::Table::Clear();
05163     }
05164   }
05165   ::memset(_has_bits_, 0, sizeof(_has_bits_));
05166   mutable_unknown_fields()->Clear();
05167 }
05168 
05169 bool CreateTableStatement::MergePartialFromCodedStream(
05170     ::google::protobuf::io::CodedInputStream* input) {
05171 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
05172   ::google::protobuf::uint32 tag;
05173   while ((tag = input->ReadTag()) != 0) {
05174     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
05175       // required .drizzled.message.Table table = 1;
05176       case 1: {
05177         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
05178             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
05179           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
05180                input, mutable_table()));
05181         } else {
05182           goto handle_uninterpreted;
05183         }
05184         if (input->ExpectAtEnd()) return true;
05185         break;
05186       }
05187       
05188       default: {
05189       handle_uninterpreted:
05190         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
05191             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
05192           return true;
05193         }
05194         DO_(::google::protobuf::internal::WireFormat::SkipField(
05195               input, tag, mutable_unknown_fields()));
05196         break;
05197       }
05198     }
05199   }
05200   return true;
05201 #undef DO_
05202 }
05203 
05204 void CreateTableStatement::SerializeWithCachedSizes(
05205     ::google::protobuf::io::CodedOutputStream* output) const {
05206   // required .drizzled.message.Table table = 1;
05207   if (_has_bit(0)) {
05208     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
05209       1, this->table(), output);
05210   }
05211   
05212   if (!unknown_fields().empty()) {
05213     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
05214         unknown_fields(), output);
05215   }
05216 }
05217 
05218 ::google::protobuf::uint8* CreateTableStatement::SerializeWithCachedSizesToArray(
05219     ::google::protobuf::uint8* target) const {
05220   // required .drizzled.message.Table table = 1;
05221   if (_has_bit(0)) {
05222     target = ::google::protobuf::internal::WireFormatLite::
05223       WriteMessageNoVirtualToArray(
05224         1, this->table(), target);
05225   }
05226   
05227   if (!unknown_fields().empty()) {
05228     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
05229         unknown_fields(), target);
05230   }
05231   return target;
05232 }
05233 
05234 int CreateTableStatement::ByteSize() const {
05235   int total_size = 0;
05236   
05237   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
05238     // required .drizzled.message.Table table = 1;
05239     if (has_table()) {
05240       total_size += 1 +
05241         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
05242           this->table());
05243     }
05244     
05245   }
05246   if (!unknown_fields().empty()) {
05247     total_size +=
05248       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
05249         unknown_fields());
05250   }
05251   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
05252   _cached_size_ = total_size;
05253   GOOGLE_SAFE_CONCURRENT_WRITES_END();
05254   return total_size;
05255 }
05256 
05257 void CreateTableStatement::MergeFrom(const ::google::protobuf::Message& from) {
05258   GOOGLE_CHECK_NE(&from, this);
05259   const CreateTableStatement* source =
05260     ::google::protobuf::internal::dynamic_cast_if_available<const CreateTableStatement*>(
05261       &from);
05262   if (source == NULL) {
05263     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
05264   } else {
05265     MergeFrom(*source);
05266   }
05267 }
05268 
05269 void CreateTableStatement::MergeFrom(const CreateTableStatement& from) {
05270   GOOGLE_CHECK_NE(&from, this);
05271   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
05272     if (from._has_bit(0)) {
05273       mutable_table()->::drizzled::message::Table::MergeFrom(from.table());
05274     }
05275   }
05276   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
05277 }
05278 
05279 void CreateTableStatement::CopyFrom(const ::google::protobuf::Message& from) {
05280   if (&from == this) return;
05281   Clear();
05282   MergeFrom(from);
05283 }
05284 
05285 void CreateTableStatement::CopyFrom(const CreateTableStatement& from) {
05286   if (&from == this) return;
05287   Clear();
05288   MergeFrom(from);
05289 }
05290 
05291 bool CreateTableStatement::IsInitialized() const {
05292   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
05293   
05294   if (has_table()) {
05295     if (!this->table().IsInitialized()) return false;
05296   }
05297   return true;
05298 }
05299 
05300 void CreateTableStatement::Swap(CreateTableStatement* other) {
05301   if (other != this) {
05302     std::swap(table_, other->table_);
05303     std::swap(_has_bits_[0], other->_has_bits_[0]);
05304     _unknown_fields_.Swap(&other->_unknown_fields_);
05305     std::swap(_cached_size_, other->_cached_size_);
05306   }
05307 }
05308 
05309 ::google::protobuf::Metadata CreateTableStatement::GetMetadata() const {
05310   protobuf_AssignDescriptorsOnce();
05311   ::google::protobuf::Metadata metadata;
05312   metadata.descriptor = CreateTableStatement_descriptor_;
05313   metadata.reflection = CreateTableStatement_reflection_;
05314   return metadata;
05315 }
05316 
05317 
05318 // ===================================================================
05319 
05320 #ifndef _MSC_VER
05321 const int AlterTableStatement::kBeforeFieldNumber;
05322 const int AlterTableStatement::kAfterFieldNumber;
05323 #endif  // !_MSC_VER
05324 
05325 AlterTableStatement::AlterTableStatement()
05326   : ::google::protobuf::Message() {
05327   SharedCtor();
05328 }
05329 
05330 void AlterTableStatement::InitAsDefaultInstance() {
05331   before_ = const_cast< ::drizzled::message::Table*>(&::drizzled::message::Table::default_instance());
05332   after_ = const_cast< ::drizzled::message::Table*>(&::drizzled::message::Table::default_instance());
05333 }
05334 
05335 AlterTableStatement::AlterTableStatement(const AlterTableStatement& from)
05336   : ::google::protobuf::Message() {
05337   SharedCtor();
05338   MergeFrom(from);
05339 }
05340 
05341 void AlterTableStatement::SharedCtor() {
05342   _cached_size_ = 0;
05343   before_ = NULL;
05344   after_ = NULL;
05345   ::memset(_has_bits_, 0, sizeof(_has_bits_));
05346 }
05347 
05348 AlterTableStatement::~AlterTableStatement() {
05349   SharedDtor();
05350 }
05351 
05352 void AlterTableStatement::SharedDtor() {
05353   if (this != default_instance_) {
05354     delete before_;
05355     delete after_;
05356   }
05357 }
05358 
05359 void AlterTableStatement::SetCachedSize(int size) const {
05360   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
05361   _cached_size_ = size;
05362   GOOGLE_SAFE_CONCURRENT_WRITES_END();
05363 }
05364 const ::google::protobuf::Descriptor* AlterTableStatement::descriptor() {
05365   protobuf_AssignDescriptorsOnce();
05366   return AlterTableStatement_descriptor_;
05367 }
05368 
05369 const AlterTableStatement& AlterTableStatement::default_instance() {
05370   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
05371 }
05372 
05373 AlterTableStatement* AlterTableStatement::default_instance_ = NULL;
05374 
05375 AlterTableStatement* AlterTableStatement::New() const {
05376   return new AlterTableStatement;
05377 }
05378 
05379 void AlterTableStatement::Clear() {
05380   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
05381     if (_has_bit(0)) {
05382       if (before_ != NULL) before_->::drizzled::message::Table::Clear();
05383     }
05384     if (_has_bit(1)) {
05385       if (after_ != NULL) after_->::drizzled::message::Table::Clear();
05386     }
05387   }
05388   ::memset(_has_bits_, 0, sizeof(_has_bits_));
05389   mutable_unknown_fields()->Clear();
05390 }
05391 
05392 bool AlterTableStatement::MergePartialFromCodedStream(
05393     ::google::protobuf::io::CodedInputStream* input) {
05394 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
05395   ::google::protobuf::uint32 tag;
05396   while ((tag = input->ReadTag()) != 0) {
05397     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
05398       // required .drizzled.message.Table before = 1;
05399       case 1: {
05400         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
05401             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
05402           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
05403                input, mutable_before()));
05404         } else {
05405           goto handle_uninterpreted;
05406         }
05407         if (input->ExpectTag(18)) goto parse_after;
05408         break;
05409       }
05410       
05411       // required .drizzled.message.Table after = 2;
05412       case 2: {
05413         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
05414             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
05415          parse_after:
05416           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
05417                input, mutable_after()));
05418         } else {
05419           goto handle_uninterpreted;
05420         }
05421         if (input->ExpectAtEnd()) return true;
05422         break;
05423       }
05424       
05425       default: {
05426       handle_uninterpreted:
05427         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
05428             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
05429           return true;
05430         }
05431         DO_(::google::protobuf::internal::WireFormat::SkipField(
05432               input, tag, mutable_unknown_fields()));
05433         break;
05434       }
05435     }
05436   }
05437   return true;
05438 #undef DO_
05439 }
05440 
05441 void AlterTableStatement::SerializeWithCachedSizes(
05442     ::google::protobuf::io::CodedOutputStream* output) const {
05443   // required .drizzled.message.Table before = 1;
05444   if (_has_bit(0)) {
05445     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
05446       1, this->before(), output);
05447   }
05448   
05449   // required .drizzled.message.Table after = 2;
05450   if (_has_bit(1)) {
05451     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
05452       2, this->after(), output);
05453   }
05454   
05455   if (!unknown_fields().empty()) {
05456     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
05457         unknown_fields(), output);
05458   }
05459 }
05460 
05461 ::google::protobuf::uint8* AlterTableStatement::SerializeWithCachedSizesToArray(
05462     ::google::protobuf::uint8* target) const {
05463   // required .drizzled.message.Table before = 1;
05464   if (_has_bit(0)) {
05465     target = ::google::protobuf::internal::WireFormatLite::
05466       WriteMessageNoVirtualToArray(
05467         1, this->before(), target);
05468   }
05469   
05470   // required .drizzled.message.Table after = 2;
05471   if (_has_bit(1)) {
05472     target = ::google::protobuf::internal::WireFormatLite::
05473       WriteMessageNoVirtualToArray(
05474         2, this->after(), target);
05475   }
05476   
05477   if (!unknown_fields().empty()) {
05478     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
05479         unknown_fields(), target);
05480   }
05481   return target;
05482 }
05483 
05484 int AlterTableStatement::ByteSize() const {
05485   int total_size = 0;
05486   
05487   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
05488     // required .drizzled.message.Table before = 1;
05489     if (has_before()) {
05490       total_size += 1 +
05491         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
05492           this->before());
05493     }
05494     
05495     // required .drizzled.message.Table after = 2;
05496     if (has_after()) {
05497       total_size += 1 +
05498         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
05499           this->after());
05500     }
05501     
05502   }
05503   if (!unknown_fields().empty()) {
05504     total_size +=
05505       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
05506         unknown_fields());
05507   }
05508   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
05509   _cached_size_ = total_size;
05510   GOOGLE_SAFE_CONCURRENT_WRITES_END();
05511   return total_size;
05512 }
05513 
05514 void AlterTableStatement::MergeFrom(const ::google::protobuf::Message& from) {
05515   GOOGLE_CHECK_NE(&from, this);
05516   const AlterTableStatement* source =
05517     ::google::protobuf::internal::dynamic_cast_if_available<const AlterTableStatement*>(
05518       &from);
05519   if (source == NULL) {
05520     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
05521   } else {
05522     MergeFrom(*source);
05523   }
05524 }
05525 
05526 void AlterTableStatement::MergeFrom(const AlterTableStatement& from) {
05527   GOOGLE_CHECK_NE(&from, this);
05528   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
05529     if (from._has_bit(0)) {
05530       mutable_before()->::drizzled::message::Table::MergeFrom(from.before());
05531     }
05532     if (from._has_bit(1)) {
05533       mutable_after()->::drizzled::message::Table::MergeFrom(from.after());
05534     }
05535   }
05536   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
05537 }
05538 
05539 void AlterTableStatement::CopyFrom(const ::google::protobuf::Message& from) {
05540   if (&from == this) return;
05541   Clear();
05542   MergeFrom(from);
05543 }
05544 
05545 void AlterTableStatement::CopyFrom(const AlterTableStatement& from) {
05546   if (&from == this) return;
05547   Clear();
05548   MergeFrom(from);
05549 }
05550 
05551 bool AlterTableStatement::IsInitialized() const {
05552   if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
05553   
05554   if (has_before()) {
05555     if (!this->before().IsInitialized()) return false;
05556   }
05557   if (has_after()) {
05558     if (!this->after().IsInitialized()) return false;
05559   }
05560   return true;
05561 }
05562 
05563 void AlterTableStatement::Swap(AlterTableStatement* other) {
05564   if (other != this) {
05565     std::swap(before_, other->before_);
05566     std::swap(after_, other->after_);
05567     std::swap(_has_bits_[0], other->_has_bits_[0]);
05568     _unknown_fields_.Swap(&other->_unknown_fields_);
05569     std::swap(_cached_size_, other->_cached_size_);
05570   }
05571 }
05572 
05573 ::google::protobuf::Metadata AlterTableStatement::GetMetadata() const {
05574   protobuf_AssignDescriptorsOnce();
05575   ::google::protobuf::Metadata metadata;
05576   metadata.descriptor = AlterTableStatement_descriptor_;
05577   metadata.reflection = AlterTableStatement_reflection_;
05578   return metadata;
05579 }
05580 
05581 
05582 // ===================================================================
05583 
05584 #ifndef _MSC_VER
05585 const int DropTableStatement::kTableMetadataFieldNumber;
05586 const int DropTableStatement::kIfExistsClauseFieldNumber;
05587 #endif  // !_MSC_VER
05588 
05589 DropTableStatement::DropTableStatement()
05590   : ::google::protobuf::Message() {
05591   SharedCtor();
05592 }
05593 
05594 void DropTableStatement::InitAsDefaultInstance() {
05595   table_metadata_ = const_cast< ::drizzled::message::TableMetadata*>(&::drizzled::message::TableMetadata::default_instance());
05596 }
05597 
05598 DropTableStatement::DropTableStatement(const DropTableStatement& from)
05599   : ::google::protobuf::Message() {
05600   SharedCtor();
05601   MergeFrom(from);
05602 }
05603 
05604 void DropTableStatement::SharedCtor() {
05605   _cached_size_ = 0;
05606   table_metadata_ = NULL;
05607   if_exists_clause_ = false;
05608   ::memset(_has_bits_, 0, sizeof(_has_bits_));
05609 }
05610 
05611 DropTableStatement::~DropTableStatement() {
05612   SharedDtor();
05613 }
05614 
05615 void DropTableStatement::SharedDtor() {
05616   if (this != default_instance_) {
05617     delete table_metadata_;
05618   }
05619 }
05620 
05621 void DropTableStatement::SetCachedSize(int size) const {
05622   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
05623   _cached_size_ = size;
05624   GOOGLE_SAFE_CONCURRENT_WRITES_END();
05625 }
05626 const ::google::protobuf::Descriptor* DropTableStatement::descriptor() {
05627   protobuf_AssignDescriptorsOnce();
05628   return DropTableStatement_descriptor_;
05629 }
05630 
05631 const DropTableStatement& DropTableStatement::default_instance() {
05632   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
05633 }
05634 
05635 DropTableStatement* DropTableStatement::default_instance_ = NULL;
05636 
05637 DropTableStatement* DropTableStatement::New() const {
05638   return new DropTableStatement;
05639 }
05640 
05641 void DropTableStatement::Clear() {
05642   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
05643     if (_has_bit(0)) {
05644       if (table_metadata_ != NULL) table_metadata_->::drizzled::message::TableMetadata::Clear();
05645     }
05646     if_exists_clause_ = false;
05647   }
05648   ::memset(_has_bits_, 0, sizeof(_has_bits_));
05649   mutable_unknown_fields()->Clear();
05650 }
05651 
05652 bool DropTableStatement::MergePartialFromCodedStream(
05653     ::google::protobuf::io::CodedInputStream* input) {
05654 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
05655   ::google::protobuf::uint32 tag;
05656   while ((tag = input->ReadTag()) != 0) {
05657     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
05658       // required .drizzled.message.TableMetadata table_metadata = 1;
05659       case 1: {
05660         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
05661             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
05662           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
05663                input, mutable_table_metadata()));
05664         } else {
05665           goto handle_uninterpreted;
05666         }
05667         if (input->ExpectTag(16)) goto parse_if_exists_clause;
05668         break;
05669       }
05670       
05671       // optional bool if_exists_clause = 2;
05672       case 2: {
05673         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
05674             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
05675          parse_if_exists_clause:
05676           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
05677                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
05678                  input, &if_exists_clause_)));
05679           _set_bit(1);
05680         } else {
05681           goto handle_uninterpreted;
05682         }
05683         if (input->ExpectAtEnd()) return true;
05684         break;
05685       }
05686       
05687       default: {
05688       handle_uninterpreted:
05689         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
05690             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
05691           return true;
05692         }
05693         DO_(::google::protobuf::internal::WireFormat::SkipField(
05694               input, tag, mutable_unknown_fields()));
05695         break;
05696       }
05697     }
05698   }
05699   return true;
05700 #undef DO_
05701 }
05702 
05703 void DropTableStatement::SerializeWithCachedSizes(
05704     ::google::protobuf::io::CodedOutputStream* output) const {
05705   // required .drizzled.message.TableMetadata table_metadata = 1;
05706   if (_has_bit(0)) {
05707     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
05708       1, this->table_metadata(), output);
05709   }
05710   
05711   // optional bool if_exists_clause = 2;
05712   if (_has_bit(1)) {
05713     ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->if_exists_clause(), output);
05714   }
05715   
05716   if (!unknown_fields().empty()) {
05717     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
05718         unknown_fields(), output);
05719   }
05720 }
05721 
05722 ::google::protobuf::uint8* DropTableStatement::SerializeWithCachedSizesToArray(
05723     ::google::protobuf::uint8* target) const {
05724   // required .drizzled.message.TableMetadata table_metadata = 1;
05725   if (_has_bit(0)) {
05726     target = ::google::protobuf::internal::WireFormatLite::
05727       WriteMessageNoVirtualToArray(
05728         1, this->table_metadata(), target);
05729   }
05730   
05731   // optional bool if_exists_clause = 2;
05732   if (_has_bit(1)) {
05733     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->if_exists_clause(), target);
05734   }
05735   
05736   if (!unknown_fields().empty()) {
05737     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
05738         unknown_fields(), target);
05739   }
05740   return target;
05741 }
05742 
05743 int DropTableStatement::ByteSize() const {
05744   int total_size = 0;
05745   
05746   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
05747     // required .drizzled.message.TableMetadata table_metadata = 1;
05748     if (has_table_metadata()) {
05749       total_size += 1 +
05750         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
05751           this->table_metadata());
05752     }
05753     
05754     // optional bool if_exists_clause = 2;
05755     if (has_if_exists_clause()) {
05756       total_size += 1 + 1;
05757     }
05758     
05759   }
05760   if (!unknown_fields().empty()) {
05761     total_size +=
05762       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
05763         unknown_fields());
05764   }
05765   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
05766   _cached_size_ = total_size;
05767   GOOGLE_SAFE_CONCURRENT_WRITES_END();
05768   return total_size;
05769 }
05770 
05771 void DropTableStatement::MergeFrom(const ::google::protobuf::Message& from) {
05772   GOOGLE_CHECK_NE(&from, this);
05773   const DropTableStatement* source =
05774     ::google::protobuf::internal::dynamic_cast_if_available<const DropTableStatement*>(
05775       &from);
05776   if (source == NULL) {
05777     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
05778   } else {
05779     MergeFrom(*source);
05780   }
05781 }
05782 
05783 void DropTableStatement::MergeFrom(const DropTableStatement& from) {
05784   GOOGLE_CHECK_NE(&from, this);
05785   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
05786     if (from._has_bit(0)) {
05787       mutable_table_metadata()->::drizzled::message::TableMetadata::MergeFrom(from.table_metadata());
05788     }
05789     if (from._has_bit(1)) {
05790       set_if_exists_clause(from.if_exists_clause());
05791     }
05792   }
05793   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
05794 }
05795 
05796 void DropTableStatement::CopyFrom(const ::google::protobuf::Message& from) {
05797   if (&from == this) return;
05798   Clear();
05799   MergeFrom(from);
05800 }
05801 
05802 void DropTableStatement::CopyFrom(const DropTableStatement& from) {
05803   if (&from == this) return;
05804   Clear();
05805   MergeFrom(from);
05806 }
05807 
05808 bool DropTableStatement::IsInitialized() const {
05809   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
05810   
05811   if (has_table_metadata()) {
05812     if (!this->table_metadata().IsInitialized()) return false;
05813   }
05814   return true;
05815 }
05816 
05817 void DropTableStatement::Swap(DropTableStatement* other) {
05818   if (other != this) {
05819     std::swap(table_metadata_, other->table_metadata_);
05820     std::swap(if_exists_clause_, other->if_exists_clause_);
05821     std::swap(_has_bits_[0], other->_has_bits_[0]);
05822     _unknown_fields_.Swap(&other->_unknown_fields_);
05823     std::swap(_cached_size_, other->_cached_size_);
05824   }
05825 }
05826 
05827 ::google::protobuf::Metadata DropTableStatement::GetMetadata() const {
05828   protobuf_AssignDescriptorsOnce();
05829   ::google::protobuf::Metadata metadata;
05830   metadata.descriptor = DropTableStatement_descriptor_;
05831   metadata.reflection = DropTableStatement_reflection_;
05832   return metadata;
05833 }
05834 
05835 
05836 // ===================================================================
05837 
05838 const ::std::string SetVariableStatement::_default_variable_value_;
05839 #ifndef _MSC_VER
05840 const int SetVariableStatement::kVariableMetadataFieldNumber;
05841 const int SetVariableStatement::kVariableValueFieldNumber;
05842 #endif  // !_MSC_VER
05843 
05844 SetVariableStatement::SetVariableStatement()
05845   : ::google::protobuf::Message() {
05846   SharedCtor();
05847 }
05848 
05849 void SetVariableStatement::InitAsDefaultInstance() {
05850   variable_metadata_ = const_cast< ::drizzled::message::FieldMetadata*>(&::drizzled::message::FieldMetadata::default_instance());
05851 }
05852 
05853 SetVariableStatement::SetVariableStatement(const SetVariableStatement& from)
05854   : ::google::protobuf::Message() {
05855   SharedCtor();
05856   MergeFrom(from);
05857 }
05858 
05859 void SetVariableStatement::SharedCtor() {
05860   _cached_size_ = 0;
05861   variable_metadata_ = NULL;
05862   variable_value_ = const_cast< ::std::string*>(&_default_variable_value_);
05863   ::memset(_has_bits_, 0, sizeof(_has_bits_));
05864 }
05865 
05866 SetVariableStatement::~SetVariableStatement() {
05867   SharedDtor();
05868 }
05869 
05870 void SetVariableStatement::SharedDtor() {
05871   if (variable_value_ != &_default_variable_value_) {
05872     delete variable_value_;
05873   }
05874   if (this != default_instance_) {
05875     delete variable_metadata_;
05876   }
05877 }
05878 
05879 void SetVariableStatement::SetCachedSize(int size) const {
05880   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
05881   _cached_size_ = size;
05882   GOOGLE_SAFE_CONCURRENT_WRITES_END();
05883 }
05884 const ::google::protobuf::Descriptor* SetVariableStatement::descriptor() {
05885   protobuf_AssignDescriptorsOnce();
05886   return SetVariableStatement_descriptor_;
05887 }
05888 
05889 const SetVariableStatement& SetVariableStatement::default_instance() {
05890   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
05891 }
05892 
05893 SetVariableStatement* SetVariableStatement::default_instance_ = NULL;
05894 
05895 SetVariableStatement* SetVariableStatement::New() const {
05896   return new SetVariableStatement;
05897 }
05898 
05899 void SetVariableStatement::Clear() {
05900   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
05901     if (_has_bit(0)) {
05902       if (variable_metadata_ != NULL) variable_metadata_->::drizzled::message::FieldMetadata::Clear();
05903     }
05904     if (_has_bit(1)) {
05905       if (variable_value_ != &_default_variable_value_) {
05906         variable_value_->clear();
05907       }
05908     }
05909   }
05910   ::memset(_has_bits_, 0, sizeof(_has_bits_));
05911   mutable_unknown_fields()->Clear();
05912 }
05913 
05914 bool SetVariableStatement::MergePartialFromCodedStream(
05915     ::google::protobuf::io::CodedInputStream* input) {
05916 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
05917   ::google::protobuf::uint32 tag;
05918   while ((tag = input->ReadTag()) != 0) {
05919     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
05920       // required .drizzled.message.FieldMetadata variable_metadata = 1;
05921       case 1: {
05922         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
05923             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
05924           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
05925                input, mutable_variable_metadata()));
05926         } else {
05927           goto handle_uninterpreted;
05928         }
05929         if (input->ExpectTag(18)) goto parse_variable_value;
05930         break;
05931       }
05932       
05933       // required bytes variable_value = 2;
05934       case 2: {
05935         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
05936             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
05937          parse_variable_value:
05938           DO_(::google::protobuf::internal::WireFormatLite::ReadBytes(
05939                 input, this->mutable_variable_value()));
05940         } else {
05941           goto handle_uninterpreted;
05942         }
05943         if (input->ExpectAtEnd()) return true;
05944         break;
05945       }
05946       
05947       default: {
05948       handle_uninterpreted:
05949         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
05950             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
05951           return true;
05952         }
05953         DO_(::google::protobuf::internal::WireFormat::SkipField(
05954               input, tag, mutable_unknown_fields()));
05955         break;
05956       }
05957     }
05958   }
05959   return true;
05960 #undef DO_
05961 }
05962 
05963 void SetVariableStatement::SerializeWithCachedSizes(
05964     ::google::protobuf::io::CodedOutputStream* output) const {
05965   // required .drizzled.message.FieldMetadata variable_metadata = 1;
05966   if (_has_bit(0)) {
05967     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
05968       1, this->variable_metadata(), output);
05969   }
05970   
05971   // required bytes variable_value = 2;
05972   if (_has_bit(1)) {
05973     ::google::protobuf::internal::WireFormatLite::WriteBytes(
05974       2, this->variable_value(), output);
05975   }
05976   
05977   if (!unknown_fields().empty()) {
05978     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
05979         unknown_fields(), output);
05980   }
05981 }
05982 
05983 ::google::protobuf::uint8* SetVariableStatement::SerializeWithCachedSizesToArray(
05984     ::google::protobuf::uint8* target) const {
05985   // required .drizzled.message.FieldMetadata variable_metadata = 1;
05986   if (_has_bit(0)) {
05987     target = ::google::protobuf::internal::WireFormatLite::
05988       WriteMessageNoVirtualToArray(
05989         1, this->variable_metadata(), target);
05990   }
05991   
05992   // required bytes variable_value = 2;
05993   if (_has_bit(1)) {
05994     target =
05995       ::google::protobuf::internal::WireFormatLite::WriteBytesToArray(
05996         2, this->variable_value(), target);
05997   }
05998   
05999   if (!unknown_fields().empty()) {
06000     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
06001         unknown_fields(), target);
06002   }
06003   return target;
06004 }
06005 
06006 int SetVariableStatement::ByteSize() const {
06007   int total_size = 0;
06008   
06009   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
06010     // required .drizzled.message.FieldMetadata variable_metadata = 1;
06011     if (has_variable_metadata()) {
06012       total_size += 1 +
06013         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06014           this->variable_metadata());
06015     }
06016     
06017     // required bytes variable_value = 2;
06018     if (has_variable_value()) {
06019       total_size += 1 +
06020         ::google::protobuf::internal::WireFormatLite::BytesSize(
06021           this->variable_value());
06022     }
06023     
06024   }
06025   if (!unknown_fields().empty()) {
06026     total_size +=
06027       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
06028         unknown_fields());
06029   }
06030   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
06031   _cached_size_ = total_size;
06032   GOOGLE_SAFE_CONCURRENT_WRITES_END();
06033   return total_size;
06034 }
06035 
06036 void SetVariableStatement::MergeFrom(const ::google::protobuf::Message& from) {
06037   GOOGLE_CHECK_NE(&from, this);
06038   const SetVariableStatement* source =
06039     ::google::protobuf::internal::dynamic_cast_if_available<const SetVariableStatement*>(
06040       &from);
06041   if (source == NULL) {
06042     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
06043   } else {
06044     MergeFrom(*source);
06045   }
06046 }
06047 
06048 void SetVariableStatement::MergeFrom(const SetVariableStatement& from) {
06049   GOOGLE_CHECK_NE(&from, this);
06050   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
06051     if (from._has_bit(0)) {
06052       mutable_variable_metadata()->::drizzled::message::FieldMetadata::MergeFrom(from.variable_metadata());
06053     }
06054     if (from._has_bit(1)) {
06055       set_variable_value(from.variable_value());
06056     }
06057   }
06058   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
06059 }
06060 
06061 void SetVariableStatement::CopyFrom(const ::google::protobuf::Message& from) {
06062   if (&from == this) return;
06063   Clear();
06064   MergeFrom(from);
06065 }
06066 
06067 void SetVariableStatement::CopyFrom(const SetVariableStatement& from) {
06068   if (&from == this) return;
06069   Clear();
06070   MergeFrom(from);
06071 }
06072 
06073 bool SetVariableStatement::IsInitialized() const {
06074   if ((_has_bits_[0] & 0x00000003) != 0x00000003) return false;
06075   
06076   if (has_variable_metadata()) {
06077     if (!this->variable_metadata().IsInitialized()) return false;
06078   }
06079   return true;
06080 }
06081 
06082 void SetVariableStatement::Swap(SetVariableStatement* other) {
06083   if (other != this) {
06084     std::swap(variable_metadata_, other->variable_metadata_);
06085     std::swap(variable_value_, other->variable_value_);
06086     std::swap(_has_bits_[0], other->_has_bits_[0]);
06087     _unknown_fields_.Swap(&other->_unknown_fields_);
06088     std::swap(_cached_size_, other->_cached_size_);
06089   }
06090 }
06091 
06092 ::google::protobuf::Metadata SetVariableStatement::GetMetadata() const {
06093   protobuf_AssignDescriptorsOnce();
06094   ::google::protobuf::Metadata metadata;
06095   metadata.descriptor = SetVariableStatement_descriptor_;
06096   metadata.reflection = SetVariableStatement_reflection_;
06097   return metadata;
06098 }
06099 
06100 
06101 // ===================================================================
06102 
06103 const ::google::protobuf::EnumDescriptor* Statement_Type_descriptor() {
06104   protobuf_AssignDescriptorsOnce();
06105   return Statement_Type_descriptor_;
06106 }
06107 bool Statement_Type_IsValid(int value) {
06108   switch(value) {
06109     case 0:
06110     case 1:
06111     case 2:
06112     case 3:
06113     case 4:
06114     case 5:
06115     case 6:
06116     case 7:
06117     case 8:
06118     case 9:
06119     case 10:
06120     case 11:
06121     case 98:
06122     case 99:
06123       return true;
06124     default:
06125       return false;
06126   }
06127 }
06128 
06129 #ifndef _MSC_VER
06130 const Statement_Type Statement::ROLLBACK;
06131 const Statement_Type Statement::INSERT;
06132 const Statement_Type Statement::DELETE;
06133 const Statement_Type Statement::UPDATE;
06134 const Statement_Type Statement::TRUNCATE_TABLE;
06135 const Statement_Type Statement::CREATE_SCHEMA;
06136 const Statement_Type Statement::ALTER_SCHEMA;
06137 const Statement_Type Statement::DROP_SCHEMA;
06138 const Statement_Type Statement::CREATE_TABLE;
06139 const Statement_Type Statement::ALTER_TABLE;
06140 const Statement_Type Statement::DROP_TABLE;
06141 const Statement_Type Statement::ROLLBACK_STATEMENT;
06142 const Statement_Type Statement::SET_VARIABLE;
06143 const Statement_Type Statement::RAW_SQL;
06144 const Statement_Type Statement::Type_MIN;
06145 const Statement_Type Statement::Type_MAX;
06146 const int Statement::Type_ARRAYSIZE;
06147 #endif  // _MSC_VER
06148 const ::std::string Statement::_default_sql_;
06149 const ::std::string Statement::_default_raw_sql_schema_;
06150 #ifndef _MSC_VER
06151 const int Statement::kTypeFieldNumber;
06152 const int Statement::kStartTimestampFieldNumber;
06153 const int Statement::kEndTimestampFieldNumber;
06154 const int Statement::kSqlFieldNumber;
06155 const int Statement::kInsertHeaderFieldNumber;
06156 const int Statement::kInsertDataFieldNumber;
06157 const int Statement::kUpdateHeaderFieldNumber;
06158 const int Statement::kUpdateDataFieldNumber;
06159 const int Statement::kDeleteHeaderFieldNumber;
06160 const int Statement::kDeleteDataFieldNumber;
06161 const int Statement::kTruncateTableStatementFieldNumber;
06162 const int Statement::kCreateSchemaStatementFieldNumber;
06163 const int Statement::kDropSchemaStatementFieldNumber;
06164 const int Statement::kAlterSchemaStatementFieldNumber;
06165 const int Statement::kCreateTableStatementFieldNumber;
06166 const int Statement::kAlterTableStatementFieldNumber;
06167 const int Statement::kDropTableStatementFieldNumber;
06168 const int Statement::kSetVariableStatementFieldNumber;
06169 const int Statement::kRawSqlSchemaFieldNumber;
06170 #endif  // !_MSC_VER
06171 
06172 Statement::Statement()
06173   : ::google::protobuf::Message() {
06174   SharedCtor();
06175 }
06176 
06177 void Statement::InitAsDefaultInstance() {
06178   insert_header_ = const_cast< ::drizzled::message::InsertHeader*>(&::drizzled::message::InsertHeader::default_instance());
06179   insert_data_ = const_cast< ::drizzled::message::InsertData*>(&::drizzled::message::InsertData::default_instance());
06180   update_header_ = const_cast< ::drizzled::message::UpdateHeader*>(&::drizzled::message::UpdateHeader::default_instance());
06181   update_data_ = const_cast< ::drizzled::message::UpdateData*>(&::drizzled::message::UpdateData::default_instance());
06182   delete_header_ = const_cast< ::drizzled::message::DeleteHeader*>(&::drizzled::message::DeleteHeader::default_instance());
06183   delete_data_ = const_cast< ::drizzled::message::DeleteData*>(&::drizzled::message::DeleteData::default_instance());
06184   truncate_table_statement_ = const_cast< ::drizzled::message::TruncateTableStatement*>(&::drizzled::message::TruncateTableStatement::default_instance());
06185   create_schema_statement_ = const_cast< ::drizzled::message::CreateSchemaStatement*>(&::drizzled::message::CreateSchemaStatement::default_instance());
06186   drop_schema_statement_ = const_cast< ::drizzled::message::DropSchemaStatement*>(&::drizzled::message::DropSchemaStatement::default_instance());
06187   alter_schema_statement_ = const_cast< ::drizzled::message::AlterSchemaStatement*>(&::drizzled::message::AlterSchemaStatement::default_instance());
06188   create_table_statement_ = const_cast< ::drizzled::message::CreateTableStatement*>(&::drizzled::message::CreateTableStatement::default_instance());
06189   alter_table_statement_ = const_cast< ::drizzled::message::AlterTableStatement*>(&::drizzled::message::AlterTableStatement::default_instance());
06190   drop_table_statement_ = const_cast< ::drizzled::message::DropTableStatement*>(&::drizzled::message::DropTableStatement::default_instance());
06191   set_variable_statement_ = const_cast< ::drizzled::message::SetVariableStatement*>(&::drizzled::message::SetVariableStatement::default_instance());
06192 }
06193 
06194 Statement::Statement(const Statement& from)
06195   : ::google::protobuf::Message() {
06196   SharedCtor();
06197   MergeFrom(from);
06198 }
06199 
06200 void Statement::SharedCtor() {
06201   _cached_size_ = 0;
06202   type_ = 0;
06203   start_timestamp_ = GOOGLE_ULONGLONG(0);
06204   end_timestamp_ = GOOGLE_ULONGLONG(0);
06205   sql_ = const_cast< ::std::string*>(&_default_sql_);
06206   insert_header_ = NULL;
06207   insert_data_ = NULL;
06208   update_header_ = NULL;
06209   update_data_ = NULL;
06210   delete_header_ = NULL;
06211   delete_data_ = NULL;
06212   truncate_table_statement_ = NULL;
06213   create_schema_statement_ = NULL;
06214   drop_schema_statement_ = NULL;
06215   alter_schema_statement_ = NULL;
06216   create_table_statement_ = NULL;
06217   alter_table_statement_ = NULL;
06218   drop_table_statement_ = NULL;
06219   set_variable_statement_ = NULL;
06220   raw_sql_schema_ = const_cast< ::std::string*>(&_default_raw_sql_schema_);
06221   ::memset(_has_bits_, 0, sizeof(_has_bits_));
06222 }
06223 
06224 Statement::~Statement() {
06225   SharedDtor();
06226 }
06227 
06228 void Statement::SharedDtor() {
06229   if (sql_ != &_default_sql_) {
06230     delete sql_;
06231   }
06232   if (raw_sql_schema_ != &_default_raw_sql_schema_) {
06233     delete raw_sql_schema_;
06234   }
06235   if (this != default_instance_) {
06236     delete insert_header_;
06237     delete insert_data_;
06238     delete update_header_;
06239     delete update_data_;
06240     delete delete_header_;
06241     delete delete_data_;
06242     delete truncate_table_statement_;
06243     delete create_schema_statement_;
06244     delete drop_schema_statement_;
06245     delete alter_schema_statement_;
06246     delete create_table_statement_;
06247     delete alter_table_statement_;
06248     delete drop_table_statement_;
06249     delete set_variable_statement_;
06250   }
06251 }
06252 
06253 void Statement::SetCachedSize(int size) const {
06254   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
06255   _cached_size_ = size;
06256   GOOGLE_SAFE_CONCURRENT_WRITES_END();
06257 }
06258 const ::google::protobuf::Descriptor* Statement::descriptor() {
06259   protobuf_AssignDescriptorsOnce();
06260   return Statement_descriptor_;
06261 }
06262 
06263 const Statement& Statement::default_instance() {
06264   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
06265 }
06266 
06267 Statement* Statement::default_instance_ = NULL;
06268 
06269 Statement* Statement::New() const {
06270   return new Statement;
06271 }
06272 
06273 void Statement::Clear() {
06274   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
06275     type_ = 0;
06276     start_timestamp_ = GOOGLE_ULONGLONG(0);
06277     end_timestamp_ = GOOGLE_ULONGLONG(0);
06278     if (_has_bit(3)) {
06279       if (sql_ != &_default_sql_) {
06280         sql_->clear();
06281       }
06282     }
06283     if (_has_bit(4)) {
06284       if (insert_header_ != NULL) insert_header_->::drizzled::message::InsertHeader::Clear();
06285     }
06286     if (_has_bit(5)) {
06287       if (insert_data_ != NULL) insert_data_->::drizzled::message::InsertData::Clear();
06288     }
06289     if (_has_bit(6)) {
06290       if (update_header_ != NULL) update_header_->::drizzled::message::UpdateHeader::Clear();
06291     }
06292     if (_has_bit(7)) {
06293       if (update_data_ != NULL) update_data_->::drizzled::message::UpdateData::Clear();
06294     }
06295   }
06296   if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
06297     if (_has_bit(8)) {
06298       if (delete_header_ != NULL) delete_header_->::drizzled::message::DeleteHeader::Clear();
06299     }
06300     if (_has_bit(9)) {
06301       if (delete_data_ != NULL) delete_data_->::drizzled::message::DeleteData::Clear();
06302     }
06303     if (_has_bit(10)) {
06304       if (truncate_table_statement_ != NULL) truncate_table_statement_->::drizzled::message::TruncateTableStatement::Clear();
06305     }
06306     if (_has_bit(11)) {
06307       if (create_schema_statement_ != NULL) create_schema_statement_->::drizzled::message::CreateSchemaStatement::Clear();
06308     }
06309     if (_has_bit(12)) {
06310       if (drop_schema_statement_ != NULL) drop_schema_statement_->::drizzled::message::DropSchemaStatement::Clear();
06311     }
06312     if (_has_bit(13)) {
06313       if (alter_schema_statement_ != NULL) alter_schema_statement_->::drizzled::message::AlterSchemaStatement::Clear();
06314     }
06315     if (_has_bit(14)) {
06316       if (create_table_statement_ != NULL) create_table_statement_->::drizzled::message::CreateTableStatement::Clear();
06317     }
06318     if (_has_bit(15)) {
06319       if (alter_table_statement_ != NULL) alter_table_statement_->::drizzled::message::AlterTableStatement::Clear();
06320     }
06321   }
06322   if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
06323     if (_has_bit(16)) {
06324       if (drop_table_statement_ != NULL) drop_table_statement_->::drizzled::message::DropTableStatement::Clear();
06325     }
06326     if (_has_bit(17)) {
06327       if (set_variable_statement_ != NULL) set_variable_statement_->::drizzled::message::SetVariableStatement::Clear();
06328     }
06329     if (_has_bit(18)) {
06330       if (raw_sql_schema_ != &_default_raw_sql_schema_) {
06331         raw_sql_schema_->clear();
06332       }
06333     }
06334   }
06335   ::memset(_has_bits_, 0, sizeof(_has_bits_));
06336   mutable_unknown_fields()->Clear();
06337 }
06338 
06339 bool Statement::MergePartialFromCodedStream(
06340     ::google::protobuf::io::CodedInputStream* input) {
06341 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
06342   ::google::protobuf::uint32 tag;
06343   while ((tag = input->ReadTag()) != 0) {
06344     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
06345       // required .drizzled.message.Statement.Type type = 1;
06346       case 1: {
06347         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06348             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
06349           int value;
06350           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
06351                    int, ::google::protobuf::internal::WireFormatLite::TYPE_ENUM>(
06352                  input, &value)));
06353           if (::drizzled::message::Statement_Type_IsValid(value)) {
06354             set_type(static_cast< ::drizzled::message::Statement_Type >(value));
06355           } else {
06356             mutable_unknown_fields()->AddVarint(1, value);
06357           }
06358         } else {
06359           goto handle_uninterpreted;
06360         }
06361         if (input->ExpectTag(16)) goto parse_start_timestamp;
06362         break;
06363       }
06364       
06365       // required uint64 start_timestamp = 2;
06366       case 2: {
06367         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06368             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
06369          parse_start_timestamp:
06370           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
06371                    ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
06372                  input, &start_timestamp_)));
06373           _set_bit(1);
06374         } else {
06375           goto handle_uninterpreted;
06376         }
06377         if (input->ExpectTag(24)) goto parse_end_timestamp;
06378         break;
06379       }
06380       
06381       // required uint64 end_timestamp = 3;
06382       case 3: {
06383         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06384             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
06385          parse_end_timestamp:
06386           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
06387                    ::google::protobuf::uint64, ::google::protobuf::internal::WireFormatLite::TYPE_UINT64>(
06388                  input, &end_timestamp_)));
06389           _set_bit(2);
06390         } else {
06391           goto handle_uninterpreted;
06392         }
06393         if (input->ExpectTag(34)) goto parse_sql;
06394         break;
06395       }
06396       
06397       // optional string sql = 4;
06398       case 4: {
06399         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06400             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
06401          parse_sql:
06402           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
06403                 input, this->mutable_sql()));
06404           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
06405             this->sql().data(), this->sql().length(),
06406             ::google::protobuf::internal::WireFormat::PARSE);
06407         } else {
06408           goto handle_uninterpreted;
06409         }
06410         if (input->ExpectTag(42)) goto parse_insert_header;
06411         break;
06412       }
06413       
06414       // optional .drizzled.message.InsertHeader insert_header = 5;
06415       case 5: {
06416         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06417             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
06418          parse_insert_header:
06419           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
06420                input, mutable_insert_header()));
06421         } else {
06422           goto handle_uninterpreted;
06423         }
06424         if (input->ExpectTag(50)) goto parse_insert_data;
06425         break;
06426       }
06427       
06428       // optional .drizzled.message.InsertData insert_data = 6;
06429       case 6: {
06430         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06431             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
06432          parse_insert_data:
06433           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
06434                input, mutable_insert_data()));
06435         } else {
06436           goto handle_uninterpreted;
06437         }
06438         if (input->ExpectTag(58)) goto parse_update_header;
06439         break;
06440       }
06441       
06442       // optional .drizzled.message.UpdateHeader update_header = 7;
06443       case 7: {
06444         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06445             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
06446          parse_update_header:
06447           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
06448                input, mutable_update_header()));
06449         } else {
06450           goto handle_uninterpreted;
06451         }
06452         if (input->ExpectTag(66)) goto parse_update_data;
06453         break;
06454       }
06455       
06456       // optional .drizzled.message.UpdateData update_data = 8;
06457       case 8: {
06458         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06459             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
06460          parse_update_data:
06461           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
06462                input, mutable_update_data()));
06463         } else {
06464           goto handle_uninterpreted;
06465         }
06466         if (input->ExpectTag(74)) goto parse_delete_header;
06467         break;
06468       }
06469       
06470       // optional .drizzled.message.DeleteHeader delete_header = 9;
06471       case 9: {
06472         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06473             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
06474          parse_delete_header:
06475           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
06476                input, mutable_delete_header()));
06477         } else {
06478           goto handle_uninterpreted;
06479         }
06480         if (input->ExpectTag(82)) goto parse_delete_data;
06481         break;
06482       }
06483       
06484       // optional .drizzled.message.DeleteData delete_data = 10;
06485       case 10: {
06486         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06487             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
06488          parse_delete_data:
06489           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
06490                input, mutable_delete_data()));
06491         } else {
06492           goto handle_uninterpreted;
06493         }
06494         if (input->ExpectTag(90)) goto parse_truncate_table_statement;
06495         break;
06496       }
06497       
06498       // optional .drizzled.message.TruncateTableStatement truncate_table_statement = 11;
06499       case 11: {
06500         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06501             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
06502          parse_truncate_table_statement:
06503           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
06504                input, mutable_truncate_table_statement()));
06505         } else {
06506           goto handle_uninterpreted;
06507         }
06508         if (input->ExpectTag(98)) goto parse_create_schema_statement;
06509         break;
06510       }
06511       
06512       // optional .drizzled.message.CreateSchemaStatement create_schema_statement = 12;
06513       case 12: {
06514         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06515             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
06516          parse_create_schema_statement:
06517           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
06518                input, mutable_create_schema_statement()));
06519         } else {
06520           goto handle_uninterpreted;
06521         }
06522         if (input->ExpectTag(106)) goto parse_drop_schema_statement;
06523         break;
06524       }
06525       
06526       // optional .drizzled.message.DropSchemaStatement drop_schema_statement = 13;
06527       case 13: {
06528         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06529             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
06530          parse_drop_schema_statement:
06531           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
06532                input, mutable_drop_schema_statement()));
06533         } else {
06534           goto handle_uninterpreted;
06535         }
06536         if (input->ExpectTag(114)) goto parse_alter_schema_statement;
06537         break;
06538       }
06539       
06540       // optional .drizzled.message.AlterSchemaStatement alter_schema_statement = 14;
06541       case 14: {
06542         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06543             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
06544          parse_alter_schema_statement:
06545           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
06546                input, mutable_alter_schema_statement()));
06547         } else {
06548           goto handle_uninterpreted;
06549         }
06550         if (input->ExpectTag(122)) goto parse_create_table_statement;
06551         break;
06552       }
06553       
06554       // optional .drizzled.message.CreateTableStatement create_table_statement = 15;
06555       case 15: {
06556         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06557             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
06558          parse_create_table_statement:
06559           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
06560                input, mutable_create_table_statement()));
06561         } else {
06562           goto handle_uninterpreted;
06563         }
06564         if (input->ExpectTag(130)) goto parse_alter_table_statement;
06565         break;
06566       }
06567       
06568       // optional .drizzled.message.AlterTableStatement alter_table_statement = 16;
06569       case 16: {
06570         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06571             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
06572          parse_alter_table_statement:
06573           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
06574                input, mutable_alter_table_statement()));
06575         } else {
06576           goto handle_uninterpreted;
06577         }
06578         if (input->ExpectTag(138)) goto parse_drop_table_statement;
06579         break;
06580       }
06581       
06582       // optional .drizzled.message.DropTableStatement drop_table_statement = 17;
06583       case 17: {
06584         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06585             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
06586          parse_drop_table_statement:
06587           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
06588                input, mutable_drop_table_statement()));
06589         } else {
06590           goto handle_uninterpreted;
06591         }
06592         if (input->ExpectTag(146)) goto parse_set_variable_statement;
06593         break;
06594       }
06595       
06596       // optional .drizzled.message.SetVariableStatement set_variable_statement = 18;
06597       case 18: {
06598         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06599             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
06600          parse_set_variable_statement:
06601           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
06602                input, mutable_set_variable_statement()));
06603         } else {
06604           goto handle_uninterpreted;
06605         }
06606         if (input->ExpectTag(154)) goto parse_raw_sql_schema;
06607         break;
06608       }
06609       
06610       // optional string raw_sql_schema = 19;
06611       case 19: {
06612         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06613             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
06614          parse_raw_sql_schema:
06615           DO_(::google::protobuf::internal::WireFormatLite::ReadString(
06616                 input, this->mutable_raw_sql_schema()));
06617           ::google::protobuf::internal::WireFormat::VerifyUTF8String(
06618             this->raw_sql_schema().data(), this->raw_sql_schema().length(),
06619             ::google::protobuf::internal::WireFormat::PARSE);
06620         } else {
06621           goto handle_uninterpreted;
06622         }
06623         if (input->ExpectAtEnd()) return true;
06624         break;
06625       }
06626       
06627       default: {
06628       handle_uninterpreted:
06629         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
06630             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
06631           return true;
06632         }
06633         DO_(::google::protobuf::internal::WireFormat::SkipField(
06634               input, tag, mutable_unknown_fields()));
06635         break;
06636       }
06637     }
06638   }
06639   return true;
06640 #undef DO_
06641 }
06642 
06643 void Statement::SerializeWithCachedSizes(
06644     ::google::protobuf::io::CodedOutputStream* output) const {
06645   // required .drizzled.message.Statement.Type type = 1;
06646   if (_has_bit(0)) {
06647     ::google::protobuf::internal::WireFormatLite::WriteEnum(
06648       1, this->type(), output);
06649   }
06650   
06651   // required uint64 start_timestamp = 2;
06652   if (_has_bit(1)) {
06653     ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->start_timestamp(), output);
06654   }
06655   
06656   // required uint64 end_timestamp = 3;
06657   if (_has_bit(2)) {
06658     ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->end_timestamp(), output);
06659   }
06660   
06661   // optional string sql = 4;
06662   if (_has_bit(3)) {
06663     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
06664       this->sql().data(), this->sql().length(),
06665       ::google::protobuf::internal::WireFormat::SERIALIZE);
06666     ::google::protobuf::internal::WireFormatLite::WriteString(
06667       4, this->sql(), output);
06668   }
06669   
06670   // optional .drizzled.message.InsertHeader insert_header = 5;
06671   if (_has_bit(4)) {
06672     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06673       5, this->insert_header(), output);
06674   }
06675   
06676   // optional .drizzled.message.InsertData insert_data = 6;
06677   if (_has_bit(5)) {
06678     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06679       6, this->insert_data(), output);
06680   }
06681   
06682   // optional .drizzled.message.UpdateHeader update_header = 7;
06683   if (_has_bit(6)) {
06684     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06685       7, this->update_header(), output);
06686   }
06687   
06688   // optional .drizzled.message.UpdateData update_data = 8;
06689   if (_has_bit(7)) {
06690     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06691       8, this->update_data(), output);
06692   }
06693   
06694   // optional .drizzled.message.DeleteHeader delete_header = 9;
06695   if (_has_bit(8)) {
06696     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06697       9, this->delete_header(), output);
06698   }
06699   
06700   // optional .drizzled.message.DeleteData delete_data = 10;
06701   if (_has_bit(9)) {
06702     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06703       10, this->delete_data(), output);
06704   }
06705   
06706   // optional .drizzled.message.TruncateTableStatement truncate_table_statement = 11;
06707   if (_has_bit(10)) {
06708     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06709       11, this->truncate_table_statement(), output);
06710   }
06711   
06712   // optional .drizzled.message.CreateSchemaStatement create_schema_statement = 12;
06713   if (_has_bit(11)) {
06714     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06715       12, this->create_schema_statement(), output);
06716   }
06717   
06718   // optional .drizzled.message.DropSchemaStatement drop_schema_statement = 13;
06719   if (_has_bit(12)) {
06720     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06721       13, this->drop_schema_statement(), output);
06722   }
06723   
06724   // optional .drizzled.message.AlterSchemaStatement alter_schema_statement = 14;
06725   if (_has_bit(13)) {
06726     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06727       14, this->alter_schema_statement(), output);
06728   }
06729   
06730   // optional .drizzled.message.CreateTableStatement create_table_statement = 15;
06731   if (_has_bit(14)) {
06732     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06733       15, this->create_table_statement(), output);
06734   }
06735   
06736   // optional .drizzled.message.AlterTableStatement alter_table_statement = 16;
06737   if (_has_bit(15)) {
06738     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06739       16, this->alter_table_statement(), output);
06740   }
06741   
06742   // optional .drizzled.message.DropTableStatement drop_table_statement = 17;
06743   if (_has_bit(16)) {
06744     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06745       17, this->drop_table_statement(), output);
06746   }
06747   
06748   // optional .drizzled.message.SetVariableStatement set_variable_statement = 18;
06749   if (_has_bit(17)) {
06750     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06751       18, this->set_variable_statement(), output);
06752   }
06753   
06754   // optional string raw_sql_schema = 19;
06755   if (_has_bit(18)) {
06756     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
06757       this->raw_sql_schema().data(), this->raw_sql_schema().length(),
06758       ::google::protobuf::internal::WireFormat::SERIALIZE);
06759     ::google::protobuf::internal::WireFormatLite::WriteString(
06760       19, this->raw_sql_schema(), output);
06761   }
06762   
06763   if (!unknown_fields().empty()) {
06764     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
06765         unknown_fields(), output);
06766   }
06767 }
06768 
06769 ::google::protobuf::uint8* Statement::SerializeWithCachedSizesToArray(
06770     ::google::protobuf::uint8* target) const {
06771   // required .drizzled.message.Statement.Type type = 1;
06772   if (_has_bit(0)) {
06773     target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
06774       1, this->type(), target);
06775   }
06776   
06777   // required uint64 start_timestamp = 2;
06778   if (_has_bit(1)) {
06779     target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->start_timestamp(), target);
06780   }
06781   
06782   // required uint64 end_timestamp = 3;
06783   if (_has_bit(2)) {
06784     target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->end_timestamp(), target);
06785   }
06786   
06787   // optional string sql = 4;
06788   if (_has_bit(3)) {
06789     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
06790       this->sql().data(), this->sql().length(),
06791       ::google::protobuf::internal::WireFormat::SERIALIZE);
06792     target =
06793       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
06794         4, this->sql(), target);
06795   }
06796   
06797   // optional .drizzled.message.InsertHeader insert_header = 5;
06798   if (_has_bit(4)) {
06799     target = ::google::protobuf::internal::WireFormatLite::
06800       WriteMessageNoVirtualToArray(
06801         5, this->insert_header(), target);
06802   }
06803   
06804   // optional .drizzled.message.InsertData insert_data = 6;
06805   if (_has_bit(5)) {
06806     target = ::google::protobuf::internal::WireFormatLite::
06807       WriteMessageNoVirtualToArray(
06808         6, this->insert_data(), target);
06809   }
06810   
06811   // optional .drizzled.message.UpdateHeader update_header = 7;
06812   if (_has_bit(6)) {
06813     target = ::google::protobuf::internal::WireFormatLite::
06814       WriteMessageNoVirtualToArray(
06815         7, this->update_header(), target);
06816   }
06817   
06818   // optional .drizzled.message.UpdateData update_data = 8;
06819   if (_has_bit(7)) {
06820     target = ::google::protobuf::internal::WireFormatLite::
06821       WriteMessageNoVirtualToArray(
06822         8, this->update_data(), target);
06823   }
06824   
06825   // optional .drizzled.message.DeleteHeader delete_header = 9;
06826   if (_has_bit(8)) {
06827     target = ::google::protobuf::internal::WireFormatLite::
06828       WriteMessageNoVirtualToArray(
06829         9, this->delete_header(), target);
06830   }
06831   
06832   // optional .drizzled.message.DeleteData delete_data = 10;
06833   if (_has_bit(9)) {
06834     target = ::google::protobuf::internal::WireFormatLite::
06835       WriteMessageNoVirtualToArray(
06836         10, this->delete_data(), target);
06837   }
06838   
06839   // optional .drizzled.message.TruncateTableStatement truncate_table_statement = 11;
06840   if (_has_bit(10)) {
06841     target = ::google::protobuf::internal::WireFormatLite::
06842       WriteMessageNoVirtualToArray(
06843         11, this->truncate_table_statement(), target);
06844   }
06845   
06846   // optional .drizzled.message.CreateSchemaStatement create_schema_statement = 12;
06847   if (_has_bit(11)) {
06848     target = ::google::protobuf::internal::WireFormatLite::
06849       WriteMessageNoVirtualToArray(
06850         12, this->create_schema_statement(), target);
06851   }
06852   
06853   // optional .drizzled.message.DropSchemaStatement drop_schema_statement = 13;
06854   if (_has_bit(12)) {
06855     target = ::google::protobuf::internal::WireFormatLite::
06856       WriteMessageNoVirtualToArray(
06857         13, this->drop_schema_statement(), target);
06858   }
06859   
06860   // optional .drizzled.message.AlterSchemaStatement alter_schema_statement = 14;
06861   if (_has_bit(13)) {
06862     target = ::google::protobuf::internal::WireFormatLite::
06863       WriteMessageNoVirtualToArray(
06864         14, this->alter_schema_statement(), target);
06865   }
06866   
06867   // optional .drizzled.message.CreateTableStatement create_table_statement = 15;
06868   if (_has_bit(14)) {
06869     target = ::google::protobuf::internal::WireFormatLite::
06870       WriteMessageNoVirtualToArray(
06871         15, this->create_table_statement(), target);
06872   }
06873   
06874   // optional .drizzled.message.AlterTableStatement alter_table_statement = 16;
06875   if (_has_bit(15)) {
06876     target = ::google::protobuf::internal::WireFormatLite::
06877       WriteMessageNoVirtualToArray(
06878         16, this->alter_table_statement(), target);
06879   }
06880   
06881   // optional .drizzled.message.DropTableStatement drop_table_statement = 17;
06882   if (_has_bit(16)) {
06883     target = ::google::protobuf::internal::WireFormatLite::
06884       WriteMessageNoVirtualToArray(
06885         17, this->drop_table_statement(), target);
06886   }
06887   
06888   // optional .drizzled.message.SetVariableStatement set_variable_statement = 18;
06889   if (_has_bit(17)) {
06890     target = ::google::protobuf::internal::WireFormatLite::
06891       WriteMessageNoVirtualToArray(
06892         18, this->set_variable_statement(), target);
06893   }
06894   
06895   // optional string raw_sql_schema = 19;
06896   if (_has_bit(18)) {
06897     ::google::protobuf::internal::WireFormat::VerifyUTF8String(
06898       this->raw_sql_schema().data(), this->raw_sql_schema().length(),
06899       ::google::protobuf::internal::WireFormat::SERIALIZE);
06900     target =
06901       ::google::protobuf::internal::WireFormatLite::WriteStringToArray(
06902         19, this->raw_sql_schema(), target);
06903   }
06904   
06905   if (!unknown_fields().empty()) {
06906     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
06907         unknown_fields(), target);
06908   }
06909   return target;
06910 }
06911 
06912 int Statement::ByteSize() const {
06913   int total_size = 0;
06914   
06915   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
06916     // required .drizzled.message.Statement.Type type = 1;
06917     if (has_type()) {
06918       total_size += 1 +
06919         ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
06920     }
06921     
06922     // required uint64 start_timestamp = 2;
06923     if (has_start_timestamp()) {
06924       total_size += 1 +
06925         ::google::protobuf::internal::WireFormatLite::UInt64Size(
06926           this->start_timestamp());
06927     }
06928     
06929     // required uint64 end_timestamp = 3;
06930     if (has_end_timestamp()) {
06931       total_size += 1 +
06932         ::google::protobuf::internal::WireFormatLite::UInt64Size(
06933           this->end_timestamp());
06934     }
06935     
06936     // optional string sql = 4;
06937     if (has_sql()) {
06938       total_size += 1 +
06939         ::google::protobuf::internal::WireFormatLite::StringSize(
06940           this->sql());
06941     }
06942     
06943     // optional .drizzled.message.InsertHeader insert_header = 5;
06944     if (has_insert_header()) {
06945       total_size += 1 +
06946         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06947           this->insert_header());
06948     }
06949     
06950     // optional .drizzled.message.InsertData insert_data = 6;
06951     if (has_insert_data()) {
06952       total_size += 1 +
06953         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06954           this->insert_data());
06955     }
06956     
06957     // optional .drizzled.message.UpdateHeader update_header = 7;
06958     if (has_update_header()) {
06959       total_size += 1 +
06960         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06961           this->update_header());
06962     }
06963     
06964     // optional .drizzled.message.UpdateData update_data = 8;
06965     if (has_update_data()) {
06966       total_size += 1 +
06967         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06968           this->update_data());
06969     }
06970     
06971   }
06972   if (_has_bits_[8 / 32] & (0xffu << (8 % 32))) {
06973     // optional .drizzled.message.DeleteHeader delete_header = 9;
06974     if (has_delete_header()) {
06975       total_size += 1 +
06976         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06977           this->delete_header());
06978     }
06979     
06980     // optional .drizzled.message.DeleteData delete_data = 10;
06981     if (has_delete_data()) {
06982       total_size += 1 +
06983         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06984           this->delete_data());
06985     }
06986     
06987     // optional .drizzled.message.TruncateTableStatement truncate_table_statement = 11;
06988     if (has_truncate_table_statement()) {
06989       total_size += 1 +
06990         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06991           this->truncate_table_statement());
06992     }
06993     
06994     // optional .drizzled.message.CreateSchemaStatement create_schema_statement = 12;
06995     if (has_create_schema_statement()) {
06996       total_size += 1 +
06997         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06998           this->create_schema_statement());
06999     }
07000     
07001     // optional .drizzled.message.DropSchemaStatement drop_schema_statement = 13;
07002     if (has_drop_schema_statement()) {
07003       total_size += 1 +
07004         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
07005           this->drop_schema_statement());
07006     }
07007     
07008     // optional .drizzled.message.AlterSchemaStatement alter_schema_statement = 14;
07009     if (has_alter_schema_statement()) {
07010       total_size += 1 +
07011         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
07012           this->alter_schema_statement());
07013     }
07014     
07015     // optional .drizzled.message.CreateTableStatement create_table_statement = 15;
07016     if (has_create_table_statement()) {
07017       total_size += 1 +
07018         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
07019           this->create_table_statement());
07020     }
07021     
07022     // optional .drizzled.message.AlterTableStatement alter_table_statement = 16;
07023     if (has_alter_table_statement()) {
07024       total_size += 2 +
07025         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
07026           this->alter_table_statement());
07027     }
07028     
07029   }
07030   if (_has_bits_[16 / 32] & (0xffu << (16 % 32))) {
07031     // optional .drizzled.message.DropTableStatement drop_table_statement = 17;
07032     if (has_drop_table_statement()) {
07033       total_size += 2 +
07034         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
07035           this->drop_table_statement());
07036     }
07037     
07038     // optional .drizzled.message.SetVariableStatement set_variable_statement = 18;
07039     if (has_set_variable_statement()) {
07040       total_size += 2 +
07041         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
07042           this->set_variable_statement());
07043     }
07044     
07045     // optional string raw_sql_schema = 19;
07046     if (has_raw_sql_schema()) {
07047       total_size += 2 +
07048         ::google::protobuf::internal::WireFormatLite::StringSize(
07049           this->raw_sql_schema());
07050     }
07051     
07052   }
07053   if (!unknown_fields().empty()) {
07054     total_size +=
07055       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
07056         unknown_fields());
07057   }
07058   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
07059   _cached_size_ = total_size;
07060   GOOGLE_SAFE_CONCURRENT_WRITES_END();
07061   return total_size;
07062 }
07063 
07064 void Statement::MergeFrom(const ::google::protobuf::Message& from) {
07065   GOOGLE_CHECK_NE(&from, this);
07066   const Statement* source =
07067     ::google::protobuf::internal::dynamic_cast_if_available<const Statement*>(
07068       &from);
07069   if (source == NULL) {
07070     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
07071   } else {
07072     MergeFrom(*source);
07073   }
07074 }
07075 
07076 void Statement::MergeFrom(const Statement& from) {
07077   GOOGLE_CHECK_NE(&from, this);
07078   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
07079     if (from._has_bit(0)) {
07080       set_type(from.type());
07081     }
07082     if (from._has_bit(1)) {
07083       set_start_timestamp(from.start_timestamp());
07084     }
07085     if (from._has_bit(2)) {
07086       set_end_timestamp(from.end_timestamp());
07087     }
07088     if (from._has_bit(3)) {
07089       set_sql(from.sql());
07090     }
07091     if (from._has_bit(4)) {
07092       mutable_insert_header()->::drizzled::message::InsertHeader::MergeFrom(from.insert_header());
07093     }
07094     if (from._has_bit(5)) {
07095       mutable_insert_data()->::drizzled::message::InsertData::MergeFrom(from.insert_data());
07096     }
07097     if (from._has_bit(6)) {
07098       mutable_update_header()->::drizzled::message::UpdateHeader::MergeFrom(from.update_header());
07099     }
07100     if (from._has_bit(7)) {
07101       mutable_update_data()->::drizzled::message::UpdateData::MergeFrom(from.update_data());
07102     }
07103   }
07104   if (from._has_bits_[8 / 32] & (0xffu << (8 % 32))) {
07105     if (from._has_bit(8)) {
07106       mutable_delete_header()->::drizzled::message::DeleteHeader::MergeFrom(from.delete_header());
07107     }
07108     if (from._has_bit(9)) {
07109       mutable_delete_data()->::drizzled::message::DeleteData::MergeFrom(from.delete_data());
07110     }
07111     if (from._has_bit(10)) {
07112       mutable_truncate_table_statement()->::drizzled::message::TruncateTableStatement::MergeFrom(from.truncate_table_statement());
07113     }
07114     if (from._has_bit(11)) {
07115       mutable_create_schema_statement()->::drizzled::message::CreateSchemaStatement::MergeFrom(from.create_schema_statement());
07116     }
07117     if (from._has_bit(12)) {
07118       mutable_drop_schema_statement()->::drizzled::message::DropSchemaStatement::MergeFrom(from.drop_schema_statement());
07119     }
07120     if (from._has_bit(13)) {
07121       mutable_alter_schema_statement()->::drizzled::message::AlterSchemaStatement::MergeFrom(from.alter_schema_statement());
07122     }
07123     if (from._has_bit(14)) {
07124       mutable_create_table_statement()->::drizzled::message::CreateTableStatement::MergeFrom(from.create_table_statement());
07125     }
07126     if (from._has_bit(15)) {
07127       mutable_alter_table_statement()->::drizzled::message::AlterTableStatement::MergeFrom(from.alter_table_statement());
07128     }
07129   }
07130   if (from._has_bits_[16 / 32] & (0xffu << (16 % 32))) {
07131     if (from._has_bit(16)) {
07132       mutable_drop_table_statement()->::drizzled::message::DropTableStatement::MergeFrom(from.drop_table_statement());
07133     }
07134     if (from._has_bit(17)) {
07135       mutable_set_variable_statement()->::drizzled::message::SetVariableStatement::MergeFrom(from.set_variable_statement());
07136     }
07137     if (from._has_bit(18)) {
07138       set_raw_sql_schema(from.raw_sql_schema());
07139     }
07140   }
07141   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
07142 }
07143 
07144 void Statement::CopyFrom(const ::google::protobuf::Message& from) {
07145   if (&from == this) return;
07146   Clear();
07147   MergeFrom(from);
07148 }
07149 
07150 void Statement::CopyFrom(const Statement& from) {
07151   if (&from == this) return;
07152   Clear();
07153   MergeFrom(from);
07154 }
07155 
07156 bool Statement::IsInitialized() const {
07157   if ((_has_bits_[0] & 0x00000007) != 0x00000007) return false;
07158   
07159   if (has_insert_header()) {
07160     if (!this->insert_header().IsInitialized()) return false;
07161   }
07162   if (has_insert_data()) {
07163     if (!this->insert_data().IsInitialized()) return false;
07164   }
07165   if (has_update_header()) {
07166     if (!this->update_header().IsInitialized()) return false;
07167   }
07168   if (has_update_data()) {
07169     if (!this->update_data().IsInitialized()) return false;
07170   }
07171   if (has_delete_header()) {
07172     if (!this->delete_header().IsInitialized()) return false;
07173   }
07174   if (has_delete_data()) {
07175     if (!this->delete_data().IsInitialized()) return false;
07176   }
07177   if (has_truncate_table_statement()) {
07178     if (!this->truncate_table_statement().IsInitialized()) return false;
07179   }
07180   if (has_create_schema_statement()) {
07181     if (!this->create_schema_statement().IsInitialized()) return false;
07182   }
07183   if (has_drop_schema_statement()) {
07184     if (!this->drop_schema_statement().IsInitialized()) return false;
07185   }
07186   if (has_alter_schema_statement()) {
07187     if (!this->alter_schema_statement().IsInitialized()) return false;
07188   }
07189   if (has_create_table_statement()) {
07190     if (!this->create_table_statement().IsInitialized()) return false;
07191   }
07192   if (has_alter_table_statement()) {
07193     if (!this->alter_table_statement().IsInitialized()) return false;
07194   }
07195   if (has_drop_table_statement()) {
07196     if (!this->drop_table_statement().IsInitialized()) return false;
07197   }
07198   if (has_set_variable_statement()) {
07199     if (!this->set_variable_statement().IsInitialized()) return false;
07200   }
07201   return true;
07202 }
07203 
07204 void Statement::Swap(Statement* other) {
07205   if (other != this) {
07206     std::swap(type_, other->type_);
07207     std::swap(start_timestamp_, other->start_timestamp_);
07208     std::swap(end_timestamp_, other->end_timestamp_);
07209     std::swap(sql_, other->sql_);
07210     std::swap(insert_header_, other->insert_header_);
07211     std::swap(insert_data_, other->insert_data_);
07212     std::swap(update_header_, other->update_header_);
07213     std::swap(update_data_, other->update_data_);
07214     std::swap(delete_header_, other->delete_header_);
07215     std::swap(delete_data_, other->delete_data_);
07216     std::swap(truncate_table_statement_, other->truncate_table_statement_);
07217     std::swap(create_schema_statement_, other->create_schema_statement_);
07218     std::swap(drop_schema_statement_, other->drop_schema_statement_);
07219     std::swap(alter_schema_statement_, other->alter_schema_statement_);
07220     std::swap(create_table_statement_, other->create_table_statement_);
07221     std::swap(alter_table_statement_, other->alter_table_statement_);
07222     std::swap(drop_table_statement_, other->drop_table_statement_);
07223     std::swap(set_variable_statement_, other->set_variable_statement_);
07224     std::swap(raw_sql_schema_, other->raw_sql_schema_);
07225     std::swap(_has_bits_[0], other->_has_bits_[0]);
07226     _unknown_fields_.Swap(&other->_unknown_fields_);
07227     std::swap(_cached_size_, other->_cached_size_);
07228   }
07229 }
07230 
07231 ::google::protobuf::Metadata Statement::GetMetadata() const {
07232   protobuf_AssignDescriptorsOnce();
07233   ::google::protobuf::Metadata metadata;
07234   metadata.descriptor = Statement_descriptor_;
07235   metadata.reflection = Statement_reflection_;
07236   return metadata;
07237 }
07238 
07239 
07240 // ===================================================================
07241 
07242 #ifndef _MSC_VER
07243 const int Transaction::kTransactionContextFieldNumber;
07244 const int Transaction::kStatementFieldNumber;
07245 const int Transaction::kEventFieldNumber;
07246 const int Transaction::kSegmentIdFieldNumber;
07247 const int Transaction::kEndSegmentFieldNumber;
07248 #endif  // !_MSC_VER
07249 
07250 Transaction::Transaction()
07251   : ::google::protobuf::Message() {
07252   SharedCtor();
07253 }
07254 
07255 void Transaction::InitAsDefaultInstance() {
07256   transaction_context_ = const_cast< ::drizzled::message::TransactionContext*>(&::drizzled::message::TransactionContext::default_instance());
07257   event_ = const_cast< ::drizzled::message::Event*>(&::drizzled::message::Event::default_instance());
07258 }
07259 
07260 Transaction::Transaction(const Transaction& from)
07261   : ::google::protobuf::Message() {
07262   SharedCtor();
07263   MergeFrom(from);
07264 }
07265 
07266 void Transaction::SharedCtor() {
07267   _cached_size_ = 0;
07268   transaction_context_ = NULL;
07269   event_ = NULL;
07270   segment_id_ = 0u;
07271   end_segment_ = false;
07272   ::memset(_has_bits_, 0, sizeof(_has_bits_));
07273 }
07274 
07275 Transaction::~Transaction() {
07276   SharedDtor();
07277 }
07278 
07279 void Transaction::SharedDtor() {
07280   if (this != default_instance_) {
07281     delete transaction_context_;
07282     delete event_;
07283   }
07284 }
07285 
07286 void Transaction::SetCachedSize(int size) const {
07287   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
07288   _cached_size_ = size;
07289   GOOGLE_SAFE_CONCURRENT_WRITES_END();
07290 }
07291 const ::google::protobuf::Descriptor* Transaction::descriptor() {
07292   protobuf_AssignDescriptorsOnce();
07293   return Transaction_descriptor_;
07294 }
07295 
07296 const Transaction& Transaction::default_instance() {
07297   if (default_instance_ == NULL) protobuf_AddDesc_transaction_2eproto();  return *default_instance_;
07298 }
07299 
07300 Transaction* Transaction::default_instance_ = NULL;
07301 
07302 Transaction* Transaction::New() const {
07303   return new Transaction;
07304 }
07305 
07306 void Transaction::Clear() {
07307   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
07308     if (_has_bit(0)) {
07309       if (transaction_context_ != NULL) transaction_context_->::drizzled::message::TransactionContext::Clear();
07310     }
07311     if (_has_bit(2)) {
07312       if (event_ != NULL) event_->::drizzled::message::Event::Clear();
07313     }
07314     segment_id_ = 0u;
07315     end_segment_ = false;
07316   }
07317   statement_.Clear();
07318   ::memset(_has_bits_, 0, sizeof(_has_bits_));
07319   mutable_unknown_fields()->Clear();
07320 }
07321 
07322 bool Transaction::MergePartialFromCodedStream(
07323     ::google::protobuf::io::CodedInputStream* input) {
07324 #define DO_(EXPRESSION) if (!(EXPRESSION)) return false
07325   ::google::protobuf::uint32 tag;
07326   while ((tag = input->ReadTag()) != 0) {
07327     switch (::google::protobuf::internal::WireFormatLite::GetTagFieldNumber(tag)) {
07328       // required .drizzled.message.TransactionContext transaction_context = 1;
07329       case 1: {
07330         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
07331             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
07332           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
07333                input, mutable_transaction_context()));
07334         } else {
07335           goto handle_uninterpreted;
07336         }
07337         if (input->ExpectTag(18)) goto parse_statement;
07338         break;
07339       }
07340       
07341       // repeated .drizzled.message.Statement statement = 2;
07342       case 2: {
07343         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
07344             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
07345          parse_statement:
07346           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
07347                 input, add_statement()));
07348         } else {
07349           goto handle_uninterpreted;
07350         }
07351         if (input->ExpectTag(18)) goto parse_statement;
07352         if (input->ExpectTag(26)) goto parse_event;
07353         break;
07354       }
07355       
07356       // optional .drizzled.message.Event event = 3;
07357       case 3: {
07358         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
07359             ::google::protobuf::internal::WireFormatLite::WIRETYPE_LENGTH_DELIMITED) {
07360          parse_event:
07361           DO_(::google::protobuf::internal::WireFormatLite::ReadMessageNoVirtual(
07362                input, mutable_event()));
07363         } else {
07364           goto handle_uninterpreted;
07365         }
07366         if (input->ExpectTag(32)) goto parse_segment_id;
07367         break;
07368       }
07369       
07370       // optional uint32 segment_id = 4;
07371       case 4: {
07372         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
07373             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
07374          parse_segment_id:
07375           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
07376                    ::google::protobuf::uint32, ::google::protobuf::internal::WireFormatLite::TYPE_UINT32>(
07377                  input, &segment_id_)));
07378           _set_bit(3);
07379         } else {
07380           goto handle_uninterpreted;
07381         }
07382         if (input->ExpectTag(40)) goto parse_end_segment;
07383         break;
07384       }
07385       
07386       // optional bool end_segment = 5;
07387       case 5: {
07388         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
07389             ::google::protobuf::internal::WireFormatLite::WIRETYPE_VARINT) {
07390          parse_end_segment:
07391           DO_((::google::protobuf::internal::WireFormatLite::ReadPrimitive<
07392                    bool, ::google::protobuf::internal::WireFormatLite::TYPE_BOOL>(
07393                  input, &end_segment_)));
07394           _set_bit(4);
07395         } else {
07396           goto handle_uninterpreted;
07397         }
07398         if (input->ExpectAtEnd()) return true;
07399         break;
07400       }
07401       
07402       default: {
07403       handle_uninterpreted:
07404         if (::google::protobuf::internal::WireFormatLite::GetTagWireType(tag) ==
07405             ::google::protobuf::internal::WireFormatLite::WIRETYPE_END_GROUP) {
07406           return true;
07407         }
07408         DO_(::google::protobuf::internal::WireFormat::SkipField(
07409               input, tag, mutable_unknown_fields()));
07410         break;
07411       }
07412     }
07413   }
07414   return true;
07415 #undef DO_
07416 }
07417 
07418 void Transaction::SerializeWithCachedSizes(
07419     ::google::protobuf::io::CodedOutputStream* output) const {
07420   // required .drizzled.message.TransactionContext transaction_context = 1;
07421   if (_has_bit(0)) {
07422     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
07423       1, this->transaction_context(), output);
07424   }
07425   
07426   // repeated .drizzled.message.Statement statement = 2;
07427   for (int i = 0; i < this->statement_size(); i++) {
07428     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
07429       2, this->statement(i), output);
07430   }
07431   
07432   // optional .drizzled.message.Event event = 3;
07433   if (_has_bit(2)) {
07434     ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
07435       3, this->event(), output);
07436   }
07437   
07438   // optional uint32 segment_id = 4;
07439   if (_has_bit(3)) {
07440     ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->segment_id(), output);
07441   }
07442   
07443   // optional bool end_segment = 5;
07444   if (_has_bit(4)) {
07445     ::google::protobuf::internal::WireFormatLite::WriteBool(5, this->end_segment(), output);
07446   }
07447   
07448   if (!unknown_fields().empty()) {
07449     ::google::protobuf::internal::WireFormat::SerializeUnknownFields(
07450         unknown_fields(), output);
07451   }
07452 }
07453 
07454 ::google::protobuf::uint8* Transaction::SerializeWithCachedSizesToArray(
07455     ::google::protobuf::uint8* target) const {
07456   // required .drizzled.message.TransactionContext transaction_context = 1;
07457   if (_has_bit(0)) {
07458     target = ::google::protobuf::internal::WireFormatLite::
07459       WriteMessageNoVirtualToArray(
07460         1, this->transaction_context(), target);
07461   }
07462   
07463   // repeated .drizzled.message.Statement statement = 2;
07464   for (int i = 0; i < this->statement_size(); i++) {
07465     target = ::google::protobuf::internal::WireFormatLite::
07466       WriteMessageNoVirtualToArray(
07467         2, this->statement(i), target);
07468   }
07469   
07470   // optional .drizzled.message.Event event = 3;
07471   if (_has_bit(2)) {
07472     target = ::google::protobuf::internal::WireFormatLite::
07473       WriteMessageNoVirtualToArray(
07474         3, this->event(), target);
07475   }
07476   
07477   // optional uint32 segment_id = 4;
07478   if (_has_bit(3)) {
07479     target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->segment_id(), target);
07480   }
07481   
07482   // optional bool end_segment = 5;
07483   if (_has_bit(4)) {
07484     target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(5, this->end_segment(), target);
07485   }
07486   
07487   if (!unknown_fields().empty()) {
07488     target = ::google::protobuf::internal::WireFormat::SerializeUnknownFieldsToArray(
07489         unknown_fields(), target);
07490   }
07491   return target;
07492 }
07493 
07494 int Transaction::ByteSize() const {
07495   int total_size = 0;
07496   
07497   if (_has_bits_[0 / 32] & (0xffu << (0 % 32))) {
07498     // required .drizzled.message.TransactionContext transaction_context = 1;
07499     if (has_transaction_context()) {
07500       total_size += 1 +
07501         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
07502           this->transaction_context());
07503     }
07504     
07505     // optional .drizzled.message.Event event = 3;
07506     if (has_event()) {
07507       total_size += 1 +
07508         ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
07509           this->event());
07510     }
07511     
07512     // optional uint32 segment_id = 4;
07513     if (has_segment_id()) {
07514       total_size += 1 +
07515         ::google::protobuf::internal::WireFormatLite::UInt32Size(
07516           this->segment_id());
07517     }
07518     
07519     // optional bool end_segment = 5;
07520     if (has_end_segment()) {
07521       total_size += 1 + 1;
07522     }
07523     
07524   }
07525   // repeated .drizzled.message.Statement statement = 2;
07526   total_size += 1 * this->statement_size();
07527   for (int i = 0; i < this->statement_size(); i++) {
07528     total_size +=
07529       ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
07530         this->statement(i));
07531   }
07532   
07533   if (!unknown_fields().empty()) {
07534     total_size +=
07535       ::google::protobuf::internal::WireFormat::ComputeUnknownFieldsSize(
07536         unknown_fields());
07537   }
07538   GOOGLE_SAFE_CONCURRENT_WRITES_BEGIN();
07539   _cached_size_ = total_size;
07540   GOOGLE_SAFE_CONCURRENT_WRITES_END();
07541   return total_size;
07542 }
07543 
07544 void Transaction::MergeFrom(const ::google::protobuf::Message& from) {
07545   GOOGLE_CHECK_NE(&from, this);
07546   const Transaction* source =
07547     ::google::protobuf::internal::dynamic_cast_if_available<const Transaction*>(
07548       &from);
07549   if (source == NULL) {
07550     ::google::protobuf::internal::ReflectionOps::Merge(from, this);
07551   } else {
07552     MergeFrom(*source);
07553   }
07554 }
07555 
07556 void Transaction::MergeFrom(const Transaction& from) {
07557   GOOGLE_CHECK_NE(&from, this);
07558   statement_.MergeFrom(from.statement_);
07559   if (from._has_bits_[0 / 32] & (0xffu << (0 % 32))) {
07560     if (from._has_bit(0)) {
07561       mutable_transaction_context()->::drizzled::message::TransactionContext::MergeFrom(from.transaction_context());
07562     }
07563     if (from._has_bit(2)) {
07564       mutable_event()->::drizzled::message::Event::MergeFrom(from.event());
07565     }
07566     if (from._has_bit(3)) {
07567       set_segment_id(from.segment_id());
07568     }
07569     if (from._has_bit(4)) {
07570       set_end_segment(from.end_segment());
07571     }
07572   }
07573   mutable_unknown_fields()->MergeFrom(from.unknown_fields());
07574 }
07575 
07576 void Transaction::CopyFrom(const ::google::protobuf::Message& from) {
07577   if (&from == this) return;
07578   Clear();
07579   MergeFrom(from);
07580 }
07581 
07582 void Transaction::CopyFrom(const Transaction& from) {
07583   if (&from == this) return;
07584   Clear();
07585   MergeFrom(from);
07586 }
07587 
07588 bool Transaction::IsInitialized() const {
07589   if ((_has_bits_[0] & 0x00000001) != 0x00000001) return false;
07590   
07591   if (has_transaction_context()) {
07592     if (!this->transaction_context().IsInitialized()) return false;
07593   }
07594   for (int i = 0; i < statement_size(); i++) {
07595     if (!this->statement(i).IsInitialized()) return false;
07596   }
07597   if (has_event()) {
07598     if (!this->event().IsInitialized()) return false;
07599   }
07600   return true;
07601 }
07602 
07603 void Transaction::Swap(Transaction* other) {
07604   if (other != this) {
07605     std::swap(transaction_context_, other->transaction_context_);
07606     statement_.Swap(&other->statement_);
07607     std::swap(event_, other->event_);
07608     std::swap(segment_id_, other->segment_id_);
07609     std::swap(end_segment_, other->end_segment_);
07610     std::swap(_has_bits_[0], other->_has_bits_[0]);
07611     _unknown_fields_.Swap(&other->_unknown_fields_);
07612     std::swap(_cached_size_, other->_cached_size_);
07613   }
07614 }
07615 
07616 ::google::protobuf::Metadata Transaction::GetMetadata() const {
07617   protobuf_AssignDescriptorsOnce();
07618   ::google::protobuf::Metadata metadata;
07619   metadata.descriptor = Transaction_descriptor_;
07620   metadata.reflection = Transaction_reflection_;
07621   return metadata;
07622 }
07623 
07624 
07625 // @@protoc_insertion_point(namespace_scope)
07626 
07627 }  // namespace message
07628 }  // namespace drizzled
07629 
07630 // @@protoc_insertion_point(global_scope)