hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From nzh...@apache.org
Subject svn commit: r923454 [1/3] - in /hadoop/hive/trunk: ./ metastore/if/ metastore/src/gen-cpp/ metastore/src/gen-javabean/org/apache/hadoop/hive/metastore/api/ metastore/src/gen-php/ metastore/src/gen-py/hive_metastore/ metastore/src/java/org/apache/hadoop...
Date Mon, 15 Mar 2010 21:49:45 GMT
Author: nzhang
Date: Mon Mar 15 21:49:45 2010
New Revision: 923454

URL: http://svn.apache.org/viewvc?rev=923454&view=rev
Log:
HIVE-1238. Get partitions with a partial specification (Paul Yang via Ning Zhang)

Added:
    hadoop/hive/trunk/ql/src/test/queries/clientpositive/show_partitions.q
    hadoop/hive/trunk/ql/src/test/results/clientpositive/show_partitions.q.out
Modified:
    hadoop/hive/trunk/CHANGES.txt
    hadoop/hive/trunk/metastore/if/hive_metastore.thrift
    hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore.cpp
    hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore.h
    hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
    hadoop/hive/trunk/metastore/src/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java
    hadoop/hive/trunk/metastore/src/gen-php/ThriftHiveMetastore.php
    hadoop/hive/trunk/metastore/src/gen-py/hive_metastore/ThriftHiveMetastore-remote
    hadoop/hive/trunk/metastore/src/gen-py/hive_metastore/ThriftHiveMetastore.py
    hadoop/hive/trunk/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStore.java
    hadoop/hive/trunk/metastore/src/java/org/apache/hadoop/hive/metastore/HiveMetaStoreClient.java
    hadoop/hive/trunk/metastore/src/java/org/apache/hadoop/hive/metastore/IMetaStoreClient.java
    hadoop/hive/trunk/metastore/src/java/org/apache/hadoop/hive/metastore/MetaStoreUtils.java
    hadoop/hive/trunk/metastore/src/test/org/apache/hadoop/hive/metastore/TestHiveMetaStore.java
    hadoop/hive/trunk/ql/src/java/org/apache/hadoop/hive/ql/exec/DDLTask.java
    hadoop/hive/trunk/ql/src/java/org/apache/hadoop/hive/ql/metadata/Hive.java
    hadoop/hive/trunk/ql/src/java/org/apache/hadoop/hive/ql/parse/DDLSemanticAnalyzer.java
    hadoop/hive/trunk/ql/src/java/org/apache/hadoop/hive/ql/parse/Hive.g
    hadoop/hive/trunk/ql/src/java/org/apache/hadoop/hive/ql/plan/ShowPartitionsDesc.java

Modified: hadoop/hive/trunk/CHANGES.txt
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/CHANGES.txt?rev=923454&r1=923453&r2=923454&view=diff
==============================================================================
--- hadoop/hive/trunk/CHANGES.txt (original)
+++ hadoop/hive/trunk/CHANGES.txt Mon Mar 15 21:49:45 2010
@@ -54,6 +54,9 @@ Trunk -  Unreleased
     HIVE-1027. Create UDFs for XPath expression evaluation
     (Patrick Angeles via Ning Zhang)
 
+    HIVE-1238. Get Partitions with a partial specification
+    (Paul Yang via Ning Zhang)
+
   IMPROVEMENTS
     HIVE-983. Function from_unixtime takes long.
     (Ning Zhang via zshao)

Modified: hadoop/hive/trunk/metastore/if/hive_metastore.thrift
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/metastore/if/hive_metastore.thrift?rev=923454&r1=923453&r2=923454&view=diff
==============================================================================
--- hadoop/hive/trunk/metastore/if/hive_metastore.thrift (original)
+++ hadoop/hive/trunk/metastore/if/hive_metastore.thrift Mon Mar 15 21:49:45 2010
@@ -206,11 +206,22 @@ service ThriftHiveMetastore extends fb30
                        throws(1:MetaException o1, 2:NoSuchObjectException o2)
 
   // returns all the partitions for this table in reverse chronological order.
-  // if max parts is given then it will return only that many
+  // If max parts is given then it will return only that many.
   list<Partition> get_partitions(1:string db_name, 2:string tbl_name, 3:i16 max_parts=-1)
                        throws(1:NoSuchObjectException o1, 2:MetaException o2)
   list<string> get_partition_names(1:string db_name, 2:string tbl_name, 3:i16 max_parts=-1)
                        throws(1:MetaException o2)
