svn commit: r1057999 [3/22] - in /hive/trunk: ./ common/src/java/org/apache/hadoop/hive/conf/ conf/ metastore/if/ metastore/src/gen/thrift/gen-cpp/ metastore/src/gen/thrift/gen-javabean/org/apache/hadoop/hive/metastore/api/ metastore/src/gen/thrift/gen...

[na...@apache.org]

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=1057999&r1=1057998&r2=1057999&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h Wed Jan 12 06:58:04 2011
@@ -39,10 +39,13 @@ class ThriftHiveMetastoreIf : virtual pu
   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;
   virtual bool drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData) = 0;
   virtual void get_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals) = 0;
+  virtual void get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const std::string& user_name, const std::vector<std::string> & group_names) = 0;
   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_partitions_with_auth(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector<std::string> & group_names) = 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_partitions_ps_with_auth(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, const std::string& user_name, const std::vector<std::string> & group_names) = 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 get_partitions_by_filter(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, 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;
@@ -55,6 +58,15 @@ class ThriftHiveMetastoreIf : virtual pu
   virtual void get_index_by_name(Index& _return, const std::string& db_name, const std::string& tbl_name, const std::string& index_name) = 0;
   virtual void get_indexes(std::vector<Index> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_indexes) = 0;
   virtual void get_index_names(std::vector<std::string> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_indexes) = 0;
+  virtual bool create_role(const Role& role) = 0;
+  virtual bool drop_role(const std::string& role_name) = 0;
+  virtual bool grant_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type, const std::string& grantor, const PrincipalType::type grantorType, const bool grant_option) = 0;
+  virtual bool revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type) = 0;
+  virtual void list_roles(std::vector<Role> & _return, const std::string& principal_name, const PrincipalType::type principal_type) = 0;
+  virtual void get_privilege_set(PrincipalPrivilegeSet& _return, const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector<std::string> & group_names) = 0;
+  virtual void list_privileges(std::vector<HiveObjectPrivilege> & _return, const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject) = 0;
+  virtual bool grant_privileges(const PrivilegeBag& privileges) = 0;
+  virtual bool revoke_privileges(const PrivilegeBag& privileges) = 0;
 };
 
 class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual public facebook::fb303::FacebookServiceNull {
@@ -136,18 +148,27 @@ class ThriftHiveMetastoreNull : virtual 
   void get_partition(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector<std::string> & /* part_vals */) {
     return;
   }
+  void get_partition_with_auth(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector<std::string> & /* part_vals */, const std::string& /* user_name */, const std::vector<std::string> & /* group_names */) {
+    return;
+  }
   void get_partition_by_name(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* part_name */) {
     return;
   }
   void get_partitions(std::vector<Partition> & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const int16_t /* max_parts */) {
     return;
   }
+  void get_partitions_with_auth(std::vector<Partition> & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const int16_t /* max_parts */, const std::string& /* user_name */, const std::vector<std::string> & /* group_names */) {
+    return;
+  }
   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_partitions_ps_with_auth(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 */, const std::string& /* user_name */, const std::vector<std::string> & /* group_names */) {
+    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;
   }
@@ -185,6 +206,39 @@ class ThriftHiveMetastoreNull : virtual 
   void get_index_names(std::vector<std::string> & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const int16_t /* max_indexes */) {
     return;
   }
+  bool create_role(const Role& /* role */) {
+    bool _return = false;
+    return _return;
+  }
+  bool drop_role(const std::string& /* role_name */) {
+    bool _return = false;
+    return _return;
+  }
+  bool grant_role(const std::string& /* role_name */, const std::string& /* principal_name */, const PrincipalType::type /* principal_type */, const std::string& /* grantor */, const PrincipalType::type /* grantorType */, const bool /* grant_option */) {
+    bool _return = false;
+    return _return;
+  }
+  bool revoke_role(const std::string& /* role_name */, const std::string& /* principal_name */, const PrincipalType::type /* principal_type */) {
+    bool _return = false;
+    return _return;
+  }
+  void list_roles(std::vector<Role> & /* _return */, const std::string& /* principal_name */, const PrincipalType::type /* principal_type */) {
+    return;
+  }
+  void get_privilege_set(PrincipalPrivilegeSet& /* _return */, const HiveObjectRef& /* hiveObject */, const std::string& /* user_name */, const std::vector<std::string> & /* group_names */) {
+    return;
+  }
+  void list_privileges(std::vector<HiveObjectPrivilege> & /* _return */, const std::string& /* principal_name */, const PrincipalType::type /* principal_type */, const HiveObjectRef& /* hiveObject */) {
+    return;
+  }
+  bool grant_privileges(const PrivilegeBag& /* privileges */) {
+    bool _return = false;
+    return _return;
+  }
+  bool revoke_privileges(const PrivilegeBag& /* privileges */) {
+    bool _return = false;
+    return _return;
+  }
 };
 
 typedef struct _ThriftHiveMetastore_create_database_args__isset {
@@ -2969,6 +3023,138 @@ class ThriftHiveMetastore_get_partition_
 
 };
 
