hive-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From hashut...@apache.org
Subject svn commit: r1574266 [3/23] - in /hive/trunk: common/src/java/org/apache/hadoop/hive/conf/ itests/hive-unit/src/test/java/org/apache/hadoop/hive/metastore/ metastore/ metastore/if/ metastore/scripts/upgrade/derby/ metastore/scripts/upgrade/mysql/ metas...
Date Wed, 05 Mar 2014 00:20:57 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=1574266&r1=1574265&r2=1574266&view=diff
==============================================================================
--- hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h (original)
+++ hive/trunk/metastore/src/gen/thrift/gen-cpp/ThriftHiveMetastore.h Wed Mar  5 00:20:53 2014
@@ -108,6 +108,18 @@ class ThriftHiveMetastoreIf : virtual pu
   virtual void get_delegation_token(std::string& _return, const std::string& token_owner, const std::string& renewer_kerberos_principal_name) = 0;
   virtual int64_t renew_delegation_token(const std::string& token_str_form) = 0;
   virtual void cancel_delegation_token(const std::string& token_str_form) = 0;
+  virtual void get_open_txns(GetOpenTxnsResponse& _return) = 0;
+  virtual void get_open_txns_info(GetOpenTxnsInfoResponse& _return) = 0;
+  virtual void open_txns(OpenTxnsResponse& _return, const OpenTxnRequest& rqst) = 0;
+  virtual void abort_txn(const AbortTxnRequest& rqst) = 0;
+  virtual void commit_txn(const CommitTxnRequest& rqst) = 0;
+  virtual void lock(LockResponse& _return, const LockRequest& rqst) = 0;
+  virtual void check_lock(LockResponse& _return, const CheckLockRequest& rqst) = 0;
+  virtual void unlock(const UnlockRequest& rqst) = 0;
+  virtual void show_locks(ShowLocksResponse& _return, const ShowLocksRequest& rqst) = 0;
+  virtual void heartbeat(const HeartbeatRequest& ids) = 0;
+  virtual void compact(const CompactionRequest& rqst) = 0;
+  virtual void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) = 0;
 };
 
 class ThriftHiveMetastoreIfFactory : virtual public  ::facebook::fb303::FacebookServiceIfFactory {
@@ -434,6 +446,42 @@ class ThriftHiveMetastoreNull : virtual 
   void cancel_delegation_token(const std::string& /* token_str_form */) {
     return;
   }
+  void get_open_txns(GetOpenTxnsResponse& /* _return */) {
+    return;
+  }
+  void get_open_txns_info(GetOpenTxnsInfoResponse& /* _return */) {
+    return;
+  }
+  void open_txns(OpenTxnsResponse& /* _return */, const OpenTxnRequest& /* rqst */) {
+    return;
+  }
+  void abort_txn(const AbortTxnRequest& /* rqst */) {
+    return;
+  }
+  void commit_txn(const CommitTxnRequest& /* rqst */) {
+    return;
+  }
+  void lock(LockResponse& /* _return */, const LockRequest& /* rqst */) {
+    return;
+  }
+  void check_lock(LockResponse& /* _return */, const CheckLockRequest& /* rqst */) {
+    return;
+  }
+  void unlock(const UnlockRequest& /* rqst */) {
+    return;
+  }
+  void show_locks(ShowLocksResponse& /* _return */, const ShowLocksRequest& /* rqst */) {
+    return;
+  }
+  void heartbeat(const HeartbeatRequest& /* ids */) {
+    return;
+  }
+  void compact(const CompactionRequest& /* rqst */) {
+    return;
+  }
+  void show_compact(ShowCompactResponse& /* _return */, const ShowCompactRequest& /* rqst */) {
+    return;
+  }
 };
 
 typedef struct _ThriftHiveMetastore_create_database_args__isset {
@@ -13452,234 +13500,1572 @@ class ThriftHiveMetastore_cancel_delegat
 
 };
 
