http://git-wip-us.apache.org/repos/asf/hive/blob/f0199500/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 4787703..dfa13a0 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 _size1191; - ::apache::thrift::protocol::TType _etype1194; - xfer += iprot->readListBegin(_etype1194, _size1191); - this->success.resize(_size1191); - uint32_t _i1195; - for (_i1195 = 0; _i1195 < _size1191; ++_i1195) + 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) { - xfer += iprot->readString(this->success[_i1195]); + xfer += iprot->readString(this->success[_i1191]); } 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 _iter1196; - for (_iter1196 = this->success.begin(); _iter1196 != this->success.end(); ++_iter1196) + std::vector<std::string> ::const_iterator _iter1192; + for (_iter1192 = this->success.begin(); _iter1192 != this->success.end(); ++_iter1192) { - xfer += oprot->writeString((*_iter1196)); + xfer += oprot->writeString((*_iter1192)); } 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 _size1197; - ::apache::thrift::protocol::TType _etype1200; - xfer += iprot->readListBegin(_etype1200, _size1197); - (*(this->success)).resize(_size1197); - uint32_t _i1201; - for (_i1201 = 0; _i1201 < _size1197; ++_i1201) + 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) { - xfer += iprot->readString((*(this->success))[_i1201]); + xfer += iprot->readString((*(this->success))[_i1197]); } 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 _size1202; - ::apache::thrift::protocol::TType _etype1205; - xfer += iprot->readListBegin(_etype1205, _size1202); - this->success.resize(_size1202); - uint32_t _i1206; - for (_i1206 = 0; _i1206 < _size1202; ++_i1206) + 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) { - xfer += iprot->readString(this->success[_i1206]); + xfer += iprot->readString(this->success[_i1202]); } 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 _iter1207; - for (_iter1207 = this->success.begin(); _iter1207 != this->success.end(); ++_iter1207) + std::vector<std::string> ::const_iterator _iter1203; + for (_iter1203 = this->success.begin(); _iter1203 != this->success.end(); ++_iter1203) { - xfer += oprot->writeString((*_iter1207)); + xfer += oprot->writeString((*_iter1203)); } 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 _size1208; - ::apache::thrift::protocol::TType _etype1211; - xfer += iprot->readListBegin(_etype1211, _size1208); - (*(this->success)).resize(_size1208); - uint32_t _i1212; - for (_i1212 = 0; _i1212 < _size1208; ++_i1212) + 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) { - xfer += iprot->readString((*(this->success))[_i1212]); + xfer += iprot->readString((*(this->success))[_i1208]); } 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 _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) + 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) { - std::string _key1218; - xfer += iprot->readString(_key1218); - Type& _val1219 = this->success[_key1218]; - xfer += _val1219.read(iprot); + std::string _key1214; + xfer += iprot->readString(_key1214); + Type& _val1215 = this->success[_key1214]; + xfer += _val1215.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 _iter1220; - for (_iter1220 = this->success.begin(); _iter1220 != this->success.end(); ++_iter1220) + std::map<std::string, Type> ::const_iterator _iter1216; + for (_iter1216 = this->success.begin(); _iter1216 != this->success.end(); ++_iter1216) { - xfer += oprot->writeString(_iter1220->first); - xfer += _iter1220->second.write(oprot); + xfer += oprot->writeString(_iter1216->first); + xfer += _iter1216->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 _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) + 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) { - std::string _key1226; - xfer += iprot->readString(_key1226); - Type& _val1227 = (*(this->success))[_key1226]; - xfer += _val1227.read(iprot); + std::string _key1222; + xfer += iprot->readString(_key1222); + Type& _val1223 = (*(this->success))[_key1222]; + xfer += _val1223.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 _size1228; - ::apache::thrift::protocol::TType _etype1231; - xfer += iprot->readListBegin(_etype1231, _size1228); - this->success.resize(_size1228); - uint32_t _i1232; - for (_i1232 = 0; _i1232 < _size1228; ++_i1232) + 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) { - xfer += this->success[_i1232].read(iprot); + xfer += this->success[_i1228].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 _iter1233; - for (_iter1233 = this->success.begin(); _iter1233 != this->success.end(); ++_iter1233) + std::vector<FieldSchema> ::const_iterator _iter1229; + for (_iter1229 = this->success.begin(); _iter1229 != this->success.end(); ++_iter1229) { - xfer += (*_iter1233).write(oprot); + xfer += (*_iter1229).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 _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 _size1230; + ::apache::thrift::protocol::TType _etype1233; + xfer += iprot->readListBegin(_etype1233, _size1230); + (*(this->success)).resize(_size1230); + uint32_t _i1234; + for (_i1234 = 0; _i1234 < _size1230; ++_i1234) { - xfer += (*(this->success))[_i1238].read(iprot); + xfer += (*(this->success))[_i1234].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 _size1239; - ::apache::thrift::protocol::TType _etype1242; - xfer += iprot->readListBegin(_etype1242, _size1239); - this->success.resize(_size1239); - uint32_t _i1243; - for (_i1243 = 0; _i1243 < _size1239; ++_i1243) + 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) { - xfer += this->success[_i1243].read(iprot); + xfer += this->success[_i1239].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 _iter1244; - for (_iter1244 = this->success.begin(); _iter1244 != this->success.end(); ++_iter1244) + std::vector<FieldSchema> ::const_iterator _iter1240; + for (_iter1240 = this->success.begin(); _iter1240 != this->success.end(); ++_iter1240) { - xfer += (*_iter1244).write(oprot); + xfer += (*_iter1240).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 _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 _size1241; + ::apache::thrift::protocol::TType _etype1244; + xfer += iprot->readListBegin(_etype1244, _size1241); + (*(this->success)).resize(_size1241); + uint32_t _i1245; + for (_i1245 = 0; _i1245 < _size1241; ++_i1245) { - xfer += (*(this->success))[_i1249].read(iprot); + xfer += (*(this->success))[_i1245].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 _size1250; - ::apache::thrift::protocol::TType _etype1253; - xfer += iprot->readListBegin(_etype1253, _size1250); - this->success.resize(_size1250); - uint32_t _i1254; - for (_i1254 = 0; _i1254 < _size1250; ++_i1254) + 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) { - xfer += this->success[_i1254].read(iprot); + xfer += this->success[_i1250].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 _iter1255; - for (_iter1255 = this->success.begin(); _iter1255 != this->success.end(); ++_iter1255) + std::vector<FieldSchema> ::const_iterator _iter1251; + for (_iter1251 = this->success.begin(); _iter1251 != this->success.end(); ++_iter1251) { - xfer += (*_iter1255).write(oprot); + xfer += (*_iter1251).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 _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 _size1252; + ::apache::thrift::protocol::TType _etype1255; + xfer += iprot->readListBegin(_etype1255, _size1252); + (*(this->success)).resize(_size1252); + uint32_t _i1256; + for (_i1256 = 0; _i1256 < _size1252; ++_i1256) { - xfer += (*(this->success))[_i1260].read(iprot); + xfer += (*(this->success))[_i1256].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 _size1261; - ::apache::thrift::protocol::TType _etype1264; - xfer += iprot->readListBegin(_etype1264, _size1261); - this->success.resize(_size1261); - uint32_t _i1265; - for (_i1265 = 0; _i1265 < _size1261; ++_i1265) + 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) { - xfer += this->success[_i1265].read(iprot); + xfer += this->success[_i1261].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 _iter1266; - for (_iter1266 = this->success.begin(); _iter1266 != this->success.end(); ++_iter1266) + std::vector<FieldSchema> ::const_iterator _iter1262; + for (_iter1262 = this->success.begin(); _iter1262 != this->success.end(); ++_iter1262) { - xfer += (*_iter1266).write(oprot); + xfer += (*_iter1262).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 _size1267; - ::apache::thrift::protocol::TType _etype1270; - xfer += iprot->readListBegin(_etype1270, _size1267); - (*(this->success)).resize(_size1267); - uint32_t _i1271; - for (_i1271 = 0; _i1271 < _size1267; ++_i1271) + 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) { - xfer += (*(this->success))[_i1271].read(iprot); + xfer += (*(this->success))[_i1267].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 _size1272; - ::apache::thrift::protocol::TType _etype1275; - xfer += iprot->readListBegin(_etype1275, _size1272); - this->primaryKeys.resize(_size1272); - uint32_t _i1276; - for (_i1276 = 0; _i1276 < _size1272; ++_i1276) + 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) { - xfer += this->primaryKeys[_i1276].read(iprot); + xfer += this->primaryKeys[_i1272].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 _size1277; - ::apache::thrift::protocol::TType _etype1280; - xfer += iprot->readListBegin(_etype1280, _size1277); - this->foreignKeys.resize(_size1277); - uint32_t _i1281; - for (_i1281 = 0; _i1281 < _size1277; ++_i1281) + 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) { - xfer += this->foreignKeys[_i1281].read(iprot); + xfer += this->foreignKeys[_i1277].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 _size1282; - ::apache::thrift::protocol::TType _etype1285; - xfer += iprot->readListBegin(_etype1285, _size1282); - this->uniqueConstraints.resize(_size1282); - uint32_t _i1286; - for (_i1286 = 0; _i1286 < _size1282; ++_i1286) + 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) { - xfer += this->uniqueConstraints[_i1286].read(iprot); + xfer += this->uniqueConstraints[_i1282].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 _size1287; - ::apache::thrift::protocol::TType _etype1290; - xfer += iprot->readListBegin(_etype1290, _size1287); - this->notNullConstraints.resize(_size1287); - uint32_t _i1291; - for (_i1291 = 0; _i1291 < _size1287; ++_i1291) + 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) { - xfer += this->notNullConstraints[_i1291].read(iprot); + xfer += this->notNullConstraints[_i1287].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 _size1292; - ::apache::thrift::protocol::TType _etype1295; - xfer += iprot->readListBegin(_etype1295, _size1292); - this->defaultConstraints.resize(_size1292); - uint32_t _i1296; - for (_i1296 = 0; _i1296 < _size1292; ++_i1296) + 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) { - xfer += this->defaultConstraints[_i1296].read(iprot); + xfer += this->defaultConstraints[_i1292].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 _size1297; - ::apache::thrift::protocol::TType _etype1300; - xfer += iprot->readListBegin(_etype1300, _size1297); - this->checkConstraints.resize(_size1297); - uint32_t _i1301; - for (_i1301 = 0; _i1301 < _size1297; ++_i1301) + 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) { - xfer += this->checkConstraints[_i1301].read(iprot); + xfer += this->checkConstraints[_i1297].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 _iter1302; - for (_iter1302 = this->primaryKeys.begin(); _iter1302 != this->primaryKeys.end(); ++_iter1302) + std::vector<SQLPrimaryKey> ::const_iterator _iter1298; + for (_iter1298 = this->primaryKeys.begin(); _iter1298 != this->primaryKeys.end(); ++_iter1298) { - xfer += (*_iter1302).write(oprot); + xfer += (*_iter1298).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 _iter1303; - for (_iter1303 = this->foreignKeys.begin(); _iter1303 != this->foreignKeys.end(); ++_iter1303) + std::vector<SQLForeignKey> ::const_iterator _iter1299; + for (_iter1299 = this->foreignKeys.begin(); _iter1299 != this->foreignKeys.end(); ++_iter1299) { - xfer += (*_iter1303).write(oprot); + xfer += (*_iter1299).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 _iter1304; - for (_iter1304 = this->uniqueConstraints.begin(); _iter1304 != this->uniqueConstraints.end(); ++_iter1304) + std::vector<SQLUniqueConstraint> ::const_iterator _iter1300; + for (_iter1300 = this->uniqueConstraints.begin(); _iter1300 != this->uniqueConstraints.end(); ++_iter1300) { - xfer += (*_iter1304).write(oprot); + xfer += (*_iter1300).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 _iter1305; - for (_iter1305 = this->notNullConstraints.begin(); _iter1305 != this->notNullConstraints.end(); ++_iter1305) + std::vector<SQLNotNullConstraint> ::const_iterator _iter1301; + for (_iter1301 = this->notNullConstraints.begin(); _iter1301 != this->notNullConstraints.end(); ++_iter1301) { - xfer += (*_iter1305).write(oprot); + xfer += (*_iter1301).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 _iter1306; - for (_iter1306 = this->defaultConstraints.begin(); _iter1306 != this->defaultConstraints.end(); ++_iter1306) + std::vector<SQLDefaultConstraint> ::const_iterator _iter1302; + for (_iter1302 = this->defaultConstraints.begin(); _iter1302 != this->defaultConstraints.end(); ++_iter1302) { - xfer += (*_iter1306).write(oprot); + xfer += (*_iter1302).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 _iter1307; - for (_iter1307 = this->checkConstraints.begin(); _iter1307 != this->checkConstraints.end(); ++_iter1307) + std::vector<SQLCheckConstraint> ::const_iterator _iter1303; + for (_iter1303 = this->checkConstraints.begin(); _iter1303 != this->checkConstraints.end(); ++_iter1303) { - xfer += (*_iter1307).write(oprot); + xfer += (*_iter1303).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 _iter1308; - for (_iter1308 = (*(this->primaryKeys)).begin(); _iter1308 != (*(this->primaryKeys)).end(); ++_iter1308) + std::vector<SQLPrimaryKey> ::const_iterator _iter1304; + for (_iter1304 = (*(this->primaryKeys)).begin(); _iter1304 != (*(this->primaryKeys)).end(); ++_iter1304) { - xfer += (*_iter1308).write(oprot); + xfer += (*_iter1304).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 _iter1309; - for (_iter1309 = (*(this->foreignKeys)).begin(); _iter1309 != (*(this->foreignKeys)).end(); ++_iter1309) + std::vector<SQLForeignKey> ::const_iterator _iter1305; + for (_iter1305 = (*(this->foreignKeys)).begin(); _iter1305 != (*(this->foreignKeys)).end(); ++_iter1305) { - xfer += (*_iter1309).write(oprot); + xfer += (*_iter1305).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 _iter1310; - for (_iter1310 = (*(this->uniqueConstraints)).begin(); _iter1310 != (*(this->uniqueConstraints)).end(); ++_iter1310) + std::vector<SQLUniqueConstraint> ::const_iterator _iter1306; + for (_iter1306 = (*(this->uniqueConstraints)).begin(); _iter1306 != (*(this->uniqueConstraints)).end(); ++_iter1306) { - xfer += (*_iter1310).write(oprot); + xfer += (*_iter1306).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 _iter1311; - for (_iter1311 = (*(this->notNullConstraints)).begin(); _iter1311 != (*(this->notNullConstraints)).end(); ++_iter1311) + std::vector<SQLNotNullConstraint> ::const_iterator _iter1307; + for (_iter1307 = (*(this->notNullConstraints)).begin(); _iter1307 != (*(this->notNullConstraints)).end(); ++_iter1307) { - xfer += (*_iter1311).write(oprot); + xfer += (*_iter1307).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 _iter1312; - for (_iter1312 = (*(this->defaultConstraints)).begin(); _iter1312 != (*(this->defaultConstraints)).end(); ++_iter1312) + std::vector<SQLDefaultConstraint> ::const_iterator _iter1308; + for (_iter1308 = (*(this->defaultConstraints)).begin(); _iter1308 != (*(this->defaultConstraints)).end(); ++_iter1308) { - xfer += (*_iter1312).write(oprot); + xfer += (*_iter1308).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 _iter1313; - for (_iter1313 = (*(this->checkConstraints)).begin(); _iter1313 != (*(this->checkConstraints)).end(); ++_iter1313) + std::vector<SQLCheckConstraint> ::const_iterator _iter1309; + for (_iter1309 = (*(this->checkConstraints)).begin(); _iter1309 != (*(this->checkConstraints)).end(); ++_iter1309) { - xfer += (*_iter1313).write(oprot); + xfer += (*_iter1309).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 _size1314; - ::apache::thrift::protocol::TType _etype1317; - xfer += iprot->readListBegin(_etype1317, _size1314); - this->partNames.resize(_size1314); - uint32_t _i1318; - for (_i1318 = 0; _i1318 < _size1314; ++_i1318) + 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) { - xfer += iprot->readString(this->partNames[_i1318]); + xfer += iprot->readString(this->partNames[_i1314]); } 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 _iter1319; - for (_iter1319 = this->partNames.begin(); _iter1319 != this->partNames.end(); ++_iter1319) + std::vector<std::string> ::const_iterator _iter1315; + for (_iter1315 = this->partNames.begin(); _iter1315 != this->partNames.end(); ++_iter1315) { - xfer += oprot->writeString((*_iter1319)); + xfer += oprot->writeString((*_iter1315)); } 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 _iter1320; - for (_iter1320 = (*(this->partNames)).begin(); _iter1320 != (*(this->partNames)).end(); ++_iter1320) + std::vector<std::string> ::const_iterator _iter1316; + for (_iter1316 = (*(this->partNames)).begin(); _iter1316 != (*(this->partNames)).end(); ++_iter1316) { - xfer += oprot->writeString((*_iter1320)); + xfer += oprot->writeString((*_iter1316)); } 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 _size1321; - ::apache::thrift::protocol::TType _etype1324; - xfer += iprot->readListBegin(_etype1324, _size1321); - this->success.resize(_size1321); - uint32_t _i1325; - for (_i1325 = 0; _i1325 < _size1321; ++_i1325) + 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) { - xfer += iprot->readString(this->success[_i1325]); + xfer += iprot->readString(this->success[_i1321]); } 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 _iter1326; - for (_iter1326 = this->success.begin(); _iter1326 != this->success.end(); ++_iter1326) + std::vector<std::string> ::const_iterator _iter1322; + for (_iter1322 = this->success.begin(); _iter1322 != this->success.end(); ++_iter1322) { - xfer += oprot->writeString((*_iter1326)); + xfer += oprot->writeString((*_iter1322)); } 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 _size1327; - ::apache::thrift::protocol::TType _etype1330; - xfer += iprot->readListBegin(_etype1330, _size1327); - (*(this->success)).resize(_size1327); - uint32_t _i1331; - for (_i1331 = 0; _i1331 < _size1327; ++_i1331) + 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) { - xfer += iprot->readString((*(this->success))[_i1331]); + xfer += iprot->readString((*(this->success))[_i1327]); } 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 _size1332; - ::apache::thrift::protocol::TType _etype1335; - xfer += iprot->readListBegin(_etype1335, _size1332); - this->success.resize(_size1332); - uint32_t _i1336; - for (_i1336 = 0; _i1336 < _size1332; ++_i1336) + 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) { - xfer += iprot->readString(this->success[_i1336]); + xfer += iprot->readString(this->success[_i1332]); } 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 _iter1337; - for (_iter1337 = this->success.begin(); _iter1337 != this->success.end(); ++_iter1337) + std::vector<std::string> ::const_iterator _iter1333; + for (_iter1333 = this->success.begin(); _iter1333 != this->success.end(); ++_iter1333) { - xfer += oprot->writeString((*_iter1337)); + xfer += oprot->writeString((*_iter1333)); } 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 _size1338; - ::apache::thrift::protocol::TType _etype1341; - xfer += iprot->readListBegin(_etype1341, _size1338); - (*(this->success)).resize(_size1338); - uint32_t _i1342; - for (_i1342 = 0; _i1342 < _size1338; ++_i1342) + 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) { - xfer += iprot->readString((*(this->success))[_i1342]); + xfer += iprot->readString((*(this->success))[_i1338]); } 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 _size1343; - ::apache::thrift::protocol::TType _etype1346; - xfer += iprot->readListBegin(_etype1346, _size1343); - this->success.resize(_size1343); - uint32_t _i1347; - for (_i1347 = 0; _i1347 < _size1343; ++_i1347) + 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) { - xfer += iprot->readString(this->success[_i1347]); + xfer += iprot->readString(this->success[_i1343]); } 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 _iter1348; - for (_iter1348 = this->success.begin(); _iter1348 != this->success.end(); ++_iter1348) + std::vector<std::string> ::const_iterator _iter1344; + for (_iter1344 = this->success.begin(); _iter1344 != this->success.end(); ++_iter1344) { - xfer += oprot->writeString((*_iter1348)); + xfer += oprot->writeString((*_iter1344)); } 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 _size1349; - ::apache::thrift::protocol::TType _etype1352; - xfer += iprot->readListBegin(_etype1352, _size1349); - (*(this->success)).resize(_size1349); - uint32_t _i1353; - for (_i1353 = 0; _i1353 < _size1349; ++_i1353) + 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) { - xfer += iprot->readString((*(this->success))[_i1353]); + xfer += iprot->readString((*(this->success))[_i1349]); } 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 _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) + 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) { - xfer += iprot->readString(this->tbl_types[_i1358]); + xfer += iprot->readString(this->tbl_types[_i1354]); } 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 _iter1359; - for (_iter1359 = this->tbl_types.begin(); _iter1359 != this->tbl_types.end(); ++_iter1359) + std::vector<std::string> ::const_iterator _iter1355; + for (_iter1355 = this->tbl_types.begin(); _iter1355 != this->tbl_types.end(); ++_iter1355) { - xfer += oprot->writeString((*_iter1359)); + xfer += oprot->writeString((*_iter1355)); } 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 _iter1360; - for (_iter1360 = (*(this->tbl_types)).begin(); _iter1360 != (*(this->tbl_types)).end(); ++_iter1360) + std::vector<std::string> ::const_iterator _iter1356; + for (_iter1356 = (*(this->tbl_types)).begin(); _iter1356 != (*(this->tbl_types)).end(); ++_iter1356) { - xfer += oprot->writeString((*_iter1360)); + xfer += oprot->writeString((*_iter1356)); } 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 _size1361; - ::apache::thrift::protocol::TType _etype1364; - xfer += iprot->readListBegin(_etype1364, _size1361); - this->success.resize(_size1361); - uint32_t _i1365; - for (_i1365 = 0; _i1365 < _size1361; ++_i1365) + 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) { - xfer += this->success[_i1365].read(iprot); + xfer += this->success[_i1361].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 _iter1366; - for (_iter1366 = this->success.begin(); _iter1366 != this->success.end(); ++_iter1366) + std::vector<TableMeta> ::const_iterator _iter1362; + for (_iter1362 = this->success.begin(); _iter1362 != this->success.end(); ++_iter1362) { - xfer += (*_iter1366).write(oprot); + xfer += (*_iter1362).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 _size1367; - ::apache::thrift::protocol::TType _etype1370; - xfer += iprot->readListBegin(_etype1370, _size1367); - (*(this->success)).resize(_size1367); - uint32_t _i1371; - for (_i1371 = 0; _i1371 < _size1367; ++_i1371) + 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) { - xfer += (*(this->success))[_i1371].read(iprot); + xfer += (*(this->success))[_i1367].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 _size1372; - ::apache::thrift::protocol::TType _etype1375; - xfer += iprot->readListBegin(_etype1375, _size1372); - this->success.resize(_size1372); - uint32_t _i1376; - for (_i1376 = 0; _i1376 < _size1372; ++_i1376) + 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) { - xfer += iprot->readString(this->success[_i1376]); + xfer += iprot->readString(this->success[_i1372]); } 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 _iter1377; - for (_iter1377 = this->success.begin(); _iter1377 != this->success.end(); ++_iter1377) + std::vector<std::string> ::const_iterator _iter1373; + for (_iter1373 = this->success.begin(); _iter1373 != this->success.end(); ++_iter1373) { - xfer += oprot->writeString((*_iter1377)); + xfer += oprot->writeString((*_iter1373)); } 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 _size1378; - ::apache::thrift::protocol::TType _etype1381; - xfer += iprot->readListBegin(_etype1381, _size1378); - (*(this->success)).resize(_size1378); - uint32_t _i1382; - for (_i1382 = 0; _i1382 < _size1378; ++_i1382) + 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) { - xfer += iprot->readString((*(this->success))[_i1382]); + xfer += iprot->readString((*(this->success))[_i1378]); } 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 _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) + 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) { - xfer += iprot->readString(this->tbl_names[_i1387]); + xfer += iprot->readString(this->tbl_names[_i1383]); } 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 _iter1388; - for (_iter1388 = this->tbl_names.begin(); _iter1388 != this->tbl_names.end(); ++_iter1388) + std::vector<std::string> ::const_iterator _iter1384; + for (_iter1384 = this->tbl_names.begin(); _iter1384 != this->tbl_names.end(); ++_iter1384) { - xfer += oprot->writeString((*_iter1388)); + xfer += oprot->writeString((*_iter1384)); } 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 _iter1389; - for (_iter1389 = (*(this->tbl_names)).begin(); _iter1389 != (*(this->tbl_names)).end(); ++_iter1389) + std::vector<std::string> ::const_iterator _iter1385; + for (_iter1385 = (*(this->tbl_names)).begin(); _iter1385 != (*(this->tbl_names)).end(); ++_iter1385) { - xfer += oprot->writeString((*_iter1389)); + xfer += oprot->writeString((*_iter1385)); } 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 _size1390; - ::apache::thrift::protocol::TType _etype1393; - xfer += iprot->readListBegin(_etype1393, _size1390); - this->success.resize(_size1390); - uint32_t _i1394; - for (_i1394 = 0; _i1394 < _size1390; ++_i1394) + 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) { - xfer += this->success[_i1394].read(iprot); + xfer += this->success[_i1390].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 _iter1395; - for (_iter1395 = this->success.begin(); _iter1395 != this->success.end(); ++_iter1395) + std::vector<Table> ::const_iterator _iter1391; + for (_iter1391 = this->success.begin(); _iter1391 != this->success.end(); ++_iter1391) { - xfer += (*_iter1395).write(oprot); + xfer += (*_iter1391).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 _size1396; - ::apache::thrift::protocol::TType _etype1399; - xfer += iprot->readListBegin(_etype1399, _size1396); - (*(this->success)).resize(_size1396); - uint32_t _i1400; - for (_i1400 = 0; _i1400 < _size1396; ++_i1400) + 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) { - xfer += (*(this->success))[_i1400].read(iprot); + xfer += (*(this->success))[_i1396].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 _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) + 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) { - xfer += iprot->readString(this->tbl_names[_i1405]); + xfer += iprot->readString(this->tbl_names[_i1401]); } 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 _iter1406; - for (_iter1406 = this->tbl_names.begin(); _iter1406 != this->tbl_names.end(); ++_iter1406) + std::vector<std::string> ::const_iterator _iter1402; + for (_iter1402 = this->tbl_names.begin(); _iter1402 != this->tbl_names.end(); ++_iter1402) { - xfer += oprot->writeString((*_iter1406)); + xfer += oprot->writeString((*_iter1402)); } 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 _iter1407; - for (_iter1407 = (*(this->tbl_names)).begin(); _iter1407 != (*(this->tbl_names)).end(); ++_iter1407) + std::vector<std::string> ::const_iterator _iter1403; + for (_iter1403 = (*(this->tbl_names)).begin(); _iter1403 != (*(this->tbl_names)).end(); ++_iter1403) { - xfer += oprot->writeString((*_iter1407)); + xfer += oprot->writeString((*_iter1403)); } 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 _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) + 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) { - std::string _key1413; - xfer += iprot->readString(_key1413); - Materialization& _val1414 = this->success[_key1413]; - xfer += _val1414.read(iprot); + std::string _key1409; + xfer += iprot->readString(_key1409); + Materialization& _val1410 = this->success[_key1409]; + xfer += _val1410.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 _iter1415; - for (_iter1415 = this->success.begin(); _iter1415 != this->success.end(); ++_iter1415) + std::map<std::string, Materialization> ::const_iterator _iter1411; + for (_iter1411 = this->success.begin(); _iter1411 != this->success.end(); ++_iter1411) { - xfer += oprot->writeString(_iter1415->first); - xfer += _iter1415->second.write(oprot); + xfer += oprot->writeString(_iter1411->first); + xfer += _iter1411->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 _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) + 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) { - std::string _key1421; - xfer += iprot->readString(_key1421); - Materialization& _val1422 = (*(this->success))[_key1421]; - xfer += _val1422.read(iprot); + std::string _key1417; + xfer += iprot->readString(_key1417); + Materialization& _val1418 = (*(this->success))[_key1417]; + xfer += _val1418.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 _size1423; - ::apache::thrift::protocol::TType _etype1426; - xfer += iprot->readListBegin(_etype1426, _size1423); - this->success.resize(_size1423); - uint32_t _i1427; - for (_i1427 = 0; _i1427 < _size1423; ++_i1427) + 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) { - xfer += iprot->readString(this->success[_i1427]); + xfer += iprot->readString(this->success[_i1423]); } 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 _iter1428; - for (_iter1428 = this->success.begin(); _iter1428 != this->success.end(); ++_iter1428) + std::vector<std::string> ::const_iterator _iter1424; + for (_iter1424 = this->success.begin(); _iter1424 != this->success.end(); ++_iter1424) { - xfer += oprot->writeString((*_iter1428)); + xfer += oprot->writeString((*_iter1424)); } 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 _size1429; - ::apache::thrift::protocol::TType _etype1432; - xfer += iprot->readListBegin(_etype1432, _size1429); - (*(this->success)).resize(_size1429); - uint32_t _i1433; - for (_i1433 = 0; _i1433 < _size1429; ++_i1433) + 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) { - xfer += iprot->readString((*(this->success))[_i1433]); + xfer += iprot->readString((*(this->success))[_i1429]); } 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 _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) + 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) { - xfer += this->new_parts[_i1438].read(iprot); + xfer += this->new_parts[_i1434].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 _iter1439; - for (_iter1439 = this->new_parts.begin(); _iter1439 != this->new_parts.end(); ++_iter1439) + std::vector<Partition> ::const_iterator _iter1435; + for (_iter1435 = this->new_parts.begin(); _iter1435 != this->new_parts.end(); ++_iter1435) { - xfer += (*_iter1439).write(oprot); + xfer += (*_iter1435).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 _iter1440; - for (_iter1440 = (*(this->new_parts)).begin(); _iter1440 != (*(this->new_parts)).end(); ++_iter1440) + std::vector<Partition> ::const_iterator _iter1436; + for (_iter1436 = (*(this->new_parts)).begin(); _iter1436 != (*(this->new_parts)).end(); ++_iter1436) { - xfer += (*_iter1440).write(oprot); + xfer += (*_iter1436).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 _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) + 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) { - xfer += this->new_parts[_i1445].read(iprot); + xfer += this->new_parts[_i1441].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 _iter1446; - for (_iter1446 = this->new_parts.begin(); _iter1446 != this->new_parts.end(); ++_iter1446) + std::vector<PartitionSpec> ::const_iterator _iter1442; + for (_iter1442 = this->new_parts.begin(); _iter1442 != this->new_parts.end(); ++_iter1442) { - xfer += (*_iter1446).write(oprot); + xfer += (*_iter1442).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 _iter1447; - for (_iter1447 = (*(this->new_parts)).begin(); _iter1447 != (*(this->new_parts)).end(); ++_iter1447) + std::vector<PartitionSpec> ::const_iterator _iter1443; + for (_iter1443 = (*(this->new_parts)).begin(); _iter1443 != (*(this->new_parts)).end(); ++_iter1443) { - xfer += (*_iter1447).write(oprot); + xfer += (*_iter1443).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 _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) + 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) { - xfer += iprot->readString(this->part_vals[_i1452]); + xfer += iprot->readString(this->part_vals[_i1448]); } 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 _iter1453; - for (_iter1453 = this->part_vals.begin(); _iter1453 != this->part_vals.end(); ++_iter1453) + std::vector<std::string> ::const_iterator _iter1449; + for (_iter1449 = this->part_vals.begin(); _iter1449 != this->part_vals.end(); ++_iter1449) { - xfer += oprot->writeString((*_iter1453)); + xfer += oprot->writeString((*_iter1449)); } 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 _iter1454; - for (_iter1454 = (*(this->part_vals)).begin(); _iter1454 != (*(this->part_vals)).end(); ++_iter1454) + std::vector<std::string> ::const_iterator _iter1450; + for (_iter1450 = (*(this->part_vals)).begin(); _iter1450 != (*(this->part_vals)).end(); ++_iter1450) { - xfer += oprot->writeString((*_iter1454)); + xfer += oprot->writeString((*_iter1450)); } 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 _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) + 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) { - xfer += iprot->readString(this->part_vals[_i1459]); + xfer += iprot->readString(this->part_vals[_i1455]); } 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 _iter1460; - for (_iter1460 = this->part_vals.begin(); _iter1460 != this->part_vals.end(); ++_iter1460) + std::vector<std::string> ::const_iterator _iter1456; + for (_iter1456 = this->part_vals.begin(); _iter1456 != this->part_vals.end(); ++_iter1456) { - xfer += oprot->writeString((*_iter1460)); + xfer += oprot->writeString((*_iter1456)); } 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 _iter1461; - for (_iter1461 = (*(this->part_vals)).begin(); _iter1461 != (*(this->part_vals)).end(); ++_iter1461) + std::vector<std::string> ::const_iterator _iter1457; + for (_iter1457 = (*(this->part_vals)).begin(); _iter1457 != (*(this->part_vals)).end(); ++_iter1457) { - xfer += oprot->writeString((*_iter1461)); + xfer += oprot->writeString((*_iter1457)); } 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 _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) + 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) { - xfer += iprot->readString(this->part_vals[_i1466]); + xfer += iprot->readString(this->part_vals[_i1462]); } 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 _iter1467; - for (_iter1467 = this->part_vals.begin(); _iter1467 != this->part_vals.end(); ++_iter1467) + std::vector<std::string> ::const_iterator _iter1463; + for (_iter1463 = this->part_vals.begin(); _iter1463 != this->part_vals.end(); ++_iter1463) { - xfer += oprot->writeString((*_iter1467)); + xfer += oprot->writeString((*_iter1463)); } 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 _iter1468; - for (_iter1468 = (*(this->part_vals)).begin(); _iter1468 != (*(this->part_vals)).end(); ++_iter1468) + std::vector<std::string> ::const_iterator _iter1464; + for (_iter1464 = (*(this->part_vals)).begin(); _iter1464 != (*(this->part_vals)).end(); ++_iter1464) { - xfer += oprot->writeString((*_iter1468)); + xfer += oprot->writeString((*_iter1464)); } 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 _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) + 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) { - xfer += iprot->readString(this->part_vals[_i1473]); + xfer += iprot->readString(this->part_vals[_i1469]); } 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 _iter1474; - for (_iter1474 = this->part_vals.begin(); _iter1474 != this->part_vals.end(); ++_iter1474) + std::vector<std::string> ::const_iterator _iter1470; + for (_iter1470 = this->part_vals.begin(); _iter1470 != this->part_vals.end(); ++_iter1470) { - xfer += oprot->writeString((*_iter1474)); + xfer += oprot->writeString((*_iter1470)); } 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 _iter1475; - for (_iter1475 = (*(this->part_vals)).begin(); _iter1475 != (*(this->part_vals)).end(); ++_iter1475) + std::vector<std::string> ::const_iterator _iter1471; + for (_iter1471 = (*(this->part_vals)).begin(); _iter1471 != (*(this->part_vals)).end(); ++_iter1471) { - xfer += oprot->writeString((*_iter1475)); + xfer += oprot->writeString((*_iter1471)); } 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 _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) + 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) { - xfer += iprot->readString(this->part_vals[_i1480]); + xfer += iprot->readString(this->part_vals[_i1476]); } 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 _iter1481; - for (_iter1481 = this->part_vals.begin(); _iter1481 != this->part_vals.end(); ++_iter1481) + std::vector<std::string> ::const_iterator _iter1477; + for (_iter1477 = this->part_vals.begin(); _iter1477 != this->part_vals.end(); ++_iter1477) { - xfer += oprot->writeString((*_iter1481)); + xfer += oprot->writeString((*_iter1477)); } 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 _iter1482; - for (_iter1482 = (*(this->part_vals)).begin(); _iter1482 != (*(this->part_vals)).end(); ++_iter1482) + std::vector<std::string> ::const_iterator _iter1478; + for (_iter1478 = (*(this->part_vals)).begin(); _iter1478 != (*(this->part_vals)).end(); ++_iter1478) { - xfer += oprot->writeString((*_iter1482)); + xfer += oprot->writeString((*_iter1478)); } xfer += oprot->writeListEnd(); }
<TRUNCATED>