hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From gunt...@apache.org
Subject svn commit: r1561947 [4/17] - in /hive/branches/tez: ./ ant/ ant/src/org/apache/hadoop/hive/ant/ beeline/ cli/ cli/src/java/org/apache/hadoop/hive/cli/ common/ common/src/ common/src/java/org/apache/hadoop/hive/common/type/ common/src/java/org/apache/h...
Date Tue, 28 Jan 2014 05:48:10 GMT
Modified: hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h?rev=1561947&r1=1561946&r2=1561947&view=diff
==============================================================================
--- hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h (original)
+++ hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h Tue Jan 28 05:48:03
2014
@@ -43,6 +43,7 @@ class ThriftHiveMetastoreIf : virtual pu
   virtual void add_partition_with_environment_context(Partition& _return, const Partition&
new_part, const EnvironmentContext& environment_context) = 0;
   virtual int32_t add_partitions(const std::vector<Partition> & new_parts) = 0;
   virtual void append_partition(Partition& _return, const std::string& db_name, const
std::string& tbl_name, const std::vector<std::string> & part_vals) = 0;
+  virtual void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest&
request) = 0;
   virtual void append_partition_with_environment_context(Partition& _return, const std::string&
db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals,
const EnvironmentContext& environment_context) = 0;
   virtual void append_partition_by_name(Partition& _return, const std::string& db_name,
const std::string& tbl_name, const std::string& part_name) = 0;
   virtual void append_partition_by_name_with_environment_context(Partition& _return,
const std::string& db_name, const std::string& tbl_name, const std::string& part_name,
const EnvironmentContext& environment_context) = 0;
@@ -212,6 +213,9 @@ class ThriftHiveMetastoreNull : virtual 
   void append_partition(Partition& /* _return */, const std::string& /* db_name */,
const std::string& /* tbl_name */, const std::vector<std::string> & /* part_vals
*/) {
     return;
   }
+  void add_partitions_req(AddPartitionsResult& /* _return */, const AddPartitionsRequest&
/* request */) {
+    return;
+  }
   void append_partition_with_environment_context(Partition& /* _return */, const std::string&
/* db_name */, const std::string& /* tbl_name */, const std::vector<std::string>
& /* part_vals */, const EnvironmentContext& /* environment_context */) {
     return;
   }
@@ -4068,6 +4072,144 @@ class ThriftHiveMetastore_append_partiti
 
 };
 