-class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public  ::facebook::fb303::FacebookServiceClient {
+
+class ThriftHiveMetastore_get_open_txns_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_;
+
+  ThriftHiveMetastore_get_open_txns_args() {
   }
-  boost::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
-    return poprot_;
+
+  virtual ~ThriftHiveMetastore_get_open_txns_args() throw() {}
+
+
+  bool operator == (const ThriftHiveMetastore_get_open_txns_args & /* rhs */) const
+  {
+    return true;
   }
-  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, const bool cascade);
-  void send_drop_database(const std::string& name, const bool deleteData, const bool cascade);
-  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 create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context);
-  void send_create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context);
-  void recv_create_table_with_environment_context();
-  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 drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context);
-  void send_drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context);
-  void recv_drop_table_with_environment_context();
-  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 get_table_objects_by_name(std::vector<Table> & _return, const std::string& dbname, const std::vector<std::string> & tbl_names);
-  void send_get_table_objects_by_name(const std::string& dbname, const std::vector<std::string> & tbl_names);
-  void recv_get_table_objects_by_name(std::vector<Table> & _return);
-  void get_table_names_by_filter(std::vector<std::string> & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables);
-  void send_get_table_names_by_filter(const std::string& dbname, const std::string& filter, const int16_t max_tables);
-  void recv_get_table_names_by_filter(std::vector<std::string> & _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 alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context);
-  void send_alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context);
-  void recv_alter_table_with_environment_context();
-  void add_partition(Partition& _return, const Partition& new_part);
-  void send_add_partition(const Partition& new_part);
-  void recv_add_partition(Partition& _return);
-  void add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context);
-  void send_add_partition_with_environment_context(const Partition& new_part, const EnvironmentContext& environment_context);
-  void recv_add_partition_with_environment_context(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);
-  void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request);
-  void send_add_partitions_req(const AddPartitionsRequest& request);
-  void recv_add_partitions_req(AddPartitionsResult& _return);
-  void append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const EnvironmentContext& environment_context);
-  void send_append_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const EnvironmentContext& environment_context);
-  void recv_append_partition_with_environment_context(Partition& _return);
-  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);
-  void append_partition_by_name_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context);
-  void send_append_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context);
-  void recv_append_partition_by_name_with_environment_context(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_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const bool deleteData, const EnvironmentContext& environment_context);
-  void send_drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const bool deleteData, const EnvironmentContext& environment_context);
-  bool recv_drop_partition_with_environment_context();
-  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();
-  bool drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context);
-  void send_drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context);
-  bool recv_drop_partition_by_name_with_environment_context();
-  void drop_partitions_req(DropPartitionsResult& _return, const DropPartitionsRequest& req);
-  void send_drop_partitions_req(const DropPartitionsRequest& req);
-  void recv_drop_partitions_req(DropPartitionsResult& _return);
-  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 exchange_partition(Partition& _return, const std::map<std::string, std::string> & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name);
-  void send_exchange_partition(const std::map<std::string, std::string> & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name);
-  void recv_exchange_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 get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req);
-  void send_get_partitions_by_expr(const PartitionsByExprRequest& req);
-  void recv_get_partitions_by_expr(PartitionsByExprResult& _return);
-  void get_partitions_by_names(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & names);
-  void send_get_partitions_by_names(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & names);
-  void recv_get_partitions_by_names(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 alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts);
-  void send_alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts);
-  void recv_alter_partitions();
-  void alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context);
-  void send_alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context);
-  void recv_alter_partition_with_environment_context();
-  void rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const Partition& new_part);
-  void send_rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const Partition& new_part);
-  void recv_rename_partition();
-  bool partition_name_has_valid_characters(const std::vector<std::string> & part_vals, const bool throw_exception);
-  void send_partition_name_has_valid_characters(const std::vector<std::string> & part_vals, const bool throw_exception);
-  bool recv_partition_name_has_valid_characters();
-  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 markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType);
-  void send_markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType);
-  void recv_markPartitionForEvent();
-  bool isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType);
-  void send_isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType);
-  bool recv_isPartitionMarkedForEvent();
-  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 update_table_column_statistics(const ColumnStatistics& stats_obj);
-  void send_update_table_column_statistics(const ColumnStatistics& stats_obj);
-  bool recv_update_table_column_statistics();
-  bool update_partition_column_statistics(const ColumnStatistics& stats_obj);
-  void send_update_partition_column_statistics(const ColumnStatistics& stats_obj);
-  bool recv_update_partition_column_statistics();
-  void get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name);
-  void send_get_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name);
-  void recv_get_table_column_statistics(ColumnStatistics& _return);
-  void get_partition_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name);
-  void send_get_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name);
-  void recv_get_partition_column_statistics(ColumnStatistics& _return);
-  void get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request);
-  void send_get_table_statistics_req(const TableStatsRequest& request);
-  void recv_get_table_statistics_req(TableStatsResult& _return);
-  void get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request);
-  void send_get_partitions_statistics_req(const PartitionsStatsRequest& request);
-  void recv_get_partitions_statistics_req(PartitionsStatsResult& _return);
-  bool delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name);
-  void send_delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name);
-  bool recv_delete_partition_column_statistics();
+  bool operator != (const ThriftHiveMetastore_get_open_txns_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_open_txns_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_open_txns_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_open_txns_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_open_txns_result__isset {
+  _ThriftHiveMetastore_get_open_txns_result__isset() : success(false) {}
+  bool success;
+} _ThriftHiveMetastore_get_open_txns_result__isset;
+
+class ThriftHiveMetastore_get_open_txns_result {
+ public:
+
+  ThriftHiveMetastore_get_open_txns_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_get_open_txns_result() throw() {}
+
+  GetOpenTxnsResponse success;
+
+  _ThriftHiveMetastore_get_open_txns_result__isset __isset;
+
+  void __set_success(const GetOpenTxnsResponse& val) {
+    success = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_get_open_txns_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_open_txns_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_open_txns_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_open_txns_presult__isset {
+  _ThriftHiveMetastore_get_open_txns_presult__isset() : success(false) {}
+  bool success;
+} _ThriftHiveMetastore_get_open_txns_presult__isset;
+
+class ThriftHiveMetastore_get_open_txns_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_open_txns_presult() throw() {}
+
+  GetOpenTxnsResponse* success;
+
+  _ThriftHiveMetastore_get_open_txns_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+
+class ThriftHiveMetastore_get_open_txns_info_args {
+ public:
+
+  ThriftHiveMetastore_get_open_txns_info_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_get_open_txns_info_args() throw() {}
+
+
+  bool operator == (const ThriftHiveMetastore_get_open_txns_info_args & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_open_txns_info_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_open_txns_info_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_get_open_txns_info_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_open_txns_info_pargs() throw() {}
+
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_open_txns_info_result__isset {
+  _ThriftHiveMetastore_get_open_txns_info_result__isset() : success(false) {}
+  bool success;
+} _ThriftHiveMetastore_get_open_txns_info_result__isset;
+
+class ThriftHiveMetastore_get_open_txns_info_result {
+ public:
+
+  ThriftHiveMetastore_get_open_txns_info_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_get_open_txns_info_result() throw() {}
+
+  GetOpenTxnsInfoResponse success;
+
+  _ThriftHiveMetastore_get_open_txns_info_result__isset __isset;
+
+  void __set_success(const GetOpenTxnsInfoResponse& val) {
+    success = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_get_open_txns_info_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_get_open_txns_info_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_get_open_txns_info_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_get_open_txns_info_presult__isset {
+  _ThriftHiveMetastore_get_open_txns_info_presult__isset() : success(false) {}
+  bool success;
+} _ThriftHiveMetastore_get_open_txns_info_presult__isset;
+
+class ThriftHiveMetastore_get_open_txns_info_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_get_open_txns_info_presult() throw() {}
+
+  GetOpenTxnsInfoResponse* success;
+
+  _ThriftHiveMetastore_get_open_txns_info_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_open_txns_args__isset {
+  _ThriftHiveMetastore_open_txns_args__isset() : rqst(false) {}
+  bool rqst;
+} _ThriftHiveMetastore_open_txns_args__isset;
+
+class ThriftHiveMetastore_open_txns_args {
+ public:
+
+  ThriftHiveMetastore_open_txns_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_open_txns_args() throw() {}
+
+  OpenTxnRequest rqst;
+
+  _ThriftHiveMetastore_open_txns_args__isset __isset;
+
+  void __set_rqst(const OpenTxnRequest& val) {
+    rqst = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_open_txns_args & rhs) const
+  {
+    if (!(rqst == rhs.rqst))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_open_txns_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_open_txns_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_open_txns_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_open_txns_pargs() throw() {}
+
+  const OpenTxnRequest* rqst;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_open_txns_result__isset {
+  _ThriftHiveMetastore_open_txns_result__isset() : success(false) {}
+  bool success;
+} _ThriftHiveMetastore_open_txns_result__isset;
+
+class ThriftHiveMetastore_open_txns_result {
+ public:
+
+  ThriftHiveMetastore_open_txns_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_open_txns_result() throw() {}
+
+  OpenTxnsResponse success;
+
+  _ThriftHiveMetastore_open_txns_result__isset __isset;
+
+  void __set_success(const OpenTxnsResponse& val) {
+    success = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_open_txns_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_open_txns_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_open_txns_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_open_txns_presult__isset {
+  _ThriftHiveMetastore_open_txns_presult__isset() : success(false) {}
+  bool success;
+} _ThriftHiveMetastore_open_txns_presult__isset;
+
+class ThriftHiveMetastore_open_txns_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_open_txns_presult() throw() {}
+
+  OpenTxnsResponse* success;
+
+  _ThriftHiveMetastore_open_txns_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_abort_txn_args__isset {
+  _ThriftHiveMetastore_abort_txn_args__isset() : rqst(false) {}
+  bool rqst;
+} _ThriftHiveMetastore_abort_txn_args__isset;
+
+class ThriftHiveMetastore_abort_txn_args {
+ public:
+
+  ThriftHiveMetastore_abort_txn_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_abort_txn_args() throw() {}
+
+  AbortTxnRequest rqst;
+
+  _ThriftHiveMetastore_abort_txn_args__isset __isset;
+
+  void __set_rqst(const AbortTxnRequest& val) {
+    rqst = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_abort_txn_args & rhs) const
+  {
+    if (!(rqst == rhs.rqst))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_abort_txn_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_abort_txn_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_abort_txn_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_abort_txn_pargs() throw() {}
+
+  const AbortTxnRequest* rqst;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_abort_txn_result__isset {
+  _ThriftHiveMetastore_abort_txn_result__isset() : o1(false) {}
+  bool o1;
+} _ThriftHiveMetastore_abort_txn_result__isset;
+
+class ThriftHiveMetastore_abort_txn_result {
+ public:
+
+  ThriftHiveMetastore_abort_txn_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_abort_txn_result() throw() {}
+
+  NoSuchTxnException o1;
+
+  _ThriftHiveMetastore_abort_txn_result__isset __isset;
+
+  void __set_o1(const NoSuchTxnException& val) {
+    o1 = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_abort_txn_result & rhs) const
+  {
+    if (!(o1 == rhs.o1))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_abort_txn_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_abort_txn_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_abort_txn_presult__isset {
+  _ThriftHiveMetastore_abort_txn_presult__isset() : o1(false) {}
+  bool o1;
+} _ThriftHiveMetastore_abort_txn_presult__isset;
+
+class ThriftHiveMetastore_abort_txn_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_abort_txn_presult() throw() {}
+
+  NoSuchTxnException o1;
+
+  _ThriftHiveMetastore_abort_txn_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_commit_txn_args__isset {
+  _ThriftHiveMetastore_commit_txn_args__isset() : rqst(false) {}
+  bool rqst;
+} _ThriftHiveMetastore_commit_txn_args__isset;
+
+class ThriftHiveMetastore_commit_txn_args {
+ public:
+
+  ThriftHiveMetastore_commit_txn_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_commit_txn_args() throw() {}
+
+  CommitTxnRequest rqst;
+
+  _ThriftHiveMetastore_commit_txn_args__isset __isset;
+
+  void __set_rqst(const CommitTxnRequest& val) {
+    rqst = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_commit_txn_args & rhs) const
+  {
+    if (!(rqst == rhs.rqst))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_commit_txn_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_commit_txn_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_commit_txn_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_commit_txn_pargs() throw() {}
+
+  const CommitTxnRequest* rqst;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_commit_txn_result__isset {
+  _ThriftHiveMetastore_commit_txn_result__isset() : o1(false), o2(false) {}
+  bool o1;
+  bool o2;
+} _ThriftHiveMetastore_commit_txn_result__isset;
+
+class ThriftHiveMetastore_commit_txn_result {
+ public:
+
+  ThriftHiveMetastore_commit_txn_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_commit_txn_result() throw() {}
+
+  NoSuchTxnException o1;
+  TxnAbortedException o2;
+
+  _ThriftHiveMetastore_commit_txn_result__isset __isset;
+
+  void __set_o1(const NoSuchTxnException& val) {
+    o1 = val;
+  }
+
+  void __set_o2(const TxnAbortedException& val) {
+    o2 = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_commit_txn_result & rhs) const
+  {
+    if (!(o1 == rhs.o1))
+      return false;
+    if (!(o2 == rhs.o2))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_commit_txn_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_commit_txn_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_commit_txn_presult__isset {
+  _ThriftHiveMetastore_commit_txn_presult__isset() : o1(false), o2(false) {}
+  bool o1;
+  bool o2;
+} _ThriftHiveMetastore_commit_txn_presult__isset;
+
+class ThriftHiveMetastore_commit_txn_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_commit_txn_presult() throw() {}
+
+  NoSuchTxnException o1;
+  TxnAbortedException o2;
+
+  _ThriftHiveMetastore_commit_txn_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_lock_args__isset {
+  _ThriftHiveMetastore_lock_args__isset() : rqst(false) {}
+  bool rqst;
+} _ThriftHiveMetastore_lock_args__isset;
+
+class ThriftHiveMetastore_lock_args {
+ public:
+
+  ThriftHiveMetastore_lock_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_lock_args() throw() {}
+
+  LockRequest rqst;
+
+  _ThriftHiveMetastore_lock_args__isset __isset;
+
+  void __set_rqst(const LockRequest& val) {
+    rqst = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_lock_args & rhs) const
+  {
+    if (!(rqst == rhs.rqst))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_lock_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_lock_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_lock_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_lock_pargs() throw() {}
+
+  const LockRequest* rqst;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_lock_result__isset {
+  _ThriftHiveMetastore_lock_result__isset() : success(false), o1(false), o2(false) {}
+  bool success;
+  bool o1;
+  bool o2;
+} _ThriftHiveMetastore_lock_result__isset;
+
+class ThriftHiveMetastore_lock_result {
+ public:
+
+  ThriftHiveMetastore_lock_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_lock_result() throw() {}
+
+  LockResponse success;
+  NoSuchTxnException o1;
+  TxnAbortedException o2;
+
+  _ThriftHiveMetastore_lock_result__isset __isset;
+
+  void __set_success(const LockResponse& val) {
+    success = val;
+  }
+
+  void __set_o1(const NoSuchTxnException& val) {
+    o1 = val;
+  }
+
+  void __set_o2(const TxnAbortedException& val) {
+    o2 = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_lock_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_lock_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_lock_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_lock_presult__isset {
+  _ThriftHiveMetastore_lock_presult__isset() : success(false), o1(false), o2(false) {}
+  bool success;
+  bool o1;
+  bool o2;
+} _ThriftHiveMetastore_lock_presult__isset;
+
+class ThriftHiveMetastore_lock_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_lock_presult() throw() {}
+
+  LockResponse* success;
+  NoSuchTxnException o1;
+  TxnAbortedException o2;
+
+  _ThriftHiveMetastore_lock_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_check_lock_args__isset {
+  _ThriftHiveMetastore_check_lock_args__isset() : rqst(false) {}
+  bool rqst;
+} _ThriftHiveMetastore_check_lock_args__isset;
+
+class ThriftHiveMetastore_check_lock_args {
+ public:
+
+  ThriftHiveMetastore_check_lock_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_check_lock_args() throw() {}
+
+  CheckLockRequest rqst;
+
+  _ThriftHiveMetastore_check_lock_args__isset __isset;
+
+  void __set_rqst(const CheckLockRequest& val) {
+    rqst = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_check_lock_args & rhs) const
+  {
+    if (!(rqst == rhs.rqst))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_check_lock_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_check_lock_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_check_lock_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_check_lock_pargs() throw() {}
+
+  const CheckLockRequest* rqst;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_check_lock_result__isset {
+  _ThriftHiveMetastore_check_lock_result__isset() : success(false), o1(false), o2(false), o3(false) {}
+  bool success;
+  bool o1;
+  bool o2;
+  bool o3;
+} _ThriftHiveMetastore_check_lock_result__isset;
+
+class ThriftHiveMetastore_check_lock_result {
+ public:
+
+  ThriftHiveMetastore_check_lock_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_check_lock_result() throw() {}
+
+  LockResponse success;
+  NoSuchTxnException o1;
+  TxnAbortedException o2;
+  NoSuchLockException o3;
+
+  _ThriftHiveMetastore_check_lock_result__isset __isset;
+
+  void __set_success(const LockResponse& val) {
+    success = val;
+  }
+
+  void __set_o1(const NoSuchTxnException& val) {
+    o1 = val;
+  }
+
+  void __set_o2(const TxnAbortedException& val) {
+    o2 = val;
+  }
+
+  void __set_o3(const NoSuchLockException& val) {
+    o3 = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_check_lock_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_check_lock_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_check_lock_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_check_lock_presult__isset {
+  _ThriftHiveMetastore_check_lock_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
+  bool success;
+  bool o1;
+  bool o2;
+  bool o3;
+} _ThriftHiveMetastore_check_lock_presult__isset;
+
+class ThriftHiveMetastore_check_lock_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_check_lock_presult() throw() {}
+
+  LockResponse* success;
+  NoSuchTxnException o1;
+  TxnAbortedException o2;
+  NoSuchLockException o3;
+
+  _ThriftHiveMetastore_check_lock_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_unlock_args__isset {
+  _ThriftHiveMetastore_unlock_args__isset() : rqst(false) {}
+  bool rqst;
+} _ThriftHiveMetastore_unlock_args__isset;
+
+class ThriftHiveMetastore_unlock_args {
+ public:
+
+  ThriftHiveMetastore_unlock_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_unlock_args() throw() {}
+
+  UnlockRequest rqst;
+
+  _ThriftHiveMetastore_unlock_args__isset __isset;
+
+  void __set_rqst(const UnlockRequest& val) {
+    rqst = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_unlock_args & rhs) const
+  {
+    if (!(rqst == rhs.rqst))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_unlock_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_unlock_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_unlock_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_unlock_pargs() throw() {}
+
+  const UnlockRequest* rqst;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_unlock_result__isset {
+  _ThriftHiveMetastore_unlock_result__isset() : o1(false), o2(false) {}
+  bool o1;
+  bool o2;
+} _ThriftHiveMetastore_unlock_result__isset;
+
+class ThriftHiveMetastore_unlock_result {
+ public:
+
+  ThriftHiveMetastore_unlock_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_unlock_result() throw() {}
+
+  NoSuchLockException o1;
+  TxnOpenException o2;
+
+  _ThriftHiveMetastore_unlock_result__isset __isset;
+
+  void __set_o1(const NoSuchLockException& val) {
+    o1 = val;
+  }
+
+  void __set_o2(const TxnOpenException& val) {
+    o2 = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_unlock_result & rhs) const
+  {
+    if (!(o1 == rhs.o1))
+      return false;
+    if (!(o2 == rhs.o2))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_unlock_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_unlock_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_unlock_presult__isset {
+  _ThriftHiveMetastore_unlock_presult__isset() : o1(false), o2(false) {}
+  bool o1;
+  bool o2;
+} _ThriftHiveMetastore_unlock_presult__isset;
+
+class ThriftHiveMetastore_unlock_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_unlock_presult() throw() {}
+
+  NoSuchLockException o1;
+  TxnOpenException o2;
+
+  _ThriftHiveMetastore_unlock_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_show_locks_args__isset {
+  _ThriftHiveMetastore_show_locks_args__isset() : rqst(false) {}
+  bool rqst;
+} _ThriftHiveMetastore_show_locks_args__isset;
+
+class ThriftHiveMetastore_show_locks_args {
+ public:
+
+  ThriftHiveMetastore_show_locks_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_show_locks_args() throw() {}
+
+  ShowLocksRequest rqst;
+
+  _ThriftHiveMetastore_show_locks_args__isset __isset;
+
+  void __set_rqst(const ShowLocksRequest& val) {
+    rqst = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_show_locks_args & rhs) const
+  {
+    if (!(rqst == rhs.rqst))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_show_locks_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_show_locks_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_show_locks_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_show_locks_pargs() throw() {}
+
+  const ShowLocksRequest* rqst;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_show_locks_result__isset {
+  _ThriftHiveMetastore_show_locks_result__isset() : success(false) {}
+  bool success;
+} _ThriftHiveMetastore_show_locks_result__isset;
+
+class ThriftHiveMetastore_show_locks_result {
+ public:
+
+  ThriftHiveMetastore_show_locks_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_show_locks_result() throw() {}
+
+  ShowLocksResponse success;
+
+  _ThriftHiveMetastore_show_locks_result__isset __isset;
+
+  void __set_success(const ShowLocksResponse& val) {
+    success = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_show_locks_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_show_locks_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_show_locks_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_show_locks_presult__isset {
+  _ThriftHiveMetastore_show_locks_presult__isset() : success(false) {}
+  bool success;
+} _ThriftHiveMetastore_show_locks_presult__isset;
+
+class ThriftHiveMetastore_show_locks_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_show_locks_presult() throw() {}
+
+  ShowLocksResponse* success;
+
+  _ThriftHiveMetastore_show_locks_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_heartbeat_args__isset {
+  _ThriftHiveMetastore_heartbeat_args__isset() : ids(false) {}
+  bool ids;
+} _ThriftHiveMetastore_heartbeat_args__isset;
+
+class ThriftHiveMetastore_heartbeat_args {
+ public:
+
+  ThriftHiveMetastore_heartbeat_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_heartbeat_args() throw() {}
+
+  HeartbeatRequest ids;
+
+  _ThriftHiveMetastore_heartbeat_args__isset __isset;
+
+  void __set_ids(const HeartbeatRequest& val) {
+    ids = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_heartbeat_args & rhs) const
+  {
+    if (!(ids == rhs.ids))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_heartbeat_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_heartbeat_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_heartbeat_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_heartbeat_pargs() throw() {}
+
+  const HeartbeatRequest* ids;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_heartbeat_result__isset {
+  _ThriftHiveMetastore_heartbeat_result__isset() : o1(false), o2(false), o3(false) {}
+  bool o1;
+  bool o2;
+  bool o3;
+} _ThriftHiveMetastore_heartbeat_result__isset;
+
+class ThriftHiveMetastore_heartbeat_result {
+ public:
+
+  ThriftHiveMetastore_heartbeat_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_heartbeat_result() throw() {}
+
+  NoSuchLockException o1;
+  NoSuchTxnException o2;
+  TxnAbortedException o3;
+
+  _ThriftHiveMetastore_heartbeat_result__isset __isset;
+
+  void __set_o1(const NoSuchLockException& val) {
+    o1 = val;
+  }
+
+  void __set_o2(const NoSuchTxnException& val) {
+    o2 = val;
+  }
+
+  void __set_o3(const TxnAbortedException& val) {
+    o3 = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_heartbeat_result & rhs) const
+  {
+    if (!(o1 == rhs.o1))
+      return false;
+    if (!(o2 == rhs.o2))
+      return false;
+    if (!(o3 == rhs.o3))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_heartbeat_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_heartbeat_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_heartbeat_presult__isset {
+  _ThriftHiveMetastore_heartbeat_presult__isset() : o1(false), o2(false), o3(false) {}
+  bool o1;
+  bool o2;
+  bool o3;
+} _ThriftHiveMetastore_heartbeat_presult__isset;
+
+class ThriftHiveMetastore_heartbeat_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_heartbeat_presult() throw() {}
+
+  NoSuchLockException o1;
+  NoSuchTxnException o2;
+  TxnAbortedException o3;
+
+  _ThriftHiveMetastore_heartbeat_presult__isset __isset;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_compact_args__isset {
+  _ThriftHiveMetastore_compact_args__isset() : rqst(false) {}
+  bool rqst;
+} _ThriftHiveMetastore_compact_args__isset;
+
+class ThriftHiveMetastore_compact_args {
+ public:
+
+  ThriftHiveMetastore_compact_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_compact_args() throw() {}
+
+  CompactionRequest rqst;
+
+  _ThriftHiveMetastore_compact_args__isset __isset;
+
+  void __set_rqst(const CompactionRequest& val) {
+    rqst = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_compact_args & rhs) const
+  {
+    if (!(rqst == rhs.rqst))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_compact_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_compact_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_compact_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_compact_pargs() throw() {}
+
+  const CompactionRequest* rqst;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_compact_result {
+ public:
+
+  ThriftHiveMetastore_compact_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_compact_result() throw() {}
+
+
+  bool operator == (const ThriftHiveMetastore_compact_result & /* rhs */) const
+  {
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_compact_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_compact_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_compact_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_compact_presult() throw() {}
+
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+
+};
+
+typedef struct _ThriftHiveMetastore_show_compact_args__isset {
+  _ThriftHiveMetastore_show_compact_args__isset() : rqst(false) {}
+  bool rqst;
+} _ThriftHiveMetastore_show_compact_args__isset;
+
+class ThriftHiveMetastore_show_compact_args {
+ public:
+
+  ThriftHiveMetastore_show_compact_args() {
+  }
+
+  virtual ~ThriftHiveMetastore_show_compact_args() throw() {}
+
+  ShowCompactRequest rqst;
+
+  _ThriftHiveMetastore_show_compact_args__isset __isset;
+
+  void __set_rqst(const ShowCompactRequest& val) {
+    rqst = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_show_compact_args & rhs) const
+  {
+    if (!(rqst == rhs.rqst))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_show_compact_args &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_show_compact_args & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+
+class ThriftHiveMetastore_show_compact_pargs {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_show_compact_pargs() throw() {}
+
+  const ShowCompactRequest* rqst;
+
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_show_compact_result__isset {
+  _ThriftHiveMetastore_show_compact_result__isset() : success(false) {}
+  bool success;
+} _ThriftHiveMetastore_show_compact_result__isset;
+
+class ThriftHiveMetastore_show_compact_result {
+ public:
+
+  ThriftHiveMetastore_show_compact_result() {
+  }
+
+  virtual ~ThriftHiveMetastore_show_compact_result() throw() {}
+
+  ShowCompactResponse success;
+
+  _ThriftHiveMetastore_show_compact_result__isset __isset;
+
+  void __set_success(const ShowCompactResponse& val) {
+    success = val;
+  }
+
+  bool operator == (const ThriftHiveMetastore_show_compact_result & rhs) const
+  {
+    if (!(success == rhs.success))
+      return false;
+    return true;
+  }
+  bool operator != (const ThriftHiveMetastore_show_compact_result &rhs) const {
+    return !(*this == rhs);
+  }
+
+  bool operator < (const ThriftHiveMetastore_show_compact_result & ) const;
+
+  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
+  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
+
+};
+
+typedef struct _ThriftHiveMetastore_show_compact_presult__isset {
+  _ThriftHiveMetastore_show_compact_presult__isset() : success(false) {}
+  bool success;
+} _ThriftHiveMetastore_show_compact_presult__isset;
+
+class ThriftHiveMetastore_show_compact_presult {
+ public:
+
+
+  virtual ~ThriftHiveMetastore_show_compact_presult() throw() {}
+
+  ShowCompactResponse* success;
+
+  _ThriftHiveMetastore_show_compact_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, const bool cascade);
+  void send_drop_database(const std::string& name, const bool deleteData, const bool cascade);
+  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 create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context);
+  void send_create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context);
+  void recv_create_table_with_environment_context();
+  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 drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context);
+  void send_drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context);
+  void recv_drop_table_with_environment_context();
+  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 get_table_objects_by_name(std::vector<Table> & _return, const std::string& dbname, const std::vector<std::string> & tbl_names);
+  void send_get_table_objects_by_name(const std::string& dbname, const std::vector<std::string> & tbl_names);
+  void recv_get_table_objects_by_name(std::vector<Table> & _return);
+  void get_table_names_by_filter(std::vector<std::string> & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables);
+  void send_get_table_names_by_filter(const std::string& dbname, const std::string& filter, const int16_t max_tables);
+  void recv_get_table_names_by_filter(std::vector<std::string> & _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 alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context);
+  void send_alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context);
+  void recv_alter_table_with_environment_context();
+  void add_partition(Partition& _return, const Partition& new_part);
+  void send_add_partition(const Partition& new_part);
+  void recv_add_partition(Partition& _return);
+  void add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context);
+  void send_add_partition_with_environment_context(const Partition& new_part, const EnvironmentContext& environment_context);
+  void recv_add_partition_with_environment_context(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);
+  void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request);
+  void send_add_partitions_req(const AddPartitionsRequest& request);
+  void recv_add_partitions_req(AddPartitionsResult& _return);
+  void append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const EnvironmentContext& environment_context);
+  void send_append_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const EnvironmentContext& environment_context);
+  void recv_append_partition_with_environment_context(Partition& _return);
+  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);
+  void append_partition_by_name_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context);
+  void send_append_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context);
+  void recv_append_partition_by_name_with_environment_context(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_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const bool deleteData, const EnvironmentContext& environment_context);
+  void send_drop_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const bool deleteData, const EnvironmentContext& environment_context);
+  bool recv_drop_partition_with_environment_context();
+  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();
+  bool drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context);
+  void send_drop_partition_by_name_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData, const EnvironmentContext& environment_context);
+  bool recv_drop_partition_by_name_with_environment_context();
+  void drop_partitions_req(DropPartitionsResult& _return, const DropPartitionsRequest& req);
+  void send_drop_partitions_req(const DropPartitionsRequest& req);
+  void recv_drop_partitions_req(DropPartitionsResult& _return);
+  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 exchange_partition(Partition& _return, const std::map<std::string, std::string> & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name);
+  void send_exchange_partition(const std::map<std::string, std::string> & partitionSpecs, const std::string& source_db, const std::string& source_table_name, const std::string& dest_db, const std::string& dest_table_name);
+  void recv_exchange_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 get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req);
+  void send_get_partitions_by_expr(const PartitionsByExprRequest& req);
+  void recv_get_partitions_by_expr(PartitionsByExprResult& _return);
+  void get_partitions_by_names(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & names);
+  void send_get_partitions_by_names(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & names);
+  void recv_get_partitions_by_names(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 alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts);
+  void send_alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts);
+  void recv_alter_partitions();
+  void alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context);
+  void send_alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context);
+  void recv_alter_partition_with_environment_context();
+  void rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const Partition& new_part);
+  void send_rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const Partition& new_part);
+  void recv_rename_partition();
+  bool partition_name_has_valid_characters(const std::vector<std::string> & part_vals, const bool throw_exception);
+  void send_partition_name_has_valid_characters(const std::vector<std::string> & part_vals, const bool throw_exception);
+  bool recv_partition_name_has_valid_characters();
+  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 markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType);
+  void send_markPartitionForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType);
+  void recv_markPartitionForEvent();
+  bool isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType);
+  void send_isPartitionMarkedForEvent(const std::string& db_name, const std::string& tbl_name, const std::map<std::string, std::string> & part_vals, const PartitionEventType::type eventType);
+  bool recv_isPartitionMarkedForEvent();
+  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 update_table_column_statistics(const ColumnStatistics& stats_obj);
+  void send_update_table_column_statistics(const ColumnStatistics& stats_obj);
+  bool recv_update_table_column_statistics();
+  bool update_partition_column_statistics(const ColumnStatistics& stats_obj);
+  void send_update_partition_column_statistics(const ColumnStatistics& stats_obj);
+  bool recv_update_partition_column_statistics();
+  void get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name);
+  void send_get_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name);
+  void recv_get_table_column_statistics(ColumnStatistics& _return);
+  void get_partition_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name);
+  void send_get_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name);
+  void recv_get_partition_column_statistics(ColumnStatistics& _return);
+  void get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request);
+  void send_get_table_statistics_req(const TableStatsRequest& request);
+  void recv_get_table_statistics_req(TableStatsResult& _return);
+  void get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request);
+  void send_get_partitions_statistics_req(const PartitionsStatsRequest& request);
+  void recv_get_partitions_statistics_req(PartitionsStatsResult& _return);
+  bool delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name);
+  void send_delete_partition_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const std::string& col_name);
+  bool recv_delete_partition_column_statistics();
   bool delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name);
   void send_delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name);
   bool recv_delete_table_column_statistics();
@@ -13740,6 +15126,42 @@ class ThriftHiveMetastoreClient : virtua
   void cancel_delegation_token(const std::string& token_str_form);
   void send_cancel_delegation_token(const std::string& token_str_form);
   void recv_cancel_delegation_token();
+  void get_open_txns(GetOpenTxnsResponse& _return);
+  void send_get_open_txns();
+  void recv_get_open_txns(GetOpenTxnsResponse& _return);
+  void get_open_txns_info(GetOpenTxnsInfoResponse& _return);
+  void send_get_open_txns_info();
+  void recv_get_open_txns_info(GetOpenTxnsInfoResponse& _return);
+  void open_txns(OpenTxnsResponse& _return, const OpenTxnRequest& rqst);
+  void send_open_txns(const OpenTxnRequest& rqst);
+  void recv_open_txns(OpenTxnsResponse& _return);
+  void abort_txn(const AbortTxnRequest& rqst);
+  void send_abort_txn(const AbortTxnRequest& rqst);
+  void recv_abort_txn();
+  void commit_txn(const CommitTxnRequest& rqst);
+  void send_commit_txn(const CommitTxnRequest& rqst);
+  void recv_commit_txn();
+  void lock(LockResponse& _return, const LockRequest& rqst);
+  void send_lock(const LockRequest& rqst);
+  void recv_lock(LockResponse& _return);
+  void check_lock(LockResponse& _return, const CheckLockRequest& rqst);
+  void send_check_lock(const CheckLockRequest& rqst);
+  void recv_check_lock(LockResponse& _return);
+  void unlock(const UnlockRequest& rqst);
+  void send_unlock(const UnlockRequest& rqst);
+  void recv_unlock();
+  void show_locks(ShowLocksResponse& _return, const ShowLocksRequest& rqst);
+  void send_show_locks(const ShowLocksRequest& rqst);
+  void recv_show_locks(ShowLocksResponse& _return);
+  void heartbeat(const HeartbeatRequest& ids);
+  void send_heartbeat(const HeartbeatRequest& ids);
+  void recv_heartbeat();
+  void compact(const CompactionRequest& rqst);
+  void send_compact(const CompactionRequest& rqst);
+  void recv_compact();
+  void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst);
+  void send_show_compact(const ShowCompactRequest& rqst);
+  void recv_show_compact(ShowCompactResponse& _return);
 };
 
 class ThriftHiveMetastoreProcessor : public  ::facebook::fb303::FacebookServiceProcessor {
@@ -13842,6 +15264,18 @@ class ThriftHiveMetastoreProcessor : pub
   void process_get_delegation_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_renew_delegation_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
   void process_cancel_delegation_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_get_open_txns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_get_open_txns_info(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_open_txns(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_abort_txn(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_commit_txn(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_lock(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_check_lock(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_unlock(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_show_locks(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_heartbeat(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
+  void process_show_compact(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  public:
   ThriftHiveMetastoreProcessor(boost::shared_ptr<ThriftHiveMetastoreIf> iface) :
      ::facebook::fb303::FacebookServiceProcessor(iface),
@@ -13938,6 +15372,18 @@ class ThriftHiveMetastoreProcessor : pub
     processMap_["get_delegation_token"] = &ThriftHiveMetastoreProcessor::process_get_delegation_token;
     processMap_["renew_delegation_token"] = &ThriftHiveMetastoreProcessor::process_renew_delegation_token;
     processMap_["cancel_delegation_token"] = &ThriftHiveMetastoreProcessor::process_cancel_delegation_token;
+    processMap_["get_open_txns"] = &ThriftHiveMetastoreProcessor::process_get_open_txns;
+    processMap_["get_open_txns_info"] = &ThriftHiveMetastoreProcessor::process_get_open_txns_info;
+    processMap_["open_txns"] = &ThriftHiveMetastoreProcessor::process_open_txns;
+    processMap_["abort_txn"] = &ThriftHiveMetastoreProcessor::process_abort_txn;
+    processMap_["commit_txn"] = &ThriftHiveMetastoreProcessor::process_commit_txn;
+    processMap_["lock"] = &ThriftHiveMetastoreProcessor::process_lock;
+    processMap_["check_lock"] = &ThriftHiveMetastoreProcessor::process_check_lock;
+    processMap_["unlock"] = &ThriftHiveMetastoreProcessor::process_unlock;
+    processMap_["show_locks"] = &ThriftHiveMetastoreProcessor::process_show_locks;
+    processMap_["heartbeat"] = &ThriftHiveMetastoreProcessor::process_heartbeat;
+    processMap_["compact"] = &ThriftHiveMetastoreProcessor::process_compact;
+    processMap_["show_compact"] = &ThriftHiveMetastoreProcessor::process_show_compact;
   }
 
   virtual ~ThriftHiveMetastoreProcessor() {}
@@ -14851,6 +16297,121 @@ class ThriftHiveMetastoreMultiface : vir
     ifaces_[i]->cancel_delegation_token(token_str_form);
   }
 
+  void get_open_txns(GetOpenTxnsResponse& _return) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->get_open_txns(_return);
+    }
+    ifaces_[i]->get_open_txns(_return);
+    return;
+  }
+
+  void get_open_txns_info(GetOpenTxnsInfoResponse& _return) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->get_open_txns_info(_return);
+    }
+    ifaces_[i]->get_open_txns_info(_return);
+    return;
+  }
+
+  void open_txns(OpenTxnsResponse& _return, const OpenTxnRequest& rqst) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->open_txns(_return, rqst);
+    }
+    ifaces_[i]->open_txns(_return, rqst);
+    return;
+  }
+
+  void abort_txn(const AbortTxnRequest& rqst) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->abort_txn(rqst);
+    }
+    ifaces_[i]->abort_txn(rqst);
+  }
+
+  void commit_txn(const CommitTxnRequest& rqst) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->commit_txn(rqst);
+    }
+    ifaces_[i]->commit_txn(rqst);
+  }
+
+  void lock(LockResponse& _return, const LockRequest& rqst) {
+    size_t sz = ifaces_.size();
+    size_t i = 0;
+    for (; i < (sz - 1); ++i) {
+      ifaces_[i]->lock(_return, rqst);
+    }

[... 65 lines stripped ...]


Mime
View raw message