hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From pa...@apache.org
Subject svn commit: r1148878 [3/5] - in /hive/trunk/metastore: if/ src/gen/thrift/gen-cpp/ src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ src/gen/thrift/gen-php/hive_metastore/ src/gen/thrift/gen-py/hive_metastore/ src/gen/thrift/gen-rb/ src...
Date Wed, 20 Jul 2011 18:25:50 GMT
Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h?rev=1148878&r1=1148877&r2=1148878&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h Wed Jul 20 18:25:45 2011
@@ -35,6 +35,7 @@ class ThriftHiveMetastoreIf : virtual pu
   virtual void get_table_objects_by_name(std::vector<Table> & _return, const std::string& dbname, const std::vector<std::string> & tbl_names) = 0;
   virtual void alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) = 0;
   virtual void add_partition(Partition& _return, const Partition& new_part) = 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 append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) = 0;
   virtual bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const bool deleteData) = 0;
@@ -142,6 +143,10 @@ class ThriftHiveMetastoreNull : virtual 
   void add_partition(Partition& /* _return */, const Partition& /* new_part */) {
     return;
   }
+  int32_t add_partitions(const std::vector<Partition> & /* new_parts */) {
+    int32_t _return = 0;
+    return _return;
+  }
   void append_partition(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector<std::string> & /* part_vals */) {
     return;
   }
@@ -2553,6 +2558,124 @@ class ThriftHiveMetastore_add_partition_
 
 };
 
+typedef struct _ThriftHiveMetastore_add_partitions_args__isset {
+  _ThriftHiveMetastore_add_partitions_args__isset() : new_parts(false) {}
+  bool new_parts;
+} _ThriftHiveMetastore_add_partitions_args__isset;
+
+class ThriftHiveMetastore_add_partitions_args {
+ public:
+
+  ThriftHiveMetastore_add_partitions_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_add_partitions_args() throw() {}
+
+  std::vector<Partition>  new_parts;
+
+  _ThriftHiveMetastore_add_partitions_args__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_add_partitions_args & rhs) const
+  {
+    if (!(new_parts == rhs.new_parts))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_add_partitions_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_add_partitions_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_add_partitions_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_add_partitions_pargs() throw() {}
+
+  const std::vector<Partition> * new_parts;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_add_partitions_result__isset {
+  _ThriftHiveMetastore_add_partitions_result__isset() : success(false), o1(false), o2(false), o3(false) {}
+  bool success;
+  bool o1;
+  bool o2;
+  bool o3;
+} _ThriftHiveMetastore_add_partitions_result__isset;
+
+class ThriftHiveMetastore_add_partitions_result {
+ public:
+
+  ThriftHiveMetastore_add_partitions_result() : success(0) {
+  }
+
+  virtual ~ThriftHiveMetastore_add_partitions_result() throw() {}
+
+  int32_t success;
+  InvalidObjectException o1;
+  AlreadyExistsException o2;
+  MetaException o3;
+
+  _ThriftHiveMetastore_add_partitions_result__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_add_partitions_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_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_add_partitions_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_add_partitions_presult__isset {
+  _ThriftHiveMetastore_add_partitions_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
+  bool success;
+  bool o1;
+  bool o2;
+  bool o3;
+} _ThriftHiveMetastore_add_partitions_presult__isset;
+
+class ThriftHiveMetastore_add_partitions_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_add_partitions_presult() throw() {}
+
+  int32_t* success;
+  InvalidObjectException o1;
+  AlreadyExistsException o2;
+  MetaException o3;
+
+  _ThriftHiveMetastore_add_partitions_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
 typedef struct _ThriftHiveMetastore_append_partition_args__isset {
   _ThriftHiveMetastore_append_partition_args__isset() : db_name(false), tbl_name(false), part_vals(false) {}
   bool db_name;
@@ -7402,6 +7525,9 @@ class ThriftHiveMetastoreClient : virtua
   void add_partition(Partition& _return, const Partition& new_part);
   void send_add_partition(const Partition& new_part);
   void recv_add_partition(Partition& _return);
+  int32_t add_partitions(const std::vector<Partition> & new_parts);
+  void send_add_partitions(const std::vector<Partition> & new_parts);
+  int32_t recv_add_partitions();
   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);
@@ -7550,6 +7676,7 @@ class ThriftHiveMetastoreProcessor : vir
   void process_get_table_objects_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
   void process_alter_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
   void process_add_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
+  void process_add_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
   void process_append_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
   void process_append_partition_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
   void process_drop_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
@@ -7614,6 +7741,7 @@ class ThriftHiveMetastoreProcessor : vir
     processMap_["get_table_objects_by_name"] = &ThriftHiveMetastoreProcessor::process_get_table_objects_by_name;
     processMap_["alter_table"] = &ThriftHiveMetastoreProcessor::process_alter_table;
     processMap_["add_partition"] = &ThriftHiveMetastoreProcessor::process_add_partition;
+    processMap_["add_partitions"] = &ThriftHiveMetastoreProcessor::process_add_partitions;
     processMap_["append_partition"] = &ThriftHiveMetastoreProcessor::process_append_partition;
     processMap_["append_partition_by_name"] = &ThriftHiveMetastoreProcessor::process_append_partition_by_name;
     processMap_["drop_partition"] = &ThriftHiveMetastoreProcessor::process_drop_partition;
@@ -7885,6 +8013,17 @@ class ThriftHiveMetastoreMultiface : vir
     }
   }
 
