You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by ga...@apache.org on 2018/03/12 23:55:57 UTC
[17/18] hive git commit: HIVE-17990 Add Thrift and DB storage for
Schema Registry objects (Alan Gates, reviewed by Thejas Nair)
http://git-wip-us.apache.org/repos/asf/hive/blob/12041d39/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 32a7086..b7a3b92 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 _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 _size1137;
+ ::apache::thrift::protocol::TType _etype1140;
+ xfer += iprot->readListBegin(_etype1140, _size1137);
+ this->success.resize(_size1137);
+ uint32_t _i1141;
+ for (_i1141 = 0; _i1141 < _size1137; ++_i1141)
{
- xfer += iprot->readString(this->success[_i1103]);
+ xfer += iprot->readString(this->success[_i1141]);
}
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 _iter1104;
- for (_iter1104 = this->success.begin(); _iter1104 != this->success.end(); ++_iter1104)
+ std::vector<std::string> ::const_iterator _iter1142;
+ for (_iter1142 = this->success.begin(); _iter1142 != this->success.end(); ++_iter1142)
{
- xfer += oprot->writeString((*_iter1104));
+ xfer += oprot->writeString((*_iter1142));
}
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 _size1105;
- ::apache::thrift::protocol::TType _etype1108;
- xfer += iprot->readListBegin(_etype1108, _size1105);
- (*(this->success)).resize(_size1105);
- uint32_t _i1109;
- for (_i1109 = 0; _i1109 < _size1105; ++_i1109)
+ uint32_t _size1143;
+ ::apache::thrift::protocol::TType _etype1146;
+ xfer += iprot->readListBegin(_etype1146, _size1143);
+ (*(this->success)).resize(_size1143);
+ uint32_t _i1147;
+ for (_i1147 = 0; _i1147 < _size1143; ++_i1147)
{
- xfer += iprot->readString((*(this->success))[_i1109]);
+ xfer += iprot->readString((*(this->success))[_i1147]);
}
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 _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 _size1148;
+ ::apache::thrift::protocol::TType _etype1151;
+ xfer += iprot->readListBegin(_etype1151, _size1148);
+ this->success.resize(_size1148);
+ uint32_t _i1152;
+ for (_i1152 = 0; _i1152 < _size1148; ++_i1152)
{
- xfer += iprot->readString(this->success[_i1114]);
+ xfer += iprot->readString(this->success[_i1152]);
}
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 _iter1115;
- for (_iter1115 = this->success.begin(); _iter1115 != this->success.end(); ++_iter1115)
+ std::vector<std::string> ::const_iterator _iter1153;
+ for (_iter1153 = this->success.begin(); _iter1153 != this->success.end(); ++_iter1153)
{
- xfer += oprot->writeString((*_iter1115));
+ xfer += oprot->writeString((*_iter1153));
}
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 _size1116;
- ::apache::thrift::protocol::TType _etype1119;
- xfer += iprot->readListBegin(_etype1119, _size1116);
- (*(this->success)).resize(_size1116);
- uint32_t _i1120;
- for (_i1120 = 0; _i1120 < _size1116; ++_i1120)
+ uint32_t _size1154;
+ ::apache::thrift::protocol::TType _etype1157;
+ xfer += iprot->readListBegin(_etype1157, _size1154);
+ (*(this->success)).resize(_size1154);
+ uint32_t _i1158;
+ for (_i1158 = 0; _i1158 < _size1154; ++_i1158)
{
- xfer += iprot->readString((*(this->success))[_i1120]);
+ xfer += iprot->readString((*(this->success))[_i1158]);
}
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 _size1121;
- ::apache::thrift::protocol::TType _ktype1122;
- ::apache::thrift::protocol::TType _vtype1123;
- xfer += iprot->readMapBegin(_ktype1122, _vtype1123, _size1121);
- uint32_t _i1125;
- for (_i1125 = 0; _i1125 < _size1121; ++_i1125)
+ uint32_t _size1159;
+ ::apache::thrift::protocol::TType _ktype1160;
+ ::apache::thrift::protocol::TType _vtype1161;
+ xfer += iprot->readMapBegin(_ktype1160, _vtype1161, _size1159);
+ uint32_t _i1163;
+ for (_i1163 = 0; _i1163 < _size1159; ++_i1163)
{
- std::string _key1126;
- xfer += iprot->readString(_key1126);
- Type& _val1127 = this->success[_key1126];
- xfer += _val1127.read(iprot);
+ std::string _key1164;
+ xfer += iprot->readString(_key1164);
+ Type& _val1165 = this->success[_key1164];
+ xfer += _val1165.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 _iter1128;
- for (_iter1128 = this->success.begin(); _iter1128 != this->success.end(); ++_iter1128)
+ std::map<std::string, Type> ::const_iterator _iter1166;
+ for (_iter1166 = this->success.begin(); _iter1166 != this->success.end(); ++_iter1166)
{
- xfer += oprot->writeString(_iter1128->first);
- xfer += _iter1128->second.write(oprot);
+ xfer += oprot->writeString(_iter1166->first);
+ xfer += _iter1166->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 _size1129;
- ::apache::thrift::protocol::TType _ktype1130;
- ::apache::thrift::protocol::TType _vtype1131;
- xfer += iprot->readMapBegin(_ktype1130, _vtype1131, _size1129);
- uint32_t _i1133;
- for (_i1133 = 0; _i1133 < _size1129; ++_i1133)
+ uint32_t _size1167;
+ ::apache::thrift::protocol::TType _ktype1168;
+ ::apache::thrift::protocol::TType _vtype1169;
+ xfer += iprot->readMapBegin(_ktype1168, _vtype1169, _size1167);
+ uint32_t _i1171;
+ for (_i1171 = 0; _i1171 < _size1167; ++_i1171)
{
- std::string _key1134;
- xfer += iprot->readString(_key1134);
- Type& _val1135 = (*(this->success))[_key1134];
- xfer += _val1135.read(iprot);
+ std::string _key1172;
+ xfer += iprot->readString(_key1172);
+ Type& _val1173 = (*(this->success))[_key1172];
+ xfer += _val1173.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 _size1136;
- ::apache::thrift::protocol::TType _etype1139;
- xfer += iprot->readListBegin(_etype1139, _size1136);
- this->success.resize(_size1136);
- uint32_t _i1140;
- for (_i1140 = 0; _i1140 < _size1136; ++_i1140)
+ 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)
{
- xfer += this->success[_i1140].read(iprot);
+ xfer += this->success[_i1178].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 _iter1141;
- for (_iter1141 = this->success.begin(); _iter1141 != this->success.end(); ++_iter1141)
+ std::vector<FieldSchema> ::const_iterator _iter1179;
+ for (_iter1179 = this->success.begin(); _iter1179 != this->success.end(); ++_iter1179)
{
- xfer += (*_iter1141).write(oprot);
+ xfer += (*_iter1179).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 _size1142;
- ::apache::thrift::protocol::TType _etype1145;
- xfer += iprot->readListBegin(_etype1145, _size1142);
- (*(this->success)).resize(_size1142);
- uint32_t _i1146;
- for (_i1146 = 0; _i1146 < _size1142; ++_i1146)
+ 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)
{
- xfer += (*(this->success))[_i1146].read(iprot);
+ xfer += (*(this->success))[_i1184].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 _size1147;
- ::apache::thrift::protocol::TType _etype1150;
- xfer += iprot->readListBegin(_etype1150, _size1147);
- this->success.resize(_size1147);
- uint32_t _i1151;
- for (_i1151 = 0; _i1151 < _size1147; ++_i1151)
+ uint32_t _size1185;
+ ::apache::thrift::protocol::TType _etype1188;
+ xfer += iprot->readListBegin(_etype1188, _size1185);
+ this->success.resize(_size1185);
+ uint32_t _i1189;
+ for (_i1189 = 0; _i1189 < _size1185; ++_i1189)
{
- xfer += this->success[_i1151].read(iprot);
+ xfer += this->success[_i1189].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 _iter1152;
- for (_iter1152 = this->success.begin(); _iter1152 != this->success.end(); ++_iter1152)
+ std::vector<FieldSchema> ::const_iterator _iter1190;
+ for (_iter1190 = this->success.begin(); _iter1190 != this->success.end(); ++_iter1190)
{
- xfer += (*_iter1152).write(oprot);
+ xfer += (*_iter1190).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 _size1153;
- ::apache::thrift::protocol::TType _etype1156;
- xfer += iprot->readListBegin(_etype1156, _size1153);
- (*(this->success)).resize(_size1153);
- uint32_t _i1157;
- for (_i1157 = 0; _i1157 < _size1153; ++_i1157)
+ uint32_t _size1191;
+ ::apache::thrift::protocol::TType _etype1194;
+ xfer += iprot->readListBegin(_etype1194, _size1191);
+ (*(this->success)).resize(_size1191);
+ uint32_t _i1195;
+ for (_i1195 = 0; _i1195 < _size1191; ++_i1195)
{
- xfer += (*(this->success))[_i1157].read(iprot);
+ xfer += (*(this->success))[_i1195].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 _size1158;
- ::apache::thrift::protocol::TType _etype1161;
- xfer += iprot->readListBegin(_etype1161, _size1158);
- this->success.resize(_size1158);
- uint32_t _i1162;
- for (_i1162 = 0; _i1162 < _size1158; ++_i1162)
+ 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[_i1162].read(iprot);
+ xfer += this->success[_i1200].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 _iter1163;
- for (_iter1163 = this->success.begin(); _iter1163 != this->success.end(); ++_iter1163)
+ std::vector<FieldSchema> ::const_iterator _iter1201;
+ for (_iter1201 = this->success.begin(); _iter1201 != this->success.end(); ++_iter1201)
{
- xfer += (*_iter1163).write(oprot);
+ xfer += (*_iter1201).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 _size1164;
- ::apache::thrift::protocol::TType _etype1167;
- xfer += iprot->readListBegin(_etype1167, _size1164);
- (*(this->success)).resize(_size1164);
- uint32_t _i1168;
- for (_i1168 = 0; _i1168 < _size1164; ++_i1168)
+ uint32_t _size1202;
+ ::apache::thrift::protocol::TType _etype1205;
+ xfer += iprot->readListBegin(_etype1205, _size1202);
+ (*(this->success)).resize(_size1202);
+ uint32_t _i1206;
+ for (_i1206 = 0; _i1206 < _size1202; ++_i1206)
{
- xfer += (*(this->success))[_i1168].read(iprot);
+ xfer += (*(this->success))[_i1206].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 _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 _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 += this->success[_i1173].read(iprot);
+ xfer += this->success[_i1211].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 _iter1174;
- for (_iter1174 = this->success.begin(); _iter1174 != this->success.end(); ++_iter1174)
+ std::vector<FieldSchema> ::const_iterator _iter1212;
+ for (_iter1212 = this->success.begin(); _iter1212 != this->success.end(); ++_iter1212)
{
- xfer += (*_iter1174).write(oprot);
+ xfer += (*_iter1212).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 _size1175;
- ::apache::thrift::protocol::TType _etype1178;
- xfer += iprot->readListBegin(_etype1178, _size1175);
- (*(this->success)).resize(_size1175);
- uint32_t _i1179;
- for (_i1179 = 0; _i1179 < _size1175; ++_i1179)
+ uint32_t _size1213;
+ ::apache::thrift::protocol::TType _etype1216;
+ xfer += iprot->readListBegin(_etype1216, _size1213);
+ (*(this->success)).resize(_size1213);
+ uint32_t _i1217;
+ for (_i1217 = 0; _i1217 < _size1213; ++_i1217)
{
- xfer += (*(this->success))[_i1179].read(iprot);
+ xfer += (*(this->success))[_i1217].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 _size1180;
- ::apache::thrift::protocol::TType _etype1183;
- xfer += iprot->readListBegin(_etype1183, _size1180);
- this->primaryKeys.resize(_size1180);
- uint32_t _i1184;
- for (_i1184 = 0; _i1184 < _size1180; ++_i1184)
+ uint32_t _size1218;
+ ::apache::thrift::protocol::TType _etype1221;
+ xfer += iprot->readListBegin(_etype1221, _size1218);
+ this->primaryKeys.resize(_size1218);
+ uint32_t _i1222;
+ for (_i1222 = 0; _i1222 < _size1218; ++_i1222)
{
- xfer += this->primaryKeys[_i1184].read(iprot);
+ xfer += this->primaryKeys[_i1222].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 _size1185;
- ::apache::thrift::protocol::TType _etype1188;
- xfer += iprot->readListBegin(_etype1188, _size1185);
- this->foreignKeys.resize(_size1185);
- uint32_t _i1189;
- for (_i1189 = 0; _i1189 < _size1185; ++_i1189)
+ uint32_t _size1223;
+ ::apache::thrift::protocol::TType _etype1226;
+ xfer += iprot->readListBegin(_etype1226, _size1223);
+ this->foreignKeys.resize(_size1223);
+ uint32_t _i1227;
+ for (_i1227 = 0; _i1227 < _size1223; ++_i1227)
{
- xfer += this->foreignKeys[_i1189].read(iprot);
+ xfer += this->foreignKeys[_i1227].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 _size1190;
- ::apache::thrift::protocol::TType _etype1193;
- xfer += iprot->readListBegin(_etype1193, _size1190);
- this->uniqueConstraints.resize(_size1190);
- uint32_t _i1194;
- for (_i1194 = 0; _i1194 < _size1190; ++_i1194)
+ uint32_t _size1228;
+ ::apache::thrift::protocol::TType _etype1231;
+ xfer += iprot->readListBegin(_etype1231, _size1228);
+ this->uniqueConstraints.resize(_size1228);
+ uint32_t _i1232;
+ for (_i1232 = 0; _i1232 < _size1228; ++_i1232)
{
- xfer += this->uniqueConstraints[_i1194].read(iprot);
+ xfer += this->uniqueConstraints[_i1232].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 _size1195;
- ::apache::thrift::protocol::TType _etype1198;
- xfer += iprot->readListBegin(_etype1198, _size1195);
- this->notNullConstraints.resize(_size1195);
- uint32_t _i1199;
- for (_i1199 = 0; _i1199 < _size1195; ++_i1199)
+ uint32_t _size1233;
+ ::apache::thrift::protocol::TType _etype1236;
+ xfer += iprot->readListBegin(_etype1236, _size1233);
+ this->notNullConstraints.resize(_size1233);
+ uint32_t _i1237;
+ for (_i1237 = 0; _i1237 < _size1233; ++_i1237)
{
- xfer += this->notNullConstraints[_i1199].read(iprot);
+ xfer += this->notNullConstraints[_i1237].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4598,14 +4598,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->defaultConstraints.clear();
- uint32_t _size1200;
- ::apache::thrift::protocol::TType _etype1203;
- xfer += iprot->readListBegin(_etype1203, _size1200);
- this->defaultConstraints.resize(_size1200);
- uint32_t _i1204;
- for (_i1204 = 0; _i1204 < _size1200; ++_i1204)
+ uint32_t _size1238;
+ ::apache::thrift::protocol::TType _etype1241;
+ xfer += iprot->readListBegin(_etype1241, _size1238);
+ this->defaultConstraints.resize(_size1238);
+ uint32_t _i1242;
+ for (_i1242 = 0; _i1242 < _size1238; ++_i1242)
{
- xfer += this->defaultConstraints[_i1204].read(iprot);
+ xfer += this->defaultConstraints[_i1242].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4638,10 +4638,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 _iter1205;
- for (_iter1205 = this->primaryKeys.begin(); _iter1205 != this->primaryKeys.end(); ++_iter1205)
+ std::vector<SQLPrimaryKey> ::const_iterator _iter1243;
+ for (_iter1243 = this->primaryKeys.begin(); _iter1243 != this->primaryKeys.end(); ++_iter1243)
{
- xfer += (*_iter1205).write(oprot);
+ xfer += (*_iter1243).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4650,10 +4650,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 _iter1206;
- for (_iter1206 = this->foreignKeys.begin(); _iter1206 != this->foreignKeys.end(); ++_iter1206)
+ std::vector<SQLForeignKey> ::const_iterator _iter1244;
+ for (_iter1244 = this->foreignKeys.begin(); _iter1244 != this->foreignKeys.end(); ++_iter1244)
{
- xfer += (*_iter1206).write(oprot);
+ xfer += (*_iter1244).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4662,10 +4662,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 _iter1207;
- for (_iter1207 = this->uniqueConstraints.begin(); _iter1207 != this->uniqueConstraints.end(); ++_iter1207)
+ std::vector<SQLUniqueConstraint> ::const_iterator _iter1245;
+ for (_iter1245 = this->uniqueConstraints.begin(); _iter1245 != this->uniqueConstraints.end(); ++_iter1245)
{
- xfer += (*_iter1207).write(oprot);
+ xfer += (*_iter1245).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4674,10 +4674,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 _iter1208;
- for (_iter1208 = this->notNullConstraints.begin(); _iter1208 != this->notNullConstraints.end(); ++_iter1208)
+ std::vector<SQLNotNullConstraint> ::const_iterator _iter1246;
+ for (_iter1246 = this->notNullConstraints.begin(); _iter1246 != this->notNullConstraints.end(); ++_iter1246)
{
- xfer += (*_iter1208).write(oprot);
+ xfer += (*_iter1246).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4686,10 +4686,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache:
xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 6);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->defaultConstraints.size()));
- std::vector<SQLDefaultConstraint> ::const_iterator _iter1209;
- for (_iter1209 = this->defaultConstraints.begin(); _iter1209 != this->defaultConstraints.end(); ++_iter1209)
+ std::vector<SQLDefaultConstraint> ::const_iterator _iter1247;
+ for (_iter1247 = this->defaultConstraints.begin(); _iter1247 != this->defaultConstraints.end(); ++_iter1247)
{
- xfer += (*_iter1209).write(oprot);
+ xfer += (*_iter1247).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4717,10 +4717,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 _iter1210;
- for (_iter1210 = (*(this->primaryKeys)).begin(); _iter1210 != (*(this->primaryKeys)).end(); ++_iter1210)
+ std::vector<SQLPrimaryKey> ::const_iterator _iter1248;
+ for (_iter1248 = (*(this->primaryKeys)).begin(); _iter1248 != (*(this->primaryKeys)).end(); ++_iter1248)
{
- xfer += (*_iter1210).write(oprot);
+ xfer += (*_iter1248).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4729,10 +4729,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 _iter1211;
- for (_iter1211 = (*(this->foreignKeys)).begin(); _iter1211 != (*(this->foreignKeys)).end(); ++_iter1211)
+ std::vector<SQLForeignKey> ::const_iterator _iter1249;
+ for (_iter1249 = (*(this->foreignKeys)).begin(); _iter1249 != (*(this->foreignKeys)).end(); ++_iter1249)
{
- xfer += (*_iter1211).write(oprot);
+ xfer += (*_iter1249).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4741,10 +4741,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 _iter1212;
- for (_iter1212 = (*(this->uniqueConstraints)).begin(); _iter1212 != (*(this->uniqueConstraints)).end(); ++_iter1212)
+ std::vector<SQLUniqueConstraint> ::const_iterator _iter1250;
+ for (_iter1250 = (*(this->uniqueConstraints)).begin(); _iter1250 != (*(this->uniqueConstraints)).end(); ++_iter1250)
{
- xfer += (*_iter1212).write(oprot);
+ xfer += (*_iter1250).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4753,10 +4753,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 _iter1213;
- for (_iter1213 = (*(this->notNullConstraints)).begin(); _iter1213 != (*(this->notNullConstraints)).end(); ++_iter1213)
+ std::vector<SQLNotNullConstraint> ::const_iterator _iter1251;
+ for (_iter1251 = (*(this->notNullConstraints)).begin(); _iter1251 != (*(this->notNullConstraints)).end(); ++_iter1251)
{
- xfer += (*_iter1213).write(oprot);
+ xfer += (*_iter1251).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4765,10 +4765,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache
xfer += oprot->writeFieldBegin("defaultConstraints", ::apache::thrift::protocol::T_LIST, 6);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->defaultConstraints)).size()));
- std::vector<SQLDefaultConstraint> ::const_iterator _iter1214;
- for (_iter1214 = (*(this->defaultConstraints)).begin(); _iter1214 != (*(this->defaultConstraints)).end(); ++_iter1214)
+ std::vector<SQLDefaultConstraint> ::const_iterator _iter1252;
+ for (_iter1252 = (*(this->defaultConstraints)).begin(); _iter1252 != (*(this->defaultConstraints)).end(); ++_iter1252)
{
- xfer += (*_iter1214).write(oprot);
+ xfer += (*_iter1252).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -6729,14 +6729,14 @@ uint32_t ThriftHiveMetastore_truncate_table_args::read(::apache::thrift::protoco
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->partNames.clear();
- uint32_t _size1215;
- ::apache::thrift::protocol::TType _etype1218;
- xfer += iprot->readListBegin(_etype1218, _size1215);
- this->partNames.resize(_size1215);
- uint32_t _i1219;
- for (_i1219 = 0; _i1219 < _size1215; ++_i1219)
+ uint32_t _size1253;
+ ::apache::thrift::protocol::TType _etype1256;
+ xfer += iprot->readListBegin(_etype1256, _size1253);
+ this->partNames.resize(_size1253);
+ uint32_t _i1257;
+ for (_i1257 = 0; _i1257 < _size1253; ++_i1257)
{
- xfer += iprot->readString(this->partNames[_i1219]);
+ xfer += iprot->readString(this->partNames[_i1257]);
}
xfer += iprot->readListEnd();
}
@@ -6773,10 +6773,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 _iter1220;
- for (_iter1220 = this->partNames.begin(); _iter1220 != this->partNames.end(); ++_iter1220)
+ std::vector<std::string> ::const_iterator _iter1258;
+ for (_iter1258 = this->partNames.begin(); _iter1258 != this->partNames.end(); ++_iter1258)
{
- xfer += oprot->writeString((*_iter1220));
+ xfer += oprot->writeString((*_iter1258));
}
xfer += oprot->writeListEnd();
}
@@ -6808,10 +6808,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 _iter1221;
- for (_iter1221 = (*(this->partNames)).begin(); _iter1221 != (*(this->partNames)).end(); ++_iter1221)
+ std::vector<std::string> ::const_iterator _iter1259;
+ for (_iter1259 = (*(this->partNames)).begin(); _iter1259 != (*(this->partNames)).end(); ++_iter1259)
{
- xfer += oprot->writeString((*_iter1221));
+ xfer += oprot->writeString((*_iter1259));
}
xfer += oprot->writeListEnd();
}
@@ -7055,14 +7055,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol:
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1222;
- ::apache::thrift::protocol::TType _etype1225;
- xfer += iprot->readListBegin(_etype1225, _size1222);
- this->success.resize(_size1222);
- uint32_t _i1226;
- for (_i1226 = 0; _i1226 < _size1222; ++_i1226)
+ uint32_t _size1260;
+ ::apache::thrift::protocol::TType _etype1263;
+ xfer += iprot->readListBegin(_etype1263, _size1260);
+ this->success.resize(_size1260);
+ uint32_t _i1264;
+ for (_i1264 = 0; _i1264 < _size1260; ++_i1264)
{
- xfer += iprot->readString(this->success[_i1226]);
+ xfer += iprot->readString(this->success[_i1264]);
}
xfer += iprot->readListEnd();
}
@@ -7101,10 +7101,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 _iter1227;
- for (_iter1227 = this->success.begin(); _iter1227 != this->success.end(); ++_iter1227)
+ std::vector<std::string> ::const_iterator _iter1265;
+ for (_iter1265 = this->success.begin(); _iter1265 != this->success.end(); ++_iter1265)
{
- xfer += oprot->writeString((*_iter1227));
+ xfer += oprot->writeString((*_iter1265));
}
xfer += oprot->writeListEnd();
}
@@ -7149,14 +7149,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1228;
- ::apache::thrift::protocol::TType _etype1231;
- xfer += iprot->readListBegin(_etype1231, _size1228);
- (*(this->success)).resize(_size1228);
- uint32_t _i1232;
- for (_i1232 = 0; _i1232 < _size1228; ++_i1232)
+ uint32_t _size1266;
+ ::apache::thrift::protocol::TType _etype1269;
+ xfer += iprot->readListBegin(_etype1269, _size1266);
+ (*(this->success)).resize(_size1266);
+ uint32_t _i1270;
+ for (_i1270 = 0; _i1270 < _size1266; ++_i1270)
{
- xfer += iprot->readString((*(this->success))[_i1232]);
+ xfer += iprot->readString((*(this->success))[_i1270]);
}
xfer += iprot->readListEnd();
}
@@ -7326,253 +7326,253 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::p
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1233;
- ::apache::thrift::protocol::TType _etype1236;
- xfer += iprot->readListBegin(_etype1236, _size1233);
- this->success.resize(_size1233);
- uint32_t _i1237;
- for (_i1237 = 0; _i1237 < _size1233; ++_i1237)
- {
- xfer += iprot->readString(this->success[_i1237]);
- }
- xfer += iprot->readListEnd();
- }
- this->__isset.success = true;
- } else {
- xfer += iprot->skip(ftype);
- }
- break;
- case 1:
- if (ftype == ::apache::thrift::protocol::T_STRUCT) {
- xfer += this->o1.read(iprot);
- this->__isset.o1 = true;
- } else {
- xfer += iprot->skip(ftype);
- }
- break;
- default:
- xfer += iprot->skip(ftype);
- break;
- }
- xfer += iprot->readFieldEnd();
- }
-
- xfer += iprot->readStructEnd();
-
- return xfer;
-}
-
-uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
-
- uint32_t xfer = 0;
-
- xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_result");
-
- if (this->__isset.success) {
- 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 _iter1238;
- for (_iter1238 = this->success.begin(); _iter1238 != this->success.end(); ++_iter1238)
- {
- xfer += oprot->writeString((*_iter1238));
- }
- xfer += oprot->writeListEnd();
- }
- xfer += oprot->writeFieldEnd();
- } else if (this->__isset.o1) {
- xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1);
- xfer += this->o1.write(oprot);
- xfer += oprot->writeFieldEnd();
- }
- xfer += oprot->writeFieldStop();
- xfer += oprot->writeStructEnd();
- return xfer;
-}
-
-
-ThriftHiveMetastore_get_tables_by_type_presult::~ThriftHiveMetastore_get_tables_by_type_presult() throw() {
-}
-
-
-uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
-
- apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
- uint32_t xfer = 0;
- std::string fname;
- ::apache::thrift::protocol::TType ftype;
- int16_t fid;
-
- xfer += iprot->readStructBegin(fname);
-
- using ::apache::thrift::protocol::TProtocolException;
-
-
- while (true)
- {
- xfer += iprot->readFieldBegin(fname, ftype, fid);
- if (ftype == ::apache::thrift::protocol::T_STOP) {
- break;
- }
- switch (fid)
- {
- case 0:
- if (ftype == ::apache::thrift::protocol::T_LIST) {
- {
- (*(this->success)).clear();
- uint32_t _size1239;
- ::apache::thrift::protocol::TType _etype1242;
- xfer += iprot->readListBegin(_etype1242, _size1239);
- (*(this->success)).resize(_size1239);
- uint32_t _i1243;
- for (_i1243 = 0; _i1243 < _size1239; ++_i1243)
- {
- xfer += iprot->readString((*(this->success))[_i1243]);
- }
- xfer += iprot->readListEnd();
- }
- this->__isset.success = true;
- } else {
- xfer += iprot->skip(ftype);
- }
- break;
- case 1:
- if (ftype == ::apache::thrift::protocol::T_STRUCT) {
- xfer += this->o1.read(iprot);
- this->__isset.o1 = true;
- } else {
- xfer += iprot->skip(ftype);
- }
- break;
- default:
- xfer += iprot->skip(ftype);
- break;
- }
- xfer += iprot->readFieldEnd();
- }
-
- xfer += iprot->readStructEnd();
-
- return xfer;
-}
-
-
-ThriftHiveMetastore_get_materialized_views_for_rewriting_args::~ThriftHiveMetastore_get_materialized_views_for_rewriting_args() throw() {
-}
-
-
-uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_args::read(::apache::thrift::protocol::TProtocol* iprot) {
-
- apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
- uint32_t xfer = 0;
- std::string fname;
- ::apache::thrift::protocol::TType ftype;
- int16_t fid;
-
- xfer += iprot->readStructBegin(fname);
-
- using ::apache::thrift::protocol::TProtocolException;
-
-
- while (true)
- {
- xfer += iprot->readFieldBegin(fname, ftype, fid);
- if (ftype == ::apache::thrift::protocol::T_STOP) {
- break;
- }
- switch (fid)
- {
- case 1:
- if (ftype == ::apache::thrift::protocol::T_STRING) {
- xfer += iprot->readString(this->db_name);
- this->__isset.db_name = true;
- } else {
- xfer += iprot->skip(ftype);
- }
- break;
- default:
- xfer += iprot->skip(ftype);
- break;
- }
- xfer += iprot->readFieldEnd();
- }
-
- xfer += iprot->readStructEnd();
-
- return xfer;
-}
-
-uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
- uint32_t xfer = 0;
- apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
- xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_materialized_views_for_rewriting_args");
-
- xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
- xfer += oprot->writeString(this->db_name);
- xfer += oprot->writeFieldEnd();
-
- xfer += oprot->writeFieldStop();
- xfer += oprot->writeStructEnd();
- return xfer;
-}
-
-
-ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs::~ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs() throw() {
-}
-
-
-uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
- uint32_t xfer = 0;
- apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
- xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs");
-
- xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
- xfer += oprot->writeString((*(this->db_name)));
- xfer += oprot->writeFieldEnd();
-
- xfer += oprot->writeFieldStop();
- xfer += oprot->writeStructEnd();
- return xfer;
-}
-
-
-ThriftHiveMetastore_get_materialized_views_for_rewriting_result::~ThriftHiveMetastore_get_materialized_views_for_rewriting_result() throw() {
-}
-
-
-uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::read(::apache::thrift::protocol::TProtocol* iprot) {
-
- apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
- uint32_t xfer = 0;
- std::string fname;
- ::apache::thrift::protocol::TType ftype;
- int16_t fid;
-
- xfer += iprot->readStructBegin(fname);
-
- using ::apache::thrift::protocol::TProtocolException;
-
-
- while (true)
- {
- xfer += iprot->readFieldBegin(fname, ftype, fid);
- if (ftype == ::apache::thrift::protocol::T_STOP) {
- break;
- }
- switch (fid)
- {
- case 0:
- if (ftype == ::apache::thrift::protocol::T_LIST) {
- {
- this->success.clear();
- uint32_t _size1244;
- ::apache::thrift::protocol::TType _etype1247;
- xfer += iprot->readListBegin(_etype1247, _size1244);
- this->success.resize(_size1244);
- uint32_t _i1248;
- for (_i1248 = 0; _i1248 < _size1244; ++_i1248)
+ uint32_t _size1271;
+ ::apache::thrift::protocol::TType _etype1274;
+ xfer += iprot->readListBegin(_etype1274, _size1271);
+ this->success.resize(_size1271);
+ uint32_t _i1275;
+ for (_i1275 = 0; _i1275 < _size1271; ++_i1275)
+ {
+ xfer += iprot->readString(this->success[_i1275]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_tables_by_type_result");
+
+ if (this->__isset.success) {
+ 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 _iter1276;
+ for (_iter1276 = this->success.begin(); _iter1276 != this->success.end(); ++_iter1276)
+ {
+ xfer += oprot->writeString((*_iter1276));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o1) {
+ xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->o1.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+
+ThriftHiveMetastore_get_tables_by_type_presult::~ThriftHiveMetastore_get_tables_by_type_presult() throw() {
+}
+
+
+uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ (*(this->success)).clear();
+ uint32_t _size1277;
+ ::apache::thrift::protocol::TType _etype1280;
+ xfer += iprot->readListBegin(_etype1280, _size1277);
+ (*(this->success)).resize(_size1277);
+ uint32_t _i1281;
+ for (_i1281 = 0; _i1281 < _size1277; ++_i1281)
+ {
+ xfer += iprot->readString((*(this->success))[_i1281]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+
+ThriftHiveMetastore_get_materialized_views_for_rewriting_args::~ThriftHiveMetastore_get_materialized_views_for_rewriting_args() throw() {
+}
+
+
+uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->db_name);
+ this->__isset.db_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_materialized_views_for_rewriting_args");
+
+ xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->db_name);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+
+ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs::~ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs() throw() {
+}
+
+
+uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs");
+
+ xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->db_name)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+
+ThriftHiveMetastore_get_materialized_views_for_rewriting_result::~ThriftHiveMetastore_get_materialized_views_for_rewriting_result() throw() {
+}
+
+
+uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->success.clear();
+ uint32_t _size1282;
+ ::apache::thrift::protocol::TType _etype1285;
+ xfer += iprot->readListBegin(_etype1285, _size1282);
+ this->success.resize(_size1282);
+ uint32_t _i1286;
+ for (_i1286 = 0; _i1286 < _size1282; ++_i1286)
{
- xfer += iprot->readString(this->success[_i1248]);
+ xfer += iprot->readString(this->success[_i1286]);
}
xfer += iprot->readListEnd();
}
@@ -7611,10 +7611,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 _iter1249;
- for (_iter1249 = this->success.begin(); _iter1249 != this->success.end(); ++_iter1249)
+ std::vector<std::string> ::const_iterator _iter1287;
+ for (_iter1287 = this->success.begin(); _iter1287 != this->success.end(); ++_iter1287)
{
- xfer += oprot->writeString((*_iter1249));
+ xfer += oprot->writeString((*_iter1287));
}
xfer += oprot->writeListEnd();
}
@@ -7659,14 +7659,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_presult::read(
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1250;
- ::apache::thrift::protocol::TType _etype1253;
- xfer += iprot->readListBegin(_etype1253, _size1250);
- (*(this->success)).resize(_size1250);
- uint32_t _i1254;
- for (_i1254 = 0; _i1254 < _size1250; ++_i1254)
+ uint32_t _size1288;
+ ::apache::thrift::protocol::TType _etype1291;
+ xfer += iprot->readListBegin(_etype1291, _size1288);
+ (*(this->success)).resize(_size1288);
+ uint32_t _i1292;
+ for (_i1292 = 0; _i1292 < _size1288; ++_i1292)
{
- xfer += iprot->readString((*(this->success))[_i1254]);
+ xfer += iprot->readString((*(this->success))[_i1292]);
}
xfer += iprot->readListEnd();
}
@@ -7741,14 +7741,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 _size1255;
- ::apache::thrift::protocol::TType _etype1258;
- xfer += iprot->readListBegin(_etype1258, _size1255);
- this->tbl_types.resize(_size1255);
- uint32_t _i1259;
- for (_i1259 = 0; _i1259 < _size1255; ++_i1259)
+ uint32_t _size1293;
+ ::apache::thrift::protocol::TType _etype1296;
+ xfer += iprot->readListBegin(_etype1296, _size1293);
+ this->tbl_types.resize(_size1293);
+ uint32_t _i1297;
+ for (_i1297 = 0; _i1297 < _size1293; ++_i1297)
{
- xfer += iprot->readString(this->tbl_types[_i1259]);
+ xfer += iprot->readString(this->tbl_types[_i1297]);
}
xfer += iprot->readListEnd();
}
@@ -7785,10 +7785,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 _iter1260;
- for (_iter1260 = this->tbl_types.begin(); _iter1260 != this->tbl_types.end(); ++_iter1260)
+ std::vector<std::string> ::const_iterator _iter1298;
+ for (_iter1298 = this->tbl_types.begin(); _iter1298 != this->tbl_types.end(); ++_iter1298)
{
- xfer += oprot->writeString((*_iter1260));
+ xfer += oprot->writeString((*_iter1298));
}
xfer += oprot->writeListEnd();
}
@@ -7820,10 +7820,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 _iter1261;
- for (_iter1261 = (*(this->tbl_types)).begin(); _iter1261 != (*(this->tbl_types)).end(); ++_iter1261)
+ std::vector<std::string> ::const_iterator _iter1299;
+ for (_iter1299 = (*(this->tbl_types)).begin(); _iter1299 != (*(this->tbl_types)).end(); ++_iter1299)
{
- xfer += oprot->writeString((*_iter1261));
+ xfer += oprot->writeString((*_iter1299));
}
xfer += oprot->writeListEnd();
}
@@ -7864,14 +7864,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1262;
- ::apache::thrift::protocol::TType _etype1265;
- xfer += iprot->readListBegin(_etype1265, _size1262);
- this->success.resize(_size1262);
- uint32_t _i1266;
- for (_i1266 = 0; _i1266 < _size1262; ++_i1266)
+ uint32_t _size1300;
+ ::apache::thrift::protocol::TType _etype1303;
+ xfer += iprot->readListBegin(_etype1303, _size1300);
+ this->success.resize(_size1300);
+ uint32_t _i1304;
+ for (_i1304 = 0; _i1304 < _size1300; ++_i1304)
{
- xfer += this->success[_i1266].read(iprot);
+ xfer += this->success[_i1304].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -7910,10 +7910,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 _iter1267;
- for (_iter1267 = this->success.begin(); _iter1267 != this->success.end(); ++_iter1267)
+ std::vector<TableMeta> ::const_iterator _iter1305;
+ for (_iter1305 = this->success.begin(); _iter1305 != this->success.end(); ++_iter1305)
{
- xfer += (*_iter1267).write(oprot);
+ xfer += (*_iter1305).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -7958,14 +7958,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1268;
- ::apache::thrift::protocol::TType _etype1271;
- xfer += iprot->readListBegin(_etype1271, _size1268);
- (*(this->success)).resize(_size1268);
- uint32_t _i1272;
- for (_i1272 = 0; _i1272 < _size1268; ++_i1272)
+ uint32_t _size1306;
+ ::apache::thrift::protocol::TType _etype1309;
+ xfer += iprot->readListBegin(_etype1309, _size1306);
+ (*(this->success)).resize(_size1306);
+ uint32_t _i1310;
+ for (_i1310 = 0; _i1310 < _size1306; ++_i1310)
{
- xfer += (*(this->success))[_i1272].read(iprot);
+ xfer += (*(this->success))[_i1310].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -8103,14 +8103,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1273;
- ::apache::thrift::protocol::TType _etype1276;
- xfer += iprot->readListBegin(_etype1276, _size1273);
- this->success.resize(_size1273);
- uint32_t _i1277;
- for (_i1277 = 0; _i1277 < _size1273; ++_i1277)
+ uint32_t _size1311;
+ ::apache::thrift::protocol::TType _etype1314;
+ xfer += iprot->readListBegin(_etype1314, _size1311);
+ this->success.resize(_size1311);
+ uint32_t _i1315;
+ for (_i1315 = 0; _i1315 < _size1311; ++_i1315)
{
- xfer += iprot->readString(this->success[_i1277]);
+ xfer += iprot->readString(this->success[_i1315]);
}
xfer += iprot->readListEnd();
}
@@ -8149,10 +8149,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 _iter1278;
- for (_iter1278 = this->success.begin(); _iter1278 != this->success.end(); ++_iter1278)
+ std::vector<std::string> ::const_iterator _iter1316;
+ for (_iter1316 = this->success.begin(); _iter1316 != this->success.end(); ++_iter1316)
{
- xfer += oprot->writeString((*_iter1278));
+ xfer += oprot->writeString((*_iter1316));
}
xfer += oprot->writeListEnd();
}
@@ -8197,14 +8197,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1279;
- ::apache::thrift::protocol::TType _etype1282;
- xfer += iprot->readListBegin(_etype1282, _size1279);
- (*(this->success)).resize(_size1279);
- uint32_t _i1283;
- for (_i1283 = 0; _i1283 < _size1279; ++_i1283)
+ uint32_t _size1317;
+ ::apache::thrift::protocol::TType _etype1320;
+ xfer += iprot->readListBegin(_etype1320, _size1317);
+ (*(this->success)).resize(_size1317);
+ uint32_t _i1321;
+ for (_i1321 = 0; _i1321 < _size1317; ++_i1321)
{
- xfer += iprot->readString((*(this->success))[_i1283]);
+ xfer += iprot->readString((*(this->success))[_i1321]);
}
xfer += iprot->readListEnd();
}
@@ -8514,14 +8514,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 _size1284;
- ::apache::thrift::protocol::TType _etype1287;
- xfer += iprot->readListBegin(_etype1287, _size1284);
- this->tbl_names.resize(_size1284);
- uint32_t _i1288;
- for (_i1288 = 0; _i1288 < _size1284; ++_i1288)
+ uint32_t _size1322;
+ ::apache::thrift::protocol::TType _etype1325;
+ xfer += iprot->readListBegin(_etype1325, _size1322);
+ this->tbl_names.resize(_size1322);
+ uint32_t _i1326;
+ for (_i1326 = 0; _i1326 < _size1322; ++_i1326)
{
- xfer += iprot->readString(this->tbl_names[_i1288]);
+ xfer += iprot->readString(this->tbl_names[_i1326]);
}
xfer += iprot->readListEnd();
}
@@ -8554,10 +8554,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 _iter1289;
- for (_iter1289 = this->tbl_names.begin(); _iter1289 != this->tbl_names.end(); ++_iter1289)
+ std::vector<std::string> ::const_iterator _iter1327;
+ for (_iter1327 = this->tbl_names.begin(); _iter1327 != this->tbl_names.end(); ++_iter1327)
{
- xfer += oprot->writeString((*_iter1289));
+ xfer += oprot->writeString((*_iter1327));
}
xfer += oprot->writeListEnd();
}
@@ -8585,10 +8585,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 _iter1290;
- for (_iter1290 = (*(this->tbl_names)).begin(); _iter1290 != (*(this->tbl_names)).end(); ++_iter1290)
+ std::vector<std::string> ::const_iterator _iter1328;
+ for (_iter1328 = (*(this->tbl_names)).begin(); _iter1328 != (*(this->tbl_names)).end(); ++_iter1328)
{
- xfer += oprot->writeString((*_iter1290));
+ xfer += oprot->writeString((*_iter1328));
}
xfer += oprot->writeListEnd();
}
@@ -8629,14 +8629,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 _size1291;
- ::apache::thrift::protocol::TType _etype1294;
- xfer += iprot->readListBegin(_etype1294, _size1291);
- this->success.resize(_size1291);
- uint32_t _i1295;
- for (_i1295 = 0; _i1295 < _size1291; ++_i1295)
+ uint32_t _size1329;
+ ::apache::thrift::protocol::TType _etype1332;
+ xfer += iprot->readListBegin(_etype1332, _size1329);
+ this->success.resize(_size1329);
+ uint32_t _i1333;
+ for (_i1333 = 0; _i1333 < _size1329; ++_i1333)
{
- xfer += this->success[_i1295].read(iprot);
+ xfer += this->success[_i1333].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -8667,10 +8667,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 _iter1296;
- for (_iter1296 = this->success.begin(); _iter1296 != this->success.end(); ++_iter1296)
+ std::vector<Table> ::const_iterator _iter1334;
+ for (_iter1334 = this->success.begin(); _iter1334 != this->success.end(); ++_iter1334)
{
- xfer += (*_iter1296).write(oprot);
+ xfer += (*_iter1334).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -8711,14 +8711,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 _size1297;
- ::apache::thrift::protocol::TType _etype1300;
- xfer += iprot->readListBegin(_etype1300, _size1297);
- (*(this->success)).resize(_size1297);
- uint32_t _i1301;
- for (_i1301 = 0; _i1301 < _size1297; ++_i1301)
+ uint32_t _size1335;
+ ::apache::thrift::protocol::TType _etype1338;
+ xfer += iprot->readListBegin(_etype1338, _size1335);
+ (*(this->success)).resize(_size1335);
+ uint32_t _i1339;
+ for (_i1339 = 0; _i1339 < _size1335; ++_i1339)
{
- xfer += (*(this->success))[_i1301].read(iprot);
+ xfer += (*(this->success))[_i1339].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9251,14 +9251,14 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_args::read(::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->tbl_names.clear();
- uint32_t _size1302;
- ::apache::thrift::protocol::TType _etype1305;
- xfer += iprot->readListBegin(_etype1305, _size1302);
- this->tbl_names.resize(_size1302);
- uint32_t _i1306;
- for (_i1306 = 0; _i1306 < _size1302; ++_i1306)
+ uint32_t _size1340;
+ ::apache::thrift::protocol::TType _etype1343;
+ xfer += iprot->readListBegin(_etype1343, _size1340);
+ this->tbl_names.resize(_size1340);
+ uint32_t _i1344;
+ for (_i1344 = 0; _i1344 < _size1340; ++_i1344)
{
- xfer += iprot->readString(this->tbl_names[_i1306]);
+ xfer += iprot->readString(this->tbl_names[_i1344]);
}
xfer += iprot->readListEnd();
}
@@ -9291,10 +9291,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 _iter1307;
- for (_iter1307 = this->tbl_names.begin(); _iter1307 != this->tbl_names.end(); ++_iter1307)
+ std::vector<std::string> ::const_iterator _iter1345;
+ for (_iter1345 = this->tbl_names.begin(); _iter1345 != this->tbl_names.end(); ++_iter1345)
{
- xfer += oprot->writeString((*_iter1307));
+ xfer += oprot->writeString((*_iter1345));
}
xfer += oprot->writeListEnd();
}
@@ -9322,10 +9322,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 _iter1308;
- for (_iter1308 = (*(this->tbl_names)).begin(); _iter1308 != (*(this->tbl_names)).end(); ++_iter1308)
+ std::vector<std::string> ::const_iterator _iter1346;
+ for (_iter1346 = (*(this->tbl_names)).begin(); _iter1346 != (*(this->tbl_names)).end(); ++_iter1346)
{
- xfer += oprot->writeString((*_iter1308));
+ xfer += oprot->writeString((*_iter1346));
}
xfer += oprot->writeListEnd();
}
@@ -9366,17 +9366,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_result::read(
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->success.clear();
- uint32_t _size1309;
- ::apache::thrift::protocol::TType _ktype1310;
- ::apache::thrift::protocol::TType _vtype1311;
- xfer += iprot->readMapBegin(_ktype1310, _vtype1311, _size1309);
- uint32_t _i1313;
- for (_i1313 = 0; _i1313 < _size1309; ++_i1313)
+ uint32_t _size1347;
+ ::apache::thrift::protocol::TType _ktype1348;
+ ::apache::thrift::protocol::TType _vtype1349;
+ xfer += iprot->readMapBegin(_ktype1348, _vtype1349, _size1347);
+ uint32_t _i1351;
+ for (_i1351 = 0; _i1351 < _size1347; ++_i1351)
{
- std::string _key1314;
- xfer += iprot->readString(_key1314);
- Materialization& _val1315 = this->success[_key1314];
- xfer += _val1315.read(iprot);
+ std::string _key1352;
+ xfer += iprot->readString(_key1352);
+ Materialization& _val1353 = this->success[_key1352];
+ xfer += _val1353.read(iprot);
}
xfer += iprot->readMapEnd();
}
@@ -9431,11 +9431,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 _iter1316;
- for (_iter1316 = this->success.begin(); _iter1316 != this->success.end(); ++_iter1316)
+ std::map<std::string, Materialization> ::const_iterator _iter1354;
+ for (_iter1354 = this->success.begin(); _iter1354 != this->success.end(); ++_iter1354)
{
- xfer += oprot->writeString(_iter1316->first);
- xfer += _iter1316->second.write(oprot);
+ xfer += oprot->writeString(_iter1354->first);
+ xfer += _iter1354->second.write(oprot);
}
xfer += oprot->writeMapEnd();
}
@@ -9488,17 +9488,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_presult::read
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
(*(this->success)).clear();
- uint32_t _size1317;
- ::apache::thrift::protocol::TType _ktype1318;
- ::apache::thrift::protocol::TType _vtype1319;
- xfer += iprot->readMapBegin(_ktype1318, _vtype1319, _size1317);
- uint32_t _i1321;
- for (_i1321 = 0; _i1321 < _size1317; ++_i1321)
+ uint32_t _size1355;
+ ::apache::thrift::protocol::TType _ktype1356;
+ ::apache::thrift::protocol::TType _vtype1357;
+ xfer += iprot->readMapBegin(_ktype1356, _vtype1357, _size1355);
+ uint32_t _i1359;
+ for (_i1359 = 0; _i1359 < _size1355; ++_i1359)
{
- std::string _key1322;
- xfer += iprot->readString(_key1322);
- Materialization& _val1323 = (*(this->success))[_key1322];
- xfer += _val1323.read(iprot);
+ std::string _key1360;
+ xfer += iprot->readString(_key1360);
+ Materialization& _val1361 = (*(this->success))[_key1360];
+ xfer += _val1361.read(iprot);
}
xfer += iprot->readMapEnd();
}
@@ -9943,14 +9943,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 _size1324;
- ::apache::thrift::protocol::TType _etype1327;
- xfer += iprot->readListBegin(_etype1327, _size1324);
- this->success.resize(_size1324);
- uint32_t _i1328;
- for (_i1328 = 0; _i1328 < _size1324; ++_i1328)
+ uint32_t _size1362;
+ ::apache::thrift::protocol::TType _etype1365;
+ xfer += iprot->readListBegin(_etype1365, _size1362);
+ this->success.resize(_size1362);
+ uint32_t _i1366;
+ for (_i1366 = 0; _i1366 < _size1362; ++_i1366)
{
- xfer += iprot->readString(this->success[_i1328]);
+ xfer += iprot->readString(this->success[_i1366]);
}
xfer += iprot->readListEnd();
}
@@ -10005,10 +10005,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 _iter1329;
- for (_iter1329 = this->success.begin(); _iter1329 != this->success.end(); ++_iter1329)
+ std::vector<std::string> ::const_iterator _iter1367;
+ for (_iter1367 = this->success.begin(); _iter1367 != this->success.end(); ++_iter1367)
{
- xfer += oprot->writeString((*_iter1329));
+ xfer += oprot->writeString((*_iter1367));
}
xfer += oprot->writeListEnd();
}
@@ -10061,14 +10061,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 _size1330;
- ::apache::thrift::protocol::TType _etype1333;
- xfer += iprot->readListBegin(_etype1333, _size1330);
- (*(this->success)).resize(_size1330);
- uint32_t _i1334;
- for (_i1334 = 0; _i1334 < _size1330; ++_i1334)
+ uint32_t _size1368;
+ ::apache::thrift::protocol::TType _etype1371;
+ xfer += iprot->readListBegin(_etype1371, _size1368);
+ (*(this->success)).resize(_size1368);
+ uint32_t _i1372;
+ for (_i1372 = 0; _i1372 < _size1368; ++_i1372)
{
- xfer += iprot->readString((*(this->success))[_i1334]);
+ xfer += iprot->readString((*(this->success))[_i1372]);
}
xfer += iprot->readListEnd();
}
@@ -11402,14 +11402,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->new_parts.clear();
- uint32_t _size1335;
- ::apache::thrift::protocol::TType _etype1338;
- xfer += iprot->readListBegin(_etype1338, _size1335);
- this->new_parts.resize(_size1335);
- uint32_t _i1339;
- for (_i1339 = 0; _i1339 < _size1335; ++_i1339)
+ uint32_t _size1373;
+ ::apache::thrift::protocol::TType _etype1376;
+ xfer += iprot->readListBegin(_etype1376, _size1373);
+ this->new_parts.resize(_size1373);
+ uint32_t _i1377;
+ for (_i1377 = 0; _i1377 < _size1373; ++_i1377)
{
- xfer += this->new_parts[_i1339].read(iprot);
+ xfer += this->new_parts[_i1377].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11438,10 +11438,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 _iter1340;
- for (_iter1340 = this->new_parts.begin(); _iter1340 != this->new_parts.end(); ++_iter1340)
+ std::vector<Partition> ::const_iterator _iter1378;
+ for (_iter1378 = this->new_parts.begin(); _iter1378 != this->new_parts.end(); ++_iter1378)
{
- xfer += (*_iter1340).write(oprot);
+ xfer += (*_iter1378).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11465,10 +11465,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 _iter1341;
- for (_iter1341 = (*(this->new_parts)).begin(); _iter1341 != (*(this->new_parts)).end(); ++_iter1341)
+ std::vector<Partition> ::const_iterator _iter1379;
+ for (_iter1379 = (*(this->new_parts)).begin(); _iter1379 != (*(this->new_parts)).end(); ++_iter1379)
{
- xfer += (*_iter1341).write(oprot);
+ xfer += (*_iter1379).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11677,14 +11677,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 _size1342;
- ::apache::thrift::protocol::TType _etype1345;
- xfer += iprot->readListBegin(_etype1345, _size1342);
- this->new_parts.resize(_size1342);
- uint32_t _i1346;
- for (_i1346 = 0; _i1346 < _size1342; ++_i1346)
+ uint32_t _size1380;
+ ::apache::thrift::protocol::TType _etype1383;
+ xfer += iprot->readListBegin(_etype1383, _size1380);
+ this->new_parts.resize(_size1380);
+ uint32_t _i1384;
+ for (_i1384 = 0; _i1384 < _size1380; ++_i1384)
{
- xfer += this->new_parts[_i1346].read(iprot);
+ xfer += this->new_parts[_i1384].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11713,10 +11713,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 _iter1347;
- for (_iter1347 = this->new_parts.begin(); _iter1347 != this->new_parts.end(); ++_iter1347)
+ std::vector<PartitionSpec> ::const_iterator _iter1385;
+ for (_iter1385 = this->new_parts.begin(); _iter1385 != this->new_parts.end(); ++_iter1385)
{
- xfer += (*_iter1347).write(oprot);
+ xfer += (*_iter1385).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11740,10 +11740,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 _iter1348;
- for (_iter1348 = (*(this->new_parts)).begin(); _iter1348 != (*(this->new_parts)).end(); ++_iter1348)
+ std::vector<PartitionSpec> ::const_iterator _iter1386;
+ for (_iter1386 = (*(this->new_parts)).begin(); _iter1386 != (*(this->new_parts)).end(); ++_iter1386)
{
- xfer += (*_iter1348).write(oprot);
+ xfer += (*_iter1386).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11968,14 +11968,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size1349;
- ::apache::thrift::protocol::TType _etype1352;
- xfer += iprot->readListBegin(_etype1352, _size1349);
- this->part_vals.resize(_size1349);
- uint32_t _i1353;
- for (_i1353 = 0; _i1353 < _size1349; ++_i1353)
+ uint32_t _size1387;
+ ::apache::thrift::protocol::TType _etype1390;
+ xfer += iprot->readListBegin(_etype1390, _size1387);
+ this->part_vals.resize(_size1387);
+ uint32_t _i1391;
+ for (_i1391 = 0; _i1391 < _size1387; ++_i1391)
{
- xfer += iprot->readString(this->part_vals[_i1353]);
+ xfer += iprot->readString(this->part_vals[_i1391]);
}
xfer += iprot->readListEnd();
}
@@ -12012,10 +12012,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 _iter1354;
- for (_iter1354 = this->part_vals.begin(); _iter1354 != this->part_vals.end(); ++_iter1354)
+ std::vector<std::string> ::const_iterator _iter1392;
+ for (_iter1392 = this->part_vals.begin(); _iter1392 != this->part_vals.end(); ++_iter1392)
{
- xfer += oprot->writeString((*_iter1354));
+ xfer += oprot->writeString((*_iter1392));
}
xfer += oprot->writeListEnd();
}
@@ -12047,10 +12047,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 _iter1355;
- for (_iter1355 = (*(this->part_vals)).begin(); _iter1355 != (*(this->part_vals)).end(); ++_iter1355)
+ std::vector<std::string> ::const_iterator _iter1393;
+ for (_iter1393 = (*(this->part_vals)).begin(); _iter1393 != (*(this->part_vals)).end(); ++_iter1393)
{
- xfer += oprot->writeString((*_iter1355));
+ xfer += oprot->writeString((*_iter1393));
}
xfer += oprot->writeListEnd();
}
@@ -12522,14 +12522,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size1356;
- ::apache::thrift::protocol::TType _etype1359;
- xfer += iprot->readListBegin(_etype1359, _size1356);
- this->part_vals.resize(_size1356);
- uint32_t _i1360;
- for (_i1360 = 0; _i1360 < _size1356; ++_i1360)
+ uint32_t _size1394;
+ ::apache::thrift::protocol::TType _etype1397;
+ xfer += iprot->readListBegin(_etype1397, _size1394);
+ this->part_vals.resize(_size1394);
+ uint32_t _i1398;
+ for (_i1398 = 0; _i1398 < _size1394; ++_i1398)
{
- xfer += iprot->readString(this->part_vals[_i1360]);
+ xfer += iprot->readString(this->part_vals[_i1398]);
}
xfer += iprot->readListEnd();
}
@@ -12574,10 +12574,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 _iter1361;
- for (_iter1361 = this->part_vals.begin(); _iter1361 != this->part_vals.end(); ++_iter1361)
+ std::vector<std::string> ::const_iterator _iter1399;
+ for (_i
<TRUNCATED>