http://git-wip-us.apache.org/repos/asf/hive/blob/b3e2d8a0/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 dfa13a0..4787703 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -2107,14 +2107,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc 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 _size1191; + ::apache::thrift::protocol::TType _etype1194; + xfer += iprot->readListBegin(_etype1194, _size1191); + this->success.resize(_size1191); + uint32_t _i1195; + for (_i1195 = 0; _i1195 < _size1191; ++_i1195) { - xfer += iprot->readString(this->success[_i1191]); + xfer += iprot->readString(this->success[_i1195]); } xfer += iprot->readListEnd(); } @@ -2153,10 +2153,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 _iter1192; - for (_iter1192 = this->success.begin(); _iter1192 != this->success.end(); ++_iter1192) + std::vector<std::string> ::const_iterator _iter1196; + for (_iter1196 = this->success.begin(); _iter1196 != this->success.end(); ++_iter1196) { - xfer += oprot->writeString((*_iter1192)); + xfer += oprot->writeString((*_iter1196)); } xfer += oprot->writeListEnd(); } @@ -2201,14 +2201,14 @@ uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1193; - ::apache::thrift::protocol::TType _etype1196; - xfer += iprot->readListBegin(_etype1196, _size1193); - (*(this->success)).resize(_size1193); - uint32_t _i1197; - for (_i1197 = 0; _i1197 < _size1193; ++_i1197) + uint32_t _size1197; + ::apache::thrift::protocol::TType _etype1200; + xfer += iprot->readListBegin(_etype1200, _size1197); + (*(this->success)).resize(_size1197); + uint32_t _i1201; + for (_i1201 = 0; _i1201 < _size1197; ++_i1201) { - xfer += iprot->readString((*(this->success))[_i1197]); + xfer += iprot->readString((*(this->success))[_i1201]); } xfer += iprot->readListEnd(); } @@ -2325,14 +2325,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1198; - ::apache::thrift::protocol::TType _etype1201; - xfer += iprot->readListBegin(_etype1201, _size1198); - this->success.resize(_size1198); - uint32_t _i1202; - for (_i1202 = 0; _i1202 < _size1198; ++_i1202) + uint32_t _size1202; + ::apache::thrift::protocol::TType _etype1205; + xfer += iprot->readListBegin(_etype1205, _size1202); + this->success.resize(_size1202); + uint32_t _i1206; + for (_i1206 = 0; _i1206 < _size1202; ++_i1206) { - xfer += iprot->readString(this->success[_i1202]); + xfer += iprot->readString(this->success[_i1206]); } xfer += iprot->readListEnd(); } @@ -2371,10 +2371,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 _iter1203; - for (_iter1203 = this->success.begin(); _iter1203 != this->success.end(); ++_iter1203) + std::vector<std::string> ::const_iterator _iter1207; + for (_iter1207 = this->success.begin(); _iter1207 != this->success.end(); ++_iter1207) { - xfer += oprot->writeString((*_iter1203)); + xfer += oprot->writeString((*_iter1207)); } xfer += oprot->writeListEnd(); } @@ -2419,14 +2419,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1204; - ::apache::thrift::protocol::TType _etype1207; - xfer += iprot->readListBegin(_etype1207, _size1204); - (*(this->success)).resize(_size1204); - uint32_t _i1208; - for (_i1208 = 0; _i1208 < _size1204; ++_i1208) + uint32_t _size1208; + ::apache::thrift::protocol::TType _etype1211; + xfer += iprot->readListBegin(_etype1211, _size1208); + (*(this->success)).resize(_size1208); + uint32_t _i1212; + for (_i1212 = 0; _i1212 < _size1208; ++_i1212) { - xfer += iprot->readString((*(this->success))[_i1208]); + xfer += iprot->readString((*(this->success))[_i1212]); } xfer += iprot->readListEnd(); } @@ -3488,17 +3488,17 @@ uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1209; - ::apache::thrift::protocol::TType _ktype1210; - ::apache::thrift::protocol::TType _vtype1211; - xfer += iprot->readMapBegin(_ktype1210, _vtype1211, _size1209); - uint32_t _i1213; - for (_i1213 = 0; _i1213 < _size1209; ++_i1213) + uint32_t _size1213; + ::apache::thrift::protocol::TType _ktype1214; + ::apache::thrift::protocol::TType _vtype1215; + xfer += iprot->readMapBegin(_ktype1214, _vtype1215, _size1213); + uint32_t _i1217; + for (_i1217 = 0; _i1217 < _size1213; ++_i1217) { - std::string _key1214; - xfer += iprot->readString(_key1214); - Type& _val1215 = this->success[_key1214]; - xfer += _val1215.read(iprot); + std::string _key1218; + xfer += iprot->readString(_key1218); + Type& _val1219 = this->success[_key1218]; + xfer += _val1219.read(iprot); } xfer += iprot->readMapEnd(); } @@ -3537,11 +3537,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 _iter1216; - for (_iter1216 = this->success.begin(); _iter1216 != this->success.end(); ++_iter1216) + std::map<std::string, Type> ::const_iterator _iter1220; + for (_iter1220 = this->success.begin(); _iter1220 != this->success.end(); ++_iter1220) { - xfer += oprot->writeString(_iter1216->first); - xfer += _iter1216->second.write(oprot); + xfer += oprot->writeString(_iter1220->first); + xfer += _iter1220->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -3586,17 +3586,17 @@ uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1217; - ::apache::thrift::protocol::TType _ktype1218; - ::apache::thrift::protocol::TType _vtype1219; - xfer += iprot->readMapBegin(_ktype1218, _vtype1219, _size1217); - uint32_t _i1221; - for (_i1221 = 0; _i1221 < _size1217; ++_i1221) + uint32_t _size1221; + ::apache::thrift::protocol::TType _ktype1222; + ::apache::thrift::protocol::TType _vtype1223; + xfer += iprot->readMapBegin(_ktype1222, _vtype1223, _size1221); + uint32_t _i1225; + for (_i1225 = 0; _i1225 < _size1221; ++_i1225) { - std::string _key1222; - xfer += iprot->readString(_key1222); - Type& _val1223 = (*(this->success))[_key1222]; - xfer += _val1223.read(iprot); + std::string _key1226; + xfer += iprot->readString(_key1226); + Type& _val1227 = (*(this->success))[_key1226]; + xfer += _val1227.read(iprot); } xfer += iprot->readMapEnd(); } @@ -3750,14 +3750,14 @@ uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1224; - ::apache::thrift::protocol::TType _etype1227; - xfer += iprot->readListBegin(_etype1227, _size1224); - this->success.resize(_size1224); - uint32_t _i1228; - for (_i1228 = 0; _i1228 < _size1224; ++_i1228) + 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 += this->success[_i1228].read(iprot); + xfer += this->success[_i1232].read(iprot); } xfer += iprot->readListEnd(); } @@ -3812,10 +3812,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 _iter1229; - for (_iter1229 = this->success.begin(); _iter1229 != this->success.end(); ++_iter1229) + std::vector<FieldSchema> ::const_iterator _iter1233; + for (_iter1233 = this->success.begin(); _iter1233 != this->success.end(); ++_iter1233) { - xfer += (*_iter1229).write(oprot); + xfer += (*_iter1233).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3868,14 +3868,14 @@ uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1230; - ::apache::thrift::protocol::TType _etype1233; - xfer += iprot->readListBegin(_etype1233, _size1230); - (*(this->success)).resize(_size1230); - uint32_t _i1234; - for (_i1234 = 0; _i1234 < _size1230; ++_i1234) + 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) { - xfer += (*(this->success))[_i1234].read(iprot); + xfer += (*(this->success))[_i1238].read(iprot); } xfer += iprot->readListEnd(); } @@ -4061,14 +4061,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1235; - ::apache::thrift::protocol::TType _etype1238; - xfer += iprot->readListBegin(_etype1238, _size1235); - this->success.resize(_size1235); - uint32_t _i1239; - for (_i1239 = 0; _i1239 < _size1235; ++_i1239) + 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 += this->success[_i1239].read(iprot); + xfer += this->success[_i1243].read(iprot); } xfer += iprot->readListEnd(); } @@ -4123,10 +4123,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 _iter1240; - for (_iter1240 = this->success.begin(); _iter1240 != this->success.end(); ++_iter1240) + std::vector<FieldSchema> ::const_iterator _iter1244; + for (_iter1244 = this->success.begin(); _iter1244 != this->success.end(); ++_iter1244) { - xfer += (*_iter1240).write(oprot); + xfer += (*_iter1244).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4179,14 +4179,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1241; - ::apache::thrift::protocol::TType _etype1244; - xfer += iprot->readListBegin(_etype1244, _size1241); - (*(this->success)).resize(_size1241); - uint32_t _i1245; - for (_i1245 = 0; _i1245 < _size1241; ++_i1245) + 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) { - xfer += (*(this->success))[_i1245].read(iprot); + xfer += (*(this->success))[_i1249].read(iprot); } xfer += iprot->readListEnd(); } @@ -4356,14 +4356,14 @@ uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1246; - ::apache::thrift::protocol::TType _etype1249; - xfer += iprot->readListBegin(_etype1249, _size1246); - this->success.resize(_size1246); - uint32_t _i1250; - for (_i1250 = 0; _i1250 < _size1246; ++_i1250) + 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 += this->success[_i1250].read(iprot); + xfer += this->success[_i1254].read(iprot); } xfer += iprot->readListEnd(); } @@ -4418,10 +4418,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 _iter1251; - for (_iter1251 = this->success.begin(); _iter1251 != this->success.end(); ++_iter1251) + std::vector<FieldSchema> ::const_iterator _iter1255; + for (_iter1255 = this->success.begin(); _iter1255 != this->success.end(); ++_iter1255) { - xfer += (*_iter1251).write(oprot); + xfer += (*_iter1255).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4474,14 +4474,14 @@ uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1252; - ::apache::thrift::protocol::TType _etype1255; - xfer += iprot->readListBegin(_etype1255, _size1252); - (*(this->success)).resize(_size1252); - uint32_t _i1256; - for (_i1256 = 0; _i1256 < _size1252; ++_i1256) + 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) { - xfer += (*(this->success))[_i1256].read(iprot); + xfer += (*(this->success))[_i1260].read(iprot); } xfer += iprot->readListEnd(); } @@ -4667,14 +4667,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1257; - ::apache::thrift::protocol::TType _etype1260; - xfer += iprot->readListBegin(_etype1260, _size1257); - this->success.resize(_size1257); - uint32_t _i1261; - for (_i1261 = 0; _i1261 < _size1257; ++_i1261) + uint32_t _size1261; + ::apache::thrift::protocol::TType _etype1264; + xfer += iprot->readListBegin(_etype1264, _size1261); + this->success.resize(_size1261); + uint32_t _i1265; + for (_i1265 = 0; _i1265 < _size1261; ++_i1265) { - xfer += this->success[_i1261].read(iprot); + xfer += this->success[_i1265].read(iprot); } xfer += iprot->readListEnd(); } @@ -4729,10 +4729,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 _iter1262; - for (_iter1262 = this->success.begin(); _iter1262 != this->success.end(); ++_iter1262) + std::vector<FieldSchema> ::const_iterator _iter1266; + for (_iter1266 = this->success.begin(); _iter1266 != this->success.end(); ++_iter1266) { - xfer += (*_iter1262).write(oprot); + xfer += (*_iter1266).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4785,14 +4785,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1263; - ::apache::thrift::protocol::TType _etype1266; - xfer += iprot->readListBegin(_etype1266, _size1263); - (*(this->success)).resize(_size1263); - uint32_t _i1267; - for (_i1267 = 0; _i1267 < _size1263; ++_i1267) + uint32_t _size1267; + ::apache::thrift::protocol::TType _etype1270; + xfer += iprot->readListBegin(_etype1270, _size1267); + (*(this->success)).resize(_size1267); + uint32_t _i1271; + for (_i1271 = 0; _i1271 < _size1267; ++_i1271) { - xfer += (*(this->success))[_i1267].read(iprot); + xfer += (*(this->success))[_i1271].read(iprot); } xfer += iprot->readListEnd(); } @@ -5385,14 +5385,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size1268; - ::apache::thrift::protocol::TType _etype1271; - xfer += iprot->readListBegin(_etype1271, _size1268); - this->primaryKeys.resize(_size1268); - uint32_t _i1272; - for (_i1272 = 0; _i1272 < _size1268; ++_i1272) + uint32_t _size1272; + ::apache::thrift::protocol::TType _etype1275; + xfer += iprot->readListBegin(_etype1275, _size1272); + this->primaryKeys.resize(_size1272); + uint32_t _i1276; + for (_i1276 = 0; _i1276 < _size1272; ++_i1276) { - xfer += this->primaryKeys[_i1272].read(iprot); + xfer += this->primaryKeys[_i1276].read(iprot); } xfer += iprot->readListEnd(); } @@ -5405,14 +5405,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size1273; - ::apache::thrift::protocol::TType _etype1276; - xfer += iprot->readListBegin(_etype1276, _size1273); - this->foreignKeys.resize(_size1273); - uint32_t _i1277; - for (_i1277 = 0; _i1277 < _size1273; ++_i1277) + uint32_t _size1277; + ::apache::thrift::protocol::TType _etype1280; + xfer += iprot->readListBegin(_etype1280, _size1277); + this->foreignKeys.resize(_size1277); + uint32_t _i1281; + for (_i1281 = 0; _i1281 < _size1277; ++_i1281) { - xfer += this->foreignKeys[_i1277].read(iprot); + xfer += this->foreignKeys[_i1281].read(iprot); } xfer += iprot->readListEnd(); } @@ -5425,14 +5425,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size1278; - ::apache::thrift::protocol::TType _etype1281; - xfer += iprot->readListBegin(_etype1281, _size1278); - this->uniqueConstraints.resize(_size1278); - uint32_t _i1282; - for (_i1282 = 0; _i1282 < _size1278; ++_i1282) + uint32_t _size1282; + ::apache::thrift::protocol::TType _etype1285; + xfer += iprot->readListBegin(_etype1285, _size1282); + this->uniqueConstraints.resize(_size1282); + uint32_t _i1286; + for (_i1286 = 0; _i1286 < _size1282; ++_i1286) { - xfer += this->uniqueConstraints[_i1282].read(iprot); + xfer += this->uniqueConstraints[_i1286].read(iprot); } xfer += iprot->readListEnd(); } @@ -5445,14 +5445,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size1283; - ::apache::thrift::protocol::TType _etype1286; - xfer += iprot->readListBegin(_etype1286, _size1283); - this->notNullConstraints.resize(_size1283); - uint32_t _i1287; - for (_i1287 = 0; _i1287 < _size1283; ++_i1287) + uint32_t _size1287; + ::apache::thrift::protocol::TType _etype1290; + xfer += iprot->readListBegin(_etype1290, _size1287); + this->notNullConstraints.resize(_size1287); + uint32_t _i1291; + for (_i1291 = 0; _i1291 < _size1287; ++_i1291) { - xfer += this->notNullConstraints[_i1287].read(iprot); + xfer += this->notNullConstraints[_i1291].read(iprot); } xfer += iprot->readListEnd(); } @@ -5465,14 +5465,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->defaultConstraints.clear(); - uint32_t _size1288; - ::apache::thrift::protocol::TType _etype1291; - xfer += iprot->readListBegin(_etype1291, _size1288); - this->defaultConstraints.resize(_size1288); - uint32_t _i1292; - for (_i1292 = 0; _i1292 < _size1288; ++_i1292) + uint32_t _size1292; + ::apache::thrift::protocol::TType _etype1295; + xfer += iprot->readListBegin(_etype1295, _size1292); + this->defaultConstraints.resize(_size1292); + uint32_t _i1296; + for (_i1296 = 0; _i1296 < _size1292; ++_i1296) { - xfer += this->defaultConstraints[_i1292].read(iprot); + xfer += this->defaultConstraints[_i1296].read(iprot); } xfer += iprot->readListEnd(); } @@ -5485,14 +5485,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->checkConstraints.clear(); - uint32_t _size1293; - ::apache::thrift::protocol::TType _etype1296; - xfer += iprot->readListBegin(_etype1296, _size1293); - this->checkConstraints.resize(_size1293); - uint32_t _i1297; - for (_i1297 = 0; _i1297 < _size1293; ++_i1297) + uint32_t _size1297; + ::apache::thrift::protocol::TType _etype1300; + xfer += iprot->readListBegin(_etype1300, _size1297); + this->checkConstraints.resize(_size1297); + uint32_t _i1301; + for (_i1301 = 0; _i1301 < _size1297; ++_i1301) { - xfer += this->checkConstraints[_i1297].read(iprot); + xfer += this->checkConstraints[_i1301].read(iprot); } xfer += iprot->readListEnd(); } @@ -5525,10 +5525,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 _iter1298; - for (_iter1298 = this->primaryKeys.begin(); _iter1298 != this->primaryKeys.end(); ++_iter1298) + std::vector<SQLPrimaryKey> ::const_iterator _iter1302; + for (_iter1302 = this->primaryKeys.begin(); _iter1302 != this->primaryKeys.end(); ++_iter1302) { - xfer += (*_iter1298).write(oprot); + xfer += (*_iter1302).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5537,10 +5537,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 _iter1299; - for (_iter1299 = this->foreignKeys.begin(); _iter1299 != this->foreignKeys.end(); ++_iter1299) + std::vector<SQLForeignKey> ::const_iterator _iter1303; + for (_iter1303 = this->foreignKeys.begin(); _iter1303 != this->foreignKeys.end(); ++_iter1303) { - xfer += (*_iter1299).write(oprot); + xfer += (*_iter1303).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5549,10 +5549,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 _iter1300; - for (_iter1300 = this->uniqueConstraints.begin(); _iter1300 != this->uniqueConstraints.end(); ++_iter1300) + std::vector<SQLUniqueConstraint> ::const_iterator _iter1304; + for (_iter1304 = this->uniqueConstraints.begin(); _iter1304 != this->uniqueConstraints.end(); ++_iter1304) { - xfer += (*_iter1300).write(oprot); + xfer += (*_iter1304).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5561,10 +5561,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 _iter1301; - for (_iter1301 = this->notNullConstraints.begin(); _iter1301 != this->notNullConstraints.end(); ++_iter1301) + std::vector<SQLNotNullConstraint> ::const_iterator _iter1305; + for (_iter1305 = this->notNullConstraints.begin(); _iter1305 != this->notNullConstraints.end(); ++_iter1305) { - xfer += (*_iter1301).write(oprot); + xfer += (*_iter1305).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5573,10 +5573,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 _iter1302; - for (_iter1302 = this->defaultConstraints.begin(); _iter1302 != this->defaultConstraints.end(); ++_iter1302) + std::vector<SQLDefaultConstraint> ::const_iterator _iter1306; + for (_iter1306 = this->defaultConstraints.begin(); _iter1306 != this->defaultConstraints.end(); ++_iter1306) { - xfer += (*_iter1302).write(oprot); + xfer += (*_iter1306).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5585,10 +5585,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache: xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 7); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->checkConstraints.size())); - std::vector<SQLCheckConstraint> ::const_iterator _iter1303; - for (_iter1303 = this->checkConstraints.begin(); _iter1303 != this->checkConstraints.end(); ++_iter1303) + std::vector<SQLCheckConstraint> ::const_iterator _iter1307; + for (_iter1307 = this->checkConstraints.begin(); _iter1307 != this->checkConstraints.end(); ++_iter1307) { - xfer += (*_iter1303).write(oprot); + xfer += (*_iter1307).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5616,10 +5616,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 _iter1304; - for (_iter1304 = (*(this->primaryKeys)).begin(); _iter1304 != (*(this->primaryKeys)).end(); ++_iter1304) + std::vector<SQLPrimaryKey> ::const_iterator _iter1308; + for (_iter1308 = (*(this->primaryKeys)).begin(); _iter1308 != (*(this->primaryKeys)).end(); ++_iter1308) { - xfer += (*_iter1304).write(oprot); + xfer += (*_iter1308).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5628,10 +5628,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 _iter1305; - for (_iter1305 = (*(this->foreignKeys)).begin(); _iter1305 != (*(this->foreignKeys)).end(); ++_iter1305) + std::vector<SQLForeignKey> ::const_iterator _iter1309; + for (_iter1309 = (*(this->foreignKeys)).begin(); _iter1309 != (*(this->foreignKeys)).end(); ++_iter1309) { - xfer += (*_iter1305).write(oprot); + xfer += (*_iter1309).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5640,10 +5640,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 _iter1306; - for (_iter1306 = (*(this->uniqueConstraints)).begin(); _iter1306 != (*(this->uniqueConstraints)).end(); ++_iter1306) + std::vector<SQLUniqueConstraint> ::const_iterator _iter1310; + for (_iter1310 = (*(this->uniqueConstraints)).begin(); _iter1310 != (*(this->uniqueConstraints)).end(); ++_iter1310) { - xfer += (*_iter1306).write(oprot); + xfer += (*_iter1310).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5652,10 +5652,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 _iter1307; - for (_iter1307 = (*(this->notNullConstraints)).begin(); _iter1307 != (*(this->notNullConstraints)).end(); ++_iter1307) + std::vector<SQLNotNullConstraint> ::const_iterator _iter1311; + for (_iter1311 = (*(this->notNullConstraints)).begin(); _iter1311 != (*(this->notNullConstraints)).end(); ++_iter1311) { - xfer += (*_iter1307).write(oprot); + xfer += (*_iter1311).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5664,10 +5664,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 _iter1308; - for (_iter1308 = (*(this->defaultConstraints)).begin(); _iter1308 != (*(this->defaultConstraints)).end(); ++_iter1308) + std::vector<SQLDefaultConstraint> ::const_iterator _iter1312; + for (_iter1312 = (*(this->defaultConstraints)).begin(); _iter1312 != (*(this->defaultConstraints)).end(); ++_iter1312) { - xfer += (*_iter1308).write(oprot); + xfer += (*_iter1312).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5676,10 +5676,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache xfer += oprot->writeFieldBegin("checkConstraints", ::apache::thrift::protocol::T_LIST, 7); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->checkConstraints)).size())); - std::vector<SQLCheckConstraint> ::const_iterator _iter1309; - for (_iter1309 = (*(this->checkConstraints)).begin(); _iter1309 != (*(this->checkConstraints)).end(); ++_iter1309) + std::vector<SQLCheckConstraint> ::const_iterator _iter1313; + for (_iter1313 = (*(this->checkConstraints)).begin(); _iter1313 != (*(this->checkConstraints)).end(); ++_iter1313) { - xfer += (*_iter1309).write(oprot); + xfer += (*_iter1313).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7847,14 +7847,14 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size1310; - ::apache::thrift::protocol::TType _etype1313; - xfer += iprot->readListBegin(_etype1313, _size1310); - this->partNames.resize(_size1310); - uint32_t _i1314; - for (_i1314 = 0; _i1314 < _size1310; ++_i1314) + uint32_t _size1314; + ::apache::thrift::protocol::TType _etype1317; + xfer += iprot->readListBegin(_etype1317, _size1314); + this->partNames.resize(_size1314); + uint32_t _i1318; + for (_i1318 = 0; _i1318 < _size1314; ++_i1318) { - xfer += iprot->readString(this->partNames[_i1314]); + xfer += iprot->readString(this->partNames[_i1318]); } xfer += iprot->readListEnd(); } @@ -7891,10 +7891,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 _iter1315; - for (_iter1315 = this->partNames.begin(); _iter1315 != this->partNames.end(); ++_iter1315) + std::vector<std::string> ::const_iterator _iter1319; + for (_iter1319 = this->partNames.begin(); _iter1319 != this->partNames.end(); ++_iter1319) { - xfer += oprot->writeString((*_iter1315)); + xfer += oprot->writeString((*_iter1319)); } xfer += oprot->writeListEnd(); } @@ -7926,10 +7926,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 _iter1316; - for (_iter1316 = (*(this->partNames)).begin(); _iter1316 != (*(this->partNames)).end(); ++_iter1316) + std::vector<std::string> ::const_iterator _iter1320; + for (_iter1320 = (*(this->partNames)).begin(); _iter1320 != (*(this->partNames)).end(); ++_iter1320) { - xfer += oprot->writeString((*_iter1316)); + xfer += oprot->writeString((*_iter1320)); } xfer += oprot->writeListEnd(); } @@ -8173,14 +8173,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1317; - ::apache::thrift::protocol::TType _etype1320; - xfer += iprot->readListBegin(_etype1320, _size1317); - this->success.resize(_size1317); - uint32_t _i1321; - for (_i1321 = 0; _i1321 < _size1317; ++_i1321) + uint32_t _size1321; + ::apache::thrift::protocol::TType _etype1324; + xfer += iprot->readListBegin(_etype1324, _size1321); + this->success.resize(_size1321); + uint32_t _i1325; + for (_i1325 = 0; _i1325 < _size1321; ++_i1325) { - xfer += iprot->readString(this->success[_i1321]); + xfer += iprot->readString(this->success[_i1325]); } xfer += iprot->readListEnd(); } @@ -8219,10 +8219,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 _iter1322; - for (_iter1322 = this->success.begin(); _iter1322 != this->success.end(); ++_iter1322) + std::vector<std::string> ::const_iterator _iter1326; + for (_iter1326 = this->success.begin(); _iter1326 != this->success.end(); ++_iter1326) { - xfer += oprot->writeString((*_iter1322)); + xfer += oprot->writeString((*_iter1326)); } xfer += oprot->writeListEnd(); } @@ -8267,14 +8267,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1323; - ::apache::thrift::protocol::TType _etype1326; - xfer += iprot->readListBegin(_etype1326, _size1323); - (*(this->success)).resize(_size1323); - uint32_t _i1327; - for (_i1327 = 0; _i1327 < _size1323; ++_i1327) + uint32_t _size1327; + ::apache::thrift::protocol::TType _etype1330; + xfer += iprot->readListBegin(_etype1330, _size1327); + (*(this->success)).resize(_size1327); + uint32_t _i1331; + for (_i1331 = 0; _i1331 < _size1327; ++_i1331) { - xfer += iprot->readString((*(this->success))[_i1327]); + xfer += iprot->readString((*(this->success))[_i1331]); } xfer += iprot->readListEnd(); } @@ -8444,14 +8444,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 _size1328; - ::apache::thrift::protocol::TType _etype1331; - xfer += iprot->readListBegin(_etype1331, _size1328); - this->success.resize(_size1328); - uint32_t _i1332; - for (_i1332 = 0; _i1332 < _size1328; ++_i1332) + uint32_t _size1332; + ::apache::thrift::protocol::TType _etype1335; + xfer += iprot->readListBegin(_etype1335, _size1332); + this->success.resize(_size1332); + uint32_t _i1336; + for (_i1336 = 0; _i1336 < _size1332; ++_i1336) { - xfer += iprot->readString(this->success[_i1332]); + xfer += iprot->readString(this->success[_i1336]); } xfer += iprot->readListEnd(); } @@ -8490,10 +8490,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 _iter1333; - for (_iter1333 = this->success.begin(); _iter1333 != this->success.end(); ++_iter1333) + std::vector<std::string> ::const_iterator _iter1337; + for (_iter1337 = this->success.begin(); _iter1337 != this->success.end(); ++_iter1337) { - xfer += oprot->writeString((*_iter1333)); + xfer += oprot->writeString((*_iter1337)); } xfer += oprot->writeListEnd(); } @@ -8538,14 +8538,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1334; - ::apache::thrift::protocol::TType _etype1337; - xfer += iprot->readListBegin(_etype1337, _size1334); - (*(this->success)).resize(_size1334); - uint32_t _i1338; - for (_i1338 = 0; _i1338 < _size1334; ++_i1338) + uint32_t _size1338; + ::apache::thrift::protocol::TType _etype1341; + xfer += iprot->readListBegin(_etype1341, _size1338); + (*(this->success)).resize(_size1338); + uint32_t _i1342; + for (_i1342 = 0; _i1342 < _size1338; ++_i1342) { - xfer += iprot->readString((*(this->success))[_i1338]); + xfer += iprot->readString((*(this->success))[_i1342]); } xfer += iprot->readListEnd(); } @@ -8683,14 +8683,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1339; - ::apache::thrift::protocol::TType _etype1342; - xfer += iprot->readListBegin(_etype1342, _size1339); - this->success.resize(_size1339); - uint32_t _i1343; - for (_i1343 = 0; _i1343 < _size1339; ++_i1343) + uint32_t _size1343; + ::apache::thrift::protocol::TType _etype1346; + xfer += iprot->readListBegin(_etype1346, _size1343); + this->success.resize(_size1343); + uint32_t _i1347; + for (_i1347 = 0; _i1347 < _size1343; ++_i1347) { - xfer += iprot->readString(this->success[_i1343]); + xfer += iprot->readString(this->success[_i1347]); } xfer += iprot->readListEnd(); } @@ -8729,10 +8729,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 _iter1344; - for (_iter1344 = this->success.begin(); _iter1344 != this->success.end(); ++_iter1344) + std::vector<std::string> ::const_iterator _iter1348; + for (_iter1348 = this->success.begin(); _iter1348 != this->success.end(); ++_iter1348) { - xfer += oprot->writeString((*_iter1344)); + xfer += oprot->writeString((*_iter1348)); } xfer += oprot->writeListEnd(); } @@ -8777,14 +8777,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_presult::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1345; - ::apache::thrift::protocol::TType _etype1348; - xfer += iprot->readListBegin(_etype1348, _size1345); - (*(this->success)).resize(_size1345); - uint32_t _i1349; - for (_i1349 = 0; _i1349 < _size1345; ++_i1349) + uint32_t _size1349; + ::apache::thrift::protocol::TType _etype1352; + xfer += iprot->readListBegin(_etype1352, _size1349); + (*(this->success)).resize(_size1349); + uint32_t _i1353; + for (_i1353 = 0; _i1353 < _size1349; ++_i1353) { - xfer += iprot->readString((*(this->success))[_i1349]); + xfer += iprot->readString((*(this->success))[_i1353]); } xfer += iprot->readListEnd(); } @@ -8859,14 +8859,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 _size1350; - ::apache::thrift::protocol::TType _etype1353; - xfer += iprot->readListBegin(_etype1353, _size1350); - this->tbl_types.resize(_size1350); - uint32_t _i1354; - for (_i1354 = 0; _i1354 < _size1350; ++_i1354) + uint32_t _size1354; + ::apache::thrift::protocol::TType _etype1357; + xfer += iprot->readListBegin(_etype1357, _size1354); + this->tbl_types.resize(_size1354); + uint32_t _i1358; + for (_i1358 = 0; _i1358 < _size1354; ++_i1358) { - xfer += iprot->readString(this->tbl_types[_i1354]); + xfer += iprot->readString(this->tbl_types[_i1358]); } xfer += iprot->readListEnd(); } @@ -8903,10 +8903,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 _iter1355; - for (_iter1355 = this->tbl_types.begin(); _iter1355 != this->tbl_types.end(); ++_iter1355) + std::vector<std::string> ::const_iterator _iter1359; + for (_iter1359 = this->tbl_types.begin(); _iter1359 != this->tbl_types.end(); ++_iter1359) { - xfer += oprot->writeString((*_iter1355)); + xfer += oprot->writeString((*_iter1359)); } xfer += oprot->writeListEnd(); } @@ -8938,10 +8938,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 _iter1356; - for (_iter1356 = (*(this->tbl_types)).begin(); _iter1356 != (*(this->tbl_types)).end(); ++_iter1356) + std::vector<std::string> ::const_iterator _iter1360; + for (_iter1360 = (*(this->tbl_types)).begin(); _iter1360 != (*(this->tbl_types)).end(); ++_iter1360) { - xfer += oprot->writeString((*_iter1356)); + xfer += oprot->writeString((*_iter1360)); } xfer += oprot->writeListEnd(); } @@ -8982,14 +8982,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1357; - ::apache::thrift::protocol::TType _etype1360; - xfer += iprot->readListBegin(_etype1360, _size1357); - this->success.resize(_size1357); - uint32_t _i1361; - for (_i1361 = 0; _i1361 < _size1357; ++_i1361) + uint32_t _size1361; + ::apache::thrift::protocol::TType _etype1364; + xfer += iprot->readListBegin(_etype1364, _size1361); + this->success.resize(_size1361); + uint32_t _i1365; + for (_i1365 = 0; _i1365 < _size1361; ++_i1365) { - xfer += this->success[_i1361].read(iprot); + xfer += this->success[_i1365].read(iprot); } xfer += iprot->readListEnd(); } @@ -9028,10 +9028,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 _iter1362; - for (_iter1362 = this->success.begin(); _iter1362 != this->success.end(); ++_iter1362) + std::vector<TableMeta> ::const_iterator _iter1366; + for (_iter1366 = this->success.begin(); _iter1366 != this->success.end(); ++_iter1366) { - xfer += (*_iter1362).write(oprot); + xfer += (*_iter1366).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9076,14 +9076,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1363; - ::apache::thrift::protocol::TType _etype1366; - xfer += iprot->readListBegin(_etype1366, _size1363); - (*(this->success)).resize(_size1363); - uint32_t _i1367; - for (_i1367 = 0; _i1367 < _size1363; ++_i1367) + uint32_t _size1367; + ::apache::thrift::protocol::TType _etype1370; + xfer += iprot->readListBegin(_etype1370, _size1367); + (*(this->success)).resize(_size1367); + uint32_t _i1371; + for (_i1371 = 0; _i1371 < _size1367; ++_i1371) { - xfer += (*(this->success))[_i1367].read(iprot); + xfer += (*(this->success))[_i1371].read(iprot); } xfer += iprot->readListEnd(); } @@ -9221,14 +9221,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1368; - ::apache::thrift::protocol::TType _etype1371; - xfer += iprot->readListBegin(_etype1371, _size1368); - this->success.resize(_size1368); - uint32_t _i1372; - for (_i1372 = 0; _i1372 < _size1368; ++_i1372) + uint32_t _size1372; + ::apache::thrift::protocol::TType _etype1375; + xfer += iprot->readListBegin(_etype1375, _size1372); + this->success.resize(_size1372); + uint32_t _i1376; + for (_i1376 = 0; _i1376 < _size1372; ++_i1376) { - xfer += iprot->readString(this->success[_i1372]); + xfer += iprot->readString(this->success[_i1376]); } xfer += iprot->readListEnd(); } @@ -9267,10 +9267,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 _iter1373; - for (_iter1373 = this->success.begin(); _iter1373 != this->success.end(); ++_iter1373) + std::vector<std::string> ::const_iterator _iter1377; + for (_iter1377 = this->success.begin(); _iter1377 != this->success.end(); ++_iter1377) { - xfer += oprot->writeString((*_iter1373)); + xfer += oprot->writeString((*_iter1377)); } xfer += oprot->writeListEnd(); } @@ -9315,14 +9315,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1374; - ::apache::thrift::protocol::TType _etype1377; - xfer += iprot->readListBegin(_etype1377, _size1374); - (*(this->success)).resize(_size1374); - uint32_t _i1378; - for (_i1378 = 0; _i1378 < _size1374; ++_i1378) + uint32_t _size1378; + ::apache::thrift::protocol::TType _etype1381; + xfer += iprot->readListBegin(_etype1381, _size1378); + (*(this->success)).resize(_size1378); + uint32_t _i1382; + for (_i1382 = 0; _i1382 < _size1378; ++_i1382) { - xfer += iprot->readString((*(this->success))[_i1378]); + xfer += iprot->readString((*(this->success))[_i1382]); } xfer += iprot->readListEnd(); } @@ -9632,14 +9632,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 _size1379; - ::apache::thrift::protocol::TType _etype1382; - xfer += iprot->readListBegin(_etype1382, _size1379); - this->tbl_names.resize(_size1379); - uint32_t _i1383; - for (_i1383 = 0; _i1383 < _size1379; ++_i1383) + uint32_t _size1383; + ::apache::thrift::protocol::TType _etype1386; + xfer += iprot->readListBegin(_etype1386, _size1383); + this->tbl_names.resize(_size1383); + uint32_t _i1387; + for (_i1387 = 0; _i1387 < _size1383; ++_i1387) { - xfer += iprot->readString(this->tbl_names[_i1383]); + xfer += iprot->readString(this->tbl_names[_i1387]); } xfer += iprot->readListEnd(); } @@ -9672,10 +9672,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 _iter1384; - for (_iter1384 = this->tbl_names.begin(); _iter1384 != this->tbl_names.end(); ++_iter1384) + std::vector<std::string> ::const_iterator _iter1388; + for (_iter1388 = this->tbl_names.begin(); _iter1388 != this->tbl_names.end(); ++_iter1388) { - xfer += oprot->writeString((*_iter1384)); + xfer += oprot->writeString((*_iter1388)); } xfer += oprot->writeListEnd(); } @@ -9703,10 +9703,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 _iter1385; - for (_iter1385 = (*(this->tbl_names)).begin(); _iter1385 != (*(this->tbl_names)).end(); ++_iter1385) + std::vector<std::string> ::const_iterator _iter1389; + for (_iter1389 = (*(this->tbl_names)).begin(); _iter1389 != (*(this->tbl_names)).end(); ++_iter1389) { - xfer += oprot->writeString((*_iter1385)); + xfer += oprot->writeString((*_iter1389)); } xfer += oprot->writeListEnd(); } @@ -9747,14 +9747,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 _size1386; - ::apache::thrift::protocol::TType _etype1389; - xfer += iprot->readListBegin(_etype1389, _size1386); - this->success.resize(_size1386); - uint32_t _i1390; - for (_i1390 = 0; _i1390 < _size1386; ++_i1390) + uint32_t _size1390; + ::apache::thrift::protocol::TType _etype1393; + xfer += iprot->readListBegin(_etype1393, _size1390); + this->success.resize(_size1390); + uint32_t _i1394; + for (_i1394 = 0; _i1394 < _size1390; ++_i1394) { - xfer += this->success[_i1390].read(iprot); + xfer += this->success[_i1394].read(iprot); } xfer += iprot->readListEnd(); } @@ -9785,10 +9785,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 _iter1391; - for (_iter1391 = this->success.begin(); _iter1391 != this->success.end(); ++_iter1391) + std::vector<Table> ::const_iterator _iter1395; + for (_iter1395 = this->success.begin(); _iter1395 != this->success.end(); ++_iter1395) { - xfer += (*_iter1391).write(oprot); + xfer += (*_iter1395).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9829,14 +9829,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 _size1392; - ::apache::thrift::protocol::TType _etype1395; - xfer += iprot->readListBegin(_etype1395, _size1392); - (*(this->success)).resize(_size1392); - uint32_t _i1396; - for (_i1396 = 0; _i1396 < _size1392; ++_i1396) + uint32_t _size1396; + ::apache::thrift::protocol::TType _etype1399; + xfer += iprot->readListBegin(_etype1399, _size1396); + (*(this->success)).resize(_size1396); + uint32_t _i1400; + for (_i1400 = 0; _i1400 < _size1396; ++_i1400) { - xfer += (*(this->success))[_i1396].read(iprot); + xfer += (*(this->success))[_i1400].read(iprot); } xfer += iprot->readListEnd(); } @@ -10369,14 +10369,14 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_args::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size1397; - ::apache::thrift::protocol::TType _etype1400; - xfer += iprot->readListBegin(_etype1400, _size1397); - this->tbl_names.resize(_size1397); - uint32_t _i1401; - for (_i1401 = 0; _i1401 < _size1397; ++_i1401) + uint32_t _size1401; + ::apache::thrift::protocol::TType _etype1404; + xfer += iprot->readListBegin(_etype1404, _size1401); + this->tbl_names.resize(_size1401); + uint32_t _i1405; + for (_i1405 = 0; _i1405 < _size1401; ++_i1405) { - xfer += iprot->readString(this->tbl_names[_i1401]); + xfer += iprot->readString(this->tbl_names[_i1405]); } xfer += iprot->readListEnd(); } @@ -10409,10 +10409,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 _iter1402; - for (_iter1402 = this->tbl_names.begin(); _iter1402 != this->tbl_names.end(); ++_iter1402) + std::vector<std::string> ::const_iterator _iter1406; + for (_iter1406 = this->tbl_names.begin(); _iter1406 != this->tbl_names.end(); ++_iter1406) { - xfer += oprot->writeString((*_iter1402)); + xfer += oprot->writeString((*_iter1406)); } xfer += oprot->writeListEnd(); } @@ -10440,10 +10440,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 _iter1403; - for (_iter1403 = (*(this->tbl_names)).begin(); _iter1403 != (*(this->tbl_names)).end(); ++_iter1403) + std::vector<std::string> ::const_iterator _iter1407; + for (_iter1407 = (*(this->tbl_names)).begin(); _iter1407 != (*(this->tbl_names)).end(); ++_iter1407) { - xfer += oprot->writeString((*_iter1403)); + xfer += oprot->writeString((*_iter1407)); } xfer += oprot->writeListEnd(); } @@ -10484,17 +10484,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_result::read( if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1404; - ::apache::thrift::protocol::TType _ktype1405; - ::apache::thrift::protocol::TType _vtype1406; - xfer += iprot->readMapBegin(_ktype1405, _vtype1406, _size1404); - uint32_t _i1408; - for (_i1408 = 0; _i1408 < _size1404; ++_i1408) + uint32_t _size1408; + ::apache::thrift::protocol::TType _ktype1409; + ::apache::thrift::protocol::TType _vtype1410; + xfer += iprot->readMapBegin(_ktype1409, _vtype1410, _size1408); + uint32_t _i1412; + for (_i1412 = 0; _i1412 < _size1408; ++_i1412) { - std::string _key1409; - xfer += iprot->readString(_key1409); - Materialization& _val1410 = this->success[_key1409]; - xfer += _val1410.read(iprot); + std::string _key1413; + xfer += iprot->readString(_key1413); + Materialization& _val1414 = this->success[_key1413]; + xfer += _val1414.read(iprot); } xfer += iprot->readMapEnd(); } @@ -10549,11 +10549,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 _iter1411; - for (_iter1411 = this->success.begin(); _iter1411 != this->success.end(); ++_iter1411) + std::map<std::string, Materialization> ::const_iterator _iter1415; + for (_iter1415 = this->success.begin(); _iter1415 != this->success.end(); ++_iter1415) { - xfer += oprot->writeString(_iter1411->first); - xfer += _iter1411->second.write(oprot); + xfer += oprot->writeString(_iter1415->first); + xfer += _iter1415->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -10606,17 +10606,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_presult::read if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1412; - ::apache::thrift::protocol::TType _ktype1413; - ::apache::thrift::protocol::TType _vtype1414; - xfer += iprot->readMapBegin(_ktype1413, _vtype1414, _size1412); - uint32_t _i1416; - for (_i1416 = 0; _i1416 < _size1412; ++_i1416) + uint32_t _size1416; + ::apache::thrift::protocol::TType _ktype1417; + ::apache::thrift::protocol::TType _vtype1418; + xfer += iprot->readMapBegin(_ktype1417, _vtype1418, _size1416); + uint32_t _i1420; + for (_i1420 = 0; _i1420 < _size1416; ++_i1420) { - std::string _key1417; - xfer += iprot->readString(_key1417); - Materialization& _val1418 = (*(this->success))[_key1417]; - xfer += _val1418.read(iprot); + std::string _key1421; + xfer += iprot->readString(_key1421); + Materialization& _val1422 = (*(this->success))[_key1421]; + xfer += _val1422.read(iprot); } xfer += iprot->readMapEnd(); } @@ -11077,14 +11077,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 _size1419; - ::apache::thrift::protocol::TType _etype1422; - xfer += iprot->readListBegin(_etype1422, _size1419); - this->success.resize(_size1419); - uint32_t _i1423; - for (_i1423 = 0; _i1423 < _size1419; ++_i1423) + uint32_t _size1423; + ::apache::thrift::protocol::TType _etype1426; + xfer += iprot->readListBegin(_etype1426, _size1423); + this->success.resize(_size1423); + uint32_t _i1427; + for (_i1427 = 0; _i1427 < _size1423; ++_i1427) { - xfer += iprot->readString(this->success[_i1423]); + xfer += iprot->readString(this->success[_i1427]); } xfer += iprot->readListEnd(); } @@ -11139,10 +11139,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 _iter1424; - for (_iter1424 = this->success.begin(); _iter1424 != this->success.end(); ++_iter1424) + std::vector<std::string> ::const_iterator _iter1428; + for (_iter1428 = this->success.begin(); _iter1428 != this->success.end(); ++_iter1428) { - xfer += oprot->writeString((*_iter1424)); + xfer += oprot->writeString((*_iter1428)); } xfer += oprot->writeListEnd(); } @@ -11195,14 +11195,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 _size1425; - ::apache::thrift::protocol::TType _etype1428; - xfer += iprot->readListBegin(_etype1428, _size1425); - (*(this->success)).resize(_size1425); - uint32_t _i1429; - for (_i1429 = 0; _i1429 < _size1425; ++_i1429) + uint32_t _size1429; + ::apache::thrift::protocol::TType _etype1432; + xfer += iprot->readListBegin(_etype1432, _size1429); + (*(this->success)).resize(_size1429); + uint32_t _i1433; + for (_i1433 = 0; _i1433 < _size1429; ++_i1433) { - xfer += iprot->readString((*(this->success))[_i1429]); + xfer += iprot->readString((*(this->success))[_i1433]); } xfer += iprot->readListEnd(); } @@ -12536,14 +12536,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1430; - ::apache::thrift::protocol::TType _etype1433; - xfer += iprot->readListBegin(_etype1433, _size1430); - this->new_parts.resize(_size1430); - uint32_t _i1434; - for (_i1434 = 0; _i1434 < _size1430; ++_i1434) + uint32_t _size1434; + ::apache::thrift::protocol::TType _etype1437; + xfer += iprot->readListBegin(_etype1437, _size1434); + this->new_parts.resize(_size1434); + uint32_t _i1438; + for (_i1438 = 0; _i1438 < _size1434; ++_i1438) { - xfer += this->new_parts[_i1434].read(iprot); + xfer += this->new_parts[_i1438].read(iprot); } xfer += iprot->readListEnd(); } @@ -12572,10 +12572,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 _iter1435; - for (_iter1435 = this->new_parts.begin(); _iter1435 != this->new_parts.end(); ++_iter1435) + std::vector<Partition> ::const_iterator _iter1439; + for (_iter1439 = this->new_parts.begin(); _iter1439 != this->new_parts.end(); ++_iter1439) { - xfer += (*_iter1435).write(oprot); + xfer += (*_iter1439).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12599,10 +12599,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 _iter1436; - for (_iter1436 = (*(this->new_parts)).begin(); _iter1436 != (*(this->new_parts)).end(); ++_iter1436) + std::vector<Partition> ::const_iterator _iter1440; + for (_iter1440 = (*(this->new_parts)).begin(); _iter1440 != (*(this->new_parts)).end(); ++_iter1440) { - xfer += (*_iter1436).write(oprot); + xfer += (*_iter1440).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12811,14 +12811,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 _size1437; - ::apache::thrift::protocol::TType _etype1440; - xfer += iprot->readListBegin(_etype1440, _size1437); - this->new_parts.resize(_size1437); - uint32_t _i1441; - for (_i1441 = 0; _i1441 < _size1437; ++_i1441) + uint32_t _size1441; + ::apache::thrift::protocol::TType _etype1444; + xfer += iprot->readListBegin(_etype1444, _size1441); + this->new_parts.resize(_size1441); + uint32_t _i1445; + for (_i1445 = 0; _i1445 < _size1441; ++_i1445) { - xfer += this->new_parts[_i1441].read(iprot); + xfer += this->new_parts[_i1445].read(iprot); } xfer += iprot->readListEnd(); } @@ -12847,10 +12847,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 _iter1442; - for (_iter1442 = this->new_parts.begin(); _iter1442 != this->new_parts.end(); ++_iter1442) + std::vector<PartitionSpec> ::const_iterator _iter1446; + for (_iter1446 = this->new_parts.begin(); _iter1446 != this->new_parts.end(); ++_iter1446) { - xfer += (*_iter1442).write(oprot); + xfer += (*_iter1446).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12874,10 +12874,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 _iter1443; - for (_iter1443 = (*(this->new_parts)).begin(); _iter1443 != (*(this->new_parts)).end(); ++_iter1443) + std::vector<PartitionSpec> ::const_iterator _iter1447; + for (_iter1447 = (*(this->new_parts)).begin(); _iter1447 != (*(this->new_parts)).end(); ++_iter1447) { - xfer += (*_iter1443).write(oprot); + xfer += (*_iter1447).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13102,14 +13102,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1444; - ::apache::thrift::protocol::TType _etype1447; - xfer += iprot->readListBegin(_etype1447, _size1444); - this->part_vals.resize(_size1444); - uint32_t _i1448; - for (_i1448 = 0; _i1448 < _size1444; ++_i1448) + uint32_t _size1448; + ::apache::thrift::protocol::TType _etype1451; + xfer += iprot->readListBegin(_etype1451, _size1448); + this->part_vals.resize(_size1448); + uint32_t _i1452; + for (_i1452 = 0; _i1452 < _size1448; ++_i1452) { - xfer += iprot->readString(this->part_vals[_i1448]); + xfer += iprot->readString(this->part_vals[_i1452]); } xfer += iprot->readListEnd(); } @@ -13146,10 +13146,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 _iter1449; - for (_iter1449 = this->part_vals.begin(); _iter1449 != this->part_vals.end(); ++_iter1449) + std::vector<std::string> ::const_iterator _iter1453; + for (_iter1453 = this->part_vals.begin(); _iter1453 != this->part_vals.end(); ++_iter1453) { - xfer += oprot->writeString((*_iter1449)); + xfer += oprot->writeString((*_iter1453)); } xfer += oprot->writeListEnd(); } @@ -13181,10 +13181,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 _iter1450; - for (_iter1450 = (*(this->part_vals)).begin(); _iter1450 != (*(this->part_vals)).end(); ++_iter1450) + std::vector<std::string> ::const_iterator _iter1454; + for (_iter1454 = (*(this->part_vals)).begin(); _iter1454 != (*(this->part_vals)).end(); ++_iter1454) { - xfer += oprot->writeString((*_iter1450)); + xfer += oprot->writeString((*_iter1454)); } xfer += oprot->writeListEnd(); } @@ -13656,14 +13656,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1451; - ::apache::thrift::protocol::TType _etype1454; - xfer += iprot->readListBegin(_etype1454, _size1451); - this->part_vals.resize(_size1451); - uint32_t _i1455; - for (_i1455 = 0; _i1455 < _size1451; ++_i1455) + uint32_t _size1455; + ::apache::thrift::protocol::TType _etype1458; + xfer += iprot->readListBegin(_etype1458, _size1455); + this->part_vals.resize(_size1455); + uint32_t _i1459; + for (_i1459 = 0; _i1459 < _size1455; ++_i1459) { - xfer += iprot->readString(this->part_vals[_i1455]); + xfer += iprot->readString(this->part_vals[_i1459]); } xfer += iprot->readListEnd(); } @@ -13708,10 +13708,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 _iter1456; - for (_iter1456 = this->part_vals.begin(); _iter1456 != this->part_vals.end(); ++_iter1456) + std::vector<std::string> ::const_iterator _iter1460; + for (_iter1460 = this->part_vals.begin(); _iter1460 != this->part_vals.end(); ++_iter1460) { - xfer += oprot->writeString((*_iter1456)); + xfer += oprot->writeString((*_iter1460)); } xfer += oprot->writeListEnd(); } @@ -13747,10 +13747,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 _iter1457; - for (_iter1457 = (*(this->part_vals)).begin(); _iter1457 != (*(this->part_vals)).end(); ++_iter1457) + std::vector<std::string> ::const_iterator _iter1461; + for (_iter1461 = (*(this->part_vals)).begin(); _iter1461 != (*(this->part_vals)).end(); ++_iter1461) { - xfer += oprot->writeString((*_iter1457)); + xfer += oprot->writeString((*_iter1461)); } xfer += oprot->writeListEnd(); } @@ -14553,14 +14553,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1458; - ::apache::thrift::protocol::TType _etype1461; - xfer += iprot->readListBegin(_etype1461, _size1458); - this->part_vals.resize(_size1458); - uint32_t _i1462; - for (_i1462 = 0; _i1462 < _size1458; ++_i1462) + uint32_t _size1462; + ::apache::thrift::protocol::TType _etype1465; + xfer += iprot->readListBegin(_etype1465, _size1462); + this->part_vals.resize(_size1462); + uint32_t _i1466; + for (_i1466 = 0; _i1466 < _size1462; ++_i1466) { - xfer += iprot->readString(this->part_vals[_i1462]); + xfer += iprot->readString(this->part_vals[_i1466]); } xfer += iprot->readListEnd(); } @@ -14605,10 +14605,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 _iter1463; - for (_iter1463 = this->part_vals.begin(); _iter1463 != this->part_vals.end(); ++_iter1463) + std::vector<std::string> ::const_iterator _iter1467; + for (_iter1467 = this->part_vals.begin(); _iter1467 != this->part_vals.end(); ++_iter1467) { - xfer += oprot->writeString((*_iter1463)); + xfer += oprot->writeString((*_iter1467)); } xfer += oprot->writeListEnd(); } @@ -14644,10 +14644,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 _iter1464; - for (_iter1464 = (*(this->part_vals)).begin(); _iter1464 != (*(this->part_vals)).end(); ++_iter1464) + std::vector<std::string> ::const_iterator _iter1468; + for (_iter1468 = (*(this->part_vals)).begin(); _iter1468 != (*(this->part_vals)).end(); ++_iter1468) { - xfer += oprot->writeString((*_iter1464)); + xfer += oprot->writeString((*_iter1468)); } xfer += oprot->writeListEnd(); } @@ -14856,14 +14856,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1465; - ::apache::thrift::protocol::TType _etype1468; - xfer += iprot->readListBegin(_etype1468, _size1465); - this->part_vals.resize(_size1465); - uint32_t _i1469; - for (_i1469 = 0; _i1469 < _size1465; ++_i1469) + uint32_t _size1469; + ::apache::thrift::protocol::TType _etype1472; + xfer += iprot->readListBegin(_etype1472, _size1469); + this->part_vals.resize(_size1469); + uint32_t _i1473; + for (_i1473 = 0; _i1473 < _size1469; ++_i1473) { - xfer += iprot->readString(this->part_vals[_i1469]); + xfer += iprot->readString(this->part_vals[_i1473]); } xfer += iprot->readListEnd(); } @@ -14916,10 +14916,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 _iter1470; - for (_iter1470 = this->part_vals.begin(); _iter1470 != this->part_vals.end(); ++_iter1470) + std::vector<std::string> ::const_iterator _iter1474; + for (_iter1474 = this->part_vals.begin(); _iter1474 != this->part_vals.end(); ++_iter1474) { - xfer += oprot->writeString((*_iter1470)); + xfer += oprot->writeString((*_iter1474)); } xfer += oprot->writeListEnd(); } @@ -14959,10 +14959,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 _iter1471; - for (_iter1471 = (*(this->part_vals)).begin(); _iter1471 != (*(this->part_vals)).end(); ++_iter1471) + std::vector<std::string> ::const_iterator _iter1475; + for (_iter1475 = (*(this->part_vals)).begin(); _iter1475 != (*(this->part_vals)).end(); ++_iter1475) { - xfer += oprot->writeString((*_iter1471)); + xfer += oprot->writeString((*_iter1475)); } xfer += oprot->writeListEnd(); } @@ -15968,14 +15968,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1472; - ::apache::thrift::protocol::TType _etype1475; - xfer += iprot->readListBegin(_etype1475, _size1472); - this->part_vals.resize(_size1472); - uint32_t _i1476; - for (_i1476 = 0; _i1476 < _size1472; ++_i1476) + uint32_t _size1476; + ::apache::thrift::protocol::TType _etype1479; + xfer += iprot->readListBegin(_etype1479, _size1476); + this->part_vals.resize(_size1476); + uint32_t _i1480; + for (_i1480 = 0; _i1480 < _size1476; ++_i1480) { - xfer += iprot->readString(this->part_vals[_i1476]); + xfer += iprot->readString(this->part_vals[_i1480]); } xfer += iprot->readListEnd(); } @@ -16012,10 +16012,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 _iter1477; - for (_iter1477 = this->part_vals.begin(); _iter1477 != this->part_vals.end(); ++_iter1477) + std::vector<std::string> ::const_iterator _iter1481; + for (_iter1481 = this->part_vals.begin(); _iter1481 != this->part_vals.end(); ++_iter1481) { - xfer += oprot->writeString((*_iter1477)); + xfer += oprot->writeString((*_iter1481)); } xfer += oprot->writeListEnd(); } @@ -16047,10 +16047,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 _iter1478; - for (_iter1478 = (*(this->part_vals)).begin(); _iter1478 != (*(this->part_vals)).end(); ++_iter1478) + std::vector<std::string> ::const_iterator _iter1482; + for (_iter1482 = (*(this->part_vals)).begin(); _iter1482 != (*(this->part_vals)).end(); ++_iter1482) { - xfer += oprot->writeString((*_iter1478)); + xfer += oprot->writeString((*_iter1482)); } xfer += oprot->writeListEnd(); }
<TRUNCATED>