+  int32_t add_partitions(const std::vector<Partition> & new_parts) {
+    uint32_t sz = ifaces_.size();
+    for (uint32_t i = 0; i < sz; ++i) {
+      if (i == sz - 1) {
+        return ifaces_[i]->add_partitions(new_parts);
+      } else {
+        ifaces_[i]->add_partitions(new_parts);
+      }
+    }
+  }
+
   void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals) {
     uint32_t sz = ifaces_.size();
     for (uint32_t i = 0; i < sz; ++i) {

Modified: hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp?rev=1148878&r1=1148877&r2=1148878&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore_server.skeleton.cpp Wed Jul 20 18:25:45 2011
@@ -122,6 +122,11 @@ class ThriftHiveMetastoreHandler : virtu
     printf("add_partition\n");
   }
 
+  int32_t add_partitions(const std::vector<Partition> & new_parts) {
+    // Your implementation goes here
+    printf("add_partitions\n");
+  }
+
   void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals) {
     // Your implementation goes here
     printf("append_partition\n");

Modified: hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java
URL: http://svn.apache.org/viewvc/hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java?rev=1148878&r1=1148877&r2=1148878&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ThriftHiveMetastore.java Wed Jul 20 18:25:45 2011
@@ -73,6 +73,8 @@ public class ThriftHiveMetastore {
 
     public Partition add_partition(Partition new_part) throws InvalidObjectException, AlreadyExistsException, MetaException, TException;
 
+    public int add_partitions(List<Partition> new_parts) throws InvalidObjectException, AlreadyExistsException, MetaException, TException;
+
     public Partition append_partition(String db_name, String tbl_name, List<String> part_vals) throws InvalidObjectException, AlreadyExistsException, MetaException, TException;
 
     public Partition append_partition_by_name(String db_name, String tbl_name, String part_name) throws InvalidObjectException, AlreadyExistsException, MetaException, TException;
@@ -197,6 +199,8 @@ public class ThriftHiveMetastore {
 
     public void add_partition(Partition new_part, AsyncMethodCallback<AsyncClient.add_partition_call> resultHandler) throws TException;
 
+    public void add_partitions(List<Partition> new_parts, AsyncMethodCallback<AsyncClient.add_partitions_call> resultHandler) throws TException;
+
     public void append_partition(String db_name, String tbl_name, List<String> part_vals, AsyncMethodCallback<AsyncClient.append_partition_call> resultHandler) throws TException;
 
     public void append_partition_by_name(String db_name, String tbl_name, String part_name, AsyncMethodCallback<AsyncClient.append_partition_by_name_call> resultHandler) throws TException;
@@ -1145,6 +1149,51 @@ public class ThriftHiveMetastore {
       throw new TApplicationException(TApplicationException.MISSING_RESULT, "add_partition failed: unknown result");
     }
 
+    public int add_partitions(List<Partition> new_parts) throws InvalidObjectException, AlreadyExistsException, MetaException, TException
+    {
+      send_add_partitions(new_parts);
+      return recv_add_partitions();
+    }
+
+    public void send_add_partitions(List<Partition> new_parts) throws TException
+    {
+      oprot_.writeMessageBegin(new TMessage("add_partitions", TMessageType.CALL, ++seqid_));
+      add_partitions_args args = new add_partitions_args();
+      args.setNew_parts(new_parts);
+      args.write(oprot_);
+      oprot_.writeMessageEnd();
+      oprot_.getTransport().flush();
+    }
+
+    public int recv_add_partitions() throws InvalidObjectException, AlreadyExistsException, MetaException, TException
+    {
+      TMessage msg = iprot_.readMessageBegin();
+      if (msg.type == TMessageType.EXCEPTION) {
+        TApplicationException x = TApplicationException.read(iprot_);
+        iprot_.readMessageEnd();
+        throw x;
+      }
+      if (msg.seqid != seqid_) {
+        throw new TApplicationException(TApplicationException.BAD_SEQUENCE_ID, "add_partitions failed: out of sequence response");
+      }
+      add_partitions_result result = new add_partitions_result();
+      result.read(iprot_);
+      iprot_.readMessageEnd();
+      if (result.isSetSuccess()) {
+        return result.success;
+      }
+      if (result.o1 != null) {
+        throw result.o1;
+      }
+      if (result.o2 != null) {
+        throw result.o2;
+      }
+      if (result.o3 != null) {
+        throw result.o3;
+      }
+      throw new TApplicationException(TApplicationException.MISSING_RESULT, "add_partitions failed: unknown result");
+    }
+
     public Partition append_partition(String db_name, String tbl_name, List<String> part_vals) throws InvalidObjectException, AlreadyExistsException, MetaException, TException
     {
       send_append_partition(db_name, tbl_name, part_vals);
@@ -3533,6 +3582,37 @@ public class ThriftHiveMetastore {
       }
     }
 
+    public void add_partitions(List<Partition> new_parts, AsyncMethodCallback<add_partitions_call> resultHandler) throws TException {
+      checkReady();
+      add_partitions_call method_call = new add_partitions_call(new_parts, resultHandler, this, protocolFactory, transport);
+      manager.call(method_call);
+    }
+
+    public static class add_partitions_call extends TAsyncMethodCall {
+      private List<Partition> new_parts;
+      public add_partitions_call(List<Partition> new_parts, AsyncMethodCallback<add_partitions_call> resultHandler, TAsyncClient client, TProtocolFactory protocolFactory, TNonblockingTransport transport) throws TException {
+        super(client, protocolFactory, transport, resultHandler, false);
+        this.new_parts = new_parts;
+      }
+
+      public void write_args(TProtocol prot) throws TException {
+        prot.writeMessageBegin(new TMessage("add_partitions", TMessageType.CALL, 0));
+        add_partitions_args args = new add_partitions_args();
+        args.setNew_parts(new_parts);
+        args.write(prot);
+        prot.writeMessageEnd();
+      }
+
+      public int getResult() throws InvalidObjectException, AlreadyExistsException, MetaException, TException {
+        if (getState() != State.RESPONSE_READ) {
+          throw new IllegalStateException("Method call not finished!");
+        }
+        TMemoryInputTransport memoryTransport = new TMemoryInputTransport(getFrameBuffer().array());
+        TProtocol prot = client.getProtocolFactory().getProtocol(memoryTransport);
+        return (new Client(prot)).recv_add_partitions();
+      }
+    }
+
     public void append_partition(String db_name, String tbl_name, List<String> part_vals, AsyncMethodCallback<append_partition_call> resultHandler) throws TException {
       checkReady();
       append_partition_call method_call = new append_partition_call(db_name, tbl_name, part_vals, resultHandler, this, protocolFactory, transport);
@@ -5029,6 +5109,7 @@ public class ThriftHiveMetastore {
       processMap_.put("get_table_objects_by_name", new get_table_objects_by_name());
       processMap_.put("alter_table", new alter_table());
       processMap_.put("add_partition", new add_partition());
+      processMap_.put("add_partitions", new add_partitions());
       processMap_.put("append_partition", new append_partition());
       processMap_.put("append_partition_by_name", new append_partition_by_name());
       processMap_.put("drop_partition", new drop_partition());
@@ -5901,6 +5982,49 @@ public class ThriftHiveMetastore {
 
     }
 
+    private class add_partitions implements ProcessFunction {
+      public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
+      {
+        add_partitions_args args = new add_partitions_args();
+        try {
+          args.read(iprot);
+        } catch (TProtocolException e) {
+          iprot.readMessageEnd();
+          TApplicationException x = new TApplicationException(TApplicationException.PROTOCOL_ERROR, e.getMessage());
+          oprot.writeMessageBegin(new TMessage("add_partitions", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        iprot.readMessageEnd();
+        add_partitions_result result = new add_partitions_result();
+        try {
+          result.success = iface_.add_partitions(args.new_parts);
+          result.setSuccessIsSet(true);
+        } catch (InvalidObjectException o1) {
+          result.o1 = o1;
+        } catch (AlreadyExistsException o2) {
+          result.o2 = o2;
+        } catch (MetaException o3) {
+          result.o3 = o3;
+        } catch (Throwable th) {
+          LOGGER.error("Internal error processing add_partitions", th);
+          TApplicationException x = new TApplicationException(TApplicationException.INTERNAL_ERROR, "Internal error processing add_partitions");
+          oprot.writeMessageBegin(new TMessage("add_partitions", TMessageType.EXCEPTION, seqid));
+          x.write(oprot);
+          oprot.writeMessageEnd();
+          oprot.getTransport().flush();
+          return;
+        }
+        oprot.writeMessageBegin(new TMessage("add_partitions", TMessageType.REPLY, seqid));
+        result.write(oprot);
+        oprot.writeMessageEnd();
+        oprot.getTransport().flush();
+      }
+
+    }
+
     private class append_partition implements ProcessFunction {
       public void process(int seqid, TProtocol iprot, TProtocol oprot) throws TException
       {
@@ -23254,6 +23378,863 @@ public class ThriftHiveMetastore {
 
   }
 
+  public static class add_partitions_args implements TBase<add_partitions_args, add_partitions_args._Fields>, java.io.Serializable, Cloneable   {
+    private static final TStruct STRUCT_DESC = new TStruct("add_partitions_args");
+
+    private static final TField NEW_PARTS_FIELD_DESC = new TField("new_parts", TType.LIST, (short)1);
+
+    private List<Partition> new_parts;
+
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+      NEW_PARTS((short)1, "new_parts");
+
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byName.put(field.getFieldName(), field);
+        }
+      }
+
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        switch(fieldId) {
+          case 1: // NEW_PARTS
+            return NEW_PARTS;
+          default:
+            return null;
+        }
+      }
+
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+
+      private final short _thriftId;
+      private final String _fieldName;
+
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+
+    // isset id assignments
+
+    public static final Map<_Fields, FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.NEW_PARTS, new FieldMetaData("new_parts", TFieldRequirementType.DEFAULT, 
+          new ListMetaData(TType.LIST, 
+              new StructMetaData(TType.STRUCT, Partition.class))));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      FieldMetaData.addStructMetaDataMap(add_partitions_args.class, metaDataMap);
+    }
+
+    public add_partitions_args() {
+    }
+
+    public add_partitions_args(
+      List<Partition> new_parts)
+    {
+      this();
+      this.new_parts = new_parts;
+    }
+
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public add_partitions_args(add_partitions_args other) {
+      if (other.isSetNew_parts()) {
+        List<Partition> __this__new_parts = new ArrayList<Partition>();
+        for (Partition other_element : other.new_parts) {
+          __this__new_parts.add(new Partition(other_element));
+        }
+        this.new_parts = __this__new_parts;
+      }
+    }
+
+    public add_partitions_args deepCopy() {
+      return new add_partitions_args(this);
+    }
+
+    @Override
+    public void clear() {
+      this.new_parts = null;
+    }
+
+    public int getNew_partsSize() {
+      return (this.new_parts == null) ? 0 : this.new_parts.size();
+    }
+
+    public java.util.Iterator<Partition> getNew_partsIterator() {
+      return (this.new_parts == null) ? null : this.new_parts.iterator();
+    }
+
+    public void addToNew_parts(Partition elem) {
+      if (this.new_parts == null) {
+        this.new_parts = new ArrayList<Partition>();
+      }
+      this.new_parts.add(elem);
+    }
+
+    public List<Partition> getNew_parts() {
+      return this.new_parts;
+    }
+
+    public void setNew_parts(List<Partition> new_parts) {
+      this.new_parts = new_parts;
+    }
+
+    public void unsetNew_parts() {
+      this.new_parts = null;
+    }
+
+    /** Returns true if field new_parts is set (has been asigned a value) and false otherwise */
+    public boolean isSetNew_parts() {
+      return this.new_parts != null;
+    }
+
+    public void setNew_partsIsSet(boolean value) {
+      if (!value) {
+        this.new_parts = null;
+      }
+    }
+
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case NEW_PARTS:
+        if (value == null) {
+          unsetNew_parts();
+        } else {
+          setNew_parts((List<Partition>)value);
+        }
+        break;
+
+      }
+    }
+
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case NEW_PARTS:
+        return getNew_parts();
+
+      }
+      throw new IllegalStateException();
+    }
+
+    /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      if (field == null) {
+        throw new IllegalArgumentException();
+      }
+
+      switch (field) {
+      case NEW_PARTS:
+        return isSetNew_parts();
+      }
+      throw new IllegalStateException();
+    }
+
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof add_partitions_args)
+        return this.equals((add_partitions_args)that);
+      return false;
+    }
+
+    public boolean equals(add_partitions_args that) {
+      if (that == null)
+        return false;
+
+      boolean this_present_new_parts = true && this.isSetNew_parts();
+      boolean that_present_new_parts = true && that.isSetNew_parts();
+      if (this_present_new_parts || that_present_new_parts) {
+        if (!(this_present_new_parts && that_present_new_parts))
+          return false;
+        if (!this.new_parts.equals(that.new_parts))
+          return false;
+      }
+
+      return true;
+    }
+
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+
+    public int compareTo(add_partitions_args other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+
+      int lastComparison = 0;
+      add_partitions_args typedOther = (add_partitions_args)other;
+
+      lastComparison = Boolean.valueOf(isSetNew_parts()).compareTo(typedOther.isSetNew_parts());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetNew_parts()) {
+        lastComparison = TBaseHelper.compareTo(this.new_parts, typedOther.new_parts);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      return 0;
+    }
+
+    public _Fields fieldForId(int fieldId) {
+      return _Fields.findByThriftId(fieldId);
+    }
+
+    public void read(TProtocol iprot) throws TException {
+      TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == TType.STOP) { 
+          break;
+        }
+        switch (field.id) {
+          case 1: // NEW_PARTS
+            if (field.type == TType.LIST) {
+              {
+                TList _list135 = iprot.readListBegin();
+                this.new_parts = new ArrayList<Partition>(_list135.size);
+                for (int _i136 = 0; _i136 < _list135.size; ++_i136)
+                {
+                  Partition _elem137;
+                  _elem137 = new Partition();
+                  _elem137.read(iprot);
+                  this.new_parts.add(_elem137);
+                }
+                iprot.readListEnd();
+              }
+            } else { 
+              TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+
+    public void write(TProtocol oprot) throws TException {
+      validate();
+
+      oprot.writeStructBegin(STRUCT_DESC);
+      if (this.new_parts != null) {
+        oprot.writeFieldBegin(NEW_PARTS_FIELD_DESC);
+        {
+          oprot.writeListBegin(new TList(TType.STRUCT, this.new_parts.size()));
+          for (Partition _iter138 : this.new_parts)
+          {
+            _iter138.write(oprot);
+          }
+          oprot.writeListEnd();
+        }
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("add_partitions_args(");
+      boolean first = true;
+
+      sb.append("new_parts:");
+      if (this.new_parts == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.new_parts);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+
+    public void validate() throws TException {
+      // check for required fields
+    }
+
+  }
+
+  public static class add_partitions_result implements TBase<add_partitions_result, add_partitions_result._Fields>, java.io.Serializable, Cloneable   {
+    private static final TStruct STRUCT_DESC = new TStruct("add_partitions_result");
+
+    private static final TField SUCCESS_FIELD_DESC = new TField("success", TType.I32, (short)0);
+    private static final TField O1_FIELD_DESC = new TField("o1", TType.STRUCT, (short)1);
+    private static final TField O2_FIELD_DESC = new TField("o2", TType.STRUCT, (short)2);
+    private static final TField O3_FIELD_DESC = new TField("o3", TType.STRUCT, (short)3);
+
+    private int success;
+    private InvalidObjectException o1;
+    private AlreadyExistsException o2;
+    private MetaException o3;
+
+    /** The set of fields this struct contains, along with convenience methods for finding and manipulating them. */
+    public enum _Fields implements TFieldIdEnum {
+      SUCCESS((short)0, "success"),
+      O1((short)1, "o1"),
+      O2((short)2, "o2"),
+      O3((short)3, "o3");
+
+      private static final Map<String, _Fields> byName = new HashMap<String, _Fields>();
+
+      static {
+        for (_Fields field : EnumSet.allOf(_Fields.class)) {
+          byName.put(field.getFieldName(), field);
+        }
+      }
+
+      /**
+       * Find the _Fields constant that matches fieldId, or null if its not found.
+       */
+      public static _Fields findByThriftId(int fieldId) {
+        switch(fieldId) {
+          case 0: // SUCCESS
+            return SUCCESS;
+          case 1: // O1
+            return O1;
+          case 2: // O2
+            return O2;
+          case 3: // O3
+            return O3;
+          default:
+            return null;
+        }
+      }
+
+      /**
+       * Find the _Fields constant that matches fieldId, throwing an exception
+       * if it is not found.
+       */
+      public static _Fields findByThriftIdOrThrow(int fieldId) {
+        _Fields fields = findByThriftId(fieldId);
+        if (fields == null) throw new IllegalArgumentException("Field " + fieldId + " doesn't exist!");
+        return fields;
+      }
+
+      /**
+       * Find the _Fields constant that matches name, or null if its not found.
+       */
+      public static _Fields findByName(String name) {
+        return byName.get(name);
+      }
+
+      private final short _thriftId;
+      private final String _fieldName;
+
+      _Fields(short thriftId, String fieldName) {
+        _thriftId = thriftId;
+        _fieldName = fieldName;
+      }
+
+      public short getThriftFieldId() {
+        return _thriftId;
+      }
+
+      public String getFieldName() {
+        return _fieldName;
+      }
+    }
+
+    // isset id assignments
+    private static final int __SUCCESS_ISSET_ID = 0;
+    private BitSet __isset_bit_vector = new BitSet(1);
+
+    public static final Map<_Fields, FieldMetaData> metaDataMap;
+    static {
+      Map<_Fields, FieldMetaData> tmpMap = new EnumMap<_Fields, FieldMetaData>(_Fields.class);
+      tmpMap.put(_Fields.SUCCESS, new FieldMetaData("success", TFieldRequirementType.DEFAULT, 
+          new FieldValueMetaData(TType.I32)));
+      tmpMap.put(_Fields.O1, new FieldMetaData("o1", TFieldRequirementType.DEFAULT, 
+          new FieldValueMetaData(TType.STRUCT)));
+      tmpMap.put(_Fields.O2, new FieldMetaData("o2", TFieldRequirementType.DEFAULT, 
+          new FieldValueMetaData(TType.STRUCT)));
+      tmpMap.put(_Fields.O3, new FieldMetaData("o3", TFieldRequirementType.DEFAULT, 
+          new FieldValueMetaData(TType.STRUCT)));
+      metaDataMap = Collections.unmodifiableMap(tmpMap);
+      FieldMetaData.addStructMetaDataMap(add_partitions_result.class, metaDataMap);
+    }
+
+    public add_partitions_result() {
+    }
+
+    public add_partitions_result(
+      int success,
+      InvalidObjectException o1,
+      AlreadyExistsException o2,
+      MetaException o3)
+    {
+      this();
+      this.success = success;
+      setSuccessIsSet(true);
+      this.o1 = o1;
+      this.o2 = o2;
+      this.o3 = o3;
+    }
+
+    /**
+     * Performs a deep copy on <i>other</i>.
+     */
+    public add_partitions_result(add_partitions_result other) {
+      __isset_bit_vector.clear();
+      __isset_bit_vector.or(other.__isset_bit_vector);
+      this.success = other.success;
+      if (other.isSetO1()) {
+        this.o1 = new InvalidObjectException(other.o1);
+      }
+      if (other.isSetO2()) {
+        this.o2 = new AlreadyExistsException(other.o2);
+      }
+      if (other.isSetO3()) {
+        this.o3 = new MetaException(other.o3);
+      }
+    }
+
+    public add_partitions_result deepCopy() {
+      return new add_partitions_result(this);
+    }
+
+    @Override
+    public void clear() {
+      setSuccessIsSet(false);
+      this.success = 0;
+      this.o1 = null;
+      this.o2 = null;
+      this.o3 = null;
+    }
+
+    public int getSuccess() {
+      return this.success;
+    }
+
+    public void setSuccess(int success) {
+      this.success = success;
+      setSuccessIsSet(true);
+    }
+
+    public void unsetSuccess() {
+      __isset_bit_vector.clear(__SUCCESS_ISSET_ID);
+    }
+
+    /** Returns true if field success is set (has been asigned a value) and false otherwise */
+    public boolean isSetSuccess() {
+      return __isset_bit_vector.get(__SUCCESS_ISSET_ID);
+    }
+
+    public void setSuccessIsSet(boolean value) {
+      __isset_bit_vector.set(__SUCCESS_ISSET_ID, value);
+    }
+
+    public InvalidObjectException getO1() {
+      return this.o1;
+    }
+
+    public void setO1(InvalidObjectException o1) {
+      this.o1 = o1;
+    }
+
+    public void unsetO1() {
+      this.o1 = null;
+    }
+
+    /** Returns true if field o1 is set (has been asigned a value) and false otherwise */
+    public boolean isSetO1() {
+      return this.o1 != null;
+    }
+
+    public void setO1IsSet(boolean value) {
+      if (!value) {
+        this.o1 = null;
+      }
+    }
+
+    public AlreadyExistsException getO2() {
+      return this.o2;
+    }
+
+    public void setO2(AlreadyExistsException o2) {
+      this.o2 = o2;
+    }
+
+    public void unsetO2() {
+      this.o2 = null;
+    }
+
+    /** Returns true if field o2 is set (has been asigned a value) and false otherwise */
+    public boolean isSetO2() {
+      return this.o2 != null;
+    }
+
+    public void setO2IsSet(boolean value) {
+      if (!value) {
+        this.o2 = null;
+      }
+    }
+
+    public MetaException getO3() {
+      return this.o3;
+    }
+
+    public void setO3(MetaException o3) {
+      this.o3 = o3;
+    }
+
+    public void unsetO3() {
+      this.o3 = null;
+    }
+
+    /** Returns true if field o3 is set (has been asigned a value) and false otherwise */
+    public boolean isSetO3() {
+      return this.o3 != null;
+    }
+
+    public void setO3IsSet(boolean value) {
+      if (!value) {
+        this.o3 = null;
+      }
+    }
+
+    public void setFieldValue(_Fields field, Object value) {
+      switch (field) {
+      case SUCCESS:
+        if (value == null) {
+          unsetSuccess();
+        } else {
+          setSuccess((Integer)value);
+        }
+        break;
+
+      case O1:
+        if (value == null) {
+          unsetO1();
+        } else {
+          setO1((InvalidObjectException)value);
+        }
+        break;
+
+      case O2:
+        if (value == null) {
+          unsetO2();
+        } else {
+          setO2((AlreadyExistsException)value);
+        }
+        break;
+
+      case O3:
+        if (value == null) {
+          unsetO3();
+        } else {
+          setO3((MetaException)value);
+        }
+        break;
+
+      }
+    }
+
+    public Object getFieldValue(_Fields field) {
+      switch (field) {
+      case SUCCESS:
+        return new Integer(getSuccess());
+
+      case O1:
+        return getO1();
+
+      case O2:
+        return getO2();
+
+      case O3:
+        return getO3();
+
+      }
+      throw new IllegalStateException();
+    }
+
+    /** Returns true if field corresponding to fieldID is set (has been asigned a value) and false otherwise */
+    public boolean isSet(_Fields field) {
+      if (field == null) {
+        throw new IllegalArgumentException();
+      }
+
+      switch (field) {
+      case SUCCESS:
+        return isSetSuccess();
+      case O1:
+        return isSetO1();
+      case O2:
+        return isSetO2();
+      case O3:
+        return isSetO3();
+      }
+      throw new IllegalStateException();
+    }
+
+    @Override
+    public boolean equals(Object that) {
+      if (that == null)
+        return false;
+      if (that instanceof add_partitions_result)
+        return this.equals((add_partitions_result)that);
+      return false;
+    }
+
+    public boolean equals(add_partitions_result that) {
+      if (that == null)
+        return false;
+
+      boolean this_present_success = true;
+      boolean that_present_success = true;
+      if (this_present_success || that_present_success) {
+        if (!(this_present_success && that_present_success))
+          return false;
+        if (this.success != that.success)
+          return false;
+      }
+
+      boolean this_present_o1 = true && this.isSetO1();
+      boolean that_present_o1 = true && that.isSetO1();
+      if (this_present_o1 || that_present_o1) {
+        if (!(this_present_o1 && that_present_o1))
+          return false;
+        if (!this.o1.equals(that.o1))
+          return false;
+      }
+
+      boolean this_present_o2 = true && this.isSetO2();
+      boolean that_present_o2 = true && that.isSetO2();
+      if (this_present_o2 || that_present_o2) {
+        if (!(this_present_o2 && that_present_o2))
+          return false;
+        if (!this.o2.equals(that.o2))
+          return false;
+      }
+
+      boolean this_present_o3 = true && this.isSetO3();
+      boolean that_present_o3 = true && that.isSetO3();
+      if (this_present_o3 || that_present_o3) {
+        if (!(this_present_o3 && that_present_o3))
+          return false;
+        if (!this.o3.equals(that.o3))
+          return false;
+      }
+
+      return true;
+    }
+
+    @Override
+    public int hashCode() {
+      return 0;
+    }
+
+    public int compareTo(add_partitions_result other) {
+      if (!getClass().equals(other.getClass())) {
+        return getClass().getName().compareTo(other.getClass().getName());
+      }
+
+      int lastComparison = 0;
+      add_partitions_result typedOther = (add_partitions_result)other;
+
+      lastComparison = Boolean.valueOf(isSetSuccess()).compareTo(typedOther.isSetSuccess());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetSuccess()) {
+        lastComparison = TBaseHelper.compareTo(this.success, typedOther.success);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetO1()).compareTo(typedOther.isSetO1());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetO1()) {
+        lastComparison = TBaseHelper.compareTo(this.o1, typedOther.o1);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetO2()).compareTo(typedOther.isSetO2());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetO2()) {
+        lastComparison = TBaseHelper.compareTo(this.o2, typedOther.o2);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      lastComparison = Boolean.valueOf(isSetO3()).compareTo(typedOther.isSetO3());
+      if (lastComparison != 0) {
+        return lastComparison;
+      }
+      if (isSetO3()) {
+        lastComparison = TBaseHelper.compareTo(this.o3, typedOther.o3);
+        if (lastComparison != 0) {
+          return lastComparison;
+        }
+      }
+      return 0;
+    }
+
+    public _Fields fieldForId(int fieldId) {
+      return _Fields.findByThriftId(fieldId);
+    }
+
+    public void read(TProtocol iprot) throws TException {
+      TField field;
+      iprot.readStructBegin();
+      while (true)
+      {
+        field = iprot.readFieldBegin();
+        if (field.type == TType.STOP) { 
+          break;
+        }
+        switch (field.id) {
+          case 0: // SUCCESS
+            if (field.type == TType.I32) {
+              this.success = iprot.readI32();
+              setSuccessIsSet(true);
+            } else { 
+              TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 1: // O1
+            if (field.type == TType.STRUCT) {
+              this.o1 = new InvalidObjectException();
+              this.o1.read(iprot);
+            } else { 
+              TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 2: // O2
+            if (field.type == TType.STRUCT) {
+              this.o2 = new AlreadyExistsException();
+              this.o2.read(iprot);
+            } else { 
+              TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          case 3: // O3
+            if (field.type == TType.STRUCT) {
+              this.o3 = new MetaException();
+              this.o3.read(iprot);
+            } else { 
+              TProtocolUtil.skip(iprot, field.type);
+            }
+            break;
+          default:
+            TProtocolUtil.skip(iprot, field.type);
+        }
+        iprot.readFieldEnd();
+      }
+      iprot.readStructEnd();
+      validate();
+    }
+
+    public void write(TProtocol oprot) throws TException {
+      oprot.writeStructBegin(STRUCT_DESC);
+
+      if (this.isSetSuccess()) {
+        oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
+        oprot.writeI32(this.success);
+        oprot.writeFieldEnd();
+      } else if (this.isSetO1()) {
+        oprot.writeFieldBegin(O1_FIELD_DESC);
+        this.o1.write(oprot);
+        oprot.writeFieldEnd();
+      } else if (this.isSetO2()) {
+        oprot.writeFieldBegin(O2_FIELD_DESC);
+        this.o2.write(oprot);
+        oprot.writeFieldEnd();
+      } else if (this.isSetO3()) {
+        oprot.writeFieldBegin(O3_FIELD_DESC);
+        this.o3.write(oprot);
+        oprot.writeFieldEnd();
+      }
+      oprot.writeFieldStop();
+      oprot.writeStructEnd();
+    }
+
+    @Override
+    public String toString() {
+      StringBuilder sb = new StringBuilder("add_partitions_result(");
+      boolean first = true;
+
+      sb.append("success:");
+      sb.append(this.success);
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("o1:");
+      if (this.o1 == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.o1);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("o2:");
+      if (this.o2 == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.o2);
+      }
+      first = false;
+      if (!first) sb.append(", ");
+      sb.append("o3:");
+      if (this.o3 == null) {
+        sb.append("null");
+      } else {
+        sb.append(this.o3);
+      }
+      first = false;
+      sb.append(")");
+      return sb.toString();
+    }
+
+    public void validate() throws TException {
+      // check for required fields
+    }
+
+  }
+
   public static class append_partition_args implements TBase<append_partition_args, append_partition_args._Fields>, java.io.Serializable, Cloneable   {
     private static final TStruct STRUCT_DESC = new TStruct("append_partition_args");
 
@@ -23654,13 +24635,13 @@ public class ThriftHiveMetastore {
           case 3: // PART_VALS
             if (field.type == TType.LIST) {
               {
-                TList _list135 = iprot.readListBegin();
-                this.part_vals = new ArrayList<String>(_list135.size);
-                for (int _i136 = 0; _i136 < _list135.size; ++_i136)
+                TList _list139 = iprot.readListBegin();
+                this.part_vals = new ArrayList<String>(_list139.size);
+                for (int _i140 = 0; _i140 < _list139.size; ++_i140)
                 {
-                  String _elem137;
-                  _elem137 = iprot.readString();
-                  this.part_vals.add(_elem137);
+                  String _elem141;
+                  _elem141 = iprot.readString();
+                  this.part_vals.add(_elem141);
                 }
                 iprot.readListEnd();
               }
@@ -23695,9 +24676,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(PART_VALS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.part_vals.size()));
-          for (String _iter138 : this.part_vals)
+          for (String _iter142 : this.part_vals)
           {
-            oprot.writeString(_iter138);
+            oprot.writeString(_iter142);
           }
           oprot.writeListEnd();
         }
@@ -25754,13 +26735,13 @@ public class ThriftHiveMetastore {
           case 3: // PART_VALS
             if (field.type == TType.LIST) {
               {
-                TList _list139 = iprot.readListBegin();
-                this.part_vals = new ArrayList<String>(_list139.size);
-                for (int _i140 = 0; _i140 < _list139.size; ++_i140)
+                TList _list143 = iprot.readListBegin();
+                this.part_vals = new ArrayList<String>(_list143.size);
+                for (int _i144 = 0; _i144 < _list143.size; ++_i144)
                 {
-                  String _elem141;
-                  _elem141 = iprot.readString();
-                  this.part_vals.add(_elem141);
+                  String _elem145;
+                  _elem145 = iprot.readString();
+                  this.part_vals.add(_elem145);
                 }
                 iprot.readListEnd();
               }
@@ -25803,9 +26784,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(PART_VALS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.part_vals.size()));
-          for (String _iter142 : this.part_vals)
+          for (String _iter146 : this.part_vals)
           {
-            oprot.writeString(_iter142);
+            oprot.writeString(_iter146);
           }
           oprot.writeListEnd();
         }
@@ -27706,13 +28687,13 @@ public class ThriftHiveMetastore {
           case 3: // PART_VALS
             if (field.type == TType.LIST) {
               {
-                TList _list143 = iprot.readListBegin();
-                this.part_vals = new ArrayList<String>(_list143.size);
-                for (int _i144 = 0; _i144 < _list143.size; ++_i144)
+                TList _list147 = iprot.readListBegin();
+                this.part_vals = new ArrayList<String>(_list147.size);
+                for (int _i148 = 0; _i148 < _list147.size; ++_i148)
                 {
-                  String _elem145;
-                  _elem145 = iprot.readString();
-                  this.part_vals.add(_elem145);
+                  String _elem149;
+                  _elem149 = iprot.readString();
+                  this.part_vals.add(_elem149);
                 }
                 iprot.readListEnd();
               }
@@ -27747,9 +28728,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(PART_VALS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.part_vals.size()));
-          for (String _iter146 : this.part_vals)
+          for (String _iter150 : this.part_vals)
           {
-            oprot.writeString(_iter146);
+            oprot.writeString(_iter150);
           }
           oprot.writeListEnd();
         }
@@ -28807,13 +29788,13 @@ public class ThriftHiveMetastore {
           case 3: // PART_VALS
             if (field.type == TType.LIST) {
               {
-                TList _list147 = iprot.readListBegin();
-                this.part_vals = new ArrayList<String>(_list147.size);
-                for (int _i148 = 0; _i148 < _list147.size; ++_i148)
+                TList _list151 = iprot.readListBegin();
+                this.part_vals = new ArrayList<String>(_list151.size);
+                for (int _i152 = 0; _i152 < _list151.size; ++_i152)
                 {
-                  String _elem149;
-                  _elem149 = iprot.readString();
-                  this.part_vals.add(_elem149);
+                  String _elem153;
+                  _elem153 = iprot.readString();
+                  this.part_vals.add(_elem153);
                 }
                 iprot.readListEnd();
               }
@@ -28831,13 +29812,13 @@ public class ThriftHiveMetastore {
           case 5: // GROUP_NAMES
             if (field.type == TType.LIST) {
               {
-                TList _list150 = iprot.readListBegin();
-                this.group_names = new ArrayList<String>(_list150.size);
-                for (int _i151 = 0; _i151 < _list150.size; ++_i151)
+                TList _list154 = iprot.readListBegin();
+                this.group_names = new ArrayList<String>(_list154.size);
+                for (int _i155 = 0; _i155 < _list154.size; ++_i155)
                 {
-                  String _elem152;
-                  _elem152 = iprot.readString();
-                  this.group_names.add(_elem152);
+                  String _elem156;
+                  _elem156 = iprot.readString();
+                  this.group_names.add(_elem156);
                 }
                 iprot.readListEnd();
               }
@@ -28872,9 +29853,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(PART_VALS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.part_vals.size()));
-          for (String _iter153 : this.part_vals)
+          for (String _iter157 : this.part_vals)
           {
-            oprot.writeString(_iter153);
+            oprot.writeString(_iter157);
           }
           oprot.writeListEnd();
         }
@@ -28889,9 +29870,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.group_names.size()));
-          for (String _iter154 : this.group_names)
+          for (String _iter158 : this.group_names)
           {
-            oprot.writeString(_iter154);
+            oprot.writeString(_iter158);
           }
           oprot.writeListEnd();
         }
@@ -31157,14 +32138,14 @@ public class ThriftHiveMetastore {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list155 = iprot.readListBegin();
-                this.success = new ArrayList<Partition>(_list155.size);
-                for (int _i156 = 0; _i156 < _list155.size; ++_i156)
+                TList _list159 = iprot.readListBegin();
+                this.success = new ArrayList<Partition>(_list159.size);
+                for (int _i160 = 0; _i160 < _list159.size; ++_i160)
                 {
-                  Partition _elem157;
-                  _elem157 = new Partition();
-                  _elem157.read(iprot);
-                  this.success.add(_elem157);
+                  Partition _elem161;
+                  _elem161 = new Partition();
+                  _elem161.read(iprot);
+                  this.success.add(_elem161);
                 }
                 iprot.readListEnd();
               }
@@ -31204,9 +32185,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Partition _iter158 : this.success)
+          for (Partition _iter162 : this.success)
           {
-            _iter158.write(oprot);
+            _iter162.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -31818,13 +32799,13 @@ public class ThriftHiveMetastore {
           case 5: // GROUP_NAMES
             if (field.type == TType.LIST) {
               {
-                TList _list159 = iprot.readListBegin();
-                this.group_names = new ArrayList<String>(_list159.size);
-                for (int _i160 = 0; _i160 < _list159.size; ++_i160)
+                TList _list163 = iprot.readListBegin();
+                this.group_names = new ArrayList<String>(_list163.size);
+                for (int _i164 = 0; _i164 < _list163.size; ++_i164)
                 {
-                  String _elem161;
-                  _elem161 = iprot.readString();
-                  this.group_names.add(_elem161);
+                  String _elem165;
+                  _elem165 = iprot.readString();
+                  this.group_names.add(_elem165);
                 }
                 iprot.readListEnd();
               }
@@ -31867,9 +32848,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.group_names.size()));
-          for (String _iter162 : this.group_names)
+          for (String _iter166 : this.group_names)
           {
-            oprot.writeString(_iter162);
+            oprot.writeString(_iter166);
           }
           oprot.writeListEnd();
         }
@@ -32315,14 +33296,14 @@ public class ThriftHiveMetastore {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list163 = iprot.readListBegin();
-                this.success = new ArrayList<Partition>(_list163.size);
-                for (int _i164 = 0; _i164 < _list163.size; ++_i164)
+                TList _list167 = iprot.readListBegin();
+                this.success = new ArrayList<Partition>(_list167.size);
+                for (int _i168 = 0; _i168 < _list167.size; ++_i168)
                 {
-                  Partition _elem165;
-                  _elem165 = new Partition();
-                  _elem165.read(iprot);
-                  this.success.add(_elem165);
+                  Partition _elem169;
+                  _elem169 = new Partition();
+                  _elem169.read(iprot);
+                  this.success.add(_elem169);
                 }
                 iprot.readListEnd();
               }
@@ -32362,9 +33343,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Partition _iter166 : this.success)
+          for (Partition _iter170 : this.success)
           {
-            _iter166.write(oprot);
+            _iter170.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -33192,13 +34173,13 @@ public class ThriftHiveMetastore {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list167 = iprot.readListBegin();
-                this.success = new ArrayList<String>(_list167.size);
-                for (int _i168 = 0; _i168 < _list167.size; ++_i168)
+                TList _list171 = iprot.readListBegin();
+                this.success = new ArrayList<String>(_list171.size);
+                for (int _i172 = 0; _i172 < _list171.size; ++_i172)
                 {
-                  String _elem169;
-                  _elem169 = iprot.readString();
-                  this.success.add(_elem169);
+                  String _elem173;
+                  _elem173 = iprot.readString();
+                  this.success.add(_elem173);
                 }
                 iprot.readListEnd();
               }
@@ -33230,9 +34211,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.success.size()));
-          for (String _iter170 : this.success)
+          for (String _iter174 : this.success)
           {
-            oprot.writeString(_iter170);
+            oprot.writeString(_iter174);
           }
           oprot.writeListEnd();
         }
