You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by vg...@apache.org on 2018/03/04 07:26:09 UTC
[15/19] hive git commit: HIVE-18726 : Implement DEFAULT constraint (Vineet Garg, reviewed by Ashutosh Chauhan, Jesús Camacho Rodríguez)
http://git-wip-us.apache.org/repos/asf/hive/blob/4047befe/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 921cba1..1510d4f 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 _size1091;
- ::apache::thrift::protocol::TType _etype1094;
- xfer += iprot->readListBegin(_etype1094, _size1091);
- this->success.resize(_size1091);
- uint32_t _i1095;
- for (_i1095 = 0; _i1095 < _size1091; ++_i1095)
+ uint32_t _size1111;
+ ::apache::thrift::protocol::TType _etype1114;
+ xfer += iprot->readListBegin(_etype1114, _size1111);
+ this->success.resize(_size1111);
+ uint32_t _i1115;
+ for (_i1115 = 0; _i1115 < _size1111; ++_i1115)
{
- xfer += iprot->readString(this->success[_i1095]);
+ xfer += iprot->readString(this->success[_i1115]);
}
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 _iter1096;
- for (_iter1096 = this->success.begin(); _iter1096 != this->success.end(); ++_iter1096)
+ std::vector<std::string> ::const_iterator _iter1116;
+ for (_iter1116 = this->success.begin(); _iter1116 != this->success.end(); ++_iter1116)
{
- xfer += oprot->writeString((*_iter1096));
+ xfer += oprot->writeString((*_iter1116));
}
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 _size1097;
- ::apache::thrift::protocol::TType _etype1100;
- xfer += iprot->readListBegin(_etype1100, _size1097);
- (*(this->success)).resize(_size1097);
- uint32_t _i1101;
- for (_i1101 = 0; _i1101 < _size1097; ++_i1101)
+ uint32_t _size1117;
+ ::apache::thrift::protocol::TType _etype1120;
+ xfer += iprot->readListBegin(_etype1120, _size1117);
+ (*(this->success)).resize(_size1117);
+ uint32_t _i1121;
+ for (_i1121 = 0; _i1121 < _size1117; ++_i1121)
{
- xfer += iprot->readString((*(this->success))[_i1101]);
+ xfer += iprot->readString((*(this->success))[_i1121]);
}
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 _size1102;
- ::apache::thrift::protocol::TType _etype1105;
- xfer += iprot->readListBegin(_etype1105, _size1102);
- this->success.resize(_size1102);
- uint32_t _i1106;
- for (_i1106 = 0; _i1106 < _size1102; ++_i1106)
+ uint32_t _size1122;
+ ::apache::thrift::protocol::TType _etype1125;
+ xfer += iprot->readListBegin(_etype1125, _size1122);
+ this->success.resize(_size1122);
+ uint32_t _i1126;
+ for (_i1126 = 0; _i1126 < _size1122; ++_i1126)
{
- xfer += iprot->readString(this->success[_i1106]);
+ xfer += iprot->readString(this->success[_i1126]);
}
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 _iter1107;
- for (_iter1107 = this->success.begin(); _iter1107 != this->success.end(); ++_iter1107)
+ std::vector<std::string> ::const_iterator _iter1127;
+ for (_iter1127 = this->success.begin(); _iter1127 != this->success.end(); ++_iter1127)
{
- xfer += oprot->writeString((*_iter1107));
+ xfer += oprot->writeString((*_iter1127));
}
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 _size1108;
- ::apache::thrift::protocol::TType _etype1111;
- xfer += iprot->readListBegin(_etype1111, _size1108);
- (*(this->success)).resize(_size1108);
- uint32_t _i1112;
- for (_i1112 = 0; _i1112 < _size1108; ++_i1112)
+ uint32_t _size1128;
+ ::apache::thrift::protocol::TType _etype1131;
+ xfer += iprot->readListBegin(_etype1131, _size1128);
+ (*(this->success)).resize(_size1128);
+ uint32_t _i1132;
+ for (_i1132 = 0; _i1132 < _size1128; ++_i1132)
{
- xfer += iprot->readString((*(this->success))[_i1112]);
+ xfer += iprot->readString((*(this->success))[_i1132]);
}
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 _size1113;
- ::apache::thrift::protocol::TType _ktype1114;
- ::apache::thrift::protocol::TType _vtype1115;
- xfer += iprot->readMapBegin(_ktype1114, _vtype1115, _size1113);
- uint32_t _i1117;
- for (_i1117 = 0; _i1117 < _size1113; ++_i1117)
+ uint32_t _size1133;
+ ::apache::thrift::protocol::TType _ktype1134;
+ ::apache::thrift::protocol::TType _vtype1135;
+ xfer += iprot->readMapBegin(_ktype1134, _vtype1135, _size1133);
+ uint32_t _i1137;
+ for (_i1137 = 0; _i1137 < _size1133; ++_i1137)
{
- std::string _key1118;
- xfer += iprot->readString(_key1118);
- Type& _val1119 = this->success[_key1118];
- xfer += _val1119.read(iprot);
+ std::string _key1138;
+ xfer += iprot->readString(_key1138);
+ Type& _val1139 = this->success[_key1138];
+ xfer += _val1139.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 _iter1120;
- for (_iter1120 = this->success.begin(); _iter1120 != this->success.end(); ++_iter1120)
+ std::map<std::string, Type> ::const_iterator _iter1140;
+ for (_iter1140 = this->success.begin(); _iter1140 != this->success.end(); ++_iter1140)
{
- xfer += oprot->writeString(_iter1120->first);
- xfer += _iter1120->second.write(oprot);
+ xfer += oprot->writeString(_iter1140->first);
+ xfer += _iter1140->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 _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 _size1141;
+ ::apache::thrift::protocol::TType _ktype1142;
+ ::apache::thrift::protocol::TType _vtype1143;
+ xfer += iprot->readMapBegin(_ktype1142, _vtype1143, _size1141);
+ uint32_t _i1145;
+ for (_i1145 = 0; _i1145 < _size1141; ++_i1145)
{
- std::string _key1126;
- xfer += iprot->readString(_key1126);
- Type& _val1127 = (*(this->success))[_key1126];
- xfer += _val1127.read(iprot);
+ std::string _key1146;
+ xfer += iprot->readString(_key1146);
+ Type& _val1147 = (*(this->success))[_key1146];
+ xfer += _val1147.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 _size1128;
- ::apache::thrift::protocol::TType _etype1131;
- xfer += iprot->readListBegin(_etype1131, _size1128);
- this->success.resize(_size1128);
- uint32_t _i1132;
- for (_i1132 = 0; _i1132 < _size1128; ++_i1132)
+ 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 += this->success[_i1132].read(iprot);
+ xfer += this->success[_i1152].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 _iter1133;
- for (_iter1133 = this->success.begin(); _iter1133 != this->success.end(); ++_iter1133)
+ std::vector<FieldSchema> ::const_iterator _iter1153;
+ for (_iter1153 = this->success.begin(); _iter1153 != this->success.end(); ++_iter1153)
{
- xfer += (*_iter1133).write(oprot);
+ xfer += (*_iter1153).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 _size1134;
- ::apache::thrift::protocol::TType _etype1137;
- xfer += iprot->readListBegin(_etype1137, _size1134);
- (*(this->success)).resize(_size1134);
- uint32_t _i1138;
- for (_i1138 = 0; _i1138 < _size1134; ++_i1138)
+ uint32_t _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 += (*(this->success))[_i1138].read(iprot);
+ xfer += (*(this->success))[_i1158].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 _size1139;
- ::apache::thrift::protocol::TType _etype1142;
- xfer += iprot->readListBegin(_etype1142, _size1139);
- this->success.resize(_size1139);
- uint32_t _i1143;
- for (_i1143 = 0; _i1143 < _size1139; ++_i1143)
+ uint32_t _size1159;
+ ::apache::thrift::protocol::TType _etype1162;
+ xfer += iprot->readListBegin(_etype1162, _size1159);
+ this->success.resize(_size1159);
+ uint32_t _i1163;
+ for (_i1163 = 0; _i1163 < _size1159; ++_i1163)
{
- xfer += this->success[_i1143].read(iprot);
+ xfer += this->success[_i1163].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 _iter1144;
- for (_iter1144 = this->success.begin(); _iter1144 != this->success.end(); ++_iter1144)
+ std::vector<FieldSchema> ::const_iterator _iter1164;
+ for (_iter1164 = this->success.begin(); _iter1164 != this->success.end(); ++_iter1164)
{
- xfer += (*_iter1144).write(oprot);
+ xfer += (*_iter1164).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 _size1145;
- ::apache::thrift::protocol::TType _etype1148;
- xfer += iprot->readListBegin(_etype1148, _size1145);
- (*(this->success)).resize(_size1145);
- uint32_t _i1149;
- for (_i1149 = 0; _i1149 < _size1145; ++_i1149)
+ uint32_t _size1165;
+ ::apache::thrift::protocol::TType _etype1168;
+ xfer += iprot->readListBegin(_etype1168, _size1165);
+ (*(this->success)).resize(_size1165);
+ uint32_t _i1169;
+ for (_i1169 = 0; _i1169 < _size1165; ++_i1169)
{
- xfer += (*(this->success))[_i1149].read(iprot);
+ xfer += (*(this->success))[_i1169].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 _size1150;
- ::apache::thrift::protocol::TType _etype1153;
- xfer += iprot->readListBegin(_etype1153, _size1150);
- this->success.resize(_size1150);
- uint32_t _i1154;
- for (_i1154 = 0; _i1154 < _size1150; ++_i1154)
+ uint32_t _size1170;
+ ::apache::thrift::protocol::TType _etype1173;
+ xfer += iprot->readListBegin(_etype1173, _size1170);
+ this->success.resize(_size1170);
+ uint32_t _i1174;
+ for (_i1174 = 0; _i1174 < _size1170; ++_i1174)
{
- xfer += this->success[_i1154].read(iprot);
+ xfer += this->success[_i1174].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 _iter1155;
- for (_iter1155 = this->success.begin(); _iter1155 != this->success.end(); ++_iter1155)
+ std::vector<FieldSchema> ::const_iterator _iter1175;
+ for (_iter1175 = this->success.begin(); _iter1175 != this->success.end(); ++_iter1175)
{
- xfer += (*_iter1155).write(oprot);
+ xfer += (*_iter1175).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 _size1156;
- ::apache::thrift::protocol::TType _etype1159;
- xfer += iprot->readListBegin(_etype1159, _size1156);
- (*(this->success)).resize(_size1156);
- uint32_t _i1160;
- for (_i1160 = 0; _i1160 < _size1156; ++_i1160)
+ uint32_t _size1176;
+ ::apache::thrift::protocol::TType _etype1179;
+ xfer += iprot->readListBegin(_etype1179, _size1176);
+ (*(this->success)).resize(_size1176);
+ uint32_t _i1180;
+ for (_i1180 = 0; _i1180 < _size1176; ++_i1180)
{
- xfer += (*(this->success))[_i1160].read(iprot);
+ xfer += (*(this->success))[_i1180].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 _size1161;
- ::apache::thrift::protocol::TType _etype1164;
- xfer += iprot->readListBegin(_etype1164, _size1161);
- this->success.resize(_size1161);
- uint32_t _i1165;
- for (_i1165 = 0; _i1165 < _size1161; ++_i1165)
+ uint32_t _size1181;
+ ::apache::thrift::protocol::TType _etype1184;
+ xfer += iprot->readListBegin(_etype1184, _size1181);
+ this->success.resize(_size1181);
+ uint32_t _i1185;
+ for (_i1185 = 0; _i1185 < _size1181; ++_i1185)
{
- xfer += this->success[_i1165].read(iprot);
+ xfer += this->success[_i1185].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 _iter1166;
- for (_iter1166 = this->success.begin(); _iter1166 != this->success.end(); ++_iter1166)
+ std::vector<FieldSchema> ::const_iterator _iter1186;
+ for (_iter1186 = this->success.begin(); _iter1186 != this->success.end(); ++_iter1186)
{
- xfer += (*_iter1166).write(oprot);
+ xfer += (*_iter1186).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 _size1167;
- ::apache::thrift::protocol::TType _etype1170;
- xfer += iprot->readListBegin(_etype1170, _size1167);
- (*(this->success)).resize(_size1167);
- uint32_t _i1171;
- for (_i1171 = 0; _i1171 < _size1167; ++_i1171)
+ uint32_t _size1187;
+ ::apache::thrift::protocol::TType _etype1190;
+ xfer += iprot->readListBegin(_etype1190, _size1187);
+ (*(this->success)).resize(_size1187);
+ uint32_t _i1191;
+ for (_i1191 = 0; _i1191 < _size1187; ++_i1191)
{
- xfer += (*(this->success))[_i1171].read(iprot);
+ xfer += (*(this->success))[_i1191].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 _size1172;
- ::apache::thrift::protocol::TType _etype1175;
- xfer += iprot->readListBegin(_etype1175, _size1172);
- this->primaryKeys.resize(_size1172);
- uint32_t _i1176;
- for (_i1176 = 0; _i1176 < _size1172; ++_i1176)
+ uint32_t _size1192;
+ ::apache::thrift::protocol::TType _etype1195;
+ xfer += iprot->readListBegin(_etype1195, _size1192);
+ this->primaryKeys.resize(_size1192);
+ uint32_t _i1196;
+ for (_i1196 = 0; _i1196 < _size1192; ++_i1196)
{
- xfer += this->primaryKeys[_i1176].read(iprot);
+ xfer += this->primaryKeys[_i1196].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 _size1177;
- ::apache::thrift::protocol::TType _etype1180;
- xfer += iprot->readListBegin(_etype1180, _size1177);
- this->foreignKeys.resize(_size1177);
- uint32_t _i1181;
- for (_i1181 = 0; _i1181 < _size1177; ++_i1181)
+ uint32_t _size1197;
+ ::apache::thrift::protocol::TType _etype1200;
+ xfer += iprot->readListBegin(_etype1200, _size1197);
+ this->foreignKeys.resize(_size1197);
+ uint32_t _i1201;
+ for (_i1201 = 0; _i1201 < _size1197; ++_i1201)
{
- xfer += this->foreignKeys[_i1181].read(iprot);
+ xfer += this->foreignKeys[_i1201].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 _size1182;
- ::apache::thrift::protocol::TType _etype1185;
- xfer += iprot->readListBegin(_etype1185, _size1182);
- this->uniqueConstraints.resize(_size1182);
- uint32_t _i1186;
- for (_i1186 = 0; _i1186 < _size1182; ++_i1186)
+ uint32_t _size1202;
+ ::apache::thrift::protocol::TType _etype1205;
+ xfer += iprot->readListBegin(_etype1205, _size1202);
+ this->uniqueConstraints.resize(_size1202);
+ uint32_t _i1206;
+ for (_i1206 = 0; _i1206 < _size1202; ++_i1206)
{
- xfer += this->uniqueConstraints[_i1186].read(iprot);
+ xfer += this->uniqueConstraints[_i1206].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 _size1187;
- ::apache::thrift::protocol::TType _etype1190;
- xfer += iprot->readListBegin(_etype1190, _size1187);
- this->notNullConstraints.resize(_size1187);
- uint32_t _i1191;
- for (_i1191 = 0; _i1191 < _size1187; ++_i1191)
+ uint32_t _size1207;
+ ::apache::thrift::protocol::TType _etype1210;
+ xfer += iprot->readListBegin(_etype1210, _size1207);
+ this->notNullConstraints.resize(_size1207);
+ uint32_t _i1211;
+ for (_i1211 = 0; _i1211 < _size1207; ++_i1211)
{
- xfer += this->notNullConstraints[_i1191].read(iprot);
+ xfer += this->notNullConstraints[_i1211].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -4594,6 +4594,26 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache::
xfer += iprot->skip(ftype);
}
break;
+ case 6:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->defaultConstraints.clear();
+ uint32_t _size1212;
+ ::apache::thrift::protocol::TType _etype1215;
+ xfer += iprot->readListBegin(_etype1215, _size1212);
+ this->defaultConstraints.resize(_size1212);
+ uint32_t _i1216;
+ for (_i1216 = 0; _i1216 < _size1212; ++_i1216)
+ {
+ xfer += this->defaultConstraints[_i1216].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.defaultConstraints = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
default:
xfer += iprot->skip(ftype);
break;
@@ -4618,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 _iter1192;
- for (_iter1192 = this->primaryKeys.begin(); _iter1192 != this->primaryKeys.end(); ++_iter1192)
+ std::vector<SQLPrimaryKey> ::const_iterator _iter1217;
+ for (_iter1217 = this->primaryKeys.begin(); _iter1217 != this->primaryKeys.end(); ++_iter1217)
{
- xfer += (*_iter1192).write(oprot);
+ xfer += (*_iter1217).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4630,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 _iter1193;
- for (_iter1193 = this->foreignKeys.begin(); _iter1193 != this->foreignKeys.end(); ++_iter1193)
+ std::vector<SQLForeignKey> ::const_iterator _iter1218;
+ for (_iter1218 = this->foreignKeys.begin(); _iter1218 != this->foreignKeys.end(); ++_iter1218)
{
- xfer += (*_iter1193).write(oprot);
+ xfer += (*_iter1218).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4642,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 _iter1194;
- for (_iter1194 = this->uniqueConstraints.begin(); _iter1194 != this->uniqueConstraints.end(); ++_iter1194)
+ std::vector<SQLUniqueConstraint> ::const_iterator _iter1219;
+ for (_iter1219 = this->uniqueConstraints.begin(); _iter1219 != this->uniqueConstraints.end(); ++_iter1219)
{
- xfer += (*_iter1194).write(oprot);
+ xfer += (*_iter1219).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4654,10 +4674,22 @@ 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 _iter1195;
- for (_iter1195 = this->notNullConstraints.begin(); _iter1195 != this->notNullConstraints.end(); ++_iter1195)
+ std::vector<SQLNotNullConstraint> ::const_iterator _iter1220;
+ for (_iter1220 = this->notNullConstraints.begin(); _iter1220 != this->notNullConstraints.end(); ++_iter1220)
+ {
+ xfer += (*_iter1220).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ 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 _iter1221;
+ for (_iter1221 = this->defaultConstraints.begin(); _iter1221 != this->defaultConstraints.end(); ++_iter1221)
{
- xfer += (*_iter1195).write(oprot);
+ xfer += (*_iter1221).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4685,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 _iter1196;
- for (_iter1196 = (*(this->primaryKeys)).begin(); _iter1196 != (*(this->primaryKeys)).end(); ++_iter1196)
+ std::vector<SQLPrimaryKey> ::const_iterator _iter1222;
+ for (_iter1222 = (*(this->primaryKeys)).begin(); _iter1222 != (*(this->primaryKeys)).end(); ++_iter1222)
{
- xfer += (*_iter1196).write(oprot);
+ xfer += (*_iter1222).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4697,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 _iter1197;
- for (_iter1197 = (*(this->foreignKeys)).begin(); _iter1197 != (*(this->foreignKeys)).end(); ++_iter1197)
+ std::vector<SQLForeignKey> ::const_iterator _iter1223;
+ for (_iter1223 = (*(this->foreignKeys)).begin(); _iter1223 != (*(this->foreignKeys)).end(); ++_iter1223)
{
- xfer += (*_iter1197).write(oprot);
+ xfer += (*_iter1223).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4709,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 _iter1198;
- for (_iter1198 = (*(this->uniqueConstraints)).begin(); _iter1198 != (*(this->uniqueConstraints)).end(); ++_iter1198)
+ std::vector<SQLUniqueConstraint> ::const_iterator _iter1224;
+ for (_iter1224 = (*(this->uniqueConstraints)).begin(); _iter1224 != (*(this->uniqueConstraints)).end(); ++_iter1224)
{
- xfer += (*_iter1198).write(oprot);
+ xfer += (*_iter1224).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -4721,10 +4753,22 @@ 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 _iter1199;
- for (_iter1199 = (*(this->notNullConstraints)).begin(); _iter1199 != (*(this->notNullConstraints)).end(); ++_iter1199)
+ std::vector<SQLNotNullConstraint> ::const_iterator _iter1225;
+ for (_iter1225 = (*(this->notNullConstraints)).begin(); _iter1225 != (*(this->notNullConstraints)).end(); ++_iter1225)
+ {
+ xfer += (*_iter1225).write(oprot);
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ 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 _iter1226;
+ for (_iter1226 = (*(this->defaultConstraints)).begin(); _iter1226 != (*(this->defaultConstraints)).end(); ++_iter1226)
{
- xfer += (*_iter1199).write(oprot);
+ xfer += (*_iter1226).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5939,6 +5983,213 @@ uint32_t ThriftHiveMetastore_add_not_null_constraint_presult::read(::apache::thr
}
+ThriftHiveMetastore_add_default_constraint_args::~ThriftHiveMetastore_add_default_constraint_args() throw() {
+}
+
+
+uint32_t ThriftHiveMetastore_add_default_constraint_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_STRUCT) {
+ xfer += this->req.read(iprot);
+ this->__isset.req = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_add_default_constraint_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_default_constraint_args");
+
+ xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->req.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+
+ThriftHiveMetastore_add_default_constraint_pargs::~ThriftHiveMetastore_add_default_constraint_pargs() throw() {
+}
+
+
+uint32_t ThriftHiveMetastore_add_default_constraint_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_default_constraint_pargs");
+
+ xfer += oprot->writeFieldBegin("req", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += (*(this->req)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+
+ThriftHiveMetastore_add_default_constraint_result::~ThriftHiveMetastore_add_default_constraint_result() throw() {
+}
+
+
+uint32_t ThriftHiveMetastore_add_default_constraint_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 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o2.read(iprot);
+ this->__isset.o2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_add_default_constraint_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_default_constraint_result");
+
+ if (this->__isset.o1) {
+ xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->o1.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o2) {
+ xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->o2.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+
+ThriftHiveMetastore_add_default_constraint_presult::~ThriftHiveMetastore_add_default_constraint_presult() throw() {
+}
+
+
+uint32_t ThriftHiveMetastore_add_default_constraint_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 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o2.read(iprot);
+ this->__isset.o2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+
ThriftHiveMetastore_drop_table_args::~ThriftHiveMetastore_drop_table_args() throw() {
}
@@ -6478,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 _size1200;
- ::apache::thrift::protocol::TType _etype1203;
- xfer += iprot->readListBegin(_etype1203, _size1200);
- this->partNames.resize(_size1200);
- uint32_t _i1204;
- for (_i1204 = 0; _i1204 < _size1200; ++_i1204)
+ uint32_t _size1227;
+ ::apache::thrift::protocol::TType _etype1230;
+ xfer += iprot->readListBegin(_etype1230, _size1227);
+ this->partNames.resize(_size1227);
+ uint32_t _i1231;
+ for (_i1231 = 0; _i1231 < _size1227; ++_i1231)
{
- xfer += iprot->readString(this->partNames[_i1204]);
+ xfer += iprot->readString(this->partNames[_i1231]);
}
xfer += iprot->readListEnd();
}
@@ -6522,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 _iter1205;
- for (_iter1205 = this->partNames.begin(); _iter1205 != this->partNames.end(); ++_iter1205)
+ std::vector<std::string> ::const_iterator _iter1232;
+ for (_iter1232 = this->partNames.begin(); _iter1232 != this->partNames.end(); ++_iter1232)
{
- xfer += oprot->writeString((*_iter1205));
+ xfer += oprot->writeString((*_iter1232));
}
xfer += oprot->writeListEnd();
}
@@ -6557,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 _iter1206;
- for (_iter1206 = (*(this->partNames)).begin(); _iter1206 != (*(this->partNames)).end(); ++_iter1206)
+ std::vector<std::string> ::const_iterator _iter1233;
+ for (_iter1233 = (*(this->partNames)).begin(); _iter1233 != (*(this->partNames)).end(); ++_iter1233)
{
- xfer += oprot->writeString((*_iter1206));
+ xfer += oprot->writeString((*_iter1233));
}
xfer += oprot->writeListEnd();
}
@@ -6804,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 _size1207;
- ::apache::thrift::protocol::TType _etype1210;
- xfer += iprot->readListBegin(_etype1210, _size1207);
- this->success.resize(_size1207);
- uint32_t _i1211;
- for (_i1211 = 0; _i1211 < _size1207; ++_i1211)
+ uint32_t _size1234;
+ ::apache::thrift::protocol::TType _etype1237;
+ xfer += iprot->readListBegin(_etype1237, _size1234);
+ this->success.resize(_size1234);
+ uint32_t _i1238;
+ for (_i1238 = 0; _i1238 < _size1234; ++_i1238)
{
- xfer += iprot->readString(this->success[_i1211]);
+ xfer += iprot->readString(this->success[_i1238]);
}
xfer += iprot->readListEnd();
}
@@ -6850,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 _iter1212;
- for (_iter1212 = this->success.begin(); _iter1212 != this->success.end(); ++_iter1212)
+ std::vector<std::string> ::const_iterator _iter1239;
+ for (_iter1239 = this->success.begin(); _iter1239 != this->success.end(); ++_iter1239)
{
- xfer += oprot->writeString((*_iter1212));
+ xfer += oprot->writeString((*_iter1239));
}
xfer += oprot->writeListEnd();
}
@@ -6898,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 _size1213;
- ::apache::thrift::protocol::TType _etype1216;
- xfer += iprot->readListBegin(_etype1216, _size1213);
- (*(this->success)).resize(_size1213);
- uint32_t _i1217;
- for (_i1217 = 0; _i1217 < _size1213; ++_i1217)
+ uint32_t _size1240;
+ ::apache::thrift::protocol::TType _etype1243;
+ xfer += iprot->readListBegin(_etype1243, _size1240);
+ (*(this->success)).resize(_size1240);
+ uint32_t _i1244;
+ for (_i1244 = 0; _i1244 < _size1240; ++_i1244)
{
- xfer += iprot->readString((*(this->success))[_i1217]);
+ xfer += iprot->readString((*(this->success))[_i1244]);
}
xfer += iprot->readListEnd();
}
@@ -7075,14 +7326,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::read(::apache::thrift::p
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1218;
- ::apache::thrift::protocol::TType _etype1221;
- xfer += iprot->readListBegin(_etype1221, _size1218);
- this->success.resize(_size1218);
- uint32_t _i1222;
- for (_i1222 = 0; _i1222 < _size1218; ++_i1222)
+ uint32_t _size1245;
+ ::apache::thrift::protocol::TType _etype1248;
+ xfer += iprot->readListBegin(_etype1248, _size1245);
+ this->success.resize(_size1245);
+ uint32_t _i1249;
+ for (_i1249 = 0; _i1249 < _size1245; ++_i1249)
{
- xfer += iprot->readString(this->success[_i1222]);
+ xfer += iprot->readString(this->success[_i1249]);
}
xfer += iprot->readListEnd();
}
@@ -7121,10 +7372,10 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_result::write(::apache::thrift::
xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
- std::vector<std::string> ::const_iterator _iter1223;
- for (_iter1223 = this->success.begin(); _iter1223 != this->success.end(); ++_iter1223)
+ std::vector<std::string> ::const_iterator _iter1250;
+ for (_iter1250 = this->success.begin(); _iter1250 != this->success.end(); ++_iter1250)
{
- xfer += oprot->writeString((*_iter1223));
+ xfer += oprot->writeString((*_iter1250));
}
xfer += oprot->writeListEnd();
}
@@ -7169,14 +7420,14 @@ uint32_t ThriftHiveMetastore_get_tables_by_type_presult::read(::apache::thrift::
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size1224;
- ::apache::thrift::protocol::TType _etype1227;
- xfer += iprot->readListBegin(_etype1227, _size1224);
- (*(this->success)).resize(_size1224);
- uint32_t _i1228;
- for (_i1228 = 0; _i1228 < _size1224; ++_i1228)
+ uint32_t _size1251;
+ ::apache::thrift::protocol::TType _etype1254;
+ xfer += iprot->readListBegin(_etype1254, _size1251);
+ (*(this->success)).resize(_size1251);
+ uint32_t _i1255;
+ for (_i1255 = 0; _i1255 < _size1251; ++_i1255)
{
- xfer += iprot->readString((*(this->success))[_i1228]);
+ xfer += iprot->readString((*(this->success))[_i1255]);
}
xfer += iprot->readListEnd();
}
@@ -7314,14 +7565,14 @@ uint32_t ThriftHiveMetastore_get_materialized_views_for_rewriting_result::read(:
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size1229;
- ::apache::thrift::protocol::TType _etype1232;
- xfer += iprot->readListBegin(_etype1232, _size1229);
- this->success.resize(_size1229);
- uint32_t _i1233;
- for (_i1233 = 0; _i1233 < _size1229; ++_i1233)
+ uint32_t _size1256;
+ ::apache::thrift::protocol::TType _etype1259;
+ xfer += iprot->readListBegin(_etype1259, _size1256);
+ this->success.resize(_size1256);
+ uint32_t _i1260;
+ for (_i1260 = 0; _i1260 < _size1256; ++_i1260)
{
- xfer += iprot->readString(this->success[_i1233]);
+ xfer += iprot->readString(this->success[_i1260]);
}
xfer += iprot->readListEnd();
}
@@ -7360,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 _iter1234;
- for (_iter1234 = this->success.begin(); _iter1234 != this->success.end(); ++_iter1234)
+ std::vector<std::string> ::const_iterator _iter1261;
+ for (_iter1261 = this->success.begin(); _iter1261 != this->success.end(); ++_iter1261)
{
- xfer += oprot->writeString((*_iter1234));
+ xfer += oprot->writeString((*_iter1261));
}
xfer += oprot->writeListEnd();
}
@@ -7408,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 _size1235;
- ::apache::thrift::protocol::TType _etype1238;
- xfer += iprot->readListBegin(_etype1238, _size1235);
- (*(this->success)).resize(_size1235);
- uint32_t _i1239;
- for (_i1239 = 0; _i1239 < _size1235; ++_i1239)
+ uint32_t _size1262;
+ ::apache::thrift::protocol::TType _etype1265;
+ xfer += iprot->readListBegin(_etype1265, _size1262);
+ (*(this->success)).resize(_size1262);
+ uint32_t _i1266;
+ for (_i1266 = 0; _i1266 < _size1262; ++_i1266)
{
- xfer += iprot->readString((*(this->success))[_i1239]);
+ xfer += iprot->readString((*(this->success))[_i1266]);
}
xfer += iprot->readListEnd();
}
@@ -7490,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 _size1240;
- ::apache::thrift::protocol::TType _etype1243;
- xfer += iprot->readListBegin(_etype1243, _size1240);
- this->tbl_types.resize(_size1240);
- uint32_t _i1244;
- for (_i1244 = 0; _i1244 < _size1240; ++_i1244)
+ uint32_t _size1267;
+ ::apache::thrift::protocol::TType _etype1270;
+ xfer += iprot->readListBegin(_etype1270, _size1267);
+ this->tbl_types.resize(_size1267);
+ uint32_t _i1271;
+ for (_i1271 = 0; _i1271 < _size1267; ++_i1271)
{
- xfer += iprot->readString(this->tbl_types[_i1244]);
+ xfer += iprot->readString(this->tbl_types[_i1271]);
}
xfer += iprot->readListEnd();
}
@@ -7534,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 _iter1245;
- for (_iter1245 = this->tbl_types.begin(); _iter1245 != this->tbl_types.end(); ++_iter1245)
+ std::vector<std::string> ::const_iterator _iter1272;
+ for (_iter1272 = this->tbl_types.begin(); _iter1272 != this->tbl_types.end(); ++_iter1272)
{
- xfer += oprot->writeString((*_iter1245));
+ xfer += oprot->writeString((*_iter1272));
}
xfer += oprot->writeListEnd();
}
@@ -7569,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 _iter1246;
- for (_iter1246 = (*(this->tbl_types)).begin(); _iter1246 != (*(this->tbl_types)).end(); ++_iter1246)
+ std::vector<std::string> ::const_iterator _iter1273;
+ for (_iter1273 = (*(this->tbl_types)).begin(); _iter1273 != (*(this->tbl_types)).end(); ++_iter1273)
{
- xfer += oprot->writeString((*_iter1246));
+ xfer += oprot->writeString((*_iter1273));
}
xfer += oprot->writeListEnd();
}
@@ -7613,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 _size1247;
- ::apache::thrift::protocol::TType _etype1250;
- xfer += iprot->readListBegin(_etype1250, _size1247);
- this->success.resize(_size1247);
- uint32_t _i1251;
- for (_i1251 = 0; _i1251 < _size1247; ++_i1251)
+ uint32_t _size1274;
+ ::apache::thrift::protocol::TType _etype1277;
+ xfer += iprot->readListBegin(_etype1277, _size1274);
+ this->success.resize(_size1274);
+ uint32_t _i1278;
+ for (_i1278 = 0; _i1278 < _size1274; ++_i1278)
{
- xfer += this->success[_i1251].read(iprot);
+ xfer += this->success[_i1278].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -7659,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 _iter1252;
- for (_iter1252 = this->success.begin(); _iter1252 != this->success.end(); ++_iter1252)
+ std::vector<TableMeta> ::const_iterator _iter1279;
+ for (_iter1279 = this->success.begin(); _iter1279 != this->success.end(); ++_iter1279)
{
- xfer += (*_iter1252).write(oprot);
+ xfer += (*_iter1279).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -7707,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 _size1253;
- ::apache::thrift::protocol::TType _etype1256;
- xfer += iprot->readListBegin(_etype1256, _size1253);
- (*(this->success)).resize(_size1253);
- uint32_t _i1257;
- for (_i1257 = 0; _i1257 < _size1253; ++_i1257)
+ uint32_t _size1280;
+ ::apache::thrift::protocol::TType _etype1283;
+ xfer += iprot->readListBegin(_etype1283, _size1280);
+ (*(this->success)).resize(_size1280);
+ uint32_t _i1284;
+ for (_i1284 = 0; _i1284 < _size1280; ++_i1284)
{
- xfer += (*(this->success))[_i1257].read(iprot);
+ xfer += (*(this->success))[_i1284].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -7852,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 _size1258;
- ::apache::thrift::protocol::TType _etype1261;
- xfer += iprot->readListBegin(_etype1261, _size1258);
- this->success.resize(_size1258);
- uint32_t _i1262;
- for (_i1262 = 0; _i1262 < _size1258; ++_i1262)
+ uint32_t _size1285;
+ ::apache::thrift::protocol::TType _etype1288;
+ xfer += iprot->readListBegin(_etype1288, _size1285);
+ this->success.resize(_size1285);
+ uint32_t _i1289;
+ for (_i1289 = 0; _i1289 < _size1285; ++_i1289)
{
- xfer += iprot->readString(this->success[_i1262]);
+ xfer += iprot->readString(this->success[_i1289]);
}
xfer += iprot->readListEnd();
}
@@ -7898,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 _iter1263;
- for (_iter1263 = this->success.begin(); _iter1263 != this->success.end(); ++_iter1263)
+ std::vector<std::string> ::const_iterator _iter1290;
+ for (_iter1290 = this->success.begin(); _iter1290 != this->success.end(); ++_iter1290)
{
- xfer += oprot->writeString((*_iter1263));
+ xfer += oprot->writeString((*_iter1290));
}
xfer += oprot->writeListEnd();
}
@@ -7946,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 _size1264;
- ::apache::thrift::protocol::TType _etype1267;
- xfer += iprot->readListBegin(_etype1267, _size1264);
- (*(this->success)).resize(_size1264);
- uint32_t _i1268;
- for (_i1268 = 0; _i1268 < _size1264; ++_i1268)
+ 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)
{
- xfer += iprot->readString((*(this->success))[_i1268]);
+ xfer += iprot->readString((*(this->success))[_i1295]);
}
xfer += iprot->readListEnd();
}
@@ -8263,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 _size1269;
- ::apache::thrift::protocol::TType _etype1272;
- xfer += iprot->readListBegin(_etype1272, _size1269);
- this->tbl_names.resize(_size1269);
- uint32_t _i1273;
- for (_i1273 = 0; _i1273 < _size1269; ++_i1273)
+ uint32_t _size1296;
+ ::apache::thrift::protocol::TType _etype1299;
+ xfer += iprot->readListBegin(_etype1299, _size1296);
+ this->tbl_names.resize(_size1296);
+ uint32_t _i1300;
+ for (_i1300 = 0; _i1300 < _size1296; ++_i1300)
{
- xfer += iprot->readString(this->tbl_names[_i1273]);
+ xfer += iprot->readString(this->tbl_names[_i1300]);
}
xfer += iprot->readListEnd();
}
@@ -8303,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 _iter1274;
- for (_iter1274 = this->tbl_names.begin(); _iter1274 != this->tbl_names.end(); ++_iter1274)
+ std::vector<std::string> ::const_iterator _iter1301;
+ for (_iter1301 = this->tbl_names.begin(); _iter1301 != this->tbl_names.end(); ++_iter1301)
{
- xfer += oprot->writeString((*_iter1274));
+ xfer += oprot->writeString((*_iter1301));
}
xfer += oprot->writeListEnd();
}
@@ -8334,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 _iter1275;
- for (_iter1275 = (*(this->tbl_names)).begin(); _iter1275 != (*(this->tbl_names)).end(); ++_iter1275)
+ std::vector<std::string> ::const_iterator _iter1302;
+ for (_iter1302 = (*(this->tbl_names)).begin(); _iter1302 != (*(this->tbl_names)).end(); ++_iter1302)
{
- xfer += oprot->writeString((*_iter1275));
+ xfer += oprot->writeString((*_iter1302));
}
xfer += oprot->writeListEnd();
}
@@ -8378,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 _size1276;
- ::apache::thrift::protocol::TType _etype1279;
- xfer += iprot->readListBegin(_etype1279, _size1276);
- this->success.resize(_size1276);
- uint32_t _i1280;
- for (_i1280 = 0; _i1280 < _size1276; ++_i1280)
+ uint32_t _size1303;
+ ::apache::thrift::protocol::TType _etype1306;
+ xfer += iprot->readListBegin(_etype1306, _size1303);
+ this->success.resize(_size1303);
+ uint32_t _i1307;
+ for (_i1307 = 0; _i1307 < _size1303; ++_i1307)
{
- xfer += this->success[_i1280].read(iprot);
+ xfer += this->success[_i1307].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -8416,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 _iter1281;
- for (_iter1281 = this->success.begin(); _iter1281 != this->success.end(); ++_iter1281)
+ std::vector<Table> ::const_iterator _iter1308;
+ for (_iter1308 = this->success.begin(); _iter1308 != this->success.end(); ++_iter1308)
{
- xfer += (*_iter1281).write(oprot);
+ xfer += (*_iter1308).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -8460,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 _size1282;
- ::apache::thrift::protocol::TType _etype1285;
- xfer += iprot->readListBegin(_etype1285, _size1282);
- (*(this->success)).resize(_size1282);
- uint32_t _i1286;
- for (_i1286 = 0; _i1286 < _size1282; ++_i1286)
+ uint32_t _size1309;
+ ::apache::thrift::protocol::TType _etype1312;
+ xfer += iprot->readListBegin(_etype1312, _size1309);
+ (*(this->success)).resize(_size1309);
+ uint32_t _i1313;
+ for (_i1313 = 0; _i1313 < _size1309; ++_i1313)
{
- xfer += (*(this->success))[_i1286].read(iprot);
+ xfer += (*(this->success))[_i1313].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -9000,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 _size1287;
- ::apache::thrift::protocol::TType _etype1290;
- xfer += iprot->readListBegin(_etype1290, _size1287);
- this->tbl_names.resize(_size1287);
- uint32_t _i1291;
- for (_i1291 = 0; _i1291 < _size1287; ++_i1291)
+ uint32_t _size1314;
+ ::apache::thrift::protocol::TType _etype1317;
+ xfer += iprot->readListBegin(_etype1317, _size1314);
+ this->tbl_names.resize(_size1314);
+ uint32_t _i1318;
+ for (_i1318 = 0; _i1318 < _size1314; ++_i1318)
{
- xfer += iprot->readString(this->tbl_names[_i1291]);
+ xfer += iprot->readString(this->tbl_names[_i1318]);
}
xfer += iprot->readListEnd();
}
@@ -9040,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 _iter1292;
- for (_iter1292 = this->tbl_names.begin(); _iter1292 != this->tbl_names.end(); ++_iter1292)
+ std::vector<std::string> ::const_iterator _iter1319;
+ for (_iter1319 = this->tbl_names.begin(); _iter1319 != this->tbl_names.end(); ++_iter1319)
{
- xfer += oprot->writeString((*_iter1292));
+ xfer += oprot->writeString((*_iter1319));
}
xfer += oprot->writeListEnd();
}
@@ -9071,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 _iter1293;
- for (_iter1293 = (*(this->tbl_names)).begin(); _iter1293 != (*(this->tbl_names)).end(); ++_iter1293)
+ std::vector<std::string> ::const_iterator _iter1320;
+ for (_iter1320 = (*(this->tbl_names)).begin(); _iter1320 != (*(this->tbl_names)).end(); ++_iter1320)
{
- xfer += oprot->writeString((*_iter1293));
+ xfer += oprot->writeString((*_iter1320));
}
xfer += oprot->writeListEnd();
}
@@ -9115,17 +9366,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_result::read(
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
this->success.clear();
- uint32_t _size1294;
- ::apache::thrift::protocol::TType _ktype1295;
- ::apache::thrift::protocol::TType _vtype1296;
- xfer += iprot->readMapBegin(_ktype1295, _vtype1296, _size1294);
- uint32_t _i1298;
- for (_i1298 = 0; _i1298 < _size1294; ++_i1298)
+ uint32_t _size1321;
+ ::apache::thrift::protocol::TType _ktype1322;
+ ::apache::thrift::protocol::TType _vtype1323;
+ xfer += iprot->readMapBegin(_ktype1322, _vtype1323, _size1321);
+ uint32_t _i1325;
+ for (_i1325 = 0; _i1325 < _size1321; ++_i1325)
{
- std::string _key1299;
- xfer += iprot->readString(_key1299);
- Materialization& _val1300 = this->success[_key1299];
- xfer += _val1300.read(iprot);
+ std::string _key1326;
+ xfer += iprot->readString(_key1326);
+ Materialization& _val1327 = this->success[_key1326];
+ xfer += _val1327.read(iprot);
}
xfer += iprot->readMapEnd();
}
@@ -9180,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 _iter1301;
- for (_iter1301 = this->success.begin(); _iter1301 != this->success.end(); ++_iter1301)
+ std::map<std::string, Materialization> ::const_iterator _iter1328;
+ for (_iter1328 = this->success.begin(); _iter1328 != this->success.end(); ++_iter1328)
{
- xfer += oprot->writeString(_iter1301->first);
- xfer += _iter1301->second.write(oprot);
+ xfer += oprot->writeString(_iter1328->first);
+ xfer += _iter1328->second.write(oprot);
}
xfer += oprot->writeMapEnd();
}
@@ -9237,17 +9488,17 @@ uint32_t ThriftHiveMetastore_get_materialization_invalidation_info_presult::read
if (ftype == ::apache::thrift::protocol::T_MAP) {
{
(*(this->success)).clear();
- uint32_t _size1302;
- ::apache::thrift::protocol::TType _ktype1303;
- ::apache::thrift::protocol::TType _vtype1304;
- xfer += iprot->readMapBegin(_ktype1303, _vtype1304, _size1302);
- uint32_t _i1306;
- for (_i1306 = 0; _i1306 < _size1302; ++_i1306)
+ uint32_t _size1329;
+ ::apache::thrift::protocol::TType _ktype1330;
+ ::apache::thrift::protocol::TType _vtype1331;
+ xfer += iprot->readMapBegin(_ktype1330, _vtype1331, _size1329);
+ uint32_t _i1333;
+ for (_i1333 = 0; _i1333 < _size1329; ++_i1333)
{
- std::string _key1307;
- xfer += iprot->readString(_key1307);
- Materialization& _val1308 = (*(this->success))[_key1307];
- xfer += _val1308.read(iprot);
+ std::string _key1334;
+ xfer += iprot->readString(_key1334);
+ Materialization& _val1335 = (*(this->success))[_key1334];
+ xfer += _val1335.read(iprot);
}
xfer += iprot->readMapEnd();
}
@@ -9692,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 _size1309;
- ::apache::thrift::protocol::TType _etype1312;
- xfer += iprot->readListBegin(_etype1312, _size1309);
- this->success.resize(_size1309);
- uint32_t _i1313;
- for (_i1313 = 0; _i1313 < _size1309; ++_i1313)
+ uint32_t _size1336;
+ ::apache::thrift::protocol::TType _etype1339;
+ xfer += iprot->readListBegin(_etype1339, _size1336);
+ this->success.resize(_size1336);
+ uint32_t _i1340;
+ for (_i1340 = 0; _i1340 < _size1336; ++_i1340)
{
- xfer += iprot->readString(this->success[_i1313]);
+ xfer += iprot->readString(this->success[_i1340]);
}
xfer += iprot->readListEnd();
}
@@ -9754,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 _iter1314;
- for (_iter1314 = this->success.begin(); _iter1314 != this->success.end(); ++_iter1314)
+ std::vector<std::string> ::const_iterator _iter1341;
+ for (_iter1341 = this->success.begin(); _iter1341 != this->success.end(); ++_iter1341)
{
- xfer += oprot->writeString((*_iter1314));
+ xfer += oprot->writeString((*_iter1341));
}
xfer += oprot->writeListEnd();
}
@@ -9810,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 _size1315;
- ::apache::thrift::protocol::TType _etype1318;
- xfer += iprot->readListBegin(_etype1318, _size1315);
- (*(this->success)).resize(_size1315);
- uint32_t _i1319;
- for (_i1319 = 0; _i1319 < _size1315; ++_i1319)
+ uint32_t _size1342;
+ ::apache::thrift::protocol::TType _etype1345;
+ xfer += iprot->readListBegin(_etype1345, _size1342);
+ (*(this->success)).resize(_size1342);
+ uint32_t _i1346;
+ for (_i1346 = 0; _i1346 < _size1342; ++_i1346)
{
- xfer += iprot->readString((*(this->success))[_i1319]);
+ xfer += iprot->readString((*(this->success))[_i1346]);
}
xfer += iprot->readListEnd();
}
@@ -11151,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 _size1320;
- ::apache::thrift::protocol::TType _etype1323;
- xfer += iprot->readListBegin(_etype1323, _size1320);
- this->new_parts.resize(_size1320);
- uint32_t _i1324;
- for (_i1324 = 0; _i1324 < _size1320; ++_i1324)
+ uint32_t _size1347;
+ ::apache::thrift::protocol::TType _etype1350;
+ xfer += iprot->readListBegin(_etype1350, _size1347);
+ this->new_parts.resize(_size1347);
+ uint32_t _i1351;
+ for (_i1351 = 0; _i1351 < _size1347; ++_i1351)
{
- xfer += this->new_parts[_i1324].read(iprot);
+ xfer += this->new_parts[_i1351].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11187,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 _iter1325;
- for (_iter1325 = this->new_parts.begin(); _iter1325 != this->new_parts.end(); ++_iter1325)
+ std::vector<Partition> ::const_iterator _iter1352;
+ for (_iter1352 = this->new_parts.begin(); _iter1352 != this->new_parts.end(); ++_iter1352)
{
- xfer += (*_iter1325).write(oprot);
+ xfer += (*_iter1352).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11214,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 _iter1326;
- for (_iter1326 = (*(this->new_parts)).begin(); _iter1326 != (*(this->new_parts)).end(); ++_iter1326)
+ std::vector<Partition> ::const_iterator _iter1353;
+ for (_iter1353 = (*(this->new_parts)).begin(); _iter1353 != (*(this->new_parts)).end(); ++_iter1353)
{
- xfer += (*_iter1326).write(oprot);
+ xfer += (*_iter1353).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11426,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 _size1327;
- ::apache::thrift::protocol::TType _etype1330;
- xfer += iprot->readListBegin(_etype1330, _size1327);
- this->new_parts.resize(_size1327);
- uint32_t _i1331;
- for (_i1331 = 0; _i1331 < _size1327; ++_i1331)
+ uint32_t _size1354;
+ ::apache::thrift::protocol::TType _etype1357;
+ xfer += iprot->readListBegin(_etype1357, _size1354);
+ this->new_parts.resize(_size1354);
+ uint32_t _i1358;
+ for (_i1358 = 0; _i1358 < _size1354; ++_i1358)
{
- xfer += this->new_parts[_i1331].read(iprot);
+ xfer += this->new_parts[_i1358].read(iprot);
}
xfer += iprot->readListEnd();
}
@@ -11462,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 _iter1332;
- for (_iter1332 = this->new_parts.begin(); _iter1332 != this->new_parts.end(); ++_iter1332)
+ std::vector<PartitionSpec> ::const_iterator _iter1359;
+ for (_iter1359 = this->new_parts.begin(); _iter1359 != this->new_parts.end(); ++_iter1359)
{
- xfer += (*_iter1332).write(oprot);
+ xfer += (*_iter1359).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11489,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 _iter1333;
- for (_iter1333 = (*(this->new_parts)).begin(); _iter1333 != (*(this->new_parts)).end(); ++_iter1333)
+ std::vector<PartitionSpec> ::const_iterator _iter1360;
+ for (_iter1360 = (*(this->new_parts)).begin(); _iter1360 != (*(this->new_parts)).end(); ++_iter1360)
{
- xfer += (*_iter1333).write(oprot);
+ xfer += (*_iter1360).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -11717,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 _size1334;
- ::apache::thrift::protocol::TType _etype1337;
- xfer += iprot->readListBegin(_etype1337, _size1334);
- this->part_vals.resize(_size1334);
- uint32_t _i1338;
- for (_i1338 = 0; _i1338 < _size1334; ++_i1338)
+ uint32_t _size1361;
+ ::apache::thrift::protocol::TType _etype1364;
+ xfer += iprot->readListBegin(_etype1364, _size1361);
+ this->part_vals.resize(_size1361);
+ uint32_t _i1365;
+ for (_i1365 = 0; _i1365 < _size1361; ++_i1365)
{
- xfer += iprot->readString(this->part_vals[_i1338]);
+ xfer += iprot->readString(this->part_vals[_i1365]);
}
xfer += iprot->readListEnd();
}
@@ -11761,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 _iter1339;
- for (_iter1339 = this->part_vals.begin(); _iter1339 != this->part_vals.end(); ++_iter1339)
+ std::vector<std::string> ::const_iterator _iter1366;
+ for (_iter1366 = this->part_vals.begin(); _iter1366 != this->part_vals.end(); ++_iter1366)
{
- xfer += oprot->writeString((*_iter1339));
+ xfer += oprot->writeString((*_iter1366));
}
xfer += oprot->writeListEnd();
}
@@ -11796,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 _iter1340;
- for (_iter1340 = (*(this->part_vals)).begin(); _iter1340 != (*(this->part_vals)).end(); ++_iter1340)
+ std::vector<std::string> ::const_iterator _iter1367;
+ for (_iter1367 = (*(this->part_vals)).begin(); _iter1367 != (*(this->part_vals)).end(); ++_iter1367)
{
- xfer += oprot->writeString((*_iter1340));
+ xfer += oprot->writeString((*_iter1367));
}
xfer += oprot->writeListEnd();
}
@@ -12271,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 _size1341;
- ::apache::thrift::protocol::TType _etype1344;
- xfer += iprot->readListBegin(_etype1344, _size1341);
- this->part_vals.resize(_size1341);
- uint32_t _i1345;
- for (_i1345 = 0; _i1345 < _size1341; ++_i1345)
+ uint32_t _size1368;
+ ::apache::thrift::protocol::TType _etype1371;
+ xfer += iprot->readListBegin(_etype1371, _size1368);
+ this->part_vals.resize(_size1368);
+ uint32_t _i1372;
+ for (_i1372 = 0; _i1372 < _size1368; ++_i1372)
{
- xfer += iprot->readString(this->part_vals[_i1345]);
+ xfer += iprot->readString(this->part_vals[_i1372]);
}
xfer += iprot->readListEnd();
}
@@ -12323,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 _iter1346;
- for (_iter1346 = this->part_vals.begin(); _iter1346 != this->part_vals.end(); ++_iter1346)
+ std::vector<std::string> ::const_iterator _iter1373;
+ for (_iter1373 = this->part_vals.begin(); _iter1373 != this->part_vals.end(); ++_iter1373)
{
- xfer += oprot->writeString((*_iter1346));
+ xfer += oprot->writeString((*_iter1373));
}
xfer += oprot->writeListEnd();
}
@@ -12362,10 +12613,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_pargs::wr
xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter1347;
- for (_iter1347 = (*(this->part_vals)).begin(); _iter1347 != (*(this->part_vals)).end(); ++_iter1347)
+ std::vector<std::string> ::const_iterator _iter1374;
+ for (_iter1374 = (*(this->part_vals)).begin(); _iter1374 != (*(this->part_vals)).end(); ++_iter1374)
{
- xfer += oprot->writeString((*_iter1347));
+ xfer += oprot->writeString((*_iter1374));
}
xfer += oprot->writeListEnd();
}
@@ -13168,14 +13419,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size1348;
- ::apache::thrift::protocol::TType _etype1351;
- xfer += iprot->readListBegin(_etype1351, _size1348);
- this->part_vals.resize(_size1348);
- uint32_t _i1352;
- for (_i1352 = 0; _i1352 < _size1348; ++_i1352)
+ uint32_t _size1375;
+ ::apache::thrift::protocol::TType _etype1378;
+ xfer += iprot->readListBegin(_etype1378, _size1375);
+ this->part_vals.resize(_size1375);
+ uint32_t _i1379;
+ for (_i1379 = 0; _i1379 < _size1375; ++_i1379)
{
- xfer += iprot->readString(this->part_vals[_i1352]);
+ xfer += iprot->readString(this->part_vals[_i1379]);
}
xfer += iprot->readListEnd();
}
@@ -13220,10 +13471,10 @@ uint32_t ThriftHiveMetastore_drop_partition_args::write(::apache::thrift::protoc
xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::vector<std::string> ::const_iterator _iter1353;
- for (_iter1353 = this->part_vals.begin(); _iter1353 != this->part_vals.end(); ++_iter1353)
+ std::vector<std::string> ::const_iterator _iter1380;
+ for (_iter1380 = this->part_vals.begin(); _iter1380 != this->part_vals.end(); ++_iter1380)
{
- xfer += oprot->writeString((*_iter1353));
+ xfer += oprot->writeString((*_iter1380));
}
xfer += oprot->writeListEnd();
}
@@ -13259,10 +13510,10 @@ uint32_t ThriftHiveMetastore_drop_partition_pargs::write(::apache::thrift::proto
xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter1354;
- for (_iter1354 = (*(this->part_vals)).begin(); _iter1354 != (*(this->part_vals)).end(); ++_iter1354)
+ std::vector<std::string> ::const_iterator _iter1381;
+ for (_iter1381 = (*(this->part_vals)).begin(); _iter1381 != (*(this->part_vals)).end(); ++_iter1381)
{
- xfer += oprot->writeString((*_iter1354));
+ xfer += oprot->writeString((*_iter1381));
}
xfer += oprot->writeListEnd();
}
@@ -13471,14 +13722,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read(
if (ftype == ::apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size1355;
- ::apache::thrift::protocol::TType _etype1358;
- xfer += iprot->readListBegin(_etype1358, _size1355);
- this->part_vals.resize(_size1355);
- uint32_t _i1359;
- for (_i1359 = 0; _i1359 < _size1355; ++_i1359)
+ uint32_t _size1382;
+ ::apache::thrift::protocol::TType _etype1385;
+ xfer += iprot->readListBegin(_etype1385, _size1382);
+ this->part_vals.resize(_size1382);
+ uint32_t _i1386;
+ for (_i1386 = 0; _i1386 < _size1382; ++_i1386)
{
- xfer += iprot->readString(this->part_vals[_i1359]);
+ xfer += iprot->readString(this->part_vals[_i1386]);
}
xfer += iprot->readListEnd();
}
@@ -13531,10 +13782,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::write
xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::vector<std::string> ::const_iterator _iter1360;
- for (_iter1360 = this->part_vals.begin(); _iter1360 != this->part_vals.end(); ++_iter1360)
+ std::vector<std::string> ::const_iterator _iter1387;
+ for (_iter1387 = this->part_vals.begin(); _iter1387 != this->part_vals.end(); ++_iter1387)
{
- xfer += oprot->writeString((*_iter1360));
+ xfer += oprot->writeString((*_iter1387));
}
xfer += oprot->writeListEnd();
}
@@ -13574,10 +13825,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_pargs::writ
xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter1361;
- for (_iter1361 = (*(this->part_vals)).begin(); _iter1361 != (*(this->part_vals)).end(); ++_iter1361)
+ std::vector<std::string> ::const_iterator _iter1388;
+ for (_iter1388 = (*(this->part_vals)).begin(); _iter1388 != (*(this->part_vals)).end(); ++_iter1388)
{
- xfer += oprot->writeString((*_iter1361));
+ xfer += oprot->writeString((*_iter1388));
}
xfer += oprot->writeListEnd();
}
@@ -14583,14 +14834,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::r
<TRUNCATED>