+typedef struct _ThriftHiveMetastore_add_partitions_req_args__isset {
+  _ThriftHiveMetastore_add_partitions_req_args__isset() : request(false) {}
+  bool request;
+} _ThriftHiveMetastore_add_partitions_req_args__isset;
+
+class ThriftHiveMetastore_add_partitions_req_args {
+ public:
+
+  ThriftHiveMetastore_add_partitions_req_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_add_partitions_req_args() throw() {}
+
+  AddPartitionsRequest request;
+
+  _ThriftHiveMetastore_add_partitions_req_args__isset __isset;
+
+  void __set_request(const AddPartitionsRequest& val) {
+    request = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_add_partitions_req_args & rhs) const
+  {
+    if (!(request == rhs.request))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_add_partitions_req_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_add_partitions_req_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_add_partitions_req_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_add_partitions_req_pargs() throw() {}
+
+  const AddPartitionsRequest* request;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_add_partitions_req_result__isset {
+  _ThriftHiveMetastore_add_partitions_req_result__isset() : success(false), o1(false), o2(false),
o3(false) {}
+  bool success;
+  bool o1;
+  bool o2;
+  bool o3;
+} _ThriftHiveMetastore_add_partitions_req_result__isset;
+
+class ThriftHiveMetastore_add_partitions_req_result {
+ public:
+
+  ThriftHiveMetastore_add_partitions_req_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_add_partitions_req_result() throw() {}
+
+  AddPartitionsResult success;
+  InvalidObjectException o1;
+  AlreadyExistsException o2;
+  MetaException o3;
+
+  _ThriftHiveMetastore_add_partitions_req_result__isset __isset;
+
+  void __set_success(const AddPartitionsResult& val) {
+    success = val;
+  }
+
+  void __set_o1(const InvalidObjectException& val) {
+    o1 = val;
+  }
+
+  void __set_o2(const AlreadyExistsException& val) {
+    o2 = val;
+  }
+
+  void __set_o3(const MetaException& val) {
+    o3 = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_add_partitions_req_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(o1 == rhs.o1))
+      return false;
+    if (!(o2 == rhs.o2))
+      return false;
+    if (!(o3 == rhs.o3))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_add_partitions_req_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_add_partitions_req_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_add_partitions_req_presult__isset {
+  _ThriftHiveMetastore_add_partitions_req_presult__isset() : success(false), o1(false), o2(false),
o3(false) {}
+  bool success;
+  bool o1;
+  bool o2;
+  bool o3;
+} _ThriftHiveMetastore_add_partitions_req_presult__isset;
+
+class ThriftHiveMetastore_add_partitions_req_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_add_partitions_req_presult() throw() {}
+
+  AddPartitionsResult* success;
+  InvalidObjectException o1;
+  AlreadyExistsException o2;
+  MetaException o3;
+
+  _ThriftHiveMetastore_add_partitions_req_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
 typedef struct _ThriftHiveMetastore_append_partition_with_environment_context_args__isset
{
   _ThriftHiveMetastore_append_partition_with_environment_context_args__isset() : db_name(false),
tbl_name(false), part_vals(false), environment_context(false) {}
   bool db_name;
@@ -12322,6 +12464,9 @@ class ThriftHiveMetastoreClient : virtua
   void append_partition(Partition& _return, const std::string& db_name, const std::string&
tbl_name, const std::vector<std::string> & part_vals);
   void send_append_partition(const std::string& db_name, const std::string& tbl_name,
const std::vector<std::string> & part_vals);
   void recv_append_partition(Partition& _return);
+  void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest&
request);
+  void send_add_partitions_req(const AddPartitionsRequest& request);
+  void recv_add_partitions_req(AddPartitionsResult& _return);
   void append_partition_with_environment_context(Partition& _return, const std::string&
db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals,
const EnvironmentContext& environment_context);
   void send_append_partition_with_environment_context(const std::string& db_name, const
std::string& tbl_name, const std::vector<std::string> & part_vals, const EnvironmentContext&
environment_context);
   void recv_append_partition_with_environment_context(Partition& _return);
@@ -12527,6 +12672,7 @@ class ThriftHiveMetastoreProcessor : pub
   void process_add_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol*
iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_add_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot,
::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_append_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot,
::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_add_partitions_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot,
::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_append_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol*
iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_append_partition_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol*
iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_append_partition_by_name_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol*
iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
@@ -12614,6 +12760,7 @@ class ThriftHiveMetastoreProcessor : pub
     processMap_["add_partition_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_add_partition_with_environment_context;
     processMap_["add_partitions"] = &ThriftHiveMetastoreProcessor::process_add_partitions;
     processMap_["append_partition"] = &ThriftHiveMetastoreProcessor::process_append_partition;
+    processMap_["add_partitions_req"] = &ThriftHiveMetastoreProcessor::process_add_partitions_req;
     processMap_["append_partition_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_append_partition_with_environment_context;
     processMap_["append_partition_by_name"] = &ThriftHiveMetastoreProcessor::process_append_partition_by_name;
     processMap_["append_partition_by_name_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_append_partition_by_name_with_environment_context;
@@ -12961,6 +13108,16 @@ class ThriftHiveMetastoreMultiface : vir
     return;
   }
 
+  void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest&
request) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->add_partitions_req(_return, request);
+    }
+    ifaces_[i]->add_partitions_req(_return, request);
+    return;
+  }
+
   void append_partition_with_environment_context(Partition& _return, const std::string&
db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals,
const EnvironmentContext& environment_context) {
     size_t sz = ifaces_.size();
     size_t i = 0;

Modified: hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp?rev=1561947&r1=1561946&r2=1561947&view=diff
==============================================================================
--- hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
(original)
+++ hive/branches/tez/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
Tue Jan 28 05:48:03 2014
@@ -157,6 +157,11 @@ class ThriftHiveMetastoreHandler : virtu
     printf("append_partition\n");
   }
 
+  void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest&
request) {
+    // Your implementation goes here
+    printf("add_partitions_req\n");
+  }
+
   void append_partition_with_environment_context(Partition& _return, const std::string&
db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals,
const EnvironmentContext& environment_context) {
     // Your implementation goes here
     printf("append_partition_with_environment_context\n");

Modified: hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp
URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp?rev=1561947&r1=1561946&r2=1561947&view=diff
==============================================================================
--- hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp (original)
+++ hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.cpp Tue Jan 28
05:48:03 2014
@@ -3719,8 +3719,8 @@ void swap(EnvironmentContext &a, Environ
   swap(a.__isset, b.__isset);
 }
 
-const char* PartitionsByExprResult::ascii_fingerprint = "1B91CF0D2FC339DC29ABBD79CC9700E4";
-const uint8_t PartitionsByExprResult::binary_fingerprint[16] = {0x1B,0x91,0xCF,0x0D,0x2F,0xC3,0x39,0xDC,0x29,0xAB,0xBD,0x79,0xCC,0x97,0x00,0xE4};
+const char* PartitionsByExprResult::ascii_fingerprint = "40B789CC91B508FE36600A14E3F80425";
+const uint8_t PartitionsByExprResult::binary_fingerprint[16] = {0x40,0xB7,0x89,0xCC,0x91,0xB5,0x08,0xFE,0x36,0x60,0x0A,0x14,0xE3,0xF8,0x04,0x25};
 
 uint32_t PartitionsByExprResult::read(::apache::thrift::protocol::TProtocol* iprot) {
 
@@ -3745,20 +3745,19 @@ uint32_t PartitionsByExprResult::read(::
     switch (fid)
     {
       case 1:
-        if (ftype == ::apache::thrift::protocol::T_SET) {
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
           {
             this->partitions.clear();
             uint32_t _size201;
             ::apache::thrift::protocol::TType _etype204;
-            xfer += iprot->readSetBegin(_etype204, _size201);
+            xfer += iprot->readListBegin(_etype204, _size201);
+            this->partitions.resize(_size201);
             uint32_t _i205;
             for (_i205 = 0; _i205 < _size201; ++_i205)
             {
-              Partition _elem206;
-              xfer += _elem206.read(iprot);
-              this->partitions.insert(_elem206);
+              xfer += this->partitions[_i205].read(iprot);
             }
-            xfer += iprot->readSetEnd();
+            xfer += iprot->readListEnd();
           }
           isset_partitions = true;
         } else {
@@ -3793,15 +3792,15 @@ uint32_t PartitionsByExprResult::write(:
   uint32_t xfer = 0;
   xfer += oprot->writeStructBegin("PartitionsByExprResult");
 
-  xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_SET, 1);
+  xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1);
   {
-    xfer += oprot->writeSetBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
-    std::set<Partition> ::const_iterator _iter207;
-    for (_iter207 = this->partitions.begin(); _iter207 != this->partitions.end(); ++_iter207)
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
+    std::vector<Partition> ::const_iterator _iter206;
+    for (_iter206 = this->partitions.begin(); _iter206 != this->partitions.end(); ++_iter206)
     {
-      xfer += (*_iter207).write(oprot);
+      xfer += (*_iter206).write(oprot);
     }
-    xfer += oprot->writeSetEnd();
+    xfer += oprot->writeListEnd();
   }
   xfer += oprot->writeFieldEnd();
 
@@ -3945,6 +3944,236 @@ void swap(PartitionsByExprRequest &a, Pa
   swap(a.__isset, b.__isset);
 }
 
+const char* AddPartitionsResult::ascii_fingerprint = "5A689D0823E7BFBB60C799BA60065C31";
+const uint8_t AddPartitionsResult::binary_fingerprint[16] = {0x5A,0x68,0x9D,0x08,0x23,0xE7,0xBF,0xBB,0x60,0xC7,0x99,0xBA,0x60,0x06,0x5C,0x31};
+
+uint32_t AddPartitionsResult::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_LIST) {
+          {
+            this->partitions.clear();
+            uint32_t _size207;
+            ::apache::thrift::protocol::TType _etype210;
+            xfer += iprot->readListBegin(_etype210, _size207);
+            this->partitions.resize(_size207);
+            uint32_t _i211;
+            for (_i211 = 0; _i211 < _size207; ++_i211)
+            {
+              xfer += this->partitions[_i211].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          this->__isset.partitions = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t AddPartitionsResult::write(::apache::thrift::protocol::TProtocol* oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("AddPartitionsResult");
+
+  if (this->__isset.partitions) {
+    xfer += oprot->writeFieldBegin("partitions", ::apache::thrift::protocol::T_LIST, 1);
+    {
+      xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->partitions.size()));
+      std::vector<Partition> ::const_iterator _iter212;
+      for (_iter212 = this->partitions.begin(); _iter212 != this->partitions.end();
++_iter212)
+      {
+        xfer += (*_iter212).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(AddPartitionsResult &a, AddPartitionsResult &b) {
+  using ::std::swap;
+  swap(a.partitions, b.partitions);
+  swap(a.__isset, b.__isset);
+}
+
+const char* AddPartitionsRequest::ascii_fingerprint = "94F938D035892CF6873DEDB99358F069";
+const uint8_t AddPartitionsRequest::binary_fingerprint[16] = {0x94,0xF9,0x38,0xD0,0x35,0x89,0x2C,0xF6,0x87,0x3D,0xED,0xB9,0x93,0x58,0xF0,0x69};
+
+uint32_t AddPartitionsRequest::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;
+
+  bool isset_dbName = false;
+  bool isset_tblName = false;
+  bool isset_parts = false;
+  bool isset_ifNotExists = false;
+
+  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);
+          isset_dbName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 2:
+        if (ftype == ::apache::thrift::protocol::T_STRING) {
+          xfer += iprot->readString(this->tblName);
+          isset_tblName = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 3:
+        if (ftype == ::apache::thrift::protocol::T_LIST) {
+          {
+            this->parts.clear();
+            uint32_t _size213;
+            ::apache::thrift::protocol::TType _etype216;
+            xfer += iprot->readListBegin(_etype216, _size213);
+            this->parts.resize(_size213);
+            uint32_t _i217;
+            for (_i217 = 0; _i217 < _size213; ++_i217)
+            {
+              xfer += this->parts[_i217].read(iprot);
+            }
+            xfer += iprot->readListEnd();
+          }
+          isset_parts = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->ifNotExists);
+          isset_ifNotExists = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 5:
+        if (ftype == ::apache::thrift::protocol::T_BOOL) {
+          xfer += iprot->readBool(this->needResult);
+          this->__isset.needResult = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  if (!isset_dbName)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_tblName)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_parts)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  if (!isset_ifNotExists)
+    throw TProtocolException(TProtocolException::INVALID_DATA);
+  return xfer;
+}
+
+uint32_t AddPartitionsRequest::write(::apache::thrift::protocol::TProtocol* oprot) const
{
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("AddPartitionsRequest");
+
+  xfer += oprot->writeFieldBegin("dbName", ::apache::thrift::protocol::T_STRING, 1);
+  xfer += oprot->writeString(this->dbName);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("tblName", ::apache::thrift::protocol::T_STRING, 2);
+  xfer += oprot->writeString(this->tblName);
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("parts", ::apache::thrift::protocol::T_LIST, 3);
+  {
+    xfer += oprot->writeListBegin(::apache::thrift::protocol::T_STRUCT, static_cast<uint32_t>(this->parts.size()));
+    std::vector<Partition> ::const_iterator _iter218;
+    for (_iter218 = this->parts.begin(); _iter218 != this->parts.end(); ++_iter218)
+    {
+      xfer += (*_iter218).write(oprot);
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+
+  xfer += oprot->writeFieldBegin("ifNotExists", ::apache::thrift::protocol::T_BOOL, 4);
+  xfer += oprot->writeBool(this->ifNotExists);
+  xfer += oprot->writeFieldEnd();
+
+  if (this->__isset.needResult) {
+    xfer += oprot->writeFieldBegin("needResult", ::apache::thrift::protocol::T_BOOL, 5);
+    xfer += oprot->writeBool(this->needResult);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+void swap(AddPartitionsRequest &a, AddPartitionsRequest &b) {
+  using ::std::swap;
+  swap(a.dbName, b.dbName);
+  swap(a.tblName, b.tblName);
+  swap(a.parts, b.parts);
+  swap(a.ifNotExists, b.ifNotExists);
+  swap(a.needResult, b.needResult);
+  swap(a.__isset, b.__isset);
+}
+
 const char* MetaException::ascii_fingerprint = "EFB929595D312AC8F305D5A794CFEDA1";
 const uint8_t MetaException::binary_fingerprint[16] = {0xEF,0xB9,0x29,0x59,0x5D,0x31,0x2A,0xC8,0xF3,0x05,0xD5,0xA7,0x94,0xCF,0xED,0xA1};
 

Modified: hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h
URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h?rev=1561947&r1=1561946&r2=1561947&view=diff
==============================================================================
--- hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h (original)
+++ hive/branches/tez/metastore/src/gen/thrift/gen-cpp/hive_metastore_types.h Tue Jan 28 05:48:03
2014
@@ -1976,18 +1976,18 @@ void swap(EnvironmentContext &a, Environ
 class PartitionsByExprResult {
  public:
 
-  static const char* ascii_fingerprint; // = "1B91CF0D2FC339DC29ABBD79CC9700E4";
-  static const uint8_t binary_fingerprint[16]; // = {0x1B,0x91,0xCF,0x0D,0x2F,0xC3,0x39,0xDC,0x29,0xAB,0xBD,0x79,0xCC,0x97,0x00,0xE4};
+  static const char* ascii_fingerprint; // = "40B789CC91B508FE36600A14E3F80425";
+  static const uint8_t binary_fingerprint[16]; // = {0x40,0xB7,0x89,0xCC,0x91,0xB5,0x08,0xFE,0x36,0x60,0x0A,0x14,0xE3,0xF8,0x04,0x25};
 
   PartitionsByExprResult() : hasUnknownPartitions(0) {
   }
 
   virtual ~PartitionsByExprResult() throw() {}
 
-  std::set<Partition>  partitions;
+  std::vector<Partition>  partitions;
   bool hasUnknownPartitions;
 
-  void __set_partitions(const std::set<Partition> & val) {
+  void __set_partitions(const std::vector<Partition> & val) {
     partitions = val;
   }
 
@@ -2094,6 +2094,126 @@ class PartitionsByExprRequest {
 
 void swap(PartitionsByExprRequest &a, PartitionsByExprRequest &b);
 
+typedef struct _AddPartitionsResult__isset {
+  _AddPartitionsResult__isset() : partitions(false) {}
+  bool partitions;
+} _AddPartitionsResult__isset;
+
+class AddPartitionsResult {
+ public:
+
+  static const char* ascii_fingerprint; // = "5A689D0823E7BFBB60C799BA60065C31";
+  static const uint8_t binary_fingerprint[16]; // = {0x5A,0x68,0x9D,0x08,0x23,0xE7,0xBF,0xBB,0x60,0xC7,0x99,0xBA,0x60,0x06,0x5C,0x31};
+
+  AddPartitionsResult() {
+  }
+
+  virtual ~AddPartitionsResult() throw() {}
+
+  std::vector<Partition>  partitions;
+
+  _AddPartitionsResult__isset __isset;
+
+  void __set_partitions(const std::vector<Partition> & val) {
+    partitions = val;
+    __isset.partitions = true;
+  }
+
+  bool operator == (const AddPartitionsResult & rhs) const
+  {
+    if (__isset.partitions != rhs.__isset.partitions)
+      return false;
+    else if (__isset.partitions && !(partitions == rhs.partitions))
+      return false;
+    return true;
+  }
+  bool operator != (const AddPartitionsResult &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const AddPartitionsResult & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(AddPartitionsResult &a, AddPartitionsResult &b);
+
+typedef struct _AddPartitionsRequest__isset {
+  _AddPartitionsRequest__isset() : needResult(true) {}
+  bool needResult;
+} _AddPartitionsRequest__isset;
+
+class AddPartitionsRequest {
+ public:
+
+  static const char* ascii_fingerprint; // = "94F938D035892CF6873DEDB99358F069";
+  static const uint8_t binary_fingerprint[16]; // = {0x94,0xF9,0x38,0xD0,0x35,0x89,0x2C,0xF6,0x87,0x3D,0xED,0xB9,0x93,0x58,0xF0,0x69};
+
+  AddPartitionsRequest() : dbName(), tblName(), ifNotExists(0), needResult(true) {
+  }
+
+  virtual ~AddPartitionsRequest() throw() {}
+
+  std::string dbName;
+  std::string tblName;
+  std::vector<Partition>  parts;
+  bool ifNotExists;
+  bool needResult;
+
+  _AddPartitionsRequest__isset __isset;
+
+  void __set_dbName(const std::string& val) {
+    dbName = val;
+  }
+
+  void __set_tblName(const std::string& val) {
+    tblName = val;
+  }
+
+  void __set_parts(const std::vector<Partition> & val) {
+    parts = val;
+  }
+
+  void __set_ifNotExists(const bool val) {
+    ifNotExists = val;
+  }
+
+  void __set_needResult(const bool val) {
+    needResult = val;
+    __isset.needResult = true;
+  }
+
+  bool operator == (const AddPartitionsRequest & rhs) const
+  {
+    if (!(dbName == rhs.dbName))
+      return false;
+    if (!(tblName == rhs.tblName))
+      return false;
+    if (!(parts == rhs.parts))
+      return false;
+    if (!(ifNotExists == rhs.ifNotExists))
+      return false;
+    if (__isset.needResult != rhs.__isset.needResult)
+      return false;
+    else if (__isset.needResult && !(needResult == rhs.needResult))
+      return false;
+    return true;
+  }
+  bool operator != (const AddPartitionsRequest &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const AddPartitionsRequest & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+void swap(AddPartitionsRequest &a, AddPartitionsRequest &b);
+
 typedef struct _MetaException__isset {
   _MetaException__isset() : message(false) {}
   bool message;

Modified: hive/branches/tez/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionsByExprResult.java
URL: http://svn.apache.org/viewvc/hive/branches/tez/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionsByExprResult.java?rev=1561947&r1=1561946&r2=1561947&view=diff
==============================================================================
--- hive/branches/tez/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionsByExprResult.java
(original)
+++ hive/branches/tez/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/PartitionsByExprResult.java
Tue Jan 28 05:48:03 2014
@@ -34,7 +34,7 @@ import org.slf4j.LoggerFactory;
 public class PartitionsByExprResult implements org.apache.thrift.TBase<PartitionsByExprResult,
PartitionsByExprResult._Fields>, java.io.Serializable, Cloneable {
   private static final org.apache.thrift.protocol.TStruct STRUCT_DESC = new org.apache.thrift.protocol.TStruct("PartitionsByExprResult");
 
-  private static final org.apache.thrift.protocol.TField PARTITIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("partitions",
org.apache.thrift.protocol.TType.SET, (short)1);
+  private static final org.apache.thrift.protocol.TField PARTITIONS_FIELD_DESC = new org.apache.thrift.protocol.TField("partitions",
org.apache.thrift.protocol.TType.LIST, (short)1);
   private static final org.apache.thrift.protocol.TField HAS_UNKNOWN_PARTITIONS_FIELD_DESC
= new org.apache.thrift.protocol.TField("hasUnknownPartitions", org.apache.thrift.protocol.TType.BOOL,
(short)2);
 
   private static final Map<Class<? extends IScheme>, SchemeFactory> schemes =
new HashMap<Class<? extends IScheme>, SchemeFactory>();
@@ -43,7 +43,7 @@ public class PartitionsByExprResult impl
     schemes.put(TupleScheme.class, new PartitionsByExprResultTupleSchemeFactory());
   }
 
-  private Set<Partition> partitions; // required
+  private List<Partition> partitions; // required
   private boolean hasUnknownPartitions; // required
 
   /** The set of fields this struct contains, along with convenience methods for finding
and manipulating them. */
@@ -114,7 +114,7 @@ public class PartitionsByExprResult impl
   static {
     Map<_Fields, org.apache.thrift.meta_data.FieldMetaData> tmpMap = new EnumMap<_Fields,
org.apache.thrift.meta_data.FieldMetaData>(_Fields.class);
     tmpMap.put(_Fields.PARTITIONS, new org.apache.thrift.meta_data.FieldMetaData("partitions",
org.apache.thrift.TFieldRequirementType.REQUIRED, 
-        new org.apache.thrift.meta_data.SetMetaData(org.apache.thrift.protocol.TType.SET,

+        new org.apache.thrift.meta_data.ListMetaData(org.apache.thrift.protocol.TType.LIST,

             new org.apache.thrift.meta_data.StructMetaData(org.apache.thrift.protocol.TType.STRUCT,
Partition.class))));
     tmpMap.put(_Fields.HAS_UNKNOWN_PARTITIONS, new org.apache.thrift.meta_data.FieldMetaData("hasUnknownPartitions",
org.apache.thrift.TFieldRequirementType.REQUIRED, 
         new org.apache.thrift.meta_data.FieldValueMetaData(org.apache.thrift.protocol.TType.BOOL)));
@@ -126,7 +126,7 @@ public class PartitionsByExprResult impl
   }
 
   public PartitionsByExprResult(
-    Set<Partition> partitions,
+    List<Partition> partitions,
     boolean hasUnknownPartitions)
   {
     this();
@@ -141,7 +141,7 @@ public class PartitionsByExprResult impl
   public PartitionsByExprResult(PartitionsByExprResult other) {
     __isset_bitfield = other.__isset_bitfield;
     if (other.isSetPartitions()) {
-      Set<Partition> __this__partitions = new HashSet<Partition>();
+      List<Partition> __this__partitions = new ArrayList<Partition>();
       for (Partition other_element : other.partitions) {
         __this__partitions.add(new Partition(other_element));
       }
@@ -171,16 +171,16 @@ public class PartitionsByExprResult impl
 
   public void addToPartitions(Partition elem) {
     if (this.partitions == null) {
-      this.partitions = new HashSet<Partition>();
+      this.partitions = new ArrayList<Partition>();
     }
     this.partitions.add(elem);
   }
 
-  public Set<Partition> getPartitions() {
+  public List<Partition> getPartitions() {
     return this.partitions;
   }
 
-  public void setPartitions(Set<Partition> partitions) {
+  public void setPartitions(List<Partition> partitions) {
     this.partitions = partitions;
   }
 
@@ -227,7 +227,7 @@ public class PartitionsByExprResult impl
       if (value == null) {
         unsetPartitions();
       } else {
-        setPartitions((Set<Partition>)value);
+        setPartitions((List<Partition>)value);
       }
       break;
 
@@ -433,18 +433,18 @@ public class PartitionsByExprResult impl
         }
         switch (schemeField.id) {
           case 1: // PARTITIONS
-            if (schemeField.type == org.apache.thrift.protocol.TType.SET) {
+            if (schemeField.type == org.apache.thrift.protocol.TType.LIST) {
               {
-                org.apache.thrift.protocol.TSet _set256 = iprot.readSetBegin();
-                struct.partitions = new HashSet<Partition>(2*_set256.size);
-                for (int _i257 = 0; _i257 < _set256.size; ++_i257)
+                org.apache.thrift.protocol.TList _list256 = iprot.readListBegin();
+                struct.partitions = new ArrayList<Partition>(_list256.size);
+                for (int _i257 = 0; _i257 < _list256.size; ++_i257)
                 {
                   Partition _elem258; // required
                   _elem258 = new Partition();
                   _elem258.read(iprot);
                   struct.partitions.add(_elem258);
                 }
-                iprot.readSetEnd();
+                iprot.readListEnd();
               }
               struct.setPartitionsIsSet(true);
             } else { 
@@ -475,12 +475,12 @@ public class PartitionsByExprResult impl
       if (struct.partitions != null) {
         oprot.writeFieldBegin(PARTITIONS_FIELD_DESC);
         {
-          oprot.writeSetBegin(new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRUCT,
struct.partitions.size()));
+          oprot.writeListBegin(new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT,
struct.partitions.size()));
           for (Partition _iter259 : struct.partitions)
           {
             _iter259.write(oprot);
           }
-          oprot.writeSetEnd();
+          oprot.writeListEnd();
         }
         oprot.writeFieldEnd();
       }
@@ -518,9 +518,9 @@ public class PartitionsByExprResult impl
     public void read(org.apache.thrift.protocol.TProtocol prot, PartitionsByExprResult struct)
throws org.apache.thrift.TException {
       TTupleProtocol iprot = (TTupleProtocol) prot;
       {
-        org.apache.thrift.protocol.TSet _set261 = new org.apache.thrift.protocol.TSet(org.apache.thrift.protocol.TType.STRUCT,
iprot.readI32());
-        struct.partitions = new HashSet<Partition>(2*_set261.size);
-        for (int _i262 = 0; _i262 < _set261.size; ++_i262)
+        org.apache.thrift.protocol.TList _list261 = new org.apache.thrift.protocol.TList(org.apache.thrift.protocol.TType.STRUCT,
iprot.readI32());
+        struct.partitions = new ArrayList<Partition>(_list261.size);
+        for (int _i262 = 0; _i262 < _list261.size; ++_i262)
         {
           Partition _elem263; // required
           _elem263 = new Partition();



Mime
View raw message