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