@@ -33749,13 +34730,13 @@ public class ThriftHiveMetastore {
           case 3: // PART_VALS
             if (field.type == TType.LIST) {
               {
-                TList _list171 = iprot.readListBegin();
-                this.part_vals = new ArrayList<String>(_list171.size);
-                for (int _i172 = 0; _i172 < _list171.size; ++_i172)
+                TList _list175 = iprot.readListBegin();
+                this.part_vals = new ArrayList<String>(_list175.size);
+                for (int _i176 = 0; _i176 < _list175.size; ++_i176)
                 {
-                  String _elem173;
-                  _elem173 = iprot.readString();
-                  this.part_vals.add(_elem173);
+                  String _elem177;
+                  _elem177 = iprot.readString();
+                  this.part_vals.add(_elem177);
                 }
                 iprot.readListEnd();
               }
@@ -33798,9 +34779,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(PART_VALS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.part_vals.size()));
-          for (String _iter174 : this.part_vals)
+          for (String _iter178 : this.part_vals)
           {
-            oprot.writeString(_iter174);
+            oprot.writeString(_iter178);
           }
           oprot.writeListEnd();
         }
@@ -34173,14 +35154,14 @@ public class ThriftHiveMetastore {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list175 = iprot.readListBegin();
-                this.success = new ArrayList<Partition>(_list175.size);
-                for (int _i176 = 0; _i176 < _list175.size; ++_i176)
+                TList _list179 = iprot.readListBegin();
+                this.success = new ArrayList<Partition>(_list179.size);
+                for (int _i180 = 0; _i180 < _list179.size; ++_i180)
                 {
-                  Partition _elem177;
-                  _elem177 = new Partition();
-                  _elem177.read(iprot);
-                  this.success.add(_elem177);
+                  Partition _elem181;
+                  _elem181 = new Partition();
+                  _elem181.read(iprot);
+                  this.success.add(_elem181);
                 }
                 iprot.readListEnd();
               }
