http://git-wip-us.apache.org/repos/asf/hive/blob/b3cb8526/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 dede79b..f667ba0 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 _size1018; - ::apache::thrift::protocol::TType _etype1021; - xfer += iprot->readListBegin(_etype1021, _size1018); - this->success.resize(_size1018); - uint32_t _i1022; - for (_i1022 = 0; _i1022 < _size1018; ++_i1022) + uint32_t _size1045; + ::apache::thrift::protocol::TType _etype1048; + xfer += iprot->readListBegin(_etype1048, _size1045); + this->success.resize(_size1045); + uint32_t _i1049; + for (_i1049 = 0; _i1049 < _size1045; ++_i1049) { - xfer += iprot->readString(this->success[_i1022]); + xfer += iprot->readString(this->success[_i1049]); } 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 _iter1023; - for (_iter1023 = this->success.begin(); _iter1023 != this->success.end(); ++_iter1023) + std::vector<std::string> ::const_iterator _iter1050; + for (_iter1050 = this->success.begin(); _iter1050 != this->success.end(); ++_iter1050) { - xfer += oprot->writeString((*_iter1023)); + xfer += oprot->writeString((*_iter1050)); } 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 _size1024; - ::apache::thrift::protocol::TType _etype1027; - xfer += iprot->readListBegin(_etype1027, _size1024); - (*(this->success)).resize(_size1024); - uint32_t _i1028; - for (_i1028 = 0; _i1028 < _size1024; ++_i1028) + uint32_t _size1051; + ::apache::thrift::protocol::TType _etype1054; + xfer += iprot->readListBegin(_etype1054, _size1051); + (*(this->success)).resize(_size1051); + uint32_t _i1055; + for (_i1055 = 0; _i1055 < _size1051; ++_i1055) { - xfer += iprot->readString((*(this->success))[_i1028]); + xfer += iprot->readString((*(this->success))[_i1055]); } 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 _size1029; - ::apache::thrift::protocol::TType _etype1032; - xfer += iprot->readListBegin(_etype1032, _size1029); - this->success.resize(_size1029); - uint32_t _i1033; - for (_i1033 = 0; _i1033 < _size1029; ++_i1033) + 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) { - xfer += iprot->readString(this->success[_i1033]); + xfer += iprot->readString(this->success[_i1060]); } 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 _iter1034; - for (_iter1034 = this->success.begin(); _iter1034 != this->success.end(); ++_iter1034) + std::vector<std::string> ::const_iterator _iter1061; + for (_iter1061 = this->success.begin(); _iter1061 != this->success.end(); ++_iter1061) { - xfer += oprot->writeString((*_iter1034)); + xfer += oprot->writeString((*_iter1061)); } 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 _size1035; - ::apache::thrift::protocol::TType _etype1038; - xfer += iprot->readListBegin(_etype1038, _size1035); - (*(this->success)).resize(_size1035); - uint32_t _i1039; - for (_i1039 = 0; _i1039 < _size1035; ++_i1039) + 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) { - xfer += iprot->readString((*(this->success))[_i1039]); + xfer += iprot->readString((*(this->success))[_i1066]); } 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 _size1040; - ::apache::thrift::protocol::TType _ktype1041; - ::apache::thrift::protocol::TType _vtype1042; - xfer += iprot->readMapBegin(_ktype1041, _vtype1042, _size1040); - uint32_t _i1044; - for (_i1044 = 0; _i1044 < _size1040; ++_i1044) + uint32_t _size1067; + ::apache::thrift::protocol::TType _ktype1068; + ::apache::thrift::protocol::TType _vtype1069; + xfer += iprot->readMapBegin(_ktype1068, _vtype1069, _size1067); + uint32_t _i1071; + for (_i1071 = 0; _i1071 < _size1067; ++_i1071) { - std::string _key1045; - xfer += iprot->readString(_key1045); - Type& _val1046 = this->success[_key1045]; - xfer += _val1046.read(iprot); + std::string _key1072; + xfer += iprot->readString(_key1072); + Type& _val1073 = this->success[_key1072]; + xfer += _val1073.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 _iter1047; - for (_iter1047 = this->success.begin(); _iter1047 != this->success.end(); ++_iter1047) + std::map<std::string, Type> ::const_iterator _iter1074; + for (_iter1074 = this->success.begin(); _iter1074 != this->success.end(); ++_iter1074) { - xfer += oprot->writeString(_iter1047->first); - xfer += _iter1047->second.write(oprot); + xfer += oprot->writeString(_iter1074->first); + xfer += _iter1074->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 _size1048; - ::apache::thrift::protocol::TType _ktype1049; - ::apache::thrift::protocol::TType _vtype1050; - xfer += iprot->readMapBegin(_ktype1049, _vtype1050, _size1048); - uint32_t _i1052; - for (_i1052 = 0; _i1052 < _size1048; ++_i1052) + uint32_t _size1075; + ::apache::thrift::protocol::TType _ktype1076; + ::apache::thrift::protocol::TType _vtype1077; + xfer += iprot->readMapBegin(_ktype1076, _vtype1077, _size1075); + uint32_t _i1079; + for (_i1079 = 0; _i1079 < _size1075; ++_i1079) { - std::string _key1053; - xfer += iprot->readString(_key1053); - Type& _val1054 = (*(this->success))[_key1053]; - xfer += _val1054.read(iprot); + std::string _key1080; + xfer += iprot->readString(_key1080); + Type& _val1081 = (*(this->success))[_key1080]; + xfer += _val1081.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 _size1055; - ::apache::thrift::protocol::TType _etype1058; - xfer += iprot->readListBegin(_etype1058, _size1055); - this->success.resize(_size1055); - uint32_t _i1059; - for (_i1059 = 0; _i1059 < _size1055; ++_i1059) + uint32_t _size1082; + ::apache::thrift::protocol::TType _etype1085; + xfer += iprot->readListBegin(_etype1085, _size1082); + this->success.resize(_size1082); + uint32_t _i1086; + for (_i1086 = 0; _i1086 < _size1082; ++_i1086) { - xfer += this->success[_i1059].read(iprot); + xfer += this->success[_i1086].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 _iter1060; - for (_iter1060 = this->success.begin(); _iter1060 != this->success.end(); ++_iter1060) + std::vector<FieldSchema> ::const_iterator _iter1087; + for (_iter1087 = this->success.begin(); _iter1087 != this->success.end(); ++_iter1087) { - xfer += (*_iter1060).write(oprot); + xfer += (*_iter1087).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 _size1061; - ::apache::thrift::protocol::TType _etype1064; - xfer += iprot->readListBegin(_etype1064, _size1061); - (*(this->success)).resize(_size1061); - uint32_t _i1065; - for (_i1065 = 0; _i1065 < _size1061; ++_i1065) + uint32_t _size1088; + ::apache::thrift::protocol::TType _etype1091; + xfer += iprot->readListBegin(_etype1091, _size1088); + (*(this->success)).resize(_size1088); + uint32_t _i1092; + for (_i1092 = 0; _i1092 < _size1088; ++_i1092) { - xfer += (*(this->success))[_i1065].read(iprot); + xfer += (*(this->success))[_i1092].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 _size1066; - ::apache::thrift::protocol::TType _etype1069; - xfer += iprot->readListBegin(_etype1069, _size1066); - this->success.resize(_size1066); - uint32_t _i1070; - for (_i1070 = 0; _i1070 < _size1066; ++_i1070) + uint32_t _size1093; + ::apache::thrift::protocol::TType _etype1096; + xfer += iprot->readListBegin(_etype1096, _size1093); + this->success.resize(_size1093); + uint32_t _i1097; + for (_i1097 = 0; _i1097 < _size1093; ++_i1097) { - xfer += this->success[_i1070].read(iprot); + xfer += this->success[_i1097].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 _iter1071; - for (_iter1071 = this->success.begin(); _iter1071 != this->success.end(); ++_iter1071) + std::vector<FieldSchema> ::const_iterator _iter1098; + for (_iter1098 = this->success.begin(); _iter1098 != this->success.end(); ++_iter1098) { - xfer += (*_iter1071).write(oprot); + xfer += (*_iter1098).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 _size1072; - ::apache::thrift::protocol::TType _etype1075; - xfer += iprot->readListBegin(_etype1075, _size1072); - (*(this->success)).resize(_size1072); - uint32_t _i1076; - for (_i1076 = 0; _i1076 < _size1072; ++_i1076) + 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) { - xfer += (*(this->success))[_i1076].read(iprot); + xfer += (*(this->success))[_i1103].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 _size1077; - ::apache::thrift::protocol::TType _etype1080; - xfer += iprot->readListBegin(_etype1080, _size1077); - this->success.resize(_size1077); - uint32_t _i1081; - for (_i1081 = 0; _i1081 < _size1077; ++_i1081) + 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) { - xfer += this->success[_i1081].read(iprot); + xfer += this->success[_i1108].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 _iter1082; - for (_iter1082 = this->success.begin(); _iter1082 != this->success.end(); ++_iter1082) + std::vector<FieldSchema> ::const_iterator _iter1109; + for (_iter1109 = this->success.begin(); _iter1109 != this->success.end(); ++_iter1109) { - xfer += (*_iter1082).write(oprot); + xfer += (*_iter1109).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 _size1083; - ::apache::thrift::protocol::TType _etype1086; - xfer += iprot->readListBegin(_etype1086, _size1083); - (*(this->success)).resize(_size1083); - uint32_t _i1087; - for (_i1087 = 0; _i1087 < _size1083; ++_i1087) + 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) { - xfer += (*(this->success))[_i1087].read(iprot); + xfer += (*(this->success))[_i1114].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 _size1088; - ::apache::thrift::protocol::TType _etype1091; - xfer += iprot->readListBegin(_etype1091, _size1088); - this->success.resize(_size1088); - uint32_t _i1092; - for (_i1092 = 0; _i1092 < _size1088; ++_i1092) + uint32_t _size1115; + ::apache::thrift::protocol::TType _etype1118; + xfer += iprot->readListBegin(_etype1118, _size1115); + this->success.resize(_size1115); + uint32_t _i1119; + for (_i1119 = 0; _i1119 < _size1115; ++_i1119) { - xfer += this->success[_i1092].read(iprot); + xfer += this->success[_i1119].read(iprot); } xfer += iprot->readListEnd(); } @@ -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 _iter1093; - for (_iter1093 = this->success.begin(); _iter1093 != this->success.end(); ++_iter1093) + std::vector<FieldSchema> ::const_iterator _iter1120; + for (_iter1120 = this->success.begin(); _iter1120 != this->success.end(); ++_iter1120) { - xfer += (*_iter1093).write(oprot); + xfer += (*_iter1120).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 _size1094; - ::apache::thrift::protocol::TType _etype1097; - xfer += iprot->readListBegin(_etype1097, _size1094); - (*(this->success)).resize(_size1094); - uint32_t _i1098; - for (_i1098 = 0; _i1098 < _size1094; ++_i1098) + 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) { - xfer += (*(this->success))[_i1098].read(iprot); + xfer += (*(this->success))[_i1125].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 _size1099; - ::apache::thrift::protocol::TType _etype1102; - xfer += iprot->readListBegin(_etype1102, _size1099); - this->primaryKeys.resize(_size1099); - uint32_t _i1103; - for (_i1103 = 0; _i1103 < _size1099; ++_i1103) + uint32_t _size1126; + ::apache::thrift::protocol::TType _etype1129; + xfer += iprot->readListBegin(_etype1129, _size1126); + this->primaryKeys.resize(_size1126); + uint32_t _i1130; + for (_i1130 = 0; _i1130 < _size1126; ++_i1130) { - xfer += this->primaryKeys[_i1103].read(iprot); + xfer += this->primaryKeys[_i1130].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 _size1104; - ::apache::thrift::protocol::TType _etype1107; - xfer += iprot->readListBegin(_etype1107, _size1104); - this->foreignKeys.resize(_size1104); - uint32_t _i1108; - for (_i1108 = 0; _i1108 < _size1104; ++_i1108) + uint32_t _size1131; + ::apache::thrift::protocol::TType _etype1134; + xfer += iprot->readListBegin(_etype1134, _size1131); + this->foreignKeys.resize(_size1131); + uint32_t _i1135; + for (_i1135 = 0; _i1135 < _size1131; ++_i1135) { - xfer += this->foreignKeys[_i1108].read(iprot); + xfer += this->foreignKeys[_i1135].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 _size1109; - ::apache::thrift::protocol::TType _etype1112; - xfer += iprot->readListBegin(_etype1112, _size1109); - this->uniqueConstraints.resize(_size1109); - uint32_t _i1113; - for (_i1113 = 0; _i1113 < _size1109; ++_i1113) + uint32_t _size1136; + ::apache::thrift::protocol::TType _etype1139; + xfer += iprot->readListBegin(_etype1139, _size1136); + this->uniqueConstraints.resize(_size1136); + uint32_t _i1140; + for (_i1140 = 0; _i1140 < _size1136; ++_i1140) { - xfer += this->uniqueConstraints[_i1113].read(iprot); + xfer += this->uniqueConstraints[_i1140].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 _size1114; - ::apache::thrift::protocol::TType _etype1117; - xfer += iprot->readListBegin(_etype1117, _size1114); - this->notNullConstraints.resize(_size1114); - uint32_t _i1118; - for (_i1118 = 0; _i1118 < _size1114; ++_i1118) + uint32_t _size1141; + ::apache::thrift::protocol::TType _etype1144; + xfer += iprot->readListBegin(_etype1144, _size1141); + this->notNullConstraints.resize(_size1141); + uint32_t _i1145; + for (_i1145 = 0; _i1145 < _size1141; ++_i1145) { - xfer += this->notNullConstraints[_i1118].read(iprot); + xfer += this->notNullConstraints[_i1145].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 _iter1119; - for (_iter1119 = this->primaryKeys.begin(); _iter1119 != this->primaryKeys.end(); ++_iter1119) + std::vector<SQLPrimaryKey> ::const_iterator _iter1146; + for (_iter1146 = this->primaryKeys.begin(); _iter1146 != this->primaryKeys.end(); ++_iter1146) { - xfer += (*_iter1119).write(oprot); + xfer += (*_iter1146).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 _iter1120; - for (_iter1120 = this->foreignKeys.begin(); _iter1120 != this->foreignKeys.end(); ++_iter1120) + std::vector<SQLForeignKey> ::const_iterator _iter1147; + for (_iter1147 = this->foreignKeys.begin(); _iter1147 != this->foreignKeys.end(); ++_iter1147) { - xfer += (*_iter1120).write(oprot); + xfer += (*_iter1147).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 _iter1121; - for (_iter1121 = this->uniqueConstraints.begin(); _iter1121 != this->uniqueConstraints.end(); ++_iter1121) + std::vector<SQLUniqueConstraint> ::const_iterator _iter1148; + for (_iter1148 = this->uniqueConstraints.begin(); _iter1148 != this->uniqueConstraints.end(); ++_iter1148) { - xfer += (*_iter1121).write(oprot); + xfer += (*_iter1148).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 _iter1122; - for (_iter1122 = this->notNullConstraints.begin(); _iter1122 != this->notNullConstraints.end(); ++_iter1122) + std::vector<SQLNotNullConstraint> ::const_iterator _iter1149; + for (_iter1149 = this->notNullConstraints.begin(); _iter1149 != this->notNullConstraints.end(); ++_iter1149) { - xfer += (*_iter1122).write(oprot); + xfer += (*_iter1149).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 _iter1123; - for (_iter1123 = (*(this->primaryKeys)).begin(); _iter1123 != (*(this->primaryKeys)).end(); ++_iter1123) + std::vector<SQLPrimaryKey> ::const_iterator _iter1150; + for (_iter1150 = (*(this->primaryKeys)).begin(); _iter1150 != (*(this->primaryKeys)).end(); ++_iter1150) { - xfer += (*_iter1123).write(oprot); + xfer += (*_iter1150).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 _iter1124; - for (_iter1124 = (*(this->foreignKeys)).begin(); _iter1124 != (*(this->foreignKeys)).end(); ++_iter1124) + std::vector<SQLForeignKey> ::const_iterator _iter1151; + for (_iter1151 = (*(this->foreignKeys)).begin(); _iter1151 != (*(this->foreignKeys)).end(); ++_iter1151) { - xfer += (*_iter1124).write(oprot); + xfer += (*_iter1151).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 _iter1125; - for (_iter1125 = (*(this->uniqueConstraints)).begin(); _iter1125 != (*(this->uniqueConstraints)).end(); ++_iter1125) + std::vector<SQLUniqueConstraint> ::const_iterator _iter1152; + for (_iter1152 = (*(this->uniqueConstraints)).begin(); _iter1152 != (*(this->uniqueConstraints)).end(); ++_iter1152) { - xfer += (*_iter1125).write(oprot); + xfer += (*_iter1152).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 _iter1126; - for (_iter1126 = (*(this->notNullConstraints)).begin(); _iter1126 != (*(this->notNullConstraints)).end(); ++_iter1126) + std::vector<SQLNotNullConstraint> ::const_iterator _iter1153; + for (_iter1153 = (*(this->notNullConstraints)).begin(); _iter1153 != (*(this->notNullConstraints)).end(); ++_iter1153) { - xfer += (*_iter1126).write(oprot); + xfer += (*_iter1153).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 _size1127; - ::apache::thrift::protocol::TType _etype1130; - xfer += iprot->readListBegin(_etype1130, _size1127); - this->partNames.resize(_size1127); - uint32_t _i1131; - for (_i1131 = 0; _i1131 < _size1127; ++_i1131) + uint32_t _size1154; + ::apache::thrift::protocol::TType _etype1157; + xfer += iprot->readListBegin(_etype1157, _size1154); + this->partNames.resize(_size1154); + uint32_t _i1158; + for (_i1158 = 0; _i1158 < _size1154; ++_i1158) { - xfer += iprot->readString(this->partNames[_i1131]); + xfer += iprot->readString(this->partNames[_i1158]); } 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 _iter1132; - for (_iter1132 = this->partNames.begin(); _iter1132 != this->partNames.end(); ++_iter1132) + std::vector<std::string> ::const_iterator _iter1159; + for (_iter1159 = this->partNames.begin(); _iter1159 != this->partNames.end(); ++_iter1159) { - xfer += oprot->writeString((*_iter1132)); + xfer += oprot->writeString((*_iter1159)); } 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 _iter1133; - for (_iter1133 = (*(this->partNames)).begin(); _iter1133 != (*(this->partNames)).end(); ++_iter1133) + std::vector<std::string> ::const_iterator _iter1160; + for (_iter1160 = (*(this->partNames)).begin(); _iter1160 != (*(this->partNames)).end(); ++_iter1160) { - xfer += oprot->writeString((*_iter1133)); + xfer += oprot->writeString((*_iter1160)); } 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 _size1134; - ::apache::thrift::protocol::TType _etype1137; - xfer += iprot->readListBegin(_etype1137, _size1134); - this->success.resize(_size1134); - uint32_t _i1138; - for (_i1138 = 0; _i1138 < _size1134; ++_i1138) + 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 += iprot->readString(this->success[_i1138]); + xfer += iprot->readString(this->success[_i1165]); } 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 _iter1139; - for (_iter1139 = this->success.begin(); _iter1139 != this->success.end(); ++_iter1139) + std::vector<std::string> ::const_iterator _iter1166; + for (_iter1166 = this->success.begin(); _iter1166 != this->success.end(); ++_iter1166) { - xfer += oprot->writeString((*_iter1139)); + xfer += oprot->writeString((*_iter1166)); } 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 _size1140; - ::apache::thrift::protocol::TType _etype1143; - xfer += iprot->readListBegin(_etype1143, _size1140); - (*(this->success)).resize(_size1140); - uint32_t _i1144; - for (_i1144 = 0; _i1144 < _size1140; ++_i1144) + uint32_t _size1167; + ::apache::thrift::protocol::TType _etype1170; + xfer += iprot->readListBegin(_etype1170, _size1167); + (*(this->success)).resize(_size1167); + uint32_t _i1171; + for (_i1171 = 0; _i1171 < _size1167; ++_i1171) { - xfer += iprot->readString((*(this->success))[_i1144]); + xfer += iprot->readString((*(this->success))[_i1171]); } 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 _size1145; - ::apache::thrift::protocol::TType _etype1148; - xfer += iprot->readListBegin(_etype1148, _size1145); - this->success.resize(_size1145); - uint32_t _i1149; - for (_i1149 = 0; _i1149 < _size1145; ++_i1149) + uint32_t _size1172; + ::apache::thrift::protocol::TType _etype1175; + xfer += iprot->readListBegin(_etype1175, _size1172); + this->success.resize(_size1172); + uint32_t _i1176; + for (_i1176 = 0; _i1176 < _size1172; ++_i1176) { - xfer += iprot->readString(this->success[_i1149]); + xfer += iprot->readString(this->success[_i1176]); } 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 _iter1150; - for (_iter1150 = this->success.begin(); _iter1150 != this->success.end(); ++_iter1150) + std::vector<std::string> ::const_iterator _iter1177; + for (_iter1177 = this->success.begin(); _iter1177 != this->success.end(); ++_iter1177) { - xfer += oprot->writeString((*_iter1150)); + xfer += oprot->writeString((*_iter1177)); } 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 _size1151; - ::apache::thrift::protocol::TType _etype1154; - xfer += iprot->readListBegin(_etype1154, _size1151); - (*(this->success)).resize(_size1151); - uint32_t _i1155; - for (_i1155 = 0; _i1155 < _size1151; ++_i1155) + 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) { - xfer += iprot->readString((*(this->success))[_i1155]); + xfer += iprot->readString((*(this->success))[_i1182]); } xfer += iprot->readListEnd(); } @@ -7251,14 +7251,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 _size1156; - ::apache::thrift::protocol::TType _etype1159; - xfer += iprot->readListBegin(_etype1159, _size1156); - this->tbl_types.resize(_size1156); - uint32_t _i1160; - for (_i1160 = 0; _i1160 < _size1156; ++_i1160) + uint32_t _size1183; + ::apache::thrift::protocol::TType _etype1186; + xfer += iprot->readListBegin(_etype1186, _size1183); + this->tbl_types.resize(_size1183); + uint32_t _i1187; + for (_i1187 = 0; _i1187 < _size1183; ++_i1187) { - xfer += iprot->readString(this->tbl_types[_i1160]); + xfer += iprot->readString(this->tbl_types[_i1187]); } xfer += iprot->readListEnd(); } @@ -7295,10 +7295,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 _iter1161; - for (_iter1161 = this->tbl_types.begin(); _iter1161 != this->tbl_types.end(); ++_iter1161) + std::vector<std::string> ::const_iterator _iter1188; + for (_iter1188 = this->tbl_types.begin(); _iter1188 != this->tbl_types.end(); ++_iter1188) { - xfer += oprot->writeString((*_iter1161)); + xfer += oprot->writeString((*_iter1188)); } xfer += oprot->writeListEnd(); } @@ -7330,10 +7330,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 _iter1162; - for (_iter1162 = (*(this->tbl_types)).begin(); _iter1162 != (*(this->tbl_types)).end(); ++_iter1162) + std::vector<std::string> ::const_iterator _iter1189; + for (_iter1189 = (*(this->tbl_types)).begin(); _iter1189 != (*(this->tbl_types)).end(); ++_iter1189) { - xfer += oprot->writeString((*_iter1162)); + xfer += oprot->writeString((*_iter1189)); } xfer += oprot->writeListEnd(); } @@ -7374,14 +7374,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1163; - ::apache::thrift::protocol::TType _etype1166; - xfer += iprot->readListBegin(_etype1166, _size1163); - this->success.resize(_size1163); - uint32_t _i1167; - for (_i1167 = 0; _i1167 < _size1163; ++_i1167) + uint32_t _size1190; + ::apache::thrift::protocol::TType _etype1193; + xfer += iprot->readListBegin(_etype1193, _size1190); + this->success.resize(_size1190); + uint32_t _i1194; + for (_i1194 = 0; _i1194 < _size1190; ++_i1194) { - xfer += this->success[_i1167].read(iprot); + xfer += this->success[_i1194].read(iprot); } xfer += iprot->readListEnd(); } @@ -7420,10 +7420,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 _iter1168; - for (_iter1168 = this->success.begin(); _iter1168 != this->success.end(); ++_iter1168) + std::vector<TableMeta> ::const_iterator _iter1195; + for (_iter1195 = this->success.begin(); _iter1195 != this->success.end(); ++_iter1195) { - xfer += (*_iter1168).write(oprot); + xfer += (*_iter1195).write(oprot); } xfer += oprot->writeListEnd(); } @@ -7468,14 +7468,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1169; - ::apache::thrift::protocol::TType _etype1172; - xfer += iprot->readListBegin(_etype1172, _size1169); - (*(this->success)).resize(_size1169); - uint32_t _i1173; - for (_i1173 = 0; _i1173 < _size1169; ++_i1173) + uint32_t _size1196; + ::apache::thrift::protocol::TType _etype1199; + xfer += iprot->readListBegin(_etype1199, _size1196); + (*(this->success)).resize(_size1196); + uint32_t _i1200; + for (_i1200 = 0; _i1200 < _size1196; ++_i1200) { - xfer += (*(this->success))[_i1173].read(iprot); + xfer += (*(this->success))[_i1200].read(iprot); } xfer += iprot->readListEnd(); } @@ -7613,14 +7613,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1174; - ::apache::thrift::protocol::TType _etype1177; - xfer += iprot->readListBegin(_etype1177, _size1174); - this->success.resize(_size1174); - uint32_t _i1178; - for (_i1178 = 0; _i1178 < _size1174; ++_i1178) + uint32_t _size1201; + ::apache::thrift::protocol::TType _etype1204; + xfer += iprot->readListBegin(_etype1204, _size1201); + this->success.resize(_size1201); + uint32_t _i1205; + for (_i1205 = 0; _i1205 < _size1201; ++_i1205) { - xfer += iprot->readString(this->success[_i1178]); + xfer += iprot->readString(this->success[_i1205]); } xfer += iprot->readListEnd(); } @@ -7659,10 +7659,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 _iter1179; - for (_iter1179 = this->success.begin(); _iter1179 != this->success.end(); ++_iter1179) + std::vector<std::string> ::const_iterator _iter1206; + for (_iter1206 = this->success.begin(); _iter1206 != this->success.end(); ++_iter1206) { - xfer += oprot->writeString((*_iter1179)); + xfer += oprot->writeString((*_iter1206)); } xfer += oprot->writeListEnd(); } @@ -7707,14 +7707,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1180; - ::apache::thrift::protocol::TType _etype1183; - xfer += iprot->readListBegin(_etype1183, _size1180); - (*(this->success)).resize(_size1180); - uint32_t _i1184; - for (_i1184 = 0; _i1184 < _size1180; ++_i1184) + 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))[_i1184]); + xfer += iprot->readString((*(this->success))[_i1211]); } xfer += iprot->readListEnd(); } @@ -8024,14 +8024,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 _size1185; - ::apache::thrift::protocol::TType _etype1188; - xfer += iprot->readListBegin(_etype1188, _size1185); - this->tbl_names.resize(_size1185); - uint32_t _i1189; - for (_i1189 = 0; _i1189 < _size1185; ++_i1189) + uint32_t _size1212; + ::apache::thrift::protocol::TType _etype1215; + xfer += iprot->readListBegin(_etype1215, _size1212); + this->tbl_names.resize(_size1212); + uint32_t _i1216; + for (_i1216 = 0; _i1216 < _size1212; ++_i1216) { - xfer += iprot->readString(this->tbl_names[_i1189]); + xfer += iprot->readString(this->tbl_names[_i1216]); } xfer += iprot->readListEnd(); } @@ -8064,10 +8064,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 _iter1190; - for (_iter1190 = this->tbl_names.begin(); _iter1190 != this->tbl_names.end(); ++_iter1190) + std::vector<std::string> ::const_iterator _iter1217; + for (_iter1217 = this->tbl_names.begin(); _iter1217 != this->tbl_names.end(); ++_iter1217) { - xfer += oprot->writeString((*_iter1190)); + xfer += oprot->writeString((*_iter1217)); } xfer += oprot->writeListEnd(); } @@ -8095,10 +8095,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 _iter1191; - for (_iter1191 = (*(this->tbl_names)).begin(); _iter1191 != (*(this->tbl_names)).end(); ++_iter1191) + std::vector<std::string> ::const_iterator _iter1218; + for (_iter1218 = (*(this->tbl_names)).begin(); _iter1218 != (*(this->tbl_names)).end(); ++_iter1218) { - xfer += oprot->writeString((*_iter1191)); + xfer += oprot->writeString((*_iter1218)); } xfer += oprot->writeListEnd(); } @@ -8139,14 +8139,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 _size1192; - ::apache::thrift::protocol::TType _etype1195; - xfer += iprot->readListBegin(_etype1195, _size1192); - this->success.resize(_size1192); - uint32_t _i1196; - for (_i1196 = 0; _i1196 < _size1192; ++_i1196) + uint32_t _size1219; + ::apache::thrift::protocol::TType _etype1222; + xfer += iprot->readListBegin(_etype1222, _size1219); + this->success.resize(_size1219); + uint32_t _i1223; + for (_i1223 = 0; _i1223 < _size1219; ++_i1223) { - xfer += this->success[_i1196].read(iprot); + xfer += this->success[_i1223].read(iprot); } xfer += iprot->readListEnd(); } @@ -8177,10 +8177,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 _iter1197; - for (_iter1197 = this->success.begin(); _iter1197 != this->success.end(); ++_iter1197) + std::vector<Table> ::const_iterator _iter1224; + for (_iter1224 = this->success.begin(); _iter1224 != this->success.end(); ++_iter1224) { - xfer += (*_iter1197).write(oprot); + xfer += (*_iter1224).write(oprot); } xfer += oprot->writeListEnd(); } @@ -8221,14 +8221,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 _size1198; - ::apache::thrift::protocol::TType _etype1201; - xfer += iprot->readListBegin(_etype1201, _size1198); - (*(this->success)).resize(_size1198); - uint32_t _i1202; - for (_i1202 = 0; _i1202 < _size1198; ++_i1202) + uint32_t _size1225; + ::apache::thrift::protocol::TType _etype1228; + xfer += iprot->readListBegin(_etype1228, _size1225); + (*(this->success)).resize(_size1225); + uint32_t _i1229; + for (_i1229 = 0; _i1229 < _size1225; ++_i1229) { - xfer += (*(this->success))[_i1202].read(iprot); + xfer += (*(this->success))[_i1229].read(iprot); } xfer += iprot->readListEnd(); } @@ -8864,14 +8864,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 _size1203; - ::apache::thrift::protocol::TType _etype1206; - xfer += iprot->readListBegin(_etype1206, _size1203); - this->success.resize(_size1203); - uint32_t _i1207; - for (_i1207 = 0; _i1207 < _size1203; ++_i1207) + uint32_t _size1230; + ::apache::thrift::protocol::TType _etype1233; + xfer += iprot->readListBegin(_etype1233, _size1230); + this->success.resize(_size1230); + uint32_t _i1234; + for (_i1234 = 0; _i1234 < _size1230; ++_i1234) { - xfer += iprot->readString(this->success[_i1207]); + xfer += iprot->readString(this->success[_i1234]); } xfer += iprot->readListEnd(); } @@ -8926,10 +8926,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 _iter1208; - for (_iter1208 = this->success.begin(); _iter1208 != this->success.end(); ++_iter1208) + std::vector<std::string> ::const_iterator _iter1235; + for (_iter1235 = this->success.begin(); _iter1235 != this->success.end(); ++_iter1235) { - xfer += oprot->writeString((*_iter1208)); + xfer += oprot->writeString((*_iter1235)); } xfer += oprot->writeListEnd(); } @@ -8982,14 +8982,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 _size1209; - ::apache::thrift::protocol::TType _etype1212; - xfer += iprot->readListBegin(_etype1212, _size1209); - (*(this->success)).resize(_size1209); - uint32_t _i1213; - for (_i1213 = 0; _i1213 < _size1209; ++_i1213) + uint32_t _size1236; + ::apache::thrift::protocol::TType _etype1239; + xfer += iprot->readListBegin(_etype1239, _size1236); + (*(this->success)).resize(_size1236); + uint32_t _i1240; + for (_i1240 = 0; _i1240 < _size1236; ++_i1240) { - xfer += iprot->readString((*(this->success))[_i1213]); + xfer += iprot->readString((*(this->success))[_i1240]); } xfer += iprot->readListEnd(); } @@ -10323,14 +10323,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->new_parts.clear(); - uint32_t _size1214; - ::apache::thrift::protocol::TType _etype1217; - xfer += iprot->readListBegin(_etype1217, _size1214); - this->new_parts.resize(_size1214); - uint32_t _i1218; - for (_i1218 = 0; _i1218 < _size1214; ++_i1218) + uint32_t _size1241; + ::apache::thrift::protocol::TType _etype1244; + xfer += iprot->readListBegin(_etype1244, _size1241); + this->new_parts.resize(_size1241); + uint32_t _i1245; + for (_i1245 = 0; _i1245 < _size1241; ++_i1245) { - xfer += this->new_parts[_i1218].read(iprot); + xfer += this->new_parts[_i1245].read(iprot); } xfer += iprot->readListEnd(); } @@ -10359,10 +10359,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 _iter1219; - for (_iter1219 = this->new_parts.begin(); _iter1219 != this->new_parts.end(); ++_iter1219) + std::vector<Partition> ::const_iterator _iter1246; + for (_iter1246 = this->new_parts.begin(); _iter1246 != this->new_parts.end(); ++_iter1246) { - xfer += (*_iter1219).write(oprot); + xfer += (*_iter1246).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10386,10 +10386,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 _iter1220; - for (_iter1220 = (*(this->new_parts)).begin(); _iter1220 != (*(this->new_parts)).end(); ++_iter1220) + std::vector<Partition> ::const_iterator _iter1247; + for (_iter1247 = (*(this->new_parts)).begin(); _iter1247 != (*(this->new_parts)).end(); ++_iter1247) { - xfer += (*_iter1220).write(oprot); + xfer += (*_iter1247).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10598,14 +10598,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 _size1221; - ::apache::thrift::protocol::TType _etype1224; - xfer += iprot->readListBegin(_etype1224, _size1221); - this->new_parts.resize(_size1221); - uint32_t _i1225; - for (_i1225 = 0; _i1225 < _size1221; ++_i1225) + uint32_t _size1248; + ::apache::thrift::protocol::TType _etype1251; + xfer += iprot->readListBegin(_etype1251, _size1248); + this->new_parts.resize(_size1248); + uint32_t _i1252; + for (_i1252 = 0; _i1252 < _size1248; ++_i1252) { - xfer += this->new_parts[_i1225].read(iprot); + xfer += this->new_parts[_i1252].read(iprot); } xfer += iprot->readListEnd(); } @@ -10634,10 +10634,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 _iter1226; - for (_iter1226 = this->new_parts.begin(); _iter1226 != this->new_parts.end(); ++_iter1226) + std::vector<PartitionSpec> ::const_iterator _iter1253; + for (_iter1253 = this->new_parts.begin(); _iter1253 != this->new_parts.end(); ++_iter1253) { - xfer += (*_iter1226).write(oprot); + xfer += (*_iter1253).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10661,10 +10661,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 _iter1227; - for (_iter1227 = (*(this->new_parts)).begin(); _iter1227 != (*(this->new_parts)).end(); ++_iter1227) + std::vector<PartitionSpec> ::const_iterator _iter1254; + for (_iter1254 = (*(this->new_parts)).begin(); _iter1254 != (*(this->new_parts)).end(); ++_iter1254) { - xfer += (*_iter1227).write(oprot); + xfer += (*_iter1254).write(oprot); } xfer += oprot->writeListEnd(); } @@ -10889,14 +10889,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1228; - ::apache::thrift::protocol::TType _etype1231; - xfer += iprot->readListBegin(_etype1231, _size1228); - this->part_vals.resize(_size1228); - uint32_t _i1232; - for (_i1232 = 0; _i1232 < _size1228; ++_i1232) + uint32_t _size1255; + ::apache::thrift::protocol::TType _etype1258; + xfer += iprot->readListBegin(_etype1258, _size1255); + this->part_vals.resize(_size1255); + uint32_t _i1259; + for (_i1259 = 0; _i1259 < _size1255; ++_i1259) { - xfer += iprot->readString(this->part_vals[_i1232]); + xfer += iprot->readString(this->part_vals[_i1259]); } xfer += iprot->readListEnd(); } @@ -10933,10 +10933,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 _iter1233; - for (_iter1233 = this->part_vals.begin(); _iter1233 != this->part_vals.end(); ++_iter1233) + std::vector<std::string> ::const_iterator _iter1260; + for (_iter1260 = this->part_vals.begin(); _iter1260 != this->part_vals.end(); ++_iter1260) { - xfer += oprot->writeString((*_iter1233)); + xfer += oprot->writeString((*_iter1260)); } xfer += oprot->writeListEnd(); } @@ -10968,10 +10968,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 _iter1234; - for (_iter1234 = (*(this->part_vals)).begin(); _iter1234 != (*(this->part_vals)).end(); ++_iter1234) + std::vector<std::string> ::const_iterator _iter1261; + for (_iter1261 = (*(this->part_vals)).begin(); _iter1261 != (*(this->part_vals)).end(); ++_iter1261) { - xfer += oprot->writeString((*_iter1234)); + xfer += oprot->writeString((*_iter1261)); } xfer += oprot->writeListEnd(); } @@ -11443,14 +11443,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1235; - ::apache::thrift::protocol::TType _etype1238; - xfer += iprot->readListBegin(_etype1238, _size1235); - this->part_vals.resize(_size1235); - uint32_t _i1239; - for (_i1239 = 0; _i1239 < _size1235; ++_i1239) + uint32_t _size1262; + ::apache::thrift::protocol::TType _etype1265; + xfer += iprot->readListBegin(_etype1265, _size1262); + this->part_vals.resize(_size1262); + uint32_t _i1266; + for (_i1266 = 0; _i1266 < _size1262; ++_i1266) { - xfer += iprot->readString(this->part_vals[_i1239]); + xfer += iprot->readString(this->part_vals[_i1266]); } xfer += iprot->readListEnd(); } @@ -11495,10 +11495,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 _iter1240; - for (_iter1240 = this->part_vals.begin(); _iter1240 != this->part_vals.end(); ++_iter1240) + std::vector<std::string> ::const_iterator _iter1267; + for (_iter1267 = this->part_vals.begin(); _iter1267 != this->part_vals.end(); ++_iter1267) { - xfer += oprot->writeString((*_iter1240)); + xfer += oprot->writeString((*_iter1267)); } xfer += oprot->writeListEnd(); } @@ -11534,10 +11534,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 _iter1241; - for (_iter1241 = (*(this->part_vals)).begin(); _iter1241 != (*(this->part_vals)).end(); ++_iter1241) + std::vector<std::string> ::const_iterator _iter1268; + for (_iter1268 = (*(this->part_vals)).begin(); _iter1268 != (*(this->part_vals)).end(); ++_iter1268) { - xfer += oprot->writeString((*_iter1241)); + xfer += oprot->writeString((*_iter1268)); } xfer += oprot->writeListEnd(); } @@ -12340,14 +12340,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1242; - ::apache::thrift::protocol::TType _etype1245; - xfer += iprot->readListBegin(_etype1245, _size1242); - this->part_vals.resize(_size1242); - uint32_t _i1246; - for (_i1246 = 0; _i1246 < _size1242; ++_i1246) + uint32_t _size1269; + ::apache::thrift::protocol::TType _etype1272; + xfer += iprot->readListBegin(_etype1272, _size1269); + this->part_vals.resize(_size1269); + uint32_t _i1273; + for (_i1273 = 0; _i1273 < _size1269; ++_i1273) { - xfer += iprot->readString(this->part_vals[_i1246]); + xfer += iprot->readString(this->part_vals[_i1273]); } xfer += iprot->readListEnd(); } @@ -12392,10 +12392,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 _iter1247; - for (_iter1247 = this->part_vals.begin(); _iter1247 != this->part_vals.end(); ++_iter1247) + std::vector<std::string> ::const_iterator _iter1274; + for (_iter1274 = this->part_vals.begin(); _iter1274 != this->part_vals.end(); ++_iter1274) { - xfer += oprot->writeString((*_iter1247)); + xfer += oprot->writeString((*_iter1274)); } xfer += oprot->writeListEnd(); } @@ -12431,10 +12431,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 _iter1248; - for (_iter1248 = (*(this->part_vals)).begin(); _iter1248 != (*(this->part_vals)).end(); ++_iter1248) + std::vector<std::string> ::const_iterator _iter1275; + for (_iter1275 = (*(this->part_vals)).begin(); _iter1275 != (*(this->part_vals)).end(); ++_iter1275) { - xfer += oprot->writeString((*_iter1248)); + xfer += oprot->writeString((*_iter1275)); } xfer += oprot->writeListEnd(); } @@ -12643,14 +12643,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read( if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1249; - ::apache::thrift::protocol::TType _etype1252; - xfer += iprot->readListBegin(_etype1252, _size1249); - this->part_vals.resize(_size1249); - uint32_t _i1253; - for (_i1253 = 0; _i1253 < _size1249; ++_i1253) + uint32_t _size1276; + ::apache::thrift::protocol::TType _etype1279; + xfer += iprot->readListBegin(_etype1279, _size1276); + this->part_vals.resize(_size1276); + uint32_t _i1280; + for (_i1280 = 0; _i1280 < _size1276; ++_i1280) { - xfer += iprot->readString(this->part_vals[_i1253]); + xfer += iprot->readString(this->part_vals[_i1280]); } xfer += iprot->readListEnd(); } @@ -12703,10 +12703,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 _iter1254; - for (_iter1254 = this->part_vals.begin(); _iter1254 != this->part_vals.end(); ++_iter1254) + std::vector<std::string> ::const_iterator _iter1281; + for (_iter1281 = this->part_vals.begin(); _iter1281 != this->part_vals.end(); ++_iter1281) { - xfer += oprot->writeString((*_iter1254)); + xfer += oprot->writeString((*_iter1281)); } xfer += oprot->writeListEnd(); } @@ -12746,10 +12746,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 _iter1255; - for (_iter1255 = (*(this->part_vals)).begin(); _iter1255 != (*(this->part_vals)).end(); ++_iter1255) + std::vector<std::string> ::const_iterator _iter1282; + for (_iter1282 = (*(this->part_vals)).begin(); _iter1282 != (*(this->part_vals)).end(); ++_iter1282) { - xfer += oprot->writeString((*_iter1255)); + xfer += oprot->writeString((*_iter1282)); } xfer += oprot->writeListEnd(); } @@ -13755,14 +13755,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1256; - ::apache::thrift::protocol::TType _etype1259; - xfer += iprot->readListBegin(_etype1259, _size1256); - this->part_vals.resize(_size1256); - uint32_t _i1260; - for (_i1260 = 0; _i1260 < _size1256; ++_i1260) + uint32_t _size1283; + ::apache::thrift::protocol::TType _etype1286; + xfer += iprot->readListBegin(_etype1286, _size1283); + this->part_vals.resize(_size1283); + uint32_t _i1287; + for (_i1287 = 0; _i1287 < _size1283; ++_i1287) { - xfer += iprot->readString(this->part_vals[_i1260]); + xfer += iprot->readString(this->part_vals[_i1287]); } xfer += iprot->readListEnd(); } @@ -13799,10 +13799,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 _iter1261; - for (_iter1261 = this->part_vals.begin(); _iter1261 != this->part_vals.end(); ++_iter1261) + std::vector<std::string> ::const_iterator _iter1288; + for (_iter1288 = this->part_vals.begin(); _iter1288 != this->part_vals.end(); ++_iter1288) { - xfer += oprot->writeString((*_iter1261)); + xfer += oprot->writeString((*_iter1288)); } xfer += oprot->writeListEnd(); } @@ -13834,10 +13834,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 _iter1262; - for (_iter1262 = (*(this->part_vals)).begin(); _iter1262 != (*(this->part_vals)).end(); ++_iter1262) + std::vector<std::string> ::const_iterator _iter1289; + for (_iter1289 = (*(this->part_vals)).begin(); _iter1289 != (*(this->part_vals)).end(); ++_iter1289) { - xfer += oprot->writeString((*_iter1262)); + xfer += oprot->writeString((*_iter1289)); } xfer += oprot->writeListEnd(); } @@ -14026,17 +14026,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1263; - ::apache::thrift::protocol::TType _ktype1264; - ::apache::thrift::protocol::TType _vtype1265; - xfer += iprot->readMapBegin(_ktype1264, _vtype1265, _size1263); - uint32_t _i1267; - for (_i1267 = 0; _i1267 < _size1263; ++_i1267) + uint32_t _size1290; + ::apache::thrift::protocol::TType _ktype1291; + ::apache::thrift::protocol::TType _vtype1292; + xfer += iprot->readMapBegin(_ktype1291, _vtype1292, _size1290); + uint32_t _i1294; + for (_i1294 = 0; _i1294 < _size1290; ++_i1294) { - std::string _key1268; - xfer += iprot->readString(_key1268); - std::string& _val1269 = this->partitionSpecs[_key1268]; - xfer += iprot->readString(_val1269); + std::string _key1295; + xfer += iprot->readString(_key1295); + std::string& _val1296 = this->partitionSpecs[_key1295]; + xfer += iprot->readString(_val1296); } xfer += iprot->readMapEnd(); } @@ -14097,11 +14097,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 _iter1270; - for (_iter1270 = this->partitionSpecs.begin(); _iter1270 != this->partitionSpecs.end(); ++_iter1270) + std::map<std::string, std::string> ::const_iterator _iter1297; + for (_iter1297 = this->partitionSpecs.begin(); _iter1297 != this->partitionSpecs.end(); ++_iter1297) { - xfer += oprot->writeString(_iter1270->first); - xfer += oprot->writeString(_iter1270->second); + xfer += oprot->writeString(_iter1297->first); + xfer += oprot->writeString(_iter1297->second); } xfer += oprot->writeMapEnd(); } @@ -14141,11 +14141,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 _iter1271; - for (_iter1271 = (*(this->partitionSpecs)).begin(); _iter1271 != (*(this->partitionSpecs)).end(); ++_iter1271) + std::map<std::string, std::string> ::const_iterator _iter1298; + for (_iter1298 = (*(this->partitionSpecs)).begin(); _iter1298 != (*(this->partitionSpecs)).end(); ++_iter1298) { - xfer += oprot->writeString(_iter1271->first); - xfer += oprot->writeString(_iter1271->second); + xfer += oprot->writeString(_iter1298->first); + xfer += oprot->writeString(_iter1298->second); } xfer += oprot->writeMapEnd(); } @@ -14390,17 +14390,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr if (ftype == ::apache::thrift::protocol::T_MAP) { { this->partitionSpecs.clear(); - uint32_t _size1272; - ::apache::thrift::protocol::TType _ktype1273; - ::apache::thrift::protocol::TType _vtype1274; - xfer += iprot->readMapBegin(_ktype1273, _vtype1274, _size1272); - uint32_t _i1276; - for (_i1276 = 0; _i1276 < _size1272; ++_i1276) + uint32_t _size1299; + ::apache::thrift::protocol::TType _ktype1300; + ::apache::thrift::protocol::TType _vtype1301; + xfer += iprot->readMapBegin(_ktype1300, _vtype1301, _size1299); + uint32_t _i1303; + for (_i1303 = 0; _i1303 < _size1299; ++_i1303) { - std::string _key1277; - xfer += iprot->readString(_key1277); - std::string& _val1278 = this->partitionSpecs[_key1277]; - xfer += iprot->readString(_val1278); + std::string _key1304; + xfer += iprot->readString(_key1304); + std::string& _val1305 = this->partitionSpecs[_key1304]; + xfer += iprot->readString(_val1305); } xfer += iprot->readMapEnd(); } @@ -14461,11 +14461,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 _iter1279; - for (_iter1279 = this->partitionSpecs.begin(); _iter1279 != this->partitionSpecs.end(); ++_iter1279) + std::map<std::string, std::string> ::const_iterator _iter1306; + for (_iter1306 = this->partitionSpecs.begin(); _iter1306 != this->partitionSpecs.end(); ++_iter1306) { - xfer += oprot->writeString(_iter1279->first); - xfer += oprot->writeString(_iter1279->second); + xfer += oprot->writeString(_iter1306->first); + xfer += oprot->writeString(_iter1306->second); } xfer += oprot->writeMapEnd(); } @@ -14505,11 +14505,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_pargs::write(::apache::thrift:: 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 _iter1280; - for (_iter1280 = (*(this->partitionSpecs)).begin(); _iter1280 != (*(this->partitionSpecs)).end(); ++_iter1280) + std::map<std::string, std::string> ::const_iterator _iter1307; + for (_iter1307 = (*(this->partitionSpecs)).begin(); _iter1307 != (*(this->partitionSpecs)).end(); ++_iter1307) { - xfer += oprot->writeString(_iter1280->first); - xfer += oprot->writeString(_iter1280->second); + xfer += oprot->writeString(_iter1307->first); + xfer += oprot->writeString(_iter1307->second); } xfer += oprot->writeMapEnd(); } @@ -14566,14 +14566,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift:: if (ftype == ::apache::thrift::protocol::T_LIST) { { this->success.clear(); - uint32_t _size1281; - ::apache::thrift::protocol::TType _etype1284; - xfer += iprot->readListBegin(_etype1284, _size1281); - this->success.resize(_size1281); - uint32_t _i1285; - for (_i1285 = 0; _i1285 < _size1281; ++_i1285) + uint32_t _size1308; + ::apache::thrift::protocol::TType _etype1311; + xfer += iprot->readListBegin(_etype1311, _size1308); + this->success.resize(_size1308); + uint32_t _i1312; + for (_i1312 = 0; _i1312 < _size1308; ++_i1312) { - xfer += this->success[_i1285].read(iprot); + xfer += this->success[_i1312].read(iprot); } xfer += iprot->readListEnd(); } @@ -14636,10 +14636,10 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::write(::apache::thrift: 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<Partition> ::const_iterator _iter1286; - for (_iter1286 = this->success.begin(); _iter1286 != this->success.end(); ++_iter1286) + std::vector<Partition> ::const_iterator _iter1313; + for (_iter1313 = this->success.begin(); _iter1313 != this->success.end(); ++_iter1313) { - xfer += (*_iter1286).write(oprot); + xfer += (*_iter1313).write(oprot); } xfer += oprot->writeListEnd(); } @@ -14696,14 +14696,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift: if (ftype == ::apache::thrift::protocol::T_LIST) { { (*(this->success)).clear(); - uint32_t _size1287; - ::apache::thrift::protocol::TType _etype1290; - xfer += iprot->readListBegin(_etype1290, _size1287); - (*(this->success)).resize(_size1287); - uint32_t _i1291; - for (_i1291 = 0; _i1291 < _size1287; ++_i1291) + uint32_t _size1314; + ::apache::thrift::protocol::TType _etype1317; + xfer += iprot->readListBegin(_etype1317, _size1314); + (*(this->success)).resize(_size1314); + uint32_t _i1318; + for (_i1318 = 0; _i1318 < _size1314; ++_i1318) { - xfer += (*(this->success))[_i1291].read(iprot); + xfer += (*(this->success))[_i1318].read(iprot); } xfer += iprot->readListEnd(); } @@ -14802,14 +14802,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->part_vals.clear(); - uint32_t _size1292; - ::apache::thrift::protocol::TType _etype1295; - xfer += iprot->readListBegin(_etype1295, _size1292); - this->part_vals.resize(_size1292); - uint32_t _i1296; - for (_i1296 = 0; _i1296 < _size1292; ++_i1296) + uint32_t _size1319; + ::apache::thrift::protocol::TType _etype1322; + xfer += iprot->readListBegin(_etype1322, _size1319); + this->part_vals.resize(_size1319); + uint32_t _i1323; + for (_i1323 = 0; _i1323 < _size1319; ++_i1323) { - xfer += iprot->readString(this->part_vals[_i1296]); + xfer += iprot->readString(this->part_vals[_i1323]); } xfer += iprot->readListEnd(); } @@ -14830,14 +14830,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift if (ftype == ::apache::thrift::protocol::T_LIST) { { this->group_names.clear(); - uint32_t _size1297; - ::apache::thrift::protocol::TType _etype1300; - xfer += iprot->readListBegin(_etype1300, _size1297); - this->group_names.resize(_size1297); - uint32_t _i1301; - for (_i1301 = 0; _i1301 < _size1297; ++_i1301) + uint32_t _size1324; + ::apache::thrift::protocol::TType _etype1327; + xfer += iprot->readListBegin(_etype1327, _size1324); + this->group_names.resize(_size1324); + uint32_t _i1328; + for (_i1328 = 0; _i1328 < _size1324; ++_i1328) { - xfer += iprot->readString(this->group_names[_i1301]); + xfer += iprot->readString(this->group_names[_i1328]); } xfer += iprot->readListEnd(); } @@ -14874,10 +14874,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif 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 _iter1302; - for (_iter1302 = this->part_vals.begin(); _iter1302 != this->part_vals.end(); ++_iter1302) + std::vector<std::string> ::const_iterator _iter1329; + for (_iter1329 = this->part_vals.begin(); _iter1329 != this->part_vals.end(); ++_iter1329) { - xfer += oprot->writeString((*_iter1302)); + xfer += oprot->writeString((*_iter1329)); } xfer += oprot->writeListEnd(); } @@ -14890,10 +14890,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->group_names.size())); - std::vector<std::string> ::const_iterator _iter1303; - for (_iter1303 = this->group_names.begin(); _iter1303 != this->group_names.end(); ++_iter1303) + std::vector<std::string> ::const_iterator _iter1330; + for (_iter1330 = this->group_names.begin(); _iter1330 != this->group_names.end(); ++_iter1330) { - xfer += oprot->writeString((*_iter1303)); + xfer += oprot->writeString((*_iter1330)); } xfer += oprot->writeListEnd(); } @@ -14925,10 +14925,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size())); - std::vector<std::string> ::const_iterator _iter1304; - for (_iter1304 = (*(this->part_vals)).begin(); _iter1304 != (*(this->part_vals)).end(); ++_iter1304) + std::vector<std::string> ::const_iterator _iter1331; + for (_iter1331 = (*(this->part_vals)).begin(); _iter1331 != (*(this->part_vals)).end(); ++_iter1331) { - xfer += oprot->writeString((*_iter1304)); + xfer += oprot->writeString((*_iter1331)); } xfer += oprot->writeListEnd(); } @@ -14941,10 +14941,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5); { xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->group_names)).size())); - std::vector<std::string> ::const_iterator _iter1305; - for (_iter1305 = (*(this->group_names)).begin(); _iter1305 != (*(this->group_names)).end(); ++_iter1305) + std::vector<std::string> ::const_iterator _iter1332; + for (_iter1332 = (*(this->group_names)).begin(); _iter1332 != (*(this->gro
<TRUNCATED>