+typedef struct _ThriftHiveMetastore_get_partition_with_auth_args__isset {
+  _ThriftHiveMetastore_get_partition_with_auth_args__isset() : db_name(false), tbl_name(false), part_vals(false), user_name(false), group_names(false) {}
+  bool db_name;
+  bool tbl_name;
+  bool part_vals;
+  bool user_name;
+  bool group_names;
+} _ThriftHiveMetastore_get_partition_with_auth_args__isset;
+
+class ThriftHiveMetastore_get_partition_with_auth_args {
+ public:
+
+  ThriftHiveMetastore_get_partition_with_auth_args() : db_name(""), tbl_name(""), user_name("") {
+  }
+
+  virtual ~ThriftHiveMetastore_get_partition_with_auth_args() throw() {}
+
+  std::string db_name;
+  std::string tbl_name;
+  std::vector<std::string>  part_vals;
+  std::string user_name;
+  std::vector<std::string>  group_names;
+
+  _ThriftHiveMetastore_get_partition_with_auth_args__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_get_partition_with_auth_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 (!(user_name == rhs.user_name))
+      return false;
+    if (!(group_names == rhs.group_names))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_partition_with_auth_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_partition_with_auth_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_partition_with_auth_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_partition_with_auth_pargs() throw() {}
+
+  const std::string* db_name;
+  const std::string* tbl_name;
+  const std::vector<std::string> * part_vals;
+  const std::string* user_name;
+  const std::vector<std::string> * group_names;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_partition_with_auth_result__isset {
+  _ThriftHiveMetastore_get_partition_with_auth_result__isset() : success(false), o1(false), o2(false) {}
+  bool success;
+  bool o1;
+  bool o2;
+} _ThriftHiveMetastore_get_partition_with_auth_result__isset;
+
+class ThriftHiveMetastore_get_partition_with_auth_result {
+ public:
+
+  ThriftHiveMetastore_get_partition_with_auth_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_get_partition_with_auth_result() throw() {}
+
+  Partition success;
+  MetaException o1;
+  NoSuchObjectException o2;
+
+  _ThriftHiveMetastore_get_partition_with_auth_result__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_get_partition_with_auth_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(o1 == rhs.o1))
+      return false;
+    if (!(o2 == rhs.o2))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_partition_with_auth_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_partition_with_auth_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_partition_with_auth_presult__isset {
+  _ThriftHiveMetastore_get_partition_with_auth_presult__isset() : success(false), o1(false), o2(false) {}
+  bool success;
+  bool o1;
+  bool o2;
+} _ThriftHiveMetastore_get_partition_with_auth_presult__isset;
+
+class ThriftHiveMetastore_get_partition_with_auth_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_partition_with_auth_presult() throw() {}
+
+  Partition* success;
+  MetaException o1;
+  NoSuchObjectException o2;
+
+  _ThriftHiveMetastore_get_partition_with_auth_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
 typedef struct _ThriftHiveMetastore_get_partition_by_name_args__isset {
   _ThriftHiveMetastore_get_partition_by_name_args__isset() : db_name(false), tbl_name(false), part_name(false) {}
   bool db_name;
@@ -3213,6 +3399,138 @@ class ThriftHiveMetastore_get_partitions
 
 };
 
+typedef struct _ThriftHiveMetastore_get_partitions_with_auth_args__isset {
+  _ThriftHiveMetastore_get_partitions_with_auth_args__isset() : db_name(false), tbl_name(false), max_parts(false), user_name(false), group_names(false) {}
+  bool db_name;
+  bool tbl_name;
+  bool max_parts;
+  bool user_name;
+  bool group_names;
+} _ThriftHiveMetastore_get_partitions_with_auth_args__isset;
+
+class ThriftHiveMetastore_get_partitions_with_auth_args {
+ public:
+
+  ThriftHiveMetastore_get_partitions_with_auth_args() : db_name(""), tbl_name(""), max_parts(-1), user_name("") {
+  }
+
+  virtual ~ThriftHiveMetastore_get_partitions_with_auth_args() throw() {}
+
+  std::string db_name;
+  std::string tbl_name;
+  int16_t max_parts;
+  std::string user_name;
+  std::vector<std::string>  group_names;
+
+  _ThriftHiveMetastore_get_partitions_with_auth_args__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_get_partitions_with_auth_args & rhs) const
+  {
+    if (!(db_name == rhs.db_name))
+      return false;
+    if (!(tbl_name == rhs.tbl_name))
+      return false;
+    if (!(max_parts == rhs.max_parts))
+      return false;
+    if (!(user_name == rhs.user_name))
+      return false;
+    if (!(group_names == rhs.group_names))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_partitions_with_auth_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_partitions_with_auth_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_partitions_with_auth_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_partitions_with_auth_pargs() throw() {}
+
+  const std::string* db_name;
+  const std::string* tbl_name;
+  const int16_t* max_parts;
+  const std::string* user_name;
+  const std::vector<std::string> * group_names;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_partitions_with_auth_result__isset {
+  _ThriftHiveMetastore_get_partitions_with_auth_result__isset() : success(false), o1(false), o2(false) {}
+  bool success;
+  bool o1;
+  bool o2;
+} _ThriftHiveMetastore_get_partitions_with_auth_result__isset;
+
+class ThriftHiveMetastore_get_partitions_with_auth_result {
+ public:
+
+  ThriftHiveMetastore_get_partitions_with_auth_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_get_partitions_with_auth_result() throw() {}
+
+  std::vector<Partition>  success;
+  NoSuchObjectException o1;
+  MetaException o2;
+
+  _ThriftHiveMetastore_get_partitions_with_auth_result__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_get_partitions_with_auth_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(o1 == rhs.o1))
+      return false;
+    if (!(o2 == rhs.o2))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_partitions_with_auth_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_partitions_with_auth_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_partitions_with_auth_presult__isset {
+  _ThriftHiveMetastore_get_partitions_with_auth_presult__isset() : success(false), o1(false), o2(false) {}
+  bool success;
+  bool o1;
+  bool o2;
+} _ThriftHiveMetastore_get_partitions_with_auth_presult__isset;
+
+class ThriftHiveMetastore_get_partitions_with_auth_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_partitions_with_auth_presult() throw() {}
+
+  std::vector<Partition> * success;
+  NoSuchObjectException o1;
+  MetaException o2;
+
+  _ThriftHiveMetastore_get_partitions_with_auth_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
 typedef struct _ThriftHiveMetastore_get_partition_names_args__isset {
   _ThriftHiveMetastore_get_partition_names_args__isset() : db_name(false), tbl_name(false), max_parts(false) {}
   bool db_name;
@@ -3450,30 +3768,34 @@ class ThriftHiveMetastore_get_partitions
 
 };
 
-typedef struct _ThriftHiveMetastore_get_partition_names_ps_args__isset {
-  _ThriftHiveMetastore_get_partition_names_ps_args__isset() : db_name(false), tbl_name(false), part_vals(false), max_parts(false) {}
+typedef struct _ThriftHiveMetastore_get_partitions_ps_with_auth_args__isset {
+  _ThriftHiveMetastore_get_partitions_ps_with_auth_args__isset() : db_name(false), tbl_name(false), part_vals(false), max_parts(false), user_name(false), group_names(false) {}
   bool db_name;
   bool tbl_name;
   bool part_vals;
   bool max_parts;
-} _ThriftHiveMetastore_get_partition_names_ps_args__isset;
+  bool user_name;
+  bool group_names;
+} _ThriftHiveMetastore_get_partitions_ps_with_auth_args__isset;
 
-class ThriftHiveMetastore_get_partition_names_ps_args {
+class ThriftHiveMetastore_get_partitions_ps_with_auth_args {
  public:
 
-  ThriftHiveMetastore_get_partition_names_ps_args() : db_name(""), tbl_name(""), max_parts(-1) {
+  ThriftHiveMetastore_get_partitions_ps_with_auth_args() : db_name(""), tbl_name(""), max_parts(-1), user_name("") {
   }
 
-  virtual ~ThriftHiveMetastore_get_partition_names_ps_args() throw() {}
+  virtual ~ThriftHiveMetastore_get_partitions_ps_with_auth_args() throw() {}
 
   std::string db_name;
   std::string tbl_name;
   std::vector<std::string>  part_vals;
   int16_t max_parts;
+  std::string user_name;
+  std::vector<std::string>  group_names;
 
-  _ThriftHiveMetastore_get_partition_names_ps_args__isset __isset;
+  _ThriftHiveMetastore_get_partitions_ps_with_auth_args__isset __isset;
 
-  bool operator == (const ThriftHiveMetastore_get_partition_names_ps_args & rhs) const
+  bool operator == (const ThriftHiveMetastore_get_partitions_ps_with_auth_args & rhs) const
   {
     if (!(db_name == rhs.db_name))
       return false;
@@ -3483,13 +3805,17 @@ class ThriftHiveMetastore_get_partition_
       return false;
     if (!(max_parts == rhs.max_parts))
       return false;
+    if (!(user_name == rhs.user_name))
+      return false;
+    if (!(group_names == rhs.group_names))
+      return false;
     return true;
   }
-  bool operator != (const ThriftHiveMetastore_get_partition_names_ps_args &rhs) const {
+  bool operator != (const ThriftHiveMetastore_get_partitions_ps_with_auth_args &rhs) const {
     return !(*this == rhs);
   }
 
-  bool operator < (const ThriftHiveMetastore_get_partition_names_ps_args & ) const;
+  bool operator < (const ThriftHiveMetastore_get_partitions_ps_with_auth_args & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
@@ -3497,61 +3823,190 @@ class ThriftHiveMetastore_get_partition_
 };
 
 
-class ThriftHiveMetastore_get_partition_names_ps_pargs {
+class ThriftHiveMetastore_get_partitions_ps_with_auth_pargs {
  public:
 
 
-  virtual ~ThriftHiveMetastore_get_partition_names_ps_pargs() throw() {}
+  virtual ~ThriftHiveMetastore_get_partitions_ps_with_auth_pargs() throw() {}
 
   const std::string* db_name;
   const std::string* tbl_name;
   const std::vector<std::string> * part_vals;
   const int16_t* max_parts;
+  const std::string* user_name;
+  const std::vector<std::string> * group_names;
 
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
-typedef struct _ThriftHiveMetastore_get_partition_names_ps_result__isset {
-  _ThriftHiveMetastore_get_partition_names_ps_result__isset() : success(false), o1(false) {}
+typedef struct _ThriftHiveMetastore_get_partitions_ps_with_auth_result__isset {
+  _ThriftHiveMetastore_get_partitions_ps_with_auth_result__isset() : success(false), o1(false), o2(false) {}
   bool success;
   bool o1;
-} _ThriftHiveMetastore_get_partition_names_ps_result__isset;
+  bool o2;
+} _ThriftHiveMetastore_get_partitions_ps_with_auth_result__isset;
 
-class ThriftHiveMetastore_get_partition_names_ps_result {
+class ThriftHiveMetastore_get_partitions_ps_with_auth_result {
  public:
 
-  ThriftHiveMetastore_get_partition_names_ps_result() {
+  ThriftHiveMetastore_get_partitions_ps_with_auth_result() {
   }
 
-  virtual ~ThriftHiveMetastore_get_partition_names_ps_result() throw() {}
+  virtual ~ThriftHiveMetastore_get_partitions_ps_with_auth_result() throw() {}
 
-  std::vector<std::string>  success;
-  MetaException o1;
+  std::vector<Partition>  success;
+  NoSuchObjectException o1;
+  MetaException o2;
 
-  _ThriftHiveMetastore_get_partition_names_ps_result__isset __isset;
+  _ThriftHiveMetastore_get_partitions_ps_with_auth_result__isset __isset;
 
-  bool operator == (const ThriftHiveMetastore_get_partition_names_ps_result & rhs) const
+  bool operator == (const ThriftHiveMetastore_get_partitions_ps_with_auth_result & rhs) const
   {
     if (!(success == rhs.success))
       return false;
     if (!(o1 == rhs.o1))
       return false;
+    if (!(o2 == rhs.o2))
+      return false;
     return true;
   }
-  bool operator != (const ThriftHiveMetastore_get_partition_names_ps_result &rhs) const {
+  bool operator != (const ThriftHiveMetastore_get_partitions_ps_with_auth_result &rhs) const {
     return !(*this == rhs);
   }
 
-  bool operator < (const ThriftHiveMetastore_get_partition_names_ps_result & ) const;
+  bool operator < (const ThriftHiveMetastore_get_partitions_ps_with_auth_result & ) const;
 
   uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
   uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
 
 };
 
-typedef struct _ThriftHiveMetastore_get_partition_names_ps_presult__isset {
-  _ThriftHiveMetastore_get_partition_names_ps_presult__isset() : success(false), o1(false) {}
+typedef struct _ThriftHiveMetastore_get_partitions_ps_with_auth_presult__isset {
+  _ThriftHiveMetastore_get_partitions_ps_with_auth_presult__isset() : success(false), o1(false), o2(false) {}
+  bool success;
+  bool o1;
+  bool o2;
+} _ThriftHiveMetastore_get_partitions_ps_with_auth_presult__isset;
+
+class ThriftHiveMetastore_get_partitions_ps_with_auth_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_partitions_ps_with_auth_presult() throw() {}
+
+  std::vector<Partition> * success;
+  NoSuchObjectException o1;
+  MetaException o2;
+
+  _ThriftHiveMetastore_get_partitions_ps_with_auth_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_get_partition_names_ps_args__isset {
+  _ThriftHiveMetastore_get_partition_names_ps_args__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;
+} _ThriftHiveMetastore_get_partition_names_ps_args__isset;
+
+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;
+
+  _ThriftHiveMetastore_get_partition_names_ps_args__isset __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;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_partition_names_ps_result__isset {
+  _ThriftHiveMetastore_get_partition_names_ps_result__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_get_partition_names_ps_result__isset;
+
+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;
+
+  _ThriftHiveMetastore_get_partition_names_ps_result__isset __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;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_partition_names_ps_presult__isset {
+  _ThriftHiveMetastore_get_partition_names_ps_presult__isset() : success(false), o1(false) {}
   bool success;
   bool o1;
 } _ThriftHiveMetastore_get_partition_names_ps_presult__isset;
@@ -4868,144 +5323,1194 @@ class ThriftHiveMetastore_get_index_name
 
 };
 
-class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public facebook::fb303::FacebookServiceClient {
+typedef struct _ThriftHiveMetastore_create_role_args__isset {
+  _ThriftHiveMetastore_create_role_args__isset() : role(false) {}
+  bool role;
+} _ThriftHiveMetastore_create_role_args__isset;
+
+class ThriftHiveMetastore_create_role_args {
  public:
-  ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
-    facebook::fb303::FacebookServiceClient(prot, prot) {}
-  ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :
-    facebook::fb303::FacebookServiceClient(iprot, oprot) {}
-  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
-    return piprot_;
-  }
-  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
-    return poprot_;
+
+  ThriftHiveMetastore_create_role_args() {
   }
-  void create_database(const Database& database);
-  void send_create_database(const Database& database);
-  void recv_create_database();
-  void get_database(Database& _return, const std::string& name);
-  void send_get_database(const std::string& name);
-  void recv_get_database(Database& _return);
-  void drop_database(const std::string& name, const bool deleteData);
-  void send_drop_database(const std::string& name, const bool deleteData);
-  void recv_drop_database();
-  void get_databases(std::vector<std::string> & _return, const std::string& pattern);
-  void send_get_databases(const std::string& pattern);
-  void recv_get_databases(std::vector<std::string> & _return);
-  void get_all_databases(std::vector<std::string> & _return);
-  void send_get_all_databases();
-  void recv_get_all_databases(std::vector<std::string> & _return);
-  void alter_database(const std::string& dbname, const Database& db);
-  void send_alter_database(const std::string& dbname, const Database& db);
-  void recv_alter_database();
-  void get_type(Type& _return, const std::string& name);
-  void send_get_type(const std::string& name);
-  void recv_get_type(Type& _return);
-  bool create_type(const Type& type);
-  void send_create_type(const Type& type);
-  bool recv_create_type();
-  bool drop_type(const std::string& type);
-  void send_drop_type(const std::string& type);
-  bool recv_drop_type();
-  void get_type_all(std::map<std::string, Type> & _return, const std::string& name);
-  void send_get_type_all(const std::string& name);
-  void recv_get_type_all(std::map<std::string, Type> & _return);
-  void get_fields(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name);
-  void send_get_fields(const std::string& db_name, const std::string& table_name);
-  void recv_get_fields(std::vector<FieldSchema> & _return);
-  void get_schema(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name);
-  void send_get_schema(const std::string& db_name, const std::string& table_name);
-  void recv_get_schema(std::vector<FieldSchema> & _return);
-  void create_table(const Table& tbl);
-  void send_create_table(const Table& tbl);
-  void recv_create_table();
-  void drop_table(const std::string& dbname, const std::string& name, const bool deleteData);
-  void send_drop_table(const std::string& dbname, const std::string& name, const bool deleteData);
-  void recv_drop_table();
-  void get_tables(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern);
-  void send_get_tables(const std::string& db_name, const std::string& pattern);
-  void recv_get_tables(std::vector<std::string> & _return);
-  void get_all_tables(std::vector<std::string> & _return, const std::string& db_name);
-  void send_get_all_tables(const std::string& db_name);
-  void recv_get_all_tables(std::vector<std::string> & _return);
-  void get_table(Table& _return, const std::string& dbname, const std::string& tbl_name);
-  void send_get_table(const std::string& dbname, const std::string& tbl_name);
-  void recv_get_table(Table& _return);
-  void alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl);
-  void send_alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl);
-  void recv_alter_table();
-  void add_partition(Partition& _return, const Partition& new_part);
-  void send_add_partition(const Partition& new_part);
-  void recv_add_partition(Partition& _return);
-  void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals);
-  void send_append_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals);
-  void recv_append_partition(Partition& _return);
-  void append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name);
-  void send_append_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name);
-  void recv_append_partition_by_name(Partition& _return);
-  bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const bool deleteData);
-  void send_drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const bool deleteData);
-  bool recv_drop_partition();
-  bool drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData);
-  void send_drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData);
-  bool recv_drop_partition_by_name();
-  void get_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals);
-  void send_get_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals);
-  void recv_get_partition(Partition& _return);
-  void get_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name);
-  void send_get_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name);
-  void recv_get_partition_by_name(Partition& _return);
-  void get_partitions(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts);
-  void send_get_partitions(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts);
-  void recv_get_partitions(std::vector<Partition> & _return);
-  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 get_partitions_by_filter(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts);
-  void send_get_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts);
-  void recv_get_partitions_by_filter(std::vector<Partition> & _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();
-  void get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue);
-  void send_get_config_value(const std::string& name, const std::string& defaultValue);
-  void recv_get_config_value(std::string& _return);
-  void partition_name_to_vals(std::vector<std::string> & _return, const std::string& part_name);
-  void send_partition_name_to_vals(const std::string& part_name);
-  void recv_partition_name_to_vals(std::vector<std::string> & _return);
-  void partition_name_to_spec(std::map<std::string, std::string> & _return, const std::string& part_name);
-  void send_partition_name_to_spec(const std::string& part_name);
-  void recv_partition_name_to_spec(std::map<std::string, std::string> & _return);
-  void add_index(Index& _return, const Index& new_index, const Table& index_table);
-  void send_add_index(const Index& new_index, const Table& index_table);
-  void recv_add_index(Index& _return);
-  void alter_index(const std::string& dbname, const std::string& base_tbl_name, const std::string& idx_name, const Index& new_idx);
-  void send_alter_index(const std::string& dbname, const std::string& base_tbl_name, const std::string& idx_name, const Index& new_idx);
-  void recv_alter_index();
-  bool drop_index_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& index_name, const bool deleteData);
-  void send_drop_index_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& index_name, const bool deleteData);
-  bool recv_drop_index_by_name();
-  void get_index_by_name(Index& _return, const std::string& db_name, const std::string& tbl_name, const std::string& index_name);
-  void send_get_index_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& index_name);
-  void recv_get_index_by_name(Index& _return);
-  void get_indexes(std::vector<Index> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_indexes);
-  void send_get_indexes(const std::string& db_name, const std::string& tbl_name, const int16_t max_indexes);
-  void recv_get_indexes(std::vector<Index> & _return);
-  void get_index_names(std::vector<std::string> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_indexes);
-  void send_get_index_names(const std::string& db_name, const std::string& tbl_name, const int16_t max_indexes);
-  void recv_get_index_names(std::vector<std::string> & _return);
-};
 
