FAQ
http://git-wip-us.apache.org/repos/asf/hive/blob/96c9ee64/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
----------------------------------------------------------------------
diff --git a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
index 0354fe1..9a0ab8b 100644
--- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
@@ -11628,6 +11628,401 @@ uint32_t ThriftHiveMetastore_exchange_partition_presult::read(::apache::thrift::
  }


+ThriftHiveMetastore_exchange_partitions_args::~ThriftHiveMetastore_exchange_partitions_args() throw() {
+}
+
+
+uint32_t ThriftHiveMetastore_exchange_partitions_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_MAP) {
+ {
+ this->partitionSpecs.clear();
+ uint32_t _size839;
+ ::apache::thrift::protocol::TType _ktype840;
+ ::apache::thrift::protocol::TType _vtype841;
+ xfer += iprot->readMapBegin(_ktype840, _vtype841, _size839);
+ uint32_t _i843;
+ for (_i843 = 0; _i843 < _size839; ++_i843)
+ {
+ std::string _key844;
+ xfer += iprot->readString(_key844);
+ std::string& _val845 = this->partitionSpecs[_key844];
+ xfer += iprot->readString(_val845);
+ }
+ xfer += iprot->readMapEnd();
+ }
+ this->__isset.partitionSpecs = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->source_db);
+ this->__isset.source_db = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->source_table_name);
+ this->__isset.source_table_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->dest_db);
+ this->__isset.dest_db = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->dest_table_name);
+ this->__isset.dest_table_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_exchange_partitions_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_exchange_partitions_args");
+
+ xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->partitionSpecs.size()));
+ std::map<std::string, std::string> ::const_iterator _iter846;
+ for (_iter846 = this->partitionSpecs.begin(); _iter846 != this->partitionSpecs.end(); ++_iter846)
+ {
+ xfer += oprot->writeString(_iter846->first);
+ xfer += oprot->writeString(_iter846->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("source_db", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->source_db);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("source_table_name", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->source_table_name);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("dest_db", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString(this->dest_db);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("dest_table_name", ::apache::thrift::protocol::T_STRING, 5);
+ xfer += oprot->writeString(this->dest_table_name);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
+ return xfer;
+}
+
+
+ThriftHiveMetastore_exchange_partitions_pargs::~ThriftHiveMetastore_exchange_partitions_pargs() throw() {
+}
+
+
+uint32_t ThriftHiveMetastore_exchange_partitions_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ oprot->incrementRecursionDepth();
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_exchange_partitions_pargs");
+
+ xfer += oprot->writeFieldBegin("partitionSpecs", ::apache::thrift::protocol::T_MAP, 1);
+ {
+ xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->partitionSpecs)).size()));
+ std::map<std::string, std::string> ::const_iterator _iter847;
+ for (_iter847 = (*(this->partitionSpecs)).begin(); _iter847 != (*(this->partitionSpecs)).end(); ++_iter847)
+ {
+ xfer += oprot->writeString(_iter847->first);
+ xfer += oprot->writeString(_iter847->second);
+ }
+ xfer += oprot->writeMapEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("source_db", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString((*(this->source_db)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("source_table_name", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString((*(this->source_table_name)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("dest_db", ::apache::thrift::protocol::T_STRING, 4);
+ xfer += oprot->writeString((*(this->dest_db)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("dest_table_name", ::apache::thrift::protocol::T_STRING, 5);
+ xfer += oprot->writeString((*(this->dest_table_name)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ oprot->decrementRecursionDepth();
+ return xfer;
+}
+
+
+ThriftHiveMetastore_exchange_partitions_result::~ThriftHiveMetastore_exchange_partitions_result() throw() {
+}
+
+
+uint32_t ThriftHiveMetastore_exchange_partitions_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 _size848;
+ ::apache::thrift::protocol::TType _etype851;
+ xfer += iprot->readListBegin(_etype851, _size848);
+ this->success.resize(_size848);
+ uint32_t _i852;
+ for (_i852 = 0; _i852 < _size848; ++_i852)
+ {
+ xfer += this->success[_i852].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ 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;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o4.read(iprot);
+ this->__isset.o4 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_exchange_partitions_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_exchange_partitions_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
+ {
+ xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
+ std::vector<Partition> ::const_iterator _iter853;
+ for (_iter853 = this->success.begin(); _iter853 != this->success.end(); ++_iter853)
+ {
+ xfer += (*_iter853).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();
+ } else if (this->__isset.o3) {
+ xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->o3.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o4) {
+ xfer += oprot->writeFieldBegin("o4", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->o4.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+
+ThriftHiveMetastore_exchange_partitions_presult::~ThriftHiveMetastore_exchange_partitions_presult() throw() {
+}
+
+
+uint32_t ThriftHiveMetastore_exchange_partitions_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 _size854;
+ ::apache::thrift::protocol::TType _etype857;
+ xfer += iprot->readListBegin(_etype857, _size854);
+ (*(this->success)).resize(_size854);
+ uint32_t _i858;
+ for (_i858 = 0; _i858 < _size854; ++_i858)
+ {
+ xfer += (*(this->success))[_i858].read(iprot);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ 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;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o4.read(iprot);
+ this->__isset.o4 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+
  ThriftHiveMetastore_get_partition_with_auth_args::~ThriftHiveMetastore_get_partition_with_auth_args() throw() {
  }

@@ -11672,14 +12067,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size839;
- ::apache::thrift::protocol::TType _etype842;
- xfer += iprot->readListBegin(_etype842, _size839);
- this->part_vals.resize(_size839);
- uint32_t _i843;
- for (_i843 = 0; _i843 < _size839; ++_i843)
+ uint32_t _size859;
+ ::apache::thrift::protocol::TType _etype862;
+ xfer += iprot->readListBegin(_etype862, _size859);
+ this->part_vals.resize(_size859);
+ uint32_t _i863;
+ for (_i863 = 0; _i863 < _size859; ++_i863)
              {
- xfer += iprot->readString(this->part_vals[_i843]);
+ xfer += iprot->readString(this->part_vals[_i863]);
              }
              xfer += iprot->readListEnd();
            }
@@ -11700,14 +12095,14 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->group_names.clear();
- uint32_t _size844;
- ::apache::thrift::protocol::TType _etype847;
- xfer += iprot->readListBegin(_etype847, _size844);
- this->group_names.resize(_size844);
- uint32_t _i848;
- for (_i848 = 0; _i848 < _size844; ++_i848)
+ uint32_t _size864;
+ ::apache::thrift::protocol::TType _etype867;
+ xfer += iprot->readListBegin(_etype867, _size864);
+ this->group_names.resize(_size864);
+ uint32_t _i868;
+ for (_i868 = 0; _i868 < _size864; ++_i868)
              {
- xfer += iprot->readString(this->group_names[_i848]);
+ xfer += iprot->readString(this->group_names[_i868]);
              }
              xfer += iprot->readListEnd();
            }
@@ -11744,10 +12139,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::vector<std::string> ::const_iterator _iter849;
- for (_iter849 = this->part_vals.begin(); _iter849 != this->part_vals.end(); ++_iter849)
+ std::vector<std::string> ::const_iterator _iter869;
+ for (_iter869 = this->part_vals.begin(); _iter869 != this->part_vals.end(); ++_iter869)
      {
- xfer += oprot->writeString((*_iter849));
+ xfer += oprot->writeString((*_iter869));
      }
      xfer += oprot->writeListEnd();
    }
@@ -11760,10 +12155,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_args::write(::apache::thrif
    xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->group_names.size()));
- std::vector<std::string> ::const_iterator _iter850;
- for (_iter850 = this->group_names.begin(); _iter850 != this->group_names.end(); ++_iter850)
+ std::vector<std::string> ::const_iterator _iter870;
+ for (_iter870 = this->group_names.begin(); _iter870 != this->group_names.end(); ++_iter870)
      {
- xfer += oprot->writeString((*_iter850));
+ xfer += oprot->writeString((*_iter870));
      }
      xfer += oprot->writeListEnd();
    }
@@ -11796,10 +12191,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter851;
- for (_iter851 = (*(this->part_vals)).begin(); _iter851 != (*(this->part_vals)).end(); ++_iter851)
+ std::vector<std::string> ::const_iterator _iter871;
+ for (_iter871 = (*(this->part_vals)).begin(); _iter871 != (*(this->part_vals)).end(); ++_iter871)
      {
- xfer += oprot->writeString((*_iter851));
+ xfer += oprot->writeString((*_iter871));
      }
      xfer += oprot->writeListEnd();
    }
@@ -11812,10 +12207,10 @@ uint32_t ThriftHiveMetastore_get_partition_with_auth_pargs::write(::apache::thri
    xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->group_names)).size()));
- std::vector<std::string> ::const_iterator _iter852;
- for (_iter852 = (*(this->group_names)).begin(); _iter852 != (*(this->group_names)).end(); ++_iter852)
+ std::vector<std::string> ::const_iterator _iter872;
+ for (_iter872 = (*(this->group_names)).begin(); _iter872 != (*(this->group_names)).end(); ++_iter872)
      {
- xfer += oprot->writeString((*_iter852));
+ xfer += oprot->writeString((*_iter872));
      }
      xfer += oprot->writeListEnd();
    }
@@ -12372,14 +12767,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size853;
- ::apache::thrift::protocol::TType _etype856;
- xfer += iprot->readListBegin(_etype856, _size853);
- this->success.resize(_size853);
- uint32_t _i857;
- for (_i857 = 0; _i857 < _size853; ++_i857)
+ uint32_t _size873;
+ ::apache::thrift::protocol::TType _etype876;
+ xfer += iprot->readListBegin(_etype876, _size873);
+ this->success.resize(_size873);
+ uint32_t _i877;
+ for (_i877 = 0; _i877 < _size873; ++_i877)
              {
- xfer += this->success[_i857].read(iprot);
+ xfer += this->success[_i877].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -12426,10 +12821,10 @@ uint32_t ThriftHiveMetastore_get_partitions_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<Partition> ::const_iterator _iter858;
- for (_iter858 = this->success.begin(); _iter858 != this->success.end(); ++_iter858)
+ std::vector<Partition> ::const_iterator _iter878;
+ for (_iter878 = this->success.begin(); _iter878 != this->success.end(); ++_iter878)
        {
- xfer += (*_iter858).write(oprot);
+ xfer += (*_iter878).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -12477,14 +12872,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size859;
- ::apache::thrift::protocol::TType _etype862;
- xfer += iprot->readListBegin(_etype862, _size859);
- (*(this->success)).resize(_size859);
- uint32_t _i863;
- for (_i863 = 0; _i863 < _size859; ++_i863)
+ uint32_t _size879;
+ ::apache::thrift::protocol::TType _etype882;
+ xfer += iprot->readListBegin(_etype882, _size879);
+ (*(this->success)).resize(_size879);
+ uint32_t _i883;
+ for (_i883 = 0; _i883 < _size879; ++_i883)
              {
- xfer += (*(this->success))[_i863].read(iprot);
+ xfer += (*(this->success))[_i883].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -12582,14 +12977,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::read(::apache::thrif
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->group_names.clear();
- uint32_t _size864;
- ::apache::thrift::protocol::TType _etype867;
- xfer += iprot->readListBegin(_etype867, _size864);
- this->group_names.resize(_size864);
- uint32_t _i868;
- for (_i868 = 0; _i868 < _size864; ++_i868)
+ uint32_t _size884;
+ ::apache::thrift::protocol::TType _etype887;
+ xfer += iprot->readListBegin(_etype887, _size884);
+ this->group_names.resize(_size884);
+ uint32_t _i888;
+ for (_i888 = 0; _i888 < _size884; ++_i888)
              {
- xfer += iprot->readString(this->group_names[_i868]);
+ xfer += iprot->readString(this->group_names[_i888]);
              }
              xfer += iprot->readListEnd();
            }
@@ -12634,10 +13029,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_args::write(::apache::thri
    xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->group_names.size()));
- std::vector<std::string> ::const_iterator _iter869;
- for (_iter869 = this->group_names.begin(); _iter869 != this->group_names.end(); ++_iter869)
+ std::vector<std::string> ::const_iterator _iter889;
+ for (_iter889 = this->group_names.begin(); _iter889 != this->group_names.end(); ++_iter889)
      {
- xfer += oprot->writeString((*_iter869));
+ xfer += oprot->writeString((*_iter889));
      }
      xfer += oprot->writeListEnd();
    }
@@ -12678,10 +13073,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_pargs::write(::apache::thr
    xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 5);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->group_names)).size()));
- std::vector<std::string> ::const_iterator _iter870;
- for (_iter870 = (*(this->group_names)).begin(); _iter870 != (*(this->group_names)).end(); ++_iter870)
+ std::vector<std::string> ::const_iterator _iter890;
+ for (_iter890 = (*(this->group_names)).begin(); _iter890 != (*(this->group_names)).end(); ++_iter890)
      {
- xfer += oprot->writeString((*_iter870));
+ xfer += oprot->writeString((*_iter890));
      }
      xfer += oprot->writeListEnd();
    }
