http://git-wip-us.apache.org/repos/asf/hive/blob/1d46608e/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 e459bc2..7a81dfb 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -2334,14 +2334,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc 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 _size1221; + ::apache::thrift::protocol::TType _etype1224; + xfer += iprot->readListBegin(_etype1224, _size1221); + this->success.resize(_size1221); + uint32_t _i1225; + for (_i1225 = 0; _i1225 < _size1221; ++_i1225) { - xfer += iprot->readString(this->success[_i1206]); + xfer += iprot->readString(this->success[_i1225]); } xfer += iprot->readListEnd(); } @@ -2380,10 +2380,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 _iter1207; - for (_iter1207 = this->success.begin(); _iter1207 != this->success.end(); ++_iter1207) + std::vector<std::string> ::const_iterator _iter1226; + for (_iter1226 = this->success.begin(); _iter1226 != this->success.end(); ++_iter1226) { - xfer += oprot->writeString((*_iter1207)); + xfer += oprot->writeString((*_iter1226)); } xfer += oprot->writeListEnd(); } @@ -2428,14 +2428,14 @@ uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::proto 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 _size1227; + ::apache::thrift::protocol::TType _etype1230; + xfer += iprot->readListBegin(_etype1230, _size1227); + (*(this->success)).resize(_size1227); + uint32_t _i1231; + for (_i1231 = 0; _i1231 < _size1227; ++_i1231) { - xfer += iprot->readString((*(this->success))[_i1212]); + xfer += iprot->readString((*(this->success))[_i1231]); } xfer += iprot->readListEnd(); } @@ -2552,14 +2552,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1213; - ::apache::thrift::protocol::TType _etype1216; - xfer += iprot->readListBegin(_etype1216, _size1213); - this->success.resize(_size1213); - uint32_t _i1217; - for (_i1217 = 0; _i1217 < _size1213; ++_i1217) + uint32_t _size1232; + ::apache::thrift::protocol::TType _etype1235; + xfer += iprot->readListBegin(_etype1235, _size1232); + this->success.resize(_size1232); + uint32_t _i1236; + for (_i1236 = 0; _i1236 < _size1232; ++_i1236) { - xfer += iprot->readString(this->success[_i1217]); + xfer += iprot->readString(this->success[_i1236]); } xfer += iprot->readListEnd(); } @@ -2598,10 +2598,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 _iter1218; - for (_iter1218 = this->success.begin(); _iter1218 != this->success.end(); ++_iter1218) + std::vector<std::string> ::const_iterator _iter1237; + for (_iter1237 = this->success.begin(); _iter1237 != this->success.end(); ++_iter1237) { - xfer += oprot->writeString((*_iter1218)); + xfer += oprot->writeString((*_iter1237)); } xfer += oprot->writeListEnd(); } @@ -2646,14 +2646,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1219; - ::apache::thrift::protocol::TType _etype1222; - xfer += iprot->readListBegin(_etype1222, _size1219); - (*(this->success)).resize(_size1219); - uint32_t _i1223; - for (_i1223 = 0; _i1223 < _size1219; ++_i1223) + uint32_t _size1238; + ::apache::thrift::protocol::TType _etype1241; + xfer += iprot->readListBegin(_etype1241, _size1238); + (*(this->success)).resize(_size1238); + uint32_t _i1242; + for (_i1242 = 0; _i1242 < _size1238; ++_i1242) { - xfer += iprot->readString((*(this->success))[_i1223]); + xfer += iprot->readString((*(this->success))[_i1242]); } xfer += iprot->readListEnd(); } @@ -3715,17 +3715,17 @@ uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1224; - ::apache::thrift::protocol::TType _ktype1225; - ::apache::thrift::protocol::TType _vtype1226; - xfer += iprot->readMapBegin(_ktype1225, _vtype1226, _size1224); - uint32_t _i1228; - for (_i1228 = 0; _i1228 < _size1224; ++_i1228) + uint32_t _size1243; + ::apache::thrift::protocol::TType _ktype1244; + ::apache::thrift::protocol::TType _vtype1245; + xfer += iprot->readMapBegin(_ktype1244, _vtype1245, _size1243); + uint32_t _i1247; + for (_i1247 = 0; _i1247 < _size1243; ++_i1247) { - std::string _key1229; - xfer += iprot->readString(_key1229); - Type& _val1230 = this->success[_key1229]; - xfer += _val1230.read(iprot); + std::string _key1248; + xfer += iprot->readString(_key1248); + Type& _val1249 = this->success[_key1248]; + xfer += _val1249.read(iprot); } xfer += iprot->readMapEnd(); } @@ -3764,11 +3764,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 _iter1231; - for (_iter1231 = this->success.begin(); _iter1231 != this->success.end(); ++_iter1231) + std::map<std::string, Type> ::const_iterator _iter1250; + for (_iter1250 = this->success.begin(); _iter1250 != this->success.end(); ++_iter1250) { - xfer += oprot->writeString(_iter1231->first); - xfer += _iter1231->second.write(oprot); + xfer += oprot->writeString(_iter1250->first); + xfer += _iter1250->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -3813,17 +3813,17 @@ uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1232; - ::apache::thrift::protocol::TType _ktype1233; - ::apache::thrift::protocol::TType _vtype1234; - xfer += iprot->readMapBegin(_ktype1233, _vtype1234, _size1232); - uint32_t _i1236; - for (_i1236 = 0; _i1236 < _size1232; ++_i1236) + uint32_t _size1251; + ::apache::thrift::protocol::TType _ktype1252; + ::apache::thrift::protocol::TType _vtype1253; + xfer += iprot->readMapBegin(_ktype1252, _vtype1253, _size1251); + uint32_t _i1255; + for (_i1255 = 0; _i1255 < _size1251; ++_i1255) { - std::string _key1237; - xfer += iprot->readString(_key1237); - Type& _val1238 = (*(this->success))[_key1237]; - xfer += _val1238.read(iprot); + std::string _key1256; + xfer += iprot->readString(_key1256); + Type& _val1257 = (*(this->success))[_key1256]; + xfer += _val1257.read(iprot); } xfer += iprot->readMapEnd(); } @@ -3977,14 +3977,14 @@ uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol: 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 _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[_i1243].read(iprot); + xfer += this->success[_i1262].read(iprot); } xfer += iprot->readListEnd(); } @@ -4039,10 +4039,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 _iter1244; - for (_iter1244 = this->success.begin(); _iter1244 != this->success.end(); ++_iter1244) + std::vector<FieldSchema> ::const_iterator _iter1263; + for (_iter1263 = this->success.begin(); _iter1263 != this->success.end(); ++_iter1263) { - xfer += (*_iter1244).write(oprot); + xfer += (*_iter1263).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4095,14 +4095,14 @@ uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol 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 _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))[_i1249].read(iprot); + xfer += (*(this->success))[_i1268].read(iprot); } xfer += iprot->readListEnd(); } @@ -4288,14 +4288,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(:: 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 _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[_i1254].read(iprot); + xfer += this->success[_i1273].read(iprot); } xfer += iprot->readListEnd(); } @@ -4350,10 +4350,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 _iter1255; - for (_iter1255 = this->success.begin(); _iter1255 != this->success.end(); ++_iter1255) + std::vector<FieldSchema> ::const_iterator _iter1274; + for (_iter1274 = this->success.begin(); _iter1274 != this->success.end(); ++_iter1274) { - xfer += (*_iter1255).write(oprot); + xfer += (*_iter1274).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4406,14 +4406,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1256; - ::apache::thrift::protocol::TType _etype1259; - xfer += iprot->readListBegin(_etype1259, _size1256); - (*(this->success)).resize(_size1256); - uint32_t _i1260; - for (_i1260 = 0; _i1260 < _size1256; ++_i1260) + uint32_t _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))[_i1260].read(iprot); + xfer += (*(this->success))[_i1279].read(iprot); } xfer += iprot->readListEnd(); } @@ -4583,14 +4583,14 @@ uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol: 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 _size1280; + ::apache::thrift::protocol::TType _etype1283; + xfer += iprot->readListBegin(_etype1283, _size1280); + this->success.resize(_size1280); + uint32_t _i1284; + for (_i1284 = 0; _i1284 < _size1280; ++_i1284) { - xfer += this->success[_i1265].read(iprot); + xfer += this->success[_i1284].read(iprot); } xfer += iprot->readListEnd(); } @@ -4645,10 +4645,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 _iter1266; - for (_iter1266 = this->success.begin(); _iter1266 != this->success.end(); ++_iter1266) + std::vector<FieldSchema> ::const_iterator _iter1285; + for (_iter1285 = this->success.begin(); _iter1285 != this->success.end(); ++_iter1285) { - xfer += (*_iter1266).write(oprot); + xfer += (*_iter1285).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4701,14 +4701,14 @@ uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol 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 _size1286; + ::apache::thrift::protocol::TType _etype1289; + xfer += iprot->readListBegin(_etype1289, _size1286); + (*(this->success)).resize(_size1286); + uint32_t _i1290; + for (_i1290 = 0; _i1290 < _size1286; ++_i1290) { - xfer += (*(this->success))[_i1271].read(iprot); + xfer += (*(this->success))[_i1290].read(iprot); } xfer += iprot->readListEnd(); } @@ -4894,14 +4894,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1272; - ::apache::thrift::protocol::TType _etype1275; - xfer += iprot->readListBegin(_etype1275, _size1272); - this->success.resize(_size1272); - uint32_t _i1276; - for (_i1276 = 0; _i1276 < _size1272; ++_i1276) + uint32_t _size1291; + ::apache::thrift::protocol::TType _etype1294; + xfer += iprot->readListBegin(_etype1294, _size1291); + this->success.resize(_size1291); + uint32_t _i1295; + for (_i1295 = 0; _i1295 < _size1291; ++_i1295) { - xfer += this->success[_i1276].read(iprot); + xfer += this->success[_i1295].read(iprot); } xfer += iprot->readListEnd(); } @@ -4956,10 +4956,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 _iter1277; - for (_iter1277 = this->success.begin(); _iter1277 != this->success.end(); ++_iter1277) + std::vector<FieldSchema> ::const_iterator _iter1296; + for (_iter1296 = this->success.begin(); _iter1296 != this->success.end(); ++_iter1296) { - xfer += (*_iter1277).write(oprot); + xfer += (*_iter1296).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5012,14 +5012,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1278; - ::apache::thrift::protocol::TType _etype1281; - xfer += iprot->readListBegin(_etype1281, _size1278); - (*(this->success)).resize(_size1278); - uint32_t _i1282; - for (_i1282 = 0; _i1282 < _size1278; ++_i1282) + uint32_t _size1297; + ::apache::thrift::protocol::TType _etype1300; + xfer += iprot->readListBegin(_etype1300, _size1297); + (*(this->success)).resize(_size1297); + uint32_t _i1301; + for (_i1301 = 0; _i1301 < _size1297; ++_i1301) { - xfer += (*(this->success))[_i1282].read(iprot); + xfer += (*(this->success))[_i1301].read(iprot); } xfer += iprot->readListEnd(); } @@ -5612,14 +5612,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size1283; - ::apache::thrift::protocol::TType _etype1286; - xfer += iprot->readListBegin(_etype1286, _size1283); - this->primaryKeys.resize(_size1283); - uint32_t _i1287; - for (_i1287 = 0; _i1287 < _size1283; ++_i1287) + uint32_t _size1302; + ::apache::thrift::protocol::TType _etype1305; + xfer += iprot->readListBegin(_etype1305, _size1302); + this->primaryKeys.resize(_size1302); + uint32_t _i1306; + for (_i1306 = 0; _i1306 < _size1302; ++_i1306) { - xfer += this->primaryKeys[_i1287].read(iprot); + xfer += this->primaryKeys[_i1306].read(iprot); } xfer += iprot->readListEnd(); } @@ -5632,14 +5632,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size1288; - ::apache::thrift::protocol::TType _etype1291; - xfer += iprot->readListBegin(_etype1291, _size1288); - this->foreignKeys.resize(_size1288); - uint32_t _i1292; - for (_i1292 = 0; _i1292 < _size1288; ++_i1292) + uint32_t _size1307; + ::apache::thrift::protocol::TType _etype1310; + xfer += iprot->readListBegin(_etype1310, _size1307); + this->foreignKeys.resize(_size1307); + uint32_t _i1311; + for (_i1311 = 0; _i1311 < _size1307; ++_i1311) { - xfer += this->foreignKeys[_i1292].read(iprot); + xfer += this->foreignKeys[_i1311].read(iprot); } xfer += iprot->readListEnd(); } @@ -5652,14 +5652,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size1293; - ::apache::thrift::protocol::TType _etype1296; - xfer += iprot->readListBegin(_etype1296, _size1293); - this->uniqueConstraints.resize(_size1293); - uint32_t _i1297; - for (_i1297 = 0; _i1297 < _size1293; ++_i1297) + uint32_t _size1312; + ::apache::thrift::protocol::TType _etype1315; + xfer += iprot->readListBegin(_etype1315, _size1312); + this->uniqueConstraints.resize(_size1312); + uint32_t _i1316; + for (_i1316 = 0; _i1316 < _size1312; ++_i1316) { - xfer += this->uniqueConstraints[_i1297].read(iprot); + xfer += this->uniqueConstraints[_i1316].read(iprot); } xfer += iprot->readListEnd(); } @@ -5672,14 +5672,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size1298; - ::apache::thrift::protocol::TType _etype1301; - xfer += iprot->readListBegin(_etype1301, _size1298); - this->notNullConstraints.resize(_size1298); - uint32_t _i1302; - for (_i1302 = 0; _i1302 < _size1298; ++_i1302) + uint32_t _size1317; + ::apache::thrift::protocol::TType _etype1320; + xfer += iprot->readListBegin(_etype1320, _size1317); + this->notNullConstraints.resize(_size1317); + uint32_t _i1321; + for (_i1321 = 0; _i1321 < _size1317; ++_i1321) { - xfer += this->notNullConstraints[_i1302].read(iprot); + xfer += this->notNullConstraints[_i1321].read(iprot); } xfer += iprot->readListEnd(); } @@ -5692,14 +5692,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->defaultConstraints.clear(); - uint32_t _size1303; - ::apache::thrift::protocol::TType _etype1306; - xfer += iprot->readListBegin(_etype1306, _size1303); - this->defaultConstraints.resize(_size1303); - uint32_t _i1307; - for (_i1307 = 0; _i1307 < _size1303; ++_i1307) + uint32_t _size1322; + ::apache::thrift::protocol::TType _etype1325; + xfer += iprot->readListBegin(_etype1325, _size1322); + this->defaultConstraints.resize(_size1322); + uint32_t _i1326; + for (_i1326 = 0; _i1326 < _size1322; ++_i1326) { - xfer += this->defaultConstraints[_i1307].read(iprot); + xfer += this->defaultConstraints[_i1326].read(iprot); } xfer += iprot->readListEnd(); } @@ -5712,14 +5712,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->checkConstraints.clear(); - uint32_t _size1308; - ::apache::thrift::protocol::TType _etype1311; - xfer += iprot->readListBegin(_etype1311, _size1308); - this->checkConstraints.resize(_size1308); - uint32_t _i1312; - for (_i1312 = 0; _i1312 < _size1308; ++_i1312) + uint32_t _size1327; + ::apache::thrift::protocol::TType _etype1330; + xfer += iprot->readListBegin(_etype1330, _size1327); + this->checkConstraints.resize(_size1327); + uint32_t _i1331; + for (_i1331 = 0; _i1331 < _size1327; ++_i1331) { - xfer += this->checkConstraints[_i1312].read(iprot); + xfer += this->checkConstraints[_i1331].read(iprot); } xfer += iprot->readListEnd(); } @@ -5752,10 +5752,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 _iter1313; - for (_iter1313 = this->primaryKeys.begin(); _iter1313 != this->primaryKeys.end(); ++_iter1313) + std::vector<SQLPrimaryKey> ::const_iterator _iter1332; + for (_iter1332 = this->primaryKeys.begin(); _iter1332 != this->primaryKeys.end(); ++_iter1332) { - xfer += (*_iter1313).write(oprot); + xfer += (*_iter1332).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5764,10 +5764,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 _iter1314; - for (_iter1314 = this->foreignKeys.begin(); _iter1314 != this->foreignKeys.end(); ++_iter1314) + std::vector<SQLForeignKey> ::const_iterator _iter1333; + for (_iter1333 = this->foreignKeys.begin(); _iter1333 != this->foreignKeys.end(); ++_iter1333) { - xfer += (*_iter1314).write(oprot); + xfer += (*_iter1333).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5776,10 +5776,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 _iter1315; - for (_iter1315 = this->uniqueConstraints.begin(); _iter1315 != this->uniqueConstraints.end(); ++_iter1315) + std::vector<SQLUniqueConstraint> ::const_iterator _iter1334; + for (_iter1334 = this->uniqueConstraints.begin(); _iter1334 != this->uniqueConstraints.end(); ++_iter1334) { - xfer += (*_iter1315).write(oprot); + xfer += (*_iter1334).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5788,10 +5788,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 _iter1316; - for (_iter1316 = this->notNullConstraints.begin(); _iter1316 != this->notNullConstraints.end(); ++_iter1316) + std::vector<SQLNotNullConstraint> ::const_iterator _iter1335; + for (_iter1335 = this->notNullConstraints.begin(); _iter1335 != this->notNullConstraints.end(); ++_iter1335) { - xfer += (*_iter1316).write(oprot); + xfer += (*_iter1335).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5800,10 +5800,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 _iter1317; - for (_iter1317 = this->defaultConstraints.begin(); _iter1317 != this->defaultConstraints.end(); ++_iter1317) + std::vector<SQLDefaultConstraint> ::const_iterator _iter1336; + for (_iter1336 = this->defaultConstraints.begin(); _iter1336 != this->defaultConstraints.end(); ++_iter1336) { - xfer += (*_iter1317).write(oprot); + xfer += (*_iter1336).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5812,10 +5812,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 _iter1318; - for (_iter1318 = this->checkConstraints.begin(); _iter1318 != this->checkConstraints.end(); ++_iter1318) + std::vector<SQLCheckConstraint> ::const_iterator _iter1337; + for (_iter1337 = this->checkConstraints.begin(); _iter1337 != this->checkConstraints.end(); ++_iter1337) { - xfer += (*_iter1318).write(oprot); + xfer += (*_iter1337).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5843,10 +5843,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 _iter1319; - for (_iter1319 = (*(this->primaryKeys)).begin(); _iter1319 != (*(this->primaryKeys)).end(); ++_iter1319) + std::vector<SQLPrimaryKey> ::const_iterator _iter1338; + for (_iter1338 = (*(this->primaryKeys)).begin(); _iter1338 != (*(this->primaryKeys)).end(); ++_iter1338) { - xfer += (*_iter1319).write(oprot); + xfer += (*_iter1338).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5855,10 +5855,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 _iter1320; - for (_iter1320 = (*(this->foreignKeys)).begin(); _iter1320 != (*(this->foreignKeys)).end(); ++_iter1320) + std::vector<SQLForeignKey> ::const_iterator _iter1339; + for (_iter1339 = (*(this->foreignKeys)).begin(); _iter1339 != (*(this->foreignKeys)).end(); ++_iter1339) { - xfer += (*_iter1320).write(oprot); + xfer += (*_iter1339).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5867,10 +5867,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 _iter1321; - for (_iter1321 = (*(this->uniqueConstraints)).begin(); _iter1321 != (*(this->uniqueConstraints)).end(); ++_iter1321) + std::vector<SQLUniqueConstraint> ::const_iterator _iter1340; + for (_iter1340 = (*(this->uniqueConstraints)).begin(); _iter1340 != (*(this->uniqueConstraints)).end(); ++_iter1340) { - xfer += (*_iter1321).write(oprot); + xfer += (*_iter1340).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5879,10 +5879,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 _iter1322; - for (_iter1322 = (*(this->notNullConstraints)).begin(); _iter1322 != (*(this->notNullConstraints)).end(); ++_iter1322) + std::vector<SQLNotNullConstraint> ::const_iterator _iter1341; + for (_iter1341 = (*(this->notNullConstraints)).begin(); _iter1341 != (*(this->notNullConstraints)).end(); ++_iter1341) { - xfer += (*_iter1322).write(oprot); + xfer += (*_iter1341).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5891,10 +5891,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 _iter1323; - for (_iter1323 = (*(this->defaultConstraints)).begin(); _iter1323 != (*(this->defaultConstraints)).end(); ++_iter1323) + std::vector<SQLDefaultConstraint> ::const_iterator _iter1342; + for (_iter1342 = (*(this->defaultConstraints)).begin(); _iter1342 != (*(this->defaultConstraints)).end(); ++_iter1342) { - xfer += (*_iter1323).write(oprot); + xfer += (*_iter1342).write(oprot); } xfer += oprot->writeListEnd(); } @@ -5903,10 +5903,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 _iter1324; - for (_iter1324 = (*(this->checkConstraints)).begin(); _iter1324 != (*(this->checkConstraints)).end(); ++_iter1324) + std::vector<SQLCheckConstraint> ::const_iterator _iter1343; + for (_iter1343 = (*(this->checkConstraints)).begin(); _iter1343 != (*(this->checkConstraints)).end(); ++_iter1343) { - xfer += (*_iter1324).write(oprot); + xfer += (*_iter1343).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8074,14 +8074,14 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size1325; - ::apache::thrift::protocol::TType _etype1328; - xfer += iprot->readListBegin(_etype1328, _size1325); - this->partNames.resize(_size1325); - uint32_t _i1329; - for (_i1329 = 0; _i1329 < _size1325; ++_i1329) + uint32_t _size1344; + ::apache::thrift::protocol::TType _etype1347; + xfer += iprot->readListBegin(_etype1347, _size1344); + this->partNames.resize(_size1344); + uint32_t _i1348; + for (_i1348 = 0; _i1348 < _size1344; ++_i1348) { - xfer += iprot->readString(this->partNames[_i1329]); + xfer += iprot->readString(this->partNames[_i1348]); } xfer += iprot->readListEnd(); } @@ -8118,10 +8118,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 _iter1330; - for (_iter1330 = this->partNames.begin(); _iter1330 != this->partNames.end(); ++_iter1330) + std::vector<std::string> ::const_iterator _iter1349; + for (_iter1349 = this->partNames.begin(); _iter1349 != this->partNames.end(); ++_iter1349) { - xfer += oprot->writeString((*_iter1330)); + xfer += oprot->writeString((*_iter1349)); } xfer += oprot->writeListEnd(); } @@ -8153,10 +8153,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 _iter1331; - for (_iter1331 = (*(this->partNames)).begin(); _iter1331 != (*(this->partNames)).end(); ++_iter1331) + std::vector<std::string> ::const_iterator _iter1350; + for (_iter1350 = (*(this->partNames)).begin(); _iter1350 != (*(this->partNames)).end(); ++_iter1350) { - xfer += oprot->writeString((*_iter1331)); + xfer += oprot->writeString((*_iter1350)); } xfer += oprot->writeListEnd(); } @@ -8400,14 +8400,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: 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 _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[_i1336]); + xfer += iprot->readString(this->success[_i1355]); } xfer += iprot->readListEnd(); } @@ -8446,10 +8446,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 _iter1337; - for (_iter1337 = this->success.begin(); _iter1337 != this->success.end(); ++_iter1337) + std::vector<std::string> ::const_iterator _iter1356; + for (_iter1356 = this->success.begin(); _iter1356 != this->success.end(); ++_iter1356) { - xfer += oprot->writeString((*_iter1337)); + xfer += oprot->writeString((*_iter1356)); } xfer += oprot->writeListEnd(); } @@ -8494,14 +8494,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol 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 _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))[_i1342]); + xfer += iprot->readString((*(this->success))[_i1361]); } xfer += iprot->readListEnd(); } @@ -8671,14 +8671,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 _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 _size1362; + ::apache::thrift::protocol::TType _etype1365; + xfer += iprot->readListBegin(_etype1365, _size1362); + this->success.resize(_size1362); + uint32_t _i1366; + for (_i1366 = 0; _i1366 < _size1362; ++_i1366) { - xfer += iprot->readString(this->success[_i1347]); + xfer += iprot->readString(this->success[_i1366]); } xfer += iprot->readListEnd(); } @@ -8717,10 +8717,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 _iter1348; - for (_iter1348 = this->success.begin(); _iter1348 != this->success.end(); ++_iter1348) + std::vector<std::string> ::const_iterator _iter1367; + for (_iter1367 = this->success.begin(); _iter1367 != this->success.end(); ++_iter1367) { - xfer += oprot->writeString((*_iter1348)); + xfer += oprot->writeString((*_iter1367)); } xfer += oprot->writeListEnd(); } @@ -8765,14 +8765,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: 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 _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))[_i1353]); + xfer += iprot->readString((*(this->success))[_i1372]); } xfer += iprot->readListEnd(); } @@ -8910,14 +8910,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1354; - ::apache::thrift::protocol::TType _etype1357; - xfer += iprot->readListBegin(_etype1357, _size1354); - this->success.resize(_size1354); - uint32_t _i1358; - for (_i1358 = 0; _i1358 < _size1354; ++_i1358) + uint32_t _size1373; + ::apache::thrift::protocol::TType _etype1376; + xfer += iprot->readListBegin(_etype1376, _size1373); + this->success.resize(_size1373); + uint32_t _i1377; + for (_i1377 = 0; _i1377 < _size1373; ++_i1377) { - xfer += iprot->readString(this->success[_i1358]); + xfer += iprot->readString(this->success[_i1377]); } xfer += iprot->readListEnd(); } @@ -8956,10 +8956,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 _iter1359; - for (_iter1359 = this->success.begin(); _iter1359 != this->success.end(); ++_iter1359) + std::vector<std::string> ::const_iterator _iter1378; + for (_iter1378 = this->success.begin(); _iter1378 != this->success.end(); ++_iter1378) { - xfer += oprot->writeString((*_iter1359)); + xfer += oprot->writeString((*_iter1378)); } xfer += oprot->writeListEnd(); } @@ -9004,14 +9004,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_presult::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1360; - ::apache::thrift::protocol::TType _etype1363; - xfer += iprot->readListBegin(_etype1363, _size1360); - (*(this->success)).resize(_size1360); - uint32_t _i1364; - for (_i1364 = 0; _i1364 < _size1360; ++_i1364) + uint32_t _size1379; + ::apache::thrift::protocol::TType _etype1382; + xfer += iprot->readListBegin(_etype1382, _size1379); + (*(this->success)).resize(_size1379); + uint32_t _i1383; + for (_i1383 = 0; _i1383 < _size1379; ++_i1383) { - xfer += iprot->readString((*(this->success))[_i1364]); + xfer += iprot->readString((*(this->success))[_i1383]); } xfer += iprot->readListEnd(); } @@ -9086,14 +9086,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 _size1365; - ::apache::thrift::protocol::TType _etype1368; - xfer += iprot->readListBegin(_etype1368, _size1365); - this->tbl_types.resize(_size1365); - uint32_t _i1369; - for (_i1369 = 0; _i1369 < _size1365; ++_i1369) + uint32_t _size1384; + ::apache::thrift::protocol::TType _etype1387; + xfer += iprot->readListBegin(_etype1387, _size1384); + this->tbl_types.resize(_size1384); + uint32_t _i1388; + for (_i1388 = 0; _i1388 < _size1384; ++_i1388) { - xfer += iprot->readString(this->tbl_types[_i1369]); + xfer += iprot->readString(this->tbl_types[_i1388]); } xfer += iprot->readListEnd(); } @@ -9130,10 +9130,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 _iter1370; - for (_iter1370 = this->tbl_types.begin(); _iter1370 != this->tbl_types.end(); ++_iter1370) + std::vector<std::string> ::const_iterator _iter1389; + for (_iter1389 = this->tbl_types.begin(); _iter1389 != this->tbl_types.end(); ++_iter1389) { - xfer += oprot->writeString((*_iter1370)); + xfer += oprot->writeString((*_iter1389)); } xfer += oprot->writeListEnd(); } @@ -9165,10 +9165,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 _iter1371; - for (_iter1371 = (*(this->tbl_types)).begin(); _iter1371 != (*(this->tbl_types)).end(); ++_iter1371) + std::vector<std::string> ::const_iterator _iter1390; + for (_iter1390 = (*(this->tbl_types)).begin(); _iter1390 != (*(this->tbl_types)).end(); ++_iter1390) { - xfer += oprot->writeString((*_iter1371)); + xfer += oprot->writeString((*_iter1390)); } xfer += oprot->writeListEnd(); } @@ -9209,14 +9209,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_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 _size1391; + ::apache::thrift::protocol::TType _etype1394; + xfer += iprot->readListBegin(_etype1394, _size1391); + this->success.resize(_size1391); + uint32_t _i1395; + for (_i1395 = 0; _i1395 < _size1391; ++_i1395) { - xfer += this->success[_i1376].read(iprot); + xfer += this->success[_i1395].read(iprot); } xfer += iprot->readListEnd(); } @@ -9255,10 +9255,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 _iter1377; - for (_iter1377 = this->success.begin(); _iter1377 != this->success.end(); ++_iter1377) + std::vector<TableMeta> ::const_iterator _iter1396; + for (_iter1396 = this->success.begin(); _iter1396 != this->success.end(); ++_iter1396) { - xfer += (*_iter1377).write(oprot); + xfer += (*_iter1396).write(oprot); } xfer += oprot->writeListEnd(); } @@ -9303,14 +9303,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_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 _size1397; + ::apache::thrift::protocol::TType _etype1400; + xfer += iprot->readListBegin(_etype1400, _size1397); + (*(this->success)).resize(_size1397); + uint32_t _i1401; + for (_i1401 = 0; _i1401 < _size1397; ++_i1401) { - xfer += (*(this->success))[_i1382].read(iprot); + xfer += (*(this->success))[_i1401].read(iprot); } xfer += iprot->readListEnd(); } @@ -9448,14 +9448,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1383; - ::apache::thrift::protocol::TType _etype1386; - xfer += iprot->readListBegin(_etype1386, _size1383); - this->success.resize(_size1383); - uint32_t _i1387; - for (_i1387 = 0; _i1387 < _size1383; ++_i1387) + uint32_t _size1402; + ::apache::thrift::protocol::TType _etype1405; + xfer += iprot->readListBegin(_etype1405, _size1402); + this->success.resize(_size1402); + uint32_t _i1406; + for (_i1406 = 0; _i1406 < _size1402; ++_i1406) { - xfer += iprot->readString(this->success[_i1387]); + xfer += iprot->readString(this->success[_i1406]); } xfer += iprot->readListEnd(); } @@ -9494,10 +9494,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 _iter1388; - for (_iter1388 = this->success.begin(); _iter1388 != this->success.end(); ++_iter1388) + std::vector<std::string> ::const_iterator _iter1407; + for (_iter1407 = this->success.begin(); _iter1407 != this->success.end(); ++_iter1407) { - xfer += oprot->writeString((*_iter1388)); + xfer += oprot->writeString((*_iter1407)); } xfer += oprot->writeListEnd(); } @@ -9542,14 +9542,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1389; - ::apache::thrift::protocol::TType _etype1392; - xfer += iprot->readListBegin(_etype1392, _size1389); - (*(this->success)).resize(_size1389); - uint32_t _i1393; - for (_i1393 = 0; _i1393 < _size1389; ++_i1393) + uint32_t _size1408; + ::apache::thrift::protocol::TType _etype1411; + xfer += iprot->readListBegin(_etype1411, _size1408); + (*(this->success)).resize(_size1408); + uint32_t _i1412; + for (_i1412 = 0; _i1412 < _size1408; ++_i1412) { - xfer += iprot->readString((*(this->success))[_i1393]); + xfer += iprot->readString((*(this->success))[_i1412]); } xfer += iprot->readListEnd(); } @@ -9859,14 +9859,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 _size1394; - ::apache::thrift::protocol::TType _etype1397; - xfer += iprot->readListBegin(_etype1397, _size1394); - this->tbl_names.resize(_size1394); - uint32_t _i1398; - for (_i1398 = 0; _i1398 < _size1394; ++_i1398) + uint32_t _size1413; + ::apache::thrift::protocol::TType _etype1416; + xfer += iprot->readListBegin(_etype1416, _size1413); + this->tbl_names.resize(_size1413); + uint32_t _i1417; + for (_i1417 = 0; _i1417 < _size1413; ++_i1417) { - xfer += iprot->readString(this->tbl_names[_i1398]); + xfer += iprot->readString(this->tbl_names[_i1417]); } xfer += iprot->readListEnd(); } @@ -9899,10 +9899,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 _iter1399; - for (_iter1399 = this->tbl_names.begin(); _iter1399 != this->tbl_names.end(); ++_iter1399) + std::vector<std::string> ::const_iterator _iter1418; + for (_iter1418 = this->tbl_names.begin(); _iter1418 != this->tbl_names.end(); ++_iter1418) { - xfer += oprot->writeString((*_iter1399)); + xfer += oprot->writeString((*_iter1418)); } xfer += oprot->writeListEnd(); } @@ -9930,10 +9930,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 _iter1400; - for (_iter1400 = (*(this->tbl_names)).begin(); _iter1400 != (*(this->tbl_names)).end(); ++_iter1400) + std::vector<std::string> ::const_iterator _iter1419; + for (_iter1419 = (*(this->tbl_names)).begin(); _iter1419 != (*(this->tbl_names)).end(); ++_iter1419) { - xfer += oprot->writeString((*_iter1400)); + xfer += oprot->writeString((*_iter1419)); } xfer += oprot->writeListEnd(); } @@ -9974,14 +9974,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 _size1401; - ::apache::thrift::protocol::TType _etype1404; - xfer += iprot->readListBegin(_etype1404, _size1401); - this->success.resize(_size1401); - uint32_t _i1405; - for (_i1405 = 0; _i1405 < _size1401; ++_i1405) + uint32_t _size1420; + ::apache::thrift::protocol::TType _etype1423; + xfer += iprot->readListBegin(_etype1423, _size1420); + this->success.resize(_size1420); + uint32_t _i1424; + for (_i1424 = 0; _i1424 < _size1420; ++_i1424) { - xfer += this->success[_i1405].read(iprot); + xfer += this->success[_i1424].read(iprot); } xfer += iprot->readListEnd(); } @@ -10012,10 +10012,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 _iter1406; - for (_iter1406 = this->success.begin(); _iter1406 != this->success.end(); ++_iter1406) + std::vector<Table> ::const_iterator _iter1425; + for (_iter1425 = this->success.begin(); _iter1425 != this->success.end(); ++_iter1425) { - xfer += (*_iter1406).write(oprot); + xfer += (*_iter1425).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10056,14 +10056,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 _size1407; - ::apache::thrift::protocol::TType _etype1410; - xfer += iprot->readListBegin(_etype1410, _size1407); - (*(this->success)).resize(_size1407); - uint32_t _i1411; - for (_i1411 = 0; _i1411 < _size1407; ++_i1411) + uint32_t _size1426; + ::apache::thrift::protocol::TType _etype1429; + xfer += iprot->readListBegin(_etype1429, _size1426); + (*(this->success)).resize(_size1426); + uint32_t _i1430; + for (_i1430 = 0; _i1430 < _size1426; ++_i1430) { - xfer += (*(this->success))[_i1411].read(iprot); + xfer += (*(this->success))[_i1430].read(iprot); } xfer += iprot->readListEnd(); } @@ -10596,14 +10596,14 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_args::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size1412; - ::apache::thrift::protocol::TType _etype1415; - xfer += iprot->readListBegin(_etype1415, _size1412); - this->tbl_names.resize(_size1412); - uint32_t _i1416; - for (_i1416 = 0; _i1416 < _size1412; ++_i1416) + uint32_t _size1431; + ::apache::thrift::protocol::TType _etype1434; + xfer += iprot->readListBegin(_etype1434, _size1431); + this->tbl_names.resize(_size1431); + uint32_t _i1435; + for (_i1435 = 0; _i1435 < _size1431; ++_i1435) { - xfer += iprot->readString(this->tbl_names[_i1416]); + xfer += iprot->readString(this->tbl_names[_i1435]); } xfer += iprot->readListEnd(); } @@ -10636,10 +10636,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 _iter1417; - for (_iter1417 = this->tbl_names.begin(); _iter1417 != this->tbl_names.end(); ++_iter1417) + std::vector<std::string> ::const_iterator _iter1436; + for (_iter1436 = this->tbl_names.begin(); _iter1436 != this->tbl_names.end(); ++_iter1436) { - xfer += oprot->writeString((*_iter1417)); + xfer += oprot->writeString((*_iter1436)); } xfer += oprot->writeListEnd(); } @@ -10667,10 +10667,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 _iter1418; - for (_iter1418 = (*(this->tbl_names)).begin(); _iter1418 != (*(this->tbl_names)).end(); ++_iter1418) + std::vector<std::string> ::const_iterator _iter1437; + for (_iter1437 = (*(this->tbl_names)).begin(); _iter1437 != (*(this->tbl_names)).end(); ++_iter1437) { - xfer += oprot->writeString((*_iter1418)); + xfer += oprot->writeString((*_iter1437)); } xfer += oprot->writeListEnd(); } @@ -10711,17 +10711,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_result::read( if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1419; - ::apache::thrift::protocol::TType _ktype1420; - ::apache::thrift::protocol::TType _vtype1421; - xfer += iprot->readMapBegin(_ktype1420, _vtype1421, _size1419); - uint32_t _i1423; - for (_i1423 = 0; _i1423 < _size1419; ++_i1423) + uint32_t _size1438; + ::apache::thrift::protocol::TType _ktype1439; + ::apache::thrift::protocol::TType _vtype1440; + xfer += iprot->readMapBegin(_ktype1439, _vtype1440, _size1438); + uint32_t _i1442; + for (_i1442 = 0; _i1442 < _size1438; ++_i1442) { - std::string _key1424; - xfer += iprot->readString(_key1424); - Materialization& _val1425 = this->success[_key1424]; - xfer += _val1425.read(iprot); + std::string _key1443; + xfer += iprot->readString(_key1443); + Materialization& _val1444 = this->success[_key1443]; + xfer += _val1444.read(iprot); } xfer += iprot->readMapEnd(); } @@ -10776,11 +10776,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 _iter1426; - for (_iter1426 = this->success.begin(); _iter1426 != this->success.end(); ++_iter1426) + std::map<std::string, Materialization> ::const_iterator _iter1445; + for (_iter1445 = this->success.begin(); _iter1445 != this->success.end(); ++_iter1445) { - xfer += oprot->writeString(_iter1426->first); - xfer += _iter1426->second.write(oprot); + xfer += oprot->writeString(_iter1445->first); + xfer += _iter1445->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -10833,17 +10833,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_presult::read if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1427; - ::apache::thrift::protocol::TType _ktype1428; - ::apache::thrift::protocol::TType _vtype1429; - xfer += iprot->readMapBegin(_ktype1428, _vtype1429, _size1427); - uint32_t _i1431; - for (_i1431 = 0; _i1431 < _size1427; ++_i1431) + uint32_t _size1446; + ::apache::thrift::protocol::TType _ktype1447; + ::apache::thrift::protocol::TType _vtype1448; + xfer += iprot->readMapBegin(_ktype1447, _vtype1448, _size1446); + uint32_t _i1450; + for (_i1450 = 0; _i1450 < _size1446; ++_i1450) { - std::string _key1432; - xfer += iprot->readString(_key1432); - Materialization& _val1433 = (*(this->success))[_key1432]; - xfer += _val1433.read(iprot); + std::string _key1451; + xfer += iprot->readString(_key1451); + Materialization& _val1452 = (*(this->success))[_key1451]; + xfer += _val1452.read(iprot); } xfer += iprot->readMapEnd(); } @@ -11304,14 +11304,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 _size1434; - ::apache::thrift::protocol::TType _etype1437; - xfer += iprot->readListBegin(_etype1437, _size1434); - this->success.resize(_size1434); - uint32_t _i1438; - for (_i1438 = 0; _i1438 < _size1434; ++_i1438) + uint32_t _size1453; + ::apache::thrift::protocol::TType _etype1456; + xfer += iprot->readListBegin(_etype1456, _size1453); + this->success.resize(_size1453); + uint32_t _i1457; + for (_i1457 = 0; _i1457 < _size1453; ++_i1457) { - xfer += iprot->readString(this->success[_i1438]); + xfer += iprot->readString(this->success[_i1457]); } xfer += iprot->readListEnd(); } @@ -11366,10 +11366,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 _iter1439; - for (_iter1439 = this->success.begin(); _iter1439 != this->success.end(); ++_iter1439) + std::vector<std::string> ::const_iterator _iter1458; + for (_iter1458 = this->success.begin(); _iter1458 != this->success.end(); ++_iter1458) { - xfer += oprot->writeString((*_iter1439)); + xfer += oprot->writeString((*_iter1458)); } xfer += oprot->writeListEnd(); } @@ -11422,14 +11422,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 _size1440; - ::apache::thrift::protocol::TType _etype1443; - xfer += iprot->readListBegin(_etype1443, _size1440); - (*(this->success)).resize(_size1440); - uint32_t _i1444; - for (_i1444 = 0; _i1444 < _size1440; ++_i1444) + uint32_t _size1459; + ::apache::thrift::protocol::TType _etype1462; + xfer += iprot->readListBegin(_etype1462, _size1459); + (*(this->success)).resize(_size1459); + uint32_t _i1463; + for (_i1463 = 0; _i1463 < _size1459; ++_i1463) { - xfer += iprot->readString((*(this->success))[_i1444]); + xfer += iprot->readString((*(this->success))[_i1463]); } xfer += iprot->readListEnd(); } @@ -12763,14 +12763,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1445; - ::apache::thrift::protocol::TType _etype1448; - xfer += iprot->readListBegin(_etype1448, _size1445); - this->new_parts.resize(_size1445); - uint32_t _i1449; - for (_i1449 = 0; _i1449 < _size1445; ++_i1449) + uint32_t _size1464; + ::apache::thrift::protocol::TType _etype1467; + xfer += iprot->readListBegin(_etype1467, _size1464); + this->new_parts.resize(_size1464); + uint32_t _i1468; + for (_i1468 = 0; _i1468 < _size1464; ++_i1468) { - xfer += this->new_parts[_i1449].read(iprot); + xfer += this->new_parts[_i1468].read(iprot); } xfer += iprot->readListEnd(); } @@ -12799,10 +12799,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 _iter1450; - for (_iter1450 = this->new_parts.begin(); _iter1450 != this->new_parts.end(); ++_iter1450) + std::vector<Partition> ::const_iterator _iter1469; + for (_iter1469 = this->new_parts.begin(); _iter1469 != this->new_parts.end(); ++_iter1469) { - xfer += (*_iter1450).write(oprot); + xfer += (*_iter1469).write(oprot); } xfer += oprot->writeListEnd(); } @@ -12826,10 +12826,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 _iter1451; - for (_iter1451 = (*(this->new_parts)).begin(); _iter1451 != (*(this->new_parts)).end(); ++_iter1451) + std::vector<Partition> ::const_iterator _iter1470; + for (_iter1470 = (*(this->new_parts)).begin(); _iter1470 != (*(this->new_parts)).end(); ++_iter1470) { - xfer += (*_iter1451).write(oprot); + xfer += (*_iter1470).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13038,14 +13038,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 _size1452; - ::apache::thrift::protocol::TType _etype1455; - xfer += iprot->readListBegin(_etype1455, _size1452); - this->new_parts.resize(_size1452); - uint32_t _i1456; - for (_i1456 = 0; _i1456 < _size1452; ++_i1456) + uint32_t _size1471; + ::apache::thrift::protocol::TType _etype1474; + xfer += iprot->readListBegin(_etype1474, _size1471); + this->new_parts.resize(_size1471); + uint32_t _i1475; + for (_i1475 = 0; _i1475 < _size1471; ++_i1475) { - xfer += this->new_parts[_i1456].read(iprot); + xfer += this->new_parts[_i1475].read(iprot); } xfer += iprot->readListEnd(); } @@ -13074,10 +13074,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 _iter1457; - for (_iter1457 = this->new_parts.begin(); _iter1457 != this->new_parts.end(); ++_iter1457) + std::vector<PartitionSpec> ::const_iterator _iter1476; + for (_iter1476 = this->new_parts.begin(); _iter1476 != this->new_parts.end(); ++_iter1476) { - xfer += (*_iter1457).write(oprot); + xfer += (*_iter1476).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13101,10 +13101,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 _iter1458; - for (_iter1458 = (*(this->new_parts)).begin(); _iter1458 != (*(this->new_parts)).end(); ++_iter1458) + std::vector<PartitionSpec> ::const_iterator _iter1477; + for (_iter1477 = (*(this->new_parts)).begin(); _iter1477 != (*(this->new_parts)).end(); ++_iter1477) { - xfer += (*_iter1458).write(oprot); + xfer += (*_iter1477).write(oprot); } xfer += oprot->writeListEnd(); } @@ -13329,14 +13329,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1459; - ::apache::thrift::protocol::TType _etype1462; - xfer += iprot->readListBegin(_etype1462, _size1459); - this->part_vals.resize(_size1459); - uint32_t _i1463; - for (_i1463 = 0; _i1463 < _size1459; ++_i1463) + uint32_t _size1478; + ::apache::thrift::protocol::TType _etype1481; + xfer += iprot->readListBegin(_etype1481, _size1478); + this->part_vals.resize(_size1478); + uint32_t _i1482; + for (_i1482 = 0; _i1482 < _size1478; ++_i1482) { - xfer += iprot->readString(this->part_vals[_i1463]); + xfer += iprot->readString(this->part_vals[_i1482]); } xfer += iprot->readListEnd(); } @@ -13373,10 +13373,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 _iter1464; - for (_iter1464 = this->part_vals.begin(); _iter1464 != this->part_vals.end(); ++_iter1464) + std::vector<std::string> ::const_iterator _iter1483; + for (_iter1483 = this->part_vals.begin(); _iter1483 != this->part_vals.end(); ++_iter1483) { - xfer += oprot->writeString((*_iter1464)); + xfer += oprot->writeString((*_iter1483)); } xfer += oprot->writeListEnd(); } @@ -13408,10 +13408,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 _iter1465; - for (_iter1465 = (*(this->part_vals)).begin(); _iter1465 != (*(this->part_vals)).end(); ++_iter1465) + std::vector<std::string> ::const_iterator _iter1484; + for (_iter1484 = (*(this->part_vals)).begin(); _iter1484 != (*(this->part_vals)).end(); ++_iter1484) { - xfer += oprot->writeString((*_iter1465)); + xfer += oprot->writeString((*_iter1484)); } xfer += oprot->writeListEnd(); } @@ -13883,14 +13883,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1466; - ::apache::thrift::protocol::TType _etype1469; - xfer += iprot->readListBegin(_etype1469, _size1466); - this->part_vals.resize(_size1466); - uint32_t _i1470; - for (_i1470 = 0; _i1470 < _size1466; ++_i1470) + uint32_t _size1485; + ::apache::thrift::protocol::TType _etype1488; + xfer += iprot->readListBegin(_etype1488, _size1485); + this->part_vals.resize(_size1485); + uint32_t _i1489; + for (_i1489 = 0; _i1489 < _size1485; ++_i1489) { - xfer += iprot->readString(this->part_vals[_i1470]); + xfer += iprot->readString(this->part_vals[_i1489]); } xfer += iprot->readListEnd(); } @@ -13935,10 +13935,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 _iter1471; - for (_iter1471 = this->part_vals.begin(); _iter1471 != this->part_vals.end(); ++_iter1471) + std::vector<std::string> ::const_iterator _iter1490; + for (_iter1490 = this->part_vals.begin(); _iter1490 != this->part_vals.end(); ++_iter1490) { - xfer += oprot->writeString((*_iter1471)); + xfer += oprot->writeString((*_iter1490)); } xfer += oprot->writeListEnd(); } @@ -13974,10 +13974,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 _iter1472; - for (_iter1472 = (*(this->part_vals)).begin(); _iter1472 != (*(this->part_vals)).end(); ++_iter1472) + std::vector<std::string> ::const_iterator _iter1491; + for (_iter1491 = (*(this->part_vals)).begin(); _iter1491 != (*(this->part_vals)).end(); ++_iter1491) { - xfer += oprot->writeString((*_iter1472)); + xfer += oprot->writeString((*_iter1491)); } xfer += oprot->writeListEnd(); } @@ -14780,14 +14780,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1473; - ::apache::thrift::protocol::TType _etype1476; - xfer += iprot->readListBegin(_etype1476, _size1473); - this->part_vals.resize(_size1473); - uint32_t _i1477; - for (_i1477 = 0; _i1477 < _size1473; ++_i1477) + uint32_t _size1492; + ::apache::thrift::protocol::TType _etype1495; + xfer += iprot->readListBegin(_etype1495, _size1492); + this->part_vals.resize(_size1492); + uint32_t _i1496; + for (_i1496 = 0; _i1496 < _size1492; ++_i1496) { - xfer += iprot->readString(this->part_vals[_i1477]); + xfer += iprot->readString(this->part_vals[_i1496]); } xfer += iprot->readListEnd(); } @@ -14832,10 +14832,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 _iter1478; - for (_iter1478 = this->part_vals.begin(); _iter1478 != this->part_vals.end(); ++_iter1478) + std::vector<std::string> ::const_iterator _iter1497; + for (_iter1497 = this->part_vals.begin(); _iter1497 != this->part_vals.end(); ++_iter1497) { - xfer += oprot->writeString((*_iter1478)); + xfer += oprot->writeString((*_iter1497)); } xfer += oprot->writeListEnd(); } @@ -14871,10 +14871,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 _iter1479; - for (_iter1479 = (*(this->part_vals)).begin(); _iter1479 != (*(this->part_vals)).end(); ++_iter1479) + std::vector<std::string> ::const_iterator _iter1498; + for (_iter1498 = (*(this->part_vals)).begin(); _iter1498 != (*(this->part_vals)).end(); ++_iter1498) { - xfer += oprot->writeString((*_iter1479)); + xfer += oprot->writeString((*_iter1498)); } xfer += oprot->writeListEnd(); } @@ -15083,14 +15083,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1480; - ::apache::thrift::protocol::TType _etype1483; - xfer += iprot->readListBegin(_etype1483, _size1480); - this->part_vals.resize(_size1480); - uint32_t _i1484; - for (_i1484 = 0; _i1484 < _size1480; ++_i1484) + uint32_t _size1499; + ::apache::thrift::protocol::TType _etype1502; + xfer += iprot->readListBegin(_etype1502, _size1499); + this->part_vals.resize(_size1499); + uint32_t _i1503; + for (_i1503 = 0; _i1503 < _size1499; ++_i1503) { - xfer += iprot->readString(this->part_vals[_i1484]); + xfer += iprot->readString(this->part_vals[_i1503]); } xfer += iprot->readListEnd(); } @@ -15143,10 +15143,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 _iter1485; - for (_iter1485 = this->part_vals.begin(); _iter1485 != this->part_vals.end(); ++_iter1485) + std::vector<std::string> ::const_iterator _iter1504; + for (_iter1504 = this->part_vals.begin(); _iter1504 != this->part_vals.end(); ++_iter1504) { - xfer += oprot->writeString((*_iter1485)); + xfer += oprot->writeString((*_iter1504)); } xfer += oprot->writeListEnd(); } @@ -15186,10 +15186,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 _iter1486; - for (_iter1486 = (*(this->part_vals)).begin(); _iter1486 != (*(this->part_vals)).end(); ++_iter1486) + std::vector<std::string> ::const_iterator _iter1505; + for (_iter1505 = (*(this->part_vals)).begin(); _iter1505 != (*(this->part_vals)).end(); ++_iter1505) { - xfer += oprot->writeString((*_iter1486)); + xfer += oprot->writeString((*_iter1505)); } xfer += oprot->writeListEnd(); } @@ -16195,14 +16195,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1487; - ::apache::thrift::protocol::TType _etype1490; - xfer += iprot->readListBegin(_etype1490, _size1487); - this->part_vals.resize(_size1487); - uint32_t _i1491; - for (_i1491 = 0; _i1491 < _size1487; ++_i1491) + uint32_t _size1506; + ::apache::thrift::protocol::TType _etype1509; + xfer += iprot->readListBegin(_etype1509, _size1506); + this->part_vals.resize(_size1506); + uint32_t _i1510; + for (_i1510 = 0; _i1510 < _size1506; ++_i1510) { - xfer += iprot->readString(this->part_vals[_i1491]); + xfer += iprot->readString(this->part_vals[_i1510]); } xfer += iprot->readListEnd(); } @@ -16239,10 +16239,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 _iter1492; - for (_iter1492 = this->part_vals.begin(); _iter1492 != this->part_vals.end(); ++_iter1492) + std::vector<std::string> ::const_iterator _iter1511; + for (_iter1511 = this->part_vals.begin(); _iter1511 != this->part_vals.end(); ++_iter1511) { - xfer += oprot->writeString((*_iter1492)); + xfer += oprot->writeString((*_iter1511)); } xfer += oprot->writeListEnd(); } @@ -16274,10 +16274,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 _iter1493; - for (_iter1493 = (*(this->part_vals)).begin(); _iter1493 != (*(this->part_vals)).end(); ++_iter1493) + std::vector<std::string> ::const_iterator _iter1512; + for (_iter1512 = (*(this->part_vals)).begin(); _iter1512 != (*(this->part_vals)).end(); ++_iter1512) { - xfer += oprot->writeString((*_iter1493)); + xfer += oprot->writeString((*_iter1512)); } xfer += oprot->writeListEnd();
<TRUNCATED>