-class ThriftHiveMetastoreProcessor : virtual public ::apache::thrift::TProcessor, public facebook::fb303::FacebookServiceProcessor {
- protected:
-  boost::shared_ptr<ThriftHiveMetastoreIf> iface_;
-  virtual bool process_fn(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid);
+  virtual ~ThriftHiveMetastore_create_role_args() throw() {}
+
+  Role role;
+
+  _ThriftHiveMetastore_create_role_args__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_create_role_args & rhs) const
+  {
+    if (!(role == rhs.role))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_create_role_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_create_role_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_create_role_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_create_role_pargs() throw() {}
+
+  const Role* role;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_create_role_result__isset {
+  _ThriftHiveMetastore_create_role_result__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_create_role_result__isset;
+
+class ThriftHiveMetastore_create_role_result {
+ public:
+
+  ThriftHiveMetastore_create_role_result() : success(0) {
+  }
+
+  virtual ~ThriftHiveMetastore_create_role_result() throw() {}
+
+  bool success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_create_role_result__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_create_role_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(o1 == rhs.o1))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_create_role_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_create_role_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_create_role_presult__isset {
+  _ThriftHiveMetastore_create_role_presult__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_create_role_presult__isset;
+
+class ThriftHiveMetastore_create_role_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_create_role_presult() throw() {}
+
+  bool* success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_create_role_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_drop_role_args__isset {
+  _ThriftHiveMetastore_drop_role_args__isset() : role_name(false) {}
+  bool role_name;
+} _ThriftHiveMetastore_drop_role_args__isset;
+
+class ThriftHiveMetastore_drop_role_args {
+ public:
+
+  ThriftHiveMetastore_drop_role_args() : role_name("") {
+  }
+
+  virtual ~ThriftHiveMetastore_drop_role_args() throw() {}
+
+  std::string role_name;
+
+  _ThriftHiveMetastore_drop_role_args__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_drop_role_args & rhs) const
+  {
+    if (!(role_name == rhs.role_name))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_drop_role_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_drop_role_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_drop_role_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_drop_role_pargs() throw() {}
+
+  const std::string* role_name;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_drop_role_result__isset {
+  _ThriftHiveMetastore_drop_role_result__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_drop_role_result__isset;
+
+class ThriftHiveMetastore_drop_role_result {
+ public:
+
+  ThriftHiveMetastore_drop_role_result() : success(0) {
+  }
+
+  virtual ~ThriftHiveMetastore_drop_role_result() throw() {}
+
+  bool success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_drop_role_result__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_drop_role_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(o1 == rhs.o1))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_drop_role_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_drop_role_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_drop_role_presult__isset {
+  _ThriftHiveMetastore_drop_role_presult__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_drop_role_presult__isset;
+
+class ThriftHiveMetastore_drop_role_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_drop_role_presult() throw() {}
+
+  bool* success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_drop_role_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_grant_role_args__isset {
+  _ThriftHiveMetastore_grant_role_args__isset() : role_name(false), principal_name(false), principal_type(false), grantor(false), grantorType(false), grant_option(false) {}
+  bool role_name;
+  bool principal_name;
+  bool principal_type;
+  bool grantor;
+  bool grantorType;
+  bool grant_option;
+} _ThriftHiveMetastore_grant_role_args__isset;
+
+class ThriftHiveMetastore_grant_role_args {
+ public:
+
+  ThriftHiveMetastore_grant_role_args() : role_name(""), principal_name(""), grantor(""), grant_option(0) {
+  }
+
+  virtual ~ThriftHiveMetastore_grant_role_args() throw() {}
+
+  std::string role_name;
+  std::string principal_name;
+  PrincipalType::type principal_type;
+  std::string grantor;
+  PrincipalType::type grantorType;
+  bool grant_option;
+
+  _ThriftHiveMetastore_grant_role_args__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_grant_role_args & rhs) const
+  {
+    if (!(role_name == rhs.role_name))
+      return false;
+    if (!(principal_name == rhs.principal_name))
+      return false;
+    if (!(principal_type == rhs.principal_type))
+      return false;
+    if (!(grantor == rhs.grantor))
+      return false;
+    if (!(grantorType == rhs.grantorType))
+      return false;
+    if (!(grant_option == rhs.grant_option))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_grant_role_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_grant_role_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_grant_role_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_grant_role_pargs() throw() {}
+
+  const std::string* role_name;
+  const std::string* principal_name;
+  const PrincipalType::type* principal_type;
+  const std::string* grantor;
+  const PrincipalType::type* grantorType;
+  const bool* grant_option;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_grant_role_result__isset {
+  _ThriftHiveMetastore_grant_role_result__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_grant_role_result__isset;
+
+class ThriftHiveMetastore_grant_role_result {
+ public:
+
+  ThriftHiveMetastore_grant_role_result() : success(0) {
+  }
+
+  virtual ~ThriftHiveMetastore_grant_role_result() throw() {}
+
+  bool success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_grant_role_result__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_grant_role_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(o1 == rhs.o1))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_grant_role_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_grant_role_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_grant_role_presult__isset {
+  _ThriftHiveMetastore_grant_role_presult__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_grant_role_presult__isset;
+
+class ThriftHiveMetastore_grant_role_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_grant_role_presult() throw() {}
+
+  bool* success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_grant_role_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_revoke_role_args__isset {
+  _ThriftHiveMetastore_revoke_role_args__isset() : role_name(false), principal_name(false), principal_type(false) {}
+  bool role_name;
+  bool principal_name;
+  bool principal_type;
+} _ThriftHiveMetastore_revoke_role_args__isset;
+
+class ThriftHiveMetastore_revoke_role_args {
+ public:
+
+  ThriftHiveMetastore_revoke_role_args() : role_name(""), principal_name("") {
+  }
+
+  virtual ~ThriftHiveMetastore_revoke_role_args() throw() {}
+
+  std::string role_name;
+  std::string principal_name;
+  PrincipalType::type principal_type;
+
+  _ThriftHiveMetastore_revoke_role_args__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_revoke_role_args & rhs) const
+  {
+    if (!(role_name == rhs.role_name))
+      return false;
+    if (!(principal_name == rhs.principal_name))
+      return false;
+    if (!(principal_type == rhs.principal_type))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_revoke_role_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_revoke_role_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_revoke_role_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_revoke_role_pargs() throw() {}
+
+  const std::string* role_name;
+  const std::string* principal_name;
+  const PrincipalType::type* principal_type;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_revoke_role_result__isset {
+  _ThriftHiveMetastore_revoke_role_result__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_revoke_role_result__isset;
+
+class ThriftHiveMetastore_revoke_role_result {
+ public:
+
+  ThriftHiveMetastore_revoke_role_result() : success(0) {
+  }
+
+  virtual ~ThriftHiveMetastore_revoke_role_result() throw() {}
+
+  bool success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_revoke_role_result__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_revoke_role_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(o1 == rhs.o1))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_revoke_role_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_revoke_role_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_revoke_role_presult__isset {
+  _ThriftHiveMetastore_revoke_role_presult__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_revoke_role_presult__isset;
+
+class ThriftHiveMetastore_revoke_role_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_revoke_role_presult() throw() {}
+
+  bool* success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_revoke_role_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_list_roles_args__isset {
+  _ThriftHiveMetastore_list_roles_args__isset() : principal_name(false), principal_type(false) {}
+  bool principal_name;
+  bool principal_type;
+} _ThriftHiveMetastore_list_roles_args__isset;
+
+class ThriftHiveMetastore_list_roles_args {
+ public:
+
+  ThriftHiveMetastore_list_roles_args() : principal_name("") {
+  }
+
+  virtual ~ThriftHiveMetastore_list_roles_args() throw() {}
+
+  std::string principal_name;
+  PrincipalType::type principal_type;
+
+  _ThriftHiveMetastore_list_roles_args__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_list_roles_args & rhs) const
+  {
+    if (!(principal_name == rhs.principal_name))
+      return false;
+    if (!(principal_type == rhs.principal_type))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_list_roles_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_list_roles_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_list_roles_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_list_roles_pargs() throw() {}
+
+  const std::string* principal_name;
+  const PrincipalType::type* principal_type;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_list_roles_result__isset {
+  _ThriftHiveMetastore_list_roles_result__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_list_roles_result__isset;
+
+class ThriftHiveMetastore_list_roles_result {
+ public:
+
+  ThriftHiveMetastore_list_roles_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_list_roles_result() throw() {}
+
+  std::vector<Role>  success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_list_roles_result__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_list_roles_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(o1 == rhs.o1))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_list_roles_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_list_roles_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_list_roles_presult__isset {
+  _ThriftHiveMetastore_list_roles_presult__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_list_roles_presult__isset;
+
+class ThriftHiveMetastore_list_roles_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_list_roles_presult() throw() {}
+
+  std::vector<Role> * success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_list_roles_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_get_privilege_set_args__isset {
+  _ThriftHiveMetastore_get_privilege_set_args__isset() : hiveObject(false), user_name(false), group_names(false) {}
+  bool hiveObject;
+  bool user_name;
+  bool group_names;
+} _ThriftHiveMetastore_get_privilege_set_args__isset;
+
+class ThriftHiveMetastore_get_privilege_set_args {
+ public:
+
+  ThriftHiveMetastore_get_privilege_set_args() : user_name("") {
+  }
+
+  virtual ~ThriftHiveMetastore_get_privilege_set_args() throw() {}
+
+  HiveObjectRef hiveObject;
+  std::string user_name;
+  std::vector<std::string>  group_names;
+
+  _ThriftHiveMetastore_get_privilege_set_args__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_get_privilege_set_args & rhs) const
+  {
+    if (!(hiveObject == rhs.hiveObject))
+      return false;
+    if (!(user_name == rhs.user_name))
+      return false;
+    if (!(group_names == rhs.group_names))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_privilege_set_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_privilege_set_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_privilege_set_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_privilege_set_pargs() throw() {}
+
+  const HiveObjectRef* hiveObject;
+  const std::string* user_name;
+  const std::vector<std::string> * group_names;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_privilege_set_result__isset {
+  _ThriftHiveMetastore_get_privilege_set_result__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_get_privilege_set_result__isset;
+
+class ThriftHiveMetastore_get_privilege_set_result {
+ public:
+
+  ThriftHiveMetastore_get_privilege_set_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_get_privilege_set_result() throw() {}
+
+  PrincipalPrivilegeSet success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_get_privilege_set_result__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_get_privilege_set_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(o1 == rhs.o1))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_privilege_set_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_privilege_set_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_privilege_set_presult__isset {
+  _ThriftHiveMetastore_get_privilege_set_presult__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_get_privilege_set_presult__isset;
+
+class ThriftHiveMetastore_get_privilege_set_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_privilege_set_presult() throw() {}
+
+  PrincipalPrivilegeSet* success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_get_privilege_set_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_list_privileges_args__isset {
+  _ThriftHiveMetastore_list_privileges_args__isset() : principal_name(false), principal_type(false), hiveObject(false) {}
+  bool principal_name;
+  bool principal_type;
+  bool hiveObject;
+} _ThriftHiveMetastore_list_privileges_args__isset;
+
+class ThriftHiveMetastore_list_privileges_args {
+ public:
+
+  ThriftHiveMetastore_list_privileges_args() : principal_name("") {
+  }
+
+  virtual ~ThriftHiveMetastore_list_privileges_args() throw() {}
+
+  std::string principal_name;
+  PrincipalType::type principal_type;
+  HiveObjectRef hiveObject;
+
+  _ThriftHiveMetastore_list_privileges_args__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_list_privileges_args & rhs) const
+  {
+    if (!(principal_name == rhs.principal_name))
+      return false;
+    if (!(principal_type == rhs.principal_type))
+      return false;
+    if (!(hiveObject == rhs.hiveObject))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_list_privileges_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_list_privileges_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_list_privileges_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_list_privileges_pargs() throw() {}
+
+  const std::string* principal_name;
+  const PrincipalType::type* principal_type;
+  const HiveObjectRef* hiveObject;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_list_privileges_result__isset {
+  _ThriftHiveMetastore_list_privileges_result__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_list_privileges_result__isset;
+
+class ThriftHiveMetastore_list_privileges_result {
+ public:
+
+  ThriftHiveMetastore_list_privileges_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_list_privileges_result() throw() {}
+
+  std::vector<HiveObjectPrivilege>  success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_list_privileges_result__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_list_privileges_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(o1 == rhs.o1))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_list_privileges_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_list_privileges_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_list_privileges_presult__isset {
+  _ThriftHiveMetastore_list_privileges_presult__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_list_privileges_presult__isset;
+
+class ThriftHiveMetastore_list_privileges_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_list_privileges_presult() throw() {}
+
+  std::vector<HiveObjectPrivilege> * success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_list_privileges_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_grant_privileges_args__isset {
+  _ThriftHiveMetastore_grant_privileges_args__isset() : privileges(false) {}
+  bool privileges;
+} _ThriftHiveMetastore_grant_privileges_args__isset;
+
+class ThriftHiveMetastore_grant_privileges_args {
+ public:
+
+  ThriftHiveMetastore_grant_privileges_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_grant_privileges_args() throw() {}
+
+  PrivilegeBag privileges;
+
+  _ThriftHiveMetastore_grant_privileges_args__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_grant_privileges_args & rhs) const
+  {
+    if (!(privileges == rhs.privileges))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_grant_privileges_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_grant_privileges_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_grant_privileges_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_grant_privileges_pargs() throw() {}
+
+  const PrivilegeBag* privileges;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_grant_privileges_result__isset {
+  _ThriftHiveMetastore_grant_privileges_result__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_grant_privileges_result__isset;
+
+class ThriftHiveMetastore_grant_privileges_result {
+ public:
+
+  ThriftHiveMetastore_grant_privileges_result() : success(0) {
+  }
+
+  virtual ~ThriftHiveMetastore_grant_privileges_result() throw() {}
+
+  bool success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_grant_privileges_result__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_grant_privileges_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(o1 == rhs.o1))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_grant_privileges_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_grant_privileges_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_grant_privileges_presult__isset {
+  _ThriftHiveMetastore_grant_privileges_presult__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_grant_privileges_presult__isset;
+
+class ThriftHiveMetastore_grant_privileges_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_grant_privileges_presult() throw() {}
+
+  bool* success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_grant_privileges_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_revoke_privileges_args__isset {
+  _ThriftHiveMetastore_revoke_privileges_args__isset() : privileges(false) {}
+  bool privileges;
+} _ThriftHiveMetastore_revoke_privileges_args__isset;
+
+class ThriftHiveMetastore_revoke_privileges_args {
+ public:
+
+  ThriftHiveMetastore_revoke_privileges_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_revoke_privileges_args() throw() {}
+
+  PrivilegeBag privileges;
+
+  _ThriftHiveMetastore_revoke_privileges_args__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_revoke_privileges_args & rhs) const
+  {
+    if (!(privileges == rhs.privileges))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_revoke_privileges_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_revoke_privileges_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_revoke_privileges_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_revoke_privileges_pargs() throw() {}
+
+  const PrivilegeBag* privileges;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_revoke_privileges_result__isset {
+  _ThriftHiveMetastore_revoke_privileges_result__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_revoke_privileges_result__isset;
+
+class ThriftHiveMetastore_revoke_privileges_result {
+ public:
+
+  ThriftHiveMetastore_revoke_privileges_result() : success(0) {
+  }
+
+  virtual ~ThriftHiveMetastore_revoke_privileges_result() throw() {}
+
+  bool success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_revoke_privileges_result__isset __isset;
+
+  bool operator == (const ThriftHiveMetastore_revoke_privileges_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    if (!(o1 == rhs.o1))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_revoke_privileges_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_revoke_privileges_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_revoke_privileges_presult__isset {
+  _ThriftHiveMetastore_revoke_privileges_presult__isset() : success(false), o1(false) {}
+  bool success;
+  bool o1;
+} _ThriftHiveMetastore_revoke_privileges_presult__isset;
+
+class ThriftHiveMetastore_revoke_privileges_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_revoke_privileges_presult() throw() {}
+
+  bool* success;
+  MetaException o1;
+
+  _ThriftHiveMetastore_revoke_privileges_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public facebook::fb303::FacebookServiceClient {
+ public:
+  ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
+    facebook::fb303::FacebookServiceClient(prot, prot) {}
+  ThriftHiveMetastoreClient(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :
+    facebook::fb303::FacebookServiceClient(iprot, oprot) {}
+  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
+    return piprot_;
+  }
+  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
+    return poprot_;
+  }
+  void create_database(const Database& database);
+  void send_create_database(const Database& database);
+  void recv_create_database();
+  void get_database(Database& _return, const std::string& name);
+  void send_get_database(const std::string& name);
+  void recv_get_database(Database& _return);
+  void drop_database(const std::string& name, const bool deleteData);
+  void send_drop_database(const std::string& name, const bool deleteData);
+  void recv_drop_database();
+  void get_databases(std::vector<std::string> & _return, const std::string& pattern);
+  void send_get_databases(const std::string& pattern);
+  void recv_get_databases(std::vector<std::string> & _return);
+  void get_all_databases(std::vector<std::string> & _return);
+  void send_get_all_databases();
+  void recv_get_all_databases(std::vector<std::string> & _return);
+  void alter_database(const std::string& dbname, const Database& db);
+  void send_alter_database(const std::string& dbname, const Database& db);
+  void recv_alter_database();
+  void get_type(Type& _return, const std::string& name);
+  void send_get_type(const std::string& name);
+  void recv_get_type(Type& _return);
+  bool create_type(const Type& type);
+  void send_create_type(const Type& type);
+  bool recv_create_type();
+  bool drop_type(const std::string& type);
+  void send_drop_type(const std::string& type);
+  bool recv_drop_type();
+  void get_type_all(std::map<std::string, Type> & _return, const std::string& name);
+  void send_get_type_all(const std::string& name);
+  void recv_get_type_all(std::map<std::string, Type> & _return);
+  void get_fields(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name);
+  void send_get_fields(const std::string& db_name, const std::string& table_name);
+  void recv_get_fields(std::vector<FieldSchema> & _return);
+  void get_schema(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name);
+  void send_get_schema(const std::string& db_name, const std::string& table_name);
+  void recv_get_schema(std::vector<FieldSchema> & _return);
+  void create_table(const Table& tbl);
+  void send_create_table(const Table& tbl);
+  void recv_create_table();
+  void drop_table(const std::string& dbname, const std::string& name, const bool deleteData);
+  void send_drop_table(const std::string& dbname, const std::string& name, const bool deleteData);
+  void recv_drop_table();
+  void get_tables(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern);
+  void send_get_tables(const std::string& db_name, const std::string& pattern);
+  void recv_get_tables(std::vector<std::string> & _return);
+  void get_all_tables(std::vector<std::string> & _return, const std::string& db_name);
+  void send_get_all_tables(const std::string& db_name);
+  void recv_get_all_tables(std::vector<std::string> & _return);
+  void get_table(Table& _return, const std::string& dbname, const std::string& tbl_name);
+  void send_get_table(const std::string& dbname, const std::string& tbl_name);
+  void recv_get_table(Table& _return);
+  void alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl);
+  void send_alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl);
+  void recv_alter_table();
+  void add_partition(Partition& _return, const Partition& new_part);
+  void send_add_partition(const Partition& new_part);
+  void recv_add_partition(Partition& _return);
+  void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals);
+  void send_append_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals);
+  void recv_append_partition(Partition& _return);
+  void append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name);
+  void send_append_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name);
+  void recv_append_partition_by_name(Partition& _return);
+  bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const bool deleteData);
+  void send_drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const bool deleteData);
+  bool recv_drop_partition();
+  bool drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData);
+  void send_drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData);
+  bool recv_drop_partition_by_name();
+  void get_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals);
+  void send_get_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals);
+  void recv_get_partition(Partition& _return);
+  void get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const std::string& user_name, const std::vector<std::string> & group_names);
+  void send_get_partition_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const std::string& user_name, const std::vector<std::string> & group_names);
+  void recv_get_partition_with_auth(Partition& _return);
+  void get_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name);
+  void send_get_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name);
+  void recv_get_partition_by_name(Partition& _return);
+  void get_partitions(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts);
+  void send_get_partitions(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts);
+  void recv_get_partitions(std::vector<Partition> & _return);
+  void get_partitions_with_auth(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector<std::string> & group_names);
+  void send_get_partitions_with_auth(const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector<std::string> & group_names);
+  void recv_get_partitions_with_auth(std::vector<Partition> & _return);
+  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_partitions_ps_with_auth(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, const std::string& user_name, const std::vector<std::string> & group_names);
+  void send_get_partitions_ps_with_auth(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const int16_t max_parts, const std::string& user_name, const std::vector<std::string> & group_names);
+  void recv_get_partitions_ps_with_auth(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 get_partitions_by_filter(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts);
+  void send_get_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int16_t max_parts);
+  void recv_get_partitions_by_filter(std::vector<Partition> & _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();
+  void get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue);
+  void send_get_config_value(const std::string& name, const std::string& defaultValue);
+  void recv_get_config_value(std::string& _return);
+  void partition_name_to_vals(std::vector<std::string> & _return, const std::string& part_name);
+  void send_partition_name_to_vals(const std::string& part_name);
+  void recv_partition_name_to_vals(std::vector<std::string> & _return);
+  void partition_name_to_spec(std::map<std::string, std::string> & _return, const std::string& part_name);
+  void send_partition_name_to_spec(const std::string& part_name);
+  void recv_partition_name_to_spec(std::map<std::string, std::string> & _return);
+  void add_index(Index& _return, const Index& new_index, const Table& index_table);
+  void send_add_index(const Index& new_index, const Table& index_table);
+  void recv_add_index(Index& _return);
+  void alter_index(const std::string& dbname, const std::string& base_tbl_name, const std::string& idx_name, const Index& new_idx);
+  void send_alter_index(const std::string& dbname, const std::string& base_tbl_name, const std::string& idx_name, const Index& new_idx);
+  void recv_alter_index();
+  bool drop_index_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& index_name, const bool deleteData);
+  void send_drop_index_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& index_name, const bool deleteData);
+  bool recv_drop_index_by_name();
+  void get_index_by_name(Index& _return, const std::string& db_name, const std::string& tbl_name, const std::string& index_name);
+  void send_get_index_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& index_name);
+  void recv_get_index_by_name(Index& _return);
+  void get_indexes(std::vector<Index> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_indexes);
+  void send_get_indexes(const std::string& db_name, const std::string& tbl_name, const int16_t max_indexes);
+  void recv_get_indexes(std::vector<Index> & _return);
+  void get_index_names(std::vector<std::string> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_indexes);
+  void send_get_index_names(const std::string& db_name, const std::string& tbl_name, const int16_t max_indexes);
+  void recv_get_index_names(std::vector<std::string> & _return);
+  bool create_role(const Role& role);
+  void send_create_role(const Role& role);
+  bool recv_create_role();
+  bool drop_role(const std::string& role_name);
+  void send_drop_role(const std::string& role_name);
+  bool recv_drop_role();
+  bool grant_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type, const std::string& grantor, const PrincipalType::type grantorType, const bool grant_option);
+  void send_grant_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type, const std::string& grantor, const PrincipalType::type grantorType, const bool grant_option);
+  bool recv_grant_role();
+  bool revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type);
+  void send_revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type);
+  bool recv_revoke_role();
+  void list_roles(std::vector<Role> & _return, const std::string& principal_name, const PrincipalType::type principal_type);
+  void send_list_roles(const std::string& principal_name, const PrincipalType::type principal_type);
+  void recv_list_roles(std::vector<Role> & _return);
+  void get_privilege_set(PrincipalPrivilegeSet& _return, const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector<std::string> & group_names);
+  void send_get_privilege_set(const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector<std::string> & group_names);
+  void recv_get_privilege_set(PrincipalPrivilegeSet& _return);
+  void list_privileges(std::vector<HiveObjectPrivilege> & _return, const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject);
+  void send_list_privileges(const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject);
+  void recv_list_privileges(std::vector<HiveObjectPrivilege> & _return);
+  bool grant_privileges(const PrivilegeBag& privileges);
+  void send_grant_privileges(const PrivilegeBag& privileges);
+  bool recv_grant_privileges();
+  bool revoke_privileges(const PrivilegeBag& privileges);
+  void send_revoke_privileges(const PrivilegeBag& privileges);
+  bool recv_revoke_privileges();
+};
+
+class ThriftHiveMetastoreProcessor : virtual public ::apache::thrift::TProcessor, public facebook::fb303::FacebookServiceProcessor {
+ protected:
+  boost::shared_ptr<ThriftHiveMetastoreIf> iface_;
+  virtual bool process_fn(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, std::string& fname, int32_t seqid);
  private:
   std::map<std::string, void (ThriftHiveMetastoreProcessor::*)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*)> processMap_;
   void process_create_database(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
@@ -5032,10 +6537,13 @@ class ThriftHiveMetastoreProcessor : vir
   void process_drop_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
   void process_drop_partition_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
   void process_get_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
+  void process_get_partition_with_auth(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
   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_partitions_with_auth(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_partitions_ps_with_auth(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_get_partitions_by_filter(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);
@@ -5048,6 +6556,15 @@ class ThriftHiveMetastoreProcessor : vir
   void process_get_index_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
   void process_get_indexes(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
   void process_get_index_names(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
+  void process_create_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
+  void process_drop_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
+  void process_grant_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
+  void process_revoke_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
+  void process_list_roles(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
+  void process_get_privilege_set(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
+  void process_list_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
+  void process_grant_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
+  void process_revoke_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot);
  public:
   ThriftHiveMetastoreProcessor(boost::shared_ptr<ThriftHiveMetastoreIf> iface) :
     facebook::fb303::FacebookServiceProcessor(iface),
@@ -5076,10 +6593,13 @@ class ThriftHiveMetastoreProcessor : vir
     processMap_["drop_partition"] = &ThriftHiveMetastoreProcessor::process_drop_partition;
     processMap_["drop_partition_by_name"] = &ThriftHiveMetastoreProcessor::process_drop_partition_by_name;
     processMap_["get_partition"] = &ThriftHiveMetastoreProcessor::process_get_partition;
+    processMap_["get_partition_with_auth"] = &ThriftHiveMetastoreProcessor::process_get_partition_with_auth;
     processMap_["get_partition_by_name"] = &ThriftHiveMetastoreProcessor::process_get_partition_by_name;
     processMap_["get_partitions"] = &ThriftHiveMetastoreProcessor::process_get_partitions;
+    processMap_["get_partitions_with_auth"] = &ThriftHiveMetastoreProcessor::process_get_partitions_with_auth;
     processMap_["get_partition_names"] = &ThriftHiveMetastoreProcessor::process_get_partition_names;
     processMap_["get_partitions_ps"] = &ThriftHiveMetastoreProcessor::process_get_partitions_ps;
+    processMap_["get_partitions_ps_with_auth"] = &ThriftHiveMetastoreProcessor::process_get_partitions_ps_with_auth;
     processMap_["get_partition_names_ps"] = &ThriftHiveMetastoreProcessor::process_get_partition_names_ps;
     processMap_["get_partitions_by_filter"] = &ThriftHiveMetastoreProcessor::process_get_partitions_by_filter;
     processMap_["alter_partition"] = &ThriftHiveMetastoreProcessor::process_alter_partition;
@@ -5092,6 +6612,15 @@ class ThriftHiveMetastoreProcessor : vir
     processMap_["get_index_by_name"] = &ThriftHiveMetastoreProcessor::process_get_index_by_name;
     processMap_["get_indexes"] = &ThriftHiveMetastoreProcessor::process_get_indexes;
     processMap_["get_index_names"] = &ThriftHiveMetastoreProcessor::process_get_index_names;
+    processMap_["create_role"] = &ThriftHiveMetastoreProcessor::process_create_role;
+    processMap_["drop_role"] = &ThriftHiveMetastoreProcessor::process_drop_role;
+    processMap_["grant_role"] = &ThriftHiveMetastoreProcessor::process_grant_role;
+    processMap_["revoke_role"] = &ThriftHiveMetastoreProcessor::process_revoke_role;
+    processMap_["list_roles"] = &ThriftHiveMetastoreProcessor::process_list_roles;
+    processMap_["get_privilege_set"] = &ThriftHiveMetastoreProcessor::process_get_privilege_set;
+    processMap_["list_privileges"] = &ThriftHiveMetastoreProcessor::process_list_privileges;
+    processMap_["grant_privileges"] = &ThriftHiveMetastoreProcessor::process_grant_privileges;
+    processMap_["revoke_privileges"] = &ThriftHiveMetastoreProcessor::process_revoke_privileges;
   }
 
   virtual bool process(boost::shared_ptr< ::apache::thrift::protocol::TProtocol> piprot, boost::shared_ptr< ::apache::thrift::protocol::TProtocol> poprot);
@@ -5369,6 +6898,18 @@ class ThriftHiveMetastoreMultiface : vir
     }
   }
 
+  void get_partition_with_auth(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const std::string& user_name, const std::vector<std::string> & group_names) {
+    uint32_t sz = ifaces_.size();
+    for (uint32_t i = 0; i < sz; ++i) {
+      if (i == sz - 1) {
+        ifaces_[i]->get_partition_with_auth(_return, db_name, tbl_name, part_vals, user_name, group_names);
+        return;
+      } else {
+        ifaces_[i]->get_partition_with_auth(_return, db_name, tbl_name, part_vals, user_name, group_names);
+      }
+    }
+  }
+
   void get_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) {
     uint32_t sz = ifaces_.size();
     for (uint32_t i = 0; i < sz; ++i) {
@@ -5393,6 +6934,18 @@ class ThriftHiveMetastoreMultiface : vir
     }
   }
 
+  void get_partitions_with_auth(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts, const std::string& user_name, const std::vector<std::string> & group_names) {
+    uint32_t sz = ifaces_.size();
+    for (uint32_t i = 0; i < sz; ++i) {
+      if (i == sz - 1) {

[... 140 lines stripped ...]