FAQ
Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp?rev=1445309&r1=1445308&r2=1445309&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.cpp Tue Feb 12 18:52:55 2013
@@ -3312,6 +3312,236 @@ uint32_t ThriftHiveMetastore_drop_table_
    return xfer;
  }

+uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->dbname);
+ this->__isset.dbname = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->name);
+ this->__isset.name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->deleteData);
+ this->__isset.deleteData = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->environment_context.read(iprot);
+ this->__isset.environment_context = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_table_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_args");
+
+ xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->dbname);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->name);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3);
+ xfer += oprot->writeBool(this->deleteData);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->environment_context.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_table_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_pargs");
+
+ xfer += oprot->writeFieldBegin("dbname", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->dbname)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("name", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString((*(this->name)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 3);
+ xfer += oprot->writeBool((*(this->deleteData)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += (*(this->environment_context)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_table_with_environment_context_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 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->o3.read(iprot);
+ this->__isset.o3 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_table_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_table_with_environment_context_result");
+
+ if (this->__isset.o1) {
+ xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->o1.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o3) {
+ xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->o3.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_table_with_environment_context_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 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->o3.read(iprot);
+ this->__isset.o3 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
  uint32_t ThriftHiveMetastore_get_tables_args::read(::apache::thrift::protocol::TProtocol* iprot) {

    uint32_t xfer = 0;
@@ -5994,7 +6224,7 @@ uint32_t ThriftHiveMetastore_append_part
    return xfer;
  }

-uint32_t ThriftHiveMetastore_append_partition_by_name_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) {

    uint32_t xfer = 0;
    std::string fname;
@@ -6031,9 +6261,29 @@ uint32_t ThriftHiveMetastore_append_part
          }
          break;
        case 3:
- if (ftype == ::apache::thrift::protocol::T_STRING) {
- xfer += iprot->readString(this->part_name);
- this->__isset.part_name = true;
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->part_vals.clear();
+ uint32_t _size325;
+ ::apache::thrift::protocol::TType _etype328;
+ xfer += iprot->readListBegin(_etype328, _size325);
+ this->part_vals.resize(_size325);
+ uint32_t _i329;
+ for (_i329 = 0; _i329 < _size325; ++_i329)
+ {
+ xfer += iprot->readString(this->part_vals[_i329]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.part_vals = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->environment_context.read(iprot);
+ this->__isset.environment_context = true;
          } else {
            xfer += iprot->skip(ftype);
          }
@@ -6050,9 +6300,9 @@ uint32_t ThriftHiveMetastore_append_part
    return xfer;
  }

-uint32_t ThriftHiveMetastore_append_partition_by_name_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t ThriftHiveMetastore_append_partition_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
- xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_by_name_args");
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_with_environment_context_args");

    xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeString(this->db_name);
@@ -6062,18 +6312,30 @@ uint32_t ThriftHiveMetastore_append_part
    xfer += oprot->writeString(this->tbl_name);
    xfer += oprot->writeFieldEnd();

- xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3);
- xfer += oprot->writeString(this->part_name);
- xfer += oprot->writeFieldEnd();
-
- xfer += oprot->writeFieldStop();
- xfer += oprot->writeStructEnd();
- return xfer;
-}
-
-uint32_t ThriftHiveMetastore_append_partition_by_name_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
- uint32_t xfer = 0;
- xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_by_name_pargs");
+ 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 _iter330;
+ for (_iter330 = this->part_vals.begin(); _iter330 != this->part_vals.end(); ++_iter330)
+ {
+ xfer += oprot->writeString((*_iter330));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->environment_context.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_append_partition_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_with_environment_context_pargs");

    xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeString((*(this->db_name)));
@@ -6083,8 +6345,20 @@ uint32_t ThriftHiveMetastore_append_part
    xfer += oprot->writeString((*(this->tbl_name)));
    xfer += oprot->writeFieldEnd();

- xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3);
- xfer += oprot->writeString((*(this->part_name)));
+ 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 _iter331;
+ for (_iter331 = (*(this->part_vals)).begin(); _iter331 != (*(this->part_vals)).end(); ++_iter331)
+ {
+ xfer += oprot->writeString((*_iter331));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += (*(this->environment_context)).write(oprot);
    xfer += oprot->writeFieldEnd();

    xfer += oprot->writeFieldStop();
@@ -6092,7 +6366,7 @@ uint32_t ThriftHiveMetastore_append_part
    return xfer;
  }

-uint32_t ThriftHiveMetastore_append_partition_by_name_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t ThriftHiveMetastore_append_partition_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) {

    uint32_t xfer = 0;
    std::string fname;
@@ -6156,11 +6430,11 @@ uint32_t ThriftHiveMetastore_append_part
    return xfer;
  }

-uint32_t ThriftHiveMetastore_append_partition_by_name_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t ThriftHiveMetastore_append_partition_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const {

    uint32_t xfer = 0;

- xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_by_name_result");
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_with_environment_context_result");

    if (this->__isset.success) {
      xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
@@ -6184,7 +6458,7 @@ uint32_t ThriftHiveMetastore_append_part
    return xfer;
  }

-uint32_t ThriftHiveMetastore_append_partition_by_name_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t ThriftHiveMetastore_append_partition_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) {

    uint32_t xfer = 0;
    std::string fname;
@@ -6248,7 +6522,7 @@ uint32_t ThriftHiveMetastore_append_part
    return xfer;
  }

-uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t ThriftHiveMetastore_append_partition_by_name_args::read(::apache::thrift::protocol::TProtocol* iprot) {

    uint32_t xfer = 0;
    std::string fname;
@@ -6285,29 +6559,9 @@ uint32_t ThriftHiveMetastore_drop_partit
          }
          break;
        case 3:
- if (ftype == ::apache::thrift::protocol::T_LIST) {
- {
- this->part_vals.clear();
- uint32_t _size325;
- ::apache::thrift::protocol::TType _etype328;
- xfer += iprot->readListBegin(_etype328, _size325);
- this->part_vals.resize(_size325);
- uint32_t _i329;
- for (_i329 = 0; _i329 < _size325; ++_i329)
- {
- xfer += iprot->readString(this->part_vals[_i329]);
- }
- xfer += iprot->readListEnd();
- }
- this->__isset.part_vals = true;
- } else {
- xfer += iprot->skip(ftype);
- }
- break;
- case 4:
- if (ftype == ::apache::thrift::protocol::T_BOOL) {
- xfer += iprot->readBool(this->deleteData);
- this->__isset.deleteData = true;
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->part_name);
+ this->__isset.part_name = true;
          } else {
            xfer += iprot->skip(ftype);
          }
@@ -6324,9 +6578,9 @@ uint32_t ThriftHiveMetastore_drop_partit
    return xfer;
  }

-uint32_t ThriftHiveMetastore_drop_partition_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t ThriftHiveMetastore_append_partition_by_name_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
- xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_args");
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_by_name_args");

    xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeString(this->db_name);
@@ -6336,20 +6590,8 @@ uint32_t ThriftHiveMetastore_drop_partit
    xfer += oprot->writeString(this->tbl_name);
    xfer += oprot->writeFieldEnd();

- 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 _iter330;
- for (_iter330 = this->part_vals.begin(); _iter330 != this->part_vals.end(); ++_iter330)
- {
- xfer += oprot->writeString((*_iter330));
- }
- xfer += oprot->writeListEnd();
- }
- xfer += oprot->writeFieldEnd();
-
- xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4);
- xfer += oprot->writeBool(this->deleteData);
+ xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->part_name);
    xfer += oprot->writeFieldEnd();

    xfer += oprot->writeFieldStop();