@@ -12722,14 +13117,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size871;
- ::apache::thrift::protocol::TType _etype874;
- xfer += iprot->readListBegin(_etype874, _size871);
- this->success.resize(_size871);
- uint32_t _i875;
- for (_i875 = 0; _i875 < _size871; ++_i875)
+ uint32_t _size891;
+ ::apache::thrift::protocol::TType _etype894;
+ xfer += iprot->readListBegin(_etype894, _size891);
+ this->success.resize(_size891);
+ uint32_t _i895;
+ for (_i895 = 0; _i895 < _size891; ++_i895)
              {
- xfer += this->success[_i875].read(iprot);
+ xfer += this->success[_i895].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -12776,10 +13171,10 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::write(::apache::th
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<Partition> ::const_iterator _iter876;
- for (_iter876 = this->success.begin(); _iter876 != this->success.end(); ++_iter876)
+ std::vector<Partition> ::const_iterator _iter896;
+ for (_iter896 = this->success.begin(); _iter896 != this->success.end(); ++_iter896)
        {
- xfer += (*_iter876).write(oprot);
+ xfer += (*_iter896).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -12827,14 +13222,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size877;
- ::apache::thrift::protocol::TType _etype880;
- xfer += iprot->readListBegin(_etype880, _size877);
- (*(this->success)).resize(_size877);
- uint32_t _i881;
- for (_i881 = 0; _i881 < _size877; ++_i881)
+ uint32_t _size897;
+ ::apache::thrift::protocol::TType _etype900;
+ xfer += iprot->readListBegin(_etype900, _size897);
+ (*(this->success)).resize(_size897);
+ uint32_t _i901;
+ for (_i901 = 0; _i901 < _size897; ++_i901)
              {
- xfer += (*(this->success))[_i881].read(iprot);
+ xfer += (*(this->success))[_i901].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -13012,14 +13407,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size882;
- ::apache::thrift::protocol::TType _etype885;
- xfer += iprot->readListBegin(_etype885, _size882);
- this->success.resize(_size882);
- uint32_t _i886;
- for (_i886 = 0; _i886 < _size882; ++_i886)
+ uint32_t _size902;
+ ::apache::thrift::protocol::TType _etype905;
+ xfer += iprot->readListBegin(_etype905, _size902);
+ this->success.resize(_size902);
+ uint32_t _i906;
+ for (_i906 = 0; _i906 < _size902; ++_i906)
              {
- xfer += this->success[_i886].read(iprot);
+ xfer += this->success[_i906].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -13066,10 +13461,10 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::write(::apache::thrift
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<PartitionSpec> ::const_iterator _iter887;
- for (_iter887 = this->success.begin(); _iter887 != this->success.end(); ++_iter887)
+ std::vector<PartitionSpec> ::const_iterator _iter907;
+ for (_iter907 = this->success.begin(); _iter907 != this->success.end(); ++_iter907)
        {
- xfer += (*_iter887).write(oprot);
+ xfer += (*_iter907).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -13117,14 +13512,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size888;
- ::apache::thrift::protocol::TType _etype891;
- xfer += iprot->readListBegin(_etype891, _size888);
- (*(this->success)).resize(_size888);
- uint32_t _i892;
- for (_i892 = 0; _i892 < _size888; ++_i892)
+ uint32_t _size908;
+ ::apache::thrift::protocol::TType _etype911;
+ xfer += iprot->readListBegin(_etype911, _size908);
+ (*(this->success)).resize(_size908);
+ uint32_t _i912;
+ for (_i912 = 0; _i912 < _size908; ++_i912)
              {
- xfer += (*(this->success))[_i892].read(iprot);
+ xfer += (*(this->success))[_i912].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -13302,14 +13697,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift::
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size893;
- ::apache::thrift::protocol::TType _etype896;
- xfer += iprot->readListBegin(_etype896, _size893);
- this->success.resize(_size893);
- uint32_t _i897;
- for (_i897 = 0; _i897 < _size893; ++_i897)
+ uint32_t _size913;
+ ::apache::thrift::protocol::TType _etype916;
+ xfer += iprot->readListBegin(_etype916, _size913);
+ this->success.resize(_size913);
+ uint32_t _i917;
+ for (_i917 = 0; _i917 < _size913; ++_i917)
              {
- xfer += iprot->readString(this->success[_i897]);
+ xfer += iprot->readString(this->success[_i917]);
              }
              xfer += iprot->readListEnd();
            }
@@ -13348,10 +13743,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_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 _iter898;
- for (_iter898 = this->success.begin(); _iter898 != this->success.end(); ++_iter898)
+ std::vector<std::string> ::const_iterator _iter918;
+ for (_iter918 = this->success.begin(); _iter918 != this->success.end(); ++_iter918)
        {
- xfer += oprot->writeString((*_iter898));
+ xfer += oprot->writeString((*_iter918));
        }
        xfer += oprot->writeListEnd();
      }
@@ -13395,14 +13790,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_presult::read(::apache::thrift:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size899;
- ::apache::thrift::protocol::TType _etype902;
- xfer += iprot->readListBegin(_etype902, _size899);
- (*(this->success)).resize(_size899);
- uint32_t _i903;
- for (_i903 = 0; _i903 < _size899; ++_i903)
+ uint32_t _size919;
+ ::apache::thrift::protocol::TType _etype922;
+ xfer += iprot->readListBegin(_etype922, _size919);
+ (*(this->success)).resize(_size919);
+ uint32_t _i923;
+ for (_i923 = 0; _i923 < _size919; ++_i923)
              {
- xfer += iprot->readString((*(this->success))[_i903]);
+ xfer += iprot->readString((*(this->success))[_i923]);
              }
              xfer += iprot->readListEnd();
            }
@@ -13476,14 +13871,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::read(::apache::thrift::prot
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size904;
- ::apache::thrift::protocol::TType _etype907;
- xfer += iprot->readListBegin(_etype907, _size904);
- this->part_vals.resize(_size904);
- uint32_t _i908;
- for (_i908 = 0; _i908 < _size904; ++_i908)
+ uint32_t _size924;
+ ::apache::thrift::protocol::TType _etype927;
+ xfer += iprot->readListBegin(_etype927, _size924);
+ this->part_vals.resize(_size924);
+ uint32_t _i928;
+ for (_i928 = 0; _i928 < _size924; ++_i928)
              {
- xfer += iprot->readString(this->part_vals[_i908]);
+ xfer += iprot->readString(this->part_vals[_i928]);
              }
              xfer += iprot->readListEnd();
            }
@@ -13528,10 +13923,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_args::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 _iter909;
- for (_iter909 = this->part_vals.begin(); _iter909 != this->part_vals.end(); ++_iter909)
+ std::vector<std::string> ::const_iterator _iter929;
+ for (_iter929 = this->part_vals.begin(); _iter929 != this->part_vals.end(); ++_iter929)
      {
- xfer += oprot->writeString((*_iter909));
+ xfer += oprot->writeString((*_iter929));
      }
      xfer += oprot->writeListEnd();
    }
@@ -13568,10 +13963,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_pargs::write(::apache::thrift::pr
    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 _iter910;
- for (_iter910 = (*(this->part_vals)).begin(); _iter910 != (*(this->part_vals)).end(); ++_iter910)
+ std::vector<std::string> ::const_iterator _iter930;
+ for (_iter930 = (*(this->part_vals)).begin(); _iter930 != (*(this->part_vals)).end(); ++_iter930)
      {
- xfer += oprot->writeString((*_iter910));
+ xfer += oprot->writeString((*_iter930));
      }
      xfer += oprot->writeListEnd();
    }
@@ -13616,14 +14011,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(::apache::thrift::pr
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size911;
- ::apache::thrift::protocol::TType _etype914;
- xfer += iprot->readListBegin(_etype914, _size911);
- this->success.resize(_size911);
- uint32_t _i915;
- for (_i915 = 0; _i915 < _size911; ++_i915)
+ uint32_t _size931;
+ ::apache::thrift::protocol::TType _etype934;
+ xfer += iprot->readListBegin(_etype934, _size931);
+ this->success.resize(_size931);
+ uint32_t _i935;
+ for (_i935 = 0; _i935 < _size931; ++_i935)
              {
- xfer += this->success[_i915].read(iprot);
+ xfer += this->success[_i935].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -13670,10 +14065,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_result::write(::apache::thrift::p
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<Partition> ::const_iterator _iter916;
- for (_iter916 = this->success.begin(); _iter916 != this->success.end(); ++_iter916)
+ std::vector<Partition> ::const_iterator _iter936;
+ for (_iter936 = this->success.begin(); _iter936 != this->success.end(); ++_iter936)
        {
- xfer += (*_iter916).write(oprot);
+ xfer += (*_iter936).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -13721,14 +14116,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(::apache::thrift::p
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size917;
- ::apache::thrift::protocol::TType _etype920;
- xfer += iprot->readListBegin(_etype920, _size917);
- (*(this->success)).resize(_size917);
- uint32_t _i921;
- for (_i921 = 0; _i921 < _size917; ++_i921)
+ uint32_t _size937;
+ ::apache::thrift::protocol::TType _etype940;
+ xfer += iprot->readListBegin(_etype940, _size937);
+ (*(this->success)).resize(_size937);
+ uint32_t _i941;
+ for (_i941 = 0; _i941 < _size937; ++_i941)
              {
- xfer += (*(this->success))[_i921].read(iprot);
+ xfer += (*(this->success))[_i941].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -13810,14 +14205,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size922;
- ::apache::thrift::protocol::TType _etype925;
- xfer += iprot->readListBegin(_etype925, _size922);
- this->part_vals.resize(_size922);
- uint32_t _i926;
- for (_i926 = 0; _i926 < _size922; ++_i926)
+ uint32_t _size942;
+ ::apache::thrift::protocol::TType _etype945;
+ xfer += iprot->readListBegin(_etype945, _size942);
+ this->part_vals.resize(_size942);
+ uint32_t _i946;
+ for (_i946 = 0; _i946 < _size942; ++_i946)
              {
- xfer += iprot->readString(this->part_vals[_i926]);
+ xfer += iprot->readString(this->part_vals[_i946]);
              }
              xfer += iprot->readListEnd();
            }
@@ -13846,14 +14241,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::read(::apache::th
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->group_names.clear();
- uint32_t _size927;
- ::apache::thrift::protocol::TType _etype930;
- xfer += iprot->readListBegin(_etype930, _size927);
- this->group_names.resize(_size927);
- uint32_t _i931;
- for (_i931 = 0; _i931 < _size927; ++_i931)
+ uint32_t _size947;
+ ::apache::thrift::protocol::TType _etype950;
+ xfer += iprot->readListBegin(_etype950, _size947);
+ this->group_names.resize(_size947);
+ uint32_t _i951;
+ for (_i951 = 0; _i951 < _size947; ++_i951)
              {
- xfer += iprot->readString(this->group_names[_i931]);
+ xfer += iprot->readString(this->group_names[_i951]);
              }
              xfer += iprot->readListEnd();
            }
@@ -13890,10 +14285,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t
    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 _iter932;
- for (_iter932 = this->part_vals.begin(); _iter932 != this->part_vals.end(); ++_iter932)
+ std::vector<std::string> ::const_iterator _iter952;
+ for (_iter952 = this->part_vals.begin(); _iter952 != this->part_vals.end(); ++_iter952)
      {
- xfer += oprot->writeString((*_iter932));
+ xfer += oprot->writeString((*_iter952));
      }
      xfer += oprot->writeListEnd();
    }
@@ -13910,10 +14305,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_args::write(::apache::t
    xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->group_names.size()));
- std::vector<std::string> ::const_iterator _iter933;
- for (_iter933 = this->group_names.begin(); _iter933 != this->group_names.end(); ++_iter933)
+ std::vector<std::string> ::const_iterator _iter953;
+ for (_iter953 = this->group_names.begin(); _iter953 != this->group_names.end(); ++_iter953)
      {
- xfer += oprot->writeString((*_iter933));
+ xfer += oprot->writeString((*_iter953));
      }
      xfer += oprot->writeListEnd();
    }
@@ -13946,10 +14341,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache::
    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 _iter934;
- for (_iter934 = (*(this->part_vals)).begin(); _iter934 != (*(this->part_vals)).end(); ++_iter934)
+ std::vector<std::string> ::const_iterator _iter954;
+ for (_iter954 = (*(this->part_vals)).begin(); _iter954 != (*(this->part_vals)).end(); ++_iter954)
      {
- xfer += oprot->writeString((*_iter934));
+ xfer += oprot->writeString((*_iter954));
      }
      xfer += oprot->writeListEnd();
    }
@@ -13966,10 +14361,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_pargs::write(::apache::
    xfer += oprot->writeFieldBegin("group_names", ::apache::thrift::protocol::T_LIST, 6);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->group_names)).size()));
- std::vector<std::string> ::const_iterator _iter935;
- for (_iter935 = (*(this->group_names)).begin(); _iter935 != (*(this->group_names)).end(); ++_iter935)
+ std::vector<std::string> ::const_iterator _iter955;
+ for (_iter955 = (*(this->group_names)).begin(); _iter955 != (*(this->group_names)).end(); ++_iter955)
      {
- xfer += oprot->writeString((*_iter935));
+ xfer += oprot->writeString((*_iter955));
      }
      xfer += oprot->writeListEnd();
    }
@@ -14010,14 +14405,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::read(::apache::
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size936;
- ::apache::thrift::protocol::TType _etype939;
- xfer += iprot->readListBegin(_etype939, _size936);
- this->success.resize(_size936);
- uint32_t _i940;
- for (_i940 = 0; _i940 < _size936; ++_i940)
+ uint32_t _size956;
+ ::apache::thrift::protocol::TType _etype959;
+ xfer += iprot->readListBegin(_etype959, _size956);
+ this->success.resize(_size956);
+ uint32_t _i960;
+ for (_i960 = 0; _i960 < _size956; ++_i960)
              {
- xfer += this->success[_i940].read(iprot);
+ xfer += this->success[_i960].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -14064,10 +14459,10 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_result::write(::apache:
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<Partition> ::const_iterator _iter941;
- for (_iter941 = this->success.begin(); _iter941 != this->success.end(); ++_iter941)
+ std::vector<Partition> ::const_iterator _iter961;
+ for (_iter961 = this->success.begin(); _iter961 != this->success.end(); ++_iter961)
        {
- xfer += (*_iter941).write(oprot);
+ xfer += (*_iter961).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -14115,14 +14510,14 @@ uint32_t ThriftHiveMetastore_get_partitions_ps_with_auth_presult::read(::apache:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size942;
- ::apache::thrift::protocol::TType _etype945;
- xfer += iprot->readListBegin(_etype945, _size942);
- (*(this->success)).resize(_size942);
- uint32_t _i946;
- for (_i946 = 0; _i946 < _size942; ++_i946)
+ uint32_t _size962;
+ ::apache::thrift::protocol::TType _etype965;
+ xfer += iprot->readListBegin(_etype965, _size962);
+ (*(this->success)).resize(_size962);
+ uint32_t _i966;
+ for (_i966 = 0; _i966 < _size962; ++_i966)
              {
- xfer += (*(this->success))[_i946].read(iprot);
+ xfer += (*(this->success))[_i966].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -14204,14 +14599,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::read(::apache::thrift:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size947;
- ::apache::thrift::protocol::TType _etype950;
- xfer += iprot->readListBegin(_etype950, _size947);
- this->part_vals.resize(_size947);
- uint32_t _i951;
- for (_i951 = 0; _i951 < _size947; ++_i951)
+ uint32_t _size967;
+ ::apache::thrift::protocol::TType _etype970;
+ xfer += iprot->readListBegin(_etype970, _size967);
+ this->part_vals.resize(_size967);
+ uint32_t _i971;
+ for (_i971 = 0; _i971 < _size967; ++_i971)
              {
- xfer += iprot->readString(this->part_vals[_i951]);
+ xfer += iprot->readString(this->part_vals[_i971]);
              }
              xfer += iprot->readListEnd();
            }
@@ -14256,10 +14651,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_args::write(::apache::thrift
    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 _iter952;
- for (_iter952 = this->part_vals.begin(); _iter952 != this->part_vals.end(); ++_iter952)
+ std::vector<std::string> ::const_iterator _iter972;
+ for (_iter972 = this->part_vals.begin(); _iter972 != this->part_vals.end(); ++_iter972)
      {
- xfer += oprot->writeString((*_iter952));
+ xfer += oprot->writeString((*_iter972));
      }
      xfer += oprot->writeListEnd();
    }
@@ -14296,10 +14691,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_pargs::write(::apache::thrif
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter953;
- for (_iter953 = (*(this->part_vals)).begin(); _iter953 != (*(this->part_vals)).end(); ++_iter953)
+ std::vector<std::string> ::const_iterator _iter973;
+ for (_iter973 = (*(this->part_vals)).begin(); _iter973 != (*(this->part_vals)).end(); ++_iter973)
      {
- xfer += oprot->writeString((*_iter953));
+ xfer += oprot->writeString((*_iter973));
      }
      xfer += oprot->writeListEnd();
    }
@@ -14344,14 +14739,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(::apache::thrif
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size954;
- ::apache::thrift::protocol::TType _etype957;
- xfer += iprot->readListBegin(_etype957, _size954);
- this->success.resize(_size954);
- uint32_t _i958;
- for (_i958 = 0; _i958 < _size954; ++_i958)
+ uint32_t _size974;
+ ::apache::thrift::protocol::TType _etype977;
+ xfer += iprot->readListBegin(_etype977, _size974);
+ this->success.resize(_size974);
+ uint32_t _i978;
+ for (_i978 = 0; _i978 < _size974; ++_i978)
              {
- xfer += iprot->readString(this->success[_i958]);
+ xfer += iprot->readString(this->success[_i978]);
              }
              xfer += iprot->readListEnd();
            }
@@ -14398,10 +14793,10 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_result::write(::apache::thri
      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 _iter959;
- for (_iter959 = this->success.begin(); _iter959 != this->success.end(); ++_iter959)
+ std::vector<std::string> ::const_iterator _iter979;
+ for (_iter979 = this->success.begin(); _iter979 != this->success.end(); ++_iter979)
        {
- xfer += oprot->writeString((*_iter959));
+ xfer += oprot->writeString((*_iter979));
        }
        xfer += oprot->writeListEnd();
      }
@@ -14449,14 +14844,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(::apache::thri
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size960;
- ::apache::thrift::protocol::TType _etype963;
- xfer += iprot->readListBegin(_etype963, _size960);
- (*(this->success)).resize(_size960);
- uint32_t _i964;
- for (_i964 = 0; _i964 < _size960; ++_i964)
+ uint32_t _size980;
+ ::apache::thrift::protocol::TType _etype983;
+ xfer += iprot->readListBegin(_etype983, _size980);
+ (*(this->success)).resize(_size980);
+ uint32_t _i984;
+ for (_i984 = 0; _i984 < _size980; ++_i984)
              {
- xfer += iprot->readString((*(this->success))[_i964]);
+ xfer += iprot->readString((*(this->success))[_i984]);
              }
              xfer += iprot->readListEnd();
            }
@@ -14650,14 +15045,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::read(::apache::thr
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size965;
- ::apache::thrift::protocol::TType _etype968;
- xfer += iprot->readListBegin(_etype968, _size965);
- this->success.resize(_size965);
- uint32_t _i969;
- for (_i969 = 0; _i969 < _size965; ++_i969)
+ uint32_t _size985;
+ ::apache::thrift::protocol::TType _etype988;
+ xfer += iprot->readListBegin(_etype988, _size985);
+ this->success.resize(_size985);
+ uint32_t _i989;
+ for (_i989 = 0; _i989 < _size985; ++_i989)
              {
- xfer += this->success[_i969].read(iprot);
+ xfer += this->success[_i989].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -14704,10 +15099,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_result::write(::apache::th
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<Partition> ::const_iterator _iter970;
- for (_iter970 = this->success.begin(); _iter970 != this->success.end(); ++_iter970)
+ std::vector<Partition> ::const_iterator _iter990;
+ for (_iter990 = this->success.begin(); _iter990 != this->success.end(); ++_iter990)
        {
- xfer += (*_iter970).write(oprot);
+ xfer += (*_iter990).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -14755,14 +15150,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_filter_presult::read(::apache::th
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size971;
- ::apache::thrift::protocol::TType _etype974;
- xfer += iprot->readListBegin(_etype974, _size971);
- (*(this->success)).resize(_size971);
- uint32_t _i975;
- for (_i975 = 0; _i975 < _size971; ++_i975)
+ uint32_t _size991;
+ ::apache::thrift::protocol::TType _etype994;
+ xfer += iprot->readListBegin(_etype994, _size991);
+ (*(this->success)).resize(_size991);
+ uint32_t _i995;
+ for (_i995 = 0; _i995 < _size991; ++_i995)
              {
- xfer += (*(this->success))[_i975].read(iprot);
+ xfer += (*(this->success))[_i995].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -14956,14 +15351,14 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::read(::apache::thr
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size976;
- ::apache::thrift::protocol::TType _etype979;
- xfer += iprot->readListBegin(_etype979, _size976);
- this->success.resize(_size976);
- uint32_t _i980;
- for (_i980 = 0; _i980 < _size976; ++_i980)
+ uint32_t _size996;
+ ::apache::thrift::protocol::TType _etype999;
+ xfer += iprot->readListBegin(_etype999, _size996);
+ this->success.resize(_size996);
+ uint32_t _i1000;
+ for (_i1000 = 0; _i1000 < _size996; ++_i1000)
              {
- xfer += this->success[_i980].read(iprot);
+ xfer += this->success[_i1000].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -15010,10 +15405,10 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_result::write(::apache::th
      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<PartitionSpec> ::const_iterator _iter981;
- for (_iter981 = this->success.begin(); _iter981 != this->success.end(); ++_iter981)
+ std::vector<PartitionSpec> ::const_iterator _iter1001;
+ for (_iter1001 = this->success.begin(); _iter1001 != this->success.end(); ++_iter1001)
        {
- xfer += (*_iter981).write(oprot);
+ xfer += (*_iter1001).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -15061,14 +15456,14 @@ uint32_t ThriftHiveMetastore_get_part_specs_by_filter_presult::read(::apache::th
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size982;
- ::apache::thrift::protocol::TType _etype985;
- xfer += iprot->readListBegin(_etype985, _size982);
- (*(this->success)).resize(_size982);
- uint32_t _i986;
- for (_i986 = 0; _i986 < _size982; ++_i986)
+ uint32_t _size1002;
+ ::apache::thrift::protocol::TType _etype1005;
+ xfer += iprot->readListBegin(_etype1005, _size1002);
+ (*(this->success)).resize(_size1002);
+ uint32_t _i1006;
+ for (_i1006 = 0; _i1006 < _size1002; ++_i1006)
              {
- xfer += (*(this->success))[_i986].read(iprot);
+ xfer += (*(this->success))[_i1006].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -15376,14 +15771,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::read(::apache::thrift
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->names.clear();
- uint32_t _size987;
- ::apache::thrift::protocol::TType _etype990;
- xfer += iprot->readListBegin(_etype990, _size987);
- this->names.resize(_size987);
- uint32_t _i991;
- for (_i991 = 0; _i991 < _size987; ++_i991)
+ uint32_t _size1007;
+ ::apache::thrift::protocol::TType _etype1010;
+ xfer += iprot->readListBegin(_etype1010, _size1007);
+ this->names.resize(_size1007);
+ uint32_t _i1011;
+ for (_i1011 = 0; _i1011 < _size1007; ++_i1011)
              {
- xfer += iprot->readString(this->names[_i991]);
+ xfer += iprot->readString(this->names[_i1011]);
              }
              xfer += iprot->readListEnd();
            }
@@ -15420,10 +15815,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_args::write(::apache::thrif
    xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->names.size()));
- std::vector<std::string> ::const_iterator _iter992;
- for (_iter992 = this->names.begin(); _iter992 != this->names.end(); ++_iter992)
+ std::vector<std::string> ::const_iterator _iter1012;
+ for (_iter1012 = this->names.begin(); _iter1012 != this->names.end(); ++_iter1012)
      {
- xfer += oprot->writeString((*_iter992));
+ xfer += oprot->writeString((*_iter1012));
      }
      xfer += oprot->writeListEnd();
    }
@@ -15456,10 +15851,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_pargs::write(::apache::thri
    xfer += oprot->writeFieldBegin("names", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->names)).size()));
- std::vector<std::string> ::const_iterator _iter993;
- for (_iter993 = (*(this->names)).begin(); _iter993 != (*(this->names)).end(); ++_iter993)
+ std::vector<std::string> ::const_iterator _iter1013;
+ for (_iter1013 = (*(this->names)).begin(); _iter1013 != (*(this->names)).end(); ++_iter1013)
      {
- xfer += oprot->writeString((*_iter993));
+ xfer += oprot->writeString((*_iter1013));
      }
      xfer += oprot->writeListEnd();
    }
@@ -15500,14 +15895,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::read(::apache::thri
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size994;
- ::apache::thrift::protocol::TType _etype997;
- xfer += iprot->readListBegin(_etype997, _size994);
- this->success.resize(_size994);
- uint32_t _i998;
- for (_i998 = 0; _i998 < _size994; ++_i998)
+ uint32_t _size1014;
+ ::apache::thrift::protocol::TType _etype1017;
+ xfer += iprot->readListBegin(_etype1017, _size1014);
+ this->success.resize(_size1014);
+ uint32_t _i1018;
+ for (_i1018 = 0; _i1018 < _size1014; ++_i1018)
              {
- xfer += this->success[_i998].read(iprot);
+ xfer += this->success[_i1018].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -15554,10 +15949,10 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_result::write(::apache::thr
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<Partition> ::const_iterator _iter999;
- for (_iter999 = this->success.begin(); _iter999 != this->success.end(); ++_iter999)
+ std::vector<Partition> ::const_iterator _iter1019;
+ for (_iter1019 = this->success.begin(); _iter1019 != this->success.end(); ++_iter1019)
        {
- xfer += (*_iter999).write(oprot);
+ xfer += (*_iter1019).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -15605,14 +16000,14 @@ uint32_t ThriftHiveMetastore_get_partitions_by_names_presult::read(::apache::thr
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size1000;
- ::apache::thrift::protocol::TType _etype1003;
- xfer += iprot->readListBegin(_etype1003, _size1000);
- (*(this->success)).resize(_size1000);
- uint32_t _i1004;
- for (_i1004 = 0; _i1004 < _size1000; ++_i1004)
+ uint32_t _size1020;
+ ::apache::thrift::protocol::TType _etype1023;
+ xfer += iprot->readListBegin(_etype1023, _size1020);
+ (*(this->success)).resize(_size1020);
+ uint32_t _i1024;
+ for (_i1024 = 0; _i1024 < _size1020; ++_i1024)
              {
- xfer += (*(this->success))[_i1004].read(iprot);
+ xfer += (*(this->success))[_i1024].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -15932,14 +16327,14 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::read(::apache::thrift::proto
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->new_parts.clear();
- uint32_t _size1005;
- ::apache::thrift::protocol::TType _etype1008;
- xfer += iprot->readListBegin(_etype1008, _size1005);
- this->new_parts.resize(_size1005);
- uint32_t _i1009;
- for (_i1009 = 0; _i1009 < _size1005; ++_i1009)
+ uint32_t _size1025;
+ ::apache::thrift::protocol::TType _etype1028;
+ xfer += iprot->readListBegin(_etype1028, _size1025);
+ this->new_parts.resize(_size1025);
+ uint32_t _i1029;
+ for (_i1029 = 0; _i1029 < _size1025; ++_i1029)
              {
- xfer += this->new_parts[_i1009].read(iprot);
+ xfer += this->new_parts[_i1029].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -15976,10 +16371,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_args::write(::apache::thrift::prot
    xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->new_parts.size()));
- std::vector<Partition> ::const_iterator _iter1010;
- for (_iter1010 = this->new_parts.begin(); _iter1010 != this->new_parts.end(); ++_iter1010)
+ std::vector<Partition> ::const_iterator _iter1030;
+ for (_iter1030 = this->new_parts.begin(); _iter1030 != this->new_parts.end(); ++_iter1030)
      {
- xfer += (*_iter1010).write(oprot);
+ xfer += (*_iter1030).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -16012,10 +16407,10 @@ uint32_t ThriftHiveMetastore_alter_partitions_pargs::write(::apache::thrift::pro
    xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->new_parts)).size()));
- std::vector<Partition> ::const_iterator _iter1011;
- for (_iter1011 = (*(this->new_parts)).begin(); _iter1011 != (*(this->new_parts)).end(); ++_iter1011)
+ std::vector<Partition> ::const_iterator _iter1031;
+ for (_iter1031 = (*(this->new_parts)).begin(); _iter1031 != (*(this->new_parts)).end(); ++_iter1031)
      {
- xfer += (*_iter1011).write(oprot);
+ xfer += (*_iter1031).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -16452,14 +16847,14 @@ uint32_t ThriftHiveMetastore_rename_partition_args::read(::apache::thrift::proto
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size1012;
- ::apache::thrift::protocol::TType _etype1015;
- xfer += iprot->readListBegin(_etype1015, _size1012);
- this->part_vals.resize(_size1012);
- uint32_t _i1016;
- for (_i1016 = 0; _i1016 < _size1012; ++_i1016)
+ uint32_t _size1032;
+ ::apache::thrift::protocol::TType _etype1035;
+ xfer += iprot->readListBegin(_etype1035, _size1032);
+ this->part_vals.resize(_size1032);
+ uint32_t _i1036;
+ for (_i1036 = 0; _i1036 < _size1032; ++_i1036)
              {
- xfer += iprot->readString(this->part_vals[_i1016]);
+ xfer += iprot->readString(this->part_vals[_i1036]);
              }
              xfer += iprot->readListEnd();
            }
@@ -16504,10 +16899,10 @@ uint32_t ThriftHiveMetastore_rename_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 _iter1017;
- for (_iter1017 = this->part_vals.begin(); _iter1017 != this->part_vals.end(); ++_iter1017)
+ std::vector<std::string> ::const_iterator _iter1037;
+ for (_iter1037 = this->part_vals.begin(); _iter1037 != this->part_vals.end(); ++_iter1037)
      {
- xfer += oprot->writeString((*_iter1017));
+ xfer += oprot->writeString((*_iter1037));
      }
      xfer += oprot->writeListEnd();
    }
@@ -16544,10 +16939,10 @@ uint32_t ThriftHiveMetastore_rename_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 _iter1018;
- for (_iter1018 = (*(this->part_vals)).begin(); _iter1018 != (*(this->part_vals)).end(); ++_iter1018)
+ std::vector<std::string> ::const_iterator _iter1038;
+ for (_iter1038 = (*(this->part_vals)).begin(); _iter1038 != (*(this->part_vals)).end(); ++_iter1038)
      {
- xfer += oprot->writeString((*_iter1018));
+ xfer += oprot->writeString((*_iter1038));
      }
      xfer += oprot->writeListEnd();
    }
@@ -16718,14 +17113,14 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::read(::ap
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size1019;
- ::apache::thrift::protocol::TType _etype1022;
- xfer += iprot->readListBegin(_etype1022, _size1019);
- this->part_vals.resize(_size1019);
- uint32_t _i1023;
- for (_i1023 = 0; _i1023 < _size1019; ++_i1023)
+ uint32_t _size1039;
+ ::apache::thrift::protocol::TType _etype1042;
+ xfer += iprot->readListBegin(_etype1042, _size1039);
+ this->part_vals.resize(_size1039);
+ uint32_t _i1043;
+ for (_i1043 = 0; _i1043 < _size1039; ++_i1043)
              {
- xfer += iprot->readString(this->part_vals[_i1023]);
+ xfer += iprot->readString(this->part_vals[_i1043]);
              }
              xfer += iprot->readListEnd();
            }
@@ -16762,10 +17157,10 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_args::write(::a
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::vector<std::string> ::const_iterator _iter1024;
- for (_iter1024 = this->part_vals.begin(); _iter1024 != this->part_vals.end(); ++_iter1024)
+ std::vector<std::string> ::const_iterator _iter1044;
+ for (_iter1044 = this->part_vals.begin(); _iter1044 != this->part_vals.end(); ++_iter1044)
      {
- xfer += oprot->writeString((*_iter1024));
+ xfer += oprot->writeString((*_iter1044));
      }
      xfer += oprot->writeListEnd();
    }
@@ -16794,10 +17189,10 @@ uint32_t ThriftHiveMetastore_partition_name_has_valid_characters_pargs::write(::
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 1);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter1025;
- for (_iter1025 = (*(this->part_vals)).begin(); _iter1025 != (*(this->part_vals)).end(); ++_iter1025)
+ std::vector<std::string> ::const_iterator _iter1045;
+ for (_iter1045 = (*(this->part_vals)).begin(); _iter1045 != (*(this->part_vals)).end(); ++_iter1045)
      {
- xfer += oprot->writeString((*_iter1025));
+ xfer += oprot->writeString((*_iter1045));
      }
      xfer += oprot->writeListEnd();
    }
@@ -17270,14 +17665,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::read(::apache::thrif
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size1026;
- ::apache::thrift::protocol::TType _etype1029;
- xfer += iprot->readListBegin(_etype1029, _size1026);
- this->success.resize(_size1026);
- uint32_t _i1030;
- for (_i1030 = 0; _i1030 < _size1026; ++_i1030)
+ uint32_t _size1046;
+ ::apache::thrift::protocol::TType _etype1049;
+ xfer += iprot->readListBegin(_etype1049, _size1046);
+ this->success.resize(_size1046);
+ uint32_t _i1050;
+ for (_i1050 = 0; _i1050 < _size1046; ++_i1050)
              {
- xfer += iprot->readString(this->success[_i1030]);
+ xfer += iprot->readString(this->success[_i1050]);
              }
              xfer += iprot->readListEnd();
            }
@@ -17316,10 +17711,10 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_result::write(::apache::thri
      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 _iter1031;
- for (_iter1031 = this->success.begin(); _iter1031 != this->success.end(); ++_iter1031)
+ std::vector<std::string> ::const_iterator _iter1051;
+ for (_iter1051 = this->success.begin(); _iter1051 != this->success.end(); ++_iter1051)
        {
- xfer += oprot->writeString((*_iter1031));
+ xfer += oprot->writeString((*_iter1051));
        }
        xfer += oprot->writeListEnd();
      }
@@ -17363,14 +17758,14 @@ uint32_t ThriftHiveMetastore_partition_name_to_vals_presult::read(::apache::thri
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size1032;
- ::apache::thrift::protocol::TType _etype1035;
- xfer += iprot->readListBegin(_etype1035, _size1032);
- (*(this->success)).resize(_size1032);
- uint32_t _i1036;
- for (_i1036 = 0; _i1036 < _size1032; ++_i1036)
+ uint32_t _size1052;
+ ::apache::thrift::protocol::TType _etype1055;
+ xfer += iprot->readListBegin(_etype1055, _size1052);
+ (*(this->success)).resize(_size1052);
+ uint32_t _i1056;
+ for (_i1056 = 0; _i1056 < _size1052; ++_i1056)
              {
- xfer += iprot->readString((*(this->success))[_i1036]);
+ xfer += iprot->readString((*(this->success))[_i1056]);
              }
              xfer += iprot->readListEnd();
            }
@@ -17508,17 +17903,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::read(::apache::thrif
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->success.clear();
- uint32_t _size1037;
- ::apache::thrift::protocol::TType _ktype1038;
- ::apache::thrift::protocol::TType _vtype1039;
- xfer += iprot->readMapBegin(_ktype1038, _vtype1039, _size1037);
- uint32_t _i1041;
- for (_i1041 = 0; _i1041 < _size1037; ++_i1041)
+ uint32_t _size1057;
+ ::apache::thrift::protocol::TType _ktype1058;
+ ::apache::thrift::protocol::TType _vtype1059;
+ xfer += iprot->readMapBegin(_ktype1058, _vtype1059, _size1057);
+ uint32_t _i1061;
+ for (_i1061 = 0; _i1061 < _size1057; ++_i1061)
              {
- std::string _key1042;
- xfer += iprot->readString(_key1042);
- std::string& _val1043 = this->success[_key1042];
- xfer += iprot->readString(_val1043);
+ std::string _key1062;
+ xfer += iprot->readString(_key1062);
+ std::string& _val1063 = this->success[_key1062];
+ xfer += iprot->readString(_val1063);
              }
              xfer += iprot->readMapEnd();
            }
@@ -17557,11 +17952,11 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_result::write(::apache::thri
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
      {
        xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
- std::map<std::string, std::string> ::const_iterator _iter1044;
- for (_iter1044 = this->success.begin(); _iter1044 != this->success.end(); ++_iter1044)
+ std::map<std::string, std::string> ::const_iterator _iter1064;
+ for (_iter1064 = this->success.begin(); _iter1064 != this->success.end(); ++_iter1064)
        {
- xfer += oprot->writeString(_iter1044->first);
- xfer += oprot->writeString(_iter1044->second);
+ xfer += oprot->writeString(_iter1064->first);
+ xfer += oprot->writeString(_iter1064->second);
        }
        xfer += oprot->writeMapEnd();
      }
@@ -17605,17 +18000,17 @@ uint32_t ThriftHiveMetastore_partition_name_to_spec_presult::read(::apache::thri
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              (*(this->success)).clear();
- uint32_t _size1045;
- ::apache::thrift::protocol::TType _ktype1046;
- ::apache::thrift::protocol::TType _vtype1047;
- xfer += iprot->readMapBegin(_ktype1046, _vtype1047, _size1045);
- uint32_t _i1049;
- for (_i1049 = 0; _i1049 < _size1045; ++_i1049)
+ uint32_t _size1065;
+ ::apache::thrift::protocol::TType _ktype1066;
+ ::apache::thrift::protocol::TType _vtype1067;
+ xfer += iprot->readMapBegin(_ktype1066, _vtype1067, _size1065);
+ uint32_t _i1069;
+ for (_i1069 = 0; _i1069 < _size1065; ++_i1069)
              {
- std::string _key1050;
- xfer += iprot->readString(_key1050);
- std::string& _val1051 = (*(this->success))[_key1050];
- xfer += iprot->readString(_val1051);
+ std::string _key1070;
+ xfer += iprot->readString(_key1070);
+ std::string& _val1071 = (*(this->success))[_key1070];
+ xfer += iprot->readString(_val1071);
              }
              xfer += iprot->readMapEnd();
            }
@@ -17689,17 +18084,17 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift::
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->part_vals.clear();
- uint32_t _size1052;
- ::apache::thrift::protocol::TType _ktype1053;
- ::apache::thrift::protocol::TType _vtype1054;
- xfer += iprot->readMapBegin(_ktype1053, _vtype1054, _size1052);
- uint32_t _i1056;
- for (_i1056 = 0; _i1056 < _size1052; ++_i1056)
+ uint32_t _size1072;
+ ::apache::thrift::protocol::TType _ktype1073;
+ ::apache::thrift::protocol::TType _vtype1074;
+ xfer += iprot->readMapBegin(_ktype1073, _vtype1074, _size1072);
+ uint32_t _i1076;
+ for (_i1076 = 0; _i1076 < _size1072; ++_i1076)
              {
- std::string _key1057;
- xfer += iprot->readString(_key1057);
- std::string& _val1058 = this->part_vals[_key1057];
- xfer += iprot->readString(_val1058);
+ std::string _key1077;
+ xfer += iprot->readString(_key1077);
+ std::string& _val1078 = this->part_vals[_key1077];
+ xfer += iprot->readString(_val1078);
              }
              xfer += iprot->readMapEnd();
            }
@@ -17710,9 +18105,9 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::read(::apache::thrift::
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast1059;
- xfer += iprot->readI32(ecast1059);
- this->eventType = (PartitionEventType::type)ecast1059;
+ int32_t ecast1079;
+ xfer += iprot->readI32(ecast1079);
+ this->eventType = (PartitionEventType::type)ecast1079;
            this->__isset.eventType = true;
          } else {
            xfer += iprot->skip(ftype);
@@ -17746,11 +18141,11 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_args::write(::apache::thrift:
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::map<std::string, std::string> ::const_iterator _iter1060;
- for (_iter1060 = this->part_vals.begin(); _iter1060 != this->part_vals.end(); ++_iter1060)
+ std::map<std::string, std::string> ::const_iterator _iter1080;
+ for (_iter1080 = this->part_vals.begin(); _iter1080 != this->part_vals.end(); ++_iter1080)
      {
- xfer += oprot->writeString(_iter1060->first);
- xfer += oprot->writeString(_iter1060->second);
+ xfer += oprot->writeString(_iter1080->first);
+ xfer += oprot->writeString(_iter1080->second);
      }
      xfer += oprot->writeMapEnd();
    }
@@ -17787,11 +18182,11 @@ uint32_t ThriftHiveMetastore_markPartitionForEvent_pargs::write(::apache::thrift
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::map<std::string, std::string> ::const_iterator _iter1061;
- for (_iter1061 = (*(this->part_vals)).begin(); _iter1061 != (*(this->part_vals)).end(); ++_iter1061)
+ std::map<std::string, std::string> ::const_iterator _iter1081;
+ for (_iter1081 = (*(this->part_vals)).begin(); _iter1081 != (*(this->part_vals)).end(); ++_iter1081)
      {
- xfer += oprot->writeString(_iter1061->first);
- xfer += oprot->writeString(_iter1061->second);
+ xfer += oprot->writeString(_iter1081->first);
+ xfer += oprot->writeString(_iter1081->second);
      }
      xfer += oprot->writeMapEnd();
    }
@@ -18058,17 +18453,17 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->part_vals.clear();
- uint32_t _size1062;
- ::apache::thrift::protocol::TType _ktype1063;
- ::apache::thrift::protocol::TType _vtype1064;
- xfer += iprot->readMapBegin(_ktype1063, _vtype1064, _size1062);
- uint32_t _i1066;
- for (_i1066 = 0; _i1066 < _size1062; ++_i1066)
+ uint32_t _size1082;
+ ::apache::thrift::protocol::TType _ktype1083;
+ ::apache::thrift::protocol::TType _vtype1084;
+ xfer += iprot->readMapBegin(_ktype1083, _vtype1084, _size1082);
+ uint32_t _i1086;
+ for (_i1086 = 0; _i1086 < _size1082; ++_i1086)
              {
- std::string _key1067;
- xfer += iprot->readString(_key1067);
- std::string& _val1068 = this->part_vals[_key1067];
- xfer += iprot->readString(_val1068);
+ std::string _key1087;
+ xfer += iprot->readString(_key1087);
+ std::string& _val1088 = this->part_vals[_key1087];
+ xfer += iprot->readString(_val1088);
              }
              xfer += iprot->readMapEnd();
            }
@@ -18079,9 +18474,9 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::read(::apache::thri
          break;
        case 4:
          if (ftype == ::apache::thrift::protocol::T_I32) {
- int32_t ecast1069;
- xfer += iprot->readI32(ecast1069);
- this->eventType = (PartitionEventType::type)ecast1069;
+ int32_t ecast1089;
+ xfer += iprot->readI32(ecast1089);
+ this->eventType = (PartitionEventType::type)ecast1089;
            this->__isset.eventType = true;
          } else {
            xfer += iprot->skip(ftype);
@@ -18115,11 +18510,11 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_args::write(::apache::thr
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::map<std::string, std::string> ::const_iterator _iter1070;
- for (_iter1070 = this->part_vals.begin(); _iter1070 != this->part_vals.end(); ++_iter1070)
+ std::map<std::string, std::string> ::const_iterator _iter1090;
+ for (_iter1090 = this->part_vals.begin(); _iter1090 != this->part_vals.end(); ++_iter1090)
      {
- xfer += oprot->writeString(_iter1070->first);
- xfer += oprot->writeString(_iter1070->second);
+ xfer += oprot->writeString(_iter1090->first);
+ xfer += oprot->writeString(_iter1090->second);
      }
      xfer += oprot->writeMapEnd();
    }
@@ -18156,11 +18551,11 @@ uint32_t ThriftHiveMetastore_isPartitionMarkedForEvent_pargs::write(::apache::th
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_MAP, 3);
    {
      xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::map<std::string, std::string> ::const_iterator _iter1071;
- for (_iter1071 = (*(this->part_vals)).begin(); _iter1071 != (*(this->part_vals)).end(); ++_iter1071)
+ std::map<std::string, std::string> ::const_iterator _iter1091;
+ for (_iter1091 = (*(this->part_vals)).begin(); _iter1091 != (*(this->part_vals)).end(); ++_iter1091)
      {
- xfer += oprot->writeString(_iter1071->first);
- xfer += oprot->writeString(_iter1071->second);
+ xfer += oprot->writeString(_iter1091->first);
+ xfer += oprot->writeString(_iter1091->second);
      }
      xfer += oprot->writeMapEnd();
    }
@@ -19591,14 +19986,14 @@ uint32_t ThriftHiveMetastore_get_indexes_result::read(::apache::thrift::protocol
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size1072;
- ::apache::thrift::protocol::TType _etype1075;
- xfer += iprot->readListBegin(_etype1075, _size1072);
- this->success.resize(_size1072);
- uint32_t _i1076;
- for (_i1076 = 0; _i1076 < _size1072; ++_i1076)
+ uint32_t _size1092;
+ ::apache::thrift::protocol::TType _etype1095;
+ xfer += iprot->readListBegin(_etype1095, _size1092);
+ this->success.resize(_size1092);
+ uint32_t _i1096;
+ for (_i1096 = 0; _i1096 < _size1092; ++_i1096)
              {
- xfer += this->success[_i1076].read(iprot);
+ xfer += this->success[_i1096].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -19645,10 +20040,10 @@ uint32_t ThriftHiveMetastore_get_indexes_result::write(::apache::thrift::protoco
      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<Index> ::const_iterator _iter1077;
- for (_iter1077 = this->success.begin(); _iter1077 != this->success.end(); ++_iter1077)
+ std::vector<Index> ::const_iterator _iter1097;
+ for (_iter1097 = this->success.begin(); _iter1097 != this->success.end(); ++_iter1097)
        {
- xfer += (*_iter1077).write(oprot);
+ xfer += (*_iter1097).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -19696,14 +20091,14 @@ uint32_t ThriftHiveMetastore_get_indexes_presult::read(::apache::thrift::protoco
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size1078;
- ::apache::thrift::protocol::TType _etype1081;
- xfer += iprot->readListBegin(_etype1081, _size1078);
- (*(this->success)).resize(_size1078);
- uint32_t _i1082;
- for (_i1082 = 0; _i1082 < _size1078; ++_i1082)
+ uint32_t _size1098;
+ ::apache::thrift::protocol::TType _etype1101;
+ xfer += iprot->readListBegin(_etype1101, _size1098);
+ (*(this->success)).resize(_size1098);
+ uint32_t _i1102;
+ for (_i1102 = 0; _i1102 < _size1098; ++_i1102)
              {
- xfer += (*(this->success))[_i1082].read(iprot);
+ xfer += (*(this->success))[_i1102].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -19881,14 +20276,14 @@ uint32_t ThriftHiveMetastore_get_index_names_result::read(::apache::thrift::prot
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size1083;
- ::apache::thrift::protocol::TType _etype1086;
- xfer += iprot->readListBegin(_etype1086, _size1083);
- this->success.resize(_size1083);
- uint32_t _i1087;
- for (_i1087 = 0; _i1087 < _size1083; ++_i1087)
+ uint32_t _size1103;
+ ::apache::thrift::protocol::TType _etype1106;
+ xfer += iprot->readListBegin(_etype1106, _size1103);
+ this->success.resize(_size1103);
+ uint32_t _i1107;
+ for (_i1107 = 0; _i1107 < _size1103; ++_i1107)
              {
- xfer += iprot->readString(this->success[_i1087]);
+ xfer += iprot->readString(this->success[_i1107]);
              }
              xfer += iprot->readListEnd();
            }
@@ -19927,10 +20322,10 @@ uint32_t ThriftHiveMetastore_get_index_names_result::write(::apache::thrift::pro
      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 _iter1088;
- for (_iter1088 = this->success.begin(); _iter1088 != this->success.end(); ++_iter1088)
+ std::vector<std::string> ::const_iterator _iter1108;
+ for (_iter1108 = this->success.begin(); _iter1108 != this->success.end(); ++_iter1108)
        {
- xfer += oprot->writeString((*_iter1088));
+ xfer += oprot->writeString((*_iter1108));
        }
        xfer += oprot->writeListEnd();
      }
@@ -19974,14 +20369,14 @@ uint32_t ThriftHiveMetastore_get_index_names_presult::read(::apache::thrift::pro
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size1089;
- ::apache::thrift::protocol::TType _etype1092;
- xfer += iprot->readListBegin(_etype1092, _size1089);
- (*(this->success)).resize(_size1089);
- uint32_t _i1093;
- for (_i1093 = 0; _i1093 < _size1089; ++_i1093)
+ uint32_t _size1109;
+ ::apache::thrift::protocol::TType _etype1112;
+ xfer += iprot->readListBegin(_etype1112, _size1109);
+ (*(this->success)).resize(_size1109);
+ uint32_t _i1113;
+ for (_i1113 = 0; _i1113 < _size1109; ++_i1113)
              {
-

<TRUNCATED>

Search Discussions

Discussion Posts

Previous

Follow ups

Related Discussions

Discussion Navigation
viewthread | post
posts ‹ prev | 4 of 6 | next ›
Discussion Overview
groupcommits @
categorieshive, hadoop
postedJan 13, '16 at 3:03p
activeJan 13, '16 at 3:03p
posts6
users1
websitehive.apache.org

1 user in discussion

Aihuaxu: 6 posts

People

Translate

site design / logo © 2021 Grokbase