@@ -34212,9 +35193,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Partition _iter178 : this.success)
+          for (Partition _iter182 : this.success)
           {
-            _iter178.write(oprot);
+            _iter182.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -34887,13 +35868,13 @@ public class ThriftHiveMetastore {
           case 3: // PART_VALS
             if (field.type == TType.LIST) {
               {
-                TList _list179 = iprot.readListBegin();
-                this.part_vals = new ArrayList<String>(_list179.size);
-                for (int _i180 = 0; _i180 < _list179.size; ++_i180)
+                TList _list183 = iprot.readListBegin();
+                this.part_vals = new ArrayList<String>(_list183.size);
+                for (int _i184 = 0; _i184 < _list183.size; ++_i184)
                 {
-                  String _elem181;
-                  _elem181 = iprot.readString();
-                  this.part_vals.add(_elem181);
+                  String _elem185;
+                  _elem185 = iprot.readString();
+                  this.part_vals.add(_elem185);
                 }
                 iprot.readListEnd();
               }
@@ -34919,13 +35900,13 @@ public class ThriftHiveMetastore {
           case 6: // GROUP_NAMES
             if (field.type == TType.LIST) {
               {
-                TList _list182 = iprot.readListBegin();
-                this.group_names = new ArrayList<String>(_list182.size);
-                for (int _i183 = 0; _i183 < _list182.size; ++_i183)
+                TList _list186 = iprot.readListBegin();
+                this.group_names = new ArrayList<String>(_list186.size);
+                for (int _i187 = 0; _i187 < _list186.size; ++_i187)
                 {
-                  String _elem184;
-                  _elem184 = iprot.readString();
-                  this.group_names.add(_elem184);
+                  String _elem188;
+                  _elem188 = iprot.readString();
+                  this.group_names.add(_elem188);
                 }
                 iprot.readListEnd();
               }
@@ -34960,9 +35941,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(PART_VALS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.part_vals.size()));
-          for (String _iter185 : this.part_vals)
+          for (String _iter189 : this.part_vals)
           {
-            oprot.writeString(_iter185);
+            oprot.writeString(_iter189);
           }
           oprot.writeListEnd();
         }
@@ -34980,9 +35961,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.group_names.size()));
-          for (String _iter186 : this.group_names)
+          for (String _iter190 : this.group_names)
           {
-            oprot.writeString(_iter186);
+            oprot.writeString(_iter190);
           }
           oprot.writeListEnd();
         }
