http://git-wip-us.apache.org/repos/asf/hive/blob/7c22d74c/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp ---------------------------------------------------------------------- diff --git a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp index 1510d4f..32a7086 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -1240,14 +1240,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1111; - ::apache::thrift::protocol::TType _etype1114; - xfer += iprot->readListBegin(_etype1114, _size1111); - this->success.resize(_size1111); - uint32_t _i1115; - for (_i1115 = 0; _i1115 < _size1111; ++_i1115) + uint32_t _size1099; + ::apache::thrift::protocol::TType _etype1102; + xfer += iprot->readListBegin(_etype1102, _size1099); + this->success.resize(_size1099); + uint32_t _i1103; + for (_i1103 = 0; _i1103 < _size1099; ++_i1103) { - xfer += iprot->readString(this->success[_i1115]); + xfer += iprot->readString(this->success[_i1103]); } xfer += iprot->readListEnd(); } @@ -1286,10 +1286,10 @@ uint32_t ThriftHiveMetastore_get_databases_result::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter1116; - for (_iter1116 = this->success.begin(); _iter1116 != this->success.end(); ++_iter1116) + std::vector<std::string> ::const_iterator _iter1104; + for (_iter1104 = this->success.begin(); _iter1104 != this->success.end(); ++_iter1104) { - xfer += oprot->writeString((*_iter1116)); + xfer += oprot->writeString((*_iter1104)); } xfer += oprot->writeListEnd(); } @@ -1334,14 +1334,14 @@ uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1117; - ::apache::thrift::protocol::TType _etype1120; - xfer += iprot->readListBegin(_etype1120, _size1117); - (*(this->success)).resize(_size1117); - uint32_t _i1121; - for (_i1121 = 0; _i1121 < _size1117; ++_i1121) + uint32_t _size1105; + ::apache::thrift::protocol::TType _etype1108; + xfer += iprot->readListBegin(_etype1108, _size1105); + (*(this->success)).resize(_size1105); + uint32_t _i1109; + for (_i1109 = 0; _i1109 < _size1105; ++_i1109) { - xfer += iprot->readString((*(this->success))[_i1121]); + xfer += iprot->readString((*(this->success))[_i1109]); } xfer += iprot->readListEnd(); } @@ -1458,14 +1458,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1122; - ::apache::thrift::protocol::TType _etype1125; - xfer += iprot->readListBegin(_etype1125, _size1122); - this->success.resize(_size1122); - uint32_t _i1126; - for (_i1126 = 0; _i1126 < _size1122; ++_i1126) + uint32_t _size1110; + ::apache::thrift::protocol::TType _etype1113; + xfer += iprot->readListBegin(_etype1113, _size1110); + this->success.resize(_size1110); + uint32_t _i1114; + for (_i1114 = 0; _i1114 < _size1110; ++_i1114) { - xfer += iprot->readString(this->success[_i1126]); + xfer += iprot->readString(this->success[_i1114]); } xfer += iprot->readListEnd(); } @@ -1504,10 +1504,10 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter1127; - for (_iter1127 = this->success.begin(); _iter1127 != this->success.end(); ++_iter1127) + std::vector<std::string> ::const_iterator _iter1115; + for (_iter1115 = this->success.begin(); _iter1115 != this->success.end(); ++_iter1115) { - xfer += oprot->writeString((*_iter1127)); + xfer += oprot->writeString((*_iter1115)); } xfer += oprot->writeListEnd(); } @@ -1552,14 +1552,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1128; - ::apache::thrift::protocol::TType _etype1131; - xfer += iprot->readListBegin(_etype1131, _size1128); - (*(this->success)).resize(_size1128); - uint32_t _i1132; - for (_i1132 = 0; _i1132 < _size1128; ++_i1132) + uint32_t _size1116; + ::apache::thrift::protocol::TType _etype1119; + xfer += iprot->readListBegin(_etype1119, _size1116); + (*(this->success)).resize(_size1116); + uint32_t _i1120; + for (_i1120 = 0; _i1120 < _size1116; ++_i1120) { - xfer += iprot->readString((*(this->success))[_i1132]); + xfer += iprot->readString((*(this->success))[_i1120]); } xfer += iprot->readListEnd(); } @@ -2621,17 +2621,17 @@ uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1133; - ::apache::thrift::protocol::TType _ktype1134; - ::apache::thrift::protocol::TType _vtype1135; - xfer += iprot->readMapBegin(_ktype1134, _vtype1135, _size1133); - uint32_t _i1137; - for (_i1137 = 0; _i1137 < _size1133; ++_i1137) + uint32_t _size1121; + ::apache::thrift::protocol::TType _ktype1122; + ::apache::thrift::protocol::TType _vtype1123; + xfer += iprot->readMapBegin(_ktype1122, _vtype1123, _size1121); + uint32_t _i1125; + for (_i1125 = 0; _i1125 < _size1121; ++_i1125) { - std::string _key1138; - xfer += iprot->readString(_key1138); - Type& _val1139 = this->success[_key1138]; - xfer += _val1139.read(iprot); + std::string _key1126; + xfer += iprot->readString(_key1126); + Type& _val1127 = this->success[_key1126]; + xfer += _val1127.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2670,11 +2670,11 @@ uint32_t ThriftHiveMetastore_get_type_all_result::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::map<std::string, Type> ::const_iterator _iter1140; - for (_iter1140 = this->success.begin(); _iter1140 != this->success.end(); ++_iter1140) + std::map<std::string, Type> ::const_iterator _iter1128; + for (_iter1128 = this->success.begin(); _iter1128 != this->success.end(); ++_iter1128) { - xfer += oprot->writeString(_iter1140->first); - xfer += _iter1140->second.write(oprot); + xfer += oprot->writeString(_iter1128->first); + xfer += _iter1128->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -2719,17 +2719,17 @@ uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1141; - ::apache::thrift::protocol::TType _ktype1142; - ::apache::thrift::protocol::TType _vtype1143; - xfer += iprot->readMapBegin(_ktype1142, _vtype1143, _size1141); - uint32_t _i1145; - for (_i1145 = 0; _i1145 < _size1141; ++_i1145) + uint32_t _size1129; + ::apache::thrift::protocol::TType _ktype1130; + ::apache::thrift::protocol::TType _vtype1131; + xfer += iprot->readMapBegin(_ktype1130, _vtype1131, _size1129); + uint32_t _i1133; + for (_i1133 = 0; _i1133 < _size1129; ++_i1133) { - std::string _key1146; - xfer += iprot->readString(_key1146); - Type& _val1147 = (*(this->success))[_key1146]; - xfer += _val1147.read(iprot); + std::string _key1134; + xfer += iprot->readString(_key1134); + Type& _val1135 = (*(this->success))[_key1134]; + xfer += _val1135.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2883,14 +2883,14 @@ uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1148; - ::apache::thrift::protocol::TType _etype1151; - xfer += iprot->readListBegin(_etype1151, _size1148); - this->success.resize(_size1148); - uint32_t _i1152; - for (_i1152 = 0; _i1152 < _size1148; ++_i1152) + uint32_t _size1136; + ::apache::thrift::protocol::TType _etype1139; + xfer += iprot->readListBegin(_etype1139, _size1136); + this->success.resize(_size1136); + uint32_t _i1140; + for (_i1140 = 0; _i1140 < _size1136; ++_i1140) { - xfer += this->success[_i1152].read(iprot); + xfer += this->success[_i1140].read(iprot); } xfer += iprot->readListEnd(); } @@ -2945,10 +2945,10 @@ uint32_t ThriftHiveMetastore_get_fields_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter1153; - for (_iter1153 = this->success.begin(); _iter1153 != this->success.end(); ++_iter1153) + std::vector<FieldSchema> ::const_iterator _iter1141; + for (_iter1141 = this->success.begin(); _iter1141 != this->success.end(); ++_iter1141) { - xfer += (*_iter1153).write(oprot); + xfer += (*_iter1141).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3001,14 +3001,14 @@ uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1154; - ::apache::thrift::protocol::TType _etype1157; - xfer += iprot->readListBegin(_etype1157, _size1154); - (*(this->success)).resize(_size1154); - uint32_t _i1158; - for (_i1158 = 0; _i1158 < _size1154; ++_i1158) + uint32_t _size1142; + ::apache::thrift::protocol::TType _etype1145; + xfer += iprot->readListBegin(_etype1145, _size1142); + (*(this->success)).resize(_size1142); + uint32_t _i1146; + for (_i1146 = 0; _i1146 < _size1142; ++_i1146) { - xfer += (*(this->success))[_i1158].read(iprot); + xfer += (*(this->success))[_i1146].read(iprot); } xfer += iprot->readListEnd(); } @@ -3194,14 +3194,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1159; - ::apache::thrift::protocol::TType _etype1162; - xfer += iprot->readListBegin(_etype1162, _size1159); - this->success.resize(_size1159); - uint32_t _i1163; - for (_i1163 = 0; _i1163 < _size1159; ++_i1163) + uint32_t _size1147; + ::apache::thrift::protocol::TType _etype1150; + xfer += iprot->readListBegin(_etype1150, _size1147); + this->success.resize(_size1147); + uint32_t _i1151; + for (_i1151 = 0; _i1151 < _size1147; ++_i1151) { - xfer += this->success[_i1163].read(iprot); + xfer += this->success[_i1151].read(iprot); } xfer += iprot->readListEnd(); } @@ -3256,10 +3256,10 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter1164; - for (_iter1164 = this->success.begin(); _iter1164 != this->success.end(); ++_iter1164) + std::vector<FieldSchema> ::const_iterator _iter1152; + for (_iter1152 = this->success.begin(); _iter1152 != this->success.end(); ++_iter1152) { - xfer += (*_iter1164).write(oprot); + xfer += (*_iter1152).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3312,14 +3312,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1165; - ::apache::thrift::protocol::TType _etype1168; - xfer += iprot->readListBegin(_etype1168, _size1165); - (*(this->success)).resize(_size1165); - uint32_t _i1169; - for (_i1169 = 0; _i1169 < _size1165; ++_i1169) + uint32_t _size1153; + ::apache::thrift::protocol::TType _etype1156; + xfer += iprot->readListBegin(_etype1156, _size1153); + (*(this->success)).resize(_size1153); + uint32_t _i1157; + for (_i1157 = 0; _i1157 < _size1153; ++_i1157) { - xfer += (*(this->success))[_i1169].read(iprot); + xfer += (*(this->success))[_i1157].read(iprot); } xfer += iprot->readListEnd(); } @@ -3489,14 +3489,14 @@ uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1170; - ::apache::thrift::protocol::TType _etype1173; - xfer += iprot->readListBegin(_etype1173, _size1170); - this->success.resize(_size1170); - uint32_t _i1174; - for (_i1174 = 0; _i1174 < _size1170; ++_i1174) + uint32_t _size1158; + ::apache::thrift::protocol::TType _etype1161; + xfer += iprot->readListBegin(_etype1161, _size1158); + this->success.resize(_size1158); + uint32_t _i1162; + for (_i1162 = 0; _i1162 < _size1158; ++_i1162) { - xfer += this->success[_i1174].read(iprot); + xfer += this->success[_i1162].read(iprot); } xfer += iprot->readListEnd(); } @@ -3551,10 +3551,10 @@ uint32_t ThriftHiveMetastore_get_schema_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter1175; - for (_iter1175 = this->success.begin(); _iter1175 != this->success.end(); ++_iter1175) + std::vector<FieldSchema> ::const_iterator _iter1163; + for (_iter1163 = this->success.begin(); _iter1163 != this->success.end(); ++_iter1163) { - xfer += (*_iter1175).write(oprot); + xfer += (*_iter1163).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3607,14 +3607,14 @@ uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1176; - ::apache::thrift::protocol::TType _etype1179; - xfer += iprot->readListBegin(_etype1179, _size1176); - (*(this->success)).resize(_size1176); - uint32_t _i1180; - for (_i1180 = 0; _i1180 < _size1176; ++_i1180) + uint32_t _size1164; + ::apache::thrift::protocol::TType _etype1167; + xfer += iprot->readListBegin(_etype1167, _size1164); + (*(this->success)).resize(_size1164); + uint32_t _i1168; + for (_i1168 = 0; _i1168 < _size1164; ++_i1168) { - xfer += (*(this->success))[_i1180].read(iprot); + xfer += (*(this->success))[_i1168].read(iprot); } xfer += iprot->readListEnd(); } @@ -3800,14 +3800,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1181; - ::apache::thrift::protocol::TType _etype1184; - xfer += iprot->readListBegin(_etype1184, _size1181); - this->success.resize(_size1181); - uint32_t _i1185; - for (_i1185 = 0; _i1185 < _size1181; ++_i1185) + uint32_t _size1169; + ::apache::thrift::protocol::TType _etype1172; + xfer += iprot->readListBegin(_etype1172, _size1169); + this->success.resize(_size1169); + uint32_t _i1173; + for (_i1173 = 0; _i1173 < _size1169; ++_i1173) { - xfer += this->success[_i1185].read(iprot); + xfer += this->success[_i1173].read(iprot); } xfer += iprot->readListEnd(); } @@ -3862,10 +3862,10 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter1186; - for (_iter1186 = this->success.begin(); _iter1186 != this->success.end(); ++_iter1186) + std::vector<FieldSchema> ::const_iterator _iter1174; + for (_iter1174 = this->success.begin(); _iter1174 != this->success.end(); ++_iter1174) { - xfer += (*_iter1186).write(oprot); + xfer += (*_iter1174).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3918,14 +3918,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1187; - ::apache::thrift::protocol::TType _etype1190; - xfer += iprot->readListBegin(_etype1190, _size1187); - (*(this->success)).resize(_size1187); - uint32_t _i1191; - for (_i1191 = 0; _i1191 < _size1187; ++_i1191) + uint32_t _size1175; + ::apache::thrift::protocol::TType _etype1178; + xfer += iprot->readListBegin(_etype1178, _size1175); + (*(this->success)).resize(_size1175); + uint32_t _i1179; + for (_i1179 = 0; _i1179 < _size1175; ++_i1179) { - xfer += (*(this->success))[_i1191].read(iprot); + xfer += (*(this->success))[_i1179].read(iprot); } xfer += iprot->readListEnd(); } @@ -4518,14 +4518,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size1192; - ::apache::thrift::protocol::TType _etype1195; - xfer += iprot->readListBegin(_etype1195, _size1192); - this->primaryKeys.resize(_size1192); - uint32_t _i1196; - for (_i1196 = 0; _i1196 < _size1192; ++_i1196) + uint32_t _size1180; + ::apache::thrift::protocol::TType _etype1183; + xfer += iprot->readListBegin(_etype1183, _size1180); + this->primaryKeys.resize(_size1180); + uint32_t _i1184; + for (_i1184 = 0; _i1184 < _size1180; ++_i1184) { - xfer += this->primaryKeys[_i1196].read(iprot); + xfer += this->primaryKeys[_i1184].read(iprot); } xfer += iprot->readListEnd(); } @@ -4538,14 +4538,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size1197; - ::apache::thrift::protocol::TType _etype1200; - xfer += iprot->readListBegin(_etype1200, _size1197); - this->foreignKeys.resize(_size1197); - uint32_t _i1201; - for (_i1201 = 0; _i1201 < _size1197; ++_i1201) + uint32_t _size1185; + ::apache::thrift::protocol::TType _etype1188; + xfer += iprot->readListBegin(_etype1188, _size1185); + this->foreignKeys.resize(_size1185); + uint32_t _i1189; + for (_i1189 = 0; _i1189 < _size1185; ++_i1189) { - xfer += this->foreignKeys[_i1201].read(iprot); + xfer += this->foreignKeys[_i1189].read(iprot); } xfer += iprot->readListEnd(); } @@ -4558,14 +4558,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size1202; - ::apache::thrift::protocol::TType _etype1205; - xfer += iprot->readListBegin(_etype1205, _size1202); - this->uniqueConstraints.resize(_size1202); - uint32_t _i1206; - for (_i1206 = 0; _i1206 < _size1202; ++_i1206) + uint32_t _size1190; + ::apache::thrift::protocol::TType _etype1193; + xfer += iprot->readListBegin(_etype1193, _size1190); + this->uniqueConstraints.resize(_size1190); + uint32_t _i1194; + for (_i1194 = 0; _i1194 < _size1190; ++_i1194) { - xfer += this->uniqueConstraints[_i1206].read(iprot); + xfer += this->uniqueConstraints[_i1194].read(iprot); } xfer += iprot->readListEnd(); } @@ -4578,14 +4578,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size1207; - ::apache::thrift::protocol::TType _etype1210; - xfer += iprot->readListBegin(_etype1210, _size1207); - this->notNullConstraints.resize(_size1207); - uint32_t _i1211; - for (_i1211 = 0; _i1211 < _size1207; ++_i1211) + uint32_t _size1195; + ::apache::thrift::protocol::TType _etype1198; + xfer += iprot->readListBegin(_etype1198, _size1195); + this->notNullConstraints.resize(_size1195); + uint32_t _i1199; + for (_i1199 = 0; _i1199 < _size1195; ++_i1199) { - xfer += this->notNullConstraints[_i1211].read(iprot); + xfer += this->notNullConstraints[_i1199].read(iprot); } xfer += iprot->readListEnd(); } @@ -4598,14 +4598,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->defaultConstraints.clear(); - uint32_t _size1212; - ::apache::thrift::protocol::TType _etype1215; - xfer += iprot->readListBegin(_etype1215, _size1212); - this->defaultConstraints.resize(_size1212); - uint32_t _i1216; - for (_i1216 = 0; _i1216 < _size1212; ++_i1216) + uint32_t _size1200; + ::apache::thrift::protocol::TType _etype1203; + xfer += iprot->readListBegin(_etype1203, _size1200); + this->defaultConstraints.resize(_size1200); + uint32_t _i1204; + for (_i1204 = 0; _i1204 < _size1200; ++_i1204) { - xfer += this->defaultConstraints[_i1216].read(iprot); + xfer += this->defaultConstraints[_i1204].read(iprot); } xfer += iprot->readListEnd(); } @@ -4638,10 +4638,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->primaryKeys.size())); - std::vector<SQLPrimaryKey> ::const_iterator _iter1217; - for (_iter1217 = this->primaryKeys.begin(); _iter1217 != this->primaryKeys.end(); ++_iter1217) + std::vector<SQLPrimaryKey> ::const_iterator _iter1205; + for (_iter1205 = this->primaryKeys.begin(); _iter1205 != this->primaryKeys.end(); ++_iter1205) { - xfer += (*_iter1217).write(oprot); + xfer += (*_iter1205).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4650,10 +4650,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->foreignKeys.size())); - std::vector<SQLForeignKey> ::const_iterator _iter1218; - for (_iter1218 = this->foreignKeys.begin(); _iter1218 != this->foreignKeys.end(); ++_iter1218) + std::vector<SQLForeignKey> ::const_iterator _iter1206; + for (_iter1206 = this->foreignKeys.begin(); _iter1206 != this->foreignKeys.end(); ++_iter1206) { - xfer += (*_iter1218).write(oprot); + xfer += (*_iter1206).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4662,10 +4662,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->uniqueConstraints.size())); - std::vector<SQLUniqueConstraint> ::const_iterator _iter1219; - for (_iter1219 = this->uniqueConstraints.begin(); _iter1219 != this->uniqueConstraints.end(); ++_iter1219) + std::vector<SQLUniqueConstraint> ::const_iterator _iter1207; + for (_iter1207 = this->uniqueConstraints.begin(); _iter1207 != this->uniqueConstraints.end(); ++_iter1207) { - xfer += (*_iter1219).write(oprot); + xfer += (*_iter1207).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4674,10 +4674,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->notNullConstraints.size())); - std::vector<SQLNotNullConstraint> ::const_iterator _iter1220; - for (_iter1220 = this->notNullConstraints.begin(); _iter1220 != this->notNullConstraints.end(); ++_iter1220) + std::vector<SQLNotNullConstraint> ::const_iterator _iter1208; + for (_iter1208 = this->notNullConstraints.begin(); _iter1208 != this->notNullConstraints.end(); ++_iter1208) { - xfer += (*_iter1220).write(oprot); + xfer += (*_iter1208).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4686,10 +4686,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->defaultConstraints.size())); - std::vector<SQLDefaultConstraint> ::const_iterator _iter1221; - for (_iter1221 = this->defaultConstraints.begin(); _iter1221 != this->defaultConstraints.end(); ++_iter1221) + std::vector<SQLDefaultConstraint> ::const_iterator _iter1209; + for (_iter1209 = this->defaultConstraints.begin(); _iter1209 != this->defaultConstraints.end(); ++_iter1209) { - xfer += (*_iter1221).write(oprot); + xfer += (*_iter1209).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4717,10 +4717,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->primaryKeys)).size())); - std::vector<SQLPrimaryKey> ::const_iterator _iter1222; - for (_iter1222 = (*(this->primaryKeys)).begin(); _iter1222 != (*(this->primaryKeys)).end(); ++_iter1222) + std::vector<SQLPrimaryKey> ::const_iterator _iter1210; + for (_iter1210 = (*(this->primaryKeys)).begin(); _iter1210 != (*(this->primaryKeys)).end(); ++_iter1210) { - xfer += (*_iter1222).write(oprot); + xfer += (*_iter1210).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4729,10 +4729,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->foreignKeys)).size())); - std::vector<SQLForeignKey> ::const_iterator _iter1223; - for (_iter1223 = (*(this->foreignKeys)).begin(); _iter1223 != (*(this->foreignKeys)).end(); ++_iter1223) + std::vector<SQLForeignKey> ::const_iterator _iter1211; + for (_iter1211 = (*(this->foreignKeys)).begin(); _iter1211 != (*(this->foreignKeys)).end(); ++_iter1211) { - xfer += (*_iter1223).write(oprot); + xfer += (*_iter1211).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4741,10 +4741,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("uniqueConstraints", ::apache::thrift::protocol::T_LIST, 4); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->uniqueConstraints)).size())); - std::vector<SQLUniqueConstraint> ::const_iterator _iter1224; - for (_iter1224 = (*(this->uniqueConstraints)).begin(); _iter1224 != (*(this->uniqueConstraints)).end(); ++_iter1224) + std::vector<SQLUniqueConstraint> ::const_iterator _iter1212; + for (_iter1212 = (*(this->uniqueConstraints)).begin(); _iter1212 != (*(this->uniqueConstraints)).end(); ++_iter1212) { - xfer += (*_iter1224).write(oprot); + xfer += (*_iter1212).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4753,10 +4753,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("notNullConstraints", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->notNullConstraints)).size())); - std::vector<SQLNotNullConstraint> ::const_iterator _iter1225; - for (_iter1225 = (*(this->notNullConstraints)).begin(); _iter1225 != (*(this->notNullConstraints)).end(); ++_iter1225) + std::vector<SQLNotNullConstraint> ::const_iterator _iter1213; + for (_iter1213 = (*(this->notNullConstraints)).begin(); _iter1213 != (*(this->notNullConstraints)).end(); ++_iter1213) { - xfer += (*_iter1225).write(oprot); + xfer += (*_iter1213).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4765,10 +4765,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 6); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->defaultConstraints)).size())); - std::vector<SQLDefaultConstraint> ::const_iterator _iter1226; - for (_iter1226 = (*(this->defaultConstraints)).begin(); _iter1226 != (*(this->defaultConstraints)).end(); ++_iter1226) + std::vector<SQLDefaultConstraint> ::const_iterator _iter1214; + for (_iter1214 = (*(this->defaultConstraints)).begin(); _iter1214 != (*(this->defaultConstraints)).end(); ++_iter1214) { - xfer += (*_iter1226).write(oprot); + xfer += (*_iter1214).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6729,14 +6729,14 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size1227; - ::apache::thrift::protocol::TType _etype1230; - xfer += iprot->readListBegin(_etype1230, _size1227); - this->partNames.resize(_size1227); - uint32_t _i1231; - for (_i1231 = 0; _i1231 < _size1227; ++_i1231) + uint32_t _size1215; + ::apache::thrift::protocol::TType _etype1218; + xfer += iprot->readListBegin(_etype1218, _size1215); + this->partNames.resize(_size1215); + uint32_t _i1219; + for (_i1219 = 0; _i1219 < _size1215; ++_i1219) { - xfer += iprot->readString(this->partNames[_i1231]); + xfer += iprot->readString(this->partNames[_i1219]); } xfer += iprot->readListEnd(); } @@ -6773,10 +6773,10 @@ uint32_t ThriftHiveMetastore_truncate_table_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partNames.size())); - std::vector<std::string> ::const_iterator _iter1232; - for (_iter1232 = this->partNames.begin(); _iter1232 != this->partNames.end(); ++_iter1232) + std::vector<std::string> ::const_iterator _iter1220; + for (_iter1220 = this->partNames.begin(); _iter1220 != this->partNames.end(); ++_iter1220) { - xfer += oprot->writeString((*_iter1232)); + xfer += oprot->writeString((*_iter1220)); } xfer += oprot->writeListEnd(); } @@ -6808,10 +6808,10 @@ uint32_t ThriftHiveMetastore_truncate_table_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("partNames", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->partNames)).size())); - std::vector<std::string> ::const_iterator _iter1233; - for (_iter1233 = (*(this->partNames)).begin(); _iter1233 != (*(this->partNames)).end(); ++_iter1233) + std::vector<std::string> ::const_iterator _iter1221; + for (_iter1221 = (*(this->partNames)).begin(); _iter1221 != (*(this->partNames)).end(); ++_iter1221) { - xfer += oprot->writeString((*_iter1233)); + xfer += oprot->writeString((*_iter1221)); } xfer += oprot->writeListEnd(); } @@ -7055,14 +7055,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1234; - ::apache::thrift::protocol::TType _etype1237; - xfer += iprot->readListBegin(_etype1237, _size1234); - this->success.resize(_size1234); - uint32_t _i1238; - for (_i1238 = 0; _i1238 < _size1234; ++_i1238) + uint32_t _size1222; + ::apache::thrift::protocol::TType _etype1225; + xfer += iprot->readListBegin(_etype1225, _size1222); + this->success.resize(_size1222); + uint32_t _i1226; + for (_i1226 = 0; _i1226 < _size1222; ++_i1226) { - xfer += iprot->readString(this->success[_i1238]); + xfer += iprot->readString(this->success[_i1226]); } xfer += iprot->readListEnd(); } @@ -7101,10 +7101,10 @@ uint32_t ThriftHiveMetastore_get_tables_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter1239; - for (_iter1239 = this->success.begin(); _iter1239 != this->success.end(); ++_iter1239) + std::vector<std::string> ::const_iterator _iter1227; + for (_iter1227 = this->success.begin(); _iter1227 != this->success.end(); ++_iter1227) { - xfer += oprot->writeString((*_iter1239)); + xfer += oprot->writeString((*_iter1227)); } xfer += oprot->writeListEnd(); } @@ -7149,14 +7149,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1240; - ::apache::thrift::protocol::TType _etype1243; - xfer += iprot->readListBegin(_etype1243, _size1240); - (*(this->success)).resize(_size1240); - uint32_t _i1244; - for (_i1244 = 0; _i1244 < _size1240; ++_i1244) + uint32_t _size1228; + ::apache::thrift::protocol::TType _etype1231; + xfer += iprot->readListBegin(_etype1231, _size1228); + (*(this->success)).resize(_size1228); + uint32_t _i1232; + for (_i1232 = 0; _i1232 < _size1228; ++_i1232) { - xfer += iprot->readString((*(this->success))[_i1244]); + xfer += iprot->readString((*(this->success))[_i1232]); } xfer += iprot->readListEnd(); } @@ -7326,14 +7326,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1245; - ::apache::thrift::protocol::TType _etype1248; - xfer += iprot->readListBegin(_etype1248, _size1245); - this->success.resize(_size1245); - uint32_t _i1249; - for (_i1249 = 0; _i1249 < _size1245; ++_i1249) + uint32_t _size1233; + ::apache::thrift::protocol::TType _etype1236; + xfer += iprot->readListBegin(_etype1236, _size1233); + this->success.resize(_size1233); + uint32_t _i1237; + for (_i1237 = 0; _i1237 < _size1233; ++_i1237) { - xfer += iprot->readString(this->success[_i1249]); + xfer += iprot->readString(this->success[_i1237]); } xfer += iprot->readListEnd(); } @@ -7372,10 +7372,10 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift:: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter1250; - for (_iter1250 = this->success.begin(); _iter1250 != this->success.end(); ++_iter1250) + std::vector<std::string> ::const_iterator _iter1238; + for (_iter1238 = this->success.begin(); _iter1238 != this->success.end(); ++_iter1238) { - xfer += oprot->writeString((*_iter1250)); + xfer += oprot->writeString((*_iter1238)); } xfer += oprot->writeListEnd(); } @@ -7420,14 +7420,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1251; - ::apache::thrift::protocol::TType _etype1254; - xfer += iprot->readListBegin(_etype1254, _size1251); - (*(this->success)).resize(_size1251); - uint32_t _i1255; - for (_i1255 = 0; _i1255 < _size1251; ++_i1255) + uint32_t _size1239; + ::apache::thrift::protocol::TType _etype1242; + xfer += iprot->readListBegin(_etype1242, _size1239); + (*(this->success)).resize(_size1239); + uint32_t _i1243; + for (_i1243 = 0; _i1243 < _size1239; ++_i1243) { - xfer += iprot->readString((*(this->success))[_i1255]); + xfer += iprot->readString((*(this->success))[_i1243]); } xfer += iprot->readListEnd(); } @@ -7565,14 +7565,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1256; - ::apache::thrift::protocol::TType _etype1259; - xfer += iprot->readListBegin(_etype1259, _size1256); - this->success.resize(_size1256); - uint32_t _i1260; - for (_i1260 = 0; _i1260 < _size1256; ++_i1260) + uint32_t _size1244; + ::apache::thrift::protocol::TType _etype1247; + xfer += iprot->readListBegin(_etype1247, _size1244); + this->success.resize(_size1244); + uint32_t _i1248; + for (_i1248 = 0; _i1248 < _size1244; ++_i1248) { - xfer += iprot->readString(this->success[_i1260]); + xfer += iprot->readString(this->success[_i1248]); } xfer += iprot->readListEnd(); } @@ -7611,10 +7611,10 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::write( xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter1261; - for (_iter1261 = this->success.begin(); _iter1261 != this->success.end(); ++_iter1261) + std::vector<std::string> ::const_iterator _iter1249; + for (_iter1249 = this->success.begin(); _iter1249 != this->success.end(); ++_iter1249) { - xfer += oprot->writeString((*_iter1261)); + xfer += oprot->writeString((*_iter1249)); } xfer += oprot->writeListEnd(); } @@ -7659,14 +7659,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_presult::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1262; - ::apache::thrift::protocol::TType _etype1265; - xfer += iprot->readListBegin(_etype1265, _size1262); - (*(this->success)).resize(_size1262); - uint32_t _i1266; - for (_i1266 = 0; _i1266 < _size1262; ++_i1266) + uint32_t _size1250; + ::apache::thrift::protocol::TType _etype1253; + xfer += iprot->readListBegin(_etype1253, _size1250); + (*(this->success)).resize(_size1250); + uint32_t _i1254; + for (_i1254 = 0; _i1254 < _size1250; ++_i1254) { - xfer += iprot->readString((*(this->success))[_i1266]); + xfer += iprot->readString((*(this->success))[_i1254]); } xfer += iprot->readListEnd(); } @@ -7741,14 +7741,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_types.clear(); - uint32_t _size1267; - ::apache::thrift::protocol::TType _etype1270; - xfer += iprot->readListBegin(_etype1270, _size1267); - this->tbl_types.resize(_size1267); - uint32_t _i1271; - for (_i1271 = 0; _i1271 < _size1267; ++_i1271) + uint32_t _size1255; + ::apache::thrift::protocol::TType _etype1258; + xfer += iprot->readListBegin(_etype1258, _size1255); + this->tbl_types.resize(_size1255); + uint32_t _i1259; + for (_i1259 = 0; _i1259 < _size1255; ++_i1259) { - xfer += iprot->readString(this->tbl_types[_i1271]); + xfer += iprot->readString(this->tbl_types[_i1259]); } xfer += iprot->readListEnd(); } @@ -7785,10 +7785,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tbl_types.size())); - std::vector<std::string> ::const_iterator _iter1272; - for (_iter1272 = this->tbl_types.begin(); _iter1272 != this->tbl_types.end(); ++_iter1272) + std::vector<std::string> ::const_iterator _iter1260; + for (_iter1260 = this->tbl_types.begin(); _iter1260 != this->tbl_types.end(); ++_iter1260) { - xfer += oprot->writeString((*_iter1272)); + xfer += oprot->writeString((*_iter1260)); } xfer += oprot->writeListEnd(); } @@ -7820,10 +7820,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->tbl_types)).size())); - std::vector<std::string> ::const_iterator _iter1273; - for (_iter1273 = (*(this->tbl_types)).begin(); _iter1273 != (*(this->tbl_types)).end(); ++_iter1273) + std::vector<std::string> ::const_iterator _iter1261; + for (_iter1261 = (*(this->tbl_types)).begin(); _iter1261 != (*(this->tbl_types)).end(); ++_iter1261) { - xfer += oprot->writeString((*_iter1273)); + xfer += oprot->writeString((*_iter1261)); } xfer += oprot->writeListEnd(); } @@ -7864,14 +7864,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1274; - ::apache::thrift::protocol::TType _etype1277; - xfer += iprot->readListBegin(_etype1277, _size1274); - this->success.resize(_size1274); - uint32_t _i1278; - for (_i1278 = 0; _i1278 < _size1274; ++_i1278) + uint32_t _size1262; + ::apache::thrift::protocol::TType _etype1265; + xfer += iprot->readListBegin(_etype1265, _size1262); + this->success.resize(_size1262); + uint32_t _i1266; + for (_i1266 = 0; _i1266 < _size1262; ++_i1266) { - xfer += this->success[_i1278].read(iprot); + xfer += this->success[_i1266].read(iprot); } xfer += iprot->readListEnd(); } @@ -7910,10 +7910,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<TableMeta> ::const_iterator _iter1279; - for (_iter1279 = this->success.begin(); _iter1279 != this->success.end(); ++_iter1279) + std::vector<TableMeta> ::const_iterator _iter1267; + for (_iter1267 = this->success.begin(); _iter1267 != this->success.end(); ++_iter1267) { - xfer += (*_iter1279).write(oprot); + xfer += (*_iter1267).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7958,14 +7958,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1280; - ::apache::thrift::protocol::TType _etype1283; - xfer += iprot->readListBegin(_etype1283, _size1280); - (*(this->success)).resize(_size1280); - uint32_t _i1284; - for (_i1284 = 0; _i1284 < _size1280; ++_i1284) + uint32_t _size1268; + ::apache::thrift::protocol::TType _etype1271; + xfer += iprot->readListBegin(_etype1271, _size1268); + (*(this->success)).resize(_size1268); + uint32_t _i1272; + for (_i1272 = 0; _i1272 < _size1268; ++_i1272) { - xfer += (*(this->success))[_i1284].read(iprot); + xfer += (*(this->success))[_i1272].read(iprot); } xfer += iprot->readListEnd(); } @@ -8103,14 +8103,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1285; - ::apache::thrift::protocol::TType _etype1288; - xfer += iprot->readListBegin(_etype1288, _size1285); - this->success.resize(_size1285); - uint32_t _i1289; - for (_i1289 = 0; _i1289 < _size1285; ++_i1289) + uint32_t _size1273; + ::apache::thrift::protocol::TType _etype1276; + xfer += iprot->readListBegin(_etype1276, _size1273); + this->success.resize(_size1273); + uint32_t _i1277; + for (_i1277 = 0; _i1277 < _size1273; ++_i1277) { - xfer += iprot->readString(this->success[_i1289]); + xfer += iprot->readString(this->success[_i1277]); } xfer += iprot->readListEnd(); } @@ -8149,10 +8149,10 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter1290; - for (_iter1290 = this->success.begin(); _iter1290 != this->success.end(); ++_iter1290) + std::vector<std::string> ::const_iterator _iter1278; + for (_iter1278 = this->success.begin(); _iter1278 != this->success.end(); ++_iter1278) { - xfer += oprot->writeString((*_iter1290)); + xfer += oprot->writeString((*_iter1278)); } xfer += oprot->writeListEnd(); } @@ -8197,14 +8197,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1291; - ::apache::thrift::protocol::TType _etype1294; - xfer += iprot->readListBegin(_etype1294, _size1291); - (*(this->success)).resize(_size1291); - uint32_t _i1295; - for (_i1295 = 0; _i1295 < _size1291; ++_i1295) + uint32_t _size1279; + ::apache::thrift::protocol::TType _etype1282; + xfer += iprot->readListBegin(_etype1282, _size1279); + (*(this->success)).resize(_size1279); + uint32_t _i1283; + for (_i1283 = 0; _i1283 < _size1279; ++_i1283) { - xfer += iprot->readString((*(this->success))[_i1295]); + xfer += iprot->readString((*(this->success))[_i1283]); } xfer += iprot->readListEnd(); } @@ -8514,14 +8514,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::read(::apache::thri if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size1296; - ::apache::thrift::protocol::TType _etype1299; - xfer += iprot->readListBegin(_etype1299, _size1296); - this->tbl_names.resize(_size1296); - uint32_t _i1300; - for (_i1300 = 0; _i1300 < _size1296; ++_i1300) + uint32_t _size1284; + ::apache::thrift::protocol::TType _etype1287; + xfer += iprot->readListBegin(_etype1287, _size1284); + this->tbl_names.resize(_size1284); + uint32_t _i1288; + for (_i1288 = 0; _i1288 < _size1284; ++_i1288) { - xfer += iprot->readString(this->tbl_names[_i1300]); + xfer += iprot->readString(this->tbl_names[_i1288]); } xfer += iprot->readListEnd(); } @@ -8554,10 +8554,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::write(::apache::thr xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tbl_names.size())); - std::vector<std::string> ::const_iterator _iter1301; - for (_iter1301 = this->tbl_names.begin(); _iter1301 != this->tbl_names.end(); ++_iter1301) + std::vector<std::string> ::const_iterator _iter1289; + for (_iter1289 = this->tbl_names.begin(); _iter1289 != this->tbl_names.end(); ++_iter1289) { - xfer += oprot->writeString((*_iter1301)); + xfer += oprot->writeString((*_iter1289)); } xfer += oprot->writeListEnd(); } @@ -8585,10 +8585,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_pargs::write(::apache::th xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->tbl_names)).size())); - std::vector<std::string> ::const_iterator _iter1302; - for (_iter1302 = (*(this->tbl_names)).begin(); _iter1302 != (*(this->tbl_names)).end(); ++_iter1302) + std::vector<std::string> ::const_iterator _iter1290; + for (_iter1290 = (*(this->tbl_names)).begin(); _iter1290 != (*(this->tbl_names)).end(); ++_iter1290) { - xfer += oprot->writeString((*_iter1302)); + xfer += oprot->writeString((*_iter1290)); } xfer += oprot->writeListEnd(); } @@ -8629,14 +8629,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1303; - ::apache::thrift::protocol::TType _etype1306; - xfer += iprot->readListBegin(_etype1306, _size1303); - this->success.resize(_size1303); - uint32_t _i1307; - for (_i1307 = 0; _i1307 < _size1303; ++_i1307) + uint32_t _size1291; + ::apache::thrift::protocol::TType _etype1294; + xfer += iprot->readListBegin(_etype1294, _size1291); + this->success.resize(_size1291); + uint32_t _i1295; + for (_i1295 = 0; _i1295 < _size1291; ++_i1295) { - xfer += this->success[_i1307].read(iprot); + xfer += this->success[_i1295].read(iprot); } xfer += iprot->readListEnd(); } @@ -8667,10 +8667,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<Table> ::const_iterator _iter1308; - for (_iter1308 = this->success.begin(); _iter1308 != this->success.end(); ++_iter1308) + std::vector<Table> ::const_iterator _iter1296; + for (_iter1296 = this->success.begin(); _iter1296 != this->success.end(); ++_iter1296) { - xfer += (*_iter1308).write(oprot); + xfer += (*_iter1296).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8711,14 +8711,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1309; - ::apache::thrift::protocol::TType _etype1312; - xfer += iprot->readListBegin(_etype1312, _size1309); - (*(this->success)).resize(_size1309); - uint32_t _i1313; - for (_i1313 = 0; _i1313 < _size1309; ++_i1313) + uint32_t _size1297; + ::apache::thrift::protocol::TType _etype1300; + xfer += iprot->readListBegin(_etype1300, _size1297); + (*(this->success)).resize(_size1297); + uint32_t _i1301; + for (_i1301 = 0; _i1301 < _size1297; ++_i1301) { - xfer += (*(this->success))[_i1313].read(iprot); + xfer += (*(this->success))[_i1301].read(iprot); } xfer += iprot->readListEnd(); } @@ -9251,14 +9251,14 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_args::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size1314; - ::apache::thrift::protocol::TType _etype1317; - xfer += iprot->readListBegin(_etype1317, _size1314); - this->tbl_names.resize(_size1314); - uint32_t _i1318; - for (_i1318 = 0; _i1318 < _size1314; ++_i1318) + uint32_t _size1302; + ::apache::thrift::protocol::TType _etype1305; + xfer += iprot->readListBegin(_etype1305, _size1302); + this->tbl_names.resize(_size1302); + uint32_t _i1306; + for (_i1306 = 0; _i1306 < _size1302; ++_i1306) { - xfer += iprot->readString(this->tbl_names[_i1318]); + xfer += iprot->readString(this->tbl_names[_i1306]); } xfer += iprot->readListEnd(); } @@ -9291,10 +9291,10 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_args::write(: xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tbl_names.size())); - std::vector<std::string> ::const_iterator _iter1319; - for (_iter1319 = this->tbl_names.begin(); _iter1319 != this->tbl_names.end(); ++_iter1319) + std::vector<std::string> ::const_iterator _iter1307; + for (_iter1307 = this->tbl_names.begin(); _iter1307 != this->tbl_names.end(); ++_iter1307) { - xfer += oprot->writeString((*_iter1319)); + xfer += oprot->writeString((*_iter1307)); } xfer += oprot->writeListEnd(); } @@ -9322,10 +9322,10 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_pargs::write( xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->tbl_names)).size())); - std::vector<std::string> ::const_iterator _iter1320; - for (_iter1320 = (*(this->tbl_names)).begin(); _iter1320 != (*(this->tbl_names)).end(); ++_iter1320) + std::vector<std::string> ::const_iterator _iter1308; + for (_iter1308 = (*(this->tbl_names)).begin(); _iter1308 != (*(this->tbl_names)).end(); ++_iter1308) { - xfer += oprot->writeString((*_iter1320)); + xfer += oprot->writeString((*_iter1308)); } xfer += oprot->writeListEnd(); } @@ -9366,17 +9366,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_result::read( if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1321; - ::apache::thrift::protocol::TType _ktype1322; - ::apache::thrift::protocol::TType _vtype1323; - xfer += iprot->readMapBegin(_ktype1322, _vtype1323, _size1321); - uint32_t _i1325; - for (_i1325 = 0; _i1325 < _size1321; ++_i1325) + uint32_t _size1309; + ::apache::thrift::protocol::TType _ktype1310; + ::apache::thrift::protocol::TType _vtype1311; + xfer += iprot->readMapBegin(_ktype1310, _vtype1311, _size1309); + uint32_t _i1313; + for (_i1313 = 0; _i1313 < _size1309; ++_i1313) { - std::string _key1326; - xfer += iprot->readString(_key1326); - Materialization& _val1327 = this->success[_key1326]; - xfer += _val1327.read(iprot); + std::string _key1314; + xfer += iprot->readString(_key1314); + Materialization& _val1315 = this->success[_key1314]; + xfer += _val1315.read(iprot); } xfer += iprot->readMapEnd(); } @@ -9431,11 +9431,11 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_result::write xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::map<std::string, Materialization> ::const_iterator _iter1328; - for (_iter1328 = this->success.begin(); _iter1328 != this->success.end(); ++_iter1328) + std::map<std::string, Materialization> ::const_iterator _iter1316; + for (_iter1316 = this->success.begin(); _iter1316 != this->success.end(); ++_iter1316) { - xfer += oprot->writeString(_iter1328->first); - xfer += _iter1328->second.write(oprot); + xfer += oprot->writeString(_iter1316->first); + xfer += _iter1316->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -9488,17 +9488,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_presult::read if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1329; - ::apache::thrift::protocol::TType _ktype1330; - ::apache::thrift::protocol::TType _vtype1331; - xfer += iprot->readMapBegin(_ktype1330, _vtype1331, _size1329); - uint32_t _i1333; - for (_i1333 = 0; _i1333 < _size1329; ++_i1333) + uint32_t _size1317; + ::apache::thrift::protocol::TType _ktype1318; + ::apache::thrift::protocol::TType _vtype1319; + xfer += iprot->readMapBegin(_ktype1318, _vtype1319, _size1317); + uint32_t _i1321; + for (_i1321 = 0; _i1321 < _size1317; ++_i1321) { - std::string _key1334; - xfer += iprot->readString(_key1334); - Materialization& _val1335 = (*(this->success))[_key1334]; - xfer += _val1335.read(iprot); + std::string _key1322; + xfer += iprot->readString(_key1322); + Materialization& _val1323 = (*(this->success))[_key1322]; + xfer += _val1323.read(iprot); } xfer += iprot->readMapEnd(); } @@ -9943,14 +9943,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::read(::apache::th if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1336; - ::apache::thrift::protocol::TType _etype1339; - xfer += iprot->readListBegin(_etype1339, _size1336); - this->success.resize(_size1336); - uint32_t _i1340; - for (_i1340 = 0; _i1340 < _size1336; ++_i1340) + uint32_t _size1324; + ::apache::thrift::protocol::TType _etype1327; + xfer += iprot->readListBegin(_etype1327, _size1324); + this->success.resize(_size1324); + uint32_t _i1328; + for (_i1328 = 0; _i1328 < _size1324; ++_i1328) { - xfer += iprot->readString(this->success[_i1340]); + xfer += iprot->readString(this->success[_i1328]); } xfer += iprot->readListEnd(); } @@ -10005,10 +10005,10 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::write(::apache::t xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter1341; - for (_iter1341 = this->success.begin(); _iter1341 != this->success.end(); ++_iter1341) + std::vector<std::string> ::const_iterator _iter1329; + for (_iter1329 = this->success.begin(); _iter1329 != this->success.end(); ++_iter1329) { - xfer += oprot->writeString((*_iter1341)); + xfer += oprot->writeString((*_iter1329)); } xfer += oprot->writeListEnd(); } @@ -10061,14 +10061,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_presult::read(::apache::t if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1342; - ::apache::thrift::protocol::TType _etype1345; - xfer += iprot->readListBegin(_etype1345, _size1342); - (*(this->success)).resize(_size1342); - uint32_t _i1346; - for (_i1346 = 0; _i1346 < _size1342; ++_i1346) + uint32_t _size1330; + ::apache::thrift::protocol::TType _etype1333; + xfer += iprot->readListBegin(_etype1333, _size1330); + (*(this->success)).resize(_size1330); + uint32_t _i1334; + for (_i1334 = 0; _i1334 < _size1330; ++_i1334) { - xfer += iprot->readString((*(this->success))[_i1346]); + xfer += iprot->readString((*(this->success))[_i1334]); } xfer += iprot->readListEnd(); } @@ -11402,14 +11402,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1347; - ::apache::thrift::protocol::TType _etype1350; - xfer += iprot->readListBegin(_etype1350, _size1347); - this->new_parts.resize(_size1347); - uint32_t _i1351; - for (_i1351 = 0; _i1351 < _size1347; ++_i1351) + uint32_t _size1335; + ::apache::thrift::protocol::TType _etype1338; + xfer += iprot->readListBegin(_etype1338, _size1335); + this->new_parts.resize(_size1335); + uint32_t _i1339; + for (_i1339 = 0; _i1339 < _size1335; ++_i1339) { - xfer += this->new_parts[_i1351].read(iprot); + xfer += this->new_parts[_i1339].read(iprot); } xfer += iprot->readListEnd(); } @@ -11438,10 +11438,10 @@ uint32_t ThriftHiveMetastore_add_partitions_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->new_parts.size())); - std::vector<Partition> ::const_iterator _iter1352; - for (_iter1352 = this->new_parts.begin(); _iter1352 != this->new_parts.end(); ++_iter1352) + std::vector<Partition> ::const_iterator _iter1340; + for (_iter1340 = this->new_parts.begin(); _iter1340 != this->new_parts.end(); ++_iter1340) { - xfer += (*_iter1352).write(oprot); + xfer += (*_iter1340).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11465,10 +11465,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->new_parts)).size())); - std::vector<Partition> ::const_iterator _iter1353; - for (_iter1353 = (*(this->new_parts)).begin(); _iter1353 != (*(this->new_parts)).end(); ++_iter1353) + std::vector<Partition> ::const_iterator _iter1341; + for (_iter1341 = (*(this->new_parts)).begin(); _iter1341 != (*(this->new_parts)).end(); ++_iter1341) { - xfer += (*_iter1353).write(oprot); + xfer += (*_iter1341).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11677,14 +11677,14 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1354; - ::apache::thrift::protocol::TType _etype1357; - xfer += iprot->readListBegin(_etype1357, _size1354); - this->new_parts.resize(_size1354); - uint32_t _i1358; - for (_i1358 = 0; _i1358 < _size1354; ++_i1358) + uint32_t _size1342; + ::apache::thrift::protocol::TType _etype1345; + xfer += iprot->readListBegin(_etype1345, _size1342); + this->new_parts.resize(_size1342); + uint32_t _i1346; + for (_i1346 = 0; _i1346 < _size1342; ++_i1346) { - xfer += this->new_parts[_i1358].read(iprot); + xfer += this->new_parts[_i1346].read(iprot); } xfer += iprot->readListEnd(); } @@ -11713,10 +11713,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::write(::apache::thrift:: xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->new_parts.size())); - std::vector<PartitionSpec> ::const_iterator _iter1359; - for (_iter1359 = this->new_parts.begin(); _iter1359 != this->new_parts.end(); ++_iter1359) + std::vector<PartitionSpec> ::const_iterator _iter1347; + for (_iter1347 = this->new_parts.begin(); _iter1347 != this->new_parts.end(); ++_iter1347) { - xfer += (*_iter1359).write(oprot); + xfer += (*_iter1347).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11740,10 +11740,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_pargs::write(::apache::thrift: xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->new_parts)).size())); - std::vector<PartitionSpec> ::const_iterator _iter1360; - for (_iter1360 = (*(this->new_parts)).begin(); _iter1360 != (*(this->new_parts)).end(); ++_iter1360) + std::vector<PartitionSpec> ::const_iterator _iter1348; + for (_iter1348 = (*(this->new_parts)).begin(); _iter1348 != (*(this->new_parts)).end(); ++_iter1348) { - xfer += (*_iter1360).write(oprot); + xfer += (*_iter1348).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11968,14 +11968,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1361; - ::apache::thrift::protocol::TType _etype1364; - xfer += iprot->readListBegin(_etype1364, _size1361); - this->part_vals.resize(_size1361); - uint32_t _i1365; - for (_i1365 = 0; _i1365 < _size1361; ++_i1365) + uint32_t _size1349; + ::apache::thrift::protocol::TType _etype1352; + xfer += iprot->readListBegin(_etype1352, _size1349); + this->part_vals.resize(_size1349); + uint32_t _i1353; + for (_i1353 = 0; _i1353 < _size1349; ++_i1353) { - xfer += iprot->readString(this->part_vals[_i1365]); + xfer += iprot->readString(this->part_vals[_i1353]); } xfer += iprot->readListEnd(); } @@ -12012,10 +12012,10 @@ uint32_t ThriftHiveMetastore_append_partition_args::write(::apache::thrift::prot xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter1366; - for (_iter1366 = this->part_vals.begin(); _iter1366 != this->part_vals.end(); ++_iter1366) + std::vector<std::string> ::const_iterator _iter1354; + for (_iter1354 = this->part_vals.begin(); _iter1354 != this->part_vals.end(); ++_iter1354) { - xfer += oprot->writeString((*_iter1366)); + xfer += oprot->writeString((*_iter1354)); } xfer += oprot->writeListEnd(); } @@ -12047,10 +12047,10 @@ uint32_t ThriftHiveMetastore_append_partition_pargs::write(::apache::thrift::pro xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter1367; - for (_iter1367 = (*(this->part_vals)).begin(); _iter1367 != (*(this->part_vals)).end(); ++_iter1367) + std::vector<std::string> ::const_iterator _iter1355; + for (_iter1355 = (*(this->part_vals)).begin(); _iter1355 != (*(this->part_vals)).end(); ++_iter1355) { - xfer += oprot->writeString((*_iter1367)); + xfer += oprot->writeString((*_iter1355)); } xfer += oprot->writeListEnd(); } @@ -12522,14 +12522,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1368; - ::apache::thrift::protocol::TType _etype1371; - xfer += iprot->readListBegin(_etype1371, _size1368); - this->part_vals.resize(_size1368); - uint32_t _i1372; - for (_i1372 = 0; _i1372 < _size1368; ++_i1372) + uint32_t _size1356; + ::apache::thrift::protocol::TType _etype1359; + xfer += iprot->readListBegin(_etype1359, _size1356); + this->part_vals.resize(_size1356); + uint32_t _i1360; + for (_i1360 = 0; _i1360 < _size1356; ++_i1360) { - xfer += iprot->readString(this->part_vals[_i1372]); + xfer += iprot->readString(this->part_vals[_i1360]); } xfer += iprot->readListEnd(); } @@ -12574,10 +12574,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::wri xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter1373; - for (_iter1373 = this->part_vals.begin(); _iter1373 != this->part_vals.end(); ++_iter1373) + std::vector<std::string> ::const_iterator _iter1361; + for (_iter1361 = this->part_vals.begin(); _iter1361 != this->part_vals.end(); ++_iter1361) { - xfer += oprot->writeString((*_iter1373)); + xfer += oprot->writeString((*_iter1361)); } xfer += oprot->writeListEnd(); } @@ -12613,10 +12613,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_pargs::wr xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter1374; - for (_iter1374 = (*(this->part_vals)).begin(); _iter1374 != (*(this->part_vals)).end(); ++_iter1374) + std::vector<std::string> ::const_iterator _iter1362; + for (_iter1362 = (*(this->part_vals)).begin(); _iter1362 != (*(this->part_vals)).end(); ++_iter1362) { - xfer += oprot->writeString((*_iter1374)); + xfer += oprot->writeString((*_iter1362)); } xfer += oprot->writeListEnd(); } @@ -13419,14 +13419,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1375; - ::apache::thrift::protocol::TType _etype1378; - xfer += iprot->readListBegin(_etype1378, _size1375); - this->part_vals.resize(_size1375); - uint32_t _i1379; - for (_i1379 = 0; _i1379 < _size1375; ++_i1379) + uint32_t _size1363; + ::apache::thrift::protocol::TType _etype1366; + xfer += iprot->readListBegin(_etype1366, _size1363); + this->part_vals.resize(_size1363); + uint32_t _i1367; + for (_i1367 = 0; _i1367 < _size1363; ++_i1367) { - xfer += iprot->readString(this->part_vals[_i1379]); + xfer += iprot->readString(this->part_vals[_i1367]); } xfer += iprot->readListEnd(); } @@ -13471,10 +13471,10 @@ uint32_t ThriftHiveMetastore_drop_partition_args::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter1380; - for (_iter1380 = this->part_vals.begin(); _iter1380 != this->part_vals.end(); ++_iter1380) + std::vector<std::string> ::const_iterator _iter1368; + for (_iter1368 = this->part_vals.begin(); _iter1368 != this->part_vals.end(); ++_iter1368) { - xfer += oprot->writeString((*_iter1380)); + xfer += oprot->writeString((*_iter1368)); } xfer += oprot->writeListEnd(); } @@ -13510,10 +13510,10 @@ uint32_t ThriftHiveMetastore_drop_partition_pargs::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter1381; - for (_iter1381 = (*(this->part_vals)).begin(); _iter1381 != (*(this->part_vals)).end(); ++_iter1381) + std::vector<std::string> ::const_iterator _iter1369; + for (_iter1369 = (*(this->part_vals)).begin(); _iter1369 != (*(this->part_vals)).end(); ++_iter1369) { - xfer += oprot->writeString((*_iter1381)); + xfer += oprot->writeString((*_iter1369)); } xfer += oprot->writeListEnd(); } @@ -13722,14 +13722,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1382; - ::apache::thrift::protocol::TType _etype1385; - xfer += iprot->readListBegin(_etype1385, _size1382); - this->part_vals.resize(_size1382); - uint32_t _i1386; - for (_i1386 = 0; _i1386 < _size1382; ++_i1386) + uint32_t _size1370; + ::apache::thrift::protocol::TType _etype1373; + xfer += iprot->readListBegin(_etype1373, _size1370); + this->part_vals.resize(_size1370); + uint32_t _i1374; + for (_i1374 = 0; _i1374 < _size1370; ++_i1374) { - xfer += iprot->readString(this->part_vals[_i1386]); + xfer += iprot->readString(this->part_vals[_i1374]); } xfer += iprot->readListEnd(); } @@ -13782,10 +13782,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::write xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter1387; - for (_iter1387 = this->part_vals.begin(); _iter1387 != this->part_vals.end(); ++_iter1387) + std::vector<std::string> ::const_iterator _iter1375; + for (_iter1375 = this->part_vals.begin(); _iter1375 != this->part_vals.end(); ++_iter1375) { - xfer += oprot->writeString((*_iter1387)); + xfer += oprot->writeString((*_iter1375)); } xfer += oprot->writeListEnd(); } @@ -13825,10 +13825,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_pargs::writ xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter1388; - for (_iter1388 = (*(this->part_vals)).begin(); _iter1388 != (*(this->part_vals)).end(); ++_iter1388) + std::vector<std::string> ::const_iterator _iter1376; + for (_iter1376 = (*(this->part_vals)).begin(); _iter1376 != (*(this->part_vals)).end(); ++_iter1376) { - xfer += oprot->writeString((*_iter1388)); + xfer += oprot->writeString((*_iter1376)); } xfer += oprot->writeListEnd(); } @@ -14834,14 +14834,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1389; - ::apache::thrift::protocol::TType _etype1392; - xfer += iprot->readListBegin(_etype1392, _size1389); - this->part_vals.resize(_size1389); - uint32_t _i1393; - for (_i1393 = 0; _i1393 < _size1389; ++_i1393) + uint32_t _size1377; + ::apache::thrift::protocol::TType _etype1380; + xfer += iprot->readListBegin(_etype1380, _size1377); + this->part_vals.resize(_size1377); + uint32_t _i1381; + for (_i1381 = 0; _i1381 < _size1377; ++_i1381) { - xfer += iprot->readString(this->part_vals[_i1393]); + xfer += iprot->readString(this->part_vals[_i1381]); } xfer += iprot->readListEnd(); } @@ -14878,10 +14878,10 @@ uint32_t ThriftHiveMetastore_get_partition_args::write(::apache::thrift::protoco xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size())); - std::vector<std::string> ::const_iterator _iter1394; - for (_iter1394 = this->part_vals.begin(); _iter1394 != this->part_vals.end(); ++_iter1394) + std::vector<std::string> ::const_iterator _iter1382; + for (_iter1382 = this->part_vals.begin(); _iter1382 != this->part_vals.end(); ++_iter1382) { - xfer += oprot->writeString((*_iter1394)); + xfer += oprot->writeString((*_iter1382)); } xfer += oprot->writeListEnd(); } @@ -14913,10 +14913,10 @@ uint32_t ThriftHiveMetastore_get_partition_pargs::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter1395; - for (_iter1395 = (*(this->part_vals)).begin(); _iter1395 != (*(this->part_vals)).end(); ++_iter1395) + std::vector<std::string> ::const_iterator _iter1383; + for (_iter1383 = (*(this->part_vals)).begin(); _iter1383 != (*(this->part_vals)).end(); ++_iter1383) { - xfer += oprot->writeString((*_iter1395)); + xfer += oprot->writeString((*_iter1383)); } xfer += oprot->writeListEnd(); } @@ -15105,17 +15105,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1396; - ::apache::thrift::protocol::TType _ktype1397; - ::apache::thrift::protocol::TType _vtype1398; - xfer += iprot->readMapBegin(_ktype1397, _vtype1398, _size1396); - uint32_t _i1400; - for (_i1400 = 0; _i1400 < _size1396; ++_i1400) + uint32_t _size1384; + ::apache::thrift::protocol::TType _ktype1385; + ::apache::thrift::protocol::TType _vtype1386; + xfer += iprot->readMapBegin(_ktype1385, _vtype1386, _size1384); + uint32_t _i1388; + for (_i1388 = 0; _i1388 < _size1384; ++_i1388) { - std::string _key1401; - xfer += iprot->readString(_key1401); - std::string& _val1402 = this->partitionSpecs[_key1401]; - xfer += iprot->readString(_val1402); + std::string _key1389; + xfer += iprot->readString(_key1389); + std::string& _val1390 = this->partitionSpecs[_key1389]; + xfer += iprot->readString(_val1390); } xfer += iprot->readMapEnd(); } @@ -15176,11 +15176,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionSpecs.size())); - std::map<std::string, std::string> ::const_iterator _iter1403; - for (_iter1403 = this->partitionSpecs.begin(); _iter1403 != this->partitionSpecs.end(); ++_iter1403) + std::map<std::string, std::string> ::const_iterator _iter1391; + for (_iter1391 = this->partitionSpecs.begin(); _iter1391 != this->partitionSpecs.end(); ++_iter1391) { - xfer += oprot->writeString(_iter1403->first); - xfer += oprot->writeString(_iter1403->second); + xfer += oprot->writeString(_iter1391->first); + xfer += oprot->writeString(_iter1391->second); } xfer += oprot->writeMapEnd(); } @@ -15220,11 +15220,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_pargs::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->partitionSpecs)).size())); - std::
<TRUNCATED>
