http://git-wip-us.apache.org/repos/asf/hive/blob/b6230001/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 fc80011..14355bb 100644 --- a/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp +++ b/standalone-metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp @@ -1240,14 +1240,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1045; - ::apache::thrift::protocol::TType _etype1048; - xfer += iprot->readListBegin(_etype1048, _size1045); - this->success.resize(_size1045); - uint32_t _i1049; - for (_i1049 = 0; _i1049 < _size1045; ++_i1049) + uint32_t _size1072; + ::apache::thrift::protocol::TType _etype1075; + xfer += iprot->readListBegin(_etype1075, _size1072); + this->success.resize(_size1072); + uint32_t _i1076; + for (_i1076 = 0; _i1076 < _size1072; ++_i1076) { - xfer += iprot->readString(this->success[_i1049]); + xfer += iprot->readString(this->success[_i1076]); } xfer += iprot->readListEnd(); } @@ -1286,10 +1286,10 @@ uint32_t ThriftHiveMetastore_get_databases_result::write(::apache::thrift::proto xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter1050; - for (_iter1050 = this->success.begin(); _iter1050 != this->success.end(); ++_iter1050) + std::vector<std::string> ::const_iterator _iter1077; + for (_iter1077 = this->success.begin(); _iter1077 != this->success.end(); ++_iter1077) { - xfer += oprot->writeString((*_iter1050)); + xfer += oprot->writeString((*_iter1077)); } xfer += oprot->writeListEnd(); } @@ -1334,14 +1334,14 @@ uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1051; - ::apache::thrift::protocol::TType _etype1054; - xfer += iprot->readListBegin(_etype1054, _size1051); - (*(this->success)).resize(_size1051); - uint32_t _i1055; - for (_i1055 = 0; _i1055 < _size1051; ++_i1055) + uint32_t _size1078; + ::apache::thrift::protocol::TType _etype1081; + xfer += iprot->readListBegin(_etype1081, _size1078); + (*(this->success)).resize(_size1078); + uint32_t _i1082; + for (_i1082 = 0; _i1082 < _size1078; ++_i1082) { - xfer += iprot->readString((*(this->success))[_i1055]); + xfer += iprot->readString((*(this->success))[_i1082]); } xfer += iprot->readListEnd(); } @@ -1458,14 +1458,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1056; - ::apache::thrift::protocol::TType _etype1059; - xfer += iprot->readListBegin(_etype1059, _size1056); - this->success.resize(_size1056); - uint32_t _i1060; - for (_i1060 = 0; _i1060 < _size1056; ++_i1060) + uint32_t _size1083; + ::apache::thrift::protocol::TType _etype1086; + xfer += iprot->readListBegin(_etype1086, _size1083); + this->success.resize(_size1083); + uint32_t _i1087; + for (_i1087 = 0; _i1087 < _size1083; ++_i1087) { - xfer += iprot->readString(this->success[_i1060]); + xfer += iprot->readString(this->success[_i1087]); } xfer += iprot->readListEnd(); } @@ -1504,10 +1504,10 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::write(::apache::thrift::p xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size())); - std::vector<std::string> ::const_iterator _iter1061; - for (_iter1061 = this->success.begin(); _iter1061 != this->success.end(); ++_iter1061) + std::vector<std::string> ::const_iterator _iter1088; + for (_iter1088 = this->success.begin(); _iter1088 != this->success.end(); ++_iter1088) { - xfer += oprot->writeString((*_iter1061)); + xfer += oprot->writeString((*_iter1088)); } xfer += oprot->writeListEnd(); } @@ -1552,14 +1552,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::p if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1062; - ::apache::thrift::protocol::TType _etype1065; - xfer += iprot->readListBegin(_etype1065, _size1062); - (*(this->success)).resize(_size1062); - uint32_t _i1066; - for (_i1066 = 0; _i1066 < _size1062; ++_i1066) + uint32_t _size1089; + ::apache::thrift::protocol::TType _etype1092; + xfer += iprot->readListBegin(_etype1092, _size1089); + (*(this->success)).resize(_size1089); + uint32_t _i1093; + for (_i1093 = 0; _i1093 < _size1089; ++_i1093) { - xfer += iprot->readString((*(this->success))[_i1066]); + xfer += iprot->readString((*(this->success))[_i1093]); } xfer += iprot->readListEnd(); } @@ -2621,17 +2621,17 @@ uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1067; - ::apache::thrift::protocol::TType _ktype1068; - ::apache::thrift::protocol::TType _vtype1069; - xfer += iprot->readMapBegin(_ktype1068, _vtype1069, _size1067); - uint32_t _i1071; - for (_i1071 = 0; _i1071 < _size1067; ++_i1071) + uint32_t _size1094; + ::apache::thrift::protocol::TType _ktype1095; + ::apache::thrift::protocol::TType _vtype1096; + xfer += iprot->readMapBegin(_ktype1095, _vtype1096, _size1094); + uint32_t _i1098; + for (_i1098 = 0; _i1098 < _size1094; ++_i1098) { - std::string _key1072; - xfer += iprot->readString(_key1072); - Type& _val1073 = this->success[_key1072]; - xfer += _val1073.read(iprot); + std::string _key1099; + xfer += iprot->readString(_key1099); + Type& _val1100 = this->success[_key1099]; + xfer += _val1100.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2670,11 +2670,11 @@ uint32_t ThriftHiveMetastore_get_type_all_result::write(::apache::thrift::protoc xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::map<std::string, Type> ::const_iterator _iter1074; - for (_iter1074 = this->success.begin(); _iter1074 != this->success.end(); ++_iter1074) + std::map<std::string, Type> ::const_iterator _iter1101; + for (_iter1101 = this->success.begin(); _iter1101 != this->success.end(); ++_iter1101) { - xfer += oprot->writeString(_iter1074->first); - xfer += _iter1074->second.write(oprot); + xfer += oprot->writeString(_iter1101->first); + xfer += _iter1101->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -2719,17 +2719,17 @@ uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protoc if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1075; - ::apache::thrift::protocol::TType _ktype1076; - ::apache::thrift::protocol::TType _vtype1077; - xfer += iprot->readMapBegin(_ktype1076, _vtype1077, _size1075); - uint32_t _i1079; - for (_i1079 = 0; _i1079 < _size1075; ++_i1079) + uint32_t _size1102; + ::apache::thrift::protocol::TType _ktype1103; + ::apache::thrift::protocol::TType _vtype1104; + xfer += iprot->readMapBegin(_ktype1103, _vtype1104, _size1102); + uint32_t _i1106; + for (_i1106 = 0; _i1106 < _size1102; ++_i1106) { - std::string _key1080; - xfer += iprot->readString(_key1080); - Type& _val1081 = (*(this->success))[_key1080]; - xfer += _val1081.read(iprot); + std::string _key1107; + xfer += iprot->readString(_key1107); + Type& _val1108 = (*(this->success))[_key1107]; + xfer += _val1108.read(iprot); } xfer += iprot->readMapEnd(); } @@ -2883,14 +2883,14 @@ uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1082; - ::apache::thrift::protocol::TType _etype1085; - xfer += iprot->readListBegin(_etype1085, _size1082); - this->success.resize(_size1082); - uint32_t _i1086; - for (_i1086 = 0; _i1086 < _size1082; ++_i1086) + uint32_t _size1109; + ::apache::thrift::protocol::TType _etype1112; + xfer += iprot->readListBegin(_etype1112, _size1109); + this->success.resize(_size1109); + uint32_t _i1113; + for (_i1113 = 0; _i1113 < _size1109; ++_i1113) { - xfer += this->success[_i1086].read(iprot); + xfer += this->success[_i1113].read(iprot); } xfer += iprot->readListEnd(); } @@ -2945,10 +2945,10 @@ uint32_t ThriftHiveMetastore_get_fields_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter1087; - for (_iter1087 = this->success.begin(); _iter1087 != this->success.end(); ++_iter1087) + std::vector<FieldSchema> ::const_iterator _iter1114; + for (_iter1114 = this->success.begin(); _iter1114 != this->success.end(); ++_iter1114) { - xfer += (*_iter1087).write(oprot); + xfer += (*_iter1114).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3001,14 +3001,14 @@ uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1088; - ::apache::thrift::protocol::TType _etype1091; - xfer += iprot->readListBegin(_etype1091, _size1088); - (*(this->success)).resize(_size1088); - uint32_t _i1092; - for (_i1092 = 0; _i1092 < _size1088; ++_i1092) + uint32_t _size1115; + ::apache::thrift::protocol::TType _etype1118; + xfer += iprot->readListBegin(_etype1118, _size1115); + (*(this->success)).resize(_size1115); + uint32_t _i1119; + for (_i1119 = 0; _i1119 < _size1115; ++_i1119) { - xfer += (*(this->success))[_i1092].read(iprot); + xfer += (*(this->success))[_i1119].read(iprot); } xfer += iprot->readListEnd(); } @@ -3194,14 +3194,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1093; - ::apache::thrift::protocol::TType _etype1096; - xfer += iprot->readListBegin(_etype1096, _size1093); - this->success.resize(_size1093); - uint32_t _i1097; - for (_i1097 = 0; _i1097 < _size1093; ++_i1097) + uint32_t _size1120; + ::apache::thrift::protocol::TType _etype1123; + xfer += iprot->readListBegin(_etype1123, _size1120); + this->success.resize(_size1120); + uint32_t _i1124; + for (_i1124 = 0; _i1124 < _size1120; ++_i1124) { - xfer += this->success[_i1097].read(iprot); + xfer += this->success[_i1124].read(iprot); } xfer += iprot->readListEnd(); } @@ -3256,10 +3256,10 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter1098; - for (_iter1098 = this->success.begin(); _iter1098 != this->success.end(); ++_iter1098) + std::vector<FieldSchema> ::const_iterator _iter1125; + for (_iter1125 = this->success.begin(); _iter1125 != this->success.end(); ++_iter1125) { - xfer += (*_iter1098).write(oprot); + xfer += (*_iter1125).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3312,14 +3312,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1099; - ::apache::thrift::protocol::TType _etype1102; - xfer += iprot->readListBegin(_etype1102, _size1099); - (*(this->success)).resize(_size1099); - uint32_t _i1103; - for (_i1103 = 0; _i1103 < _size1099; ++_i1103) + uint32_t _size1126; + ::apache::thrift::protocol::TType _etype1129; + xfer += iprot->readListBegin(_etype1129, _size1126); + (*(this->success)).resize(_size1126); + uint32_t _i1130; + for (_i1130 = 0; _i1130 < _size1126; ++_i1130) { - xfer += (*(this->success))[_i1103].read(iprot); + xfer += (*(this->success))[_i1130].read(iprot); } xfer += iprot->readListEnd(); } @@ -3489,14 +3489,14 @@ uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1104; - ::apache::thrift::protocol::TType _etype1107; - xfer += iprot->readListBegin(_etype1107, _size1104); - this->success.resize(_size1104); - uint32_t _i1108; - for (_i1108 = 0; _i1108 < _size1104; ++_i1108) + uint32_t _size1131; + ::apache::thrift::protocol::TType _etype1134; + xfer += iprot->readListBegin(_etype1134, _size1131); + this->success.resize(_size1131); + uint32_t _i1135; + for (_i1135 = 0; _i1135 < _size1131; ++_i1135) { - xfer += this->success[_i1108].read(iprot); + xfer += this->success[_i1135].read(iprot); } xfer += iprot->readListEnd(); } @@ -3551,10 +3551,10 @@ uint32_t ThriftHiveMetastore_get_schema_result::write(::apache::thrift::protocol xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter1109; - for (_iter1109 = this->success.begin(); _iter1109 != this->success.end(); ++_iter1109) + std::vector<FieldSchema> ::const_iterator _iter1136; + for (_iter1136 = this->success.begin(); _iter1136 != this->success.end(); ++_iter1136) { - xfer += (*_iter1109).write(oprot); + xfer += (*_iter1136).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3607,14 +3607,14 @@ uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1110; - ::apache::thrift::protocol::TType _etype1113; - xfer += iprot->readListBegin(_etype1113, _size1110); - (*(this->success)).resize(_size1110); - uint32_t _i1114; - for (_i1114 = 0; _i1114 < _size1110; ++_i1114) + uint32_t _size1137; + ::apache::thrift::protocol::TType _etype1140; + xfer += iprot->readListBegin(_etype1140, _size1137); + (*(this->success)).resize(_size1137); + uint32_t _i1141; + for (_i1141 = 0; _i1141 < _size1137; ++_i1141) { - xfer += (*(this->success))[_i1114].read(iprot); + xfer += (*(this->success))[_i1141].read(iprot); } xfer += iprot->readListEnd(); } @@ -3800,14 +3800,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1115; - ::apache::thrift::protocol::TType _etype1118; - xfer += iprot->readListBegin(_etype1118, _size1115); - this->success.resize(_size1115); - uint32_t _i1119; - for (_i1119 = 0; _i1119 < _size1115; ++_i1119) + uint32_t _size1142; + ::apache::thrift::protocol::TType _etype1145; + xfer += iprot->readListBegin(_etype1145, _size1142); + this->success.resize(_size1142); + uint32_t _i1146; + for (_i1146 = 0; _i1146 < _size1142; ++_i1146) { - xfer += this->success[_i1119].read(iprot); + xfer += this->success[_i1146].read(iprot); } xfer += iprot->readListEnd(); } @@ -3862,10 +3862,10 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::write(: xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size())); - std::vector<FieldSchema> ::const_iterator _iter1120; - for (_iter1120 = this->success.begin(); _iter1120 != this->success.end(); ++_iter1120) + std::vector<FieldSchema> ::const_iterator _iter1147; + for (_iter1147 = this->success.begin(); _iter1147 != this->success.end(); ++_iter1147) { - xfer += (*_iter1120).write(oprot); + xfer += (*_iter1147).write(oprot); } xfer += oprot->writeListEnd(); } @@ -3918,14 +3918,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1121; - ::apache::thrift::protocol::TType _etype1124; - xfer += iprot->readListBegin(_etype1124, _size1121); - (*(this->success)).resize(_size1121); - uint32_t _i1125; - for (_i1125 = 0; _i1125 < _size1121; ++_i1125) + uint32_t _size1148; + ::apache::thrift::protocol::TType _etype1151; + xfer += iprot->readListBegin(_etype1151, _size1148); + (*(this->success)).resize(_size1148); + uint32_t _i1152; + for (_i1152 = 0; _i1152 < _size1148; ++_i1152) { - xfer += (*(this->success))[_i1125].read(iprot); + xfer += (*(this->success))[_i1152].read(iprot); } xfer += iprot->readListEnd(); } @@ -4518,14 +4518,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->primaryKeys.clear(); - uint32_t _size1126; - ::apache::thrift::protocol::TType _etype1129; - xfer += iprot->readListBegin(_etype1129, _size1126); - this->primaryKeys.resize(_size1126); - uint32_t _i1130; - for (_i1130 = 0; _i1130 < _size1126; ++_i1130) + uint32_t _size1153; + ::apache::thrift::protocol::TType _etype1156; + xfer += iprot->readListBegin(_etype1156, _size1153); + this->primaryKeys.resize(_size1153); + uint32_t _i1157; + for (_i1157 = 0; _i1157 < _size1153; ++_i1157) { - xfer += this->primaryKeys[_i1130].read(iprot); + xfer += this->primaryKeys[_i1157].read(iprot); } xfer += iprot->readListEnd(); } @@ -4538,14 +4538,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->foreignKeys.clear(); - uint32_t _size1131; - ::apache::thrift::protocol::TType _etype1134; - xfer += iprot->readListBegin(_etype1134, _size1131); - this->foreignKeys.resize(_size1131); - uint32_t _i1135; - for (_i1135 = 0; _i1135 < _size1131; ++_i1135) + uint32_t _size1158; + ::apache::thrift::protocol::TType _etype1161; + xfer += iprot->readListBegin(_etype1161, _size1158); + this->foreignKeys.resize(_size1158); + uint32_t _i1162; + for (_i1162 = 0; _i1162 < _size1158; ++_i1162) { - xfer += this->foreignKeys[_i1135].read(iprot); + xfer += this->foreignKeys[_i1162].read(iprot); } xfer += iprot->readListEnd(); } @@ -4558,14 +4558,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->uniqueConstraints.clear(); - uint32_t _size1136; - ::apache::thrift::protocol::TType _etype1139; - xfer += iprot->readListBegin(_etype1139, _size1136); - this->uniqueConstraints.resize(_size1136); - uint32_t _i1140; - for (_i1140 = 0; _i1140 < _size1136; ++_i1140) + uint32_t _size1163; + ::apache::thrift::protocol::TType _etype1166; + xfer += iprot->readListBegin(_etype1166, _size1163); + this->uniqueConstraints.resize(_size1163); + uint32_t _i1167; + for (_i1167 = 0; _i1167 < _size1163; ++_i1167) { - xfer += this->uniqueConstraints[_i1140].read(iprot); + xfer += this->uniqueConstraints[_i1167].read(iprot); } xfer += iprot->readListEnd(); } @@ -4578,14 +4578,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->notNullConstraints.clear(); - uint32_t _size1141; - ::apache::thrift::protocol::TType _etype1144; - xfer += iprot->readListBegin(_etype1144, _size1141); - this->notNullConstraints.resize(_size1141); - uint32_t _i1145; - for (_i1145 = 0; _i1145 < _size1141; ++_i1145) + uint32_t _size1168; + ::apache::thrift::protocol::TType _etype1171; + xfer += iprot->readListBegin(_etype1171, _size1168); + this->notNullConstraints.resize(_size1168); + uint32_t _i1172; + for (_i1172 = 0; _i1172 < _size1168; ++_i1172) { - xfer += this->notNullConstraints[_i1145].read(iprot); + xfer += this->notNullConstraints[_i1172].read(iprot); } xfer += iprot->readListEnd(); } @@ -4618,10 +4618,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 _iter1146; - for (_iter1146 = this->primaryKeys.begin(); _iter1146 != this->primaryKeys.end(); ++_iter1146) + std::vector<SQLPrimaryKey> ::const_iterator _iter1173; + for (_iter1173 = this->primaryKeys.begin(); _iter1173 != this->primaryKeys.end(); ++_iter1173) { - xfer += (*_iter1146).write(oprot); + xfer += (*_iter1173).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4630,10 +4630,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 _iter1147; - for (_iter1147 = this->foreignKeys.begin(); _iter1147 != this->foreignKeys.end(); ++_iter1147) + std::vector<SQLForeignKey> ::const_iterator _iter1174; + for (_iter1174 = this->foreignKeys.begin(); _iter1174 != this->foreignKeys.end(); ++_iter1174) { - xfer += (*_iter1147).write(oprot); + xfer += (*_iter1174).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4642,10 +4642,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 _iter1148; - for (_iter1148 = this->uniqueConstraints.begin(); _iter1148 != this->uniqueConstraints.end(); ++_iter1148) + std::vector<SQLUniqueConstraint> ::const_iterator _iter1175; + for (_iter1175 = this->uniqueConstraints.begin(); _iter1175 != this->uniqueConstraints.end(); ++_iter1175) { - xfer += (*_iter1148).write(oprot); + xfer += (*_iter1175).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4654,10 +4654,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 _iter1149; - for (_iter1149 = this->notNullConstraints.begin(); _iter1149 != this->notNullConstraints.end(); ++_iter1149) + std::vector<SQLNotNullConstraint> ::const_iterator _iter1176; + for (_iter1176 = this->notNullConstraints.begin(); _iter1176 != this->notNullConstraints.end(); ++_iter1176) { - xfer += (*_iter1149).write(oprot); + xfer += (*_iter1176).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4685,10 +4685,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 _iter1150; - for (_iter1150 = (*(this->primaryKeys)).begin(); _iter1150 != (*(this->primaryKeys)).end(); ++_iter1150) + std::vector<SQLPrimaryKey> ::const_iterator _iter1177; + for (_iter1177 = (*(this->primaryKeys)).begin(); _iter1177 != (*(this->primaryKeys)).end(); ++_iter1177) { - xfer += (*_iter1150).write(oprot); + xfer += (*_iter1177).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4697,10 +4697,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 _iter1151; - for (_iter1151 = (*(this->foreignKeys)).begin(); _iter1151 != (*(this->foreignKeys)).end(); ++_iter1151) + std::vector<SQLForeignKey> ::const_iterator _iter1178; + for (_iter1178 = (*(this->foreignKeys)).begin(); _iter1178 != (*(this->foreignKeys)).end(); ++_iter1178) { - xfer += (*_iter1151).write(oprot); + xfer += (*_iter1178).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4709,10 +4709,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 _iter1152; - for (_iter1152 = (*(this->uniqueConstraints)).begin(); _iter1152 != (*(this->uniqueConstraints)).end(); ++_iter1152) + std::vector<SQLUniqueConstraint> ::const_iterator _iter1179; + for (_iter1179 = (*(this->uniqueConstraints)).begin(); _iter1179 != (*(this->uniqueConstraints)).end(); ++_iter1179) { - xfer += (*_iter1152).write(oprot); + xfer += (*_iter1179).write(oprot); } xfer += oprot->writeListEnd(); } @@ -4721,10 +4721,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 _iter1153; - for (_iter1153 = (*(this->notNullConstraints)).begin(); _iter1153 != (*(this->notNullConstraints)).end(); ++_iter1153) + std::vector<SQLNotNullConstraint> ::const_iterator _iter1180; + for (_iter1180 = (*(this->notNullConstraints)).begin(); _iter1180 != (*(this->notNullConstraints)).end(); ++_iter1180) { - xfer += (*_iter1153).write(oprot); + xfer += (*_iter1180).write(oprot); } xfer += oprot->writeListEnd(); } @@ -6478,14 +6478,14 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->partNames.clear(); - uint32_t _size1154; - ::apache::thrift::protocol::TType _etype1157; - xfer += iprot->readListBegin(_etype1157, _size1154); - this->partNames.resize(_size1154); - uint32_t _i1158; - for (_i1158 = 0; _i1158 < _size1154; ++_i1158) + uint32_t _size1181; + ::apache::thrift::protocol::TType _etype1184; + xfer += iprot->readListBegin(_etype1184, _size1181); + this->partNames.resize(_size1181); + uint32_t _i1185; + for (_i1185 = 0; _i1185 < _size1181; ++_i1185) { - xfer += iprot->readString(this->partNames[_i1158]); + xfer += iprot->readString(this->partNames[_i1185]); } xfer += iprot->readListEnd(); } @@ -6522,10 +6522,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 _iter1159; - for (_iter1159 = this->partNames.begin(); _iter1159 != this->partNames.end(); ++_iter1159) + std::vector<std::string> ::const_iterator _iter1186; + for (_iter1186 = this->partNames.begin(); _iter1186 != this->partNames.end(); ++_iter1186) { - xfer += oprot->writeString((*_iter1159)); + xfer += oprot->writeString((*_iter1186)); } xfer += oprot->writeListEnd(); } @@ -6557,10 +6557,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 _iter1160; - for (_iter1160 = (*(this->partNames)).begin(); _iter1160 != (*(this->partNames)).end(); ++_iter1160) + std::vector<std::string> ::const_iterator _iter1187; + for (_iter1187 = (*(this->partNames)).begin(); _iter1187 != (*(this->partNames)).end(); ++_iter1187) { - xfer += oprot->writeString((*_iter1160)); + xfer += oprot->writeString((*_iter1187)); } xfer += oprot->writeListEnd(); } @@ -6804,14 +6804,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1161; - ::apache::thrift::protocol::TType _etype1164; - xfer += iprot->readListBegin(_etype1164, _size1161); - this->success.resize(_size1161); - uint32_t _i1165; - for (_i1165 = 0; _i1165 < _size1161; ++_i1165) + uint32_t _size1188; + ::apache::thrift::protocol::TType _etype1191; + xfer += iprot->readListBegin(_etype1191, _size1188); + this->success.resize(_size1188); + uint32_t _i1192; + for (_i1192 = 0; _i1192 < _size1188; ++_i1192) { - xfer += iprot->readString(this->success[_i1165]); + xfer += iprot->readString(this->success[_i1192]); } xfer += iprot->readListEnd(); } @@ -6850,10 +6850,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 _iter1166; - for (_iter1166 = this->success.begin(); _iter1166 != this->success.end(); ++_iter1166) + std::vector<std::string> ::const_iterator _iter1193; + for (_iter1193 = this->success.begin(); _iter1193 != this->success.end(); ++_iter1193) { - xfer += oprot->writeString((*_iter1166)); + xfer += oprot->writeString((*_iter1193)); } xfer += oprot->writeListEnd(); } @@ -6898,14 +6898,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1167; - ::apache::thrift::protocol::TType _etype1170; - xfer += iprot->readListBegin(_etype1170, _size1167); - (*(this->success)).resize(_size1167); - uint32_t _i1171; - for (_i1171 = 0; _i1171 < _size1167; ++_i1171) + uint32_t _size1194; + ::apache::thrift::protocol::TType _etype1197; + xfer += iprot->readListBegin(_etype1197, _size1194); + (*(this->success)).resize(_size1194); + uint32_t _i1198; + for (_i1198 = 0; _i1198 < _size1194; ++_i1198) { - xfer += iprot->readString((*(this->success))[_i1171]); + xfer += iprot->readString((*(this->success))[_i1198]); } xfer += iprot->readListEnd(); } @@ -7075,14 +7075,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 _size1172; - ::apache::thrift::protocol::TType _etype1175; - xfer += iprot->readListBegin(_etype1175, _size1172); - this->success.resize(_size1172); - uint32_t _i1176; - for (_i1176 = 0; _i1176 < _size1172; ++_i1176) + 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[_i1176]); + xfer += iprot->readString(this->success[_i1203]); } xfer += iprot->readListEnd(); } @@ -7121,10 +7121,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 _iter1177; - for (_iter1177 = this->success.begin(); _iter1177 != this->success.end(); ++_iter1177) + std::vector<std::string> ::const_iterator _iter1204; + for (_iter1204 = this->success.begin(); _iter1204 != this->success.end(); ++_iter1204) { - xfer += oprot->writeString((*_iter1177)); + xfer += oprot->writeString((*_iter1204)); } xfer += oprot->writeListEnd(); } @@ -7169,14 +7169,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1178; - ::apache::thrift::protocol::TType _etype1181; - xfer += iprot->readListBegin(_etype1181, _size1178); - (*(this->success)).resize(_size1178); - uint32_t _i1182; - for (_i1182 = 0; _i1182 < _size1178; ++_i1182) + 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))[_i1182]); + xfer += iprot->readString((*(this->success))[_i1209]); } xfer += iprot->readListEnd(); } @@ -7314,14 +7314,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::read(: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1183; - ::apache::thrift::protocol::TType _etype1186; - xfer += iprot->readListBegin(_etype1186, _size1183); - this->success.resize(_size1183); - uint32_t _i1187; - for (_i1187 = 0; _i1187 < _size1183; ++_i1187) + 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[_i1187]); + xfer += iprot->readString(this->success[_i1214]); } xfer += iprot->readListEnd(); } @@ -7360,10 +7360,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 _iter1188; - for (_iter1188 = this->success.begin(); _iter1188 != this->success.end(); ++_iter1188) + std::vector<std::string> ::const_iterator _iter1215; + for (_iter1215 = this->success.begin(); _iter1215 != this->success.end(); ++_iter1215) { - xfer += oprot->writeString((*_iter1188)); + xfer += oprot->writeString((*_iter1215)); } xfer += oprot->writeListEnd(); } @@ -7408,14 +7408,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_presult::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1189; - ::apache::thrift::protocol::TType _etype1192; - xfer += iprot->readListBegin(_etype1192, _size1189); - (*(this->success)).resize(_size1189); - uint32_t _i1193; - for (_i1193 = 0; _i1193 < _size1189; ++_i1193) + 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))[_i1193]); + xfer += iprot->readString((*(this->success))[_i1220]); } xfer += iprot->readListEnd(); } @@ -7490,14 +7490,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 _size1194; - ::apache::thrift::protocol::TType _etype1197; - xfer += iprot->readListBegin(_etype1197, _size1194); - this->tbl_types.resize(_size1194); - uint32_t _i1198; - for (_i1198 = 0; _i1198 < _size1194; ++_i1198) + uint32_t _size1221; + ::apache::thrift::protocol::TType _etype1224; + xfer += iprot->readListBegin(_etype1224, _size1221); + this->tbl_types.resize(_size1221); + uint32_t _i1225; + for (_i1225 = 0; _i1225 < _size1221; ++_i1225) { - xfer += iprot->readString(this->tbl_types[_i1198]); + xfer += iprot->readString(this->tbl_types[_i1225]); } xfer += iprot->readListEnd(); } @@ -7534,10 +7534,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 _iter1199; - for (_iter1199 = this->tbl_types.begin(); _iter1199 != this->tbl_types.end(); ++_iter1199) + std::vector<std::string> ::const_iterator _iter1226; + for (_iter1226 = this->tbl_types.begin(); _iter1226 != this->tbl_types.end(); ++_iter1226) { - xfer += oprot->writeString((*_iter1199)); + xfer += oprot->writeString((*_iter1226)); } xfer += oprot->writeListEnd(); } @@ -7569,10 +7569,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 _iter1200; - for (_iter1200 = (*(this->tbl_types)).begin(); _iter1200 != (*(this->tbl_types)).end(); ++_iter1200) + std::vector<std::string> ::const_iterator _iter1227; + for (_iter1227 = (*(this->tbl_types)).begin(); _iter1227 != (*(this->tbl_types)).end(); ++_iter1227) { - xfer += oprot->writeString((*_iter1200)); + xfer += oprot->writeString((*_iter1227)); } xfer += oprot->writeListEnd(); } @@ -7613,14 +7613,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1201; - ::apache::thrift::protocol::TType _etype1204; - xfer += iprot->readListBegin(_etype1204, _size1201); - this->success.resize(_size1201); - uint32_t _i1205; - for (_i1205 = 0; _i1205 < _size1201; ++_i1205) + uint32_t _size1228; + ::apache::thrift::protocol::TType _etype1231; + xfer += iprot->readListBegin(_etype1231, _size1228); + this->success.resize(_size1228); + uint32_t _i1232; + for (_i1232 = 0; _i1232 < _size1228; ++_i1232) { - xfer += this->success[_i1205].read(iprot); + xfer += this->success[_i1232].read(iprot); } xfer += iprot->readListEnd(); } @@ -7659,10 +7659,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 _iter1206; - for (_iter1206 = this->success.begin(); _iter1206 != this->success.end(); ++_iter1206) + std::vector<TableMeta> ::const_iterator _iter1233; + for (_iter1233 = this->success.begin(); _iter1233 != this->success.end(); ++_iter1233) { - xfer += (*_iter1206).write(oprot); + xfer += (*_iter1233).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7707,14 +7707,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1207; - ::apache::thrift::protocol::TType _etype1210; - xfer += iprot->readListBegin(_etype1210, _size1207); - (*(this->success)).resize(_size1207); - uint32_t _i1211; - for (_i1211 = 0; _i1211 < _size1207; ++_i1211) + uint32_t _size1234; + ::apache::thrift::protocol::TType _etype1237; + xfer += iprot->readListBegin(_etype1237, _size1234); + (*(this->success)).resize(_size1234); + uint32_t _i1238; + for (_i1238 = 0; _i1238 < _size1234; ++_i1238) { - xfer += (*(this->success))[_i1211].read(iprot); + xfer += (*(this->success))[_i1238].read(iprot); } xfer += iprot->readListEnd(); } @@ -7852,14 +7852,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1212; - ::apache::thrift::protocol::TType _etype1215; - xfer += iprot->readListBegin(_etype1215, _size1212); - this->success.resize(_size1212); - uint32_t _i1216; - for (_i1216 = 0; _i1216 < _size1212; ++_i1216) + uint32_t _size1239; + ::apache::thrift::protocol::TType _etype1242; + xfer += iprot->readListBegin(_etype1242, _size1239); + this->success.resize(_size1239); + uint32_t _i1243; + for (_i1243 = 0; _i1243 < _size1239; ++_i1243) { - xfer += iprot->readString(this->success[_i1216]); + xfer += iprot->readString(this->success[_i1243]); } xfer += iprot->readListEnd(); } @@ -7898,10 +7898,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 _iter1217; - for (_iter1217 = this->success.begin(); _iter1217 != this->success.end(); ++_iter1217) + std::vector<std::string> ::const_iterator _iter1244; + for (_iter1244 = this->success.begin(); _iter1244 != this->success.end(); ++_iter1244) { - xfer += oprot->writeString((*_iter1217)); + xfer += oprot->writeString((*_iter1244)); } xfer += oprot->writeListEnd(); } @@ -7946,14 +7946,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1218; - ::apache::thrift::protocol::TType _etype1221; - xfer += iprot->readListBegin(_etype1221, _size1218); - (*(this->success)).resize(_size1218); - uint32_t _i1222; - for (_i1222 = 0; _i1222 < _size1218; ++_i1222) + uint32_t _size1245; + ::apache::thrift::protocol::TType _etype1248; + xfer += iprot->readListBegin(_etype1248, _size1245); + (*(this->success)).resize(_size1245); + uint32_t _i1249; + for (_i1249 = 0; _i1249 < _size1245; ++_i1249) { - xfer += iprot->readString((*(this->success))[_i1222]); + xfer += iprot->readString((*(this->success))[_i1249]); } xfer += iprot->readListEnd(); } @@ -8263,14 +8263,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 _size1223; - ::apache::thrift::protocol::TType _etype1226; - xfer += iprot->readListBegin(_etype1226, _size1223); - this->tbl_names.resize(_size1223); - uint32_t _i1227; - for (_i1227 = 0; _i1227 < _size1223; ++_i1227) + uint32_t _size1250; + ::apache::thrift::protocol::TType _etype1253; + xfer += iprot->readListBegin(_etype1253, _size1250); + this->tbl_names.resize(_size1250); + uint32_t _i1254; + for (_i1254 = 0; _i1254 < _size1250; ++_i1254) { - xfer += iprot->readString(this->tbl_names[_i1227]); + xfer += iprot->readString(this->tbl_names[_i1254]); } xfer += iprot->readListEnd(); } @@ -8303,10 +8303,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 _iter1228; - for (_iter1228 = this->tbl_names.begin(); _iter1228 != this->tbl_names.end(); ++_iter1228) + std::vector<std::string> ::const_iterator _iter1255; + for (_iter1255 = this->tbl_names.begin(); _iter1255 != this->tbl_names.end(); ++_iter1255) { - xfer += oprot->writeString((*_iter1228)); + xfer += oprot->writeString((*_iter1255)); } xfer += oprot->writeListEnd(); } @@ -8334,10 +8334,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 _iter1229; - for (_iter1229 = (*(this->tbl_names)).begin(); _iter1229 != (*(this->tbl_names)).end(); ++_iter1229) + std::vector<std::string> ::const_iterator _iter1256; + for (_iter1256 = (*(this->tbl_names)).begin(); _iter1256 != (*(this->tbl_names)).end(); ++_iter1256) { - xfer += oprot->writeString((*_iter1229)); + xfer += oprot->writeString((*_iter1256)); } xfer += oprot->writeListEnd(); } @@ -8378,14 +8378,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 _size1230; - ::apache::thrift::protocol::TType _etype1233; - xfer += iprot->readListBegin(_etype1233, _size1230); - this->success.resize(_size1230); - uint32_t _i1234; - for (_i1234 = 0; _i1234 < _size1230; ++_i1234) + uint32_t _size1257; + ::apache::thrift::protocol::TType _etype1260; + xfer += iprot->readListBegin(_etype1260, _size1257); + this->success.resize(_size1257); + uint32_t _i1261; + for (_i1261 = 0; _i1261 < _size1257; ++_i1261) { - xfer += this->success[_i1234].read(iprot); + xfer += this->success[_i1261].read(iprot); } xfer += iprot->readListEnd(); } @@ -8416,10 +8416,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 _iter1235; - for (_iter1235 = this->success.begin(); _iter1235 != this->success.end(); ++_iter1235) + std::vector<Table> ::const_iterator _iter1262; + for (_iter1262 = this->success.begin(); _iter1262 != this->success.end(); ++_iter1262) { - xfer += (*_iter1235).write(oprot); + xfer += (*_iter1262).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8460,14 +8460,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 _size1236; - ::apache::thrift::protocol::TType _etype1239; - xfer += iprot->readListBegin(_etype1239, _size1236); - (*(this->success)).resize(_size1236); - uint32_t _i1240; - for (_i1240 = 0; _i1240 < _size1236; ++_i1240) + uint32_t _size1263; + ::apache::thrift::protocol::TType _etype1266; + xfer += iprot->readListBegin(_etype1266, _size1263); + (*(this->success)).resize(_size1263); + uint32_t _i1267; + for (_i1267 = 0; _i1267 < _size1263; ++_i1267) { - xfer += (*(this->success))[_i1240].read(iprot); + xfer += (*(this->success))[_i1267].read(iprot); } xfer += iprot->readListEnd(); } @@ -9000,14 +9000,14 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_args::read(:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->tbl_names.clear(); - uint32_t _size1241; - ::apache::thrift::protocol::TType _etype1244; - xfer += iprot->readListBegin(_etype1244, _size1241); - this->tbl_names.resize(_size1241); - uint32_t _i1245; - for (_i1245 = 0; _i1245 < _size1241; ++_i1245) + uint32_t _size1268; + ::apache::thrift::protocol::TType _etype1271; + xfer += iprot->readListBegin(_etype1271, _size1268); + this->tbl_names.resize(_size1268); + uint32_t _i1272; + for (_i1272 = 0; _i1272 < _size1268; ++_i1272) { - xfer += iprot->readString(this->tbl_names[_i1245]); + xfer += iprot->readString(this->tbl_names[_i1272]); } xfer += iprot->readListEnd(); } @@ -9040,10 +9040,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 _iter1246; - for (_iter1246 = this->tbl_names.begin(); _iter1246 != this->tbl_names.end(); ++_iter1246) + std::vector<std::string> ::const_iterator _iter1273; + for (_iter1273 = this->tbl_names.begin(); _iter1273 != this->tbl_names.end(); ++_iter1273) { - xfer += oprot->writeString((*_iter1246)); + xfer += oprot->writeString((*_iter1273)); } xfer += oprot->writeListEnd(); } @@ -9071,10 +9071,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 _iter1247; - for (_iter1247 = (*(this->tbl_names)).begin(); _iter1247 != (*(this->tbl_names)).end(); ++_iter1247) + std::vector<std::string> ::const_iterator _iter1274; + for (_iter1274 = (*(this->tbl_names)).begin(); _iter1274 != (*(this->tbl_names)).end(); ++_iter1274) { - xfer += oprot->writeString((*_iter1247)); + xfer += oprot->writeString((*_iter1274)); } xfer += oprot->writeListEnd(); } @@ -9115,17 +9115,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_result::read( if (ftype == ::apache::thrift::protocol::T_MAP) { { this->success.clear(); - uint32_t _size1248; - ::apache::thrift::protocol::TType _ktype1249; - ::apache::thrift::protocol::TType _vtype1250; - xfer += iprot->readMapBegin(_ktype1249, _vtype1250, _size1248); - uint32_t _i1252; - for (_i1252 = 0; _i1252 < _size1248; ++_i1252) + uint32_t _size1275; + ::apache::thrift::protocol::TType _ktype1276; + ::apache::thrift::protocol::TType _vtype1277; + xfer += iprot->readMapBegin(_ktype1276, _vtype1277, _size1275); + uint32_t _i1279; + for (_i1279 = 0; _i1279 < _size1275; ++_i1279) { - std::string _key1253; - xfer += iprot->readString(_key1253); - Materialization& _val1254 = this->success[_key1253]; - xfer += _val1254.read(iprot); + std::string _key1280; + xfer += iprot->readString(_key1280); + Materialization& _val1281 = this->success[_key1280]; + xfer += _val1281.read(iprot); } xfer += iprot->readMapEnd(); } @@ -9180,11 +9180,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 _iter1255; - for (_iter1255 = this->success.begin(); _iter1255 != this->success.end(); ++_iter1255) + std::map<std::string, Materialization> ::const_iterator _iter1282; + for (_iter1282 = this->success.begin(); _iter1282 != this->success.end(); ++_iter1282) { - xfer += oprot->writeString(_iter1255->first); - xfer += _iter1255->second.write(oprot); + xfer += oprot->writeString(_iter1282->first); + xfer += _iter1282->second.write(oprot); } xfer += oprot->writeMapEnd(); } @@ -9237,17 +9237,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_presult::read if (ftype == ::apache::thrift::protocol::T_MAP) { { (*(this->success)).clear(); - uint32_t _size1256; - ::apache::thrift::protocol::TType _ktype1257; - ::apache::thrift::protocol::TType _vtype1258; - xfer += iprot->readMapBegin(_ktype1257, _vtype1258, _size1256); - uint32_t _i1260; - for (_i1260 = 0; _i1260 < _size1256; ++_i1260) + uint32_t _size1283; + ::apache::thrift::protocol::TType _ktype1284; + ::apache::thrift::protocol::TType _vtype1285; + xfer += iprot->readMapBegin(_ktype1284, _vtype1285, _size1283); + uint32_t _i1287; + for (_i1287 = 0; _i1287 < _size1283; ++_i1287) { - std::string _key1261; - xfer += iprot->readString(_key1261); - Materialization& _val1262 = (*(this->success))[_key1261]; - xfer += _val1262.read(iprot); + std::string _key1288; + xfer += iprot->readString(_key1288); + Materialization& _val1289 = (*(this->success))[_key1288]; + xfer += _val1289.read(iprot); } xfer += iprot->readMapEnd(); } @@ -9433,14 +9433,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 _size1263; - ::apache::thrift::protocol::TType _etype1266; - xfer += iprot->readListBegin(_etype1266, _size1263); - this->success.resize(_size1263); - uint32_t _i1267; - for (_i1267 = 0; _i1267 < _size1263; ++_i1267) + uint32_t _size1290; + ::apache::thrift::protocol::TType _etype1293; + xfer += iprot->readListBegin(_etype1293, _size1290); + this->success.resize(_size1290); + uint32_t _i1294; + for (_i1294 = 0; _i1294 < _size1290; ++_i1294) { - xfer += iprot->readString(this->success[_i1267]); + xfer += iprot->readString(this->success[_i1294]); } xfer += iprot->readListEnd(); } @@ -9495,10 +9495,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 _iter1268; - for (_iter1268 = this->success.begin(); _iter1268 != this->success.end(); ++_iter1268) + std::vector<std::string> ::const_iterator _iter1295; + for (_iter1295 = this->success.begin(); _iter1295 != this->success.end(); ++_iter1295) { - xfer += oprot->writeString((*_iter1268)); + xfer += oprot->writeString((*_iter1295)); } xfer += oprot->writeListEnd(); } @@ -9551,14 +9551,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 _size1269; - ::apache::thrift::protocol::TType _etype1272; - xfer += iprot->readListBegin(_etype1272, _size1269); - (*(this->success)).resize(_size1269); - uint32_t _i1273; - for (_i1273 = 0; _i1273 < _size1269; ++_i1273) + uint32_t _size1296; + ::apache::thrift::protocol::TType _etype1299; + xfer += iprot->readListBegin(_etype1299, _size1296); + (*(this->success)).resize(_size1296); + uint32_t _i1300; + for (_i1300 = 0; _i1300 < _size1296; ++_i1300) { - xfer += iprot->readString((*(this->success))[_i1273]); + xfer += iprot->readString((*(this->success))[_i1300]); } xfer += iprot->readListEnd(); } @@ -10892,14 +10892,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1274; - ::apache::thrift::protocol::TType _etype1277; - xfer += iprot->readListBegin(_etype1277, _size1274); - this->new_parts.resize(_size1274); - uint32_t _i1278; - for (_i1278 = 0; _i1278 < _size1274; ++_i1278) + uint32_t _size1301; + ::apache::thrift::protocol::TType _etype1304; + xfer += iprot->readListBegin(_etype1304, _size1301); + this->new_parts.resize(_size1301); + uint32_t _i1305; + for (_i1305 = 0; _i1305 < _size1301; ++_i1305) { - xfer += this->new_parts[_i1278].read(iprot); + xfer += this->new_parts[_i1305].read(iprot); } xfer += iprot->readListEnd(); } @@ -10928,10 +10928,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 _iter1279; - for (_iter1279 = this->new_parts.begin(); _iter1279 != this->new_parts.end(); ++_iter1279) + std::vector<Partition> ::const_iterator _iter1306; + for (_iter1306 = this->new_parts.begin(); _iter1306 != this->new_parts.end(); ++_iter1306) { - xfer += (*_iter1279).write(oprot); + xfer += (*_iter1306).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10955,10 +10955,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 _iter1280; - for (_iter1280 = (*(this->new_parts)).begin(); _iter1280 != (*(this->new_parts)).end(); ++_iter1280) + std::vector<Partition> ::const_iterator _iter1307; + for (_iter1307 = (*(this->new_parts)).begin(); _iter1307 != (*(this->new_parts)).end(); ++_iter1307) { - xfer += (*_iter1280).write(oprot); + xfer += (*_iter1307).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11167,14 +11167,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 _size1281; - ::apache::thrift::protocol::TType _etype1284; - xfer += iprot->readListBegin(_etype1284, _size1281); - this->new_parts.resize(_size1281); - uint32_t _i1285; - for (_i1285 = 0; _i1285 < _size1281; ++_i1285) + uint32_t _size1308; + ::apache::thrift::protocol::TType _etype1311; + xfer += iprot->readListBegin(_etype1311, _size1308); + this->new_parts.resize(_size1308); + uint32_t _i1312; + for (_i1312 = 0; _i1312 < _size1308; ++_i1312) { - xfer += this->new_parts[_i1285].read(iprot); + xfer += this->new_parts[_i1312].read(iprot); } xfer += iprot->readListEnd(); } @@ -11203,10 +11203,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 _iter1286; - for (_iter1286 = this->new_parts.begin(); _iter1286 != this->new_parts.end(); ++_iter1286) + std::vector<PartitionSpec> ::const_iterator _iter1313; + for (_iter1313 = this->new_parts.begin(); _iter1313 != this->new_parts.end(); ++_iter1313) { - xfer += (*_iter1286).write(oprot); + xfer += (*_iter1313).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11230,10 +11230,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 _iter1287; - for (_iter1287 = (*(this->new_parts)).begin(); _iter1287 != (*(this->new_parts)).end(); ++_iter1287) + std::vector<PartitionSpec> ::const_iterator _iter1314; + for (_iter1314 = (*(this->new_parts)).begin(); _iter1314 != (*(this->new_parts)).end(); ++_iter1314) { - xfer += (*_iter1287).write(oprot); + xfer += (*_iter1314).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11458,14 +11458,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1288; - ::apache::thrift::protocol::TType _etype1291; - xfer += iprot->readListBegin(_etype1291, _size1288); - this->part_vals.resize(_size1288); - uint32_t _i1292; - for (_i1292 = 0; _i1292 < _size1288; ++_i1292) + uint32_t _size1315; + ::apache::thrift::protocol::TType _etype1318; + xfer += iprot->readListBegin(_etype1318, _size1315); + this->part_vals.resize(_size1315); + uint32_t _i1319; + for (_i1319 = 0; _i1319 < _size1315; ++_i1319) { - xfer += iprot->readString(this->part_vals[_i1292]); + xfer += iprot->readString(this->part_vals[_i1319]); } xfer += iprot->readListEnd(); } @@ -11502,10 +11502,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 _iter1293; - for (_iter1293 = this->part_vals.begin(); _iter1293 != this->part_vals.end(); ++_iter1293) + std::vector<std::string> ::const_iterator _iter1320; + for (_iter1320 = this->part_vals.begin(); _iter1320 != this->part_vals.end(); ++_iter1320) { - xfer += oprot->writeString((*_iter1293)); + xfer += oprot->writeString((*_iter1320)); } xfer += oprot->writeListEnd(); } @@ -11537,10 +11537,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 _iter1294; - for (_iter1294 = (*(this->part_vals)).begin(); _iter1294 != (*(this->part_vals)).end(); ++_iter1294) + std::vector<std::string> ::const_iterator _iter1321; + for (_iter1321 = (*(this->part_vals)).begin(); _iter1321 != (*(this->part_vals)).end(); ++_iter1321) { - xfer += oprot->writeString((*_iter1294)); + xfer += oprot->writeString((*_iter1321)); } xfer += oprot->writeListEnd(); } @@ -12012,14 +12012,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1295; - ::apache::thrift::protocol::TType _etype1298; - xfer += iprot->readListBegin(_etype1298, _size1295); - this->part_vals.resize(_size1295); - uint32_t _i1299; - for (_i1299 = 0; _i1299 < _size1295; ++_i1299) + uint32_t _size1322; + ::apache::thrift::protocol::TType _etype1325; + xfer += iprot->readListBegin(_etype1325, _size1322); + this->part_vals.resize(_size1322); + uint32_t _i1326; + for (_i1326 = 0; _i1326 < _size1322; ++_i1326) { - xfer += iprot->readString(this->part_vals[_i1299]); + xfer += iprot->readString(this->part_vals[_i1326]); } xfer += iprot->readListEnd(); } @@ -12064,10 +12064,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 _iter1300; - for (_iter1300 = this->part_vals.begin(); _iter1300 != this->part_vals.end(); ++_iter1300) + std::vector<std::string> ::const_iterator _iter1327; + for (_iter1327 = this->part_vals.begin(); _iter1327 != this->part_vals.end(); ++_iter1327) { - xfer += oprot->writeString((*_iter1300)); + xfer += oprot->writeString((*_iter1327)); } xfer += oprot->writeListEnd(); } @@ -12103,10 +12103,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 _iter1301; - for (_iter1301 = (*(this->part_vals)).begin(); _iter1301 != (*(this->part_vals)).end(); ++_iter1301) + std::vector<std::string> ::const_iterator _iter1328; + for (_iter1328 = (*(this->part_vals)).begin(); _iter1328 != (*(this->part_vals)).end(); ++_iter1328) { - xfer += oprot->writeString((*_iter1301)); + xfer += oprot->writeString((*_iter1328)); } xfer += oprot->writeListEnd(); } @@ -12909,14 +12909,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1302; - ::apache::thrift::protocol::TType _etype1305; - xfer += iprot->readListBegin(_etype1305, _size1302); - this->part_vals.resize(_size1302); - uint32_t _i1306; - for (_i1306 = 0; _i1306 < _size1302; ++_i1306) + uint32_t _size1329; + ::apache::thrift::protocol::TType _etype1332; + xfer += iprot->readListBegin(_etype1332, _size1329); + this->part_vals.resize(_size1329); + uint32_t _i1333; + for (_i1333 = 0; _i1333 < _size1329; ++_i1333) { - xfer += iprot->readString(this->part_vals[_i1306]); + xfer += iprot->readString(this->part_vals[_i1333]); } xfer += iprot->readListEnd(); } @@ -12961,10 +12961,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 _iter1307; - for (_iter1307 = this->part_vals.begin(); _iter1307 != this->part_vals.end(); ++_iter1307) + std::vector<std::string> ::const_iterator _iter1334; + for (_iter1334 = this->part_vals.begin(); _iter1334 != this->part_vals.end(); ++_iter1334) { - xfer += oprot->writeString((*_iter1307)); + xfer += oprot->writeString((*_iter1334)); } xfer += oprot->writeListEnd(); } @@ -13000,10 +13000,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 _iter1308; - for (_iter1308 = (*(this->part_vals)).begin(); _iter1308 != (*(this->part_vals)).end(); ++_iter1308) + std::vector<std::string> ::const_iterator _iter1335; + for (_iter1335 = (*(this->part_vals)).begin(); _iter1335 != (*(this->part_vals)).end(); ++_iter1335) { - xfer += oprot->writeString((*_iter1308)); + xfer += oprot->writeString((*_iter1335)); } xfer += oprot->writeListEnd(); } @@ -13212,14 +13212,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1309; - ::apache::thrift::protocol::TType _etype1312; - xfer += iprot->readListBegin(_etype1312, _size1309); - this->part_vals.resize(_size1309); - uint32_t _i1313; - for (_i1313 = 0; _i1313 < _size1309; ++_i1313) + uint32_t _size1336; + ::apache::thrift::protocol::TType _etype1339; + xfer += iprot->readListBegin(_etype1339, _size1336); + this->part_vals.resize(_size1336); + uint32_t _i1340; + for (_i1340 = 0; _i1340 < _size1336; ++_i1340) { - xfer += iprot->readString(this->part_vals[_i1313]); + xfer += iprot->readString(this->part_vals[_i1340]); } xfer += iprot->readListEnd(); } @@ -13272,10 +13272,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 _iter1314; - for (_iter1314 = this->part_vals.begin(); _iter1314 != this->part_vals.end(); ++_iter1314) + std::vector<std::string> ::const_iterator _iter1341; + for (_iter1341 = this->part_vals.begin(); _iter1341 != this->part_vals.end(); ++_iter1341) { - xfer += oprot->writeString((*_iter1314)); + xfer += oprot->writeString((*_iter1341)); } xfer += oprot->writeListEnd(); } @@ -13315,10 +13315,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 _iter1315; - for (_iter1315 = (*(this->part_vals)).begin(); _iter1315 != (*(this->part_vals)).end(); ++_iter1315) + std::vector<std::string> ::const_iterator _iter1342; + for (_iter1342 = (*(this->part_vals)).begin(); _iter1342 != (*(this->part_vals)).end(); ++_iter1342) { - xfer += oprot->writeString((*_iter1315)); + xfer += oprot->writeString((*_iter1342)); } xfer += oprot->writeListEnd(); } @@ -14324,14 +14324,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1316; - ::apache::thrift::protocol::TType _etype1319; - xfer += iprot->readListBegin(_etype1319, _size1316); - this->part_vals.resize(_size1316); - uint32_t _i1320; - for (_i1320 = 0; _i1320 < _size1316; ++_i1320) + uint32_t _size1343; + ::apache::thrift::protocol::TType _etype1346; + xfer += iprot->readListBegin(_etype1346, _size1343); + this->part_vals.resize(_size1343); + uint32_t _i1347; + for (_i1347 = 0; _i1347 < _size1343; ++_i1347) { - xfer += iprot->readString(this->part_vals[_i1320]); + xfer += iprot->readString(this->part_vals[_i1347]); } xfer += iprot->readListEnd(); } @@ -14368,10 +14368,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 _iter1321; - for (_iter1321 = this->part_vals.begin(); _iter1321 != this->part_vals.end(); ++_iter1321) + std::vector<std::string> ::const_iterator _iter1348; + for (_iter1348 = this->part_vals.begin(); _iter1348 != this->part_vals.end(); ++_iter1348) { - xfer += oprot->writeString((*_iter1321)); + xfer += oprot->writeString((*_iter1348)); } xfer += oprot->writeListEnd(); } @@ -14403,10 +14403,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 _iter1322; - for (_iter1322 = (*(this->part_vals)).begin(); _iter1322 != (*(this->part_vals)).end(); ++_iter1322) + std::vector<std::string> ::const_iterator _iter1349; + for (_iter1349 = (*(this->part_vals)).begin(); _iter1349 != (*(this->part_vals)).end(); ++_iter1349) { - xfer += oprot->writeString((*_iter1322)); + xfer += oprot->writeString((*_iter1349)); } xfer += oprot->writeListEnd(); } @@ -14595,17 +14595,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1323; - ::apache::thrift::protocol::TType _ktype1324; - ::apache::thrift::protocol::TType _vtype1325; - xfer += iprot->readMapBegin(_ktype1324, _vtype1325, _size1323); - uint32_t _i1327; - for (_i1327 = 0; _i1327 < _size1323; ++_i1327) + uint32_t _size1350; + ::apache::thrift::protocol::TType _ktype1351; + ::apache::thrift::protocol::TType _vtype1352; + xfer += iprot->readMapBegin(_ktype1351, _vtype1352, _size1350); + uint32_t _i1354; + for (_i1354 = 0; _i1354 < _size1350; ++_i1354) { - std::string _key1328; - xfer += iprot->readString(_key1328); - std::string& _val1329 = this->partitionSpecs[_key1328]; - xfer += iprot->readString(_val1329); + std::string _key1355; + xfer += iprot->readString(_key1355); + std::string& _val1356 = this->partitionSpecs[_key1355]; + xfer += iprot->readString(_val1356); } xfer += iprot->readMapEnd(); } @@ -14666,11 +14666,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::write(::apache::thrift::pr xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionSpecs.size())); - std::map<std::string, std::string> ::const_iterator _iter1330; - for (_iter1330 = this->partitionSpecs.begin(); _iter1330 != this->partitionSpecs.end(); ++_iter1330) + std::map<std::string, std::string> ::const_iterator _iter1357; + for (_iter1357 = this->partitionSpecs.begin(); _iter1357 != this->partitionSpecs.end(); ++_iter1357) { - xfer += oprot->writeString(_iter1330->first); - xfer += oprot->writeString(_iter1330->second); + xfer += oprot->writeString(_iter1357->first); + xfer += oprot->writeString(_iter1357->second); } xfer += oprot->writeMapEnd(); } @@ -14710,11 +14710,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_pargs::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->partitionSpecs)).size())); - std::map<std::string, std::string> ::const_iterator _iter1331; - for (_iter1331 = (*(this->partitionSpecs)).begin(); _iter1331 != (*(this->partitionSpecs)).end(); ++_iter1331) + std::map<std::string, std::string> ::const_iterator _iter1358; + for (_iter1358 = (*(this->partitionSpecs)).begin(); _iter1358 != (*(this->partitionSpecs)).end(); ++_iter1358) { - xfer += oprot->writeString(_iter1331->first); - xfer += oprot->writeString(_iter1331->second); + xfer += oprot->writeString(_iter1358->first); + xfer += oprot->writeString(_iter1358->second); } xfer += oprot->writeMapEnd(); } @@ -14959,17 +14959,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1332; - ::apache::thrift::protocol::TType _ktype1333; - ::apache::thrift::protocol::TType _vtype1334; - xfer += iprot->readMapBegin(_ktype1333, _vtype1334, _size1332); - uint32_t _i1336; - for (_i1336 = 0; _i1336 < _size1332; ++_i1336) + uint32_t _size1359; + ::apache::thrift::protocol::TType _ktype1360; + ::apache::thrift::protocol::TType _vtype1361; + xfer += iprot->readMapBegin(_ktype1360, _vtype1361, _size1359); + uint32_t _i1363; + for (_i1363 = 0; _i1363 < _size1359; ++_i1363) { - std::string _key1337; - xfer += iprot->readString(_key1337); - std::string& _val1338 = this->partitionSpecs[_key1337]; - xfer += iprot->readString(_val1338); + std::string _key1364; + xfer += iprot->readString(_key1364); + std::string& _val1365 = this->partitionSpecs[_key1364]; + xfer += iprot->readString(_val1365); } xfer += iprot->readMapEnd(); } @@ -15030,11 +15030,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::write(::apache::thrift::p xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1); { xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionSpecs.size())); - std::map<std::string, std::string> ::const_iterator _iter1339; - for (_iter1339 = this->partitionSpecs.begin(); _iter1339 != this->partitionSpecs.end(); ++_iter1339) + std::map<std::string, std::string> ::const_iterator _iter1366; + for (_iter1366 = this->partitionSpecs.begin(); _iter1366 != this->partitionSpecs.end(); ++_iter1366) { - xfer += oprot->writeString(_iter1339->fir
<TRUNCATED>