+                       
+  // get_partition_mp methods allow filtering by a partial partition specification, 
+  // as needed for dynamic partitions. The values that are not restricted should 
+  // be empty strings. Nulls were considered (instead of "") but caused errors in 
+  // generated Python code.
+  list<Partition> get_partitions_ps(1:string db_name 2:string tbl_name 
+  	3:list<string> part_vals, 4:i16 max_parts=-1)
+                       throws(1:MetaException o1)
+  list<string> get_partition_names_ps(1:string db_name, 
+  	2:string tbl_name, 3:list<string> part_vals, 4:i16 max_parts=-1)
+  	                   throws(1:MetaException o1)
 
   // changes the partition to the new partition object. partition is identified from the
part values
   // in the new_part

Modified: hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore.cpp
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore.cpp?rev=923454&r1=923453&r2=923454&view=diff
==============================================================================
--- hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore.cpp (original)
+++ hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore.cpp Mon Mar 15 21:49:45 2010
@@ -5378,6 +5378,566 @@ uint32_t ThriftHiveMetastore_get_partiti
   return xfer;
 }
 
+uint32_t ThriftHiveMetastore_get_partitions_ps_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 _size190;
+            apache::thrift::protocol::TType _etype193;
+            iprot->readListBegin(_etype193, _size190);
+            this->part_vals.resize(_size190);
+            uint32_t _i194;
+            for (_i194 = 0; _i194 < _size190; ++_i194)
+            {
+              xfer += iprot->readString(this->part_vals[_i194]);
+            }
+            iprot->readListEnd();
+          }
+          this->__isset.part_vals = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == apache::thrift::protocol::T_I16) {
+          xfer += iprot->readI16(this->max_parts);
+          this->__isset.max_parts = 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_partitions_ps_args::write(apache::thrift::protocol::TProtocol*
oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_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, this->part_vals.size());
+    std::vector<std::string> ::const_iterator _iter195;
+    for (_iter195 = this->part_vals.begin(); _iter195 != this->part_vals.end(); ++_iter195)
+    {
+      xfer += oprot->writeString((*_iter195));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("max_parts", apache::thrift::protocol::T_I16, 4);
+  xfer += oprot->writeI16(this->max_parts);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_partitions_ps_pargs::write(apache::thrift::protocol::TProtocol*
oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_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, (*(this->part_vals)).size());
+    std::vector<std::string> ::const_iterator _iter196;
+    for (_iter196 = (*(this->part_vals)).begin(); _iter196 != (*(this->part_vals)).end();
++_iter196)
+    {
+      xfer += oprot->writeString((*_iter196));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("max_parts", apache::thrift::protocol::T_I16, 4);
+  xfer += oprot->writeI16((*(this->max_parts)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_partitions_ps_result::read(apache::thrift::protocol::TProtocol*
iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == apache::thrift::protocol::T_LIST) {
+          {
+            this->success.clear();
+            uint32_t _size197;
+            apache::thrift::protocol::TType _etype200;
+            iprot->readListBegin(_etype200, _size197);
+            this->success.resize(_size197);
+            uint32_t _i201;
+            for (_i201 = 0; _i201 < _size197; ++_i201)
+            {
+              xfer += this->success[_i201].read(iprot);
+            }
+            iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == apache::thrift::protocol::T_STRUCT) {
+          xfer += this->o1.read(iprot);
+          this->__isset.o1 = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_partitions_ps_result::write(apache::thrift::protocol::TProtocol*
oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partitions_ps_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_LIST, 0);
+    {
+      xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRUCT, this->success.size());
+      std::vector<Partition> ::const_iterator _iter202;
+      for (_iter202 = this->success.begin(); _iter202 != this->success.end(); ++_iter202)
+      {
+        xfer += (*_iter202).write(oprot);
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.o1) {
+    xfer += oprot->writeFieldBegin("o1", apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->o1.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_partitions_ps_presult::read(apache::thrift::protocol::TProtocol*
iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == apache::thrift::protocol::T_LIST) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size203;
+            apache::thrift::protocol::TType _etype206;
+            iprot->readListBegin(_etype206, _size203);
+            (*(this->success)).resize(_size203);
+            uint32_t _i207;
+            for (_i207 = 0; _i207 < _size203; ++_i207)
+            {
+              xfer += (*(this->success))[_i207].read(iprot);
+            }
+            iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == apache::thrift::protocol::T_STRUCT) {
+          xfer += this->o1.read(iprot);
+          this->__isset.o1 = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_partition_names_ps_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 _size208;
+            apache::thrift::protocol::TType _etype211;
+            iprot->readListBegin(_etype211, _size208);
+            this->part_vals.resize(_size208);
+            uint32_t _i212;
+            for (_i212 = 0; _i212 < _size208; ++_i212)
+            {
+              xfer += iprot->readString(this->part_vals[_i212]);
+            }
+            iprot->readListEnd();
+          }
+          this->__isset.part_vals = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 4:
+        if (ftype == apache::thrift::protocol::T_I16) {
+          xfer += iprot->readI16(this->max_parts);
+          this->__isset.max_parts = 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_names_ps_args::write(apache::thrift::protocol::TProtocol*
oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_ps_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, this->part_vals.size());
+    std::vector<std::string> ::const_iterator _iter213;
+    for (_iter213 = this->part_vals.begin(); _iter213 != this->part_vals.end(); ++_iter213)
+    {
+      xfer += oprot->writeString((*_iter213));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("max_parts", apache::thrift::protocol::T_I16, 4);
+  xfer += oprot->writeI16(this->max_parts);
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_partition_names_ps_pargs::write(apache::thrift::protocol::TProtocol*
oprot) const {
+  uint32_t xfer = 0;
+  xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_ps_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, (*(this->part_vals)).size());
+    std::vector<std::string> ::const_iterator _iter214;
+    for (_iter214 = (*(this->part_vals)).begin(); _iter214 != (*(this->part_vals)).end();
++_iter214)
+    {
+      xfer += oprot->writeString((*_iter214));
+    }
+    xfer += oprot->writeListEnd();
+  }
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldBegin("max_parts", apache::thrift::protocol::T_I16, 4);
+  xfer += oprot->writeI16((*(this->max_parts)));
+  xfer += oprot->writeFieldEnd();
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_partition_names_ps_result::read(apache::thrift::protocol::TProtocol*
iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == apache::thrift::protocol::T_LIST) {
+          {
+            this->success.clear();
+            uint32_t _size215;
+            apache::thrift::protocol::TType _etype218;
+            iprot->readListBegin(_etype218, _size215);
+            this->success.resize(_size215);
+            uint32_t _i219;
+            for (_i219 = 0; _i219 < _size215; ++_i219)
+            {
+              xfer += iprot->readString(this->success[_i219]);
+            }
+            iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == apache::thrift::protocol::T_STRUCT) {
+          xfer += this->o1.read(iprot);
+          this->__isset.o1 = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_partition_names_ps_result::write(apache::thrift::protocol::TProtocol*
oprot) const {
+
+  uint32_t xfer = 0;
+
+  xfer += oprot->writeStructBegin("ThriftHiveMetastore_get_partition_names_ps_result");
+
+  if (this->__isset.success) {
+    xfer += oprot->writeFieldBegin("success", apache::thrift::protocol::T_LIST, 0);
+    {
+      xfer += oprot->writeListBegin(apache::thrift::protocol::T_STRING, this->success.size());
+      std::vector<std::string> ::const_iterator _iter220;
+      for (_iter220 = this->success.begin(); _iter220 != this->success.end(); ++_iter220)
+      {
+        xfer += oprot->writeString((*_iter220));
+      }
+      xfer += oprot->writeListEnd();
+    }
+    xfer += oprot->writeFieldEnd();
+  } else if (this->__isset.o1) {
+    xfer += oprot->writeFieldBegin("o1", apache::thrift::protocol::T_STRUCT, 1);
+    xfer += this->o1.write(oprot);
+    xfer += oprot->writeFieldEnd();
+  }
+  xfer += oprot->writeFieldStop();
+  xfer += oprot->writeStructEnd();
+  return xfer;
+}
+
+uint32_t ThriftHiveMetastore_get_partition_names_ps_presult::read(apache::thrift::protocol::TProtocol*
iprot) {
+
+  uint32_t xfer = 0;
+  std::string fname;
+  apache::thrift::protocol::TType ftype;
+  int16_t fid;
+
+  xfer += iprot->readStructBegin(fname);
+
+  using apache::thrift::protocol::TProtocolException;
+
+
+  while (true)
+  {
+    xfer += iprot->readFieldBegin(fname, ftype, fid);
+    if (ftype == apache::thrift::protocol::T_STOP) {
+      break;
+    }
+    switch (fid)
+    {
+      case 0:
+        if (ftype == apache::thrift::protocol::T_LIST) {
+          {
+            (*(this->success)).clear();
+            uint32_t _size221;
+            apache::thrift::protocol::TType _etype224;
+            iprot->readListBegin(_etype224, _size221);
+            (*(this->success)).resize(_size221);
+            uint32_t _i225;
+            for (_i225 = 0; _i225 < _size221; ++_i225)
+            {
+              xfer += iprot->readString((*(this->success))[_i225]);
+            }
+            iprot->readListEnd();
+          }
+          this->__isset.success = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      case 1:
+        if (ftype == apache::thrift::protocol::T_STRUCT) {
+          xfer += this->o1.read(iprot);
+          this->__isset.o1 = true;
+        } else {
+          xfer += iprot->skip(ftype);
+        }
+        break;
+      default:
+        xfer += iprot->skip(ftype);
+        break;
+    }
+    xfer += iprot->readFieldEnd();
+  }
+
+  xfer += iprot->readStructEnd();
+
+  return xfer;
+}
+
 uint32_t ThriftHiveMetastore_alter_partition_args::read(apache::thrift::protocol::TProtocol*
iprot) {
 
   uint32_t xfer = 0;
@@ -7371,6 +7931,138 @@ void ThriftHiveMetastoreClient::recv_get
   throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT,
"get_partition_names failed: unknown result");
 }
 
+void ThriftHiveMetastoreClient::get_partitions_ps(std::vector<Partition> & _return,
const std::string& db_name, const std::string& tbl_name, const std::vector<std::string>
& part_vals, const int16_t max_parts)
+{
+  send_get_partitions_ps(db_name, tbl_name, part_vals, max_parts);
+  recv_get_partitions_ps(_return);
+}
+
+void ThriftHiveMetastoreClient::send_get_partitions_ps(const std::string& db_name, const
std::string& tbl_name, const std::vector<std::string> & part_vals, const int16_t
max_parts)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("get_partitions_ps", apache::thrift::protocol::T_CALL, cseqid);
+
+  ThriftHiveMetastore_get_partitions_ps_pargs args;
+  args.db_name = &db_name;
+  args.tbl_name = &tbl_name;
+  args.part_vals = &part_vals;
+  args.max_parts = &max_parts;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->flush();
+  oprot_->getTransport()->writeEnd();
+}
+
+void ThriftHiveMetastoreClient::recv_get_partitions_ps(std::vector<Partition> &
_return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
+  }
+  if (fname.compare("get_partitions_ps") != 0) {
+    iprot_->skip(apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
+  }
+  ThriftHiveMetastore_get_partitions_ps_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.o1) {
+    throw result.o1;
+  }
+  throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT,
"get_partitions_ps failed: unknown result");
+}
+
+void ThriftHiveMetastoreClient::get_partition_names_ps(std::vector<std::string> &
_return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string>
& part_vals, const int16_t max_parts)
+{
+  send_get_partition_names_ps(db_name, tbl_name, part_vals, max_parts);
+  recv_get_partition_names_ps(_return);
+}
+
+void ThriftHiveMetastoreClient::send_get_partition_names_ps(const std::string& db_name,
const std::string& tbl_name, const std::vector<std::string> & part_vals, const
int16_t max_parts)
+{
+  int32_t cseqid = 0;
+  oprot_->writeMessageBegin("get_partition_names_ps", apache::thrift::protocol::T_CALL,
cseqid);
+
+  ThriftHiveMetastore_get_partition_names_ps_pargs args;
+  args.db_name = &db_name;
+  args.tbl_name = &tbl_name;
+  args.part_vals = &part_vals;
+  args.max_parts = &max_parts;
+  args.write(oprot_);
+
+  oprot_->writeMessageEnd();
+  oprot_->getTransport()->flush();
+  oprot_->getTransport()->writeEnd();
+}
+
+void ThriftHiveMetastoreClient::recv_get_partition_names_ps(std::vector<std::string>
& _return)
+{
+
+  int32_t rseqid = 0;
+  std::string fname;
+  apache::thrift::protocol::TMessageType mtype;
+
+  iprot_->readMessageBegin(fname, mtype, rseqid);
+  if (mtype == apache::thrift::protocol::T_EXCEPTION) {
+    apache::thrift::TApplicationException x;
+    x.read(iprot_);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw x;
+  }
+  if (mtype != apache::thrift::protocol::T_REPLY) {
+    iprot_->skip(apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::INVALID_MESSAGE_TYPE);
+  }
+  if (fname.compare("get_partition_names_ps") != 0) {
+    iprot_->skip(apache::thrift::protocol::T_STRUCT);
+    iprot_->readMessageEnd();
+    iprot_->getTransport()->readEnd();
+    throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::WRONG_METHOD_NAME);
+  }
+  ThriftHiveMetastore_get_partition_names_ps_presult result;
+  result.success = &_return;
+  result.read(iprot_);
+  iprot_->readMessageEnd();
+  iprot_->getTransport()->readEnd();
+
+  if (result.__isset.success) {
+    // _return pointer has now been filled
+    return;
+  }
+  if (result.__isset.o1) {
+    throw result.o1;
+  }
+  throw apache::thrift::TApplicationException(apache::thrift::TApplicationException::MISSING_RESULT,
"get_partition_names_ps failed: unknown result");
+}
+
 void ThriftHiveMetastoreClient::alter_partition(const std::string& db_name, const std::string&
tbl_name, const Partition& new_part)
 {
   send_alter_partition(db_name, tbl_name, new_part);
@@ -8347,6 +9039,68 @@ void ThriftHiveMetastoreProcessor::proce
   oprot->getTransport()->writeEnd();
 }
 
+void ThriftHiveMetastoreProcessor::process_get_partitions_ps(int32_t seqid, apache::thrift::protocol::TProtocol*
iprot, apache::thrift::protocol::TProtocol* oprot)
+{
+  ThriftHiveMetastore_get_partitions_ps_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  ThriftHiveMetastore_get_partitions_ps_result result;
+  try {
+    iface_->get_partitions_ps(result.success, args.db_name, args.tbl_name, args.part_vals,
args.max_parts);
+    result.__isset.success = true;
+  } catch (MetaException &o1) {
+    result.o1 = o1;
+    result.__isset.o1 = true;
+  } catch (const std::exception& e) {
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("get_partitions_ps", apache::thrift::protocol::T_EXCEPTION,
seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->flush();
+    oprot->getTransport()->writeEnd();
+    return;
+  }
+
+  oprot->writeMessageBegin("get_partitions_ps", apache::thrift::protocol::T_REPLY, seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
+void ThriftHiveMetastoreProcessor::process_get_partition_names_ps(int32_t seqid, apache::thrift::protocol::TProtocol*
iprot, apache::thrift::protocol::TProtocol* oprot)
+{
+  ThriftHiveMetastore_get_partition_names_ps_args args;
+  args.read(iprot);
+  iprot->readMessageEnd();
+  iprot->getTransport()->readEnd();
+
+  ThriftHiveMetastore_get_partition_names_ps_result result;
+  try {
+    iface_->get_partition_names_ps(result.success, args.db_name, args.tbl_name, args.part_vals,
args.max_parts);
+    result.__isset.success = true;
+  } catch (MetaException &o1) {
+    result.o1 = o1;
+    result.__isset.o1 = true;
+  } catch (const std::exception& e) {
+    apache::thrift::TApplicationException x(e.what());
+    oprot->writeMessageBegin("get_partition_names_ps", apache::thrift::protocol::T_EXCEPTION,
seqid);
+    x.write(oprot);
+    oprot->writeMessageEnd();
+    oprot->getTransport()->flush();
+    oprot->getTransport()->writeEnd();
+    return;
+  }
+
+  oprot->writeMessageBegin("get_partition_names_ps", apache::thrift::protocol::T_REPLY,
seqid);
+  result.write(oprot);
+  oprot->writeMessageEnd();
+  oprot->getTransport()->flush();
+  oprot->getTransport()->writeEnd();
+}
+
 void ThriftHiveMetastoreProcessor::process_alter_partition(int32_t seqid, apache::thrift::protocol::TProtocol*
iprot, apache::thrift::protocol::TProtocol* oprot)
 {
   ThriftHiveMetastore_alter_partition_args args;

Modified: hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore.h
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore.h?rev=923454&r1=923453&r2=923454&view=diff
==============================================================================
--- hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore.h (original)
+++ hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore.h Mon Mar 15 21:49:45 2010
@@ -39,6 +39,8 @@ class ThriftHiveMetastoreIf : virtual pu
   virtual void get_partition_by_name(Partition& _return, const std::string& db_name,
const std::string& tbl_name, const std::string& part_name) = 0;
   virtual void get_partitions(std::vector<Partition> & _return, const std::string&
db_name, const std::string& tbl_name, const int16_t max_parts) = 0;
   virtual void get_partition_names(std::vector<std::string> & _return, const std::string&
db_name, const std::string& tbl_name, const int16_t max_parts) = 0;
+  virtual void get_partitions_ps(std::vector<Partition> & _return, const std::string&
db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals,
const int16_t max_parts) = 0;
+  virtual void get_partition_names_ps(std::vector<std::string> & _return, const
std::string& db_name, const std::string& tbl_name, const std::vector<std::string>
& part_vals, const int16_t max_parts) = 0;
   virtual void alter_partition(const std::string& db_name, const std::string& tbl_name,
const Partition& new_part) = 0;
   virtual void get_config_value(std::string& _return, const std::string& name, const
std::string& defaultValue) = 0;
 };
@@ -124,6 +126,12 @@ class ThriftHiveMetastoreNull : virtual 
   void get_partition_names(std::vector<std::string> & /* _return */, const std::string&
/* db_name */, const std::string& /* tbl_name */, const int16_t /* max_parts */) {
     return;
   }
+  void get_partitions_ps(std::vector<Partition> & /* _return */, const std::string&
/* db_name */, const std::string& /* tbl_name */, const std::vector<std::string>
& /* part_vals */, const int16_t /* max_parts */) {
+    return;
+  }
+  void get_partition_names_ps(std::vector<std::string> & /* _return */, const std::string&
/* db_name */, const std::string& /* tbl_name */, const std::vector<std::string>
& /* part_vals */, const int16_t /* max_parts */) {
+    return;
+  }
   void alter_partition(const std::string& /* db_name */, const std::string& /* tbl_name
*/, const Partition& /* new_part */) {
     return;
   }
@@ -2760,6 +2768,234 @@ class ThriftHiveMetastore_get_partition_
 
 };
 
+class ThriftHiveMetastore_get_partitions_ps_args {
+ public:
+
+  ThriftHiveMetastore_get_partitions_ps_args() : db_name(""), tbl_name(""), max_parts(-1)
{
+  }
+
+  virtual ~ThriftHiveMetastore_get_partitions_ps_args() throw() {}
+
+  std::string db_name;
+  std::string tbl_name;
+  std::vector<std::string>  part_vals;
+  int16_t max_parts;
+
+  struct __isset {
+    __isset() : db_name(false), tbl_name(false), part_vals(false), max_parts(false) {}
+    bool db_name;
+    bool tbl_name;
+    bool part_vals;
+    bool max_parts;
+  } __isset;
+
+  bool operator == (const ThriftHiveMetastore_get_partitions_ps_args & rhs) const
+  {
+    if (!(db_name == rhs.db_name))
+      return false;
+    if (!(tbl_name == rhs.tbl_name))
+      return false;
+    if (!(part_vals == rhs.part_vals))
+      return false;
+    if (!(max_parts == rhs.max_parts))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_partitions_ps_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_partitions_ps_args & ) const;
+
+  uint32_t read(apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHiveMetastore_get_partitions_ps_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_partitions_ps_pargs() throw() {}
+
+  const std::string* db_name;
+  const std::string* tbl_name;
+  const std::vector<std::string> * part_vals;
+  const int16_t* max_parts;
+
+  uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHiveMetastore_get_partitions_ps_result {
+ public:
+
+  ThriftHiveMetastore_get_partitions_ps_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_get_partitions_ps_result() throw() {}
+
+  std::vector<Partition>  success;
+  MetaException o1;
+
+  struct __isset {
+    __isset() : success(false), o1(false) {}
+    bool success;
+    bool o1;
+  } __isset;
+
+  bool operator == (const ThriftHiveMetastore_get_partitions_ps_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(o1 == rhs.o1))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_partitions_ps_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_partitions_ps_result & ) const;
+
+  uint32_t read(apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHiveMetastore_get_partitions_ps_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_partitions_ps_presult() throw() {}
+
+  std::vector<Partition> * success;
+  MetaException o1;
+
+  struct __isset {
+    __isset() : success(false), o1(false) {}
+    bool success;
+    bool o1;
+  } __isset;
+
+  uint32_t read(apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHiveMetastore_get_partition_names_ps_args {
+ public:
+
+  ThriftHiveMetastore_get_partition_names_ps_args() : db_name(""), tbl_name(""), max_parts(-1)
{
+  }
+
+  virtual ~ThriftHiveMetastore_get_partition_names_ps_args() throw() {}
+
+  std::string db_name;
+  std::string tbl_name;
+  std::vector<std::string>  part_vals;
+  int16_t max_parts;
+
+  struct __isset {
+    __isset() : db_name(false), tbl_name(false), part_vals(false), max_parts(false) {}
+    bool db_name;
+    bool tbl_name;
+    bool part_vals;
+    bool max_parts;
+  } __isset;
+
+  bool operator == (const ThriftHiveMetastore_get_partition_names_ps_args & rhs) const
+  {
+    if (!(db_name == rhs.db_name))
+      return false;
+    if (!(tbl_name == rhs.tbl_name))
+      return false;
+    if (!(part_vals == rhs.part_vals))
+      return false;
+    if (!(max_parts == rhs.max_parts))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_partition_names_ps_args &rhs) const
{
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_partition_names_ps_args & ) const;
+
+  uint32_t read(apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHiveMetastore_get_partition_names_ps_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_partition_names_ps_pargs() throw() {}
+
+  const std::string* db_name;
+  const std::string* tbl_name;
+  const std::vector<std::string> * part_vals;
+  const int16_t* max_parts;
+
+  uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHiveMetastore_get_partition_names_ps_result {
+ public:
+
+  ThriftHiveMetastore_get_partition_names_ps_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_get_partition_names_ps_result() throw() {}
+
+  std::vector<std::string>  success;
+  MetaException o1;
+
+  struct __isset {
+    __isset() : success(false), o1(false) {}
+    bool success;
+    bool o1;
+  } __isset;
+
+  bool operator == (const ThriftHiveMetastore_get_partition_names_ps_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(o1 == rhs.o1))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_partition_names_ps_result &rhs) const
{
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_partition_names_ps_result & ) const;
+
+  uint32_t read(apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+class ThriftHiveMetastore_get_partition_names_ps_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_partition_names_ps_presult() throw() {}
+
+  std::vector<std::string> * success;
+  MetaException o1;
+
+  struct __isset {
+    __isset() : success(false), o1(false) {}
+    bool success;
+    bool o1;
+  } __isset;
+
+  uint32_t read(apache::thrift::protocol::TProtocol* iprot);
+
+};
+
 class ThriftHiveMetastore_alter_partition_args {
  public:
 
@@ -3057,6 +3293,12 @@ class ThriftHiveMetastoreClient : virtua
   void get_partition_names(std::vector<std::string> & _return, const std::string&
db_name, const std::string& tbl_name, const int16_t max_parts);
   void send_get_partition_names(const std::string& db_name, const std::string& tbl_name,
const int16_t max_parts);
   void recv_get_partition_names(std::vector<std::string> & _return);
+  void get_partitions_ps(std::vector<Partition> & _return, const std::string&
db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals,
const int16_t max_parts);
+  void send_get_partitions_ps(const std::string& db_name, const std::string& tbl_name,
const std::vector<std::string> & part_vals, const int16_t max_parts);
+  void recv_get_partitions_ps(std::vector<Partition> & _return);
+  void get_partition_names_ps(std::vector<std::string> & _return, const std::string&
db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals,
const int16_t max_parts);
+  void send_get_partition_names_ps(const std::string& db_name, const std::string&
tbl_name, const std::vector<std::string> & part_vals, const int16_t max_parts);
+  void recv_get_partition_names_ps(std::vector<std::string> & _return);
   void alter_partition(const std::string& db_name, const std::string& tbl_name, const
Partition& new_part);
   void send_alter_partition(const std::string& db_name, const std::string& tbl_name,
const Partition& new_part);
   void recv_alter_partition();
@@ -3095,6 +3337,8 @@ class ThriftHiveMetastoreProcessor : vir
   void process_get_partition_by_name(int32_t seqid, apache::thrift::protocol::TProtocol*
iprot, apache::thrift::protocol::TProtocol* oprot);
   void process_get_partitions(int32_t seqid, apache::thrift::protocol::TProtocol* iprot,
apache::thrift::protocol::TProtocol* oprot);
   void process_get_partition_names(int32_t seqid, apache::thrift::protocol::TProtocol* iprot,
apache::thrift::protocol::TProtocol* oprot);
+  void process_get_partitions_ps(int32_t seqid, apache::thrift::protocol::TProtocol* iprot,
apache::thrift::protocol::TProtocol* oprot);
+  void process_get_partition_names_ps(int32_t seqid, apache::thrift::protocol::TProtocol*
iprot, apache::thrift::protocol::TProtocol* oprot);
   void process_alter_partition(int32_t seqid, apache::thrift::protocol::TProtocol* iprot,
apache::thrift::protocol::TProtocol* oprot);
   void process_get_config_value(int32_t seqid, apache::thrift::protocol::TProtocol* iprot,
apache::thrift::protocol::TProtocol* oprot);
  public:
@@ -3125,6 +3369,8 @@ class ThriftHiveMetastoreProcessor : vir
     processMap_["get_partition_by_name"] = &ThriftHiveMetastoreProcessor::process_get_partition_by_name;
     processMap_["get_partitions"] = &ThriftHiveMetastoreProcessor::process_get_partitions;
     processMap_["get_partition_names"] = &ThriftHiveMetastoreProcessor::process_get_partition_names;
+    processMap_["get_partitions_ps"] = &ThriftHiveMetastoreProcessor::process_get_partitions_ps;
+    processMap_["get_partition_names_ps"] = &ThriftHiveMetastoreProcessor::process_get_partition_names_ps;
     processMap_["alter_partition"] = &ThriftHiveMetastoreProcessor::process_alter_partition;
     processMap_["get_config_value"] = &ThriftHiveMetastoreProcessor::process_get_config_value;
   }
@@ -3417,6 +3663,30 @@ class ThriftHiveMetastoreMultiface : vir
     }
   }
 
+  void get_partitions_ps(std::vector<Partition> & _return, const std::string&
db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals,
const int16_t max_parts) {
+    uint32_t sz = ifaces_.size();
+    for (uint32_t i = 0; i < sz; ++i) {
+      if (i == sz - 1) {
+        ifaces_[i]->get_partitions_ps(_return, db_name, tbl_name, part_vals, max_parts);
+        return;
+      } else {
+        ifaces_[i]->get_partitions_ps(_return, db_name, tbl_name, part_vals, max_parts);
+      }
+    }
+  }
+
+  void get_partition_names_ps(std::vector<std::string> & _return, const std::string&
db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals,
const int16_t max_parts) {
+    uint32_t sz = ifaces_.size();
+    for (uint32_t i = 0; i < sz; ++i) {
+      if (i == sz - 1) {
+        ifaces_[i]->get_partition_names_ps(_return, db_name, tbl_name, part_vals, max_parts);
+        return;
+      } else {
+        ifaces_[i]->get_partition_names_ps(_return, db_name, tbl_name, part_vals, max_parts);
+      }
+    }
+  }
+
   void alter_partition(const std::string& db_name, const std::string& tbl_name, const
Partition& new_part) {
     uint32_t sz = ifaces_.size();
     for (uint32_t i = 0; i < sz; ++i) {

Modified: hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
URL: http://svn.apache.org/viewvc/hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp?rev=923454&r1=923453&r2=923454&view=diff
==============================================================================
--- hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp (original)
+++ hadoop/hive/trunk/metastore/src/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp Mon Mar
15 21:49:45 2010
@@ -142,6 +142,16 @@ class ThriftHiveMetastoreHandler : virtu
     printf("get_partition_names\n");
   }
 
+  void get_partitions_ps(std::vector<Partition> & _return, const std::string&
db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals,
const int16_t max_parts) {
+    // Your implementation goes here
+    printf("get_partitions_ps\n");
+  }
+
+  void get_partition_names_ps(std::vector<std::string> & _return, const std::string&
db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals,
const int16_t max_parts) {
+    // Your implementation goes here
+    printf("get_partition_names_ps\n");
+  }
+
   void alter_partition(const std::string& db_name, const std::string& tbl_name, const
Partition& new_part) {
     // Your implementation goes here
     printf("alter_partition\n");



Mime
View raw message