http://git-wip-us.apache.org/repos/asf/hive/blob/0a328f03/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 8b78230..af0fd6b 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 _size1056; - ::apache::thrift::protocol::TType _etype1059; - xfer += iprot->readListBegin(_etype1059, _size1056); - this->success.resize(_size1056); - uint32_t _i1060; - for (_i1060 = 0; _i1060 < _size1056; ++_i1060) + uint32_t _size1049; + ::apache::thrift::protocol::TType _etype1052; + xfer += iprot->readListBegin(_etype1052, _size1049); + this->success.resize(_size1049); + uint32_t _i1053; + for (_i1053 = 0; _i1053 < _size1049; ++_i1053) { - xfer += iprot->readString(this->success[_i1060]); + xfer += iprot->readString(this->success[_i1053]); } 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 _iter1061; - for (_iter1061 = this->success.begin(); _iter1061 != this->success.end(); ++_iter1061) + std::vector<std::string> ::const_iterator _iter1054; + for (_iter1054 = this->success.begin(); _iter1054 != this->success.end(); ++_iter1054) { - xfer += oprot->writeString((*_iter1061)); + xfer += oprot->writeString((*_iter1054)); } 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 _size1062; - ::apache::thrift::protocol::TType _etype1065; - xfer += iprot->readListBegin(_etype1065, _size1062); - (*(this->success)).resize(_size1062); - uint32_t _i1066; - for (_i1066 = 0; _i1066 < _size1062; ++_i1066) + uint32_t _size1055; + ::apache::thrift::protocol::TType _etype1058; + xfer += iprot->readListBegin(_etype1058, _size1055); + (*(this->success)).resize(_size1055); + uint32_t _i1059; + for (_i1059 = 0; _i1059 < _size1055; ++_i1059) { - xfer += iprot->readString((*(this->success))[_i1066]); + xfer += iprot->readString((*(this->success))[_i1059]); } 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 _size1067; - ::apache::thrift::protocol::TType _etype1070; - xfer += iprot->readListBegin(_etype1070, _size1067); - this->success.resize(_size1067); - uint32_t _i1071; - for (_i1071 = 0; _i1071 < _size1067; ++_i1071) + 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) { - xfer += iprot->readString(this->success[_i1071]); + xfer += iprot->readString(this->success[_i1064]); } 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 _iter1072; - for (_iter1072 = this->success.begin(); _iter1072 != this->success.end(); ++_iter1072) + std::vector<std::string> ::const_iterator _iter1065; + for (_iter1065 = this->success.begin(); _iter1065 != this->success.end(); ++_iter1065) { - xfer += oprot->writeString((*_iter1072)); + xfer += oprot->writeString((*_iter1065)); } 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 _size1073; - ::apache::thrift::protocol::TType _etype1076; - xfer += iprot->readListBegin(_etype1076, _size1073); - (*(this->success)).resize(_size1073); - uint32_t _i1077; - for (_i1077 = 0; _i1077 < _size1073; ++_i1077) + 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) { - xfer += iprot->readString((*(this->success))[_i1077]); + xfer += iprot->readString((*(this->success))[_i1070]); } 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 _size1078; - ::apache::thrift::protocol::TType _ktype1079; - ::apache::thrift::protocol::TType _vtype1080; - xfer += iprot->readMapBegin(_ktype1079, _vtype1080, _size1078); - uint32_t _i1082; - for (_i1082 = 0; _i1082 < _size1078; ++_i1082) + 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) { - std::string _key1083; - xfer += iprot->readString(_key1083); - Type& _val1084 = this->success[_key1083]; - xfer += _val1084.read(iprot); + std::string _key1076; + xfer += iprot->readString(_key1076); + Type& _val1077 = this->success[_key1076]; + xfer += _val1077.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 _iter1085; - for (_iter1085 = this->success.begin(); _iter1085 != this->success.end(); ++_iter1085) + std::map<std::string, Type> ::const_iterator _iter1078; + for (_iter1078 = this->success.begin(); _iter1078 != this->success.end(); ++_iter1078) { - xfer += oprot->writeString(_iter1085->first); - xfer += _iter1085->second.write(oprot); + xfer += oprot->writeString(_iter1078->first); + xfer += _iter1078->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 _size1086; - ::apache::thrift::protocol::TType _ktype1087; - ::apache::thrift::protocol::TType _vtype1088; - xfer += iprot->readMapBegin(_ktype1087, _vtype1088, _size1086); - uint32_t _i1090; - for (_i1090 = 0; _i1090 < _size1086; ++_i1090) + 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) { - std::string _key1091; - xfer += iprot->readString(_key1091); - Type& _val1092 = (*(this->success))[_key1091]; - xfer += _val1092.read(iprot); + std::string _key1084; + xfer += iprot->readString(_key1084); + Type& _val1085 = (*(this->success))[_key1084]; + xfer += _val1085.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 _size1093; - ::apache::thrift::protocol::TType _etype1096; - xfer += iprot->readListBegin(_etype1096, _size1093); - this->success.resize(_size1093); - uint32_t _i1097; - for (_i1097 = 0; _i1097 < _size1093; ++_i1097) + uint32_t _size1086; + ::apache::thrift::protocol::TType _etype1089; + xfer += iprot->readListBegin(_etype1089, _size1086); + this->success.resize(_size1086); + uint32_t _i1090; + for (_i1090 = 0; _i1090 < _size1086; ++_i1090) { - xfer += this->success[_i1097].read(iprot); + xfer += this->success[_i1090].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 _iter1098; - for (_iter1098 = this->success.begin(); _iter1098 != this->success.end(); ++_iter1098) + std::vector<FieldSchema> ::const_iterator _iter1091; + for (_iter1091 = this->success.begin(); _iter1091 != this->success.end(); ++_iter1091) { - xfer += (*_iter1098).write(oprot); + xfer += (*_iter1091).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 _size1099; - ::apache::thrift::protocol::TType _etype1102; - xfer += iprot->readListBegin(_etype1102, _size1099); - (*(this->success)).resize(_size1099); - uint32_t _i1103; - for (_i1103 = 0; _i1103 < _size1099; ++_i1103) + uint32_t _size1092; + ::apache::thrift::protocol::TType _etype1095; + xfer += iprot->readListBegin(_etype1095, _size1092); + (*(this->success)).resize(_size1092); + uint32_t _i1096; + for (_i1096 = 0; _i1096 < _size1092; ++_i1096) { - xfer += (*(this->success))[_i1103].read(iprot); + xfer += (*(this->success))[_i1096].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 _size1104; - ::apache::thrift::protocol::TType _etype1107; - xfer += iprot->readListBegin(_etype1107, _size1104); - this->success.resize(_size1104); - uint32_t _i1108; - for (_i1108 = 0; _i1108 < _size1104; ++_i1108) + uint32_t _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 += this->success[_i1108].read(iprot); + xfer += this->success[_i1101].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 _iter1109; - for (_iter1109 = this->success.begin(); _iter1109 != this->success.end(); ++_iter1109) + std::vector<FieldSchema> ::const_iterator _iter1102; + for (_iter1102 = this->success.begin(); _iter1102 != this->success.end(); ++_iter1102) { - xfer += (*_iter1109).write(oprot); + xfer += (*_iter1102).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 _size1110; - ::apache::thrift::protocol::TType _etype1113; - xfer += iprot->readListBegin(_etype1113, _size1110); - (*(this->success)).resize(_size1110); - uint32_t _i1114; - for (_i1114 = 0; _i1114 < _size1110; ++_i1114) + uint32_t _size1103; + ::apache::thrift::protocol::TType _etype1106; + xfer += iprot->readListBegin(_etype1106, _size1103); + (*(this->success)).resize(_size1103); + uint32_t _i1107; + for (_i1107 = 0; _i1107 < _size1103; ++_i1107) { - xfer += (*(this->success))[_i1114].read(iprot); + xfer += (*(this->success))[_i1107].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 _size1115; - ::apache::thrift::protocol::TType _etype1118; - xfer += iprot->readListBegin(_etype1118, _size1115); - this->success.resize(_size1115); - uint32_t _i1119; - for (_i1119 = 0; _i1119 < _size1115; ++_i1119) + uint32_t _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 += this->success[_i1119].read(iprot); + xfer += this->success[_i1112].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 _iter1120; - for (_iter1120 = this->success.begin(); _iter1120 != this->success.end(); ++_iter1120) + std::vector<FieldSchema> ::const_iterator _iter1113; + for (_iter1113 = this->success.begin(); _iter1113 != this->success.end(); ++_iter1113) { - xfer += (*_iter1120).write(oprot); + xfer += (*_iter1113).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 _size1121; - ::apache::thrift::protocol::TType _etype1124; - xfer += iprot->readListBegin(_etype1124, _size1121); - (*(this->success)).resize(_size1121); - uint32_t _i1125; - for (_i1125 = 0; _i1125 < _size1121; ++_i1125) + uint32_t _size1114; + ::apache::thrift::protocol::TType _etype1117; + xfer += iprot->readListBegin(_etype1117, _size1114); + (*(this->success)).resize(_size1114); + uint32_t _i1118; + for (_i1118 = 0; _i1118 < _size1114; ++_i1118) { - xfer += (*(this->success))[_i1125].read(iprot); + xfer += (*(this->success))[_i1118].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 _size1126; - ::apache::thrift::protocol::TType _etype1129; - xfer += iprot->readListBegin(_etype1129, _size1126); - this->success.resize(_size1126); - uint32_t _i1130; - for (_i1130 = 0; _i1130 < _size1126; ++_i1130) + 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[_i1130].read(iprot); + xfer += this->success[_i1123].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 _iter1131; - for (_iter1131 = this->success.begin(); _iter1131 != this->success.end(); ++_iter1131) + std::vector<FieldSchema> ::const_iterator _iter1124; + for (_iter1124 = this->success.begin(); _iter1124 != this->success.end(); ++_iter1124) { - xfer += (*_iter1131).write(oprot); + xfer += (*_iter1124).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 _size1132; - ::apache::thrift::protocol::TType _etype1135; - xfer += iprot->readListBegin(_etype1135, _size1132); - (*(this->success)).resize(_size1132); - uint32_t _i1136; - for (_i1136 = 0; _i1136 < _size1132; ++_i1136) + 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) { - xfer += (*(this->success))[_i1136].read(iprot); + xfer += (*(this->success))[_i1129].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 _size1137; - ::apache::thrift::protocol::TType _etype1140; - xfer += iprot->readListBegin(_etype1140, _size1137); - this->primaryKeys.resize(_size1137); - uint32_t _i1141; - for (_i1141 = 0; _i1141 < _size1137; ++_i1141) + 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) { - xfer += this->primaryKeys[_i1141].read(iprot); + xfer += this->primaryKeys[_i1134].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 _size1142; - ::apache::thrift::protocol::TType _etype1145; - xfer += iprot->readListBegin(_etype1145, _size1142); - this->foreignKeys.resize(_size1142); - uint32_t _i1146; - for (_i1146 = 0; _i1146 < _size1142; ++_i1146) + 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) { - xfer += this->foreignKeys[_i1146].read(iprot); + xfer += this->foreignKeys[_i1139].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 _size1147; - ::apache::thrift::protocol::TType _etype1150; - xfer += iprot->readListBegin(_etype1150, _size1147); - this->uniqueConstraints.resize(_size1147); - uint32_t _i1151; - for (_i1151 = 0; _i1151 < _size1147; ++_i1151) + 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) { - xfer += this->uniqueConstraints[_i1151].read(iprot); + xfer += this->uniqueConstraints[_i1144].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 _size1152; - ::apache::thrift::protocol::TType _etype1155; - xfer += iprot->readListBegin(_etype1155, _size1152); - this->notNullConstraints.resize(_size1152); - uint32_t _i1156; - for (_i1156 = 0; _i1156 < _size1152; ++_i1156) + 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) { - xfer += this->notNullConstraints[_i1156].read(iprot); + xfer += this->notNullConstraints[_i1149].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 _iter1157; - for (_iter1157 = this->primaryKeys.begin(); _iter1157 != this->primaryKeys.end(); ++_iter1157) + std::vector<SQLPrimaryKey> ::const_iterator _iter1150; + for (_iter1150 = this->primaryKeys.begin(); _iter1150 != this->primaryKeys.end(); ++_iter1150) { - xfer += (*_iter1157).write(oprot); + xfer += (*_iter1150).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 _iter1158; - for (_iter1158 = this->foreignKeys.begin(); _iter1158 != this->foreignKeys.end(); ++_iter1158) + std::vector<SQLForeignKey> ::const_iterator _iter1151; + for (_iter1151 = this->foreignKeys.begin(); _iter1151 != this->foreignKeys.end(); ++_iter1151) { - xfer += (*_iter1158).write(oprot); + xfer += (*_iter1151).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 _iter1159; - for (_iter1159 = this->uniqueConstraints.begin(); _iter1159 != this->uniqueConstraints.end(); ++_iter1159) + std::vector<SQLUniqueConstraint> ::const_iterator _iter1152; + for (_iter1152 = this->uniqueConstraints.begin(); _iter1152 != this->uniqueConstraints.end(); ++_iter1152) { - xfer += (*_iter1159).write(oprot); + xfer += (*_iter1152).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 _iter1160; - for (_iter1160 = this->notNullConstraints.begin(); _iter1160 != this->notNullConstraints.end(); ++_iter1160) + std::vector<SQLNotNullConstraint> ::const_iterator _iter1153; + for (_iter1153 = this->notNullConstraints.begin(); _iter1153 != this->notNullConstraints.end(); ++_iter1153) { - xfer += (*_iter1160).write(oprot); + xfer += (*_iter1153).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 _iter1161; - for (_iter1161 = (*(this->primaryKeys)).begin(); _iter1161 != (*(this->primaryKeys)).end(); ++_iter1161) + std::vector<SQLPrimaryKey> ::const_iterator _iter1154; + for (_iter1154 = (*(this->primaryKeys)).begin(); _iter1154 != (*(this->primaryKeys)).end(); ++_iter1154) { - xfer += (*_iter1161).write(oprot); + xfer += (*_iter1154).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 _iter1162; - for (_iter1162 = (*(this->foreignKeys)).begin(); _iter1162 != (*(this->foreignKeys)).end(); ++_iter1162) + std::vector<SQLForeignKey> ::const_iterator _iter1155; + for (_iter1155 = (*(this->foreignKeys)).begin(); _iter1155 != (*(this->foreignKeys)).end(); ++_iter1155) { - xfer += (*_iter1162).write(oprot); + xfer += (*_iter1155).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 _iter1163; - for (_iter1163 = (*(this->uniqueConstraints)).begin(); _iter1163 != (*(this->uniqueConstraints)).end(); ++_iter1163) + std::vector<SQLUniqueConstraint> ::const_iterator _iter1156; + for (_iter1156 = (*(this->uniqueConstraints)).begin(); _iter1156 != (*(this->uniqueConstraints)).end(); ++_iter1156) { - xfer += (*_iter1163).write(oprot); + xfer += (*_iter1156).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 _iter1164; - for (_iter1164 = (*(this->notNullConstraints)).begin(); _iter1164 != (*(this->notNullConstraints)).end(); ++_iter1164) + std::vector<SQLNotNullConstraint> ::const_iterator _iter1157; + for (_iter1157 = (*(this->notNullConstraints)).begin(); _iter1157 != (*(this->notNullConstraints)).end(); ++_iter1157) { - xfer += (*_iter1164).write(oprot); + xfer += (*_iter1157).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 _size1165; - ::apache::thrift::protocol::TType _etype1168; - xfer += iprot->readListBegin(_etype1168, _size1165); - this->partNames.resize(_size1165); - uint32_t _i1169; - for (_i1169 = 0; _i1169 < _size1165; ++_i1169) + 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) { - xfer += iprot->readString(this->partNames[_i1169]); + xfer += iprot->readString(this->partNames[_i1162]); } 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 _iter1170; - for (_iter1170 = this->partNames.begin(); _iter1170 != this->partNames.end(); ++_iter1170) + std::vector<std::string> ::const_iterator _iter1163; + for (_iter1163 = this->partNames.begin(); _iter1163 != this->partNames.end(); ++_iter1163) { - xfer += oprot->writeString((*_iter1170)); + xfer += oprot->writeString((*_iter1163)); } 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 _iter1171; - for (_iter1171 = (*(this->partNames)).begin(); _iter1171 != (*(this->partNames)).end(); ++_iter1171) + std::vector<std::string> ::const_iterator _iter1164; + for (_iter1164 = (*(this->partNames)).begin(); _iter1164 != (*(this->partNames)).end(); ++_iter1164) { - xfer += oprot->writeString((*_iter1171)); + xfer += oprot->writeString((*_iter1164)); } 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 _size1172; - ::apache::thrift::protocol::TType _etype1175; - xfer += iprot->readListBegin(_etype1175, _size1172); - this->success.resize(_size1172); - uint32_t _i1176; - for (_i1176 = 0; _i1176 < _size1172; ++_i1176) + uint32_t _size1165; + ::apache::thrift::protocol::TType _etype1168; + xfer += iprot->readListBegin(_etype1168, _size1165); + this->success.resize(_size1165); + uint32_t _i1169; + for (_i1169 = 0; _i1169 < _size1165; ++_i1169) { - xfer += iprot->readString(this->success[_i1176]); + xfer += iprot->readString(this->success[_i1169]); } 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 _iter1177; - for (_iter1177 = this->success.begin(); _iter1177 != this->success.end(); ++_iter1177) + std::vector<std::string> ::const_iterator _iter1170; + for (_iter1170 = this->success.begin(); _iter1170 != this->success.end(); ++_iter1170) { - xfer += oprot->writeString((*_iter1177)); + xfer += oprot->writeString((*_iter1170)); } 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 _size1178; - ::apache::thrift::protocol::TType _etype1181; - xfer += iprot->readListBegin(_etype1181, _size1178); - (*(this->success)).resize(_size1178); - uint32_t _i1182; - for (_i1182 = 0; _i1182 < _size1178; ++_i1182) + uint32_t _size1171; + ::apache::thrift::protocol::TType _etype1174; + xfer += iprot->readListBegin(_etype1174, _size1171); + (*(this->success)).resize(_size1171); + uint32_t _i1175; + for (_i1175 = 0; _i1175 < _size1171; ++_i1175) { - xfer += iprot->readString((*(this->success))[_i1182]); + xfer += iprot->readString((*(this->success))[_i1175]); } 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 _size1183; - ::apache::thrift::protocol::TType _etype1186; - xfer += iprot->readListBegin(_etype1186, _size1183); - this->success.resize(_size1183); - uint32_t _i1187; - for (_i1187 = 0; _i1187 < _size1183; ++_i1187) + uint32_t _size1176; + ::apache::thrift::protocol::TType _etype1179; + xfer += iprot->readListBegin(_etype1179, _size1176); + this->success.resize(_size1176); + uint32_t _i1180; + for (_i1180 = 0; _i1180 < _size1176; ++_i1180) { - xfer += iprot->readString(this->success[_i1187]); + xfer += iprot->readString(this->success[_i1180]); } 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 _iter1188; - for (_iter1188 = this->success.begin(); _iter1188 != this->success.end(); ++_iter1188) + std::vector<std::string> ::const_iterator _iter1181; + for (_iter1181 = this->success.begin(); _iter1181 != this->success.end(); ++_iter1181) { - xfer += oprot->writeString((*_iter1188)); + xfer += oprot->writeString((*_iter1181)); } 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 _size1189; - ::apache::thrift::protocol::TType _etype1192; - xfer += iprot->readListBegin(_etype1192, _size1189); - (*(this->success)).resize(_size1189); - uint32_t _i1193; - for (_i1193 = 0; _i1193 < _size1189; ++_i1193) + uint32_t _size1182; + ::apache::thrift::protocol::TType _etype1185; + xfer += iprot->readListBegin(_etype1185, _size1182); + (*(this->success)).resize(_size1182); + uint32_t _i1186; + for (_i1186 = 0; _i1186 < _size1182; ++_i1186) { - xfer += iprot->readString((*(this->success))[_i1193]); + xfer += iprot->readString((*(this->success))[_i1186]); } 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 _size1194; - ::apache::thrift::protocol::TType _etype1197; - xfer += iprot->readListBegin(_etype1197, _size1194); - this->success.resize(_size1194); - uint32_t _i1198; - for (_i1198 = 0; _i1198 < _size1194; ++_i1198) + 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) { - xfer += iprot->readString(this->success[_i1198]); + xfer += iprot->readString(this->success[_i1191]); } 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 _iter1199; - for (_iter1199 = this->success.begin(); _iter1199 != this->success.end(); ++_iter1199) + std::vector<std::string> ::const_iterator _iter1192; + for (_iter1192 = this->success.begin(); _iter1192 != this->success.end(); ++_iter1192) { - xfer += oprot->writeString((*_iter1199)); + xfer += oprot->writeString((*_iter1192)); } 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 _size1200; - ::apache::thrift::protocol::TType _etype1203; - xfer += iprot->readListBegin(_etype1203, _size1200); - (*(this->success)).resize(_size1200); - uint32_t _i1204; - for (_i1204 = 0; _i1204 < _size1200; ++_i1204) + 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) { - xfer += iprot->readString((*(this->success))[_i1204]); + xfer += iprot->readString((*(this->success))[_i1197]); } 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 _size1205; - ::apache::thrift::protocol::TType _etype1208; - xfer += iprot->readListBegin(_etype1208, _size1205); - this->tbl_types.resize(_size1205); - uint32_t _i1209; - for (_i1209 = 0; _i1209 < _size1205; ++_i1209) + 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) { - xfer += iprot->readString(this->tbl_types[_i1209]); + xfer += iprot->readString(this->tbl_types[_i1202]); } 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 _iter1210; - for (_iter1210 = this->tbl_types.begin(); _iter1210 != this->tbl_types.end(); ++_iter1210) + std::vector<std::string> ::const_iterator _iter1203; + for (_iter1203 = this->tbl_types.begin(); _iter1203 != this->tbl_types.end(); ++_iter1203) { - xfer += oprot->writeString((*_iter1210)); + xfer += oprot->writeString((*_iter1203)); } 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 _iter1211; - for (_iter1211 = (*(this->tbl_types)).begin(); _iter1211 != (*(this->tbl_types)).end(); ++_iter1211) + std::vector<std::string> ::const_iterator _iter1204; + for (_iter1204 = (*(this->tbl_types)).begin(); _iter1204 != (*(this->tbl_types)).end(); ++_iter1204) { - xfer += oprot->writeString((*_iter1211)); + xfer += oprot->writeString((*_iter1204)); } 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 _size1212; - ::apache::thrift::protocol::TType _etype1215; - xfer += iprot->readListBegin(_etype1215, _size1212); - this->success.resize(_size1212); - uint32_t _i1216; - for (_i1216 = 0; _i1216 < _size1212; ++_i1216) + uint32_t _size1205; + ::apache::thrift::protocol::TType _etype1208; + xfer += iprot->readListBegin(_etype1208, _size1205); + this->success.resize(_size1205); + uint32_t _i1209; + for (_i1209 = 0; _i1209 < _size1205; ++_i1209) { - xfer += this->success[_i1216].read(iprot); + xfer += this->success[_i1209].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 _iter1217; - for (_iter1217 = this->success.begin(); _iter1217 != this->success.end(); ++_iter1217) + std::vector<TableMeta> ::const_iterator _iter1210; + for (_iter1210 = this->success.begin(); _iter1210 != this->success.end(); ++_iter1210) { - xfer += (*_iter1217).write(oprot); + xfer += (*_iter1210).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 _size1218; - ::apache::thrift::protocol::TType _etype1221; - xfer += iprot->readListBegin(_etype1221, _size1218); - (*(this->success)).resize(_size1218); - uint32_t _i1222; - for (_i1222 = 0; _i1222 < _size1218; ++_i1222) + uint32_t _size1211; + ::apache::thrift::protocol::TType _etype1214; + xfer += iprot->readListBegin(_etype1214, _size1211); + (*(this->success)).resize(_size1211); + uint32_t _i1215; + for (_i1215 = 0; _i1215 < _size1211; ++_i1215) { - xfer += (*(this->success))[_i1222].read(iprot); + xfer += (*(this->success))[_i1215].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 _size1223; - ::apache::thrift::protocol::TType _etype1226; - xfer += iprot->readListBegin(_etype1226, _size1223); - this->success.resize(_size1223); - uint32_t _i1227; - for (_i1227 = 0; _i1227 < _size1223; ++_i1227) + uint32_t _size1216; + ::apache::thrift::protocol::TType _etype1219; + xfer += iprot->readListBegin(_etype1219, _size1216); + this->success.resize(_size1216); + uint32_t _i1220; + for (_i1220 = 0; _i1220 < _size1216; ++_i1220) { - xfer += iprot->readString(this->success[_i1227]); + xfer += iprot->readString(this->success[_i1220]); } 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 _iter1228; - for (_iter1228 = this->success.begin(); _iter1228 != this->success.end(); ++_iter1228) + std::vector<std::string> ::const_iterator _iter1221; + for (_iter1221 = this->success.begin(); _iter1221 != this->success.end(); ++_iter1221) { - xfer += oprot->writeString((*_iter1228)); + xfer += oprot->writeString((*_iter1221)); } 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 _size1229; - ::apache::thrift::protocol::TType _etype1232; - xfer += iprot->readListBegin(_etype1232, _size1229); - (*(this->success)).resize(_size1229); - uint32_t _i1233; - for (_i1233 = 0; _i1233 < _size1229; ++_i1233) + 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) { - xfer += iprot->readString((*(this->success))[_i1233]); + xfer += iprot->readString((*(this->success))[_i1226]); } 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 _size1234; - ::apache::thrift::protocol::TType _etype1237; - xfer += iprot->readListBegin(_etype1237, _size1234); - this->tbl_names.resize(_size1234); - uint32_t _i1238; - for (_i1238 = 0; _i1238 < _size1234; ++_i1238) + 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) { - xfer += iprot->readString(this->tbl_names[_i1238]); + xfer += iprot->readString(this->tbl_names[_i1231]); } 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 _iter1239; - for (_iter1239 = this->tbl_names.begin(); _iter1239 != this->tbl_names.end(); ++_iter1239) + std::vector<std::string> ::const_iterator _iter1232; + for (_iter1232 = this->tbl_names.begin(); _iter1232 != this->tbl_names.end(); ++_iter1232) { - xfer += oprot->writeString((*_iter1239)); + xfer += oprot->writeString((*_iter1232)); } 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 _iter1240; - for (_iter1240 = (*(this->tbl_names)).begin(); _iter1240 != (*(this->tbl_names)).end(); ++_iter1240) + std::vector<std::string> ::const_iterator _iter1233; + for (_iter1233 = (*(this->tbl_names)).begin(); _iter1233 != (*(this->tbl_names)).end(); ++_iter1233) { - xfer += oprot->writeString((*_iter1240)); + xfer += oprot->writeString((*_iter1233)); } 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 _size1241; - ::apache::thrift::protocol::TType _etype1244; - xfer += iprot->readListBegin(_etype1244, _size1241); - this->success.resize(_size1241); - uint32_t _i1245; - for (_i1245 = 0; _i1245 < _size1241; ++_i1245) + uint32_t _size1234; + ::apache::thrift::protocol::TType _etype1237; + xfer += iprot->readListBegin(_etype1237, _size1234); + this->success.resize(_size1234); + uint32_t _i1238; + for (_i1238 = 0; _i1238 < _size1234; ++_i1238) { - xfer += this->success[_i1245].read(iprot); + xfer += this->success[_i1238].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 _iter1246; - for (_iter1246 = this->success.begin(); _iter1246 != this->success.end(); ++_iter1246) + std::vector<Table> ::const_iterator _iter1239; + for (_iter1239 = this->success.begin(); _iter1239 != this->success.end(); ++_iter1239) { - xfer += (*_iter1246).write(oprot); + xfer += (*_iter1239).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 _size1247; - ::apache::thrift::protocol::TType _etype1250; - xfer += iprot->readListBegin(_etype1250, _size1247); - (*(this->success)).resize(_size1247); - uint32_t _i1251; - for (_i1251 = 0; _i1251 < _size1247; ++_i1251) + 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) { - xfer += (*(this->success))[_i1251].read(iprot); + xfer += (*(this->success))[_i1244].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 _size1252; - ::apache::thrift::protocol::TType _etype1255; - xfer += iprot->readListBegin(_etype1255, _size1252); - this->tbl_names.resize(_size1252); - uint32_t _i1256; - for (_i1256 = 0; _i1256 < _size1252; ++_i1256) + 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) { - xfer += iprot->readString(this->tbl_names[_i1256]); + xfer += iprot->readString(this->tbl_names[_i1249]); } 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 _iter1257; - for (_iter1257 = this->tbl_names.begin(); _iter1257 != this->tbl_names.end(); ++_iter1257) + std::vector<std::string> ::const_iterator _iter1250; + for (_iter1250 = this->tbl_names.begin(); _iter1250 != this->tbl_names.end(); ++_iter1250) { - xfer += oprot->writeString((*_iter1257)); + xfer += oprot->writeString((*_iter1250)); } 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 _iter1258; - for (_iter1258 = (*(this->tbl_names)).begin(); _iter1258 != (*(this->tbl_names)).end(); ++_iter1258) + std::vector<std::string> ::const_iterator _iter1251; + for (_iter1251 = (*(this->tbl_names)).begin(); _iter1251 != (*(this->tbl_names)).end(); ++_iter1251) { - xfer += oprot->writeString((*_iter1258)); + xfer += oprot->writeString((*_iter1251)); } 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 _size1259; - ::apache::thrift::protocol::TType _ktype1260; - ::apache::thrift::protocol::TType _vtype1261; - xfer += iprot->readMapBegin(_ktype1260, _vtype1261, _size1259); - uint32_t _i1263; - for (_i1263 = 0; _i1263 < _size1259; ++_i1263) + 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) { - std::string _key1264; - xfer += iprot->readString(_key1264); - Materialization& _val1265 = this->success[_key1264]; - xfer += _val1265.read(iprot); + std::string _key1257; + xfer += iprot->readString(_key1257); + Materialization& _val1258 = this->success[_key1257]; + xfer += _val1258.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 _iter1266; - for (_iter1266 = this->success.begin(); _iter1266 != this->success.end(); ++_iter1266) + std::map<std::string, Materialization> ::const_iterator _iter1259; + for (_iter1259 = this->success.begin(); _iter1259 != this->success.end(); ++_iter1259) { - xfer += oprot->writeString(_iter1266->first); - xfer += _iter1266->second.write(oprot); + xfer += oprot->writeString(_iter1259->first); + xfer += _iter1259->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 _size1267; - ::apache::thrift::protocol::TType _ktype1268; - ::apache::thrift::protocol::TType _vtype1269; - xfer += iprot->readMapBegin(_ktype1268, _vtype1269, _size1267); - uint32_t _i1271; - for (_i1271 = 0; _i1271 < _size1267; ++_i1271) + 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) { - std::string _key1272; - xfer += iprot->readString(_key1272); - Materialization& _val1273 = (*(this->success))[_key1272]; - xfer += _val1273.read(iprot); + std::string _key1265; + xfer += iprot->readString(_key1265); + Materialization& _val1266 = (*(this->success))[_key1265]; + xfer += _val1266.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 _size1274; - ::apache::thrift::protocol::TType _etype1277; - xfer += iprot->readListBegin(_etype1277, _size1274); - this->success.resize(_size1274); - uint32_t _i1278; - for (_i1278 = 0; _i1278 < _size1274; ++_i1278) + 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 += iprot->readString(this->success[_i1278]); + xfer += iprot->readString(this->success[_i1271]); } 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 _iter1279; - for (_iter1279 = this->success.begin(); _iter1279 != this->success.end(); ++_iter1279) + std::vector<std::string> ::const_iterator _iter1272; + for (_iter1272 = this->success.begin(); _iter1272 != this->success.end(); ++_iter1272) { - xfer += oprot->writeString((*_iter1279)); + xfer += oprot->writeString((*_iter1272)); } 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 _size1280; - ::apache::thrift::protocol::TType _etype1283; - xfer += iprot->readListBegin(_etype1283, _size1280); - (*(this->success)).resize(_size1280); - uint32_t _i1284; - for (_i1284 = 0; _i1284 < _size1280; ++_i1284) + 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) { - xfer += iprot->readString((*(this->success))[_i1284]); + xfer += iprot->readString((*(this->success))[_i1277]); } 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 _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 _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) { - xfer += this->new_parts[_i1289].read(iprot); + xfer += this->new_parts[_i1282].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 _iter1290; - for (_iter1290 = this->new_parts.begin(); _iter1290 != this->new_parts.end(); ++_iter1290) + std::vector<Partition> ::const_iterator _iter1283; + for (_iter1283 = this->new_parts.begin(); _iter1283 != this->new_parts.end(); ++_iter1283) { - xfer += (*_iter1290).write(oprot); + xfer += (*_iter1283).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 _iter1291; - for (_iter1291 = (*(this->new_parts)).begin(); _iter1291 != (*(this->new_parts)).end(); ++_iter1291) + std::vector<Partition> ::const_iterator _iter1284; + for (_iter1284 = (*(this->new_parts)).begin(); _iter1284 != (*(this->new_parts)).end(); ++_iter1284) { - xfer += (*_iter1291).write(oprot); + xfer += (*_iter1284).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 _size1292; - ::apache::thrift::protocol::TType _etype1295; - xfer += iprot->readListBegin(_etype1295, _size1292); - this->new_parts.resize(_size1292); - uint32_t _i1296; - for (_i1296 = 0; _i1296 < _size1292; ++_i1296) + 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) { - xfer += this->new_parts[_i1296].read(iprot); + xfer += this->new_parts[_i1289].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 _iter1297; - for (_iter1297 = this->new_parts.begin(); _iter1297 != this->new_parts.end(); ++_iter1297) + std::vector<PartitionSpec> ::const_iterator _iter1290; + for (_iter1290 = this->new_parts.begin(); _iter1290 != this->new_parts.end(); ++_iter1290) { - xfer += (*_iter1297).write(oprot); + xfer += (*_iter1290).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 _iter1298; - for (_iter1298 = (*(this->new_parts)).begin(); _iter1298 != (*(this->new_parts)).end(); ++_iter1298) + std::vector<PartitionSpec> ::const_iterator _iter1291; + for (_iter1291 = (*(this->new_parts)).begin(); _iter1291 != (*(this->new_parts)).end(); ++_iter1291) { - xfer += (*_iter1298).write(oprot); + xfer += (*_iter1291).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 _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 _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) { - xfer += iprot->readString(this->part_vals[_i1303]); + xfer += iprot->readString(this->part_vals[_i1296]); } 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 _iter1304; - for (_iter1304 = this->part_vals.begin(); _iter1304 != this->part_vals.end(); ++_iter1304) + std::vector<std::string> ::const_iterator _iter1297; + for (_iter1297 = this->part_vals.begin(); _iter1297 != this->part_vals.end(); ++_iter1297) { - xfer += oprot->writeString((*_iter1304)); + xfer += oprot->writeString((*_iter1297)); } 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 _iter1305; - for (_iter1305 = (*(this->part_vals)).begin(); _iter1305 != (*(this->part_vals)).end(); ++_iter1305) + std::vector<std::string> ::const_iterator _iter1298; + for (_iter1298 = (*(this->part_vals)).begin(); _iter1298 != (*(this->part_vals)).end(); ++_iter1298) { - xfer += oprot->writeString((*_iter1305)); + xfer += oprot->writeString((*_iter1298)); } 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 _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 _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) { - xfer += iprot->readString(this->part_vals[_i1310]); + xfer += iprot->readString(this->part_vals[_i1303]); } 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 _iter1311; - for (_iter1311 = this->part_vals.begin(); _iter1311 != this->part_vals.end(); ++_iter1311) + std::vector<std::string> ::const_iterator _iter1304; + for (_iter1304 = this->part_vals.begin(); _iter1304 != this->part_vals.end(); ++_iter1304) { - xfer += oprot->writeString((*_iter1311)); + xfer += oprot->writeString((*_iter1304)); } 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 _iter1312; - for (_iter1312 = (*(this->part_vals)).begin(); _iter1312 != (*(this->part_vals)).end(); ++_iter1312) + std::vector<std::string> ::const_iterator _iter1305; + for (_iter1305 = (*(this->part_vals)).begin(); _iter1305 != (*(this->part_vals)).end(); ++_iter1305) { - xfer += oprot->writeString((*_iter1312)); + xfer += oprot->writeString((*_iter1305)); } 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 _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 _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) { - xfer += iprot->readString(this->part_vals[_i1317]); + xfer += iprot->readString(this->part_vals[_i1310]); } 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 _iter1318; - for (_iter1318 = this->part_vals.begin(); _iter1318 != this->part_vals.end(); ++_iter1318) + std::vector<std::string> ::const_iterator _iter1311; + for (_iter1311 = this->part_vals.begin(); _iter1311 != this->part_vals.end(); ++_iter1311) { - xfer += oprot->writeString((*_iter1318)); + xfer += oprot->writeString((*_iter1311)); } 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 _iter1319; - for (_iter1319 = (*(this->part_vals)).begin(); _iter1319 != (*(this->part_vals)).end(); ++_iter1319) + std::vector<std::string> ::const_iterator _iter1312; + for (_iter1312 = (*(this->part_vals)).begin(); _iter1312 != (*(this->part_vals)).end(); ++_iter1312) { - xfer += oprot->writeString((*_iter1319)); + xfer += oprot->writeString((*_iter1312)); } 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 _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 _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) { - xfer += iprot->readString(this->part_vals[_i1324]); + xfer += iprot->readString(this->part_vals[_i1317]); } 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 _iter1325; - for (_iter1325 = this->part_vals.begin(); _iter1325 != this->part_vals.end(); ++_iter1325) + std::vector<std::string> ::const_iterator _iter1318; + for (_iter1318 = this->part_vals.begin(); _iter1318 != this->part_vals.end(); ++_iter1318) { - xfer += oprot->writeString((*_iter1325)); + xfer += oprot->writeString((*_iter1318)); } 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 _iter1326; - for (_iter1326 = (*(this->part_vals)).begin(); _iter1326 != (*(this->part_vals)).end(); ++_iter1326) + std::vector<std::string> ::const_iterator _iter1319; + for (_iter1319 = (*(this->part_vals)).begin(); _iter1319 != (*(this->part_vals)).end(); ++_iter1319) { - xfer += oprot->writeString((*_iter1326)); + xfer += oprot->writeString((*_iter1319)); } 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 _size1327; - ::apache::thrift::protocol::TType _etype1330; - xfer += iprot->readListBegin(_etype1330, _size1327); - this->part_vals.resize(_size1327); - uint32_t _i1331; - for (_i1331 = 0; _i1331 < _size1327; ++_i1331) + 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) { - xfer += iprot->readString(this->part_vals[_i1331]); + xfer += iprot->readString(this->part_vals[_i1324]); } 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 _iter1332; - for (_iter1332 = this->part_vals.begin(); _iter1332 != this->part_vals.end(); ++_iter1332) + std::vector<std::string> ::const_iterator _iter1325; + for (_iter1325 = this->part_vals.begin(); _iter1325 != this->part_vals.end(); ++_iter1325) { - xfer += oprot->writeString((*_iter1332)); + xfer += oprot->writeString((*_iter1325)); } 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 _iter1333; - for (_iter1333 = (*(this->part_vals)).begin(); _iter1333 != (*(this->part_vals)).end(); ++_iter1333) + std::vector<std::string> ::const_iterator _iter1326; + for (_iter1326 = (*(this->part_vals)).begin(); _iter1326 != (*(this->part_vals)).end(); ++_iter1326) { - xfer += oprot->writeString((*_iter1333)); + xfer += oprot->writeString((*_iter1326)); } 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 _size1334; - ::apache::thrift::protocol::TType _ktype1335; - ::apache::thrift::protocol::TType _vtype1336; - xfer += iprot->readMapBegin(_ktype1335, _vtype1336, _size1334); - uint32_t _i1338; - for (_i1338 = 0; _i1338 < _size1334; ++_i1338) + 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) { - std::string _key1339; - xfer += iprot->readString(_key1339); - std::string& _val1340 = this->partitionSpecs[_key1339]; - xfer += iprot->readString(_val1340); + std::string _key1332; + xfer += iprot->readString(_key1332); + std::string& _val1333 = this->partitionSpecs[_key1332]; + xfer += iprot->readString(_val1333); } 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 _iter1341; - for (_iter1341 = this->partitionSpecs.begin(); _iter1341 != this->partitionSpecs.end(); ++_iter1341) + std::map<std::string, std::string> ::const_iterator _iter1334; + for (_iter1334 = this->partitionSpecs.begin(); _iter1334 != this->partitionSpecs.end(); ++_iter1334) { - xfer += oprot->writeString(_iter1341->first); - xfer += oprot->writeString(_iter1341->second); + xfer += oprot->writeString(_iter1334->first); + xfer += oprot->writeString(_iter1334->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 _iter1342; - for (_iter1342 = (*(this->partitionSpecs)).begin(); _iter1342 != (*(this->partitionSpecs)).end(); ++_iter1342) + std::map<std::string, std::string> ::const_iterator _iter1335; + for (_iter1335 = (*(this->partitionSpecs)).begin(); _iter1335 != (*(this->partitionSpecs)).end(); ++_iter1335) { - xfer += oprot->writeString(_iter1342->first); - xfer += oprot->writeString(_iter1342->second); + xfer += oprot->writeString(_iter1335->first); + xfer += oprot->writeString(_iter1335->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 _size1343; - ::apache::thrift::protocol::TType _ktype1344; - ::apache::thrift::protocol::TType _vtype1345; - xfer += iprot->readMapBegin(_ktype1344, _vtype1345, _size1343); - uint32_t _i1347; - for (_i1347 = 0; _i1347 < _size1343; ++_i1347) + 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) { - std::string _key1348; - xfer += iprot->readString(_key1348); - std::string& _val1349 = this->partitionSpecs[_key1348]; - xfer += iprot->readString(_val1349); + std::string _key1341; + xfer += iprot->readString(_key1341); + std::string& _val1342 = this->partitionSpecs[_key1341]; + xfer += iprot->readString(_val1342); } 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 _iter1350; - for (_iter1350 = this->partitionSpecs.begin(); _iter1350 != this->partitionSpecs.end(); ++_iter1350) + std::map<std::string, std::string> ::const_iterator _iter1343; + for (_iter1343 = this->partitionSpecs.begin(); _iter1343 != this->partitionSpecs.end(); ++_iter1343) { - xfer += oprot->writeString(_iter1350->fir
<TRUNCATED>
