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