http://git-wip-us.apache.org/repos/asf/hive/blob/a9e1acaf/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 af0fd6b..14718b5 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 _size1049; - ::apache::thrift::protocol::TType _etype1052; - xfer += iprot->readListBegin(_etype1052, _size1049); - this->success.resize(_size1049); - uint32_t _i1053; - for (_i1053 = 0; _i1053 < _size1049; ++_i1053) + uint32_t _size1076; + ::apache::thrift::protocol::TType _etype1079; + xfer += iprot->readListBegin(_etype1079, _size1076); + this->success.resize(_size1076); + uint32_t _i1080; + for (_i1080 = 0; _i1080 < _size1076; ++_i1080) { - xfer += iprot->readString(this->success[_i1053]); + xfer += iprot->readString(this->success[_i1080]); } 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 _iter1054; - for (_iter1054 = this->success.begin(); _iter1054 != this->success.end(); ++_iter1054) + std::vector<std::string> ::const_iterator _iter1081; + for (_iter1081 = this->success.begin(); _iter1081 != this->success.end(); ++_iter1081) { - xfer += oprot->writeString((*_iter1054)); + xfer += oprot->writeString((*_iter1081)); } 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 _size1055; - ::apache::thrift::protocol::TType _etype1058; - xfer += iprot->readListBegin(_etype1058, _size1055); - (*(this->success)).resize(_size1055); - uint32_t _i1059; - for (_i1059 = 0; _i1059 < _size1055; ++_i1059) + 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) { - xfer += iprot->readString((*(this->success))[_i1059]); + xfer += iprot->readString((*(this->success))[_i1086]); } 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 _size1060; - ::apache::thrift::protocol::TType _etype1063; - xfer += iprot->readListBegin(_etype1063, _size1060); - this->success.resize(_size1060); - uint32_t _i1064; - for (_i1064 = 0; _i1064 < _size1060; ++_i1064) + uint32_t _size1087; + ::apache::thrift::protocol::TType _etype1090; + xfer += iprot->readListBegin(_etype1090, _size1087); + this->success.resize(_size1087); + uint32_t _i1091; + for (_i1091 = 0; _i1091 < _size1087; ++_i1091) { - xfer += iprot->readString(this->success[_i1064]); + xfer += iprot->readString(this->success[_i1091]); } 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 _iter1065; - for (_iter1065 = this->success.begin(); _iter1065 != this->success.end(); ++_iter1065) + std::vector<std::string> ::const_iterator _iter1092; + for (_iter1092 = this->success.begin(); _iter1092 != this->success.end(); ++_iter1092) { - xfer += oprot->writeString((*_iter1065)); + xfer += oprot->writeString((*_iter1092)); } 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 _size1066; - ::apache::thrift::protocol::TType _etype1069; - xfer += iprot->readListBegin(_etype1069, _size1066); - (*(this->success)).resize(_size1066); - uint32_t _i1070; - for (_i1070 = 0; _i1070 < _size1066; ++_i1070) + 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) { - xfer += iprot->readString((*(this->success))[_i1070]); + xfer += iprot->readString((*(this->success))[_i1097]); } 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 _size1071; - ::apache::thrift::protocol::TType _ktype1072; - ::apache::thrift::protocol::TType _vtype1073; - xfer += iprot->readMapBegin(_ktype1072, _vtype1073, _size1071); - uint32_t _i1075; - for (_i1075 = 0; _i1075 < _size1071; ++_i1075) + uint32_t _size1098; + ::apache::thrift::protocol::TType _ktype1099; + ::apache::thrift::protocol::TType _vtype1100; + xfer += iprot->readMapBegin(_ktype1099, _vtype1100, _size1098); + uint32_t _i1102; + for (_i1102 = 0; _i1102 < _size1098; ++_i1102) { - std::string _key1076; - xfer += iprot->readString(_key1076); - Type& _val1077 = this->success[_key1076]; - xfer += _val1077.read(iprot); + std::string _key1103; + xfer += iprot->readString(_key1103); + Type& _val1104 = this->success[_key1103]; + xfer += _val1104.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 _iter1078; - for (_iter1078 = this->success.begin(); _iter1078 != this->success.end(); ++_iter1078) + std::map<std::string, Type> ::const_iterator _iter1105; + for (_iter1105 = this->success.begin(); _iter1105 != this->success.end(); ++_iter1105) { - xfer += oprot->writeString(_iter1078->first); - xfer += _iter1078->second.write(oprot); + xfer += oprot->writeString(_iter1105->first); + xfer += _iter1105->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 _size1079; - ::apache::thrift::protocol::TType _ktype1080; - ::apache::thrift::protocol::TType _vtype1081; - xfer += iprot->readMapBegin(_ktype1080, _vtype1081, _size1079); - uint32_t _i1083; - for (_i1083 = 0; _i1083 < _size1079; ++_i1083) + uint32_t _size1106; + ::apache::thrift::protocol::TType _ktype1107; + ::apache::thrift::protocol::TType _vtype1108; + xfer += iprot->readMapBegin(_ktype1107, _vtype1108, _size1106); + uint32_t _i1110; + for (_i1110 = 0; _i1110 < _size1106; ++_i1110) { - std::string _key1084; - xfer += iprot->readString(_key1084); - Type& _val1085 = (*(this->success))[_key1084]; - xfer += _val1085.read(iprot); + std::string _key1111; + xfer += iprot->readString(_key1111); + Type& _val1112 = (*(this->success))[_key1111]; + xfer += _val1112.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 _size1086; - ::apache::thrift::protocol::TType _etype1089; - xfer += iprot->readListBegin(_etype1089, _size1086); - this->success.resize(_size1086); - uint32_t _i1090; - for (_i1090 = 0; _i1090 < _size1086; ++_i1090) + uint32_t _size1113; + ::apache::thrift::protocol::TType _etype1116; + xfer += iprot->readListBegin(_etype1116, _size1113); + this->success.resize(_size1113); + uint32_t _i1117; + for (_i1117 = 0; _i1117 < _size1113; ++_i1117) { - xfer += this->success[_i1090].read(iprot); + xfer += this->success[_i1117].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 _iter1091; - for (_iter1091 = this->success.begin(); _iter1091 != this->success.end(); ++_iter1091) + std::vector<FieldSchema> ::const_iterator _iter1118; + for (_iter1118 = this->success.begin(); _iter1118 != this->success.end(); ++_iter1118) { - xfer += (*_iter1091).write(oprot); + xfer += (*_iter1118).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 _size1092; - ::apache::thrift::protocol::TType _etype1095; - xfer += iprot->readListBegin(_etype1095, _size1092); - (*(this->success)).resize(_size1092); - uint32_t _i1096; - for (_i1096 = 0; _i1096 < _size1092; ++_i1096) + uint32_t _size1119; + ::apache::thrift::protocol::TType _etype1122; + xfer += iprot->readListBegin(_etype1122, _size1119); + (*(this->success)).resize(_size1119); + uint32_t _i1123; + for (_i1123 = 0; _i1123 < _size1119; ++_i1123) { - xfer += (*(this->success))[_i1096].read(iprot); + xfer += (*(this->success))[_i1123].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 _size1097; - ::apache::thrift::protocol::TType _etype1100; - xfer += iprot->readListBegin(_etype1100, _size1097); - this->success.resize(_size1097); - uint32_t _i1101; - for (_i1101 = 0; _i1101 < _size1097; ++_i1101) + uint32_t _size1124; + ::apache::thrift::protocol::TType _etype1127; + xfer += iprot->readListBegin(_etype1127, _size1124); + this->success.resize(_size1124); + uint32_t _i1128; + for (_i1128 = 0; _i1128 < _size1124; ++_i1128) { - xfer += this->success[_i1101].read(iprot); + xfer += this->success[_i1128].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 _iter1102; - for (_iter1102 = this->success.begin(); _iter1102 != this->success.end(); ++_iter1102) + std::vector<FieldSchema> ::const_iterator _iter1129; + for (_iter1129 = this->success.begin(); _iter1129 != this->success.end(); ++_iter1129) { - xfer += (*_iter1102).write(oprot); + xfer += (*_iter1129).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 _size1103; - ::apache::thrift::protocol::TType _etype1106; - xfer += iprot->readListBegin(_etype1106, _size1103); - (*(this->success)).resize(_size1103); - uint32_t _i1107; - for (_i1107 = 0; _i1107 < _size1103; ++_i1107) + uint32_t _size1130; + ::apache::thrift::protocol::TType _etype1133; + xfer += iprot->readListBegin(_etype1133, _size1130); + (*(this->success)).resize(_size1130); + uint32_t _i1134; + for (_i1134 = 0; _i1134 < _size1130; ++_i1134) { - xfer += (*(this->success))[_i1107].read(iprot); + xfer += (*(this->success))[_i1134].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 _size1108; - ::apache::thrift::protocol::TType _etype1111; - xfer += iprot->readListBegin(_etype1111, _size1108); - this->success.resize(_size1108); - uint32_t _i1112; - for (_i1112 = 0; _i1112 < _size1108; ++_i1112) + uint32_t _size1135; + ::apache::thrift::protocol::TType _etype1138; + xfer += iprot->readListBegin(_etype1138, _size1135); + this->success.resize(_size1135); + uint32_t _i1139; + for (_i1139 = 0; _i1139 < _size1135; ++_i1139) { - xfer += this->success[_i1112].read(iprot); + xfer += this->success[_i1139].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 _iter1113; - for (_iter1113 = this->success.begin(); _iter1113 != this->success.end(); ++_iter1113) + std::vector<FieldSchema> ::const_iterator _iter1140; + for (_iter1140 = this->success.begin(); _iter1140 != this->success.end(); ++_iter1140) { - xfer += (*_iter1113).write(oprot); + xfer += (*_iter1140).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 _size1114; - ::apache::thrift::protocol::TType _etype1117; - xfer += iprot->readListBegin(_etype1117, _size1114); - (*(this->success)).resize(_size1114); - uint32_t _i1118; - for (_i1118 = 0; _i1118 < _size1114; ++_i1118) + uint32_t _size1141; + ::apache::thrift::protocol::TType _etype1144; + xfer += iprot->readListBegin(_etype1144, _size1141); + (*(this->success)).resize(_size1141); + uint32_t _i1145; + for (_i1145 = 0; _i1145 < _size1141; ++_i1145) { - xfer += (*(this->success))[_i1118].read(iprot); + xfer += (*(this->success))[_i1145].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 _size1119; - ::apache::thrift::protocol::TType _etype1122; - xfer += iprot->readListBegin(_etype1122, _size1119); - this->success.resize(_size1119); - uint32_t _i1123; - for (_i1123 = 0; _i1123 < _size1119; ++_i1123) + uint32_t _size1146; + ::apache::thrift::protocol::TType _etype1149; + xfer += iprot->readListBegin(_etype1149, _size1146); + this->success.resize(_size1146); + uint32_t _i1150; + for (_i1150 = 0; _i1150 < _size1146; ++_i1150) { - xfer += this->success[_i1123].read(iprot); + xfer += this->success[_i1150].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 _iter1124; - for (_iter1124 = this->success.begin(); _iter1124 != this->success.end(); ++_iter1124) + std::vector<FieldSchema> ::const_iterator _iter1151; + for (_iter1151 = this->success.begin(); _iter1151 != this->success.end(); ++_iter1151) { - xfer += (*_iter1124).write(oprot); + xfer += (*_iter1151).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 _size1125; - ::apache::thrift::protocol::TType _etype1128; - xfer += iprot->readListBegin(_etype1128, _size1125); - (*(this->success)).resize(_size1125); - uint32_t _i1129; - for (_i1129 = 0; _i1129 < _size1125; ++_i1129) + uint32_t _size1152; + ::apache::thrift::protocol::TType _etype1155; + xfer += iprot->readListBegin(_etype1155, _size1152); + (*(this->success)).resize(_size1152); + uint32_t _i1156; + for (_i1156 = 0; _i1156 < _size1152; ++_i1156) { - xfer += (*(this->success))[_i1129].read(iprot); + xfer += (*(this->success))[_i1156].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 _size1130; - ::apache::thrift::protocol::TType _etype1133; - xfer += iprot->readListBegin(_etype1133, _size1130); - this->primaryKeys.resize(_size1130); - uint32_t _i1134; - for (_i1134 = 0; _i1134 < _size1130; ++_i1134) + uint32_t _size1157; + ::apache::thrift::protocol::TType _etype1160; + xfer += iprot->readListBegin(_etype1160, _size1157); + this->primaryKeys.resize(_size1157); + uint32_t _i1161; + for (_i1161 = 0; _i1161 < _size1157; ++_i1161) { - xfer += this->primaryKeys[_i1134].read(iprot); + xfer += this->primaryKeys[_i1161].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 _size1135; - ::apache::thrift::protocol::TType _etype1138; - xfer += iprot->readListBegin(_etype1138, _size1135); - this->foreignKeys.resize(_size1135); - uint32_t _i1139; - for (_i1139 = 0; _i1139 < _size1135; ++_i1139) + uint32_t _size1162; + ::apache::thrift::protocol::TType _etype1165; + xfer += iprot->readListBegin(_etype1165, _size1162); + this->foreignKeys.resize(_size1162); + uint32_t _i1166; + for (_i1166 = 0; _i1166 < _size1162; ++_i1166) { - xfer += this->foreignKeys[_i1139].read(iprot); + xfer += this->foreignKeys[_i1166].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 _size1140; - ::apache::thrift::protocol::TType _etype1143; - xfer += iprot->readListBegin(_etype1143, _size1140); - this->uniqueConstraints.resize(_size1140); - uint32_t _i1144; - for (_i1144 = 0; _i1144 < _size1140; ++_i1144) + uint32_t _size1167; + ::apache::thrift::protocol::TType _etype1170; + xfer += iprot->readListBegin(_etype1170, _size1167); + this->uniqueConstraints.resize(_size1167); + uint32_t _i1171; + for (_i1171 = 0; _i1171 < _size1167; ++_i1171) { - xfer += this->uniqueConstraints[_i1144].read(iprot); + xfer += this->uniqueConstraints[_i1171].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 _size1145; - ::apache::thrift::protocol::TType _etype1148; - xfer += iprot->readListBegin(_etype1148, _size1145); - this->notNullConstraints.resize(_size1145); - uint32_t _i1149; - for (_i1149 = 0; _i1149 < _size1145; ++_i1149) + uint32_t _size1172; + ::apache::thrift::protocol::TType _etype1175; + xfer += iprot->readListBegin(_etype1175, _size1172); + this->notNullConstraints.resize(_size1172); + uint32_t _i1176; + for (_i1176 = 0; _i1176 < _size1172; ++_i1176) { - xfer += this->notNullConstraints[_i1149].read(iprot); + xfer += this->notNullConstraints[_i1176].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 _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(); } @@ -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 _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(); } @@ -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 _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(); } @@ -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 _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(); } @@ -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 _iter1154; - for (_iter1154 = (*(this->primaryKeys)).begin(); _iter1154 != (*(this->primaryKeys)).end(); ++_iter1154) + std::vector<SQLPrimaryKey> ::const_iterator _iter1181; + for (_iter1181 = (*(this->primaryKeys)).begin(); _iter1181 != (*(this->primaryKeys)).end(); ++_iter1181) { - xfer += (*_iter1154).write(oprot); + xfer += (*_iter1181).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 _iter1155; - for (_iter1155 = (*(this->foreignKeys)).begin(); _iter1155 != (*(this->foreignKeys)).end(); ++_iter1155) + std::vector<SQLForeignKey> ::const_iterator _iter1182; + for (_iter1182 = (*(this->foreignKeys)).begin(); _iter1182 != (*(this->foreignKeys)).end(); ++_iter1182) { - xfer += (*_iter1155).write(oprot); + xfer += (*_iter1182).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 _iter1156; - for (_iter1156 = (*(this->uniqueConstraints)).begin(); _iter1156 != (*(this->uniqueConstraints)).end(); ++_iter1156) + std::vector<SQLUniqueConstraint> ::const_iterator _iter1183; + for (_iter1183 = (*(this->uniqueConstraints)).begin(); _iter1183 != (*(this->uniqueConstraints)).end(); ++_iter1183) { - xfer += (*_iter1156).write(oprot); + xfer += (*_iter1183).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 _iter1157; - for (_iter1157 = (*(this->notNullConstraints)).begin(); _iter1157 != (*(this->notNullConstraints)).end(); ++_iter1157) + std::vector<SQLNotNullConstraint> ::const_iterator _iter1184; + for (_iter1184 = (*(this->notNullConstraints)).begin(); _iter1184 != (*(this->notNullConstraints)).end(); ++_iter1184) { - xfer += (*_iter1157).write(oprot); + xfer += (*_iter1184).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 _size1158; - ::apache::thrift::protocol::TType _etype1161; - xfer += iprot->readListBegin(_etype1161, _size1158); - this->partNames.resize(_size1158); - uint32_t _i1162; - for (_i1162 = 0; _i1162 < _size1158; ++_i1162) + uint32_t _size1185; + ::apache::thrift::protocol::TType _etype1188; + xfer += iprot->readListBegin(_etype1188, _size1185); + this->partNames.resize(_size1185); + uint32_t _i1189; + for (_i1189 = 0; _i1189 < _size1185; ++_i1189) { - xfer += iprot->readString(this->partNames[_i1162]); + xfer += iprot->readString(this->partNames[_i1189]); } 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 _iter1163; - for (_iter1163 = this->partNames.begin(); _iter1163 != this->partNames.end(); ++_iter1163) + std::vector<std::string> ::const_iterator _iter1190; + for (_iter1190 = this->partNames.begin(); _iter1190 != this->partNames.end(); ++_iter1190) { - xfer += oprot->writeString((*_iter1163)); + xfer += oprot->writeString((*_iter1190)); } 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 _iter1164; - for (_iter1164 = (*(this->partNames)).begin(); _iter1164 != (*(this->partNames)).end(); ++_iter1164) + std::vector<std::string> ::const_iterator _iter1191; + for (_iter1191 = (*(this->partNames)).begin(); _iter1191 != (*(this->partNames)).end(); ++_iter1191) { - xfer += oprot->writeString((*_iter1164)); + xfer += oprot->writeString((*_iter1191)); } 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 _size1165; - ::apache::thrift::protocol::TType _etype1168; - xfer += iprot->readListBegin(_etype1168, _size1165); - this->success.resize(_size1165); - uint32_t _i1169; - for (_i1169 = 0; _i1169 < _size1165; ++_i1169) + uint32_t _size1192; + ::apache::thrift::protocol::TType _etype1195; + xfer += iprot->readListBegin(_etype1195, _size1192); + this->success.resize(_size1192); + uint32_t _i1196; + for (_i1196 = 0; _i1196 < _size1192; ++_i1196) { - xfer += iprot->readString(this->success[_i1169]); + xfer += iprot->readString(this->success[_i1196]); } 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 _iter1170; - for (_iter1170 = this->success.begin(); _iter1170 != this->success.end(); ++_iter1170) + std::vector<std::string> ::const_iterator _iter1197; + for (_iter1197 = this->success.begin(); _iter1197 != this->success.end(); ++_iter1197) { - xfer += oprot->writeString((*_iter1170)); + xfer += oprot->writeString((*_iter1197)); } 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 _size1171; - ::apache::thrift::protocol::TType _etype1174; - xfer += iprot->readListBegin(_etype1174, _size1171); - (*(this->success)).resize(_size1171); - uint32_t _i1175; - for (_i1175 = 0; _i1175 < _size1171; ++_i1175) + uint32_t _size1198; + ::apache::thrift::protocol::TType _etype1201; + xfer += iprot->readListBegin(_etype1201, _size1198); + (*(this->success)).resize(_size1198); + uint32_t _i1202; + for (_i1202 = 0; _i1202 < _size1198; ++_i1202) { - xfer += iprot->readString((*(this->success))[_i1175]); + xfer += iprot->readString((*(this->success))[_i1202]); } 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 _size1176; - ::apache::thrift::protocol::TType _etype1179; - xfer += iprot->readListBegin(_etype1179, _size1176); - this->success.resize(_size1176); - uint32_t _i1180; - for (_i1180 = 0; _i1180 < _size1176; ++_i1180) + uint32_t _size1203; + ::apache::thrift::protocol::TType _etype1206; + xfer += iprot->readListBegin(_etype1206, _size1203); + this->success.resize(_size1203); + uint32_t _i1207; + for (_i1207 = 0; _i1207 < _size1203; ++_i1207) { - xfer += iprot->readString(this->success[_i1180]); + xfer += iprot->readString(this->success[_i1207]); } 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 _iter1181; - for (_iter1181 = this->success.begin(); _iter1181 != this->success.end(); ++_iter1181) + std::vector<std::string> ::const_iterator _iter1208; + for (_iter1208 = this->success.begin(); _iter1208 != this->success.end(); ++_iter1208) { - xfer += oprot->writeString((*_iter1181)); + xfer += oprot->writeString((*_iter1208)); } 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 _size1182; - ::apache::thrift::protocol::TType _etype1185; - xfer += iprot->readListBegin(_etype1185, _size1182); - (*(this->success)).resize(_size1182); - uint32_t _i1186; - for (_i1186 = 0; _i1186 < _size1182; ++_i1186) + uint32_t _size1209; + ::apache::thrift::protocol::TType _etype1212; + xfer += iprot->readListBegin(_etype1212, _size1209); + (*(this->success)).resize(_size1209); + uint32_t _i1213; + for (_i1213 = 0; _i1213 < _size1209; ++_i1213) { - xfer += iprot->readString((*(this->success))[_i1186]); + xfer += iprot->readString((*(this->success))[_i1213]); } 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 _size1187; - ::apache::thrift::protocol::TType _etype1190; - xfer += iprot->readListBegin(_etype1190, _size1187); - this->success.resize(_size1187); - uint32_t _i1191; - for (_i1191 = 0; _i1191 < _size1187; ++_i1191) + uint32_t _size1214; + ::apache::thrift::protocol::TType _etype1217; + xfer += iprot->readListBegin(_etype1217, _size1214); + this->success.resize(_size1214); + uint32_t _i1218; + for (_i1218 = 0; _i1218 < _size1214; ++_i1218) { - xfer += iprot->readString(this->success[_i1191]); + xfer += iprot->readString(this->success[_i1218]); } 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 _iter1192; - for (_iter1192 = this->success.begin(); _iter1192 != this->success.end(); ++_iter1192) + std::vector<std::string> ::const_iterator _iter1219; + for (_iter1219 = this->success.begin(); _iter1219 != this->success.end(); ++_iter1219) { - xfer += oprot->writeString((*_iter1192)); + xfer += oprot->writeString((*_iter1219)); } 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 _size1193; - ::apache::thrift::protocol::TType _etype1196; - xfer += iprot->readListBegin(_etype1196, _size1193); - (*(this->success)).resize(_size1193); - uint32_t _i1197; - for (_i1197 = 0; _i1197 < _size1193; ++_i1197) + uint32_t _size1220; + ::apache::thrift::protocol::TType _etype1223; + xfer += iprot->readListBegin(_etype1223, _size1220); + (*(this->success)).resize(_size1220); + uint32_t _i1224; + for (_i1224 = 0; _i1224 < _size1220; ++_i1224) { - xfer += iprot->readString((*(this->success))[_i1197]); + xfer += iprot->readString((*(this->success))[_i1224]); } 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 _size1198; - ::apache::thrift::protocol::TType _etype1201; - xfer += iprot->readListBegin(_etype1201, _size1198); - this->tbl_types.resize(_size1198); - uint32_t _i1202; - for (_i1202 = 0; _i1202 < _size1198; ++_i1202) + uint32_t _size1225; + ::apache::thrift::protocol::TType _etype1228; + xfer += iprot->readListBegin(_etype1228, _size1225); + this->tbl_types.resize(_size1225); + uint32_t _i1229; + for (_i1229 = 0; _i1229 < _size1225; ++_i1229) { - xfer += iprot->readString(this->tbl_types[_i1202]); + xfer += iprot->readString(this->tbl_types[_i1229]); } 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 _iter1203; - for (_iter1203 = this->tbl_types.begin(); _iter1203 != this->tbl_types.end(); ++_iter1203) + std::vector<std::string> ::const_iterator _iter1230; + for (_iter1230 = this->tbl_types.begin(); _iter1230 != this->tbl_types.end(); ++_iter1230) { - xfer += oprot->writeString((*_iter1203)); + xfer += oprot->writeString((*_iter1230)); } 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 _iter1204; - for (_iter1204 = (*(this->tbl_types)).begin(); _iter1204 != (*(this->tbl_types)).end(); ++_iter1204) + std::vector<std::string> ::const_iterator _iter1231; + for (_iter1231 = (*(this->tbl_types)).begin(); _iter1231 != (*(this->tbl_types)).end(); ++_iter1231) { - xfer += oprot->writeString((*_iter1204)); + xfer += oprot->writeString((*_iter1231)); } 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 _size1205; - ::apache::thrift::protocol::TType _etype1208; - xfer += iprot->readListBegin(_etype1208, _size1205); - this->success.resize(_size1205); - uint32_t _i1209; - for (_i1209 = 0; _i1209 < _size1205; ++_i1209) + 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 += this->success[_i1209].read(iprot); + xfer += this->success[_i1236].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 _iter1210; - for (_iter1210 = this->success.begin(); _iter1210 != this->success.end(); ++_iter1210) + std::vector<TableMeta> ::const_iterator _iter1237; + for (_iter1237 = this->success.begin(); _iter1237 != this->success.end(); ++_iter1237) { - xfer += (*_iter1210).write(oprot); + xfer += (*_iter1237).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 _size1211; - ::apache::thrift::protocol::TType _etype1214; - xfer += iprot->readListBegin(_etype1214, _size1211); - (*(this->success)).resize(_size1211); - uint32_t _i1215; - for (_i1215 = 0; _i1215 < _size1211; ++_i1215) + 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 += (*(this->success))[_i1215].read(iprot); + xfer += (*(this->success))[_i1242].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 _size1216; - ::apache::thrift::protocol::TType _etype1219; - xfer += iprot->readListBegin(_etype1219, _size1216); - this->success.resize(_size1216); - uint32_t _i1220; - for (_i1220 = 0; _i1220 < _size1216; ++_i1220) + uint32_t _size1243; + ::apache::thrift::protocol::TType _etype1246; + xfer += iprot->readListBegin(_etype1246, _size1243); + this->success.resize(_size1243); + uint32_t _i1247; + for (_i1247 = 0; _i1247 < _size1243; ++_i1247) { - xfer += iprot->readString(this->success[_i1220]); + xfer += iprot->readString(this->success[_i1247]); } 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 _iter1221; - for (_iter1221 = this->success.begin(); _iter1221 != this->success.end(); ++_iter1221) + std::vector<std::string> ::const_iterator _iter1248; + for (_iter1248 = this->success.begin(); _iter1248 != this->success.end(); ++_iter1248) { - xfer += oprot->writeString((*_iter1221)); + xfer += oprot->writeString((*_iter1248)); } 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 _size1222; - ::apache::thrift::protocol::TType _etype1225; - xfer += iprot->readListBegin(_etype1225, _size1222); - (*(this->success)).resize(_size1222); - uint32_t _i1226; - for (_i1226 = 0; _i1226 < _size1222; ++_i1226) + uint32_t _size1249; + ::apache::thrift::protocol::TType _etype1252; + xfer += iprot->readListBegin(_etype1252, _size1249); + (*(this->success)).resize(_size1249); + uint32_t _i1253; + for (_i1253 = 0; _i1253 < _size1249; ++_i1253) { - xfer += iprot->readString((*(this->success))[_i1226]); + xfer += iprot->readString((*(this->success))[_i1253]); } 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 _size1227; - ::apache::thrift::protocol::TType _etype1230; - xfer += iprot->readListBegin(_etype1230, _size1227); - this->tbl_names.resize(_size1227); - uint32_t _i1231; - for (_i1231 = 0; _i1231 < _size1227; ++_i1231) + uint32_t _size1254; + ::apache::thrift::protocol::TType _etype1257; + xfer += iprot->readListBegin(_etype1257, _size1254); + this->tbl_names.resize(_size1254); + uint32_t _i1258; + for (_i1258 = 0; _i1258 < _size1254; ++_i1258) { - xfer += iprot->readString(this->tbl_names[_i1231]); + xfer += iprot->readString(this->tbl_names[_i1258]); } 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 _iter1232; - for (_iter1232 = this->tbl_names.begin(); _iter1232 != this->tbl_names.end(); ++_iter1232) + std::vector<std::string> ::const_iterator _iter1259; + for (_iter1259 = this->tbl_names.begin(); _iter1259 != this->tbl_names.end(); ++_iter1259) { - xfer += oprot->writeString((*_iter1232)); + xfer += oprot->writeString((*_iter1259)); } 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 _iter1233; - for (_iter1233 = (*(this->tbl_names)).begin(); _iter1233 != (*(this->tbl_names)).end(); ++_iter1233) + std::vector<std::string> ::const_iterator _iter1260; + for (_iter1260 = (*(this->tbl_names)).begin(); _iter1260 != (*(this->tbl_names)).end(); ++_iter1260) { - xfer += oprot->writeString((*_iter1233)); + xfer += oprot->writeString((*_iter1260)); } 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 _size1234; - ::apache::thrift::protocol::TType _etype1237; - xfer += iprot->readListBegin(_etype1237, _size1234); - this->success.resize(_size1234); - uint32_t _i1238; - for (_i1238 = 0; _i1238 < _size1234; ++_i1238) + uint32_t _size1261; + ::apache::thrift::protocol::TType _etype1264; + xfer += iprot->readListBegin(_etype1264, _size1261); + this->success.resize(_size1261); + uint32_t _i1265; + for (_i1265 = 0; _i1265 < _size1261; ++_i1265) { - xfer += this->success[_i1238].read(iprot); + xfer += this->success[_i1265].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 _iter1239; - for (_iter1239 = this->success.begin(); _iter1239 != this->success.end(); ++_iter1239) + std::vector<Table> ::const_iterator _iter1266; + for (_iter1266 = this->success.begin(); _iter1266 != this->success.end(); ++_iter1266) { - xfer += (*_iter1239).write(oprot); + xfer += (*_iter1266).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 _size1240; - ::apache::thrift::protocol::TType _etype1243; - xfer += iprot->readListBegin(_etype1243, _size1240); - (*(this->success)).resize(_size1240); - uint32_t _i1244; - for (_i1244 = 0; _i1244 < _size1240; ++_i1244) + uint32_t _size1267; + ::apache::thrift::protocol::TType _etype1270; + xfer += iprot->readListBegin(_etype1270, _size1267); + (*(this->success)).resize(_size1267); + uint32_t _i1271; + for (_i1271 = 0; _i1271 < _size1267; ++_i1271) { - xfer += (*(this->success))[_i1244].read(iprot); + xfer += (*(this->success))[_i1271].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 _size1245; - ::apache::thrift::protocol::TType _etype1248; - xfer += iprot->readListBegin(_etype1248, _size1245); - this->tbl_names.resize(_size1245); - uint32_t _i1249; - for (_i1249 = 0; _i1249 < _size1245; ++_i1249) + uint32_t _size1272; + ::apache::thrift::protocol::TType _etype1275; + xfer += iprot->readListBegin(_etype1275, _size1272); + this->tbl_names.resize(_size1272); + uint32_t _i1276; + for (_i1276 = 0; _i1276 < _size1272; ++_i1276) { - xfer += iprot->readString(this->tbl_names[_i1249]); + xfer += iprot->readString(this->tbl_names[_i1276]); } 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 _iter1250; - for (_iter1250 = this->tbl_names.begin(); _iter1250 != this->tbl_names.end(); ++_iter1250) + std::vector<std::string> ::const_iterator _iter1277; + for (_iter1277 = this->tbl_names.begin(); _iter1277 != this->tbl_names.end(); ++_iter1277) { - xfer += oprot->writeString((*_iter1250)); + xfer += oprot->writeString((*_iter1277)); } 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 _iter1251; - for (_iter1251 = (*(this->tbl_names)).begin(); _iter1251 != (*(this->tbl_names)).end(); ++_iter1251) + std::vector<std::string> ::const_iterator _iter1278; + for (_iter1278 = (*(this->tbl_names)).begin(); _iter1278 != (*(this->tbl_names)).end(); ++_iter1278) { - xfer += oprot->writeString((*_iter1251)); + xfer += oprot->writeString((*_iter1278)); } 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 _size1252; - ::apache::thrift::protocol::TType _ktype1253; - ::apache::thrift::protocol::TType _vtype1254; - xfer += iprot->readMapBegin(_ktype1253, _vtype1254, _size1252); - uint32_t _i1256; - for (_i1256 = 0; _i1256 < _size1252; ++_i1256) + uint32_t _size1279; + ::apache::thrift::protocol::TType _ktype1280; + ::apache::thrift::protocol::TType _vtype1281; + xfer += iprot->readMapBegin(_ktype1280, _vtype1281, _size1279); + uint32_t _i1283; + for (_i1283 = 0; _i1283 < _size1279; ++_i1283) { - std::string _key1257; - xfer += iprot->readString(_key1257); - Materialization& _val1258 = this->success[_key1257]; - xfer += _val1258.read(iprot); + std::string _key1284; + xfer += iprot->readString(_key1284); + Materialization& _val1285 = this->success[_key1284]; + xfer += _val1285.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 _iter1259; - for (_iter1259 = this->success.begin(); _iter1259 != this->success.end(); ++_iter1259) + std::map<std::string, Materialization> ::const_iterator _iter1286; + for (_iter1286 = this->success.begin(); _iter1286 != this->success.end(); ++_iter1286) { - xfer += oprot->writeString(_iter1259->first); - xfer += _iter1259->second.write(oprot); + xfer += oprot->writeString(_iter1286->first); + xfer += _iter1286->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 _size1260; - ::apache::thrift::protocol::TType _ktype1261; - ::apache::thrift::protocol::TType _vtype1262; - xfer += iprot->readMapBegin(_ktype1261, _vtype1262, _size1260); - uint32_t _i1264; - for (_i1264 = 0; _i1264 < _size1260; ++_i1264) + uint32_t _size1287; + ::apache::thrift::protocol::TType _ktype1288; + ::apache::thrift::protocol::TType _vtype1289; + xfer += iprot->readMapBegin(_ktype1288, _vtype1289, _size1287); + uint32_t _i1291; + for (_i1291 = 0; _i1291 < _size1287; ++_i1291) { - std::string _key1265; - xfer += iprot->readString(_key1265); - Materialization& _val1266 = (*(this->success))[_key1265]; - xfer += _val1266.read(iprot); + std::string _key1292; + xfer += iprot->readString(_key1292); + Materialization& _val1293 = (*(this->success))[_key1292]; + xfer += _val1293.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 _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 _size1294; + ::apache::thrift::protocol::TType _etype1297; + xfer += iprot->readListBegin(_etype1297, _size1294); + this->success.resize(_size1294); + uint32_t _i1298; + for (_i1298 = 0; _i1298 < _size1294; ++_i1298) { - xfer += iprot->readString(this->success[_i1271]); + xfer += iprot->readString(this->success[_i1298]); } 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 _iter1272; - for (_iter1272 = this->success.begin(); _iter1272 != this->success.end(); ++_iter1272) + std::vector<std::string> ::const_iterator _iter1299; + for (_iter1299 = this->success.begin(); _iter1299 != this->success.end(); ++_iter1299) { - xfer += oprot->writeString((*_iter1272)); + xfer += oprot->writeString((*_iter1299)); } 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 _size1273; - ::apache::thrift::protocol::TType _etype1276; - xfer += iprot->readListBegin(_etype1276, _size1273); - (*(this->success)).resize(_size1273); - uint32_t _i1277; - for (_i1277 = 0; _i1277 < _size1273; ++_i1277) + uint32_t _size1300; + ::apache::thrift::protocol::TType _etype1303; + xfer += iprot->readListBegin(_etype1303, _size1300); + (*(this->success)).resize(_size1300); + uint32_t _i1304; + for (_i1304 = 0; _i1304 < _size1300; ++_i1304) { - xfer += iprot->readString((*(this->success))[_i1277]); + xfer += iprot->readString((*(this->success))[_i1304]); } 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 _size1278; - ::apache::thrift::protocol::TType _etype1281; - xfer += iprot->readListBegin(_etype1281, _size1278); - this->new_parts.resize(_size1278); - uint32_t _i1282; - for (_i1282 = 0; _i1282 < _size1278; ++_i1282) + uint32_t _size1305; + ::apache::thrift::protocol::TType _etype1308; + xfer += iprot->readListBegin(_etype1308, _size1305); + this->new_parts.resize(_size1305); + uint32_t _i1309; + for (_i1309 = 0; _i1309 < _size1305; ++_i1309) { - xfer += this->new_parts[_i1282].read(iprot); + xfer += this->new_parts[_i1309].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 _iter1283; - for (_iter1283 = this->new_parts.begin(); _iter1283 != this->new_parts.end(); ++_iter1283) + std::vector<Partition> ::const_iterator _iter1310; + for (_iter1310 = this->new_parts.begin(); _iter1310 != this->new_parts.end(); ++_iter1310) { - xfer += (*_iter1283).write(oprot); + xfer += (*_iter1310).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 _iter1284; - for (_iter1284 = (*(this->new_parts)).begin(); _iter1284 != (*(this->new_parts)).end(); ++_iter1284) + std::vector<Partition> ::const_iterator _iter1311; + for (_iter1311 = (*(this->new_parts)).begin(); _iter1311 != (*(this->new_parts)).end(); ++_iter1311) { - xfer += (*_iter1284).write(oprot); + xfer += (*_iter1311).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 _size1285; - ::apache::thrift::protocol::TType _etype1288; - xfer += iprot->readListBegin(_etype1288, _size1285); - this->new_parts.resize(_size1285); - uint32_t _i1289; - for (_i1289 = 0; _i1289 < _size1285; ++_i1289) + uint32_t _size1312; + ::apache::thrift::protocol::TType _etype1315; + xfer += iprot->readListBegin(_etype1315, _size1312); + this->new_parts.resize(_size1312); + uint32_t _i1316; + for (_i1316 = 0; _i1316 < _size1312; ++_i1316) { - xfer += this->new_parts[_i1289].read(iprot); + xfer += this->new_parts[_i1316].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 _iter1290; - for (_iter1290 = this->new_parts.begin(); _iter1290 != this->new_parts.end(); ++_iter1290) + std::vector<PartitionSpec> ::const_iterator _iter1317; + for (_iter1317 = this->new_parts.begin(); _iter1317 != this->new_parts.end(); ++_iter1317) { - xfer += (*_iter1290).write(oprot); + xfer += (*_iter1317).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 _iter1291; - for (_iter1291 = (*(this->new_parts)).begin(); _iter1291 != (*(this->new_parts)).end(); ++_iter1291) + std::vector<PartitionSpec> ::const_iterator _iter1318; + for (_iter1318 = (*(this->new_parts)).begin(); _iter1318 != (*(this->new_parts)).end(); ++_iter1318) { - xfer += (*_iter1291).write(oprot); + xfer += (*_iter1318).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 _size1292; - ::apache::thrift::protocol::TType _etype1295; - xfer += iprot->readListBegin(_etype1295, _size1292); - this->part_vals.resize(_size1292); - uint32_t _i1296; - for (_i1296 = 0; _i1296 < _size1292; ++_i1296) + uint32_t _size1319; + ::apache::thrift::protocol::TType _etype1322; + xfer += iprot->readListBegin(_etype1322, _size1319); + this->part_vals.resize(_size1319); + uint32_t _i1323; + for (_i1323 = 0; _i1323 < _size1319; ++_i1323) { - xfer += iprot->readString(this->part_vals[_i1296]); + xfer += iprot->readString(this->part_vals[_i1323]); } 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 _iter1297; - for (_iter1297 = this->part_vals.begin(); _iter1297 != this->part_vals.end(); ++_iter1297) + std::vector<std::string> ::const_iterator _iter1324; + for (_iter1324 = this->part_vals.begin(); _iter1324 != this->part_vals.end(); ++_iter1324) { - xfer += oprot->writeString((*_iter1297)); + xfer += oprot->writeString((*_iter1324)); } 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 _iter1298; - for (_iter1298 = (*(this->part_vals)).begin(); _iter1298 != (*(this->part_vals)).end(); ++_iter1298) + std::vector<std::string> ::const_iterator _iter1325; + for (_iter1325 = (*(this->part_vals)).begin(); _iter1325 != (*(this->part_vals)).end(); ++_iter1325) { - xfer += oprot->writeString((*_iter1298)); + xfer += oprot->writeString((*_iter1325)); } 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 _size1299; - ::apache::thrift::protocol::TType _etype1302; - xfer += iprot->readListBegin(_etype1302, _size1299); - this->part_vals.resize(_size1299); - uint32_t _i1303; - for (_i1303 = 0; _i1303 < _size1299; ++_i1303) + uint32_t _size1326; + ::apache::thrift::protocol::TType _etype1329; + xfer += iprot->readListBegin(_etype1329, _size1326); + this->part_vals.resize(_size1326); + uint32_t _i1330; + for (_i1330 = 0; _i1330 < _size1326; ++_i1330) { - xfer += iprot->readString(this->part_vals[_i1303]); + xfer += iprot->readString(this->part_vals[_i1330]); } 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 _iter1304; - for (_iter1304 = this->part_vals.begin(); _iter1304 != this->part_vals.end(); ++_iter1304) + std::vector<std::string> ::const_iterator _iter1331; + for (_iter1331 = this->part_vals.begin(); _iter1331 != this->part_vals.end(); ++_iter1331) { - xfer += oprot->writeString((*_iter1304)); + xfer += oprot->writeString((*_iter1331)); } 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 _iter1305; - for (_iter1305 = (*(this->part_vals)).begin(); _iter1305 != (*(this->part_vals)).end(); ++_iter1305) + std::vector<std::string> ::const_iterator _iter1332; + for (_iter1332 = (*(this->part_vals)).begin(); _iter1332 != (*(this->part_vals)).end(); ++_iter1332) { - xfer += oprot->writeString((*_iter1305)); + xfer += oprot->writeString((*_iter1332)); } 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 _size1306; - ::apache::thrift::protocol::TType _etype1309; - xfer += iprot->readListBegin(_etype1309, _size1306); - this->part_vals.resize(_size1306); - uint32_t _i1310; - for (_i1310 = 0; _i1310 < _size1306; ++_i1310) + uint32_t _size1333; + ::apache::thrift::protocol::TType _etype1336; + xfer += iprot->readListBegin(_etype1336, _size1333); + this->part_vals.resize(_size1333); + uint32_t _i1337; + for (_i1337 = 0; _i1337 < _size1333; ++_i1337) { - xfer += iprot->readString(this->part_vals[_i1310]); + xfer += iprot->readString(this->part_vals[_i1337]); } 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 _iter1311; - for (_iter1311 = this->part_vals.begin(); _iter1311 != this->part_vals.end(); ++_iter1311) + std::vector<std::string> ::const_iterator _iter1338; + for (_iter1338 = this->part_vals.begin(); _iter1338 != this->part_vals.end(); ++_iter1338) { - xfer += oprot->writeString((*_iter1311)); + xfer += oprot->writeString((*_iter1338)); } 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 _iter1312; - for (_iter1312 = (*(this->part_vals)).begin(); _iter1312 != (*(this->part_vals)).end(); ++_iter1312) + std::vector<std::string> ::const_iterator _iter1339; + for (_iter1339 = (*(this->part_vals)).begin(); _iter1339 != (*(this->part_vals)).end(); ++_iter1339) { - xfer += oprot->writeString((*_iter1312)); + xfer += oprot->writeString((*_iter1339)); } 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 _size1313; - ::apache::thrift::protocol::TType _etype1316; - xfer += iprot->readListBegin(_etype1316, _size1313); - this->part_vals.resize(_size1313); - uint32_t _i1317; - for (_i1317 = 0; _i1317 < _size1313; ++_i1317) + uint32_t _size1340; + ::apache::thrift::protocol::TType _etype1343; + xfer += iprot->readListBegin(_etype1343, _size1340); + this->part_vals.resize(_size1340); + uint32_t _i1344; + for (_i1344 = 0; _i1344 < _size1340; ++_i1344) { - xfer += iprot->readString(this->part_vals[_i1317]); + xfer += iprot->readString(this->part_vals[_i1344]); } 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 _iter1318; - for (_iter1318 = this->part_vals.begin(); _iter1318 != this->part_vals.end(); ++_iter1318) + std::vector<std::string> ::const_iterator _iter1345; + for (_iter1345 = this->part_vals.begin(); _iter1345 != this->part_vals.end(); ++_iter1345) { - xfer += oprot->writeString((*_iter1318)); + xfer += oprot->writeString((*_iter1345)); } 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 _iter1319; - for (_iter1319 = (*(this->part_vals)).begin(); _iter1319 != (*(this->part_vals)).end(); ++_iter1319) + std::vector<std::string> ::const_iterator _iter1346; + for (_iter1346 = (*(this->part_vals)).begin(); _iter1346 != (*(this->part_vals)).end(); ++_iter1346) { - xfer += oprot->writeString((*_iter1319)); + xfer += oprot->writeString((*_iter1346)); } 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 _size1320; - ::apache::thrift::protocol::TType _etype1323; - xfer += iprot->readListBegin(_etype1323, _size1320); - this->part_vals.resize(_size1320); - uint32_t _i1324; - for (_i1324 = 0; _i1324 < _size1320; ++_i1324) + uint32_t _size1347; + ::apache::thrift::protocol::TType _etype1350; + xfer += iprot->readListBegin(_etype1350, _size1347); + this->part_vals.resize(_size1347); + uint32_t _i1351; + for (_i1351 = 0; _i1351 < _size1347; ++_i1351) { - xfer += iprot->readString(this->part_vals[_i1324]); + xfer += iprot->readString(this->part_vals[_i1351]); } 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 _iter1325; - for (_iter1325 = this->part_vals.begin(); _iter1325 != this->part_vals.end(); ++_iter1325) + std::vector<std::string> ::const_iterator _iter1352; + for (_iter1352 = this->part_vals.begin(); _iter1352 != this->part_vals.end(); ++_iter1352) { - xfer += oprot->writeString((*_iter1325)); + xfer += oprot->writeString((*_iter1352)); } 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 _iter1326; - for (_iter1326 = (*(this->part_vals)).begin(); _iter1326 != (*(this->part_vals)).end(); ++_iter1326) + std::vector<std::string> ::const_iterator _iter1353; + for (_iter1353 = (*(this->part_vals)).begin(); _iter1353 != (*(this->part_vals)).end(); ++_iter1353) { - xfer += oprot->writeString((*_iter1326)); + xfer += oprot->writeString((*_iter1353)); } 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 _size1327; - ::apache::thrift::protocol::TType _ktype1328; - ::apache::thrift::protocol::TType _vtype1329; - xfer += iprot->readMapBegin(_ktype1328, _vtype1329, _size1327); - uint32_t _i1331; - for (_i1331 = 0; _i1331 < _size1327; ++_i1331) + uint32_t _size1354; + ::apache::thrift::protocol::TType _ktype1355; + ::apache::thrift::protocol::TType _vtype1356; + xfer += iprot->readMapBegin(_ktype1355, _vtype1356, _size1354); + uint32_t _i1358; + for (_i1358 = 0; _i1358 < _size1354; ++_i1358) { - std::string _key1332; - xfer += iprot->readString(_key1332); - std::string& _val1333 = this->partitionSpecs[_key1332]; - xfer += iprot->readString(_val1333); + std::string _key1359; + xfer += iprot->readString(_key1359); + std::string& _val1360 = this->partitionSpecs[_key1359]; + xfer += iprot->readString(_val1360); } 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 _iter1334; - for (_iter1334 = this->partitionSpecs.begin(); _iter1334 != this->partitionSpecs.end(); ++_iter1334) + std::map<std::string, std::string> ::const_iterator _iter1361; + for (_iter1361 = this->partitionSpecs.begin(); _iter1361 != this->partitionSpecs.end(); ++_iter1361) { - xfer += oprot->writeString(_iter1334->first); - xfer += oprot->writeString(_iter1334->second); + xfer += oprot->writeString(_iter1361->first); + xfer += oprot->writeString(_iter1361->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 _iter1335; - for (_iter1335 = (*(this->partitionSpecs)).begin(); _iter1335 != (*(this->partitionSpecs)).end(); ++_iter1335) + std::map<std::string, std::string> ::const_iterator _iter1362; + for (_iter1362 = (*(this->partitionSpecs)).begin(); _iter1362 != (*(this->partitionSpecs)).end(); ++_iter1362) { - xfer += oprot->writeString(_iter1335->first); - xfer += oprot->writeString(_iter1335->second); + xfer += oprot->writeString(_iter1362->first); + xfer += oprot->writeString(_iter1362->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 _size1336; - ::apache::thrift::protocol::TType _ktype1337; - ::apache::thrift::protocol::TType _vtype1338; - xfer += iprot->readMapBegin(_ktype1337, _vtype1338, _size1336); - uint32_t _i1340; - for (_i1340 = 0; _i1340 < _size1336; ++_i1340) + uint32_t _size1363; + ::apache::thrift::protocol::TType _ktype1364; + ::apache::thrift::protocol::TType _vtype1365; + xfer += iprot->readMapBegin(_ktype1364, _vtype1365, _size1363); + uint32_t _i1367; + for (_i1367 = 0; _i1367 < _size1363; ++_i1367) { - std::string _key1341; - xfer += iprot->readString(_key1341); - std::string& _val1342 = this->partitionSpecs[_key1341]; - xfer += iprot->readString(_val1342); + std::string _key1368; + xfer += iprot->readString(_key1368); + std::string& _val1369 = this->partitionSpecs[_key1368]; + xfer += iprot->readString(_val1369); } 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 _iter1343; - for (_iter1343 = this->partitionSpecs.begin(); _iter1343 != this->partitionSpecs.end(); ++_iter1343) + std::map<std::string, std::string> ::const_iterator _iter1370; + for (_iter1370 = this->partitionSpecs.begin(); _iter1370 != this->partitionSpecs.end(); ++_iter1370) { - xfer += oprot->writeString(_iter1343->fir
<TRUNCATED>