@@ -6357,9 +6599,9 @@ uint32_t ThriftHiveMetastore_drop_partit
    return xfer;
  }

-uint32_t ThriftHiveMetastore_drop_partition_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t ThriftHiveMetastore_append_partition_by_name_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
- xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_pargs");
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_by_name_pargs");

    xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeString((*(this->db_name)));
@@ -6369,20 +6611,8 @@ uint32_t ThriftHiveMetastore_drop_partit
    xfer += oprot->writeString((*(this->tbl_name)));
    xfer += oprot->writeFieldEnd();

- 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 _iter331;
- for (_iter331 = (*(this->part_vals)).begin(); _iter331 != (*(this->part_vals)).end(); ++_iter331)
- {
- xfer += oprot->writeString((*_iter331));
- }
- xfer += oprot->writeListEnd();
- }
- xfer += oprot->writeFieldEnd();
-
- xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4);
- xfer += oprot->writeBool((*(this->deleteData)));
+ xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString((*(this->part_name)));
    xfer += oprot->writeFieldEnd();

    xfer += oprot->writeFieldStop();
@@ -6390,7 +6620,7 @@ uint32_t ThriftHiveMetastore_drop_partit
    return xfer;
  }

-uint32_t ThriftHiveMetastore_drop_partition_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t ThriftHiveMetastore_append_partition_by_name_result::read(::apache::thrift::protocol::TProtocol* iprot) {

    uint32_t xfer = 0;
    std::string fname;
@@ -6411,8 +6641,8 @@ uint32_t ThriftHiveMetastore_drop_partit
      switch (fid)
      {
        case 0:
- if (ftype == ::apache::thrift::protocol::T_BOOL) {
- xfer += iprot->readBool(this->success);
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->success.read(iprot);
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
@@ -6434,6 +6664,14 @@ uint32_t ThriftHiveMetastore_drop_partit
            xfer += iprot->skip(ftype);
          }
          break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o3.read(iprot);
+ this->__isset.o3 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
        default:
          xfer += iprot->skip(ftype);
          break;
@@ -6446,15 +6684,15 @@ uint32_t ThriftHiveMetastore_drop_partit
    return xfer;
  }

-uint32_t ThriftHiveMetastore_drop_partition_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t ThriftHiveMetastore_append_partition_by_name_result::write(::apache::thrift::protocol::TProtocol* oprot) const {

    uint32_t xfer = 0;

- xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_result");
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_by_name_result");

    if (this->__isset.success) {
- xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0);
- xfer += oprot->writeBool(this->success);
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+ xfer += this->success.write(oprot);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.o1) {
      xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -6464,13 +6702,17 @@ uint32_t ThriftHiveMetastore_drop_partit
      xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2);
      xfer += this->o2.write(oprot);
      xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o3) {
+ xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->o3.write(oprot);
+ xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }

-uint32_t ThriftHiveMetastore_drop_partition_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t ThriftHiveMetastore_append_partition_by_name_presult::read(::apache::thrift::protocol::TProtocol* iprot) {

    uint32_t xfer = 0;
    std::string fname;
@@ -6491,8 +6733,8 @@ uint32_t ThriftHiveMetastore_drop_partit
      switch (fid)
      {
        case 0:
- if (ftype == ::apache::thrift::protocol::T_BOOL) {
- xfer += iprot->readBool((*(this->success)));
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += (*(this->success)).read(iprot);
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
@@ -6514,6 +6756,14 @@ uint32_t ThriftHiveMetastore_drop_partit
            xfer += iprot->skip(ftype);
          }
          break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o3.read(iprot);
+ this->__isset.o3 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
        default:
          xfer += iprot->skip(ftype);
          break;
@@ -6526,7 +6776,7 @@ uint32_t ThriftHiveMetastore_drop_partit
    return xfer;
  }

-uint32_t ThriftHiveMetastore_drop_partition_by_name_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t ThriftHiveMetastore_append_partition_by_name_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) {

    uint32_t xfer = 0;
    std::string fname;
@@ -6571,9 +6821,9 @@ uint32_t ThriftHiveMetastore_drop_partit
          }
          break;
        case 4:
