Grokbase Groups Hive commits May 2016
FAQ
http://git-wip-us.apache.org/repos/asf/hive/blob/f25b8652/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 618c3ac..298384c 100644
--- a/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
+++ b/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
@@ -1240,14 +1240,14 @@ uint32_t ThriftHiveMetastore_get_databases_result::read(::apache::thrift::protoc
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size771;
- ::apache::thrift::protocol::TType _etype774;
- xfer += iprot->readListBegin(_etype774, _size771);
- this->success.resize(_size771);
- uint32_t _i775;
- for (_i775 = 0; _i775 < _size771; ++_i775)
+ uint32_t _size773;
+ ::apache::thrift::protocol::TType _etype776;
+ xfer += iprot->readListBegin(_etype776, _size773);
+ this->success.resize(_size773);
+ uint32_t _i777;
+ for (_i777 = 0; _i777 < _size773; ++_i777)
              {
- xfer += iprot->readString(this->success[_i775]);
+ xfer += iprot->readString(this->success[_i777]);
              }
              xfer += iprot->readListEnd();
            }
@@ -1286,10 +1286,10 @@ uint32_t ThriftHiveMetastore_get_databases_result::write(::apache::thrift::proto
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
- std::vector<std::string> ::const_iterator _iter776;
- for (_iter776 = this->success.begin(); _iter776 != this->success.end(); ++_iter776)
+ std::vector<std::string> ::const_iterator _iter778;
+ for (_iter778 = this->success.begin(); _iter778 != this->success.end(); ++_iter778)
        {
- xfer += oprot->writeString((*_iter776));
+ xfer += oprot->writeString((*_iter778));
        }
        xfer += oprot->writeListEnd();
      }
@@ -1334,14 +1334,14 @@ uint32_t ThriftHiveMetastore_get_databases_presult::read(::apache::thrift::proto
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size777;
- ::apache::thrift::protocol::TType _etype780;
- xfer += iprot->readListBegin(_etype780, _size777);
- (*(this->success)).resize(_size777);
- uint32_t _i781;
- for (_i781 = 0; _i781 < _size777; ++_i781)
+ uint32_t _size779;
+ ::apache::thrift::protocol::TType _etype782;
+ xfer += iprot->readListBegin(_etype782, _size779);
+ (*(this->success)).resize(_size779);
+ uint32_t _i783;
+ for (_i783 = 0; _i783 < _size779; ++_i783)
              {
- xfer += iprot->readString((*(this->success))[_i781]);
+ xfer += iprot->readString((*(this->success))[_i783]);
              }
              xfer += iprot->readListEnd();
            }
@@ -1458,14 +1458,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::read(::apache::thrift::pr
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size782;
- ::apache::thrift::protocol::TType _etype785;
- xfer += iprot->readListBegin(_etype785, _size782);
- this->success.resize(_size782);
- uint32_t _i786;
- for (_i786 = 0; _i786 < _size782; ++_i786)
+ uint32_t _size784;
+ ::apache::thrift::protocol::TType _etype787;
+ xfer += iprot->readListBegin(_etype787, _size784);
+ this->success.resize(_size784);
+ uint32_t _i788;
+ for (_i788 = 0; _i788 < _size784; ++_i788)
              {
- xfer += iprot->readString(this->success[_i786]);
+ xfer += iprot->readString(this->success[_i788]);
              }
              xfer += iprot->readListEnd();
            }
@@ -1504,10 +1504,10 @@ uint32_t ThriftHiveMetastore_get_all_databases_result::write(::apache::thrift::p
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
- std::vector<std::string> ::const_iterator _iter787;
- for (_iter787 = this->success.begin(); _iter787 != this->success.end(); ++_iter787)
+ std::vector<std::string> ::const_iterator _iter789;
+ for (_iter789 = this->success.begin(); _iter789 != this->success.end(); ++_iter789)
        {
- xfer += oprot->writeString((*_iter787));
+ xfer += oprot->writeString((*_iter789));
        }
        xfer += oprot->writeListEnd();
      }
@@ -1552,14 +1552,14 @@ uint32_t ThriftHiveMetastore_get_all_databases_presult::read(::apache::thrift::p
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size788;
- ::apache::thrift::protocol::TType _etype791;
- xfer += iprot->readListBegin(_etype791, _size788);
- (*(this->success)).resize(_size788);
- uint32_t _i792;
- for (_i792 = 0; _i792 < _size788; ++_i792)
+ uint32_t _size790;
+ ::apache::thrift::protocol::TType _etype793;
+ xfer += iprot->readListBegin(_etype793, _size790);
+ (*(this->success)).resize(_size790);
+ uint32_t _i794;
+ for (_i794 = 0; _i794 < _size790; ++_i794)
              {
- xfer += iprot->readString((*(this->success))[_i792]);
+ xfer += iprot->readString((*(this->success))[_i794]);
              }
              xfer += iprot->readListEnd();
            }
@@ -2621,17 +2621,17 @@ uint32_t ThriftHiveMetastore_get_type_all_result::read(::apache::thrift::protoco
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->success.clear();
- uint32_t _size793;
- ::apache::thrift::protocol::TType _ktype794;
- ::apache::thrift::protocol::TType _vtype795;
- xfer += iprot->readMapBegin(_ktype794, _vtype795, _size793);
- uint32_t _i797;
- for (_i797 = 0; _i797 < _size793; ++_i797)
+ uint32_t _size795;
+ ::apache::thrift::protocol::TType _ktype796;
+ ::apache::thrift::protocol::TType _vtype797;
+ xfer += iprot->readMapBegin(_ktype796, _vtype797, _size795);
+ uint32_t _i799;
+ for (_i799 = 0; _i799 < _size795; ++_i799)
              {
- std::string _key798;
- xfer += iprot->readString(_key798);
- Type& _val799 = this->success[_key798];
- xfer += _val799.read(iprot);
+ std::string _key800;
+ xfer += iprot->readString(_key800);
+ Type& _val801 = this->success[_key800];
+ xfer += _val801.read(iprot);
              }
              xfer += iprot->readMapEnd();
            }
