http://git-wip-us.apache.org/repos/asf/hive/blob/cbb9233a/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 6bd6aa2..921cba1 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 _size1091; + ::apache::thrift::protocol::TType _etype1094; + xfer += iprot->readListBegin(_etype1094, _size1091); + this->success.resize(_size1091); + uint32_t _i1095; + for (_i1095 = 0; _i1095 < _size1091; ++_i1095) { - xfer += iprot->readString(this->success[_i1053]); + xfer += iprot->readString(this->success[_i1095]); } 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 _iter1096; + for (_iter1096 = this->success.begin(); _iter1096 != this->success.end(); ++_iter1096) { - xfer += oprot->writeString((*_iter1054)); + xfer += oprot->writeString((*_iter1096)); } 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 _size1097; + ::apache::thrift::protocol::TType _etype1100; + xfer += iprot->readListBegin(_etype1100, _size1097); + (*(this->success)).resize(_size1097); + uint32_t _i1101; + for (_i1101 = 0; _i1101 < _size1097; ++_i1101) { - xfer += iprot->readString((*(this->success))[_i1059]); + xfer += iprot->readString((*(this->success))[_i1101]); } 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 _size1102; + ::apache::thrift::protocol::TType _etype1105; + xfer += iprot->readListBegin(_etype1105, _size1102); + this->success.resize(_size1102); + uint32_t _i1106; + for (_i1106 = 0; _i1106 < _size1102; ++_i1106) { - xfer += iprot->readString(this->success[_i1064]); + xfer += iprot->readString(this->success[_i1106]); } 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 _iter1107; + for (_iter1107 = this->success.begin(); _iter1107 != this->success.end(); ++_iter1107) { - xfer += oprot->writeString((*_iter1065)); + xfer += oprot->writeString((*_iter1107)); } 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 _size1108; + ::apache::thrift::protocol::TType _etype1111; + xfer += iprot->readListBegin(_etype1111, _size1108); + (*(this->success)).resize(_size1108); + uint32_t _i1112; + for (_i1112 = 0; _i1112 < _size1108; ++_i1112) { - xfer += iprot->readString((*(this->success))[_i1070]); + xfer += iprot->readString((*(this->success))[_i1112]); } 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 _size1113; + ::apache::thrift::protocol::TType _ktype1114; + ::apache::thrift::protocol::TType _vtype1115; + xfer += iprot->readMapBegin(_ktype1114, _vtype1115, _size1113); + uint32_t _i1117; + for (_i1117 = 0; _i1117 < _size1113; ++_i1117) { - std::string _key1076; - xfer += iprot->readString(_key1076); - Type& _val1077 = this->success[_key1076]; - xfer += _val1077.read(iprot); + std::string _key1118; + xfer += iprot->readString(_key1118); + Type& _val1119 = this->success[_key1118]; + xfer += _val1119.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 _iter1120; + for (_iter1120 = this->success.begin(); _iter1120 != this->success.end(); ++_iter1120) { - xfer += oprot->writeString(_iter1078->first); - xfer += _iter1078->second.write(oprot); + xfer += oprot->writeString(_iter1120->first); + xfer += _iter1120->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 _size1121; + ::apache::thrift::protocol::TType _ktype1122; + ::apache::thrift::protocol::TType _vtype1123; + xfer += iprot->readMapBegin(_ktype1122, _vtype1123, _size1121); + uint32_t _i1125; + for (_i1125 = 0; _i1125 < _size1121; ++_i1125) { - std::string _key1084; - xfer += iprot->readString(_key1084); - Type& _val1085 = (*(this->success))[_key1084]; - xfer += _val1085.read(iprot); + std::string _key1126; + xfer += iprot->readString(_key1126); + Type& _val1127 = (*(this->success))[_key1126]; + xfer += _val1127.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 _size1128; + ::apache::thrift::protocol::TType _etype1131; + xfer += iprot->readListBegin(_etype1131, _size1128); + this->success.resize(_size1128); + uint32_t _i1132; + for (_i1132 = 0; _i1132 < _size1128; ++_i1132) { - xfer += this->success[_i1090].read(iprot); + xfer += this->success[_i1132].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 _iter1133; + for (_iter1133 = this->success.begin(); _iter1133 != this->success.end(); ++_iter1133) { - xfer += (*_iter1091).write(oprot); + xfer += (*_iter1133).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 _size1134; + ::apache::thrift::protocol::TType _etype1137; + xfer += iprot->readListBegin(_etype1137, _size1134); + (*(this->success)).resize(_size1134); + uint32_t _i1138; + for (_i1138 = 0; _i1138 < _size1134; ++_i1138) { - xfer += (*(this->success))[_i1096].read(iprot); + xfer += (*(this->success))[_i1138].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 _size1139; + ::apache::thrift::protocol::TType _etype1142; + xfer += iprot->readListBegin(_etype1142, _size1139); + this->success.resize(_size1139); + uint32_t _i1143; + for (_i1143 = 0; _i1143 < _size1139; ++_i1143) { - xfer += this->success[_i1101].read(iprot); + xfer += this->success[_i1143].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 _iter1144; + for (_iter1144 = this->success.begin(); _iter1144 != this->success.end(); ++_iter1144) { - xfer += (*_iter1102).write(oprot); + xfer += (*_iter1144).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 _size1145; + ::apache::thrift::protocol::TType _etype1148; + xfer += iprot->readListBegin(_etype1148, _size1145); + (*(this->success)).resize(_size1145); + uint32_t _i1149; + for (_i1149 = 0; _i1149 < _size1145; ++_i1149) { - xfer += (*(this->success))[_i1107].read(iprot); + xfer += (*(this->success))[_i1149].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 _size1150; + ::apache::thrift::protocol::TType _etype1153; + xfer += iprot->readListBegin(_etype1153, _size1150); + this->success.resize(_size1150); + uint32_t _i1154; + for (_i1154 = 0; _i1154 < _size1150; ++_i1154) { - xfer += this->success[_i1112].read(iprot); + xfer += this->success[_i1154].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 _iter1155; + for (_iter1155 = this->success.begin(); _iter1155 != this->success.end(); ++_iter1155) { - xfer += (*_iter1113).write(oprot); + xfer += (*_iter1155).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 _size1156; + ::apache::thrift::protocol::TType _etype1159; + xfer += iprot->readListBegin(_etype1159, _size1156); + (*(this->success)).resize(_size1156); + uint32_t _i1160; + for (_i1160 = 0; _i1160 < _size1156; ++_i1160) { - xfer += (*(this->success))[_i1118].read(iprot); + xfer += (*(this->success))[_i1160].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 _size1161; + ::apache::thrift::protocol::TType _etype1164; + xfer += iprot->readListBegin(_etype1164, _size1161); + this->success.resize(_size1161); + uint32_t _i1165; + for (_i1165 = 0; _i1165 < _size1161; ++_i1165) { - xfer += this->success[_i1123].read(iprot); + xfer += this->success[_i1165].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 _iter1166; + for (_iter1166 = this->success.begin(); _iter1166 != this->success.end(); ++_iter1166) { - xfer += (*_iter1124).write(oprot); + xfer += (*_iter1166).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 _size1167; + ::apache::thrift::protocol::TType _etype1170; + xfer += iprot->readListBegin(_etype1170, _size1167); + (*(this->success)).resize(_size1167); + uint32_t _i1171; + for (_i1171 = 0; _i1171 < _size1167; ++_i1171) { - xfer += (*(this->success))[_i1129].read(iprot); + xfer += (*(this->success))[_i1171].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 _size1172; + ::apache::thrift::protocol::TType _etype1175; + xfer += iprot->readListBegin(_etype1175, _size1172); + this->primaryKeys.resize(_size1172); + uint32_t _i1176; + for (_i1176 = 0; _i1176 < _size1172; ++_i1176) { - xfer += this->primaryKeys[_i1134].read(iprot); + xfer += this->primaryKeys[_i1176].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 _size1177; + ::apache::thrift::protocol::TType _etype1180; + xfer += iprot->readListBegin(_etype1180, _size1177); + this->foreignKeys.resize(_size1177); + uint32_t _i1181; + for (_i1181 = 0; _i1181 < _size1177; ++_i1181) { - xfer += this->foreignKeys[_i1139].read(iprot); + xfer += this->foreignKeys[_i1181].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 _size1182; + ::apache::thrift::protocol::TType _etype1185; + xfer += iprot->readListBegin(_etype1185, _size1182); + this->uniqueConstraints.resize(_size1182); + uint32_t _i1186; + for (_i1186 = 0; _i1186 < _size1182; ++_i1186) { - xfer += this->uniqueConstraints[_i1144].read(iprot); + xfer += this->uniqueConstraints[_i1186].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 _size1187; + ::apache::thrift::protocol::TType _etype1190; + xfer += iprot->readListBegin(_etype1190, _size1187); + this->notNullConstraints.resize(_size1187); + uint32_t _i1191; + for (_i1191 = 0; _i1191 < _size1187; ++_i1191) { - xfer += this->notNullConstraints[_i1149].read(iprot); + xfer += this->notNullConstraints[_i1191].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 _iter1192; + for (_iter1192 = this->primaryKeys.begin(); _iter1192 != this->primaryKeys.end(); ++_iter1192) { - xfer += (*_iter1150).write(oprot); + xfer += (*_iter1192).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 _iter1193; + for (_iter1193 = this->foreignKeys.begin(); _iter1193 != this->foreignKeys.end(); ++_iter1193) { - xfer += (*_iter1151).write(oprot); + xfer += (*_iter1193).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 _iter1194; + for (_iter1194 = this->uniqueConstraints.begin(); _iter1194 != this->uniqueConstraints.end(); ++_iter1194) { - xfer += (*_iter1152).write(oprot); + xfer += (*_iter1194).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 _iter1195; + for (_iter1195 = this->notNullConstraints.begin(); _iter1195 != this->notNullConstraints.end(); ++_iter1195) { - xfer += (*_iter1153).write(oprot); + xfer += (*_iter1195).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 _iter1196; + for (_iter1196 = (*(this->primaryKeys)).begin(); _iter1196 != (*(this->primaryKeys)).end(); ++_iter1196) { - xfer += (*_iter1154).write(oprot); + xfer += (*_iter1196).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 _iter1197; + for (_iter1197 = (*(this->foreignKeys)).begin(); _iter1197 != (*(this->foreignKeys)).end(); ++_iter1197) { - xfer += (*_iter1155).write(oprot); + xfer += (*_iter1197).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 _iter1198; + for (_iter1198 = (*(this->uniqueConstraints)).begin(); _iter1198 != (*(this->uniqueConstraints)).end(); ++_iter1198) { - xfer += (*_iter1156).write(oprot); + xfer += (*_iter1198).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 _iter1199; + for (_iter1199 = (*(this->notNullConstraints)).begin(); _iter1199 != (*(this->notNullConstraints)).end(); ++_iter1199) { - xfer += (*_iter1157).write(oprot); + xfer += (*_iter1199).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 _size1200; + ::apache::thrift::protocol::TType _etype1203; + xfer += iprot->readListBegin(_etype1203, _size1200); + this->partNames.resize(_size1200); + uint32_t _i1204; + for (_i1204 = 0; _i1204 < _size1200; ++_i1204) { - xfer += iprot->readString(this->partNames[_i1162]); + xfer += iprot->readString(this->partNames[_i1204]); } 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 _iter1205; + for (_iter1205 = this->partNames.begin(); _iter1205 != this->partNames.end(); ++_iter1205) { - xfer += oprot->writeString((*_iter1163)); + xfer += oprot->writeString((*_iter1205)); } 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 _iter1206; + for (_iter1206 = (*(this->partNames)).begin(); _iter1206 != (*(this->partNames)).end(); ++_iter1206) { - xfer += oprot->writeString((*_iter1164)); + xfer += oprot->writeString((*_iter1206)); } 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 _size1207; + ::apache::thrift::protocol::TType _etype1210; + xfer += iprot->readListBegin(_etype1210, _size1207); + this->success.resize(_size1207); + uint32_t _i1211; + for (_i1211 = 0; _i1211 < _size1207; ++_i1211) { - xfer += iprot->readString(this->success[_i1169]); + xfer += iprot->readString(this->success[_i1211]); } 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 _iter1212; + for (_iter1212 = this->success.begin(); _iter1212 != this->success.end(); ++_iter1212) { - xfer += oprot->writeString((*_iter1170)); + xfer += oprot->writeString((*_iter1212)); } 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 _size1213; + ::apache::thrift::protocol::TType _etype1216; + xfer += iprot->readListBegin(_etype1216, _size1213); + (*(this->success)).resize(_size1213); + uint32_t _i1217; + for (_i1217 = 0; _i1217 < _size1213; ++_i1217) { - xfer += iprot->readString((*(this->success))[_i1175]); + xfer += iprot->readString((*(this->success))[_i1217]); } 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 _size1218; + ::apache::thrift::protocol::TType _etype1221; + xfer += iprot->readListBegin(_etype1221, _size1218); + this->success.resize(_size1218); + uint32_t _i1222; + for (_i1222 = 0; _i1222 < _size1218; ++_i1222) { - xfer += iprot->readString(this->success[_i1180]); + xfer += iprot->readString(this->success[_i1222]); } 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 _iter1223; + for (_iter1223 = this->success.begin(); _iter1223 != this->success.end(); ++_iter1223) { - xfer += oprot->writeString((*_iter1181)); + xfer += oprot->writeString((*_iter1223)); } 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 _size1224; + ::apache::thrift::protocol::TType _etype1227; + xfer += iprot->readListBegin(_etype1227, _size1224); + (*(this->success)).resize(_size1224); + uint32_t _i1228; + for (_i1228 = 0; _i1228 < _size1224; ++_i1228) { - xfer += iprot->readString((*(this->success))[_i1186]); + xfer += iprot->readString((*(this->success))[_i1228]); } 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 _size1229; + ::apache::thrift::protocol::TType _etype1232; + xfer += iprot->readListBegin(_etype1232, _size1229); + this->success.resize(_size1229); + uint32_t _i1233; + for (_i1233 = 0; _i1233 < _size1229; ++_i1233) { - xfer += iprot->readString(this->success[_i1191]); + xfer += iprot->readString(this->success[_i1233]); } 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 _iter1234; + for (_iter1234 = this->success.begin(); _iter1234 != this->success.end(); ++_iter1234) { - xfer += oprot->writeString((*_iter1192)); + xfer += oprot->writeString((*_iter1234)); } 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 _size1235; + ::apache::thrift::protocol::TType _etype1238; + xfer += iprot->readListBegin(_etype1238, _size1235); + (*(this->success)).resize(_size1235); + uint32_t _i1239; + for (_i1239 = 0; _i1239 < _size1235; ++_i1239) { - xfer += iprot->readString((*(this->success))[_i1197]); + xfer += iprot->readString((*(this->success))[_i1239]); } 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 _size1240; + ::apache::thrift::protocol::TType _etype1243; + xfer += iprot->readListBegin(_etype1243, _size1240); + this->tbl_types.resize(_size1240); + uint32_t _i1244; + for (_i1244 = 0; _i1244 < _size1240; ++_i1244) { - xfer += iprot->readString(this->tbl_types[_i1202]); + xfer += iprot->readString(this->tbl_types[_i1244]); } 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 _iter1245; + for (_iter1245 = this->tbl_types.begin(); _iter1245 != this->tbl_types.end(); ++_iter1245) { - xfer += oprot->writeString((*_iter1203)); + xfer += oprot->writeString((*_iter1245)); } 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 _iter1246; + for (_iter1246 = (*(this->tbl_types)).begin(); _iter1246 != (*(this->tbl_types)).end(); ++_iter1246) { - xfer += oprot->writeString((*_iter1204)); + xfer += oprot->writeString((*_iter1246)); } 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 _size1247; + ::apache::thrift::protocol::TType _etype1250; + xfer += iprot->readListBegin(_etype1250, _size1247); + this->success.resize(_size1247); + uint32_t _i1251; + for (_i1251 = 0; _i1251 < _size1247; ++_i1251) { - xfer += this->success[_i1209].read(iprot); + xfer += this->success[_i1251].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 _iter1252; + for (_iter1252 = this->success.begin(); _iter1252 != this->success.end(); ++_iter1252) { - xfer += (*_iter1210).write(oprot); + xfer += (*_iter1252).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 _size1253; + ::apache::thrift::protocol::TType _etype1256; + xfer += iprot->readListBegin(_etype1256, _size1253); + (*(this->success)).resize(_size1253); + uint32_t _i1257; + for (_i1257 = 0; _i1257 < _size1253; ++_i1257) { - xfer += (*(this->success))[_i1215].read(iprot); + xfer += (*(this->success))[_i1257].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 _size1258; + ::apache::thrift::protocol::TType _etype1261; + xfer += iprot->readListBegin(_etype1261, _size1258); + this->success.resize(_size1258); + uint32_t _i1262; + for (_i1262 = 0; _i1262 < _size1258; ++_i1262) { - xfer += iprot->readString(this->success[_i1220]); + xfer += iprot->readString(this->success[_i1262]); } 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 _iter1263; + for (_iter1263 = this->success.begin(); _iter1263 != this->success.end(); ++_iter1263) { - xfer += oprot->writeString((*_iter1221)); + xfer += oprot->writeString((*_iter1263)); } 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 _size1264; + ::apache::thrift::protocol::TType _etype1267; + xfer += iprot->readListBegin(_etype1267, _size1264); + (*(this->success)).resize(_size1264); + uint32_t _i1268; + for (_i1268 = 0; _i1268 < _size1264; ++_i1268) { - xfer += iprot->readString((*(this->success))[_i1226]); + xfer += iprot->readString((*(this->success))[_i1268]); } 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 _size1269; + ::apache::thrift::protocol::TType _etype1272; + xfer += iprot->readListBegin(_etype1272, _size1269); + this->tbl_names.resize(_size1269); + uint32_t _i1273; + for (_i1273 = 0; _i1273 < _size1269; ++_i1273) { - xfer += iprot->readString(this->tbl_names[_i1231]); + xfer += iprot->readString(this->tbl_names[_i1273]); } 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 _iter1274; + for (_iter1274 = this->tbl_names.begin(); _iter1274 != this->tbl_names.end(); ++_iter1274) { - xfer += oprot->writeString((*_iter1232)); + xfer += oprot->writeString((*_iter1274)); } 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 _iter1275; + for (_iter1275 = (*(this->tbl_names)).begin(); _iter1275 != (*(this->tbl_names)).end(); ++_iter1275) { - xfer += oprot->writeString((*_iter1233)); + xfer += oprot->writeString((*_iter1275)); } 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 _size1276; + ::apache::thrift::protocol::TType _etype1279; + xfer += iprot->readListBegin(_etype1279, _size1276); + this->success.resize(_size1276); + uint32_t _i1280; + for (_i1280 = 0; _i1280 < _size1276; ++_i1280) { - xfer += this->success[_i1238].read(iprot); + xfer += this->success[_i1280].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 _iter1281; + for (_iter1281 = this->success.begin(); _iter1281 != this->success.end(); ++_iter1281) { - xfer += (*_iter1239).write(oprot); + xfer += (*_iter1281).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 _size1282; + ::apache::thrift::protocol::TType _etype1285; + xfer += iprot->readListBegin(_etype1285, _size1282); + (*(this->success)).resize(_size1282); + uint32_t _i1286; + for (_i1286 = 0; _i1286 < _size1282; ++_i1286) { - xfer += (*(this->success))[_i1244].read(iprot); + xfer += (*(this->success))[_i1286].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 _size1287; + ::apache::thrift::protocol::TType _etype1290; + xfer += iprot->readListBegin(_etype1290, _size1287); + this->tbl_names.resize(_size1287); + uint32_t _i1291; + for (_i1291 = 0; _i1291 < _size1287; ++_i1291) { - xfer += iprot->readString(this->tbl_names[_i1249]); + xfer += iprot->readString(this->tbl_names[_i1291]); } 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 _iter1292; + for (_iter1292 = this->tbl_names.begin(); _iter1292 != this->tbl_names.end(); ++_iter1292) { - xfer += oprot->writeString((*_iter1250)); + xfer += oprot->writeString((*_iter1292)); } 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 _iter1293; + for (_iter1293 = (*(this->tbl_names)).begin(); _iter1293 != (*(this->tbl_names)).end(); ++_iter1293) { - xfer += oprot->writeString((*_iter1251)); + xfer += oprot->writeString((*_iter1293)); } 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 _size1294; + ::apache::thrift::protocol::TType _ktype1295; + ::apache::thrift::protocol::TType _vtype1296; + xfer += iprot->readMapBegin(_ktype1295, _vtype1296, _size1294); + uint32_t _i1298; + for (_i1298 = 0; _i1298 < _size1294; ++_i1298) { - std::string _key1257; - xfer += iprot->readString(_key1257); - Materialization& _val1258 = this->success[_key1257]; - xfer += _val1258.read(iprot); + std::string _key1299; + xfer += iprot->readString(_key1299); + Materialization& _val1300 = this->success[_key1299]; + xfer += _val1300.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 _iter1301; + for (_iter1301 = this->success.begin(); _iter1301 != this->success.end(); ++_iter1301) { - xfer += oprot->writeString(_iter1259->first); - xfer += _iter1259->second.write(oprot); + xfer += oprot->writeString(_iter1301->first); + xfer += _iter1301->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 _size1302; + ::apache::thrift::protocol::TType _ktype1303; + ::apache::thrift::protocol::TType _vtype1304; + xfer += iprot->readMapBegin(_ktype1303, _vtype1304, _size1302); + uint32_t _i1306; + for (_i1306 = 0; _i1306 < _size1302; ++_i1306) { - std::string _key1265; - xfer += iprot->readString(_key1265); - Materialization& _val1266 = (*(this->success))[_key1265]; - xfer += _val1266.read(iprot); + std::string _key1307; + xfer += iprot->readString(_key1307); + Materialization& _val1308 = (*(this->success))[_key1307]; + xfer += _val1308.read(iprot); } xfer += iprot->readMapEnd(); } @@ -9692,14 +9692,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 _size1309; + ::apache::thrift::protocol::TType _etype1312; + xfer += iprot->readListBegin(_etype1312, _size1309); + this->success.resize(_size1309); + uint32_t _i1313; + for (_i1313 = 0; _i1313 < _size1309; ++_i1313) { - xfer += iprot->readString(this->success[_i1271]); + xfer += iprot->readString(this->success[_i1313]); } xfer += iprot->readListEnd(); } @@ -9754,10 +9754,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 _iter1314; + for (_iter1314 = this->success.begin(); _iter1314 != this->success.end(); ++_iter1314) { - xfer += oprot->writeString((*_iter1272)); + xfer += oprot->writeString((*_iter1314)); } xfer += oprot->writeListEnd(); } @@ -9810,14 +9810,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 _size1315; + ::apache::thrift::protocol::TType _etype1318; + xfer += iprot->readListBegin(_etype1318, _size1315); + (*(this->success)).resize(_size1315); + uint32_t _i1319; + for (_i1319 = 0; _i1319 < _size1315; ++_i1319) { - xfer += iprot->readString((*(this->success))[_i1277]); + xfer += iprot->readString((*(this->success))[_i1319]); } xfer += iprot->readListEnd(); } @@ -11151,14 +11151,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 _size1320; + ::apache::thrift::protocol::TType _etype1323; + xfer += iprot->readListBegin(_etype1323, _size1320); + this->new_parts.resize(_size1320); + uint32_t _i1324; + for (_i1324 = 0; _i1324 < _size1320; ++_i1324) { - xfer += this->new_parts[_i1282].read(iprot); + xfer += this->new_parts[_i1324].read(iprot); } xfer += iprot->readListEnd(); } @@ -11187,10 +11187,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 _iter1325; + for (_iter1325 = this->new_parts.begin(); _iter1325 != this->new_parts.end(); ++_iter1325) { - xfer += (*_iter1283).write(oprot); + xfer += (*_iter1325).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11214,10 +11214,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 _iter1326; + for (_iter1326 = (*(this->new_parts)).begin(); _iter1326 != (*(this->new_parts)).end(); ++_iter1326) { - xfer += (*_iter1284).write(oprot); + xfer += (*_iter1326).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11426,14 +11426,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 _size1327; + ::apache::thrift::protocol::TType _etype1330; + xfer += iprot->readListBegin(_etype1330, _size1327); + this->new_parts.resize(_size1327); + uint32_t _i1331; + for (_i1331 = 0; _i1331 < _size1327; ++_i1331) { - xfer += this->new_parts[_i1289].read(iprot); + xfer += this->new_parts[_i1331].read(iprot); } xfer += iprot->readListEnd(); } @@ -11462,10 +11462,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 _iter1332; + for (_iter1332 = this->new_parts.begin(); _iter1332 != this->new_parts.end(); ++_iter1332) { - xfer += (*_iter1290).write(oprot); + xfer += (*_iter1332).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11489,10 +11489,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 _iter1333; + for (_iter1333 = (*(this->new_parts)).begin(); _iter1333 != (*(this->new_parts)).end(); ++_iter1333) { - xfer += (*_iter1291).write(oprot); + xfer += (*_iter1333).write(oprot); } xfer += oprot->writeListEnd(); } @@ -11717,14 +11717,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 _size1334; + ::apache::thrift::protocol::TType _etype1337; + xfer += iprot->readListBegin(_etype1337, _size1334); + this->part_vals.resize(_size1334); + uint32_t _i1338; + for (_i1338 = 0; _i1338 < _size1334; ++_i1338) { - xfer += iprot->readString(this->part_vals[_i1296]); + xfer += iprot->readString(this->part_vals[_i1338]); } xfer += iprot->readListEnd(); } @@ -11761,10 +11761,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 _iter1339; + for (_iter1339 = this->part_vals.begin(); _iter1339 != this->part_vals.end(); ++_iter1339) { - xfer += oprot->writeString((*_iter1297)); + xfer += oprot->writeString((*_iter1339)); } xfer += oprot->writeListEnd(); } @@ -11796,10 +11796,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 _iter1340; + for (_iter1340 = (*(this->part_vals)).begin(); _iter1340 != (*(this->part_vals)).end(); ++_iter1340) { - xfer += oprot->writeString((*_iter1298)); + xfer += oprot->writeString((*_iter1340)); } xfer += oprot->writeListEnd(); } @@ -12271,14 +12271,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 _size1341; + ::apache::thrift::protocol::TType _etype1344; + xfer += iprot->readListBegin(_etype1344, _size1341); + this->part_vals.resize(_size1341); + uint32_t _i1345; + for (_i1345 = 0; _i1345 < _size1341; ++_i1345) { - xfer += iprot->readString(this->part_vals[_i1303]); + xfer += iprot->readString(this->part_vals[_i1345]); } xfer += iprot->readListEnd(); } @@ -12323,10 +12323,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 _iter1346; + for (_iter1346 = this->part_vals.begin(); _iter1346 != this->part_vals.end(); ++_iter1346) { - xfer += oprot->writeString((*_iter1304)); + xfer += oprot->writeString((*_iter1346)); } xfer += oprot->writeListEnd(); } @@ -12362,10 +12362,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 _iter1347; + for (_iter1347 = (*(this->part_vals)).begin(); _iter1347 != (*(this->part_vals)).end(); ++_iter1347) { - xfer += oprot->writeString((*_iter1305)); + xfer += oprot->writeString((*_iter1347)); } xfer += oprot->writeListEnd(); } @@ -13168,14 +13168,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 _size1348; + ::apache::thrift::protocol::TType _etype1351; + xfer += iprot->readListBegin(_etype1351, _size1348); + this->part_vals.resize(_size1348); + uint32_t _i1352; + for (_i1352 = 0; _i1352 < _size1348; ++_i1352) { - xfer += iprot->readString(this->part_vals[_i1310]); + xfer += iprot->readString(this->part_vals[_i1352]); } xfer += iprot->readListEnd(); } @@ -13220,10 +13220,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 _iter1353; + for (_iter1353 = this->part_vals.begin(); _iter1353 != this->part_vals.end(); ++_iter1353) { - xfer += oprot->writeString((*_iter1311)); + xfer += oprot->writeString((*_iter1353)); } xfer += oprot->writeListEnd(); } @@ -13259,10 +13259,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 _iter1354; + for (_iter1354 = (*(this->part_vals)).begin(); _iter1354 != (*(this->part_vals)).end(); ++_iter1354) { - xfer += oprot->writeString((*_iter1312)); + xfer += oprot->writeString((*_iter1354)); } xfer += oprot->writeListEnd(); } @@ -13471,14 +13471,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 _size1355; + ::apache::thrift::protocol::TType _etype1358; + xfer += iprot->readListBegin(_etype1358, _size1355); + this->part_vals.resize(_size1355); + uint32_t _i1359; + for (_i1359 = 0; _i1359 < _size1355; ++_i1359) { - xfer += iprot->readString(this->part_vals[_i1317]); + xfer += iprot->readString(this->part_vals[_i1359]); } xfer += iprot->readListEnd(); } @@ -13531,10 +13531,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 _iter1360; + for (_iter1360 = this->part_vals.begin(); _iter1360 != this->part_vals.end(); ++_iter1360) { - xfer += oprot->writeString((*_iter1318)); + xfer += oprot->writeString((*_iter1360)); } xfer += oprot->writeListEnd(); } @@ -13574,10 +13574,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 _iter1361; + for (_iter1361 = (*(this->part_vals)).begin(); _iter1361 != (*(this->part_vals)).end(); ++_iter1361) { - xfer += oprot->writeString((*_iter1319)); + xfer += oprot->writeString((*_iter1361)); } xfer += oprot->writeListEnd(); } @@ -14583,14 +14583,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 _size1362; + ::apache::thrift::protocol::TType _etype1365; + xfer += iprot->readListBegin(_etype1365, _size1362); + this->part_vals.resize(_size1362); + uint32_t _i1366; + for (_i1366 = 0; _i1366 < _size1362; ++_i1366) { - xfer += iprot->readString(this->part_vals[_i1324]); + xfer += iprot->readString(this->part_vals[_i1366]); } xfer += iprot->readListEnd(); } @@ -14627,10 +14627,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 _iter1367; + for (_iter1367 = this->part_vals.begin(); _iter1367 != this->part_vals.end(); ++_iter1367) { - xfer += oprot->writeString((*_iter1325)); + xfer += oprot->writeString((*_iter1367)); } xfer += oprot->writeListEnd(); } @@ -14662,10 +14662,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 _iter1368; + for (_iter1368 = (*(this->part_vals)).begin(); _iter1368 != (*(this->part_vals)).end(); ++_iter1368) { - xfer += oprot->writeString((*_iter1326)); + xfer += oprot->writeString((*_iter1368)); } xfer += oprot->writeListEnd(); } @@ -14854,17 +14854,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 _size1369; + ::apache::thrift::protocol::TType _ktype1370; + ::apache::thrift::protocol::TType _vtype1371; + xfer += iprot->readMapBegin(_ktype1370, _vtype1371, _size1369); + uint32_t _i1373; + for (_i1373 = 0; _i1373 < _size1369; ++_i1373) { - std::string _key1332; - xfer += iprot->readString(_key1332); - std::string& _val1333 = this->partitionSpecs[_key1332]; - xfer += iprot->readString(_val1333); + std::string _key1374; + xfer += iprot->readString(_key1374); + std::string& _val1375 = this->partitionSpecs[_key1374]; + xfer += iprot->readString(_val1375); } xfer += iprot->readMapEnd(); } @@ -14925,11 +14925,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 _iter1376; + for (_iter1376 = this->partitionSpecs.begin(); _iter1376 != this->partitionSpecs.end(); ++_iter1376) { - xfer += oprot->writeString(_iter1334->first); - xfer += oprot->writeString(_iter1334->second); + xfer += oprot->writeString(_iter1376->first); + xfer += oprot->writeString(_iter1376->second); } xfer += oprot->writeMapEnd(); } @@ -14969,11 +14969,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 _iter1377; + for (_iter1377 = (*(this->partitionSpecs)).begin(); _iter1377 != (*(this->partitionSpecs)).end(); ++_iter1377) { - xfer += oprot->writeString(_iter1335->first); - xfer += oprot->writeString(_iter1335->second); + xfer += oprot->writeString(_iter1377->first); + xfer += oprot->writeString(_iter1377->second); } xfer += oprot->writeMapEnd(); } @@ -15218,17 +15218,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 _size1378; + ::apache::thrift::protocol::TType _ktype1379; + ::apache::thrift::protocol::TType _vtype1380; + xfer += iprot->readMapBegin(_ktype1379, _vtype1380, _size1378); + uint32_t _i1382; + for (_i1382 = 0; _i1382 < _size1378; ++_i1382) { - std::string _key1341; - xfer += iprot->readString(_key1341); - std::string& _val1342 = this->partitionSpecs[_key1341]; - xfer += iprot->readString(_val1342); + std::string _key1383; + xfer += iprot->readString(_key1383); + std::string& _val1384 = this->partitionSpecs[_key1383]; + xfer += iprot->readString(_val1384); } xfer += iprot->readMapEnd(); } @@ -15289,11 +15289,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 _iter1385; + for (_iter1385 = this->partitionSpecs.begin(); _iter1385 != this->partitionSpecs.end(); ++_iter1385) { - xfer += oprot->writeString(_iter1343->fir
<TRUNCATED>