- if (ftype == ::apache::thrift::protocol::T_BOOL) {
- xfer += iprot->readBool(this->deleteData);
- this->__isset.deleteData = true;
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->environment_context.read(iprot);
+ this->__isset.environment_context = true;
          } else {
            xfer += iprot->skip(ftype);
          }
@@ -6590,9 +6840,9 @@ uint32_t ThriftHiveMetastore_drop_partit
    return xfer;
  }

-uint32_t ThriftHiveMetastore_drop_partition_by_name_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t ThriftHiveMetastore_append_partition_by_name_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
- xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_by_name_args");
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_by_name_with_environment_context_args");

    xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeString(this->db_name);
@@ -6606,8 +6856,8 @@ uint32_t ThriftHiveMetastore_drop_partit
    xfer += oprot->writeString(this->part_name);
    xfer += oprot->writeFieldEnd();

- xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4);
- xfer += oprot->writeBool(this->deleteData);
+ xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += this->environment_context.write(oprot);
    xfer += oprot->writeFieldEnd();

    xfer += oprot->writeFieldStop();
@@ -6615,9 +6865,9 @@ uint32_t ThriftHiveMetastore_drop_partit
    return xfer;
  }

-uint32_t ThriftHiveMetastore_drop_partition_by_name_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t ThriftHiveMetastore_append_partition_by_name_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
- xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_by_name_pargs");
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_by_name_with_environment_context_pargs");

    xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeString((*(this->db_name)));
@@ -6631,8 +6881,8 @@ uint32_t ThriftHiveMetastore_drop_partit
    xfer += oprot->writeString((*(this->part_name)));
    xfer += oprot->writeFieldEnd();

- xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4);
- xfer += oprot->writeBool((*(this->deleteData)));
+ xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 4);
+ xfer += (*(this->environment_context)).write(oprot);
    xfer += oprot->writeFieldEnd();

    xfer += oprot->writeFieldStop();
@@ -6640,7 +6890,7 @@ uint32_t ThriftHiveMetastore_drop_partit
    return xfer;
  }

-uint32_t ThriftHiveMetastore_drop_partition_by_name_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t ThriftHiveMetastore_append_partition_by_name_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) {

    uint32_t xfer = 0;
    std::string fname;
@@ -6661,8 +6911,8 @@ uint32_t ThriftHiveMetastore_drop_partit
      switch (fid)
      {
        case 0:
- if (ftype == ::apache::thrift::protocol::T_BOOL) {
- xfer += iprot->readBool(this->success);
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->success.read(iprot);
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
@@ -6684,6 +6934,14 @@ uint32_t ThriftHiveMetastore_drop_partit
            xfer += iprot->skip(ftype);
          }
          break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o3.read(iprot);
+ this->__isset.o3 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
        default:
          xfer += iprot->skip(ftype);
          break;
@@ -6696,15 +6954,15 @@ uint32_t ThriftHiveMetastore_drop_partit
    return xfer;
  }

-uint32_t ThriftHiveMetastore_drop_partition_by_name_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t ThriftHiveMetastore_append_partition_by_name_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const {

    uint32_t xfer = 0;

- xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_by_name_result");
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_append_partition_by_name_with_environment_context_result");

    if (this->__isset.success) {
- xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0);
- xfer += oprot->writeBool(this->success);
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+ xfer += this->success.write(oprot);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.o1) {
      xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -6714,13 +6972,17 @@ uint32_t ThriftHiveMetastore_drop_partit
      xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2);
      xfer += this->o2.write(oprot);
      xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o3) {
+ xfer += oprot->writeFieldBegin("o3", ::apache::thrift::protocol::T_STRUCT, 3);
+ xfer += this->o3.write(oprot);
+ xfer += oprot->writeFieldEnd();
    }
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }

-uint32_t ThriftHiveMetastore_drop_partition_by_name_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) {

    uint32_t xfer = 0;
    std::string fname;
@@ -6741,8 +7003,8 @@ uint32_t ThriftHiveMetastore_drop_partit
      switch (fid)
      {
        case 0:
- if (ftype == ::apache::thrift::protocol::T_BOOL) {
- xfer += iprot->readBool((*(this->success)));
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += (*(this->success)).read(iprot);
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
@@ -6764,6 +7026,14 @@ uint32_t ThriftHiveMetastore_drop_partit
            xfer += iprot->skip(ftype);
          }
          break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o3.read(iprot);
+ this->__isset.o3 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
        default:
          xfer += iprot->skip(ftype);
          break;
@@ -6776,7 +7046,7 @@ uint32_t ThriftHiveMetastore_drop_partit
    return xfer;
  }

-uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t ThriftHiveMetastore_drop_partition_args::read(::apache::thrift::protocol::TProtocol* iprot) {

    uint32_t xfer = 0;
    std::string fname;
@@ -6832,6 +7102,14 @@ uint32_t ThriftHiveMetastore_get_partiti
            xfer += iprot->skip(ftype);
          }
          break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->deleteData);
+ this->__isset.deleteData = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
        default:
          xfer += iprot->skip(ftype);
          break;
@@ -6844,9 +7122,9 @@ uint32_t ThriftHiveMetastore_get_partiti
    return xfer;
  }

-uint32_t ThriftHiveMetastore_get_partition_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t ThriftHiveMetastore_drop_partition_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
- xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_args");
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_args");

    xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeString(this->db_name);
@@ -6868,14 +7146,18 @@ uint32_t ThriftHiveMetastore_get_partiti
    }
    xfer += oprot->writeFieldEnd();

+ xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool(this->deleteData);
+ xfer += oprot->writeFieldEnd();
+
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }

-uint32_t ThriftHiveMetastore_get_partition_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t ThriftHiveMetastore_drop_partition_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
    uint32_t xfer = 0;
- xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_pargs");
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_pargs");

    xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
    xfer += oprot->writeString((*(this->db_name)));
@@ -6897,12 +7179,16 @@ uint32_t ThriftHiveMetastore_get_partiti
    }
    xfer += oprot->writeFieldEnd();

+ xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool((*(this->deleteData)));
+ xfer += oprot->writeFieldEnd();
+
    xfer += oprot->writeFieldStop();
    xfer += oprot->writeStructEnd();
    return xfer;
  }

-uint32_t ThriftHiveMetastore_get_partition_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t ThriftHiveMetastore_drop_partition_result::read(::apache::thrift::protocol::TProtocol* iprot) {

    uint32_t xfer = 0;
    std::string fname;
@@ -6923,8 +7209,8 @@ uint32_t ThriftHiveMetastore_get_partiti
      switch (fid)
      {
        case 0:
- if (ftype == ::apache::thrift::protocol::T_STRUCT) {
- xfer += this->success.read(iprot);
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->success);
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
@@ -6958,15 +7244,15 @@ uint32_t ThriftHiveMetastore_get_partiti
    return xfer;
  }

-uint32_t ThriftHiveMetastore_get_partition_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+uint32_t ThriftHiveMetastore_drop_partition_result::write(::apache::thrift::protocol::TProtocol* oprot) const {

    uint32_t xfer = 0;

- xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_result");
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_result");

    if (this->__isset.success) {
- xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
- xfer += this->success.write(oprot);
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0);
+ xfer += oprot->writeBool(this->success);
      xfer += oprot->writeFieldEnd();
    } else if (this->__isset.o1) {
      xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1);
@@ -6982,7 +7268,7 @@ uint32_t ThriftHiveMetastore_get_partiti
    return xfer;
  }