@@ -35436,14 +36417,14 @@ public class ThriftHiveMetastore {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list187 = iprot.readListBegin();
-                this.success = new ArrayList<Partition>(_list187.size);
-                for (int _i188 = 0; _i188 < _list187.size; ++_i188)
+                TList _list191 = iprot.readListBegin();
+                this.success = new ArrayList<Partition>(_list191.size);
+                for (int _i192 = 0; _i192 < _list191.size; ++_i192)
                 {
-                  Partition _elem189;
-                  _elem189 = new Partition();
-                  _elem189.read(iprot);
-                  this.success.add(_elem189);
+                  Partition _elem193;
+                  _elem193 = new Partition();
+                  _elem193.read(iprot);
+                  this.success.add(_elem193);
                 }
                 iprot.readListEnd();
               }
@@ -35483,9 +36464,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Partition _iter190 : this.success)
+          for (Partition _iter194 : this.success)
           {
-            _iter190.write(oprot);
+            _iter194.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -36014,13 +36995,13 @@ public class ThriftHiveMetastore {
           case 3: // PART_VALS
             if (field.type == TType.LIST) {
               {
-                TList _list191 = iprot.readListBegin();
-                this.part_vals = new ArrayList<String>(_list191.size);
-                for (int _i192 = 0; _i192 < _list191.size; ++_i192)
+                TList _list195 = iprot.readListBegin();
+                this.part_vals = new ArrayList<String>(_list195.size);
+                for (int _i196 = 0; _i196 < _list195.size; ++_i196)
                 {
-                  String _elem193;
-                  _elem193 = iprot.readString();
-                  this.part_vals.add(_elem193);
+                  String _elem197;
+                  _elem197 = iprot.readString();
+                  this.part_vals.add(_elem197);
                 }
                 iprot.readListEnd();
               }
@@ -36063,9 +37044,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(PART_VALS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.part_vals.size()));
-          for (String _iter194 : this.part_vals)
+          for (String _iter198 : this.part_vals)
           {
-            oprot.writeString(_iter194);
+            oprot.writeString(_iter198);
           }
           oprot.writeListEnd();
         }
@@ -36438,13 +37419,13 @@ public class ThriftHiveMetastore {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list195 = iprot.readListBegin();
-                this.success = new ArrayList<String>(_list195.size);
-                for (int _i196 = 0; _i196 < _list195.size; ++_i196)
+                TList _list199 = iprot.readListBegin();
+                this.success = new ArrayList<String>(_list199.size);
+                for (int _i200 = 0; _i200 < _list199.size; ++_i200)
                 {
-                  String _elem197;
-                  _elem197 = iprot.readString();
-                  this.success.add(_elem197);
+                  String _elem201;
+                  _elem201 = iprot.readString();
+                  this.success.add(_elem201);
                 }
                 iprot.readListEnd();
               }
@@ -36476,9 +37457,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.success.size()));
-          for (String _iter198 : this.success)
+          for (String _iter202 : this.success)
           {
-            oprot.writeString(_iter198);
+            oprot.writeString(_iter202);
           }
           oprot.writeListEnd();
         }
