00001
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
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 }
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 }
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
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
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
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
00874 if (has_type()) {
00875 ::google::protobuf::internal::WireFormatLite::WriteEnum(
00876 1, this->type(), output);
00877 }
00878
00879
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
00897 if (has_type()) {
00898 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
00899 1, this->type(), target);
00900 }
00901
00902
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
00924 if (has_type()) {
00925 total_size += 1 +
00926 ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
00927 }
00928
00929
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
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
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
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
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
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
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
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
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
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
01251 if (has_schema_name()) {
01252 total_size += 1 +
01253 ::google::protobuf::internal::WireFormatLite::StringSize(
01254 this->schema_name());
01255 }
01256
01257
01258 if (has_table_name()) {
01259 total_size += 1 +
01260 ::google::protobuf::internal::WireFormatLite::StringSize(
01261 this->table_name());
01262 }
01263
01264
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
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
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
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
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
01509 if (has_server_id()) {
01510 ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->server_id(), output);
01511 }
01512
01513
01514 if (has_transaction_id()) {
01515 ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->transaction_id(), output);
01516 }
01517
01518
01519 if (has_start_timestamp()) {
01520 ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->start_timestamp(), output);
01521 }
01522
01523
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
01537 if (has_server_id()) {
01538 target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->server_id(), target);
01539 }
01540
01541
01542 if (has_transaction_id()) {
01543 target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->transaction_id(), target);
01544 }
01545
01546
01547 if (has_start_timestamp()) {
01548 target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->start_timestamp(), target);
01549 }
01550
01551
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
01568 if (has_server_id()) {
01569 total_size += 1 +
01570 ::google::protobuf::internal::WireFormatLite::UInt32Size(
01571 this->server_id());
01572 }
01573
01574
01575 if (has_transaction_id()) {
01576 total_size += 1 +
01577 ::google::protobuf::internal::WireFormatLite::UInt64Size(
01578 this->transaction_id());
01579 }
01580
01581
01582 if (has_start_timestamp()) {
01583 total_size += 1 +
01584 ::google::protobuf::internal::WireFormatLite::UInt64Size(
01585 this->start_timestamp());
01586 }
01587
01588
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
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
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
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
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
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
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
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
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
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
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
02044 if (has_table_metadata()) {
02045 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
02046 1, this->table_metadata(), output);
02047 }
02048
02049
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
02064 if (has_table_metadata()) {
02065 target = ::google::protobuf::internal::WireFormatLite::
02066 WriteMessageNoVirtualToArray(
02067 1, this->table_metadata(), target);
02068 }
02069
02070
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
02089 if (has_table_metadata()) {
02090 total_size += 1 +
02091 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
02092 this->table_metadata());
02093 }
02094
02095 }
02096
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
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
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
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
02320 if (has_segment_id()) {
02321 ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->segment_id(), output);
02322 }
02323
02324
02325 if (has_end_segment()) {
02326 ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->end_segment(), output);
02327 }
02328
02329
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
02344 if (has_segment_id()) {
02345 target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->segment_id(), target);
02346 }
02347
02348
02349 if (has_end_segment()) {
02350 target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->end_segment(), target);
02351 }
02352
02353
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
02372 if (has_segment_id()) {
02373 total_size += 1 +
02374 ::google::protobuf::internal::WireFormatLite::UInt32Size(
02375 this->segment_id());
02376 }
02377
02378
02379 if (has_end_segment()) {
02380 total_size += 1 + 1;
02381 }
02382
02383 }
02384
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
02927 if (has_table_metadata()) {
02928 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
02929 1, this->table_metadata(), output);
02930 }
02931
02932
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
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
02953 if (has_table_metadata()) {
02954 target = ::google::protobuf::internal::WireFormatLite::
02955 WriteMessageNoVirtualToArray(
02956 1, this->table_metadata(), target);
02957 }
02958
02959
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
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
02985 if (has_table_metadata()) {
02986 total_size += 1 +
02987 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
02988 this->table_metadata());
02989 }
02990
02991 }
02992
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
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
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
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
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
03229 if (has_segment_id()) {
03230 ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->segment_id(), output);
03231 }
03232
03233
03234 if (has_end_segment()) {
03235 ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->end_segment(), output);
03236 }
03237
03238
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
03253 if (has_segment_id()) {
03254 target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->segment_id(), target);
03255 }
03256
03257
03258 if (has_end_segment()) {
03259 target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->end_segment(), target);
03260 }
03261
03262
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
03281 if (has_segment_id()) {
03282 total_size += 1 +
03283 ::google::protobuf::internal::WireFormatLite::UInt32Size(
03284 this->segment_id());
03285 }
03286
03287
03288 if (has_end_segment()) {
03289 total_size += 1 + 1;
03290 }
03291
03292 }
03293
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
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
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
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
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
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
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
03698 if (has_table_metadata()) {
03699 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
03700 1, this->table_metadata(), output);
03701 }
03702
03703
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
03718 if (has_table_metadata()) {
03719 target = ::google::protobuf::internal::WireFormatLite::
03720 WriteMessageNoVirtualToArray(
03721 1, this->table_metadata(), target);
03722 }
03723
03724
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
03743 if (has_table_metadata()) {
03744 total_size += 1 +
03745 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
03746 this->table_metadata());
03747 }
03748
03749 }
03750
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
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
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
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
03974 if (has_segment_id()) {
03975 ::google::protobuf::internal::WireFormatLite::WriteUInt32(1, this->segment_id(), output);
03976 }
03977
03978
03979 if (has_end_segment()) {
03980 ::google::protobuf::internal::WireFormatLite::WriteBool(2, this->end_segment(), output);
03981 }
03982
03983
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
03998 if (has_segment_id()) {
03999 target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(1, this->segment_id(), target);
04000 }
04001
04002
04003 if (has_end_segment()) {
04004 target = ::google::protobuf::internal::WireFormatLite::WriteBoolToArray(2, this->end_segment(), target);
04005 }
04006
04007
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
04026 if (has_segment_id()) {
04027 total_size += 1 +
04028 ::google::protobuf::internal::WireFormatLite::UInt32Size(
04029 this->segment_id());
04030 }
04031
04032
04033 if (has_end_segment()) {
04034 total_size += 1 + 1;
04035 }
04036
04037 }
04038
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
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
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
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
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
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
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
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
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
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
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
04679 if (has_before()) {
04680 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
04681 1, this->before(), output);
04682 }
04683
04684
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
04699 if (has_before()) {
04700 target = ::google::protobuf::internal::WireFormatLite::
04701 WriteMessageNoVirtualToArray(
04702 1, this->before(), target);
04703 }
04704
04705
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
04724 if (has_before()) {
04725 total_size += 1 +
04726 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
04727 this->before());
04728 }
04729
04730
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
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
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
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
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
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
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
05012 if (has_schema_name()) {
05013 total_size += 1 +
05014 ::google::protobuf::internal::WireFormatLite::StringSize(
05015 this->schema_name());
05016 }
05017
05018
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
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
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
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
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
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
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
05441 if (has_before()) {
05442 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
05443 1, this->before(), output);
05444 }
05445
05446
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
05461 if (has_before()) {
05462 target = ::google::protobuf::internal::WireFormatLite::
05463 WriteMessageNoVirtualToArray(
05464 1, this->before(), target);
05465 }
05466
05467
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
05486 if (has_before()) {
05487 total_size += 1 +
05488 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
05489 this->before());
05490 }
05491
05492
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
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
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
05703 if (has_table_metadata()) {
05704 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
05705 1, this->table_metadata(), output);
05706 }
05707
05708
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
05722 if (has_table_metadata()) {
05723 target = ::google::protobuf::internal::WireFormatLite::
05724 WriteMessageNoVirtualToArray(
05725 1, this->table_metadata(), target);
05726 }
05727
05728
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
05745 if (has_table_metadata()) {
05746 total_size += 1 +
05747 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
05748 this->table_metadata());
05749 }
05750
05751
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
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
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
05962 if (has_variable_metadata()) {
05963 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
05964 1, this->variable_metadata(), output);
05965 }
05966
05967
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
05982 if (has_variable_metadata()) {
05983 target = ::google::protobuf::internal::WireFormatLite::
05984 WriteMessageNoVirtualToArray(
05985 1, this->variable_metadata(), target);
05986 }
05987
05988
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
06007 if (has_variable_metadata()) {
06008 total_size += 1 +
06009 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06010 this->variable_metadata());
06011 }
06012
06013
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
06640 if (has_type()) {
06641 ::google::protobuf::internal::WireFormatLite::WriteEnum(
06642 1, this->type(), output);
06643 }
06644
06645
06646 if (has_start_timestamp()) {
06647 ::google::protobuf::internal::WireFormatLite::WriteUInt64(2, this->start_timestamp(), output);
06648 }
06649
06650
06651 if (has_end_timestamp()) {
06652 ::google::protobuf::internal::WireFormatLite::WriteUInt64(3, this->end_timestamp(), output);
06653 }
06654
06655
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
06665 if (has_insert_header()) {
06666 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06667 5, this->insert_header(), output);
06668 }
06669
06670
06671 if (has_insert_data()) {
06672 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06673 6, this->insert_data(), output);
06674 }
06675
06676
06677 if (has_update_header()) {
06678 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06679 7, this->update_header(), output);
06680 }
06681
06682
06683 if (has_update_data()) {
06684 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06685 8, this->update_data(), output);
06686 }
06687
06688
06689 if (has_delete_header()) {
06690 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06691 9, this->delete_header(), output);
06692 }
06693
06694
06695 if (has_delete_data()) {
06696 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06697 10, this->delete_data(), output);
06698 }
06699
06700
06701 if (has_truncate_table_statement()) {
06702 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06703 11, this->truncate_table_statement(), output);
06704 }
06705
06706
06707 if (has_create_schema_statement()) {
06708 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06709 12, this->create_schema_statement(), output);
06710 }
06711
06712
06713 if (has_drop_schema_statement()) {
06714 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06715 13, this->drop_schema_statement(), output);
06716 }
06717
06718
06719 if (has_alter_schema_statement()) {
06720 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06721 14, this->alter_schema_statement(), output);
06722 }
06723
06724
06725 if (has_create_table_statement()) {
06726 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06727 15, this->create_table_statement(), output);
06728 }
06729
06730
06731 if (has_alter_table_statement()) {
06732 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06733 16, this->alter_table_statement(), output);
06734 }
06735
06736
06737 if (has_drop_table_statement()) {
06738 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06739 17, this->drop_table_statement(), output);
06740 }
06741
06742
06743 if (has_set_variable_statement()) {
06744 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
06745 18, this->set_variable_statement(), output);
06746 }
06747
06748
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
06766 if (has_type()) {
06767 target = ::google::protobuf::internal::WireFormatLite::WriteEnumToArray(
06768 1, this->type(), target);
06769 }
06770
06771
06772 if (has_start_timestamp()) {
06773 target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(2, this->start_timestamp(), target);
06774 }
06775
06776
06777 if (has_end_timestamp()) {
06778 target = ::google::protobuf::internal::WireFormatLite::WriteUInt64ToArray(3, this->end_timestamp(), target);
06779 }
06780
06781
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
06792 if (has_insert_header()) {
06793 target = ::google::protobuf::internal::WireFormatLite::
06794 WriteMessageNoVirtualToArray(
06795 5, this->insert_header(), target);
06796 }
06797
06798
06799 if (has_insert_data()) {
06800 target = ::google::protobuf::internal::WireFormatLite::
06801 WriteMessageNoVirtualToArray(
06802 6, this->insert_data(), target);
06803 }
06804
06805
06806 if (has_update_header()) {
06807 target = ::google::protobuf::internal::WireFormatLite::
06808 WriteMessageNoVirtualToArray(
06809 7, this->update_header(), target);
06810 }
06811
06812
06813 if (has_update_data()) {
06814 target = ::google::protobuf::internal::WireFormatLite::
06815 WriteMessageNoVirtualToArray(
06816 8, this->update_data(), target);
06817 }
06818
06819
06820 if (has_delete_header()) {
06821 target = ::google::protobuf::internal::WireFormatLite::
06822 WriteMessageNoVirtualToArray(
06823 9, this->delete_header(), target);
06824 }
06825
06826
06827 if (has_delete_data()) {
06828 target = ::google::protobuf::internal::WireFormatLite::
06829 WriteMessageNoVirtualToArray(
06830 10, this->delete_data(), target);
06831 }
06832
06833
06834 if (has_truncate_table_statement()) {
06835 target = ::google::protobuf::internal::WireFormatLite::
06836 WriteMessageNoVirtualToArray(
06837 11, this->truncate_table_statement(), target);
06838 }
06839
06840
06841 if (has_create_schema_statement()) {
06842 target = ::google::protobuf::internal::WireFormatLite::
06843 WriteMessageNoVirtualToArray(
06844 12, this->create_schema_statement(), target);
06845 }
06846
06847
06848 if (has_drop_schema_statement()) {
06849 target = ::google::protobuf::internal::WireFormatLite::
06850 WriteMessageNoVirtualToArray(
06851 13, this->drop_schema_statement(), target);
06852 }
06853
06854
06855 if (has_alter_schema_statement()) {
06856 target = ::google::protobuf::internal::WireFormatLite::
06857 WriteMessageNoVirtualToArray(
06858 14, this->alter_schema_statement(), target);
06859 }
06860
06861
06862 if (has_create_table_statement()) {
06863 target = ::google::protobuf::internal::WireFormatLite::
06864 WriteMessageNoVirtualToArray(
06865 15, this->create_table_statement(), target);
06866 }
06867
06868
06869 if (has_alter_table_statement()) {
06870 target = ::google::protobuf::internal::WireFormatLite::
06871 WriteMessageNoVirtualToArray(
06872 16, this->alter_table_statement(), target);
06873 }
06874
06875
06876 if (has_drop_table_statement()) {
06877 target = ::google::protobuf::internal::WireFormatLite::
06878 WriteMessageNoVirtualToArray(
06879 17, this->drop_table_statement(), target);
06880 }
06881
06882
06883 if (has_set_variable_statement()) {
06884 target = ::google::protobuf::internal::WireFormatLite::
06885 WriteMessageNoVirtualToArray(
06886 18, this->set_variable_statement(), target);
06887 }
06888
06889
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
06911 if (has_type()) {
06912 total_size += 1 +
06913 ::google::protobuf::internal::WireFormatLite::EnumSize(this->type());
06914 }
06915
06916
06917 if (has_start_timestamp()) {
06918 total_size += 1 +
06919 ::google::protobuf::internal::WireFormatLite::UInt64Size(
06920 this->start_timestamp());
06921 }
06922
06923
06924 if (has_end_timestamp()) {
06925 total_size += 1 +
06926 ::google::protobuf::internal::WireFormatLite::UInt64Size(
06927 this->end_timestamp());
06928 }
06929
06930
06931 if (has_sql()) {
06932 total_size += 1 +
06933 ::google::protobuf::internal::WireFormatLite::StringSize(
06934 this->sql());
06935 }
06936
06937
06938 if (has_insert_header()) {
06939 total_size += 1 +
06940 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06941 this->insert_header());
06942 }
06943
06944
06945 if (has_insert_data()) {
06946 total_size += 1 +
06947 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06948 this->insert_data());
06949 }
06950
06951
06952 if (has_update_header()) {
06953 total_size += 1 +
06954 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06955 this->update_header());
06956 }
06957
06958
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
06968 if (has_delete_header()) {
06969 total_size += 1 +
06970 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06971 this->delete_header());
06972 }
06973
06974
06975 if (has_delete_data()) {
06976 total_size += 1 +
06977 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06978 this->delete_data());
06979 }
06980
06981
06982 if (has_truncate_table_statement()) {
06983 total_size += 1 +
06984 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06985 this->truncate_table_statement());
06986 }
06987
06988
06989 if (has_create_schema_statement()) {
06990 total_size += 1 +
06991 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06992 this->create_schema_statement());
06993 }
06994
06995
06996 if (has_drop_schema_statement()) {
06997 total_size += 1 +
06998 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
06999 this->drop_schema_statement());
07000 }
07001
07002
07003 if (has_alter_schema_statement()) {
07004 total_size += 1 +
07005 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
07006 this->alter_schema_statement());
07007 }
07008
07009
07010 if (has_create_table_statement()) {
07011 total_size += 1 +
07012 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
07013 this->create_table_statement());
07014 }
07015
07016
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
07026 if (has_drop_table_statement()) {
07027 total_size += 2 +
07028 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
07029 this->drop_table_statement());
07030 }
07031
07032
07033 if (has_set_variable_statement()) {
07034 total_size += 2 +
07035 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
07036 this->set_variable_statement());
07037 }
07038
07039
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
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
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
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
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
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
07415 if (has_transaction_context()) {
07416 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
07417 1, this->transaction_context(), output);
07418 }
07419
07420
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
07427 if (has_event()) {
07428 ::google::protobuf::internal::WireFormatLite::WriteMessageMaybeToArray(
07429 3, this->event(), output);
07430 }
07431
07432
07433 if (has_segment_id()) {
07434 ::google::protobuf::internal::WireFormatLite::WriteUInt32(4, this->segment_id(), output);
07435 }
07436
07437
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
07451 if (has_transaction_context()) {
07452 target = ::google::protobuf::internal::WireFormatLite::
07453 WriteMessageNoVirtualToArray(
07454 1, this->transaction_context(), target);
07455 }
07456
07457
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
07465 if (has_event()) {
07466 target = ::google::protobuf::internal::WireFormatLite::
07467 WriteMessageNoVirtualToArray(
07468 3, this->event(), target);
07469 }
07470
07471
07472 if (has_segment_id()) {
07473 target = ::google::protobuf::internal::WireFormatLite::WriteUInt32ToArray(4, this->segment_id(), target);
07474 }
07475
07476
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
07493 if (has_transaction_context()) {
07494 total_size += 1 +
07495 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
07496 this->transaction_context());
07497 }
07498
07499
07500 if (has_event()) {
07501 total_size += 1 +
07502 ::google::protobuf::internal::WireFormatLite::MessageSizeNoVirtual(
07503 this->event());
07504 }
07505
07506
07507 if (has_segment_id()) {
07508 total_size += 1 +
07509 ::google::protobuf::internal::WireFormatLite::UInt32Size(
07510 this->segment_id());
07511 }
07512
07513
07514 if (has_end_segment()) {
07515 total_size += 1 + 1;
07516 }
07517
07518 }
07519
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
07620
07621 }
07622 }
07623
07624