-uint32_t ThriftHiveMetastore_get_partition_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t ThriftHiveMetastore_drop_partition_presult::read(::apache::thrift::protocol::TProtocol* iprot) {

    uint32_t xfer = 0;
    std::string fname;
@@ -7003,8 +7289,8 @@ uint32_t ThriftHiveMetastore_get_partiti
      switch (fid)
      {
        case 0:
- if (ftype == ::apache::thrift::protocol::T_STRUCT) {
- xfer += (*(this->success)).read(iprot);
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool((*(this->success)));
            this->__isset.success = true;
          } else {
            xfer += iprot->skip(ftype);
@@ -7038,7 +7324,7 @@ uint32_t ThriftHiveMetastore_get_partiti
    return xfer;
  }

-uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) {

    uint32_t xfer = 0;
    std::string fname;
@@ -7095,9 +7381,1081 @@ uint32_t ThriftHiveMetastore_get_partiti
          }
          break;
        case 4:
- if (ftype == ::apache::thrift::protocol::T_STRING) {
- xfer += iprot->readString(this->user_name);
- this->__isset.user_name = true;
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->deleteData);
+ this->__isset.deleteData = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->environment_context.read(iprot);
+ this->__isset.environment_context = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_with_environment_context_args");
+
+ xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->db_name);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tbl_name);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("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 _iter344;
+ for (_iter344 = this->part_vals.begin(); _iter344 != this->part_vals.end(); ++_iter344)
+ {
+ xfer += oprot->writeString((*_iter344));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool(this->deleteData);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 5);
+ xfer += this->environment_context.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_with_environment_context_pargs");
+
+ xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->db_name)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString((*(this->tbl_name)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("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 _iter345;
+ for (_iter345 = (*(this->part_vals)).begin(); _iter345 != (*(this->part_vals)).end(); ++_iter345)
+ {
+ xfer += oprot->writeString((*_iter345));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool((*(this->deleteData)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 5);
+ xfer += (*(this->environment_context)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->success);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o2.read(iprot);
+ this->__isset.o2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_with_environment_context_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0);
+ xfer += oprot->writeBool(this->success);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o1) {
+ xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->o1.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o2) {
+ xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->o2.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool((*(this->success)));
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o2.read(iprot);
+ this->__isset.o2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_by_name_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->db_name);
+ this->__isset.db_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tbl_name);
+ this->__isset.tbl_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->part_name);
+ this->__isset.part_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->deleteData);
+ this->__isset.deleteData = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_by_name_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_by_name_args");
+
+ xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->db_name);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tbl_name);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->part_name);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool(this->deleteData);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_by_name_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_by_name_pargs");
+
+ xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->db_name)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString((*(this->tbl_name)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString((*(this->part_name)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool((*(this->deleteData)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_by_name_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->success);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o2.read(iprot);
+ this->__isset.o2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_by_name_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_by_name_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0);
+ xfer += oprot->writeBool(this->success);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o1) {
+ xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->o1.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o2) {
+ xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->o2.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_by_name_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool((*(this->success)));
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o2.read(iprot);
+ this->__isset.o2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->db_name);
+ this->__isset.db_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tbl_name);
+ this->__isset.tbl_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->part_name);
+ this->__isset.part_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->deleteData);
+ this->__isset.deleteData = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 5:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->environment_context.read(iprot);
+ this->__isset.environment_context = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args");
+
+ xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->db_name);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tbl_name);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString(this->part_name);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool(this->deleteData);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 5);
+ xfer += this->environment_context.write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_by_name_with_environment_context_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_by_name_with_environment_context_pargs");
+
+ xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->db_name)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString((*(this->tbl_name)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("part_name", ::apache::thrift::protocol::T_STRING, 3);
+ xfer += oprot->writeString((*(this->part_name)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("deleteData", ::apache::thrift::protocol::T_BOOL, 4);
+ xfer += oprot->writeBool((*(this->deleteData)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("environment_context", ::apache::thrift::protocol::T_STRUCT, 5);
+ xfer += (*(this->environment_context)).write(oprot);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool(this->success);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o2.read(iprot);
+ this->__isset.o2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_BOOL, 0);
+ xfer += oprot->writeBool(this->success);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o1) {
+ xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->o1.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o2) {
+ xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->o2.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_BOOL) {
+ xfer += iprot->readBool((*(this->success)));
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o2.read(iprot);
+ this->__isset.o2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_partition_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->db_name);
+ this->__isset.db_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tbl_name);
+ this->__isset.tbl_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->part_vals.clear();
+ uint32_t _size346;
+ ::apache::thrift::protocol::TType _etype349;
+ xfer += iprot->readListBegin(_etype349, _size346);
+ this->part_vals.resize(_size346);
+ uint32_t _i350;
+ for (_i350 = 0; _i350 < _size346; ++_i350)
+ {
+ xfer += iprot->readString(this->part_vals[_i350]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.part_vals = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_partition_args::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_args");
+
+ xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString(this->db_name);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString(this->tbl_name);
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("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 _iter351;
+ for (_iter351 = this->part_vals.begin(); _iter351 != this->part_vals.end(); ++_iter351)
+ {
+ xfer += oprot->writeString((*_iter351));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_partition_pargs::write(::apache::thrift::protocol::TProtocol* oprot) const {
+ uint32_t xfer = 0;
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_pargs");
+
+ xfer += oprot->writeFieldBegin("db_name", ::apache::thrift::protocol::T_STRING, 1);
+ xfer += oprot->writeString((*(this->db_name)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("tbl_name", ::apache::thrift::protocol::T_STRING, 2);
+ xfer += oprot->writeString((*(this->tbl_name)));
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldBegin("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 _iter352;
+ for (_iter352 = (*(this->part_vals)).begin(); _iter352 != (*(this->part_vals)).end(); ++_iter352)
+ {
+ xfer += oprot->writeString((*_iter352));
+ }
+ xfer += oprot->writeListEnd();
+ }
+ xfer += oprot->writeFieldEnd();
+
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_partition_result::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->success.read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o2.read(iprot);
+ this->__isset.o2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_partition_result::write(::apache::thrift::protocol::TProtocol* oprot) const {
+
+ uint32_t xfer = 0;
+
+ xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_result");
+
+ if (this->__isset.success) {
+ xfer += oprot->writeFieldBegin("success", ::apache::thrift::protocol::T_STRUCT, 0);
+ xfer += this->success.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o1) {
+ xfer += oprot->writeFieldBegin("o1", ::apache::thrift::protocol::T_STRUCT, 1);
+ xfer += this->o1.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ } else if (this->__isset.o2) {
+ xfer += oprot->writeFieldBegin("o2", ::apache::thrift::protocol::T_STRUCT, 2);
+ xfer += this->o2.write(oprot);
+ xfer += oprot->writeFieldEnd();
+ }
+ xfer += oprot->writeFieldStop();
+ xfer += oprot->writeStructEnd();
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_partition_presult::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 0:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += (*(this->success)).read(iprot);
+ this->__isset.success = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o1.read(iprot);
+ this->__isset.o1 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRUCT) {
+ xfer += this->o2.read(iprot);
+ this->__isset.o2 = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ default:
+ xfer += iprot->skip(ftype);
+ break;
+ }
+ xfer += iprot->readFieldEnd();
+ }
+
+ xfer += iprot->readStructEnd();
+
+ return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_partition_with_auth_args::read(::apache::thrift::protocol::TProtocol* iprot) {
+
+ uint32_t xfer = 0;
+ std::string fname;
+ ::apache::thrift::protocol::TType ftype;
+ int16_t fid;
+
+ xfer += iprot->readStructBegin(fname);
+
+ using ::apache::thrift::protocol::TProtocolException;
+
+
+ while (true)
+ {
+ xfer += iprot->readFieldBegin(fname, ftype, fid);
+ if (ftype == ::apache::thrift::protocol::T_STOP) {
+ break;
+ }
+ switch (fid)
+ {
+ case 1:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->db_name);
+ this->__isset.db_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 2:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->tbl_name);
+ this->__isset.tbl_name = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 3:
+ if (ftype == ::apache::thrift::protocol::T_LIST) {
+ {
+ this->part_vals.clear();
+ uint32_t _size353;
+ ::apache::thrift::protocol::TType _etype356;
+ xfer += iprot->readListBegin(_etype356, _size353);
+ this->part_vals.resize(_size353);
+ uint32_t _i357;
+ for (_i357 = 0; _i357 < _size353; ++_i357)
+ {
+ xfer += iprot->readString(this->part_vals[_i357]);
+ }
+ xfer += iprot->readListEnd();
+ }
+ this->__isset.part_vals = true;
+ } else {
+ xfer += iprot->skip(ftype);
+ }
+ break;
+ case 4:
+ if (ftype == ::apache::thrift::protocol::T_STRING) {
+ xfer += iprot->readString(this->user_name);
+ this->__isset.user_name = true;
          } else {
            xfer += iprot->skip(ftype);
          }
@@ -7106,14 +8464,14 @@ uint32_t ThriftHiveMetastore_get_partiti
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->group_names.clear();
- uint32_t _size344;
- ::apache::thrift::protocol::TType _etype347;
- xfer += iprot->readListBegin(_etype347, _size344);
- this->group_names.resize(_size344);
- uint32_t _i348;
- for (_i348 = 0; _i348 < _size344; ++_i348)
+ uint32_t _size358;
+ ::apache::thrift::protocol::TType _etype361;
+ xfer += iprot->readListBegin(_etype361, _size358);
+ this->group_names.resize(_size358);
+ uint32_t _i362;
+ for (_i362 = 0; _i362 < _size358; ++_i362)
              {
- xfer += iprot->readString(this->group_names[_i348]);
+ xfer += iprot->readString(this->group_names[_i362]);
              }
              xfer += iprot->readListEnd();
            }
@@ -7149,10 +8507,10 @@ uint32_t ThriftHiveMetastore_get_partiti
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::vector<std::string> ::const_iterator _iter349;
- for (_iter349 = this->part_vals.begin(); _iter349 != this->part_vals.end(); ++_iter349)
+ std::vector<std::string> ::const_iterator _iter363;
+ for (_iter363 = this->part_vals.begin(); _iter363 != this->part_vals.end(); ++_iter363)
      {
- xfer += oprot->writeString((*_iter349));
+ xfer += oprot->writeString((*_iter363));
      }
      xfer += oprot->writeListEnd();
    }
@@ -7165,10 +8523,10 @@ uint32_t ThriftHiveMetastore_get_partiti
    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 _iter350;
- for (_iter350 = this->group_names.begin(); _iter350 != this->group_names.end(); ++_iter350)
+ std::vector<std::string> ::const_iterator _iter364;
+ for (_iter364 = this->group_names.begin(); _iter364 != this->group_names.end(); ++_iter364)
      {
- xfer += oprot->writeString((*_iter350));
+ xfer += oprot->writeString((*_iter364));
      }
      xfer += oprot->writeListEnd();
    }
@@ -7194,10 +8552,10 @@ uint32_t ThriftHiveMetastore_get_partiti
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter351;
- for (_iter351 = (*(this->part_vals)).begin(); _iter351 != (*(this->part_vals)).end(); ++_iter351)
+ std::vector<std::string> ::const_iterator _iter365;
+ for (_iter365 = (*(this->part_vals)).begin(); _iter365 != (*(this->part_vals)).end(); ++_iter365)
      {
- xfer += oprot->writeString((*_iter351));
+ xfer += oprot->writeString((*_iter365));
      }
      xfer += oprot->writeListEnd();
    }
@@ -7210,10 +8568,10 @@ uint32_t ThriftHiveMetastore_get_partiti
    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 _iter352;
- for (_iter352 = (*(this->group_names)).begin(); _iter352 != (*(this->group_names)).end(); ++_iter352)
+ std::vector<std::string> ::const_iterator _iter366;
+ for (_iter366 = (*(this->group_names)).begin(); _iter366 != (*(this->group_names)).end(); ++_iter366)
      {
- xfer += oprot->writeString((*_iter352));
+ xfer += oprot->writeString((*_iter366));
      }
      xfer += oprot->writeListEnd();
    }
@@ -7716,14 +9074,14 @@ uint32_t ThriftHiveMetastore_get_partiti
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size353;
- ::apache::thrift::protocol::TType _etype356;
- xfer += iprot->readListBegin(_etype356, _size353);
- this->success.resize(_size353);
- uint32_t _i357;
- for (_i357 = 0; _i357 < _size353; ++_i357)
+ uint32_t _size367;
+ ::apache::thrift::protocol::TType _etype370;
+ xfer += iprot->readListBegin(_etype370, _size367);
+ this->success.resize(_size367);
+ uint32_t _i371;
+ for (_i371 = 0; _i371 < _size367; ++_i371)
              {
- xfer += this->success[_i357].read(iprot);
+ xfer += this->success[_i371].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -7770,10 +9128,10 @@ uint32_t ThriftHiveMetastore_get_partiti
      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 _iter358;
- for (_iter358 = this->success.begin(); _iter358 != this->success.end(); ++_iter358)
+ std::vector<Partition> ::const_iterator _iter372;
+ for (_iter372 = this->success.begin(); _iter372 != this->success.end(); ++_iter372)
        {
- xfer += (*_iter358).write(oprot);
+ xfer += (*_iter372).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -7816,14 +9174,14 @@ uint32_t ThriftHiveMetastore_get_partiti
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size359;
- ::apache::thrift::protocol::TType _etype362;
- xfer += iprot->readListBegin(_etype362, _size359);
- (*(this->success)).resize(_size359);
- uint32_t _i363;
- for (_i363 = 0; _i363 < _size359; ++_i363)
+ uint32_t _size373;
+ ::apache::thrift::protocol::TType _etype376;
+ xfer += iprot->readListBegin(_etype376, _size373);
+ (*(this->success)).resize(_size373);
+ uint32_t _i377;
+ for (_i377 = 0; _i377 < _size373; ++_i377)
              {
- xfer += (*(this->success))[_i363].read(iprot);
+ xfer += (*(this->success))[_i377].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -7916,14 +9274,14 @@ uint32_t ThriftHiveMetastore_get_partiti
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->group_names.clear();
- uint32_t _size364;
- ::apache::thrift::protocol::TType _etype367;
- xfer += iprot->readListBegin(_etype367, _size364);
- this->group_names.resize(_size364);
- uint32_t _i368;
- for (_i368 = 0; _i368 < _size364; ++_i368)
+ uint32_t _size378;
+ ::apache::thrift::protocol::TType _etype381;
+ xfer += iprot->readListBegin(_etype381, _size378);
+ this->group_names.resize(_size378);
+ uint32_t _i382;
+ for (_i382 = 0; _i382 < _size378; ++_i382)
              {
- xfer += iprot->readString(this->group_names[_i368]);
+ xfer += iprot->readString(this->group_names[_i382]);
              }
              xfer += iprot->readListEnd();
            }
@@ -7967,10 +9325,10 @@ uint32_t ThriftHiveMetastore_get_partiti
    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 _iter369;
- for (_iter369 = this->group_names.begin(); _iter369 != this->group_names.end(); ++_iter369)
+ std::vector<std::string> ::const_iterator _iter383;
+ for (_iter383 = this->group_names.begin(); _iter383 != this->group_names.end(); ++_iter383)
      {
- xfer += oprot->writeString((*_iter369));
+ xfer += oprot->writeString((*_iter383));
      }
      xfer += oprot->writeListEnd();
    }
@@ -8004,10 +9362,10 @@ uint32_t ThriftHiveMetastore_get_partiti
    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 _iter370;
- for (_iter370 = (*(this->group_names)).begin(); _iter370 != (*(this->group_names)).end(); ++_iter370)
+ std::vector<std::string> ::const_iterator _iter384;
+ for (_iter384 = (*(this->group_names)).begin(); _iter384 != (*(this->group_names)).end(); ++_iter384)
      {
- xfer += oprot->writeString((*_iter370));
+ xfer += oprot->writeString((*_iter384));
      }
      xfer += oprot->writeListEnd();
    }
@@ -8042,14 +9400,14 @@ uint32_t ThriftHiveMetastore_get_partiti
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size371;
- ::apache::thrift::protocol::TType _etype374;
- xfer += iprot->readListBegin(_etype374, _size371);
- this->success.resize(_size371);
- uint32_t _i375;
- for (_i375 = 0; _i375 < _size371; ++_i375)
+ uint32_t _size385;
+ ::apache::thrift::protocol::TType _etype388;
+ xfer += iprot->readListBegin(_etype388, _size385);
+ this->success.resize(_size385);
+ uint32_t _i389;
+ for (_i389 = 0; _i389 < _size385; ++_i389)
              {
- xfer += this->success[_i375].read(iprot);
+ xfer += this->success[_i389].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -8096,10 +9454,10 @@ uint32_t ThriftHiveMetastore_get_partiti
      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 _iter376;
- for (_iter376 = this->success.begin(); _iter376 != this->success.end(); ++_iter376)
+ std::vector<Partition> ::const_iterator _iter390;
+ for (_iter390 = this->success.begin(); _iter390 != this->success.end(); ++_iter390)
        {
- xfer += (*_iter376).write(oprot);
+ xfer += (*_iter390).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -8142,14 +9500,14 @@ uint32_t ThriftHiveMetastore_get_partiti
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size377;
- ::apache::thrift::protocol::TType _etype380;
- xfer += iprot->readListBegin(_etype380, _size377);
- (*(this->success)).resize(_size377);
- uint32_t _i381;
- for (_i381 = 0; _i381 < _size377; ++_i381)
+ uint32_t _size391;
+ ::apache::thrift::protocol::TType _etype394;
+ xfer += iprot->readListBegin(_etype394, _size391);
+ (*(this->success)).resize(_size391);
+ uint32_t _i395;
+ for (_i395 = 0; _i395 < _size391; ++_i395)
              {
- xfer += (*(this->success))[_i381].read(iprot);
+ xfer += (*(this->success))[_i395].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -8308,14 +9666,14 @@ uint32_t ThriftHiveMetastore_get_partiti
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size382;
- ::apache::thrift::protocol::TType _etype385;
- xfer += iprot->readListBegin(_etype385, _size382);
- this->success.resize(_size382);
- uint32_t _i386;
- for (_i386 = 0; _i386 < _size382; ++_i386)
+ uint32_t _size396;
+ ::apache::thrift::protocol::TType _etype399;
+ xfer += iprot->readListBegin(_etype399, _size396);
+ this->success.resize(_size396);
+ uint32_t _i400;
+ for (_i400 = 0; _i400 < _size396; ++_i400)
              {
- xfer += iprot->readString(this->success[_i386]);
+ xfer += iprot->readString(this->success[_i400]);
              }
              xfer += iprot->readListEnd();
            }
@@ -8354,10 +9712,10 @@ uint32_t ThriftHiveMetastore_get_partiti
      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 _iter387;
- for (_iter387 = this->success.begin(); _iter387 != this->success.end(); ++_iter387)
+ std::vector<std::string> ::const_iterator _iter401;
+ for (_iter401 = this->success.begin(); _iter401 != this->success.end(); ++_iter401)
        {
- xfer += oprot->writeString((*_iter387));
+ xfer += oprot->writeString((*_iter401));
        }
        xfer += oprot->writeListEnd();
      }
@@ -8396,14 +9754,14 @@ uint32_t ThriftHiveMetastore_get_partiti
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size388;
- ::apache::thrift::protocol::TType _etype391;
- xfer += iprot->readListBegin(_etype391, _size388);
- (*(this->success)).resize(_size388);
- uint32_t _i392;
- for (_i392 = 0; _i392 < _size388; ++_i392)
+ uint32_t _size402;
+ ::apache::thrift::protocol::TType _etype405;
+ xfer += iprot->readListBegin(_etype405, _size402);
+ (*(this->success)).resize(_size402);
+ uint32_t _i406;
+ for (_i406 = 0; _i406 < _size402; ++_i406)
              {
- xfer += iprot->readString((*(this->success))[_i392]);
+ xfer += iprot->readString((*(this->success))[_i406]);
              }
              xfer += iprot->readListEnd();
            }
@@ -8472,14 +9830,14 @@ uint32_t ThriftHiveMetastore_get_partiti
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size393;
- ::apache::thrift::protocol::TType _etype396;
- xfer += iprot->readListBegin(_etype396, _size393);
- this->part_vals.resize(_size393);
- uint32_t _i397;
- for (_i397 = 0; _i397 < _size393; ++_i397)
+ uint32_t _size407;
+ ::apache::thrift::protocol::TType _etype410;
+ xfer += iprot->readListBegin(_etype410, _size407);
+ this->part_vals.resize(_size407);
+ uint32_t _i411;
+ for (_i411 = 0; _i411 < _size407; ++_i411)
              {
- xfer += iprot->readString(this->part_vals[_i397]);
+ xfer += iprot->readString(this->part_vals[_i411]);
              }
              xfer += iprot->readListEnd();
            }
@@ -8523,10 +9881,10 @@ uint32_t ThriftHiveMetastore_get_partiti
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>(this->part_vals.size()));
- std::vector<std::string> ::const_iterator _iter398;
- for (_iter398 = this->part_vals.begin(); _iter398 != this->part_vals.end(); ++_iter398)
+ std::vector<std::string> ::const_iterator _iter412;
+ for (_iter412 = this->part_vals.begin(); _iter412 != this->part_vals.end(); ++_iter412)
      {
- xfer += oprot->writeString((*_iter398));
+ xfer += oprot->writeString((*_iter412));
      }
      xfer += oprot->writeListEnd();
    }
@@ -8556,10 +9914,10 @@ uint32_t ThriftHiveMetastore_get_partiti
    xfer += oprot->writeFieldBegin("part_vals", ::apache::thrift::protocol::T_LIST, 3);
    {
      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRING, static_cast<uint32_t>((*(this->part_vals)).size()));
- std::vector<std::string> ::const_iterator _iter399;
- for (_iter399 = (*(this->part_vals)).begin(); _iter399 != (*(this->part_vals)).end(); ++_iter399)
+ std::vector<std::string> ::const_iterator _iter413;
+ for (_iter413 = (*(this->part_vals)).begin(); _iter413 != (*(this->part_vals)).end(); ++_iter413)
      {
- xfer += oprot->writeString((*_iter399));
+ xfer += oprot->writeString((*_iter413));
      }
      xfer += oprot->writeListEnd();
    }
@@ -8598,14 +9956,14 @@ uint32_t ThriftHiveMetastore_get_partiti
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->success.clear();
- uint32_t _size400;
- ::apache::thrift::protocol::TType _etype403;
- xfer += iprot->readListBegin(_etype403, _size400);
- this->success.resize(_size400);
- uint32_t _i404;
- for (_i404 = 0; _i404 < _size400; ++_i404)
+ uint32_t _size414;
+ ::apache::thrift::protocol::TType _etype417;
+ xfer += iprot->readListBegin(_etype417, _size414);
+ this->success.resize(_size414);
+ uint32_t _i418;
+ for (_i418 = 0; _i418 < _size414; ++_i418)
              {
- xfer += this->success[_i404].read(iprot);
+ xfer += this->success[_i418].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -8652,10 +10010,10 @@ uint32_t ThriftHiveMetastore_get_partiti
      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 _iter405;
- for (_iter405 = this->success.begin(); _iter405 != this->success.end(); ++_iter405)
+ std::vector<Partition> ::const_iterator _iter419;
+ for (_iter419 = this->success.begin(); _iter419 != this->success.end(); ++_iter419)
        {
- xfer += (*_iter405).write(oprot);
+ xfer += (*_iter419).write(oprot);
        }
        xfer += oprot->writeListEnd();
      }
@@ -8698,14 +10056,14 @@ uint32_t ThriftHiveMetastore_get_partiti
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              (*(this->success)).clear();
- uint32_t _size406;
- ::apache::thrift::protocol::TType _etype409;
- xfer += iprot->readListBegin(_etype409, _size406);
- (*(this->success)).resize(_size406);
- uint32_t _i410;
- for (_i410 = 0; _i410 < _size406; ++_i410)
+ uint32_t _size420;
+ ::apache::thrift::protocol::TType _etype423;
+ xfer += iprot->readListBegin(_etype423, _size420);
+ (*(this->success)).resize(_size420);
+ uint32_t _i424;
+ for (_i424 = 0; _i424 < _size420; ++_i424)
              {
- xfer += (*(this->success))[_i410].read(iprot);
+ xfer += (*(this->success))[_i424].read(iprot);
              }
              xfer += iprot->readListEnd();
            }