@@ -37450,14 +38431,14 @@ public class ThriftHiveMetastore {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list199 = iprot.readListBegin();
-                this.success = new ArrayList<Partition>(_list199.size);
-                for (int _i200 = 0; _i200 < _list199.size; ++_i200)
+                TList _list203 = iprot.readListBegin();
+                this.success = new ArrayList<Partition>(_list203.size);
+                for (int _i204 = 0; _i204 < _list203.size; ++_i204)
                 {
-                  Partition _elem201;
-                  _elem201 = new Partition();
-                  _elem201.read(iprot);
-                  this.success.add(_elem201);
+                  Partition _elem205;
+                  _elem205 = new Partition();
+                  _elem205.read(iprot);
+                  this.success.add(_elem205);
                 }
                 iprot.readListEnd();
               }
@@ -37497,9 +38478,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Partition _iter202 : this.success)
+          for (Partition _iter206 : this.success)
           {
-            _iter202.write(oprot);
+            _iter206.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -37955,13 +38936,13 @@ public class ThriftHiveMetastore {
           case 3: // NAMES
             if (field.type == TType.LIST) {
               {
-                TList _list203 = iprot.readListBegin();
-                this.names = new ArrayList<String>(_list203.size);
-                for (int _i204 = 0; _i204 < _list203.size; ++_i204)
+                TList _list207 = iprot.readListBegin();
+                this.names = new ArrayList<String>(_list207.size);
+                for (int _i208 = 0; _i208 < _list207.size; ++_i208)
                 {
-                  String _elem205;
-                  _elem205 = iprot.readString();
-                  this.names.add(_elem205);
+                  String _elem209;
+                  _elem209 = iprot.readString();
+                  this.names.add(_elem209);
                 }
                 iprot.readListEnd();
               }
@@ -37996,9 +38977,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(NAMES_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.names.size()));
-          for (String _iter206 : this.names)
+          for (String _iter210 : this.names)
           {
-            oprot.writeString(_iter206);
+            oprot.writeString(_iter210);
           }
           oprot.writeListEnd();
         }
@@ -38432,14 +39413,14 @@ public class ThriftHiveMetastore {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list207 = iprot.readListBegin();
-                this.success = new ArrayList<Partition>(_list207.size);
-                for (int _i208 = 0; _i208 < _list207.size; ++_i208)
+                TList _list211 = iprot.readListBegin();
+                this.success = new ArrayList<Partition>(_list211.size);
+                for (int _i212 = 0; _i212 < _list211.size; ++_i212)
                 {
-                  Partition _elem209;
-                  _elem209 = new Partition();
-                  _elem209.read(iprot);
-                  this.success.add(_elem209);
+                  Partition _elem213;
+                  _elem213 = new Partition();
+                  _elem213.read(iprot);
+                  this.success.add(_elem213);
                 }
                 iprot.readListEnd();
               }
@@ -38479,9 +39460,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Partition _iter210 : this.success)
+          for (Partition _iter214 : this.success)
           {
-            _iter210.write(oprot);
+            _iter214.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -40685,13 +41666,13 @@ public class ThriftHiveMetastore {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list211 = iprot.readListBegin();
-                this.success = new ArrayList<String>(_list211.size);
-                for (int _i212 = 0; _i212 < _list211.size; ++_i212)
+                TList _list215 = iprot.readListBegin();
+                this.success = new ArrayList<String>(_list215.size);
+                for (int _i216 = 0; _i216 < _list215.size; ++_i216)
                 {
-                  String _elem213;
-                  _elem213 = iprot.readString();
-                  this.success.add(_elem213);
+                  String _elem217;
+                  _elem217 = iprot.readString();
+                  this.success.add(_elem217);
                 }
                 iprot.readListEnd();
               }
@@ -40723,9 +41704,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.success.size()));
-          for (String _iter214 : this.success)
+          for (String _iter218 : this.success)
           {
-            oprot.writeString(_iter214);
+            oprot.writeString(_iter218);
           }
           oprot.writeListEnd();
         }
