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>