http://git-wip-us.apache.org/repos/asf/hive/blob/4c0475ff/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..81ae327 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 _size1199; + ::apache::thrift::protocol::TType _etype1202; + xfer += iprot->readListBegin(_etype1202, _size1199); + this->success.resize(_size1199); + uint32_t _i1203; + for (_i1203 = 0; _i1203 < _size1199; ++_i1203) { - xfer += iprot->readString(this->success[_i1195]); + xfer += iprot->readString(this->success[_i1203]); } 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 _iter1204; + for (_iter1204 = this->success.begin(); _iter1204 != this->success.end(); ++_iter1204) { - xfer += oprot->writeString((*_iter1196)); + xfer += oprot->writeString((*_iter1204)); } 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 _size1205; + ::apache::thrift::protocol::TType _etype1208; + xfer += iprot->readListBegin(_etype1208, _size1205); + (*(this->success)).resize(_size1205); + uint32_t _i1209; + for (_i1209 = 0; _i1209 < _size1205; ++_i1209) { - xfer += iprot->readString((*(this->success))[_i1201]); + xfer += iprot->readString((*(this->success))[_i1209]); } 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 _size1210; + ::apache::thrift::protocol::TType _etype1213; + xfer += iprot->readListBegin(_etype1213, _size1210); + this->success.resize(_size1210); + uint32_t _i1214; + for (_i1214 = 0; _i1214 < _size1210; ++_i1214) { - xfer += iprot->readString(this->success[_i1206]); + xfer += iprot->readString(this->success[_i1214]); } 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 _iter1215; + for (_iter1215 = this->success.begin(); _iter1215 != this->success.end(); ++_iter1215) { - xfer += oprot->writeString((*_iter1207)); + xfer += oprot->writeString((*_iter1215)); } 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 _size1216; + ::apache::thrift::protocol::TType _etype1219; + xfer += iprot->readListBegin(_etype1219, _size1216); + (*(this->success)).resize(_size1216); + uint32_t _i1220; + for (_i1220 = 0; _i1220 < _size1216; ++_i1220) { - xfer += iprot->readString((*(this->success))[_i1212]); + xfer += iprot->readString((*(this->success))[_i1220]); } 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 _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 _key1218; - xfer += iprot->readString(_key1218); - Type& _val1219 = this->success[_key1218]; - xfer += _val1219.read(iprot); + std::string _key1226; + xfer += iprot->readString(_key1226); + Type& _val1227 = this->success[_key1226]; + xfer += _val1227.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 _iter1228; + for (_iter1228 = this->success.begin(); _iter1228 != this->success.end(); ++_iter1228) { - xfer += oprot->writeString(_iter1220->first); - xfer += _iter1220->second.write(oprot); + xfer += oprot->writeString(_iter1228->first); + xfer += _iter1228->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 _size1229; + ::apache::thrift::protocol::TType _ktype1230; + ::apache::thrift::protocol::TType _vtype1231; + xfer += iprot->readMapBegin(_ktype1230, _vtype1231, _size1229); + uint32_t _i1233; + for (_i1233 = 0; _i1233 < _size1229; ++_i1233) { - std::string _key1226; - xfer += iprot->readString(_key1226); - Type& _val1227 = (*(this->success))[_key1226]; - xfer += _val1227.read(iprot); + std::string _key1234; + xfer += iprot->readString(_key1234); + Type& _val1235 = (*(this->success))[_key1234]; + xfer += _val1235.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 _size1236; + ::apache::thrift::protocol::TType _etype1239; + xfer += iprot->readListBegin(_etype1239, _size1236); + this->success.resize(_size1236); + uint32_t _i1240; + for (_i1240 = 0; _i1240 < _size1236; ++_i1240) { - xfer += this->success[_i1232].read(iprot); + xfer += this->success[_i1240].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 _iter1241; + for (_iter1241 = this->success.begin(); _iter1241 != this->success.end(); ++_iter1241) { - xfer += (*_iter1233).write(oprot); + xfer += (*_iter1241).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 _size1242; + ::apache::thrift::protocol::TType _etype1245; + xfer += iprot->readListBegin(_etype1245, _size1242); + (*(this->success)).resize(_size1242); + uint32_t _i1246; + for (_i1246 = 0; _i1246 < _size1242; ++_i1246) { - xfer += (*(this->success))[_i1238].read(iprot); + xfer += (*(this->success))[_i1246].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 _size1247; + ::apache::thrift::protocol::TType _etype1250; + xfer += iprot->readListBegin(_etype1250, _size1247); + this->success.resize(_size1247); + uint32_t _i1251; + for (_i1251 = 0; _i1251 < _size1247; ++_i1251) { - xfer += this->success[_i1243].read(iprot); + xfer += this->success[_i1251].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 _iter1252; + for (_iter1252 = this->success.begin(); _iter1252 != this->success.end(); ++_iter1252) { - xfer += (*_iter1244).write(oprot); + xfer += (*_iter1252).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 _size1253; + ::apache::thrift::protocol::TType _etype1256; + xfer += iprot->readListBegin(_etype1256, _size1253); + (*(this->success)).resize(_size1253); + uint32_t _i1257; + for (_i1257 = 0; _i1257 < _size1253; ++_i1257) { - xfer += (*(this->success))[_i1249].read(iprot); + xfer += (*(this->success))[_i1257].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 _size1258; + ::apache::thrift::protocol::TType _etype1261; + xfer += iprot->readListBegin(_etype1261, _size1258); + this->success.resize(_size1258); + uint32_t _i1262; + for (_i1262 = 0; _i1262 < _size1258; ++_i1262) { - xfer += this->success[_i1254].read(iprot); + xfer += this->success[_i1262].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 _iter1263; + for (_iter1263 = this->success.begin(); _iter1263 != this->success.end(); ++_iter1263) { - xfer += (*_iter1255).write(oprot); + xfer += (*_iter1263).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 _size1264; + ::apache::thrift::protocol::TType _etype1267; + xfer += iprot->readListBegin(_etype1267, _size1264); + (*(this->success)).resize(_size1264); + uint32_t _i1268; + for (_i1268 = 0; _i1268 < _size1264; ++_i1268) { - xfer += (*(this->success))[_i1260].read(iprot); + xfer += (*(this->success))[_i1268].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 _size1269; + ::apache::thrift::protocol::TType _etype1272; + xfer += iprot->readListBegin(_etype1272, _size1269); + this->success.resize(_size1269); + uint32_t _i1273; + for (_i1273 = 0; _i1273 < _size1269; ++_i1273) { - xfer += this->success[_i1265].read(iprot); + xfer += this->success[_i1273].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 _iter1274; + for (_iter1274 = this->success.begin(); _iter1274 != this->success.end(); ++_iter1274) { - xfer += (*_iter1266).write(oprot); + xfer += (*_iter1274).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 _size1275; + ::apache::thrift::protocol::TType _etype1278; + xfer += iprot->readListBegin(_etype1278, _size1275); + (*(this->success)).resize(_size1275); + uint32_t _i1279; + for (_i1279 = 0; _i1279 < _size1275; ++_i1279) { - xfer += (*(this->success))[_i1271].read(iprot); + xfer += (*(this->success))[_i1279].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 _size1280; + ::apache::thrift::protocol::TType _etype1283; + xfer += iprot->readListBegin(_etype1283, _size1280); + this->primaryKeys.resize(_size1280); + uint32_t _i1284; + for (_i1284 = 0; _i1284 < _size1280; ++_i1284) { - xfer += this->primaryKeys[_i1276].read(iprot); + xfer += this->primaryKeys[_i1284].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 _size1285; + ::apache::thrift::protocol::TType _etype1288; + xfer += iprot->readListBegin(_etype1288, _size1285); + this->foreignKeys.resize(_size1285); + uint32_t _i1289; + for (_i1289 = 0; _i1289 < _size1285; ++_i1289) { - xfer += this->foreignKeys[_i1281].read(iprot); + xfer += this->foreignKeys[_i1289].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 _size1290; + ::apache::thrift::protocol::TType _etype1293; + xfer += iprot->readListBegin(_etype1293, _size1290); + this->uniqueConstraints.resize(_size1290); + uint32_t _i1294; + for (_i1294 = 0; _i1294 < _size1290; ++_i1294) { - xfer += this->uniqueConstraints[_i1286].read(iprot); + xfer += this->uniqueConstraints[_i1294].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 _size1295; + ::apache::thrift::protocol::TType _etype1298; + xfer += iprot->readListBegin(_etype1298, _size1295); + this->notNullConstraints.resize(_size1295); + uint32_t _i1299; + for (_i1299 = 0; _i1299 < _size1295; ++_i1299) { - xfer += this->notNullConstraints[_i1291].read(iprot); + xfer += this->notNullConstraints[_i1299].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 _size1300; + ::apache::thrift::protocol::TType _etype1303; + xfer += iprot->readListBegin(_etype1303, _size1300); + this->defaultConstraints.resize(_size1300); + uint32_t _i1304; + for (_i1304 = 0; _i1304 < _size1300; ++_i1304) { - xfer += this->defaultConstraints[_i1296].read(iprot); + xfer += this->defaultConstraints[_i1304].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 _size1305; + ::apache::thrift::protocol::TType _etype1308; + xfer += iprot->readListBegin(_etype1308, _size1305); + this->checkConstraints.resize(_size1305); + uint32_t _i1309; + for (_i1309 = 0; _i1309 < _size1305; ++_i1309) { - xfer += this->checkConstraints[_i1301].read(iprot); + xfer += this->checkConstraints[_i1309].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 _iter1310; + for (_iter1310 = this->primaryKeys.begin(); _iter1310 != this->primaryKeys.end(); ++_iter1310) { - xfer += (*_iter1302).write(oprot); + xfer += (*_iter1310).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 _iter1311; + for (_iter1311 = this->foreignKeys.begin(); _iter1311 != this->foreignKeys.end(); ++_iter1311) { - xfer += (*_iter1303).write(oprot); + xfer += (*_iter1311).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 _iter1312; + for (_iter1312 = this->uniqueConstraints.begin(); _iter1312 != this->uniqueConstraints.end(); ++_iter1312) { - xfer += (*_iter1304).write(oprot); + xfer += (*_iter1312).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 _iter1313; + for (_iter1313 = this->notNullConstraints.begin(); _iter1313 != this->notNullConstraints.end(); ++_iter1313) { - xfer += (*_iter1305).write(oprot); + xfer += (*_iter1313).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 _iter1314; + for (_iter1314 = this->defaultConstraints.begin(); _iter1314 != this->defaultConstraints.end(); ++_iter1314) { - xfer += (*_iter1306).write(oprot); + xfer += (*_iter1314).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 _iter1315; + for (_iter1315 = this->checkConstraints.begin(); _iter1315 != this->checkConstraints.end(); ++_iter1315) { - xfer += (*_iter1307).write(oprot); + xfer += (*_iter1315).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 _iter1316; + for (_iter1316 = (*(this->primaryKeys)).begin(); _iter1316 != (*(this->primaryKeys)).end(); ++_iter1316) { - xfer += (*_iter1308).write(oprot); + xfer += (*_iter1316).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 _iter1317; + for (_iter1317 = (*(this->foreignKeys)).begin(); _iter1317 != (*(this->foreignKeys)).end(); ++_iter1317) { - xfer += (*_iter1309).write(oprot); + xfer += (*_iter1317).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 _iter1318; + for (_iter1318 = (*(this->uniqueConstraints)).begin(); _iter1318 != (*(this->uniqueConstraints)).end(); ++_iter1318) { - xfer += (*_iter1310).write(oprot); + xfer += (*_iter1318).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 _iter1319; + for (_iter1319 = (*(this->notNullConstraints)).begin(); _iter1319 != (*(this->notNullConstraints)).end(); ++_iter1319) { - xfer += (*_iter1311).write(oprot); + xfer += (*_iter1319).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 _iter1320; + for (_iter1320 = (*(this->defaultConstraints)).begin(); _iter1320 != (*(this->defaultConstraints)).end(); ++_iter1320) { - xfer += (*_iter1312).write(oprot); + xfer += (*_iter1320).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 _iter1321; + for (_iter1321 = (*(this->checkConstraints)).begin(); _iter1321 != (*(this->checkConstraints)).end(); ++_iter1321) { - xfer += (*_iter1313).write(oprot); + xfer += (*_iter1321).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 _size1322; + ::apache::thrift::protocol::TType _etype1325; + xfer += iprot->readListBegin(_etype1325, _size1322); + this->partNames.resize(_size1322); + uint32_t _i1326; + for (_i1326 = 0; _i1326 < _size1322; ++_i1326) { - xfer += iprot->readString(this->partNames[_i1318]); + xfer += iprot->readString(this->partNames[_i1326]); } 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 _iter1327; + for (_iter1327 = this->partNames.begin(); _iter1327 != this->partNames.end(); ++_iter1327) { - xfer += oprot->writeString((*_iter1319)); + xfer += oprot->writeString((*_iter1327)); } 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 _iter1328; + for (_iter1328 = (*(this->partNames)).begin(); _iter1328 != (*(this->partNames)).end(); ++_iter1328) { - xfer += oprot->writeString((*_iter1320)); + xfer += oprot->writeString((*_iter1328)); } 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 _size1329; + ::apache::thrift::protocol::TType _etype1332; + xfer += iprot->readListBegin(_etype1332, _size1329); + this->success.resize(_size1329); + uint32_t _i1333; + for (_i1333 = 0; _i1333 < _size1329; ++_i1333) { - xfer += iprot->readString(this->success[_i1325]); + xfer += iprot->readString(this->success[_i1333]); } 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 _iter1334; + for (_iter1334 = this->success.begin(); _iter1334 != this->success.end(); ++_iter1334) { - xfer += oprot->writeString((*_iter1326)); + xfer += oprot->writeString((*_iter1334)); } 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 _size1335; + ::apache::thrift::protocol::TType _etype1338; + xfer += iprot->readListBegin(_etype1338, _size1335); + (*(this->success)).resize(_size1335); + uint32_t _i1339; + for (_i1339 = 0; _i1339 < _size1335; ++_i1339) { - xfer += iprot->readString((*(this->success))[_i1331]); + xfer += iprot->readString((*(this->success))[_i1339]); } 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 _size1340; + ::apache::thrift::protocol::TType _etype1343; + xfer += iprot->readListBegin(_etype1343, _size1340); + this->success.resize(_size1340); + uint32_t _i1344; + for (_i1344 = 0; _i1344 < _size1340; ++_i1344) { - xfer += iprot->readString(this->success[_i1336]); + xfer += iprot->readString(this->success[_i1344]); } 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 _iter1345; + for (_iter1345 = this->success.begin(); _iter1345 != this->success.end(); ++_iter1345) { - xfer += oprot->writeString((*_iter1337)); + xfer += oprot->writeString((*_iter1345)); } 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 _size1346; + ::apache::thrift::protocol::TType _etype1349; + xfer += iprot->readListBegin(_etype1349, _size1346); + (*(this->success)).resize(_size1346); + uint32_t _i1350; + for (_i1350 = 0; _i1350 < _size1346; ++_i1350) { - xfer += iprot->readString((*(this->success))[_i1342]); + xfer += iprot->readString((*(this->success))[_i1350]); } 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 _size1351; + ::apache::thrift::protocol::TType _etype1354; + xfer += iprot->readListBegin(_etype1354, _size1351); + this->success.resize(_size1351); + uint32_t _i1355; + for (_i1355 = 0; _i1355 < _size1351; ++_i1355) { - xfer += iprot->readString(this->success[_i1347]); + xfer += iprot->readString(this->success[_i1355]); } 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 _iter1356; + for (_iter1356 = this->success.begin(); _iter1356 != this->success.end(); ++_iter1356) { - xfer += oprot->writeString((*_iter1348)); + xfer += oprot->writeString((*_iter1356)); } 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 _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 += iprot->readString((*(this->success))[_i1353]); + xfer += iprot->readString((*(this->success))[_i1361]); } 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 _size1362; + ::apache::thrift::protocol::TType _etype1365; + xfer += iprot->readListBegin(_etype1365, _size1362); + this->tbl_types.resize(_size1362); + uint32_t _i1366; + for (_i1366 = 0; _i1366 < _size1362; ++_i1366) { - xfer += iprot->readString(this->tbl_types[_i1358]); + xfer += iprot->readString(this->tbl_types[_i1366]); } 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 _iter1367; + for (_iter1367 = this->tbl_types.begin(); _iter1367 != this->tbl_types.end(); ++_iter1367) { - xfer += oprot->writeString((*_iter1359)); + xfer += oprot->writeString((*_iter1367)); } 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 _iter1368; + for (_iter1368 = (*(this->tbl_types)).begin(); _iter1368 != (*(this->tbl_types)).end(); ++_iter1368) { - xfer += oprot->writeString((*_iter1360)); + xfer += oprot->writeString((*_iter1368)); } 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 _size1369; + ::apache::thrift::protocol::TType _etype1372; + xfer += iprot->readListBegin(_etype1372, _size1369); + this->success.resize(_size1369); + uint32_t _i1373; + for (_i1373 = 0; _i1373 < _size1369; ++_i1373) { - xfer += this->success[_i1365].read(iprot); + xfer += this->success[_i1373].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 _iter1374; + for (_iter1374 = this->success.begin(); _iter1374 != this->success.end(); ++_iter1374) { - xfer += (*_iter1366).write(oprot); + xfer += (*_iter1374).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 _size1375; + ::apache::thrift::protocol::TType _etype1378; + xfer += iprot->readListBegin(_etype1378, _size1375); + (*(this->success)).resize(_size1375); + uint32_t _i1379; + for (_i1379 = 0; _i1379 < _size1375; ++_i1379) { - xfer += (*(this->success))[_i1371].read(iprot); + xfer += (*(this->success))[_i1379].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 _size1380; + ::apache::thrift::protocol::TType _etype1383; + xfer += iprot->readListBegin(_etype1383, _size1380); + this->success.resize(_size1380); + uint32_t _i1384; + for (_i1384 = 0; _i1384 < _size1380; ++_i1384) { - xfer += iprot->readString(this->success[_i1376]); + xfer += iprot->readString(this->success[_i1384]); } 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 _iter1385; + for (_iter1385 = this->success.begin(); _iter1385 != this->success.end(); ++_iter1385) { - xfer += oprot->writeString((*_iter1377)); + xfer += oprot->writeString((*_iter1385)); } 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 _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 += iprot->readString((*(this->success))[_i1382]); + xfer += iprot->readString((*(this->success))[_i1390]); } 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 _size1391; + ::apache::thrift::protocol::TType _etype1394; + xfer += iprot->readListBegin(_etype1394, _size1391); + this->tbl_names.resize(_size1391); + uint32_t _i1395; + for (_i1395 = 0; _i1395 < _size1391; ++_i1395) { - xfer += iprot->readString(this->tbl_names[_i1387]); + xfer += iprot->readString(this->tbl_names[_i1395]); } 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 _iter1396; + for (_iter1396 = this->tbl_names.begin(); _iter1396 != this->tbl_names.end(); ++_iter1396) { - xfer += oprot->writeString((*_iter1388)); + xfer += oprot->writeString((*_iter1396)); } 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 _iter1397; + for (_iter1397 = (*(this->tbl_names)).begin(); _iter1397 != (*(this->tbl_names)).end(); ++_iter1397) { - xfer += oprot->writeString((*_iter1389)); + xfer += oprot->writeString((*_iter1397)); } 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 _size1398; + ::apache::thrift::protocol::TType _etype1401; + xfer += iprot->readListBegin(_etype1401, _size1398); + this->success.resize(_size1398); + uint32_t _i1402; + for (_i1402 = 0; _i1402 < _size1398; ++_i1402) { - xfer += this->success[_i1394].read(iprot); + xfer += this->success[_i1402].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 _iter1403; + for (_iter1403 = this->success.begin(); _iter1403 != this->success.end(); ++_iter1403) { - xfer += (*_iter1395).write(oprot); + xfer += (*_iter1403).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 _size1404; + ::apache::thrift::protocol::TType _etype1407; + xfer += iprot->readListBegin(_etype1407, _size1404); + (*(this->success)).resize(_size1404); + uint32_t _i1408; + for (_i1408 = 0; _i1408 < _size1404; ++_i1408) { - xfer += (*(this->success))[_i1400].read(iprot); + xfer += (*(this->success))[_i1408].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 _size1409; + ::apache::thrift::protocol::TType _etype1412; + xfer += iprot->readListBegin(_etype1412, _size1409); + this->tbl_names.resize(_size1409); + uint32_t _i1413; + for (_i1413 = 0; _i1413 < _size1409; ++_i1413) { - xfer += iprot->readString(this->tbl_names[_i1405]); + xfer += iprot->readString(this->tbl_names[_i1413]); } 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 _iter1414; + for (_iter1414 = this->tbl_names.begin(); _iter1414 != this->tbl_names.end(); ++_iter1414) { - xfer += oprot->writeString((*_iter1406)); + xfer += oprot->writeString((*_iter1414)); } 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 _iter1415; + for (_iter1415 = (*(this->tbl_names)).begin(); _iter1415 != (*(this->tbl_names)).end(); ++_iter1415) { - xfer += oprot->writeString((*_iter1407)); + xfer += oprot->writeString((*_iter1415)); } 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 _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 _key1413; - xfer += iprot->readString(_key1413); - Materialization& _val1414 = this->success[_key1413]; - xfer += _val1414.read(iprot); + std::string _key1421; + xfer += iprot->readString(_key1421); + Materialization& _val1422 = this->success[_key1421]; + xfer += _val1422.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 _iter1423; + for (_iter1423 = this->success.begin(); _iter1423 != this->success.end(); ++_iter1423) { - xfer += oprot->writeString(_iter1415->first); - xfer += _iter1415->second.write(oprot); + xfer += oprot->writeString(_iter1423->first); + xfer += _iter1423->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 _size1424; + ::apache::thrift::protocol::TType _ktype1425; + ::apache::thrift::protocol::TType _vtype1426; + xfer += iprot->readMapBegin(_ktype1425, _vtype1426, _size1424); + uint32_t _i1428; + for (_i1428 = 0; _i1428 < _size1424; ++_i1428) { - std::string _key1421; - xfer += iprot->readString(_key1421); - Materialization& _val1422 = (*(this->success))[_key1421]; - xfer += _val1422.read(iprot); + std::string _key1429; + xfer += iprot->readString(_key1429); + Materialization& _val1430 = (*(this->success))[_key1429]; + xfer += _val1430.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 _size1431; + ::apache::thrift::protocol::TType _etype1434; + xfer += iprot->readListBegin(_etype1434, _size1431); + this->success.resize(_size1431); + uint32_t _i1435; + for (_i1435 = 0; _i1435 < _size1431; ++_i1435) { - xfer += iprot->readString(this->success[_i1427]); + xfer += iprot->readString(this->success[_i1435]); } 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 _iter1436; + for (_iter1436 = this->success.begin(); _iter1436 != this->success.end(); ++_iter1436) { - xfer += oprot->writeString((*_iter1428)); + xfer += oprot->writeString((*_iter1436)); } 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 _size1437; + ::apache::thrift::protocol::TType _etype1440; + xfer += iprot->readListBegin(_etype1440, _size1437); + (*(this->success)).resize(_size1437); + uint32_t _i1441; + for (_i1441 = 0; _i1441 < _size1437; ++_i1441) { - xfer += iprot->readString((*(this->success))[_i1433]); + xfer += iprot->readString((*(this->success))[_i1441]); } 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 _size1442; + ::apache::thrift::protocol::TType _etype1445; + xfer += iprot->readListBegin(_etype1445, _size1442); + this->new_parts.resize(_size1442); + uint32_t _i1446; + for (_i1446 = 0; _i1446 < _size1442; ++_i1446) { - xfer += this->new_parts[_i1438].read(iprot); + xfer += this->new_parts[_i1446].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 _iter1447; + for (_iter1447 = this->new_parts.begin(); _iter1447 != this->new_parts.end(); ++_iter1447) { - xfer += (*_iter1439).write(oprot); + xfer += (*_iter1447).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 _iter1448; + for (_iter1448 = (*(this->new_parts)).begin(); _iter1448 != (*(this->new_parts)).end(); ++_iter1448) { - xfer += (*_iter1440).write(oprot); + xfer += (*_iter1448).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 _size1449; + ::apache::thrift::protocol::TType _etype1452; + xfer += iprot->readListBegin(_etype1452, _size1449); + this->new_parts.resize(_size1449); + uint32_t _i1453; + for (_i1453 = 0; _i1453 < _size1449; ++_i1453) { - xfer += this->new_parts[_i1445].read(iprot); + xfer += this->new_parts[_i1453].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 _iter1454; + for (_iter1454 = this->new_parts.begin(); _iter1454 != this->new_parts.end(); ++_iter1454) { - xfer += (*_iter1446).write(oprot); + xfer += (*_iter1454).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 _iter1455; + for (_iter1455 = (*(this->new_parts)).begin(); _iter1455 != (*(this->new_parts)).end(); ++_iter1455) { - xfer += (*_iter1447).write(oprot); + xfer += (*_iter1455).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 _size1456; + ::apache::thrift::protocol::TType _etype1459; + xfer += iprot->readListBegin(_etype1459, _size1456); + this->part_vals.resize(_size1456); + uint32_t _i1460; + for (_i1460 = 0; _i1460 < _size1456; ++_i1460) { - xfer += iprot->readString(this->part_vals[_i1452]); + xfer += iprot->readString(this->part_vals[_i1460]); } 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 _iter1461; + for (_iter1461 = this->part_vals.begin(); _iter1461 != this->part_vals.end(); ++_iter1461) { - xfer += oprot->writeString((*_iter1453)); + xfer += oprot->writeString((*_iter1461)); } 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 _iter1462; + for (_iter1462 = (*(this->part_vals)).begin(); _iter1462 != (*(this->part_vals)).end(); ++_iter1462) { - xfer += oprot->writeString((*_iter1454)); + xfer += oprot->writeString((*_iter1462)); } 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 _size1463; + ::apache::thrift::protocol::TType _etype1466; + xfer += iprot->readListBegin(_etype1466, _size1463); + this->part_vals.resize(_size1463); + uint32_t _i1467; + for (_i1467 = 0; _i1467 < _size1463; ++_i1467) { - xfer += iprot->readString(this->part_vals[_i1459]); + xfer += iprot->readString(this->part_vals[_i1467]); } 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 _iter1468; + for (_iter1468 = this->part_vals.begin(); _iter1468 != this->part_vals.end(); ++_iter1468) { - xfer += oprot->writeString((*_iter1460)); + xfer += oprot->writeString((*_iter1468)); } 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 _iter1469; + for (_iter1469 = (*(this->part_vals)).begin(); _iter1469 != (*(this->part_vals)).end(); ++_iter1469) { - xfer += oprot->writeString((*_iter1461)); + xfer += oprot->writeString((*_iter1469)); } 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 _size1470; + ::apache::thrift::protocol::TType _etype1473; + xfer += iprot->readListBegin(_etype1473, _size1470); + this->part_vals.resize(_size1470); + uint32_t _i1474; + for (_i1474 = 0; _i1474 < _size1470; ++_i1474) { - xfer += iprot->readString(this->part_vals[_i1466]); + xfer += iprot->readString(this->part_vals[_i1474]); } 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 _iter1475; + for (_iter1475 = this->part_vals.begin(); _iter1475 != this->part_vals.end(); ++_iter1475) { - xfer += oprot->writeString((*_iter1467)); + xfer += oprot->writeString((*_iter1475)); } 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 _iter1476; + for (_iter1476 = (*(this->part_vals)).begin(); _iter1476 != (*(this->part_vals)).end(); ++_iter1476) { - xfer += oprot->writeString((*_iter1468)); + xfer += oprot->writeString((*_iter1476)); } 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 _size1477; + ::apache::thrift::protocol::TType _etype1480; + xfer += iprot->readListBegin(_etype1480, _size1477); + this->part_vals.resize(_size1477); + uint32_t _i1481; + for (_i1481 = 0; _i1481 < _size1477; ++_i1481) { - xfer += iprot->readString(this->part_vals[_i1473]); + xfer += iprot->readString(this->part_vals[_i1481]); } 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 _iter1482; + for (_iter1482 = this->part_vals.begin(); _iter1482 != this->part_vals.end(); ++_iter1482) { - xfer += oprot->writeString((*_iter1474)); + xfer += oprot->writeString((*_iter1482)); } 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 _iter1483; + for (_iter1483 = (*(this->part_vals)).begin(); _iter1483 != (*(this->part_vals)).end(); ++_iter1483) { - xfer += oprot->writeString((*_iter1475)); + xfer += oprot->writeString((*_iter1483)); } 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 _size1484; + ::apache::thrift::protocol::TType _etype1487; + xfer += iprot->readListBegin(_etype1487, _size1484); + this->part_vals.resize(_size1484); + uint32_t _i1488; + for (_i1488 = 0; _i1488 < _size1484; ++_i1488) { - xfer += iprot->readString(this->part_vals[_i1480]); + xfer += iprot->readString(this->part_vals[_i1488]); } 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 _iter1489; + for (_iter1489 = this->part_vals.begin(); _iter1489 != this->part_vals.end(); ++_iter1489) { - xfer += oprot->writeString((*_iter1481)); + xfer += oprot->writeString((*_iter1489)); } 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 _iter1490; + for (_iter1490 = (*(this->part_vals)).begin(); _iter1490 != (*(this->part_vals)).end(); ++_iter1490) { - xfer += oprot->writeString((*_iter1482)); + xfer += oprot->writeString((*_iter1490)); } xfer += oprot->writeListEnd(); }
<TRUNCATED>