@@ -41370,15 +42351,15 @@ public class ThriftHiveMetastore {
           case 0: // SUCCESS
             if (field.type == TType.MAP) {
               {
-                TMap _map215 = iprot.readMapBegin();
-                this.success = new HashMap<String,String>(2*_map215.size);
-                for (int _i216 = 0; _i216 < _map215.size; ++_i216)
+                TMap _map219 = iprot.readMapBegin();
+                this.success = new HashMap<String,String>(2*_map219.size);
+                for (int _i220 = 0; _i220 < _map219.size; ++_i220)
                 {
-                  String _key217;
-                  String _val218;
-                  _key217 = iprot.readString();
-                  _val218 = iprot.readString();
-                  this.success.put(_key217, _val218);
+                  String _key221;
+                  String _val222;
+                  _key221 = iprot.readString();
+                  _val222 = iprot.readString();
+                  this.success.put(_key221, _val222);
                 }
                 iprot.readMapEnd();
               }
@@ -41410,10 +42391,10 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeMapBegin(new TMap(TType.STRING, TType.STRING, this.success.size()));
-          for (Map.Entry<String, String> _iter219 : this.success.entrySet())
+          for (Map.Entry<String, String> _iter223 : this.success.entrySet())
           {
-            oprot.writeString(_iter219.getKey());
-            oprot.writeString(_iter219.getValue());
+            oprot.writeString(_iter223.getKey());
+            oprot.writeString(_iter223.getValue());
           }
           oprot.writeMapEnd();
         }
@@ -41942,15 +42923,15 @@ public class ThriftHiveMetastore {
           case 3: // PART_VALS
             if (field.type == TType.MAP) {
               {
-                TMap _map220 = iprot.readMapBegin();
-                this.part_vals = new HashMap<String,String>(2*_map220.size);
-                for (int _i221 = 0; _i221 < _map220.size; ++_i221)
+                TMap _map224 = iprot.readMapBegin();
+                this.part_vals = new HashMap<String,String>(2*_map224.size);
+                for (int _i225 = 0; _i225 < _map224.size; ++_i225)
                 {
-                  String _key222;
-                  String _val223;
-                  _key222 = iprot.readString();
-                  _val223 = iprot.readString();
-                  this.part_vals.put(_key222, _val223);
+                  String _key226;
+                  String _val227;
+                  _key226 = iprot.readString();
+                  _val227 = iprot.readString();
+                  this.part_vals.put(_key226, _val227);
                 }
                 iprot.readMapEnd();
               }
@@ -41992,10 +42973,10 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(PART_VALS_FIELD_DESC);
         {
           oprot.writeMapBegin(new TMap(TType.STRING, TType.STRING, this.part_vals.size()));
-          for (Map.Entry<String, String> _iter224 : this.part_vals.entrySet())
+          for (Map.Entry<String, String> _iter228 : this.part_vals.entrySet())
           {
-            oprot.writeString(_iter224.getKey());
-            oprot.writeString(_iter224.getValue());
+            oprot.writeString(_iter228.getKey());
+            oprot.writeString(_iter228.getValue());
           }
           oprot.writeMapEnd();
         }
@@ -43259,15 +44240,15 @@ public class ThriftHiveMetastore {
           case 3: // PART_VALS
             if (field.type == TType.MAP) {
               {
-                TMap _map225 = iprot.readMapBegin();
-                this.part_vals = new HashMap<String,String>(2*_map225.size);
-                for (int _i226 = 0; _i226 < _map225.size; ++_i226)
+                TMap _map229 = iprot.readMapBegin();
+                this.part_vals = new HashMap<String,String>(2*_map229.size);
+                for (int _i230 = 0; _i230 < _map229.size; ++_i230)
                 {
-                  String _key227;
-                  String _val228;
-                  _key227 = iprot.readString();
-                  _val228 = iprot.readString();
-                  this.part_vals.put(_key227, _val228);
+                  String _key231;
+                  String _val232;
+                  _key231 = iprot.readString();
+                  _val232 = iprot.readString();
+                  this.part_vals.put(_key231, _val232);
                 }
                 iprot.readMapEnd();
               }
@@ -43309,10 +44290,10 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(PART_VALS_FIELD_DESC);
         {
           oprot.writeMapBegin(new TMap(TType.STRING, TType.STRING, this.part_vals.size()));
-          for (Map.Entry<String, String> _iter229 : this.part_vals.entrySet())
+          for (Map.Entry<String, String> _iter233 : this.part_vals.entrySet())
           {
-            oprot.writeString(_iter229.getKey());
-            oprot.writeString(_iter229.getValue());
+            oprot.writeString(_iter233.getKey());
+            oprot.writeString(_iter233.getValue());
           }
           oprot.writeMapEnd();
         }
@@ -48738,14 +49719,14 @@ public class ThriftHiveMetastore {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list230 = iprot.readListBegin();
-                this.success = new ArrayList<Index>(_list230.size);
-                for (int _i231 = 0; _i231 < _list230.size; ++_i231)
+                TList _list234 = iprot.readListBegin();
+                this.success = new ArrayList<Index>(_list234.size);
+                for (int _i235 = 0; _i235 < _list234.size; ++_i235)
                 {
-                  Index _elem232;
-                  _elem232 = new Index();
-                  _elem232.read(iprot);
-                  this.success.add(_elem232);
+                  Index _elem236;
+                  _elem236 = new Index();
+                  _elem236.read(iprot);
+                  this.success.add(_elem236);
                 }
                 iprot.readListEnd();
               }
@@ -48785,9 +49766,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Index _iter233 : this.success)
+          for (Index _iter237 : this.success)
           {
-            _iter233.write(oprot);
+            _iter237.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -49615,13 +50596,13 @@ public class ThriftHiveMetastore {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list234 = iprot.readListBegin();
-                this.success = new ArrayList<String>(_list234.size);
-                for (int _i235 = 0; _i235 < _list234.size; ++_i235)
+                TList _list238 = iprot.readListBegin();
+                this.success = new ArrayList<String>(_list238.size);
+                for (int _i239 = 0; _i239 < _list238.size; ++_i239)
                 {
-                  String _elem236;
-                  _elem236 = iprot.readString();
-                  this.success.add(_elem236);
+                  String _elem240;
+                  _elem240 = iprot.readString();
+                  this.success.add(_elem240);
                 }
                 iprot.readListEnd();
               }
@@ -49653,9 +50634,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.success.size()));
-          for (String _iter237 : this.success)
+          for (String _iter241 : this.success)
           {
-            oprot.writeString(_iter237);
+            oprot.writeString(_iter241);
           }
           oprot.writeListEnd();
         }
@@ -51488,13 +52469,13 @@ public class ThriftHiveMetastore {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list238 = iprot.readListBegin();
-                this.success = new ArrayList<String>(_list238.size);
-                for (int _i239 = 0; _i239 < _list238.size; ++_i239)
+                TList _list242 = iprot.readListBegin();
+                this.success = new ArrayList<String>(_list242.size);
+                for (int _i243 = 0; _i243 < _list242.size; ++_i243)
                 {
-                  String _elem240;
-                  _elem240 = iprot.readString();
-                  this.success.add(_elem240);
+                  String _elem244;
+                  _elem244 = iprot.readString();
+                  this.success.add(_elem244);
                 }
                 iprot.readListEnd();
               }
@@ -51526,9 +52507,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.success.size()));
-          for (String _iter241 : this.success)
+          for (String _iter245 : this.success)
           {
-            oprot.writeString(_iter241);
+            oprot.writeString(_iter245);
           }
           oprot.writeListEnd();
         }
