You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@hive.apache.org by jv...@apache.org on 2010/07/30 08:40:11 UTC
svn commit: r980659 [2/34] - in /hadoop/hive/trunk: ./
common/src/java/org/apache/hadoop/hive/common/
contrib/src/test/results/clientpositive/ metastore/if/ metastore/src/gen-cpp/
metastore/src/gen-javabean/org/apache/hadoop/hive/metastore/api/ metasto...
Modified: hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore.cpp
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore.cpp?rev=980659&r1=980658&r2=980659&view=diff
==============================================================================
--- hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore.cpp (original)
+++ hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore.cpp Fri Jul 30 06:40:04 2010
@@ -667,14 +667,14 @@ uint32_t ThriftHiveMetastore_get_databas
if (ftype == apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size88;
- apache::thrift::protocol::TType _etype91;
- iprot->readListBegin(_etype91, _size88);
- this->success.resize(_size88);
- uint32_t _i92;
- for (_i92 = 0; _i92 < _size88; ++_i92)
+ uint32_t _size90;
+ apache::thrift::protocol::TType _etype93;
+ iprot->readListBegin(_etype93, _size90);
+ this->success.resize(_size90);
+ uint32_t _i94;
+ for (_i94 = 0; _i94 < _size90; ++_i94)
{
- xfer += iprot->readString(this->success[_i92]);
+ xfer += iprot->readString(this->success[_i94]);
}
iprot->readListEnd();
}
@@ -713,10 +713,10 @@ uint32_t ThriftHiveMetastore_get_databas
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, this->success.size());
- std::vector<std::string> ::const_iterator _iter93;
- for (_iter93 = this->success.begin(); _iter93 != this->success.end(); ++_iter93)
+ std::vector<std::string> ::const_iterator _iter95;
+ for (_iter95 = this->success.begin(); _iter95 != this->success.end(); ++_iter95)
{
- xfer += oprot->writeString((*_iter93));
+ xfer += oprot->writeString((*_iter95));
}
xfer += oprot->writeListEnd();
}
@@ -755,14 +755,14 @@ uint32_t ThriftHiveMetastore_get_databas
if (ftype == apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size94;
- apache::thrift::protocol::TType _etype97;
- iprot->readListBegin(_etype97, _size94);
- (*(this->success)).resize(_size94);
- uint32_t _i98;
- for (_i98 = 0; _i98 < _size94; ++_i98)
+ uint32_t _size96;
+ apache::thrift::protocol::TType _etype99;
+ iprot->readListBegin(_etype99, _size96);
+ (*(this->success)).resize(_size96);
+ uint32_t _i100;
+ for (_i100 = 0; _i100 < _size96; ++_i100)
{
- xfer += iprot->readString((*(this->success))[_i98]);
+ xfer += iprot->readString((*(this->success))[_i100]);
}
iprot->readListEnd();
}
@@ -1451,17 +1451,17 @@ uint32_t ThriftHiveMetastore_get_type_al
if (ftype == apache::thrift::protocol::T_MAP) {
{
this->success.clear();
- uint32_t _size99;
- apache::thrift::protocol::TType _ktype100;
- apache::thrift::protocol::TType _vtype101;
- iprot->readMapBegin(_ktype100, _vtype101, _size99);
- uint32_t _i103;
- for (_i103 = 0; _i103 < _size99; ++_i103)
+ uint32_t _size101;
+ apache::thrift::protocol::TType _ktype102;
+ apache::thrift::protocol::TType _vtype103;
+ iprot->readMapBegin(_ktype102, _vtype103, _size101);
+ uint32_t _i105;
+ for (_i105 = 0; _i105 < _size101; ++_i105)
{
- std::string _key104;
- xfer += iprot->readString(_key104);
- Type& _val105 = this->success[_key104];
- xfer += _val105.read(iprot);
+ std::string _key106;
+ xfer += iprot->readString(_key106);
+ Type& _val107 = this->success[_key106];
+ xfer += _val107.read(iprot);
}
iprot->readMapEnd();
}
@@ -1500,11 +1500,11 @@ uint32_t ThriftHiveMetastore_get_type_al
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_MAP, 0);
{
xfer += oprot->writeMapBegin(apache::thrift::protocol::T_STRING, apache::thrift::protocol::T_STRUCT, this->success.size());
- std::map<std::string, Type> ::const_iterator _iter106;
- for (_iter106 = this->success.begin(); _iter106 != this->success.end(); ++_iter106)
+ std::map<std::string, Type> ::const_iterator _iter108;
+ for (_iter108 = this->success.begin(); _iter108 != this->success.end(); ++_iter108)
{
- xfer += oprot->writeString(_iter106->first);
- xfer += _iter106->second.write(oprot);
+ xfer += oprot->writeString(_iter108->first);
+ xfer += _iter108->second.write(oprot);
}
xfer += oprot->writeMapEnd();
}
@@ -1543,17 +1543,17 @@ uint32_t ThriftHiveMetastore_get_type_al
if (ftype == apache::thrift::protocol::T_MAP) {
{
(*(this->success)).clear();
- uint32_t _size107;
- apache::thrift::protocol::TType _ktype108;
- apache::thrift::protocol::TType _vtype109;
- iprot->readMapBegin(_ktype108, _vtype109, _size107);
- uint32_t _i111;
- for (_i111 = 0; _i111 < _size107; ++_i111)
+ uint32_t _size109;
+ apache::thrift::protocol::TType _ktype110;
+ apache::thrift::protocol::TType _vtype111;
+ iprot->readMapBegin(_ktype110, _vtype111, _size109);
+ uint32_t _i113;
+ for (_i113 = 0; _i113 < _size109; ++_i113)
{
- std::string _key112;
- xfer += iprot->readString(_key112);
- Type& _val113 = (*(this->success))[_key112];
- xfer += _val113.read(iprot);
+ std::string _key114;
+ xfer += iprot->readString(_key114);
+ Type& _val115 = (*(this->success))[_key114];
+ xfer += _val115.read(iprot);
}
iprot->readMapEnd();
}
@@ -1682,14 +1682,14 @@ uint32_t ThriftHiveMetastore_get_fields_
if (ftype == apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size114;
- apache::thrift::protocol::TType _etype117;
- iprot->readListBegin(_etype117, _size114);
- this->success.resize(_size114);
- uint32_t _i118;
- for (_i118 = 0; _i118 < _size114; ++_i118)
+ uint32_t _size116;
+ apache::thrift::protocol::TType _etype119;
+ iprot->readListBegin(_etype119, _size116);
+ this->success.resize(_size116);
+ uint32_t _i120;
+ for (_i120 = 0; _i120 < _size116; ++_i120)
{
- xfer += this->success[_i118].read(iprot);
+ xfer += this->success[_i120].read(iprot);
}
iprot->readListEnd();
}
@@ -1744,10 +1744,10 @@ uint32_t ThriftHiveMetastore_get_fields_
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRUCT, this->success.size());
- std::vector<FieldSchema> ::const_iterator _iter119;
- for (_iter119 = this->success.begin(); _iter119 != this->success.end(); ++_iter119)
+ std::vector<FieldSchema> ::const_iterator _iter121;
+ for (_iter121 = this->success.begin(); _iter121 != this->success.end(); ++_iter121)
{
- xfer += (*_iter119).write(oprot);
+ xfer += (*_iter121).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -1794,14 +1794,14 @@ uint32_t ThriftHiveMetastore_get_fields_
if (ftype == apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size120;
- apache::thrift::protocol::TType _etype123;
- iprot->readListBegin(_etype123, _size120);
- (*(this->success)).resize(_size120);
- uint32_t _i124;
- for (_i124 = 0; _i124 < _size120; ++_i124)
+ uint32_t _size122;
+ apache::thrift::protocol::TType _etype125;
+ iprot->readListBegin(_etype125, _size122);
+ (*(this->success)).resize(_size122);
+ uint32_t _i126;
+ for (_i126 = 0; _i126 < _size122; ++_i126)
{
- xfer += (*(this->success))[_i124].read(iprot);
+ xfer += (*(this->success))[_i126].read(iprot);
}
iprot->readListEnd();
}
@@ -1946,14 +1946,14 @@ uint32_t ThriftHiveMetastore_get_schema_
if (ftype == apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size125;
- apache::thrift::protocol::TType _etype128;
- iprot->readListBegin(_etype128, _size125);
- this->success.resize(_size125);
- uint32_t _i129;
- for (_i129 = 0; _i129 < _size125; ++_i129)
+ uint32_t _size127;
+ apache::thrift::protocol::TType _etype130;
+ iprot->readListBegin(_etype130, _size127);
+ this->success.resize(_size127);
+ uint32_t _i131;
+ for (_i131 = 0; _i131 < _size127; ++_i131)
{
- xfer += this->success[_i129].read(iprot);
+ xfer += this->success[_i131].read(iprot);
}
iprot->readListEnd();
}
@@ -2008,10 +2008,10 @@ uint32_t ThriftHiveMetastore_get_schema_
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRUCT, this->success.size());
- std::vector<FieldSchema> ::const_iterator _iter130;
- for (_iter130 = this->success.begin(); _iter130 != this->success.end(); ++_iter130)
+ std::vector<FieldSchema> ::const_iterator _iter132;
+ for (_iter132 = this->success.begin(); _iter132 != this->success.end(); ++_iter132)
{
- xfer += (*_iter130).write(oprot);
+ xfer += (*_iter132).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -2058,14 +2058,14 @@ uint32_t ThriftHiveMetastore_get_schema_
if (ftype == apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size131;
- apache::thrift::protocol::TType _etype134;
- iprot->readListBegin(_etype134, _size131);
- (*(this->success)).resize(_size131);
- uint32_t _i135;
- for (_i135 = 0; _i135 < _size131; ++_i135)
+ uint32_t _size133;
+ apache::thrift::protocol::TType _etype136;
+ iprot->readListBegin(_etype136, _size133);
+ (*(this->success)).resize(_size133);
+ uint32_t _i137;
+ for (_i137 = 0; _i137 < _size133; ++_i137)
{
- xfer += (*(this->success))[_i135].read(iprot);
+ xfer += (*(this->success))[_i137].read(iprot);
}
iprot->readListEnd();
}
@@ -2634,14 +2634,14 @@ uint32_t ThriftHiveMetastore_get_tables_
if (ftype == apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size136;
- apache::thrift::protocol::TType _etype139;
- iprot->readListBegin(_etype139, _size136);
- this->success.resize(_size136);
- uint32_t _i140;
- for (_i140 = 0; _i140 < _size136; ++_i140)
+ uint32_t _size138;
+ apache::thrift::protocol::TType _etype141;
+ iprot->readListBegin(_etype141, _size138);
+ this->success.resize(_size138);
+ uint32_t _i142;
+ for (_i142 = 0; _i142 < _size138; ++_i142)
{
- xfer += iprot->readString(this->success[_i140]);
+ xfer += iprot->readString(this->success[_i142]);
}
iprot->readListEnd();
}
@@ -2680,10 +2680,10 @@ uint32_t ThriftHiveMetastore_get_tables_
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, this->success.size());
- std::vector<std::string> ::const_iterator _iter141;
- for (_iter141 = this->success.begin(); _iter141 != this->success.end(); ++_iter141)
+ std::vector<std::string> ::const_iterator _iter143;
+ for (_iter143 = this->success.begin(); _iter143 != this->success.end(); ++_iter143)
{
- xfer += oprot->writeString((*_iter141));
+ xfer += oprot->writeString((*_iter143));
}
xfer += oprot->writeListEnd();
}
@@ -2722,14 +2722,14 @@ uint32_t ThriftHiveMetastore_get_tables_
if (ftype == apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size142;
- apache::thrift::protocol::TType _etype145;
- iprot->readListBegin(_etype145, _size142);
- (*(this->success)).resize(_size142);
- uint32_t _i146;
- for (_i146 = 0; _i146 < _size142; ++_i146)
+ uint32_t _size144;
+ apache::thrift::protocol::TType _etype147;
+ iprot->readListBegin(_etype147, _size144);
+ (*(this->success)).resize(_size144);
+ uint32_t _i148;
+ for (_i148 = 0; _i148 < _size144; ++_i148)
{
- xfer += iprot->readString((*(this->success))[_i146]);
+ xfer += iprot->readString((*(this->success))[_i148]);
}
iprot->readListEnd();
}
@@ -3434,14 +3434,14 @@ uint32_t ThriftHiveMetastore_append_part
if (ftype == apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size147;
- apache::thrift::protocol::TType _etype150;
- iprot->readListBegin(_etype150, _size147);
- this->part_vals.resize(_size147);
- uint32_t _i151;
- for (_i151 = 0; _i151 < _size147; ++_i151)
+ uint32_t _size149;
+ apache::thrift::protocol::TType _etype152;
+ iprot->readListBegin(_etype152, _size149);
+ this->part_vals.resize(_size149);
+ uint32_t _i153;
+ for (_i153 = 0; _i153 < _size149; ++_i153)
{
- xfer += iprot->readString(this->part_vals[_i151]);
+ xfer += iprot->readString(this->part_vals[_i153]);
}
iprot->readListEnd();
}
@@ -3474,10 +3474,10 @@ uint32_t ThriftHiveMetastore_append_part
xfer += oprot->writeFieldBegin("part_vals", apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, this->part_vals.size());
- std::vector<std::string> ::const_iterator _iter152;
- for (_iter152 = this->part_vals.begin(); _iter152 != this->part_vals.end(); ++_iter152)
+ std::vector<std::string> ::const_iterator _iter154;
+ for (_iter154 = this->part_vals.begin(); _iter154 != this->part_vals.end(); ++_iter154)
{
- xfer += oprot->writeString((*_iter152));
+ xfer += oprot->writeString((*_iter154));
}
xfer += oprot->writeListEnd();
}
@@ -3499,10 +3499,10 @@ uint32_t ThriftHiveMetastore_append_part
xfer += oprot->writeFieldBegin("part_vals", apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, (*(this->part_vals)).size());
- std::vector<std::string> ::const_iterator _iter153;
- for (_iter153 = (*(this->part_vals)).begin(); _iter153 != (*(this->part_vals)).end(); ++_iter153)
+ std::vector<std::string> ::const_iterator _iter155;
+ for (_iter155 = (*(this->part_vals)).begin(); _iter155 != (*(this->part_vals)).end(); ++_iter155)
{
- xfer += oprot->writeString((*_iter153));
+ xfer += oprot->writeString((*_iter155));
}
xfer += oprot->writeListEnd();
}
@@ -3954,14 +3954,14 @@ uint32_t ThriftHiveMetastore_drop_partit
if (ftype == apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size154;
- apache::thrift::protocol::TType _etype157;
- iprot->readListBegin(_etype157, _size154);
- this->part_vals.resize(_size154);
- uint32_t _i158;
- for (_i158 = 0; _i158 < _size154; ++_i158)
+ uint32_t _size156;
+ apache::thrift::protocol::TType _etype159;
+ iprot->readListBegin(_etype159, _size156);
+ this->part_vals.resize(_size156);
+ uint32_t _i160;
+ for (_i160 = 0; _i160 < _size156; ++_i160)
{
- xfer += iprot->readString(this->part_vals[_i158]);
+ xfer += iprot->readString(this->part_vals[_i160]);
}
iprot->readListEnd();
}
@@ -4002,10 +4002,10 @@ uint32_t ThriftHiveMetastore_drop_partit
xfer += oprot->writeFieldBegin("part_vals", apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, this->part_vals.size());
- std::vector<std::string> ::const_iterator _iter159;
- for (_iter159 = this->part_vals.begin(); _iter159 != this->part_vals.end(); ++_iter159)
+ std::vector<std::string> ::const_iterator _iter161;
+ for (_iter161 = this->part_vals.begin(); _iter161 != this->part_vals.end(); ++_iter161)
{
- xfer += oprot->writeString((*_iter159));
+ xfer += oprot->writeString((*_iter161));
}
xfer += oprot->writeListEnd();
}
@@ -4030,10 +4030,10 @@ uint32_t ThriftHiveMetastore_drop_partit
xfer += oprot->writeFieldBegin("part_vals", apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, (*(this->part_vals)).size());
- std::vector<std::string> ::const_iterator _iter160;
- for (_iter160 = (*(this->part_vals)).begin(); _iter160 != (*(this->part_vals)).end(); ++_iter160)
+ std::vector<std::string> ::const_iterator _iter162;
+ for (_iter162 = (*(this->part_vals)).begin(); _iter162 != (*(this->part_vals)).end(); ++_iter162)
{
- xfer += oprot->writeString((*_iter160));
+ xfer += oprot->writeString((*_iter162));
}
xfer += oprot->writeListEnd();
}
@@ -4462,14 +4462,14 @@ uint32_t ThriftHiveMetastore_get_partiti
if (ftype == apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size161;
- apache::thrift::protocol::TType _etype164;
- iprot->readListBegin(_etype164, _size161);
- this->part_vals.resize(_size161);
- uint32_t _i165;
- for (_i165 = 0; _i165 < _size161; ++_i165)
+ uint32_t _size163;
+ apache::thrift::protocol::TType _etype166;
+ iprot->readListBegin(_etype166, _size163);
+ this->part_vals.resize(_size163);
+ uint32_t _i167;
+ for (_i167 = 0; _i167 < _size163; ++_i167)
{
- xfer += iprot->readString(this->part_vals[_i165]);
+ xfer += iprot->readString(this->part_vals[_i167]);
}
iprot->readListEnd();
}
@@ -4502,10 +4502,10 @@ uint32_t ThriftHiveMetastore_get_partiti
xfer += oprot->writeFieldBegin("part_vals", apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, this->part_vals.size());
- std::vector<std::string> ::const_iterator _iter166;
- for (_iter166 = this->part_vals.begin(); _iter166 != this->part_vals.end(); ++_iter166)
+ std::vector<std::string> ::const_iterator _iter168;
+ for (_iter168 = this->part_vals.begin(); _iter168 != this->part_vals.end(); ++_iter168)
{
- xfer += oprot->writeString((*_iter166));
+ xfer += oprot->writeString((*_iter168));
}
xfer += oprot->writeListEnd();
}
@@ -4527,10 +4527,10 @@ uint32_t ThriftHiveMetastore_get_partiti
xfer += oprot->writeFieldBegin("part_vals", apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, (*(this->part_vals)).size());
- std::vector<std::string> ::const_iterator _iter167;
- for (_iter167 = (*(this->part_vals)).begin(); _iter167 != (*(this->part_vals)).end(); ++_iter167)
+ std::vector<std::string> ::const_iterator _iter169;
+ for (_iter169 = (*(this->part_vals)).begin(); _iter169 != (*(this->part_vals)).end(); ++_iter169)
{
- xfer += oprot->writeString((*_iter167));
+ xfer += oprot->writeString((*_iter169));
}
xfer += oprot->writeListEnd();
}
@@ -5016,14 +5016,14 @@ uint32_t ThriftHiveMetastore_get_partiti
if (ftype == apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size168;
- apache::thrift::protocol::TType _etype171;
- iprot->readListBegin(_etype171, _size168);
- this->success.resize(_size168);
- uint32_t _i172;
- for (_i172 = 0; _i172 < _size168; ++_i172)
+ uint32_t _size170;
+ apache::thrift::protocol::TType _etype173;
+ iprot->readListBegin(_etype173, _size170);
+ this->success.resize(_size170);
+ uint32_t _i174;
+ for (_i174 = 0; _i174 < _size170; ++_i174)
{
- xfer += this->success[_i172].read(iprot);
+ xfer += this->success[_i174].read(iprot);
}
iprot->readListEnd();
}
@@ -5070,10 +5070,10 @@ uint32_t ThriftHiveMetastore_get_partiti
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRUCT, this->success.size());
- std::vector<Partition> ::const_iterator _iter173;
- for (_iter173 = this->success.begin(); _iter173 != this->success.end(); ++_iter173)
+ std::vector<Partition> ::const_iterator _iter175;
+ for (_iter175 = this->success.begin(); _iter175 != this->success.end(); ++_iter175)
{
- xfer += (*_iter173).write(oprot);
+ xfer += (*_iter175).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5116,14 +5116,14 @@ uint32_t ThriftHiveMetastore_get_partiti
if (ftype == apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size174;
- apache::thrift::protocol::TType _etype177;
- iprot->readListBegin(_etype177, _size174);
- (*(this->success)).resize(_size174);
- uint32_t _i178;
- for (_i178 = 0; _i178 < _size174; ++_i178)
+ uint32_t _size176;
+ apache::thrift::protocol::TType _etype179;
+ iprot->readListBegin(_etype179, _size176);
+ (*(this->success)).resize(_size176);
+ uint32_t _i180;
+ for (_i180 = 0; _i180 < _size176; ++_i180)
{
- xfer += (*(this->success))[_i178].read(iprot);
+ xfer += (*(this->success))[_i180].read(iprot);
}
iprot->readListEnd();
}
@@ -5274,14 +5274,14 @@ uint32_t ThriftHiveMetastore_get_partiti
if (ftype == apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size179;
- apache::thrift::protocol::TType _etype182;
- iprot->readListBegin(_etype182, _size179);
- this->success.resize(_size179);
- uint32_t _i183;
- for (_i183 = 0; _i183 < _size179; ++_i183)
+ uint32_t _size181;
+ apache::thrift::protocol::TType _etype184;
+ iprot->readListBegin(_etype184, _size181);
+ this->success.resize(_size181);
+ uint32_t _i185;
+ for (_i185 = 0; _i185 < _size181; ++_i185)
{
- xfer += iprot->readString(this->success[_i183]);
+ xfer += iprot->readString(this->success[_i185]);
}
iprot->readListEnd();
}
@@ -5320,10 +5320,10 @@ uint32_t ThriftHiveMetastore_get_partiti
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, this->success.size());
- std::vector<std::string> ::const_iterator _iter184;
- for (_iter184 = this->success.begin(); _iter184 != this->success.end(); ++_iter184)
+ std::vector<std::string> ::const_iterator _iter186;
+ for (_iter186 = this->success.begin(); _iter186 != this->success.end(); ++_iter186)
{
- xfer += oprot->writeString((*_iter184));
+ xfer += oprot->writeString((*_iter186));
}
xfer += oprot->writeListEnd();
}
@@ -5362,14 +5362,14 @@ uint32_t ThriftHiveMetastore_get_partiti
if (ftype == apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size185;
- apache::thrift::protocol::TType _etype188;
- iprot->readListBegin(_etype188, _size185);
- (*(this->success)).resize(_size185);
- uint32_t _i189;
- for (_i189 = 0; _i189 < _size185; ++_i189)
+ uint32_t _size187;
+ apache::thrift::protocol::TType _etype190;
+ iprot->readListBegin(_etype190, _size187);
+ (*(this->success)).resize(_size187);
+ uint32_t _i191;
+ for (_i191 = 0; _i191 < _size187; ++_i191)
{
- xfer += iprot->readString((*(this->success))[_i189]);
+ xfer += iprot->readString((*(this->success))[_i191]);
}
iprot->readListEnd();
}
@@ -5438,14 +5438,14 @@ uint32_t ThriftHiveMetastore_get_partiti
if (ftype == apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size190;
- apache::thrift::protocol::TType _etype193;
- iprot->readListBegin(_etype193, _size190);
- this->part_vals.resize(_size190);
- uint32_t _i194;
- for (_i194 = 0; _i194 < _size190; ++_i194)
+ uint32_t _size192;
+ apache::thrift::protocol::TType _etype195;
+ iprot->readListBegin(_etype195, _size192);
+ this->part_vals.resize(_size192);
+ uint32_t _i196;
+ for (_i196 = 0; _i196 < _size192; ++_i196)
{
- xfer += iprot->readString(this->part_vals[_i194]);
+ xfer += iprot->readString(this->part_vals[_i196]);
}
iprot->readListEnd();
}
@@ -5486,10 +5486,10 @@ uint32_t ThriftHiveMetastore_get_partiti
xfer += oprot->writeFieldBegin("part_vals", apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, this->part_vals.size());
- std::vector<std::string> ::const_iterator _iter195;
- for (_iter195 = this->part_vals.begin(); _iter195 != this->part_vals.end(); ++_iter195)
+ std::vector<std::string> ::const_iterator _iter197;
+ for (_iter197 = this->part_vals.begin(); _iter197 != this->part_vals.end(); ++_iter197)
{
- xfer += oprot->writeString((*_iter195));
+ xfer += oprot->writeString((*_iter197));
}
xfer += oprot->writeListEnd();
}
@@ -5514,10 +5514,10 @@ uint32_t ThriftHiveMetastore_get_partiti
xfer += oprot->writeFieldBegin("part_vals", apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, (*(this->part_vals)).size());
- std::vector<std::string> ::const_iterator _iter196;
- for (_iter196 = (*(this->part_vals)).begin(); _iter196 != (*(this->part_vals)).end(); ++_iter196)
+ std::vector<std::string> ::const_iterator _iter198;
+ for (_iter198 = (*(this->part_vals)).begin(); _iter198 != (*(this->part_vals)).end(); ++_iter198)
{
- xfer += oprot->writeString((*_iter196));
+ xfer += oprot->writeString((*_iter198));
}
xfer += oprot->writeListEnd();
}
@@ -5554,14 +5554,14 @@ uint32_t ThriftHiveMetastore_get_partiti
if (ftype == apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size197;
- apache::thrift::protocol::TType _etype200;
- iprot->readListBegin(_etype200, _size197);
- this->success.resize(_size197);
- uint32_t _i201;
- for (_i201 = 0; _i201 < _size197; ++_i201)
+ uint32_t _size199;
+ apache::thrift::protocol::TType _etype202;
+ iprot->readListBegin(_etype202, _size199);
+ this->success.resize(_size199);
+ uint32_t _i203;
+ for (_i203 = 0; _i203 < _size199; ++_i203)
{
- xfer += this->success[_i201].read(iprot);
+ xfer += this->success[_i203].read(iprot);
}
iprot->readListEnd();
}
@@ -5600,10 +5600,10 @@ uint32_t ThriftHiveMetastore_get_partiti
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRUCT, this->success.size());
- std::vector<Partition> ::const_iterator _iter202;
- for (_iter202 = this->success.begin(); _iter202 != this->success.end(); ++_iter202)
+ std::vector<Partition> ::const_iterator _iter204;
+ for (_iter204 = this->success.begin(); _iter204 != this->success.end(); ++_iter204)
{
- xfer += (*_iter202).write(oprot);
+ xfer += (*_iter204).write(oprot);
}
xfer += oprot->writeListEnd();
}
@@ -5642,14 +5642,14 @@ uint32_t ThriftHiveMetastore_get_partiti
if (ftype == apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size203;
- apache::thrift::protocol::TType _etype206;
- iprot->readListBegin(_etype206, _size203);
- (*(this->success)).resize(_size203);
- uint32_t _i207;
- for (_i207 = 0; _i207 < _size203; ++_i207)
+ uint32_t _size205;
+ apache::thrift::protocol::TType _etype208;
+ iprot->readListBegin(_etype208, _size205);
+ (*(this->success)).resize(_size205);
+ uint32_t _i209;
+ for (_i209 = 0; _i209 < _size205; ++_i209)
{
- xfer += (*(this->success))[_i207].read(iprot);
+ xfer += (*(this->success))[_i209].read(iprot);
}
iprot->readListEnd();
}
@@ -5718,14 +5718,14 @@ uint32_t ThriftHiveMetastore_get_partiti
if (ftype == apache::thrift::protocol::T_LIST) {
{
this->part_vals.clear();
- uint32_t _size208;
- apache::thrift::protocol::TType _etype211;
- iprot->readListBegin(_etype211, _size208);
- this->part_vals.resize(_size208);
- uint32_t _i212;
- for (_i212 = 0; _i212 < _size208; ++_i212)
+ uint32_t _size210;
+ apache::thrift::protocol::TType _etype213;
+ iprot->readListBegin(_etype213, _size210);
+ this->part_vals.resize(_size210);
+ uint32_t _i214;
+ for (_i214 = 0; _i214 < _size210; ++_i214)
{
- xfer += iprot->readString(this->part_vals[_i212]);
+ xfer += iprot->readString(this->part_vals[_i214]);
}
iprot->readListEnd();
}
@@ -5766,10 +5766,10 @@ uint32_t ThriftHiveMetastore_get_partiti
xfer += oprot->writeFieldBegin("part_vals", apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, this->part_vals.size());
- std::vector<std::string> ::const_iterator _iter213;
- for (_iter213 = this->part_vals.begin(); _iter213 != this->part_vals.end(); ++_iter213)
+ std::vector<std::string> ::const_iterator _iter215;
+ for (_iter215 = this->part_vals.begin(); _iter215 != this->part_vals.end(); ++_iter215)
{
- xfer += oprot->writeString((*_iter213));
+ xfer += oprot->writeString((*_iter215));
}
xfer += oprot->writeListEnd();
}
@@ -5794,10 +5794,10 @@ uint32_t ThriftHiveMetastore_get_partiti
xfer += oprot->writeFieldBegin("part_vals", apache::thrift::protocol::T_LIST, 3);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, (*(this->part_vals)).size());
- std::vector<std::string> ::const_iterator _iter214;
- for (_iter214 = (*(this->part_vals)).begin(); _iter214 != (*(this->part_vals)).end(); ++_iter214)
+ std::vector<std::string> ::const_iterator _iter216;
+ for (_iter216 = (*(this->part_vals)).begin(); _iter216 != (*(this->part_vals)).end(); ++_iter216)
{
- xfer += oprot->writeString((*_iter214));
+ xfer += oprot->writeString((*_iter216));
}
xfer += oprot->writeListEnd();
}
@@ -5834,14 +5834,14 @@ uint32_t ThriftHiveMetastore_get_partiti
if (ftype == apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size215;
- apache::thrift::protocol::TType _etype218;
- iprot->readListBegin(_etype218, _size215);
- this->success.resize(_size215);
- uint32_t _i219;
- for (_i219 = 0; _i219 < _size215; ++_i219)
+ uint32_t _size217;
+ apache::thrift::protocol::TType _etype220;
+ iprot->readListBegin(_etype220, _size217);
+ this->success.resize(_size217);
+ uint32_t _i221;
+ for (_i221 = 0; _i221 < _size217; ++_i221)
{
- xfer += iprot->readString(this->success[_i219]);
+ xfer += iprot->readString(this->success[_i221]);
}
iprot->readListEnd();
}
@@ -5880,10 +5880,10 @@ uint32_t ThriftHiveMetastore_get_partiti
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, this->success.size());
- std::vector<std::string> ::const_iterator _iter220;
- for (_iter220 = this->success.begin(); _iter220 != this->success.end(); ++_iter220)
+ std::vector<std::string> ::const_iterator _iter222;
+ for (_iter222 = this->success.begin(); _iter222 != this->success.end(); ++_iter222)
{
- xfer += oprot->writeString((*_iter220));
+ xfer += oprot->writeString((*_iter222));
}
xfer += oprot->writeListEnd();
}
@@ -5922,14 +5922,14 @@ uint32_t ThriftHiveMetastore_get_partiti
if (ftype == apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size221;
- apache::thrift::protocol::TType _etype224;
- iprot->readListBegin(_etype224, _size221);
- (*(this->success)).resize(_size221);
- uint32_t _i225;
- for (_i225 = 0; _i225 < _size221; ++_i225)
+ uint32_t _size223;
+ apache::thrift::protocol::TType _etype226;
+ iprot->readListBegin(_etype226, _size223);
+ (*(this->success)).resize(_size223);
+ uint32_t _i227;
+ for (_i227 = 0; _i227 < _size223; ++_i227)
{
- xfer += iprot->readString((*(this->success))[_i225]);
+ xfer += iprot->readString((*(this->success))[_i227]);
}
iprot->readListEnd();
}
@@ -6442,14 +6442,14 @@ uint32_t ThriftHiveMetastore_partition_n
if (ftype == apache::thrift::protocol::T_LIST) {
{
this->success.clear();
- uint32_t _size226;
- apache::thrift::protocol::TType _etype229;
- iprot->readListBegin(_etype229, _size226);
- this->success.resize(_size226);
- uint32_t _i230;
- for (_i230 = 0; _i230 < _size226; ++_i230)
+ uint32_t _size228;
+ apache::thrift::protocol::TType _etype231;
+ iprot->readListBegin(_etype231, _size228);
+ this->success.resize(_size228);
+ uint32_t _i232;
+ for (_i232 = 0; _i232 < _size228; ++_i232)
{
- xfer += iprot->readString(this->success[_i230]);
+ xfer += iprot->readString(this->success[_i232]);
}
iprot->readListEnd();
}
@@ -6488,10 +6488,10 @@ uint32_t ThriftHiveMetastore_partition_n
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_LIST, 0);
{
xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, this->success.size());
- std::vector<std::string> ::const_iterator _iter231;
- for (_iter231 = this->success.begin(); _iter231 != this->success.end(); ++_iter231)
+ std::vector<std::string> ::const_iterator _iter233;
+ for (_iter233 = this->success.begin(); _iter233 != this->success.end(); ++_iter233)
{
- xfer += oprot->writeString((*_iter231));
+ xfer += oprot->writeString((*_iter233));
}
xfer += oprot->writeListEnd();
}
@@ -6530,14 +6530,14 @@ uint32_t ThriftHiveMetastore_partition_n
if (ftype == apache::thrift::protocol::T_LIST) {
{
(*(this->success)).clear();
- uint32_t _size232;
- apache::thrift::protocol::TType _etype235;
- iprot->readListBegin(_etype235, _size232);
- (*(this->success)).resize(_size232);
- uint32_t _i236;
- for (_i236 = 0; _i236 < _size232; ++_i236)
+ uint32_t _size234;
+ apache::thrift::protocol::TType _etype237;
+ iprot->readListBegin(_etype237, _size234);
+ (*(this->success)).resize(_size234);
+ uint32_t _i238;
+ for (_i238 = 0; _i238 < _size234; ++_i238)
{
- xfer += iprot->readString((*(this->success))[_i236]);
+ xfer += iprot->readString((*(this->success))[_i238]);
}
iprot->readListEnd();
}
@@ -6652,17 +6652,17 @@ uint32_t ThriftHiveMetastore_partition_n
if (ftype == apache::thrift::protocol::T_MAP) {
{
this->success.clear();
- uint32_t _size237;
- apache::thrift::protocol::TType _ktype238;
- apache::thrift::protocol::TType _vtype239;
- iprot->readMapBegin(_ktype238, _vtype239, _size237);
- uint32_t _i241;
- for (_i241 = 0; _i241 < _size237; ++_i241)
+ uint32_t _size239;
+ apache::thrift::protocol::TType _ktype240;
+ apache::thrift::protocol::TType _vtype241;
+ iprot->readMapBegin(_ktype240, _vtype241, _size239);
+ uint32_t _i243;
+ for (_i243 = 0; _i243 < _size239; ++_i243)
{
- std::string _key242;
- xfer += iprot->readString(_key242);
- std::string& _val243 = this->success[_key242];
- xfer += iprot->readString(_val243);
+ std::string _key244;
+ xfer += iprot->readString(_key244);
+ std::string& _val245 = this->success[_key244];
+ xfer += iprot->readString(_val245);
}
iprot->readMapEnd();
}
@@ -6701,11 +6701,11 @@ uint32_t ThriftHiveMetastore_partition_n
xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_MAP, 0);
{
xfer += oprot->writeMapBegin(apache::thrift::protocol::T_STRING, apache::thrift::protocol::T_STRING, this->success.size());
- std::map<std::string, std::string> ::const_iterator _iter244;
- for (_iter244 = this->success.begin(); _iter244 != this->success.end(); ++_iter244)
+ std::map<std::string, std::string> ::const_iterator _iter246;
+ for (_iter246 = this->success.begin(); _iter246 != this->success.end(); ++_iter246)
{
- xfer += oprot->writeString(_iter244->first);
- xfer += oprot->writeString(_iter244->second);
+ xfer += oprot->writeString(_iter246->first);
+ xfer += oprot->writeString(_iter246->second);
}
xfer += oprot->writeMapEnd();
}
@@ -6744,17 +6744,17 @@ uint32_t ThriftHiveMetastore_partition_n
if (ftype == apache::thrift::protocol::T_MAP) {
{
(*(this->success)).clear();
- uint32_t _size245;
- apache::thrift::protocol::TType _ktype246;
- apache::thrift::protocol::TType _vtype247;
- iprot->readMapBegin(_ktype246, _vtype247, _size245);
- uint32_t _i249;
- for (_i249 = 0; _i249 < _size245; ++_i249)
+ uint32_t _size247;
+ apache::thrift::protocol::TType _ktype248;
+ apache::thrift::protocol::TType _vtype249;
+ iprot->readMapBegin(_ktype248, _vtype249, _size247);
+ uint32_t _i251;
+ for (_i251 = 0; _i251 < _size247; ++_i251)
{
- std::string _key250;
- xfer += iprot->readString(_key250);
- std::string& _val251 = (*(this->success))[_key250];
- xfer += iprot->readString(_val251);
+ std::string _key252;
+ xfer += iprot->readString(_key252);
+ std::string& _val253 = (*(this->success))[_key252];
+ xfer += iprot->readString(_val253);
}
iprot->readMapEnd();
}
@@ -6783,20 +6783,1471 @@ uint32_t ThriftHiveMetastore_partition_n
return xfer;
}
+uint32_t ThriftHiveMetastore_add_index_args::read(apache::thrift::protocol::TProtocol* 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->new_index.read(iprot);
+ this->__isset.new_index = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == apache::thrift::protocol::T_STRUCT) {
+ xfer += this->index_table.read(iprot);
+ this->__isset.index_table = 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_index_args::write(apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_index_args");
+ xfer += oprot->writeFieldBegin("new_index", apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->new_index.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("index_table", apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->index_table.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_add_index_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_index_pargs");
+ xfer += oprot->writeFieldBegin("new_index", apache::thrift::protocol::T_STRUCT, 1);
+ xfer += (*(this->new_index)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("index_table", apache::thrift::protocol::T_STRUCT, 2);
+ xfer += (*(this->index_table)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_add_index_result::read(apache::thrift::protocol::TProtocol* 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_STRUCT) {
+ xfer += this->success.read(iprot);
+ 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;
+ case 2:
+ if (ftype == apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o2.read(iprot);
+ this->__isset.o2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o3.read(iprot);
+ this->__isset.o3 = 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_index_result::write(apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_add_index_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_STRUCT, 0);
+ xfer += this->success.write(oprot);
+ 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();
+ } else if (this->__isset.o2) {
+ xfer += oprot->writeFieldBegin("o2", apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->o2.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o3) {
+ xfer += oprot->writeFieldBegin("o3", apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->o3.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_add_index_presult::read(apache::thrift::protocol::TProtocol* 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_STRUCT) {
+ xfer += (*(this->success)).read(iprot);
+ 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;
+ case 2:
+ if (ftype == apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o2.read(iprot);
+ this->__isset.o2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o3.read(iprot);
+ this->__isset.o3 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_index_by_name_args::read(apache::thrift::protocol::TProtocol* 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;
+ case 2:
+ if (ftype == apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tbl_name);
+ this->__isset.tbl_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->index_name);
+ this->__isset.index_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->deleteData);
+ this->__isset.deleteData = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_index_by_name_args::write(apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_index_by_name_args");
+ xfer += oprot->writeFieldBegin("db_name", apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->db_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("tbl_name", apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tbl_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("index_name", apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->index_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("deleteData", apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool(this->deleteData);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_index_by_name_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_index_by_name_pargs");
+ xfer += oprot->writeFieldBegin("db_name", apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->db_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("tbl_name", apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString((*(this->tbl_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("index_name", apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString((*(this->index_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("deleteData", apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool((*(this->deleteData)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_index_by_name_result::read(apache::thrift::protocol::TProtocol* 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_BOOL) {
+ xfer += iprot->readBool(this->success);
+ 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;
+ 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_drop_index_by_name_result::write(apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_index_by_name_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_BOOL, 0);
+ xfer += oprot->writeBool(this->success);
+ 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();
+ } 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;
+}
+
+uint32_t ThriftHiveMetastore_drop_index_by_name_presult::read(apache::thrift::protocol::TProtocol* 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_BOOL) {
+ xfer += iprot->readBool((*(this->success)));
+ 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;
+ 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_get_index_by_name_args::read(apache::thrift::protocol::TProtocol* 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;
+ case 2:
+ if (ftype == apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tbl_name);
+ this->__isset.tbl_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->index_name);
+ this->__isset.index_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_index_by_name_args::write(apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_index_by_name_args");
+ xfer += oprot->writeFieldBegin("db_name", apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->db_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("tbl_name", apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tbl_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("index_name", apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->index_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_index_by_name_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_index_by_name_pargs");
+ xfer += oprot->writeFieldBegin("db_name", apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->db_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("tbl_name", apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString((*(this->tbl_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("index_name", apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString((*(this->index_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_index_by_name_result::read(apache::thrift::protocol::TProtocol* 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_STRUCT) {
+ xfer += this->success.read(iprot);
+ 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;
+ 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_get_index_by_name_result::write(apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_index_by_name_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_STRUCT, 0);
+ xfer += this->success.write(oprot);
+ 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();
+ } 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;
+}
+
+uint32_t ThriftHiveMetastore_get_index_by_name_presult::read(apache::thrift::protocol::TProtocol* 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_STRUCT) {
+ xfer += (*(this->success)).read(iprot);
+ 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;
+ 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_get_indexes_args::read(apache::thrift::protocol::TProtocol* 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;
+ case 2:
+ if (ftype == apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tbl_name);
+ this->__isset.tbl_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == apache::thrift::protocol::T_I16) {
+ xfer += iprot->readI16(this->max_indexes);
+ this->__isset.max_indexes = 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_indexes_args::write(apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_indexes_args");
+ xfer += oprot->writeFieldBegin("db_name", apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->db_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("tbl_name", apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tbl_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("max_indexes", apache::thrift::protocol::T_I16, 3);
+ xfer += oprot->writeI16(this->max_indexes);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_indexes_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_indexes_pargs");
+ xfer += oprot->writeFieldBegin("db_name", apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->db_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("tbl_name", apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString((*(this->tbl_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("max_indexes", apache::thrift::protocol::T_I16, 3);
+ xfer += oprot->writeI16((*(this->max_indexes)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_indexes_result::read(apache::thrift::protocol::TProtocol* 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 _size254;
+ apache::thrift::protocol::TType _etype257;
+ iprot->readListBegin(_etype257, _size254);
+ this->success.resize(_size254);
+ uint32_t _i258;
+ for (_i258 = 0; _i258 < _size254; ++_i258)
+ {
+ xfer += this->success[_i258].read(iprot);
+ }
+ 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;
+ 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_get_indexes_result::write(apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_indexes_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_LIST, 0);
+ {
+ xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRUCT, this->success.size());
+ std::vector<Index> ::const_iterator _iter259;
+ for (_iter259 = this->success.begin(); _iter259 != this->success.end(); ++_iter259)
+ {
+ xfer += (*_iter259).write(oprot);
+ }
+ 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();
+ } 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;
+}
+
+uint32_t ThriftHiveMetastore_get_indexes_presult::read(apache::thrift::protocol::TProtocol* 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 _size260;
+ apache::thrift::protocol::TType _etype263;
+ iprot->readListBegin(_etype263, _size260);
+ (*(this->success)).resize(_size260);
+ uint32_t _i264;
+ for (_i264 = 0; _i264 < _size260; ++_i264)
+ {
+ xfer += (*(this->success))[_i264].read(iprot);
+ }
+ 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;
+ 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_get_index_names_args::read(apache::thrift::protocol::TProtocol* 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;
+ case 2:
+ if (ftype == apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tbl_name);
+ this->__isset.tbl_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == apache::thrift::protocol::T_I16) {
+ xfer += iprot->readI16(this->max_indexes);
+ this->__isset.max_indexes = 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_index_names_args::write(apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_index_names_args");
+ xfer += oprot->writeFieldBegin("db_name", apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->db_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("tbl_name", apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tbl_name);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("max_indexes", apache::thrift::protocol::T_I16, 3);
+ xfer += oprot->writeI16(this->max_indexes);
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_index_names_pargs::write(apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_index_names_pargs");
+ xfer += oprot->writeFieldBegin("db_name", apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->db_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("tbl_name", apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString((*(this->tbl_name)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldBegin("max_indexes", apache::thrift::protocol::T_I16, 3);
+ xfer += oprot->writeI16((*(this->max_indexes)));
+ xfer += oprot->writeFieldEnd();
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_index_names_result::read(apache::thrift::protocol::TProtocol* 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 _size265;
+ apache::thrift::protocol::TType _etype268;
+ iprot->readListBegin(_etype268, _size265);
+ this->success.resize(_size265);
+ uint32_t _i269;
+ for (_i269 = 0; _i269 < _size265; ++_i269)
+ {
+ xfer += iprot->readString(this->success[_i269]);
+ }
+ iprot->readListEnd();
+ }
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ 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_get_index_names_result::write(apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_index_names_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_LIST, 0);
+ {
+ xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, this->success.size());
+ std::vector<std::string> ::const_iterator _iter270;
+ for (_iter270 = this->success.begin(); _iter270 != this->success.end(); ++_iter270)
+ {
+ xfer += oprot->writeString((*_iter270));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o2) {
+ xfer += oprot->writeFieldBegin("o2", apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->o2.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_index_names_presult::read(apache::thrift::protocol::TProtocol* 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 _size271;
+ apache::thrift::protocol::TType _etype274;
+ iprot->readListBegin(_etype274, _size271);
+ (*(this->success)).resize(_size271);
+ uint32_t _i275;
+ for (_i275 = 0; _i275 < _size271; ++_i275)
+ {
+ xfer += iprot->readString((*(this->success))[_i275]);
+ }
+ iprot->readListEnd();
+ }
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ 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;
+}
+
bool ThriftHiveMetastoreClient::create_database(const std::string& name, const std::string& description)
{
- send_create_database(name, description);
- return recv_create_database();
+ send_create_database(name, description);
+ return recv_create_database();
+}
+
+void ThriftHiveMetastoreClient::send_create_database(const std::string& name, const std::string& description)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("create_database", apache::thrift::protocol::T_CALL, cseqid);
+
+ ThriftHiveMetastore_create_database_pargs args;
+ args.name = &name;
+ args.description = &description;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->flush();
+ oprot_->getTransport()->writeEnd();
+}
+
+bool ThriftHiveMetastoreClient::recv_create_database()
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ apache::thrift::protocol::TMessageType mtype;
+
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+ apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw x;
+ }
+ if (mtype != apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
+ }
+ if (fname.compare("create_database") != 0) {
+ iprot_->skip(apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
+ }
+ bool _return;
+ ThriftHiveMetastore_create_database_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ return _return;
+ }
+ if (result.__isset.o1) {
+ throw result.o1;
+ }
+ if (result.__isset.o2) {
+ throw result.o2;
+ }
+ throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "create_database failed: unknown result");
+}
+
+void ThriftHiveMetastoreClient::get_database(Database& _return, const std::string& name)
+{
+ send_get_database(name);
+ recv_get_database(_return);
+}
+
+void ThriftHiveMetastoreClient::send_get_database(const std::string& name)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("get_database", apache::thrift::protocol::T_CALL, cseqid);
+
+ ThriftHiveMetastore_get_database_pargs args;
+ args.name = &name;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->flush();
+ oprot_->getTransport()->writeEnd();
+}
+
+void ThriftHiveMetastoreClient::recv_get_database(Database& _return)
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ apache::thrift::protocol::TMessageType mtype;
+
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+ apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw x;
+ }
+ if (mtype != apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
+ }
+ if (fname.compare("get_database") != 0) {
+ iprot_->skip(apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
+ }
+ ThriftHiveMetastore_get_database_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ // _return pointer has now been filled
+ return;
+ }
+ if (result.__isset.o1) {
+ throw result.o1;
+ }
+ if (result.__isset.o2) {
+ throw result.o2;
+ }
+ throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "get_database failed: unknown result");
+}
+
+bool ThriftHiveMetastoreClient::drop_database(const std::string& name)
+{
+ send_drop_database(name);
+ return recv_drop_database();
+}
+
+void ThriftHiveMetastoreClient::send_drop_database(const std::string& name)
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("drop_database", apache::thrift::protocol::T_CALL, cseqid);
+
+ ThriftHiveMetastore_drop_database_pargs args;
+ args.name = &name;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->flush();
+ oprot_->getTransport()->writeEnd();
+}
+
+bool ThriftHiveMetastoreClient::recv_drop_database()
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ apache::thrift::protocol::TMessageType mtype;
+
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+ apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw x;
+ }
+ if (mtype != apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
+ }
+ if (fname.compare("drop_database") != 0) {
+ iprot_->skip(apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
+ }
+ bool _return;
+ ThriftHiveMetastore_drop_database_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ return _return;
+ }
+ if (result.__isset.o2) {
+ throw result.o2;
+ }
+ throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "drop_database failed: unknown result");
+}
+
+void ThriftHiveMetastoreClient::get_databases(std::vector<std::string> & _return)
+{
+ send_get_databases();
+ recv_get_databases(_return);
+}
+
+void ThriftHiveMetastoreClient::send_get_databases()
+{
+ int32_t cseqid = 0;
+ oprot_->writeMessageBegin("get_databases", apache::thrift::protocol::T_CALL, cseqid);
+
+ ThriftHiveMetastore_get_databases_pargs args;
+ args.write(oprot_);
+
+ oprot_->writeMessageEnd();
+ oprot_->getTransport()->flush();
+ oprot_->getTransport()->writeEnd();
+}
+
+void ThriftHiveMetastoreClient::recv_get_databases(std::vector<std::string> & _return)
+{
+
+ int32_t rseqid = 0;
+ std::string fname;
+ apache::thrift::protocol::TMessageType mtype;
+
+ iprot_->readMessageBegin(fname, mtype, rseqid);
+ if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+ apache::thrift::TApplicationException x;
+ x.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw x;
+ }
+ if (mtype != apache::thrift::protocol::T_REPLY) {
+ iprot_->skip(apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
+ }
+ if (fname.compare("get_databases") != 0) {
+ iprot_->skip(apache::thrift::protocol::T_STRUCT);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+ throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
+ }
+ ThriftHiveMetastore_get_databases_presult result;
+ result.success = &_return;
+ result.read(iprot_);
+ iprot_->readMessageEnd();
+ iprot_->getTransport()->readEnd();
+
+ if (result.__isset.success) {
+ // _return pointer has now been filled
+ return;
+ }
+ if (result.__isset.o1) {
+ throw result.o1;
+ }
+ throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "get_databases failed: unknown result");
+}
+
+void ThriftHiveMetastoreClient::get_type(Type& _return, const std::string& name)
+{
+ send_get_type(name);
+ recv_get_type(_return);
}
-void ThriftHiveMetastoreClient::send_create_database(const std::string& name, const std::string& description)
+void ThriftHiveMetastoreClient::send_get_type(const std::string& name)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("create_database", apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("get_type", apache::thrift::protocol::T_CALL, cseqid);
- ThriftHiveMetastore_create_database_pargs args;
+ ThriftHiveMetastore_get_type_pargs args;
args.name = &name;
- args.description = &description;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -6804,7 +8255,7 @@ void ThriftHiveMetastoreClient::send_cre
oprot_->getTransport()->writeEnd();
}
-bool ThriftHiveMetastoreClient::recv_create_database()
+void ThriftHiveMetastoreClient::recv_get_type(Type& _return)
{
int32_t rseqid = 0;
@@ -6825,44 +8276,41 @@ bool ThriftHiveMetastoreClient::recv_cre
iprot_->getTransport()->readEnd();
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
}
- if (fname.compare("create_database") != 0) {
+ if (fname.compare("get_type") != 0) {
iprot_->skip(apache::thrift::protocol::T_STRUCT);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
}
- bool _return;
- ThriftHiveMetastore_create_database_presult result;
+ ThriftHiveMetastore_get_type_presult result;
result.success = &_return;
result.read(iprot_);
iprot_->readMessageEnd();
iprot_->getTransport()->readEnd();
if (result.__isset.success) {
- return _return;
- }
- if (result.__isset.o1) {
- throw result.o1;
+ // _return pointer has now been filled
+ return;
}
if (result.__isset.o2) {
throw result.o2;
}
- throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "create_database failed: unknown result");
+ throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT, "get_type failed: unknown result");
}
-void ThriftHiveMetastoreClient::get_database(Database& _return, const std::string& name)
+bool ThriftHiveMetastoreClient::create_type(const Type& type)
{
- send_get_database(name);
- recv_get_database(_return);
+ send_create_type(type);
+ return recv_create_type();
}
-void ThriftHiveMetastoreClient::send_get_database(const std::string& name)
+void ThriftHiveMetastoreClient::send_create_type(const Type& type)
{
int32_t cseqid = 0;
- oprot_->writeMessageBegin("get_database", apache::thrift::protocol::T_CALL, cseqid);
+ oprot_->writeMessageBegin("create_type", apache::thrift::protocol::T_CALL, cseqid);
- ThriftHiveMetastore_get_database_pargs args;
- args.name = &name;
+ ThriftHiveMetastore_create_type_pargs args;
+ args.type = &type;
args.write(oprot_);
oprot_->writeMessageEnd();
@@ -6870,7 +8318,7 @@ void ThriftHiveMetastoreClient::send_get
oprot_->getTransport()->writeEnd();
}
-void ThriftHiveMetastoreClient::recv_get_database(Database& _return)
+bool ThriftHiveMetastoreClient::recv_create_type()
{
int32_t rseqid = 0;
@@ -6891,21 +8339,21 @@ void ThriftHiveMetastoreClient::recv_get
iprot_->getTransport()->readEnd();
[... 2082 lines stripped ...]