@@ -8782,14 +10140,14 @@ uint32_t ThriftHiveMetastore_get_partiti
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->part_vals.clear();
- uint32_t _size411;
- ::apache::thrift::protocol::TType _etype414;
- xfer += iprot->readListBegin(_etype414, _size411);
- this->part_vals.resize(_size411);
- uint32_t _i415;
- for (_i415 = 0; _i415 < _size411; ++_i415)
+ uint32_t _size425;
+ ::apache::thrift::protocol::TType _etype428;
+ xfer += iprot->readListBegin(_etype428, _size425);
+ this->part_vals.resize(_size425);
+ uint32_t _i429;
+ for (_i429 = 0; _i429 < _size425; ++_i429)
              {
- xfer += iprot->readString(this->part_vals[_i415]);
+ xfer += iprot->readString(this->part_vals[_i429]);
              }
              xfer += iprot->readListEnd();
            }
@@ -8818,14 +10176,14 @@ uint32_t ThriftHiveMetastore_get_partiti
          if (ftype == ::apache::thrift::protocol::T_LIST) {
            {
              this->group_names.clear();
- uint32_t _size416;

[... 2115 lines stripped ...]

Search Discussions

Discussion Posts

Previous

Follow ups

Related Discussions

Discussion Navigation
viewthread | post
posts ‹ prev | 5 of 8 | next ›
Discussion Overview
groupcommits @
categorieshive, hadoop
postedFeb 12, '13 at 6:53p
activeFeb 12, '13 at 6:53p
posts8
users1
websitehive.apache.org

1 user in discussion

Kevinwilfong: 8 posts

People

Translate

site design / logo © 2021 Grokbase