@@ -54204,14 +55185,14 @@ public class ThriftHiveMetastore {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list242 = iprot.readListBegin();
-                this.success = new ArrayList<Role>(_list242.size);
-                for (int _i243 = 0; _i243 < _list242.size; ++_i243)
+                TList _list246 = iprot.readListBegin();
+                this.success = new ArrayList<Role>(_list246.size);
+                for (int _i247 = 0; _i247 < _list246.size; ++_i247)
                 {
-                  Role _elem244;
-                  _elem244 = new Role();
-                  _elem244.read(iprot);
-                  this.success.add(_elem244);
+                  Role _elem248;
+                  _elem248 = new Role();
+                  _elem248.read(iprot);
+                  this.success.add(_elem248);
                 }
                 iprot.readListEnd();
               }
@@ -54243,9 +55224,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (Role _iter245 : this.success)
+          for (Role _iter249 : this.success)
           {
-            _iter245.write(oprot);
+            _iter249.write(oprot);
           }
           oprot.writeListEnd();
         }
@@ -54690,13 +55671,13 @@ public class ThriftHiveMetastore {
           case 3: // GROUP_NAMES
             if (field.type == TType.LIST) {
               {
-                TList _list246 = iprot.readListBegin();
-                this.group_names = new ArrayList<String>(_list246.size);
-                for (int _i247 = 0; _i247 < _list246.size; ++_i247)
+                TList _list250 = iprot.readListBegin();
+                this.group_names = new ArrayList<String>(_list250.size);
+                for (int _i251 = 0; _i251 < _list250.size; ++_i251)
                 {
-                  String _elem248;
-                  _elem248 = iprot.readString();
-                  this.group_names.add(_elem248);
+                  String _elem252;
+                  _elem252 = iprot.readString();
+                  this.group_names.add(_elem252);
                 }
                 iprot.readListEnd();
               }
@@ -54731,9 +55712,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(GROUP_NAMES_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRING, this.group_names.size()));
-          for (String _iter249 : this.group_names)
+          for (String _iter253 : this.group_names)
           {
-            oprot.writeString(_iter249);
+            oprot.writeString(_iter253);
           }
           oprot.writeListEnd();
         }
@@ -55932,14 +56913,14 @@ public class ThriftHiveMetastore {
           case 0: // SUCCESS
             if (field.type == TType.LIST) {
               {
-                TList _list250 = iprot.readListBegin();
-                this.success = new ArrayList<HiveObjectPrivilege>(_list250.size);
-                for (int _i251 = 0; _i251 < _list250.size; ++_i251)
+                TList _list254 = iprot.readListBegin();
+                this.success = new ArrayList<HiveObjectPrivilege>(_list254.size);
+                for (int _i255 = 0; _i255 < _list254.size; ++_i255)
                 {
-                  HiveObjectPrivilege _elem252;
-                  _elem252 = new HiveObjectPrivilege();
-                  _elem252.read(iprot);
-                  this.success.add(_elem252);
+                  HiveObjectPrivilege _elem256;
+                  _elem256 = new HiveObjectPrivilege();
+                  _elem256.read(iprot);
+                  this.success.add(_elem256);
                 }
                 iprot.readListEnd();
               }
@@ -55971,9 +56952,9 @@ public class ThriftHiveMetastore {
         oprot.writeFieldBegin(SUCCESS_FIELD_DESC);
         {
           oprot.writeListBegin(new TList(TType.STRUCT, this.success.size()));
-          for (HiveObjectPrivilege _iter253 : this.success)
+          for (HiveObjectPrivilege _iter257 : this.success)
           {
-            _iter253.write(oprot);
+            _iter257.write(oprot);
           }
           oprot.writeListEnd();
         }



Mime
View raw message