@@ -2670,11 +2670,11 @@ uint32_t ThriftHiveMetastore_get_type_all_result::write(::apache::thrift::protoc
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_MAP, 0);
      {
        xfer += oprot->writeMapBegin(::apache::thrift::protocol::T_STRING, ::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::map<std::string, Type> ::const_iterator _iter800;
- for (_iter800 = this->success.begin(); _iter800 != this->success.end(); ++_iter800)
+ std::map<std::string, Type> ::const_iterator _iter802;
+ for (_iter802 = this->success.begin(); _iter802 != this->success.end(); ++_iter802)
        {
- xfer += oprot->writeString(_iter800->first);
- xfer += _iter800->second.write(oprot);
+ xfer += oprot->writeString(_iter802->first);
+ xfer += _iter802->second.write(oprot);
        }
        xfer += oprot->writeMapEnd();
      }
@@ -2719,17 +2719,17 @@ uint32_t ThriftHiveMetastore_get_type_all_presult::read(::apache::thrift::protoc
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              (*(this->success)).clear();
- uint32_t _size801;
- ::apache::thrift::protocol::TType _ktype802;
- ::apache::thrift::protocol::TType _vtype803;
- xfer += iprot->readMapBegin(_ktype802, _vtype803, _size801);
- uint32_t _i805;
- for (_i805 = 0; _i805 < _size801; ++_i805)
+ uint32_t _size803;
+ ::apache::thrift::protocol::TType _ktype804;
+ ::apache::thrift::protocol::TType _vtype805;
+ xfer += iprot->readMapBegin(_ktype804, _vtype805, _size803);
+ uint32_t _i807;
+ for (_i807 = 0; _i807 < _size803; ++_i807)
              {
- std::string _key806;
- xfer += iprot->readString(_key806);
- Type& _val807 = (*(this->success))[_key806];
- xfer += _val807.read(iprot);
+ std::string _key808;
+ xfer += iprot->readString(_key808);
+ Type& _val809 = (*(this->success))[_key808];
+ xfer += _val809.read(iprot);
              }
              xfer += iprot->readMapEnd();
            }
@@ -2883,14 +2883,14 @@ uint32_t ThriftHiveMetastore_get_fields_result::read(::apache::thrift::protocol:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size808;
- ::apache::thrift::protocol::TType _etype811;
- xfer += iprot->readListBegin(_etype811, _size808);
- this->success.resize(_size808);
- uint32_t _i812;
- for (_i812 = 0; _i812 < _size808; ++_i812)
+ uint32_t _size810;
+ ::apache::thrift::protocol::TType _etype813;
+ xfer += iprot->readListBegin(_etype813, _size810);
+ this->success.resize(_size810);
+ uint32_t _i814;
+ for (_i814 = 0; _i814 < _size810; ++_i814)
              {
- xfer += this->success[_i812].read(iprot);
+ xfer += this->success[_i814].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -2945,10 +2945,10 @@ uint32_t ThriftHiveMetastore_get_fields_result::write(::apache::thrift::protocol
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<FieldSchema> ::const_iterator _iter813;
- for (_iter813 = this->success.begin(); _iter813 != this->success.end(); ++_iter813)
+ std::vector<FieldSchema> ::const_iterator _iter815;
+ for (_iter815 = this->success.begin(); _iter815 != this->success.end(); ++_iter815)
        {
- xfer += (*_iter813).write(oprot);
+ xfer += (*_iter815).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -3001,14 +3001,14 @@ uint32_t ThriftHiveMetastore_get_fields_presult::read(::apache::thrift::protocol
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size814;
- ::apache::thrift::protocol::TType _etype817;
- xfer += iprot->readListBegin(_etype817, _size814);
- (*(this->success)).resize(_size814);
- uint32_t _i818;
- for (_i818 = 0; _i818 < _size814; ++_i818)
+ uint32_t _size816;
+ ::apache::thrift::protocol::TType _etype819;
+ xfer += iprot->readListBegin(_etype819, _size816);
+ (*(this->success)).resize(_size816);
+ uint32_t _i820;
+ for (_i820 = 0; _i820 < _size816; ++_i820)
              {
- xfer += (*(this->success))[_i818].read(iprot);
+ xfer += (*(this->success))[_i820].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -3194,14 +3194,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::read(::
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size819;
- ::apache::thrift::protocol::TType _etype822;
- xfer += iprot->readListBegin(_etype822, _size819);
- this->success.resize(_size819);
- uint32_t _i823;
- for (_i823 = 0; _i823 < _size819; ++_i823)
+ uint32_t _size821;
+ ::apache::thrift::protocol::TType _etype824;
+ xfer += iprot->readListBegin(_etype824, _size821);
+ this->success.resize(_size821);
+ uint32_t _i825;
+ for (_i825 = 0; _i825 < _size821; ++_i825)
              {
- xfer += this->success[_i823].read(iprot);
+ xfer += this->success[_i825].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -3256,10 +3256,10 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_result::write(:
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<FieldSchema> ::const_iterator _iter824;
- for (_iter824 = this->success.begin(); _iter824 != this->success.end(); ++_iter824)
+ std::vector<FieldSchema> ::const_iterator _iter826;
+ for (_iter826 = this->success.begin(); _iter826 != this->success.end(); ++_iter826)
        {
- xfer += (*_iter824).write(oprot);
+ xfer += (*_iter826).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -3312,14 +3312,14 @@ uint32_t ThriftHiveMetastore_get_fields_with_environment_context_presult::read(:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size825;
- ::apache::thrift::protocol::TType _etype828;
- xfer += iprot->readListBegin(_etype828, _size825);
- (*(this->success)).resize(_size825);
- uint32_t _i829;
- for (_i829 = 0; _i829 < _size825; ++_i829)
+ uint32_t _size827;
+ ::apache::thrift::protocol::TType _etype830;
+ xfer += iprot->readListBegin(_etype830, _size827);
+ (*(this->success)).resize(_size827);
+ uint32_t _i831;
+ for (_i831 = 0; _i831 < _size827; ++_i831)
              {
- xfer += (*(this->success))[_i829].read(iprot);
+ xfer += (*(this->success))[_i831].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -3489,14 +3489,14 @@ uint32_t ThriftHiveMetastore_get_schema_result::read(::apache::thrift::protocol:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size830;
- ::apache::thrift::protocol::TType _etype833;
- xfer += iprot->readListBegin(_etype833, _size830);
- this->success.resize(_size830);
- uint32_t _i834;
- for (_i834 = 0; _i834 < _size830; ++_i834)
+ uint32_t _size832;
+ ::apache::thrift::protocol::TType _etype835;
+ xfer += iprot->readListBegin(_etype835, _size832);
+ this->success.resize(_size832);
+ uint32_t _i836;
+ for (_i836 = 0; _i836 < _size832; ++_i836)
              {
- xfer += this->success[_i834].read(iprot);
+ xfer += this->success[_i836].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -3551,10 +3551,10 @@ uint32_t ThriftHiveMetastore_get_schema_result::write(::apache::thrift::protocol
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<FieldSchema> ::const_iterator _iter835;
- for (_iter835 = this->success.begin(); _iter835 != this->success.end(); ++_iter835)
+ std::vector<FieldSchema> ::const_iterator _iter837;
+ for (_iter837 = this->success.begin(); _iter837 != this->success.end(); ++_iter837)
        {
- xfer += (*_iter835).write(oprot);
+ xfer += (*_iter837).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -3607,14 +3607,14 @@ uint32_t ThriftHiveMetastore_get_schema_presult::read(::apache::thrift::protocol
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size836;
- ::apache::thrift::protocol::TType _etype839;
- xfer += iprot->readListBegin(_etype839, _size836);
- (*(this->success)).resize(_size836);
- uint32_t _i840;
- for (_i840 = 0; _i840 < _size836; ++_i840)
+ uint32_t _size838;
+ ::apache::thrift::protocol::TType _etype841;
+ xfer += iprot->readListBegin(_etype841, _size838);
+ (*(this->success)).resize(_size838);
+ uint32_t _i842;
+ for (_i842 = 0; _i842 < _size838; ++_i842)
              {
- xfer += (*(this->success))[_i840].read(iprot);
+ xfer += (*(this->success))[_i842].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -3800,14 +3800,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::read(::
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size841;
- ::apache::thrift::protocol::TType _etype844;
- xfer += iprot->readListBegin(_etype844, _size841);
- this->success.resize(_size841);
- uint32_t _i845;
- for (_i845 = 0; _i845 < _size841; ++_i845)
+ uint32_t _size843;
+ ::apache::thrift::protocol::TType _etype846;
+ xfer += iprot->readListBegin(_etype846, _size843);
+ this->success.resize(_size843);
+ uint32_t _i847;
+ for (_i847 = 0; _i847 < _size843; ++_i847)
              {
- xfer += this->success[_i845].read(iprot);
+ xfer += this->success[_i847].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -3862,10 +3862,10 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_result::write(:
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<FieldSchema> ::const_iterator _iter846;
- for (_iter846 = this->success.begin(); _iter846 != this->success.end(); ++_iter846)
+ std::vector<FieldSchema> ::const_iterator _iter848;
+ for (_iter848 = this->success.begin(); _iter848 != this->success.end(); ++_iter848)
        {
- xfer += (*_iter846).write(oprot);
+ xfer += (*_iter848).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -3918,14 +3918,14 @@ uint32_t ThriftHiveMetastore_get_schema_with_environment_context_presult::read(:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size847;
- ::apache::thrift::protocol::TType _etype850;
- xfer += iprot->readListBegin(_etype850, _size847);
- (*(this->success)).resize(_size847);
- uint32_t _i851;
- for (_i851 = 0; _i851 < _size847; ++_i851)
+ uint32_t _size849;
+ ::apache::thrift::protocol::TType _etype852;
+ xfer += iprot->readListBegin(_etype852, _size849);
+ (*(this->success)).resize(_size849);
+ uint32_t _i853;
+ for (_i853 = 0; _i853 < _size849; ++_i853)
              {
- xfer += (*(this->success))[_i851].read(iprot);
+ xfer += (*(this->success))[_i853].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -4518,14 +4518,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache::
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->primaryKeys.clear();
- uint32_t _size852;
- ::apache::thrift::protocol::TType _etype855;
- xfer += iprot->readListBegin(_etype855, _size852);
- this->primaryKeys.resize(_size852);
- uint32_t _i856;
- for (_i856 = 0; _i856 < _size852; ++_i856)
+ uint32_t _size854;
+ ::apache::thrift::protocol::TType _etype857;
+ xfer += iprot->readListBegin(_etype857, _size854);
+ this->primaryKeys.resize(_size854);
+ uint32_t _i858;
+ for (_i858 = 0; _i858 < _size854; ++_i858)
              {
- xfer += this->primaryKeys[_i856].read(iprot);
+ xfer += this->primaryKeys[_i858].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -4538,14 +4538,14 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::read(::apache::
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->foreignKeys.clear();
- uint32_t _size857;
- ::apache::thrift::protocol::TType _etype860;
- xfer += iprot->readListBegin(_etype860, _size857);
- this->foreignKeys.resize(_size857);
- uint32_t _i861;
- for (_i861 = 0; _i861 < _size857; ++_i861)
+ uint32_t _size859;
+ ::apache::thrift::protocol::TType _etype862;
+ xfer += iprot->readListBegin(_etype862, _size859);
+ this->foreignKeys.resize(_size859);
+ uint32_t _i863;
+ for (_i863 = 0; _i863 < _size859; ++_i863)
              {
- xfer += this->foreignKeys[_i861].read(iprot);
+ xfer += this->foreignKeys[_i863].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -4578,10 +4578,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache:
    xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->primaryKeys.size()));
- std::vector<SQLPrimaryKey> ::const_iterator _iter862;
- for (_iter862 = this->primaryKeys.begin(); _iter862 != this->primaryKeys.end(); ++_iter862)
+ std::vector<SQLPrimaryKey> ::const_iterator _iter864;
+ for (_iter864 = this->primaryKeys.begin(); _iter864 != this->primaryKeys.end(); ++_iter864)
      {
- xfer += (*_iter862).write(oprot);
+ xfer += (*_iter864).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -4590,10 +4590,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_args::write(::apache:
    xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->foreignKeys.size()));
- std::vector<SQLForeignKey> ::const_iterator _iter863;
- for (_iter863 = this->foreignKeys.begin(); _iter863 != this->foreignKeys.end(); ++_iter863)
+ std::vector<SQLForeignKey> ::const_iterator _iter865;
+ for (_iter865 = this->foreignKeys.begin(); _iter865 != this->foreignKeys.end(); ++_iter865)
      {
- xfer += (*_iter863).write(oprot);
+ xfer += (*_iter865).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -4621,10 +4621,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache
    xfer += oprot->writeFieldBegin("primaryKeys", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->primaryKeys)).size()));
- std::vector<SQLPrimaryKey> ::const_iterator _iter864;
- for (_iter864 = (*(this->primaryKeys)).begin(); _iter864 != (*(this->primaryKeys)).end(); ++_iter864)
+ std::vector<SQLPrimaryKey> ::const_iterator _iter866;
+ for (_iter866 = (*(this->primaryKeys)).begin(); _iter866 != (*(this->primaryKeys)).end(); ++_iter866)
      {
- xfer += (*_iter864).write(oprot);
+ xfer += (*_iter866).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -4633,10 +4633,10 @@ uint32_t ThriftHiveMetastore_create_table_with_constraints_pargs::write(::apache
    xfer += oprot->writeFieldBegin("foreignKeys", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->foreignKeys)).size()));
- std::vector<SQLForeignKey> ::const_iterator _iter865;
- for (_iter865 = (*(this->foreignKeys)).begin(); _iter865 != (*(this->foreignKeys)).end(); ++_iter865)
+ std::vector<SQLForeignKey> ::const_iterator _iter867;
+ for (_iter867 = (*(this->foreignKeys)).begin(); _iter867 != (*(this->foreignKeys)).end(); ++_iter867)
      {
- xfer += (*_iter865).write(oprot);
+ xfer += (*_iter867).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -6055,14 +6055,14 @@ uint32_t ThriftHiveMetastore_get_tables_result::read(::apache::thrift::protocol:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size866;
- ::apache::thrift::protocol::TType _etype869;
- xfer += iprot->readListBegin(_etype869, _size866);
- this->success.resize(_size866);
- uint32_t _i870;
- for (_i870 = 0; _i870 < _size866; ++_i870)
+ uint32_t _size868;
+ ::apache::thrift::protocol::TType _etype871;
+ xfer += iprot->readListBegin(_etype871, _size868);
+ this->success.resize(_size868);
+ uint32_t _i872;
+ for (_i872 = 0; _i872 < _size868; ++_i872)
              {
- xfer += iprot->readString(this->success[_i870]);
+ xfer += iprot->readString(this->success[_i872]);
              }
              xfer += iprot->readListEnd();
            }
@@ -6101,10 +6101,10 @@ uint32_t ThriftHiveMetastore_get_tables_result::write(::apache::thrift::protocol
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
- std::vector<std::string> ::const_iterator _iter871;
- for (_iter871 = this->success.begin(); _iter871 != this->success.end(); ++_iter871)
+ std::vector<std::string> ::const_iterator _iter873;
+ for (_iter873 = this->success.begin(); _iter873 != this->success.end(); ++_iter873)
        {
- xfer += oprot->writeString((*_iter871));
+ xfer += oprot->writeString((*_iter873));
        }
        xfer += oprot->writeListEnd();
      }
@@ -6149,14 +6149,14 @@ uint32_t ThriftHiveMetastore_get_tables_presult::read(::apache::thrift::protocol
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size872;
- ::apache::thrift::protocol::TType _etype875;
- xfer += iprot->readListBegin(_etype875, _size872);
- (*(this->success)).resize(_size872);
- uint32_t _i876;
- for (_i876 = 0; _i876 < _size872; ++_i876)
+ uint32_t _size874;
+ ::apache::thrift::protocol::TType _etype877;
+ xfer += iprot->readListBegin(_etype877, _size874);
+ (*(this->success)).resize(_size874);
+ uint32_t _i878;
+ for (_i878 = 0; _i878 < _size874; ++_i878)
              {
- xfer += iprot->readString((*(this->success))[_i876]);
+ xfer += iprot->readString((*(this->success))[_i878]);
              }
              xfer += iprot->readListEnd();
            }
@@ -6231,14 +6231,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::read(::apache::thrift::protoco
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->tbl_types.clear();
- uint32_t _size877;
- ::apache::thrift::protocol::TType _etype880;
- xfer += iprot->readListBegin(_etype880, _size877);
- this->tbl_types.resize(_size877);
- uint32_t _i881;
- for (_i881 = 0; _i881 < _size877; ++_i881)
+ uint32_t _size879;
+ ::apache::thrift::protocol::TType _etype882;
+ xfer += iprot->readListBegin(_etype882, _size879);
+ this->tbl_types.resize(_size879);
+ uint32_t _i883;
+ for (_i883 = 0; _i883 < _size879; ++_i883)
              {
- xfer += iprot->readString(this->tbl_types[_i881]);
+ xfer += iprot->readString(this->tbl_types[_i883]);
              }
              xfer += iprot->readListEnd();
            }
@@ -6275,10 +6275,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_args::write(::apache::thrift::protoc
    xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tbl_types.size()));
- std::vector<std::string> ::const_iterator _iter882;
- for (_iter882 = this->tbl_types.begin(); _iter882 != this->tbl_types.end(); ++_iter882)
+ std::vector<std::string> ::const_iterator _iter884;
+ for (_iter884 = this->tbl_types.begin(); _iter884 != this->tbl_types.end(); ++_iter884)
      {
- xfer += oprot->writeString((*_iter882));
+ xfer += oprot->writeString((*_iter884));
      }
      xfer += oprot->writeListEnd();
    }
@@ -6310,10 +6310,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_pargs::write(::apache::thrift::proto
    xfer += oprot->writeFieldBegin("tbl_types", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->tbl_types)).size()));
- std::vector<std::string> ::const_iterator _iter883;
- for (_iter883 = (*(this->tbl_types)).begin(); _iter883 != (*(this->tbl_types)).end(); ++_iter883)
+ std::vector<std::string> ::const_iterator _iter885;
+ for (_iter885 = (*(this->tbl_types)).begin(); _iter885 != (*(this->tbl_types)).end(); ++_iter885)
      {
- xfer += oprot->writeString((*_iter883));
+ xfer += oprot->writeString((*_iter885));
      }
      xfer += oprot->writeListEnd();
    }
@@ -6354,14 +6354,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::read(::apache::thrift::proto
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size884;
- ::apache::thrift::protocol::TType _etype887;
- xfer += iprot->readListBegin(_etype887, _size884);
- this->success.resize(_size884);
- uint32_t _i888;
- for (_i888 = 0; _i888 < _size884; ++_i888)
+ uint32_t _size886;
+ ::apache::thrift::protocol::TType _etype889;
+ xfer += iprot->readListBegin(_etype889, _size886);
+ this->success.resize(_size886);
+ uint32_t _i890;
+ for (_i890 = 0; _i890 < _size886; ++_i890)
              {
- xfer += this->success[_i888].read(iprot);
+ xfer += this->success[_i890].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -6400,10 +6400,10 @@ uint32_t ThriftHiveMetastore_get_table_meta_result::write(::apache::thrift::prot
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<TableMeta> ::const_iterator _iter889;
- for (_iter889 = this->success.begin(); _iter889 != this->success.end(); ++_iter889)
+ std::vector<TableMeta> ::const_iterator _iter891;
+ for (_iter891 = this->success.begin(); _iter891 != this->success.end(); ++_iter891)
        {
- xfer += (*_iter889).write(oprot);
+ xfer += (*_iter891).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -6448,14 +6448,14 @@ uint32_t ThriftHiveMetastore_get_table_meta_presult::read(::apache::thrift::prot
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size890;
- ::apache::thrift::protocol::TType _etype893;
- xfer += iprot->readListBegin(_etype893, _size890);
- (*(this->success)).resize(_size890);
- uint32_t _i894;
- for (_i894 = 0; _i894 < _size890; ++_i894)
+ uint32_t _size892;
+ ::apache::thrift::protocol::TType _etype895;
+ xfer += iprot->readListBegin(_etype895, _size892);
+ (*(this->success)).resize(_size892);
+ uint32_t _i896;
+ for (_i896 = 0; _i896 < _size892; ++_i896)
              {
- xfer += (*(this->success))[_i894].read(iprot);
+ xfer += (*(this->success))[_i896].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -6593,14 +6593,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::read(::apache::thrift::proto
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size895;
- ::apache::thrift::protocol::TType _etype898;
- xfer += iprot->readListBegin(_etype898, _size895);
- this->success.resize(_size895);
- uint32_t _i899;
- for (_i899 = 0; _i899 < _size895; ++_i899)
+ 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 += iprot->readString(this->success[_i899]);
+ xfer += iprot->readString(this->success[_i901]);
              }
              xfer += iprot->readListEnd();
            }
@@ -6639,10 +6639,10 @@ uint32_t ThriftHiveMetastore_get_all_tables_result::write(::apache::thrift::prot
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
- std::vector<std::string> ::const_iterator _iter900;
- for (_iter900 = this->success.begin(); _iter900 != this->success.end(); ++_iter900)
+ std::vector<std::string> ::const_iterator _iter902;
+ for (_iter902 = this->success.begin(); _iter902 != this->success.end(); ++_iter902)
        {
- xfer += oprot->writeString((*_iter900));
+ xfer += oprot->writeString((*_iter902));
        }
        xfer += oprot->writeListEnd();
      }
@@ -6687,14 +6687,14 @@ uint32_t ThriftHiveMetastore_get_all_tables_presult::read(::apache::thrift::prot
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size901;
- ::apache::thrift::protocol::TType _etype904;
- xfer += iprot->readListBegin(_etype904, _size901);
- (*(this->success)).resize(_size901);
- uint32_t _i905;
- for (_i905 = 0; _i905 < _size901; ++_i905)
+ uint32_t _size903;
+ ::apache::thrift::protocol::TType _etype906;
+ xfer += iprot->readListBegin(_etype906, _size903);
+ (*(this->success)).resize(_size903);
+ uint32_t _i907;
+ for (_i907 = 0; _i907 < _size903; ++_i907)
              {
- xfer += iprot->readString((*(this->success))[_i905]);
+ xfer += iprot->readString((*(this->success))[_i907]);
              }
              xfer += iprot->readListEnd();
            }
@@ -7004,14 +7004,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::read(::apache::thri
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->tbl_names.clear();
- uint32_t _size906;
- ::apache::thrift::protocol::TType _etype909;
- xfer += iprot->readListBegin(_etype909, _size906);
- this->tbl_names.resize(_size906);
- uint32_t _i910;
- for (_i910 = 0; _i910 < _size906; ++_i910)
+ uint32_t _size908;
+ ::apache::thrift::protocol::TType _etype911;
+ xfer += iprot->readListBegin(_etype911, _size908);
+ this->tbl_names.resize(_size908);
+ uint32_t _i912;
+ for (_i912 = 0; _i912 < _size908; ++_i912)
              {
- xfer += iprot->readString(this->tbl_names[_i910]);
+ xfer += iprot->readString(this->tbl_names[_i912]);
              }
              xfer += iprot->readListEnd();
            }
@@ -7044,10 +7044,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_args::write(::apache::thr
    xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->tbl_names.size()));
- std::vector<std::string> ::const_iterator _iter911;
- for (_iter911 = this->tbl_names.begin(); _iter911 != this->tbl_names.end(); ++_iter911)
+ std::vector<std::string> ::const_iterator _iter913;
+ for (_iter913 = this->tbl_names.begin(); _iter913 != this->tbl_names.end(); ++_iter913)
      {
- xfer += oprot->writeString((*_iter911));
+ xfer += oprot->writeString((*_iter913));
      }
      xfer += oprot->writeListEnd();
    }
@@ -7075,10 +7075,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_pargs::write(::apache::th
    xfer += oprot->writeFieldBegin("tbl_names", ::apache::thrift::protocol::T_LIST, 2);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->tbl_names)).size()));
- std::vector<std::string> ::const_iterator _iter912;
- for (_iter912 = (*(this->tbl_names)).begin(); _iter912 != (*(this->tbl_names)).end(); ++_iter912)
+ std::vector<std::string> ::const_iterator _iter914;
+ for (_iter914 = (*(this->tbl_names)).begin(); _iter914 != (*(this->tbl_names)).end(); ++_iter914)
      {
- xfer += oprot->writeString((*_iter912));
+ xfer += oprot->writeString((*_iter914));
      }
      xfer += oprot->writeListEnd();
    }
@@ -7119,14 +7119,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::read(::apache::th
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size913;
- ::apache::thrift::protocol::TType _etype916;
- xfer += iprot->readListBegin(_etype916, _size913);
- this->success.resize(_size913);
- uint32_t _i917;
- for (_i917 = 0; _i917 < _size913; ++_i917)
+ uint32_t _size915;
+ ::apache::thrift::protocol::TType _etype918;
+ xfer += iprot->readListBegin(_etype918, _size915);
+ this->success.resize(_size915);
+ uint32_t _i919;
+ for (_i919 = 0; _i919 < _size915; ++_i919)
              {
- xfer += this->success[_i917].read(iprot);
+ xfer += this->success[_i919].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -7181,10 +7181,10 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_result::write(::apache::t
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->success.size()));
- std::vector<Table> ::const_iterator _iter918;
- for (_iter918 = this->success.begin(); _iter918 != this->success.end(); ++_iter918)
+ std::vector<Table> ::const_iterator _iter920;
+ for (_iter920 = this->success.begin(); _iter920 != this->success.end(); ++_iter920)
        {
- xfer += (*_iter918).write(oprot);
+ xfer += (*_iter920).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -7237,14 +7237,14 @@ uint32_t ThriftHiveMetastore_get_table_objects_by_name_presult::read(::apache::t
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size919;
- ::apache::thrift::protocol::TType _etype922;
- xfer += iprot->readListBegin(_etype922, _size919);
- (*(this->success)).resize(_size919);
- uint32_t _i923;
- for (_i923 = 0; _i923 < _size919; ++_i923)
+ uint32_t _size921;
+ ::apache::thrift::protocol::TType _etype924;
+ xfer += iprot->readListBegin(_etype924, _size921);
+ (*(this->success)).resize(_size921);
+ uint32_t _i925;
+ for (_i925 = 0; _i925 < _size921; ++_i925)
              {
- xfer += (*(this->success))[_i923].read(iprot);
+ xfer += (*(this->success))[_i925].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -7430,14 +7430,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::read(::apache::th
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size924;
- ::apache::thrift::protocol::TType _etype927;
- xfer += iprot->readListBegin(_etype927, _size924);
- this->success.resize(_size924);
- uint32_t _i928;
- for (_i928 = 0; _i928 < _size924; ++_i928)
+ uint32_t _size926;
+ ::apache::thrift::protocol::TType _etype929;
+ xfer += iprot->readListBegin(_etype929, _size926);
+ this->success.resize(_size926);
+ uint32_t _i930;
+ for (_i930 = 0; _i930 < _size926; ++_i930)
              {
- xfer += iprot->readString(this->success[_i928]);
+ xfer += iprot->readString(this->success[_i930]);
              }
              xfer += iprot->readListEnd();
            }
@@ -7492,10 +7492,10 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_result::write(::apache::t
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_LIST, 0);
      {
        xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->success.size()));
- std::vector<std::string> ::const_iterator _iter929;
- for (_iter929 = this->success.begin(); _iter929 != this->success.end(); ++_iter929)
+ std::vector<std::string> ::const_iterator _iter931;
+ for (_iter931 = this->success.begin(); _iter931 != this->success.end(); ++_iter931)
        {
- xfer += oprot->writeString((*_iter929));
+ xfer += oprot->writeString((*_iter931));
        }
        xfer += oprot->writeListEnd();
      }
@@ -7548,14 +7548,14 @@ uint32_t ThriftHiveMetastore_get_table_names_by_filter_presult::read(::apache::t
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size930;
- ::apache::thrift::protocol::TType _etype933;
- xfer += iprot->readListBegin(_etype933, _size930);
- (*(this->success)).resize(_size930);
- uint32_t _i934;
- for (_i934 = 0; _i934 < _size930; ++_i934)
+ uint32_t _size932;
+ ::apache::thrift::protocol::TType _etype935;
+ xfer += iprot->readListBegin(_etype935, _size932);
+ (*(this->success)).resize(_size932);
+ uint32_t _i936;
+ for (_i936 = 0; _i936 < _size932; ++_i936)
              {
- xfer += iprot->readString((*(this->success))[_i934]);
+ xfer += iprot->readString((*(this->success))[_i936]);
              }
              xfer += iprot->readListEnd();
            }
@@ -8889,14 +8889,14 @@ uint32_t ThriftHiveMetastore_add_partitions_args::read(::apache::thrift::protoco
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->new_parts.clear();
- uint32_t _size935;
- ::apache::thrift::protocol::TType _etype938;
- xfer += iprot->readListBegin(_etype938, _size935);
- this->new_parts.resize(_size935);
- uint32_t _i939;
- for (_i939 = 0; _i939 < _size935; ++_i939)
+ uint32_t _size937;
+ ::apache::thrift::protocol::TType _etype940;
+ xfer += iprot->readListBegin(_etype940, _size937);
+ this->new_parts.resize(_size937);
+ uint32_t _i941;
+ for (_i941 = 0; _i941 < _size937; ++_i941)
              {
- xfer += this->new_parts[_i939].read(iprot);
+ xfer += this->new_parts[_i941].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -8925,10 +8925,10 @@ uint32_t ThriftHiveMetastore_add_partitions_args::write(::apache::thrift::protoc
    xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->new_parts.size()));
- std::vector<Partition> ::const_iterator _iter940;
- for (_iter940 = this->new_parts.begin(); _iter940 != this->new_parts.end(); ++_iter940)
+ std::vector<Partition> ::const_iterator _iter942;
+ for (_iter942 = this->new_parts.begin(); _iter942 != this->new_parts.end(); ++_iter942)
      {
- xfer += (*_iter940).write(oprot);
+ xfer += (*_iter942).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -8952,10 +8952,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pargs::write(::apache::thrift::proto
    xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->new_parts)).size()));
- std::vector<Partition> ::const_iterator _iter941;
- for (_iter941 = (*(this->new_parts)).begin(); _iter941 != (*(this->new_parts)).end(); ++_iter941)
+ std::vector<Partition> ::const_iterator _iter943;
+ for (_iter943 = (*(this->new_parts)).begin(); _iter943 != (*(this->new_parts)).end(); ++_iter943)
      {
- xfer += (*_iter941).write(oprot);
+ xfer += (*_iter943).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -9164,14 +9164,14 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::read(::apache::thrift::p
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->new_parts.clear();
- uint32_t _size942;
- ::apache::thrift::protocol::TType _etype945;
- xfer += iprot->readListBegin(_etype945, _size942);
- this->new_parts.resize(_size942);
- uint32_t _i946;
- for (_i946 = 0; _i946 < _size942; ++_i946)
+ uint32_t _size944;
+ ::apache::thrift::protocol::TType _etype947;
+ xfer += iprot->readListBegin(_etype947, _size944);
+ this->new_parts.resize(_size944);
+ uint32_t _i948;
+ for (_i948 = 0; _i948 < _size944; ++_i948)
              {
- xfer += this->new_parts[_i946].read(iprot);
+ xfer += this->new_parts[_i948].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -9200,10 +9200,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_args::write(::apache::thrift::
    xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->new_parts.size()));
- std::vector<PartitionSpec> ::const_iterator _iter947;
- for (_iter947 = this->new_parts.begin(); _iter947 != this->new_parts.end(); ++_iter947)
+ std::vector<PartitionSpec> ::const_iterator _iter949;
+ for (_iter949 = this->new_parts.begin(); _iter949 != this->new_parts.end(); ++_iter949)
      {
- xfer += (*_iter947).write(oprot);
+ xfer += (*_iter949).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -9227,10 +9227,10 @@ uint32_t ThriftHiveMetastore_add_partitions_pspec_pargs::write(::apache::thrift:
    xfer += oprot->writeFieldBegin("new_parts", ::apache::thrift::protocol::T_LIST, 1);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>((*(this->new_parts)).size()));
- std::vector<PartitionSpec> ::const_iterator _iter948;
- for (_iter948 = (*(this->new_parts)).begin(); _iter948 != (*(this->new_parts)).end(); ++_iter948)
+ std::vector<PartitionSpec> ::const_iterator _iter950;
+ for (_iter950 = (*(this->new_parts)).begin(); _iter950 != (*(this->new_parts)).end(); ++_iter950)
      {
- xfer += (*_iter948).write(oprot);
+ xfer += (*_iter950).write(oprot);
      }
      xfer += oprot->writeListEnd();
    }
@@ -9455,14 +9455,14 @@ uint32_t ThriftHiveMetastore_append_partition_args::read(::apache::thrift::proto
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size949;
- ::apache::thrift::protocol::TType _etype952;
- xfer += iprot->readListBegin(_etype952, _size949);
- this->part_vals.resize(_size949);
- uint32_t _i953;
- for (_i953 = 0; _i953 < _size949; ++_i953)
+ uint32_t _size951;
+ ::apache::thrift::protocol::TType _etype954;
+ xfer += iprot->readListBegin(_etype954, _size951);
+ this->part_vals.resize(_size951);
+ uint32_t _i955;
+ for (_i955 = 0; _i955 < _size951; ++_i955)
              {
- xfer += iprot->readString(this->part_vals[_i953]);
+ xfer += iprot->readString(this->part_vals[_i955]);
              }
              xfer += iprot->readListEnd();
            }
@@ -9499,10 +9499,10 @@ uint32_t ThriftHiveMetastore_append_partition_args::write(::apache::thrift::prot
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::vector<std::string> ::const_iterator _iter954;
- for (_iter954 = this->part_vals.begin(); _iter954 != this->part_vals.end(); ++_iter954)
+ std::vector<std::string> ::const_iterator _iter956;
+ for (_iter956 = this->part_vals.begin(); _iter956 != this->part_vals.end(); ++_iter956)
      {
- xfer += oprot->writeString((*_iter954));
+ xfer += oprot->writeString((*_iter956));
      }
      xfer += oprot->writeListEnd();
    }
@@ -9534,10 +9534,10 @@ uint32_t ThriftHiveMetastore_append_partition_pargs::write(::apache::thrift::pro
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter955;
- for (_iter955 = (*(this->part_vals)).begin(); _iter955 != (*(this->part_vals)).end(); ++_iter955)
+ std::vector<std::string> ::const_iterator _iter957;
+ for (_iter957 = (*(this->part_vals)).begin(); _iter957 != (*(this->part_vals)).end(); ++_iter957)
      {
- xfer += oprot->writeString((*_iter955));
+ xfer += oprot->writeString((*_iter957));
      }
      xfer += oprot->writeListEnd();
    }
@@ -10009,14 +10009,14 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::rea
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size956;
- ::apache::thrift::protocol::TType _etype959;
- xfer += iprot->readListBegin(_etype959, _size956);
- this->part_vals.resize(_size956);
- uint32_t _i960;
- for (_i960 = 0; _i960 < _size956; ++_i960)
+ uint32_t _size958;
+ ::apache::thrift::protocol::TType _etype961;
+ xfer += iprot->readListBegin(_etype961, _size958);
+ this->part_vals.resize(_size958);
+ uint32_t _i962;
+ for (_i962 = 0; _i962 < _size958; ++_i962)
              {
- xfer += iprot->readString(this->part_vals[_i960]);
+ xfer += iprot->readString(this->part_vals[_i962]);
              }
              xfer += iprot->readListEnd();
            }
@@ -10061,10 +10061,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::wri
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::vector<std::string> ::const_iterator _iter961;
- for (_iter961 = this->part_vals.begin(); _iter961 != this->part_vals.end(); ++_iter961)
+ std::vector<std::string> ::const_iterator _iter963;
+ for (_iter963 = this->part_vals.begin(); _iter963 != this->part_vals.end(); ++_iter963)
      {
- xfer += oprot->writeString((*_iter961));
+ xfer += oprot->writeString((*_iter963));
      }
      xfer += oprot->writeListEnd();
    }
@@ -10100,10 +10100,10 @@ uint32_t ThriftHiveMetastore_append_partition_with_environment_context_pargs::wr
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter962;
- for (_iter962 = (*(this->part_vals)).begin(); _iter962 != (*(this->part_vals)).end(); ++_iter962)
+ std::vector<std::string> ::const_iterator _iter964;
+ for (_iter964 = (*(this->part_vals)).begin(); _iter964 != (*(this->part_vals)).end(); ++_iter964)
      {
- xfer += oprot->writeString((*_iter962));
+ xfer += oprot->writeString((*_iter964));
      }
      xfer += oprot->writeListEnd();
    }
@@ -10906,14 +10906,14 @@ uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protoco
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size963;
- ::apache::thrift::protocol::TType _etype966;
- xfer += iprot->readListBegin(_etype966, _size963);
- this->part_vals.resize(_size963);
- uint32_t _i967;
- for (_i967 = 0; _i967 < _size963; ++_i967)
+ uint32_t _size965;
+ ::apache::thrift::protocol::TType _etype968;
+ xfer += iprot->readListBegin(_etype968, _size965);
+ this->part_vals.resize(_size965);
+ uint32_t _i969;
+ for (_i969 = 0; _i969 < _size965; ++_i969)
              {
- xfer += iprot->readString(this->part_vals[_i967]);
+ xfer += iprot->readString(this->part_vals[_i969]);
              }
              xfer += iprot->readListEnd();
            }
@@ -10958,10 +10958,10 @@ uint32_t ThriftHiveMetastore_drop_partition_args::write(::apache::thrift::protoc
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::vector<std::string> ::const_iterator _iter968;
- for (_iter968 = this->part_vals.begin(); _iter968 != this->part_vals.end(); ++_iter968)
+ std::vector<std::string> ::const_iterator _iter970;
+ for (_iter970 = this->part_vals.begin(); _iter970 != this->part_vals.end(); ++_iter970)
      {
- xfer += oprot->writeString((*_iter968));
+ xfer += oprot->writeString((*_iter970));
      }
      xfer += oprot->writeListEnd();
    }
@@ -10997,10 +10997,10 @@ uint32_t ThriftHiveMetastore_drop_partition_pargs::write(::apache::thrift::proto
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter969;
- for (_iter969 = (*(this->part_vals)).begin(); _iter969 != (*(this->part_vals)).end(); ++_iter969)
+ std::vector<std::string> ::const_iterator _iter971;
+ for (_iter971 = (*(this->part_vals)).begin(); _iter971 != (*(this->part_vals)).end(); ++_iter971)
      {
- xfer += oprot->writeString((*_iter969));
+ xfer += oprot->writeString((*_iter971));
      }
      xfer += oprot->writeListEnd();
    }
@@ -11209,14 +11209,14 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read(
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size970;
- ::apache::thrift::protocol::TType _etype973;
- xfer += iprot->readListBegin(_etype973, _size970);
- this->part_vals.resize(_size970);
- uint32_t _i974;
- for (_i974 = 0; _i974 < _size970; ++_i974)
+ uint32_t _size972;
+ ::apache::thrift::protocol::TType _etype975;
+ xfer += iprot->readListBegin(_etype975, _size972);
+ this->part_vals.resize(_size972);
+ uint32_t _i976;
+ for (_i976 = 0; _i976 < _size972; ++_i976)
              {
- xfer += iprot->readString(this->part_vals[_i974]);
+ xfer += iprot->readString(this->part_vals[_i976]);
              }
              xfer += iprot->readListEnd();
            }
@@ -11269,10 +11269,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::write
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::vector<std::string> ::const_iterator _iter975;
- for (_iter975 = this->part_vals.begin(); _iter975 != this->part_vals.end(); ++_iter975)
+ std::vector<std::string> ::const_iterator _iter977;
+ for (_iter977 = this->part_vals.begin(); _iter977 != this->part_vals.end(); ++_iter977)
      {
- xfer += oprot->writeString((*_iter975));
+ xfer += oprot->writeString((*_iter977));
      }
      xfer += oprot->writeListEnd();
    }
@@ -11312,10 +11312,10 @@ uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_pargs::writ
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter976;
- for (_iter976 = (*(this->part_vals)).begin(); _iter976 != (*(this->part_vals)).end(); ++_iter976)
+ std::vector<std::string> ::const_iterator _iter978;
+ for (_iter978 = (*(this->part_vals)).begin(); _iter978 != (*(this->part_vals)).end(); ++_iter978)
      {
- xfer += oprot->writeString((*_iter976));
+ xfer += oprot->writeString((*_iter978));
      }
      xfer += oprot->writeListEnd();
    }
@@ -12321,14 +12321,14 @@ uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size977;
- ::apache::thrift::protocol::TType _etype980;
- xfer += iprot->readListBegin(_etype980, _size977);
- this->part_vals.resize(_size977);
- uint32_t _i981;
- for (_i981 = 0; _i981 < _size977; ++_i981)
+ uint32_t _size979;
+ ::apache::thrift::protocol::TType _etype982;
+ xfer += iprot->readListBegin(_etype982, _size979);
+ this->part_vals.resize(_size979);
+ uint32_t _i983;
+ for (_i983 = 0; _i983 < _size979; ++_i983)
              {
- xfer += iprot->readString(this->part_vals[_i981]);
+ xfer += iprot->readString(this->part_vals[_i983]);
              }
              xfer += iprot->readListEnd();
            }
@@ -12365,10 +12365,10 @@ uint32_t ThriftHiveMetastore_get_partition_args::write(::apache::thrift::protoco
    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 _iter982;
- for (_iter982 = this->part_vals.begin(); _iter982 != this->part_vals.end(); ++_iter982)
+ std::vector<std::string> ::const_iterator _iter984;
+ for (_iter984 = this->part_vals.begin(); _iter984 != this->part_vals.end(); ++_iter984)
      {
- xfer += oprot->writeString((*_iter982));
+ xfer += oprot->writeString((*_iter984));
      }
      xfer += oprot->writeListEnd();
    }
@@ -12400,10 +12400,10 @@ uint32_t ThriftHiveMetastore_get_partition_pargs::write(::apache::thrift::protoc
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter983;
- for (_iter983 = (*(this->part_vals)).begin(); _iter983 != (*(this->part_vals)).end(); ++_iter983)
+ std::vector<std::string> ::const_iterator _iter985;
+ for (_iter985 = (*(this->part_vals)).begin(); _iter985 != (*(this->part_vals)).end(); ++_iter985)
      {
- xfer += oprot->writeString((*_iter983));
+ xfer += oprot->writeString((*_iter985));
      }
      xfer += oprot->writeListEnd();
    }
@@ -12592,17 +12592,17 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::read(::apache::thrift::pro
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->partitionSpecs.clear();
- uint32_t _size984;
- ::apache::thrift::protocol::TType _ktype985;
- ::apache::thrift::protocol::TType _vtype986;
- xfer += iprot->readMapBegin(_ktype985, _vtype986, _size984);
- uint32_t _i988;
- for (_i988 = 0; _i988 < _size984; ++_i988)
+ uint32_t _size986;
+ ::apache::thrift::protocol::TType _ktype987;
+ ::apache::thrift::protocol::TType _vtype988;
+ xfer += iprot->readMapBegin(_ktype987, _vtype988, _size986);
+ uint32_t _i990;
+ for (_i990 = 0; _i990 < _size986; ++_i990)
              {
- std::string _key989;
- xfer += iprot->readString(_key989);
- std::string& _val990 = this->partitionSpecs[_key989];
- xfer += iprot->readString(_val990);
+ std::string _key991;
+ xfer += iprot->readString(_key991);
+ std::string& _val992 = this->partitionSpecs[_key991];
+ xfer += iprot->readString(_val992);
              }
              xfer += iprot->readMapEnd();
            }
@@ -12663,11 +12663,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_args::write(::apache::thrift::pr
    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 _iter991;
- for (_iter991 = this->partitionSpecs.begin(); _iter991 != this->partitionSpecs.end(); ++_iter991)
+ std::map<std::string, std::string> ::const_iterator _iter993;
+ for (_iter993 = this->partitionSpecs.begin(); _iter993 != this->partitionSpecs.end(); ++_iter993)
      {
- xfer += oprot->writeString(_iter991->first);
- xfer += oprot->writeString(_iter991->second);
+ xfer += oprot->writeString(_iter993->first);
+ xfer += oprot->writeString(_iter993->second);
      }
      xfer += oprot->writeMapEnd();
    }
@@ -12707,11 +12707,11 @@ uint32_t ThriftHiveMetastore_exchange_partition_pargs::write(::apache::thrift::p
    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 _iter992;
- for (_iter992 = (*(this->partitionSpecs)).begin(); _iter992 != (*(this->partitionSpecs)).end(); ++_iter992)
+ std::map<std::string, std::string> ::const_iterator _iter994;
+ for (_iter994 = (*(this->partitionSpecs)).begin(); _iter994 != (*(this->partitionSpecs)).end(); ++_iter994)
      {
- xfer += oprot->writeString(_iter992->first);
- xfer += oprot->writeString(_iter992->second);
+ xfer += oprot->writeString(_iter994->first);
+ xfer += oprot->writeString(_iter994->second);
      }
      xfer += oprot->writeMapEnd();
    }
@@ -12956,17 +12956,17 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::read(::apache::thrift::pr
          if (ftype == ::apache::thrift::protocol::T_MAP) {
            {
              this->partitionSpecs.clear();
- uint32_t _size993;
- ::apache::thrift::protocol::TType _ktype994;
- ::apache::thrift::protocol::TType _vtype995;
- xfer += iprot->readMapBegin(_ktype994, _vtype995, _size993);
- uint32_t _i997;
- for (_i997 = 0; _i997 < _size993; ++_i997)
+ uint32_t _size995;
+ ::apache::thrift::protocol::TType _ktype996;
+ ::apache::thrift::protocol::TType _vtype997;
+ xfer += iprot->readMapBegin(_ktype996, _vtype997, _size995);
+ uint32_t _i999;
+ for (_i999 = 0; _i999 < _size995; ++_i999)
              {
- std::string _key998;
- xfer += iprot->readString(_key998);
- std::string& _val999 = this->partitionSpecs[_key998];
- xfer += iprot->readString(_val999);
+ std::string _key1000;
+ xfer += iprot->readString(_key1000);
+ std::string& _val1001 = this->partitionSpecs[_key1000];
+ xfer += iprot->readString(_val1001);
              }
              xfer += iprot->readMapEnd();
            }
@@ -13027,11 +13027,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_args::write(::apache::thrift::p
    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 _iter1000;
- for (_iter1000 = this->partitionSpecs.begin(); _iter1000 != this->partitionSpecs.end(); ++_iter1000)
+ std::map<std::string, std::string> ::const_iterator _iter1002;
+ for (_iter1002 = this->partitionSpecs.begin(); _iter1002 != this->partitionSpecs.end(); ++_iter1002)
      {
- xfer += oprot->writeString(_iter1000->first);
- xfer += oprot->writeString(_iter1000->second);
+ xfer += oprot->writeString(_iter1002->first);
+ xfer += oprot->writeString(_iter1002->second);
      }
      xfer += oprot->writeMapEnd();
    }
@@ -13071,11 +13071,11 @@ uint32_t ThriftHiveMetastore_exchange_partitions_pargs::write(::apache::thrift::
    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 _iter1001;
- for (_iter1001 = (*(this->partitionSpecs)).begin(); _iter1001 != (*(this->partitionSpecs)).end(); ++_iter1001)
+ std::map<std::string, std::string> ::const_iterator _iter1003;
+ for (_iter1003 = (*(this->partitionSpecs)).begin(); _iter1003 != (*(this->partitionSpecs)).end(); ++_iter1003)
      {
- xfer += oprot->writeString(_iter1001->first);
- xfer += oprot->writeString(_iter1001->second);
+ xfer += oprot->writeString(_iter1003->first);
+ xfer += oprot->writeString(_iter1003->second);
      }
      xfer += oprot->writeMapEnd();
    }
@@ -13132,14 +13132,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_result::read(::apache::thrift::
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- 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)
+ uint32_t _size1004;
+ ::apache::thrift::protocol::TType _etype1007;
+ xfer += iprot->readListBegin(_etype1007, _size1004);
+ this->success.resize(_size1004);
+ uint32_t _i1008;
+ for (_i1008 = 0; _i1008 < _size1004; ++_i1008)
              {
- xfer += this->success[_i1006].read(iprot);
+ xfer += this->success[_i1008].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -13202,10 +13202,10 @@ uint32_t ThriftHiveMetastore_exchange_partitions_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<Partition> ::const_iterator _iter1007;
- for (_iter1007 = this->success.begin(); _iter1007 != this->success.end(); ++_iter1007)
+ std::vector<Partition> ::const_iterator _iter1009;
+ for (_iter1009 = this->success.begin(); _iter1009 != this->success.end(); ++_iter1009)
        {
- xfer += (*_iter1007).write(oprot);
+ xfer += (*_iter1009).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -13262,14 +13262,14 @@ uint32_t ThriftHiveMetastore_exchange_partitions_presult::read(::apache::thrift:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size1008;
- ::apache::thrift::protocol::TType _etype1011;
- xfer += iprot->readListBegin(_etype1011, _size1008);
- (*(this->success)).resize(_size1008);
- uint32_t _i1012;
- for (_i1012 = 0; _i1012 < _size1008; ++_i1012)
+ uint32_t _size1010;
+ ::apache::thrift::protocol::TType _etype1013;
+ xfer += iprot->readListBegin(_etype1013, _size1010);
+ (*(this->success)).resize(_size1010);
+ uint32_t _i1014;
+ for (_i1014 = 0; _i1014 < _size1010; ++_i1014)
              {
- xfer += (*(this->success))[_i1012].read(iprot);
+ xfer += (*(this->success))[_i1014].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -13368,14 +13368,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 _size1013;
- ::apache::thrift::protocol::TType _etype1016;
- xfer += iprot->readListBegin(_etype1016, _size1013);
- this->part_vals.resize(_size1013);
- uint32_t _i1017;
- for (_i1017 = 0; _i1017 < _size1013; ++_i1017)
+ uint32_t _size1015;
+ ::apache::thrift::protocol::TType _etype1018;
+ xfer += iprot->readListBegin(_etype1018, _size1015);
+ this->part_vals.resize(_size1015);
+ uint32_t _i1019;
+ for (_i1019 = 0; _i1019 < _size1015; ++_i1019)
              {
- xfer += iprot->readString(this->part_vals[_i1017]);
+ xfer += iprot->readString(this->part_vals[_i1019]);
              }
              xfer += iprot->readListEnd();
            }
@@ -13396,14 +13396,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 _size1018;
- ::apache::thrift::protocol::TType _etype1021;
- xfer += iprot->readListBegin(_etype1021, _size1018);
- this->group_names.resize(_size1018);
- uint32_t _i1022;
- for (_i1022 = 0; _i1022 < _size1018; ++_i1022)
+ uint32_t _size1020;
+ ::apache::thrift::protocol::TType _etype1023;
+ xfer += iprot->readListBegin(_etype1023, _size1020);
+ this->group_names.resize(_size1020);
+ uint32_t _i1024;
+ for (_i1024 = 0; _i1024 < _size1020; ++_i1024)
              {
- xfer += iprot->readString(this->group_names[_i1022]);
+ xfer += iprot->readString(this->group_names[_i1024]);
              }
              xfer += iprot->readListEnd();
            }
@@ -13440,10 +13440,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 _iter1023;
- for (_iter1023 = this->part_vals.begin(); _iter1023 != this->part_vals.end(); ++_iter1023)
+ std::vector<std::string> ::const_iterator _iter1025;
+ for (_iter1025 = this->part_vals.begin(); _iter1025 != this->part_vals.end(); ++_iter1025)
      {
- xfer += oprot->writeString((*_iter1023));
+ xfer += oprot->writeString((*_iter1025));
      }
      xfer += oprot->writeListEnd();
    }
@@ -13456,10 +13456,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 _iter1024;
- for (_iter1024 = this->group_names.begin(); _iter1024 != this->group_names.end(); ++_iter1024)
+ std::vector<std::string> ::const_iterator _iter1026;
+ for (_iter1026 = this->group_names.begin(); _iter1026 != this->group_names.end(); ++_iter1026)
      {
- xfer += oprot->writeString((*_iter1024));
+ xfer += oprot->writeString((*_iter1026));
      }
      xfer += oprot->writeListEnd();
    }
@@ -13491,10 +13491,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 _iter1025;
- for (_iter1025 = (*(this->part_vals)).begin(); _iter1025 != (*(this->part_vals)).end(); ++_iter1025)
+ std::vector<std::string> ::const_iterator _iter1027;
+ for (_iter1027 = (*(this->part_vals)).begin(); _iter1027 != (*(this->part_vals)).end(); ++_iter1027)
      {
- xfer += oprot->writeString((*_iter1025));
+ xfer += oprot->writeString((*_iter1027));
      }
      xfer += oprot->writeListEnd();
    }
@@ -13507,10 +13507,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 _iter1026;
- for (_iter1026 = (*(this->group_names)).begin(); _iter1026 != (*(this->group_names)).end(); ++_iter1026)
+ std::vector<std::string> ::const_iterator _iter1028;
+ for (_iter1028 = (*(this->group_names)).begin(); _iter1028 != (*(this->group_names)).end(); ++_iter1028)
      {
- xfer += oprot->writeString((*_iter1026));
+ xfer += oprot->writeString((*_iter1028));
      }
      xfer += oprot->writeListEnd();
    }
@@ -14069,14 +14069,14 @@ uint32_t ThriftHiveMetastore_get_partitions_result::read(::apache::thrift::proto
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size1027;
- ::apache::thrift::protocol::TType _etype1030;
- xfer += iprot->readListBegin(_etype1030, _size1027);
- this->success.resize(_size1027);
- uint32_t _i1031;
- for (_i1031 = 0; _i1031 < _size1027; ++_i1031)
+ uint32_t _size1029;
+ ::apache::thrift::protocol::TType _etype1032;
+ xfer += iprot->readListBegin(_etype1032, _size1029);
+ this->success.resize(_size1029);
+ uint32_t _i1033;
+ for (_i1033 = 0; _i1033 < _size1029; ++_i1033)
              {
- xfer += this->success[_i1031].read(iprot);
+ xfer += this->success[_i1033].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -14123,10 +14123,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 _iter1032;
- for (_iter1032 = this->success.begin(); _iter1032 != this->success.end(); ++_iter1032)
+ std::vector<Partition> ::const_iterator _iter1034;
+ for (_iter1034 = this->success.begin(); _iter1034 != this->success.end(); ++_iter1034)
        {
- xfer += (*_iter1032).write(oprot);
+ xfer += (*_iter1034).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -14175,14 +14175,14 @@ uint32_t ThriftHiveMetastore_get_partitions_presult::read(::apache::thrift::prot
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size1033;
- ::apache::thrift::protocol::TType _etype1036;
- xfer += iprot->readListBegin(_etype1036, _size1033);
- (*(this->success)).resize(_size1033);
- uint32_t _i1037;
- for (_i1037 = 0; _i1037 < _size1033; ++_i1037)
+ uint32_t _size1035;
+ ::apache::thrift::protocol::TType _etype1038;
+ xfer += iprot->readListBegin(_etype1038, _size1035);
+ (*(this->success)).resize(_size1035);
+ uint32_t _i1039;
+ for (_i1039 = 0; _i1039 < _size1035; ++_i1039)
              {
- xfer += (*(this->success))[_i1037].read(iprot);
+ xfer += (*(this->success))[_i1039].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -14281,14 +14281,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 _size1038;
- ::apache::thrift::protocol::TType _etype1041;
- xfer += iprot->readListBegin(_etype1041, _size1038);
- this->group_names.resize(_size1038);
- uint32_t _i1042;
- for (_i1042 = 0; _i1042 < _size1038; ++_i1042)
+ uint32_t _size1040;
+ ::apache::thrift::protocol::TType _etype1043;
+ xfer += iprot->readListBegin(_etype1043, _size1040);
+ this->group_names.resize(_size1040);
+ uint32_t _i1044;
+ for (_i1044 = 0; _i1044 < _size1040; ++_i1044)
              {
- xfer += iprot->readString(this->group_names[_i1042]);
+ xfer += iprot->readString(this->group_names[_i1044]);
              }
              xfer += iprot->readListEnd();
            }
@@ -14333,10 +14333,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 _iter1043;
- for (_iter1043 = this->group_names.begin(); _iter1043 != this->group_names.end(); ++_iter1043)
+ std::vector<std::string> ::const_iterator _iter1045;
+ for (_iter1045 = this->group_names.begin(); _iter1045 != this->group_names.end(); ++_iter1045)
      {
- xfer += oprot->writeString((*_iter1043));
+ xfer += oprot->writeString((*_iter1045));
      }
      xfer += oprot->writeListEnd();
    }
@@ -14376,10 +14376,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 _iter1044;
- for (_iter1044 = (*(this->group_names)).begin(); _iter1044 != (*(this->group_names)).end(); ++_iter1044)
+ std::vector<std::string> ::const_iterator _iter1046;
+ for (_iter1046 = (*(this->group_names)).begin(); _iter1046 != (*(this->group_names)).end(); ++_iter1046)
      {
- xfer += oprot->writeString((*_iter1044));
+ xfer += oprot->writeString((*_iter1046));
      }
      xfer += oprot->writeListEnd();
    }
@@ -14420,14 +14420,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_result::read(::apache::thr
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size1045;
- ::apache::thrift::protocol::TType _etype1048;
- xfer += iprot->readListBegin(_etype1048, _size1045);
- this->success.resize(_size1045);
- uint32_t _i1049;
- for (_i1049 = 0; _i1049 < _size1045; ++_i1049)
+ uint32_t _size1047;
+ ::apache::thrift::protocol::TType _etype1050;
+ xfer += iprot->readListBegin(_etype1050, _size1047);
+ this->success.resize(_size1047);
+ uint32_t _i1051;
+ for (_i1051 = 0; _i1051 < _size1047; ++_i1051)
              {
- xfer += this->success[_i1049].read(iprot);
+ xfer += this->success[_i1051].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -14474,10 +14474,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 _iter1050;
- for (_iter1050 = this->success.begin(); _iter1050 != this->success.end(); ++_iter1050)
+ std::vector<Partition> ::const_iterator _iter1052;
+ for (_iter1052 = this->success.begin(); _iter1052 != this->success.end(); ++_iter1052)
        {
- xfer += (*_iter1050).write(oprot);
+ xfer += (*_iter1052).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -14526,14 +14526,14 @@ uint32_t ThriftHiveMetastore_get_partitions_with_auth_presult::read(::apache::th
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size1051;
- ::apache::thrift::protocol::TType _etype1054;
- xfer += iprot->readListBegin(_etype1054, _size1051);
- (*(this->success)).resize(_size1051);
- uint32_t _i1055;
- for (_i1055 = 0; _i1055 < _size1051; ++_i1055)
+ uint32_t _size1053;
+ ::apache::thrift::protocol::TType _etype1056;
+ xfer += iprot->readListBegin(_etype1056, _size1053);
+ (*(this->success)).resize(_size1053);
+ uint32_t _i1057;
+ for (_i1057 = 0; _i1057 < _size1053; ++_i1057)
              {
- xfer += (*(this->success))[_i1055].read(iprot);
+ xfer += (*(this->success))[_i1057].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -14711,14 +14711,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_result::read(::apache::thrift:
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size1056;
- ::apache::thrift::protocol::TType _etype1059;
- xfer += iprot->readListBegin(_etype1059, _size1056);
- this->success.resize(_size1056);
- uint32_t _i1060;
- for (_i1060 = 0; _i1060 < _size1056; ++_i1060)
+ uint32_t _size1058;
+ ::apache::thrift::protocol::TType _etype1061;
+ xfer += iprot->readListBegin(_etype1061, _size1058);
+ this->success.resize(_size1058);
+ uint32_t _i1062;
+ for (_i1062 = 0; _i1062 < _size1058; ++_i1062)
              {
- xfer += this->success[_i1060].read(iprot);
+ xfer += this->success[_i1062].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -14765,10 +14765,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 _iter1061;
- for (_iter1061 = this->success.begin(); _iter1061 != this->success.end(); ++_iter1061)
+ std::vector<PartitionSpec> ::const_iterator _iter1063;
+ for (_iter1063 = this->success.begin(); _iter1063 != this->success.end(); ++_iter1063)
        {
- xfer += (*_iter1061).write(oprot);
+ xfer += (*_iter1063).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -14817,14 +14817,14 @@ uint32_t ThriftHiveMetastore_get_partitions_pspec_presult::read(::apache::thrift
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size1062;
- ::apache::thrift::protocol::TType _etype1065;
- xfer += iprot->readListBegin(_etype1065, _size1062);
- (*(this->success)).resize(_size1062);
- uint32_t _i1066;
- for (_i1066 = 0; _i1066 < _size1062; ++_i1066)
+ uint32_t _size1064;
+ ::apache::thrift::protocol::TType _etype1067;
+ xfer += iprot->readListBegin(_etype1067, _size1064);
+ (*(this->success)).resize(_size1064);
+ uint32_t _i1068;
+ for (_i1068 = 0; _i1068 < _size1064; ++_i1068)
              {
- xfer += (*(this->success))[_i1066].read(iprot);
+ xfer += (*(this->success))[_i1068].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -15002,14 +15002,14 @@ uint32_t ThriftHiveMetastore_get_partition_names_result::read(::apache::thrift::
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size1067;
- ::apache::thrift::protocol::TType _etype1070;
- xfer += iprot->readListBegin(_etype1070, _size1067);
- this->success.resize(_size1067);
- uint32_t _i1071;
- for (_i1071 = 0; _i1071 < _size1067; ++_i1071)
+ uint32_t _size1069;
+ ::apache::thrift::protocol::TType _etype1072;
+ xfer += iprot->readListBegin(_etype1072, _size1069);
+ this->success.resize(_size1069);
+ uint32_t _i1073;
+ for (_i1073 = 0; _i1073 < _size1069; ++_i1073)
              {
- xfer += iprot->readString(this->success[_i1071]);
+ xfer += iprot->readString(this->success[_i1073]);
              }

<TRUNCATED>

Search Discussions

Discussion Posts

Previous

Follow ups

Related Discussions

Discussion Navigation
viewthread | post
posts ‹ prev | 2 of 11 | next ›
Discussion Overview
groupcommits @
categorieshive, hadoop
postedMay 19, '16 at 7:29p
activeMay 19, '16 at 8:00p
posts11
users1
websitehive.apache.org

1 user in discussion

Ekoifman: 11 posts

People

Translate

site design / logo © 2021 Grokbase