text: /**
   * Autogenerated by Thrift Compiler (0.9.0)
   *
   * DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING
   *  @generated
   */
  #ifndef ThriftHiveMetastore_H
  #define ThriftHiveMetastore_H
  
  #include <thrift/TDispatchProcessor.h>
  #include "hive_metastore_types.h"
  #include "FacebookService.h"
  
  namespace Apache { namespace Hadoop { namespace Hive {
  
  class ThriftHiveMetastoreIf : virtual public  ::facebook::fb303::FacebookServiceIf {
   public:
    virtual ~ThriftHiveMetastoreIf() {}
    virtual void create_database(const Database& database) = 0;
    virtual void get_database(Database& _return, const std::string& name) = 0;
    virtual void drop_database(const std::string& name, const bool deleteData, const bool cascade) = 0;
    virtual void get_databases(std::vector<std::string> & _return, const std::string& pattern) = 0;
    virtual void get_all_databases(std::vector<std::string> & _return) = 0;
    virtual void alter_database(const std::string& dbname, const Database& db) = 0;
    virtual void get_type(Type& _return, const std::string& name) = 0;
    virtual bool create_type(const Type& type) = 0;
    virtual bool drop_type(const std::string& type) = 0;
    virtual void get_type_all(std::map<std::string, Type> & _return, const std::string& name) = 0;
    virtual void get_fields(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name) = 0;
    virtual void get_schema(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name) = 0;
    virtual void create_table(const Table& tbl) = 0;
    virtual void create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context) = 0;
    virtual void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) = 0;
    virtual void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context) = 0;
    virtual void get_tables(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern) = 0;
    virtual void get_all_tables(std::vector<std::string> & _return, const std::string& db_name) = 0;
    virtual void get_table(Table& _return, const std::string& dbname, const std::string& tbl_name) = 0;
    virtual void get_table_objects_by_name(std::vector<Table> & _return, const std::string& dbname, const std::vector<std::string> & tbl_names) = 0;
    virtual void get_table_names_by_filter(std::vector<std::string> & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables) = 0;
    virtual void alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) = 0;
    virtual void alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) = 0;
    virtual void add_partition(Partition& _return, const Partition& new_part) = 0;
    virtual void add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context) = 0;
    virtual int32_t add_partitions(const std::vector<Partition> & new_parts) = 0;
    virtual void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals) = 0;
    virtual void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request) = 0;
    virtual void append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const EnvironmentContext& environment_context) = 0;
    virtual void append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) = 0;
    virtual void append_partition_by_name_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const EnvironmentContext& environment_context) = 0;
    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_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) = 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 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) = 0;
    virtual void drop_partitions_req(DropPartitionsResult& _return, const DropPartitionsRequest& req) = 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 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) = 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 get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req) = 0;
    virtual 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) = 0;
    virtual void alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part) = 0;
    virtual void alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts) = 0;
    virtual void alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context) = 0;
    virtual void rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const Partition& new_part) = 0;
    virtual bool partition_name_has_valid_characters(const std::vector<std::string> & part_vals, const bool throw_exception) = 0;
    virtual void get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue) = 0;
    virtual void partition_name_to_vals(std::vector<std::string> & _return, const std::string& part_name) = 0;
    virtual void partition_name_to_spec(std::map<std::string, std::string> & _return, const std::string& part_name) = 0;
    virtual 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) = 0;
    virtual 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) = 0;
    virtual void add_index(Index& _return, const Index& new_index, const Table& index_table) = 0;
    virtual void alter_index(const std::string& dbname, const std::string& base_tbl_name, const std::string& idx_name, const Index& new_idx) = 0;
    virtual bool drop_index_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& index_name, const bool deleteData) = 0;
    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 update_table_column_statistics(const ColumnStatistics& stats_obj) = 0;
    virtual bool update_partition_column_statistics(const ColumnStatistics& stats_obj) = 0;
    virtual void get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name) = 0;
    virtual 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) = 0;
    virtual void get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request) = 0;
    virtual void get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request) = 0;
    virtual void get_aggr_stats_for(AggrStats& _return, const PartitionsStatsRequest& request) = 0;
    virtual 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) = 0;
    virtual bool delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name) = 0;
    virtual void create_function(const Function& func) = 0;
    virtual void drop_function(const std::string& dbName, const std::string& funcName) = 0;
    virtual void alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc) = 0;
    virtual void get_functions(std::vector<std::string> & _return, const std::string& dbName, const std::string& pattern) = 0;
    virtual void get_function(Function& _return, const std::string& dbName, const std::string& funcName) = 0;
    virtual bool create_role(const Role& role) = 0;
    virtual bool drop_role(const std::string& role_name) = 0;
    virtual void get_role_names(std::vector<std::string> & _return) = 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 grant_revoke_role(GrantRevokeRoleResponse& _return, const GrantRevokeRoleRequest& request) = 0;
    virtual void get_principals_in_role(GetPrincipalsInRoleResponse& _return, const GetPrincipalsInRoleRequest& request) = 0;
    virtual void get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const GetRoleGrantsForPrincipalRequest& request) = 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;
    virtual void grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const GrantRevokePrivilegeRequest& request) = 0;
    virtual void set_ugi(std::vector<std::string> & _return, const std::string& user_name, const std::vector<std::string> & group_names) = 0;
    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 heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) = 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 {
   public:
    typedef ThriftHiveMetastoreIf Handler;
  
    virtual ~ThriftHiveMetastoreIfFactory() {}
  
    virtual ThriftHiveMetastoreIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) = 0;
    virtual void releaseHandler( ::facebook::fb303::FacebookServiceIf* /* handler */) = 0;
  };
  
  class ThriftHiveMetastoreIfSingletonFactory : virtual public ThriftHiveMetastoreIfFactory {
   public:
    ThriftHiveMetastoreIfSingletonFactory(const boost::shared_ptr<ThriftHiveMetastoreIf>& iface) : iface_(iface) {}
    virtual ~ThriftHiveMetastoreIfSingletonFactory() {}
  
    virtual ThriftHiveMetastoreIf* getHandler(const ::apache::thrift::TConnectionInfo&) {
      return iface_.get();
    }
    virtual void releaseHandler( ::facebook::fb303::FacebookServiceIf* /* handler */) {}
  
   protected:
    boost::shared_ptr<ThriftHiveMetastoreIf> iface_;
  };
  
  class ThriftHiveMetastoreNull : virtual public ThriftHiveMetastoreIf , virtual public  ::facebook::fb303::FacebookServiceNull {
   public:
    virtual ~ThriftHiveMetastoreNull() {}
    void create_database(const Database& /* database */) {
      return;
    }
    void get_database(Database& /* _return */, const std::string& /* name */) {
      return;
    }
    void drop_database(const std::string& /* name */, const bool /* deleteData */, const bool /* cascade */) {
      return;
    }
    void get_databases(std::vector<std::string> & /* _return */, const std::string& /* pattern */) {
      return;
    }
    void get_all_databases(std::vector<std::string> & /* _return */) {
      return;
    }
    void alter_database(const std::string& /* dbname */, const Database& /* db */) {
      return;
    }
    void get_type(Type& /* _return */, const std::string& /* name */) {
      return;
    }
    bool create_type(const Type& /* type */) {
      bool _return = false;
      return _return;
    }
    bool drop_type(const std::string& /* type */) {
      bool _return = false;
      return _return;
    }
    void get_type_all(std::map<std::string, Type> & /* _return */, const std::string& /* name */) {
      return;
    }
    void get_fields(std::vector<FieldSchema> & /* _return */, const std::string& /* db_name */, const std::string& /* table_name */) {
      return;
    }
    void get_schema(std::vector<FieldSchema> & /* _return */, const std::string& /* db_name */, const std::string& /* table_name */) {
      return;
    }
    void create_table(const Table& /* tbl */) {
      return;
    }
    void create_table_with_environment_context(const Table& /* tbl */, const EnvironmentContext& /* environment_context */) {
      return;
    }
    void drop_table(const std::string& /* dbname */, const std::string& /* name */, const bool /* deleteData */) {
      return;
    }
    void drop_table_with_environment_context(const std::string& /* dbname */, const std::string& /* name */, const bool /* deleteData */, const EnvironmentContext& /* environment_context */) {
      return;
    }
    void get_tables(std::vector<std::string> & /* _return */, const std::string& /* db_name */, const std::string& /* pattern */) {
      return;
    }
    void get_all_tables(std::vector<std::string> & /* _return */, const std::string& /* db_name */) {
      return;
    }
    void get_table(Table& /* _return */, const std::string& /* dbname */, const std::string& /* tbl_name */) {
      return;
    }
    void get_table_objects_by_name(std::vector<Table> & /* _return */, const std::string& /* dbname */, const std::vector<std::string> & /* tbl_names */) {
      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 */) {
      return;
    }
    void alter_table(const std::string& /* dbname */, const std::string& /* tbl_name */, const Table& /* new_tbl */) {
      return;
    }
    void alter_table_with_environment_context(const std::string& /* dbname */, const std::string& /* tbl_name */, const Table& /* new_tbl */, const EnvironmentContext& /* environment_context */) {
      return;
    }
    void add_partition(Partition& /* _return */, const Partition& /* new_part */) {
      return;
    }
    void add_partition_with_environment_context(Partition& /* _return */, const Partition& /* new_part */, const EnvironmentContext& /* environment_context */) {
      return;
    }
    int32_t add_partitions(const std::vector<Partition> & /* new_parts */) {
      int32_t _return = 0;
      return _return;
    }
    void append_partition(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector<std::string> & /* part_vals */) {
      return;
    }
    void add_partitions_req(AddPartitionsResult& /* _return */, const AddPartitionsRequest& /* request */) {
      return;
    }
    void append_partition_with_environment_context(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector<std::string> & /* part_vals */, const EnvironmentContext& /* environment_context */) {
      return;
    }
    void append_partition_by_name(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* part_name */) {
      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 */) {
      return;
    }
    bool drop_partition(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector<std::string> & /* part_vals */, const bool /* deleteData */) {
      bool _return = false;
      return _return;
    }
    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 */) {
      bool _return = false;
      return _return;
    }
    bool drop_partition_by_name(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* part_name */, const bool /* deleteData */) {
      bool _return = false;
      return _return;
    }
    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 */) {
      bool _return = false;
      return _return;
    }
    void drop_partitions_req(DropPartitionsResult& /* _return */, const DropPartitionsRequest& /* req */) {
      return;
    }
    void get_partition(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector<std::string> & /* part_vals */) {
      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 */) {
      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;
    }
    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 */) {
      return;
    }
    void get_partitions_by_expr(PartitionsByExprResult& /* _return */, const PartitionsByExprRequest& /* req */) {
      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 */) {
      return;
    }
    void alter_partition(const std::string& /* db_name */, const std::string& /* tbl_name */, const Partition& /* new_part */) {
      return;
    }
    void alter_partitions(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector<Partition> & /* new_parts */) {
      return;
    }
    void alter_partition_with_environment_context(const std::string& /* db_name */, const std::string& /* tbl_name */, const Partition& /* new_part */, const EnvironmentContext& /* environment_context */) {
      return;
    }
    void rename_partition(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector<std::string> & /* part_vals */, const Partition& /* new_part */) {
      return;
    }
    bool partition_name_has_valid_characters(const std::vector<std::string> & /* part_vals */, const bool /* throw_exception */) {
      bool _return = false;
      return _return;
    }
    void get_config_value(std::string& /* _return */, const std::string& /* name */, const std::string& /* defaultValue */) {
      return;
    }
    void partition_name_to_vals(std::vector<std::string> & /* _return */, const std::string& /* part_name */) {
      return;
    }
    void partition_name_to_spec(std::map<std::string, std::string> & /* _return */, const std::string& /* part_name */) {
      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 */) {
      return;
    }
    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 */) {
      bool _return = false;
      return _return;
    }
    void add_index(Index& /* _return */, const Index& /* new_index */, const Table& /* index_table */) {
      return;
    }
    void alter_index(const std::string& /* dbname */, const std::string& /* base_tbl_name */, const std::string& /* idx_name */, const Index& /* new_idx */) {
      return;
    }
    bool drop_index_by_name(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* index_name */, const bool /* deleteData */) {
      bool _return = false;
      return _return;
    }
    void get_index_by_name(Index& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* index_name */) {
      return;
    }
    void get_indexes(std::vector<Index> & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const int16_t /* max_indexes */) {
      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 */) {
      return;
    }
    bool update_table_column_statistics(const ColumnStatistics& /* stats_obj */) {
      bool _return = false;
      return _return;
    }
    bool update_partition_column_statistics(const ColumnStatistics& /* stats_obj */) {
      bool _return = false;
      return _return;
    }
    void get_table_column_statistics(ColumnStatistics& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* col_name */) {
      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 */) {
      return;
    }
    void get_table_statistics_req(TableStatsResult& /* _return */, const TableStatsRequest& /* request */) {
      return;
    }
    void get_partitions_statistics_req(PartitionsStatsResult& /* _return */, const PartitionsStatsRequest& /* request */) {
      return;
    }
    void get_aggr_stats_for(AggrStats& /* _return */, const PartitionsStatsRequest& /* request */) {
      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 */) {
      bool _return = false;
      return _return;
    }
    bool delete_table_column_statistics(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* col_name */) {
      bool _return = false;
      return _return;
    }
    void create_function(const Function& /* func */) {
      return;
    }
    void drop_function(const std::string& /* dbName */, const std::string& /* funcName */) {
      return;
    }
    void alter_function(const std::string& /* dbName */, const std::string& /* funcName */, const Function& /* newFunc */) {
      return;
    }
    void get_functions(std::vector<std::string> & /* _return */, const std::string& /* dbName */, const std::string& /* pattern */) {
      return;
    }
    void get_function(Function& /* _return */, const std::string& /* dbName */, const std::string& /* funcName */) {
      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;
    }
    void get_role_names(std::vector<std::string> & /* _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 grant_revoke_role(GrantRevokeRoleResponse& /* _return */, const GrantRevokeRoleRequest& /* request */) {
      return;
    }
    void get_principals_in_role(GetPrincipalsInRoleResponse& /* _return */, const GetPrincipalsInRoleRequest& /* request */) {
      return;
    }
    void get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& /* _return */, const GetRoleGrantsForPrincipalRequest& /* request */) {
      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;
    }
    void grant_revoke_privileges(GrantRevokePrivilegeResponse& /* _return */, const GrantRevokePrivilegeRequest& /* request */) {
      return;
    }
    void set_ugi(std::vector<std::string> & /* _return */, const std::string& /* user_name */, const std::vector<std::string> & /* group_names */) {
      return;
    }
    void get_delegation_token(std::string& /* _return */, const std::string& /* token_owner */, const std::string& /* renewer_kerberos_principal_name */) {
      return;
    }
    int64_t renew_delegation_token(const std::string& /* token_str_form */) {
      int64_t _return = 0;
      return _return;
    }
    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 heartbeat_txn_range(HeartbeatTxnRangeResponse& /* _return */, const HeartbeatTxnRangeRequest& /* txns */) {
      return;
    }
    void compact(const CompactionRequest& /* rqst */) {
      return;
    }
    void show_compact(ShowCompactResponse& /* _return */, const ShowCompactRequest& /* rqst */) {
      return;
    }
  };
  
  typedef struct _ThriftHiveMetastore_create_database_args__isset {
    _ThriftHiveMetastore_create_database_args__isset() : database(false) {}
    bool database;
  } _ThriftHiveMetastore_create_database_args__isset;
  
  class ThriftHiveMetastore_create_database_args {
   public:
  
    ThriftHiveMetastore_create_database_args() {
    }
  
    virtual ~ThriftHiveMetastore_create_database_args() throw() {}
  
    Database database;
  
    _ThriftHiveMetastore_create_database_args__isset __isset;
  
    void __set_database(const Database& val) {
      database = val;
    }
  
    bool operator == (const ThriftHiveMetastore_create_database_args & rhs) const
    {
      if (!(database == rhs.database))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_create_database_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_create_database_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_create_database_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_create_database_pargs() throw() {}
  
    const Database* database;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_create_database_result__isset {
    _ThriftHiveMetastore_create_database_result__isset() : o1(false), o2(false), o3(false) {}
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_create_database_result__isset;
  
  class ThriftHiveMetastore_create_database_result {
   public:
  
    ThriftHiveMetastore_create_database_result() {
    }
  
    virtual ~ThriftHiveMetastore_create_database_result() throw() {}
  
    AlreadyExistsException o1;
    InvalidObjectException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_create_database_result__isset __isset;
  
    void __set_o1(const AlreadyExistsException& val) {
      o1 = val;
    }
  
    void __set_o2(const InvalidObjectException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_create_database_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_create_database_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_create_database_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_create_database_presult__isset {
    _ThriftHiveMetastore_create_database_presult__isset() : o1(false), o2(false), o3(false) {}
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_create_database_presult__isset;
  
  class ThriftHiveMetastore_create_database_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_create_database_presult() throw() {}
  
    AlreadyExistsException o1;
    InvalidObjectException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_create_database_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_database_args__isset {
    _ThriftHiveMetastore_get_database_args__isset() : name(false) {}
    bool name;
  } _ThriftHiveMetastore_get_database_args__isset;
  
  class ThriftHiveMetastore_get_database_args {
   public:
  
    ThriftHiveMetastore_get_database_args() : name() {
    }
  
    virtual ~ThriftHiveMetastore_get_database_args() throw() {}
  
    std::string name;
  
    _ThriftHiveMetastore_get_database_args__isset __isset;
  
    void __set_name(const std::string& val) {
      name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_database_args & rhs) const
    {
      if (!(name == rhs.name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_database_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_database_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_database_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_database_pargs() throw() {}
  
    const std::string* name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_database_result__isset {
    _ThriftHiveMetastore_get_database_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_database_result__isset;
  
  class ThriftHiveMetastore_get_database_result {
   public:
  
    ThriftHiveMetastore_get_database_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_database_result() throw() {}
  
    Database success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_get_database_result__isset __isset;
  
    void __set_success(const Database& val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_database_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_database_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_database_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_database_presult__isset {
    _ThriftHiveMetastore_get_database_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_database_presult__isset;
  
  class ThriftHiveMetastore_get_database_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_database_presult() throw() {}
  
    Database* success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_get_database_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_database_args__isset {
    _ThriftHiveMetastore_drop_database_args__isset() : name(false), deleteData(false), cascade(false) {}
    bool name;
    bool deleteData;
    bool cascade;
  } _ThriftHiveMetastore_drop_database_args__isset;
  
  class ThriftHiveMetastore_drop_database_args {
   public:
  
    ThriftHiveMetastore_drop_database_args() : name(), deleteData(0), cascade(0) {
    }
  
    virtual ~ThriftHiveMetastore_drop_database_args() throw() {}
  
    std::string name;
    bool deleteData;
    bool cascade;
  
    _ThriftHiveMetastore_drop_database_args__isset __isset;
  
    void __set_name(const std::string& val) {
      name = val;
    }
  
    void __set_deleteData(const bool val) {
      deleteData = val;
    }
  
    void __set_cascade(const bool val) {
      cascade = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_database_args & rhs) const
    {
      if (!(name == rhs.name))
        return false;
      if (!(deleteData == rhs.deleteData))
        return false;
      if (!(cascade == rhs.cascade))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_drop_database_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_database_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_drop_database_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_database_pargs() throw() {}
  
    const std::string* name;
    const bool* deleteData;
    const bool* cascade;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_database_result__isset {
    _ThriftHiveMetastore_drop_database_result__isset() : o1(false), o2(false), o3(false) {}
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_drop_database_result__isset;
  
  class ThriftHiveMetastore_drop_database_result {
   public:
  
    ThriftHiveMetastore_drop_database_result() {
    }
  
    virtual ~ThriftHiveMetastore_drop_database_result() throw() {}
  
    NoSuchObjectException o1;
    InvalidOperationException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_drop_database_result__isset __isset;
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const InvalidOperationException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_database_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_drop_database_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_database_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_database_presult__isset {
    _ThriftHiveMetastore_drop_database_presult__isset() : o1(false), o2(false), o3(false) {}
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_drop_database_presult__isset;
  
  class ThriftHiveMetastore_drop_database_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_database_presult() throw() {}
  
    NoSuchObjectException o1;
    InvalidOperationException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_drop_database_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_databases_args__isset {
    _ThriftHiveMetastore_get_databases_args__isset() : pattern(false) {}
    bool pattern;
  } _ThriftHiveMetastore_get_databases_args__isset;
  
  class ThriftHiveMetastore_get_databases_args {
   public:
  
    ThriftHiveMetastore_get_databases_args() : pattern() {
    }
  
    virtual ~ThriftHiveMetastore_get_databases_args() throw() {}
  
    std::string pattern;
  
    _ThriftHiveMetastore_get_databases_args__isset __isset;
  
    void __set_pattern(const std::string& val) {
      pattern = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_databases_args & rhs) const
    {
      if (!(pattern == rhs.pattern))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_databases_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_databases_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_databases_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_databases_pargs() throw() {}
  
    const std::string* pattern;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_databases_result__isset {
    _ThriftHiveMetastore_get_databases_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_databases_result__isset;
  
  class ThriftHiveMetastore_get_databases_result {
   public:
  
    ThriftHiveMetastore_get_databases_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_databases_result() throw() {}
  
    std::vector<std::string>  success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_databases_result__isset __isset;
  
    void __set_success(const std::vector<std::string> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_databases_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_databases_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_databases_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_databases_presult__isset {
    _ThriftHiveMetastore_get_databases_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_databases_presult__isset;
  
  class ThriftHiveMetastore_get_databases_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_databases_presult() throw() {}
  
    std::vector<std::string> * success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_databases_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  
  class ThriftHiveMetastore_get_all_databases_args {
   public:
  
    ThriftHiveMetastore_get_all_databases_args() {
    }
  
    virtual ~ThriftHiveMetastore_get_all_databases_args() throw() {}
  
  
    bool operator == (const ThriftHiveMetastore_get_all_databases_args & /* rhs */) const
    {
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_all_databases_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_all_databases_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_all_databases_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_all_databases_pargs() throw() {}
  
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_all_databases_result__isset {
    _ThriftHiveMetastore_get_all_databases_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_all_databases_result__isset;
  
  class ThriftHiveMetastore_get_all_databases_result {
   public:
  
    ThriftHiveMetastore_get_all_databases_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_all_databases_result() throw() {}
  
    std::vector<std::string>  success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_all_databases_result__isset __isset;
  
    void __set_success(const std::vector<std::string> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_all_databases_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_all_databases_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_all_databases_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_all_databases_presult__isset {
    _ThriftHiveMetastore_get_all_databases_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_all_databases_presult__isset;
  
  class ThriftHiveMetastore_get_all_databases_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_all_databases_presult() throw() {}
  
    std::vector<std::string> * success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_all_databases_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_database_args__isset {
    _ThriftHiveMetastore_alter_database_args__isset() : dbname(false), db(false) {}
    bool dbname;
    bool db;
  } _ThriftHiveMetastore_alter_database_args__isset;
  
  class ThriftHiveMetastore_alter_database_args {
   public:
  
    ThriftHiveMetastore_alter_database_args() : dbname() {
    }
  
    virtual ~ThriftHiveMetastore_alter_database_args() throw() {}
  
    std::string dbname;
    Database db;
  
    _ThriftHiveMetastore_alter_database_args__isset __isset;
  
    void __set_dbname(const std::string& val) {
      dbname = val;
    }
  
    void __set_db(const Database& val) {
      db = val;
    }
  
    bool operator == (const ThriftHiveMetastore_alter_database_args & rhs) const
    {
      if (!(dbname == rhs.dbname))
        return false;
      if (!(db == rhs.db))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_alter_database_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_alter_database_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_alter_database_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_alter_database_pargs() throw() {}
  
    const std::string* dbname;
    const Database* db;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_database_result__isset {
    _ThriftHiveMetastore_alter_database_result__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_alter_database_result__isset;
  
  class ThriftHiveMetastore_alter_database_result {
   public:
  
    ThriftHiveMetastore_alter_database_result() {
    }
  
    virtual ~ThriftHiveMetastore_alter_database_result() throw() {}
  
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_alter_database_result__isset __isset;
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_alter_database_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_alter_database_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_alter_database_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_database_presult__isset {
    _ThriftHiveMetastore_alter_database_presult__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_alter_database_presult__isset;
  
  class ThriftHiveMetastore_alter_database_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_alter_database_presult() throw() {}
  
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_alter_database_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_type_args__isset {
    _ThriftHiveMetastore_get_type_args__isset() : name(false) {}
    bool name;
  } _ThriftHiveMetastore_get_type_args__isset;
  
  class ThriftHiveMetastore_get_type_args {
   public:
  
    ThriftHiveMetastore_get_type_args() : name() {
    }
  
    virtual ~ThriftHiveMetastore_get_type_args() throw() {}
  
    std::string name;
  
    _ThriftHiveMetastore_get_type_args__isset __isset;
  
    void __set_name(const std::string& val) {
      name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_type_args & rhs) const
    {
      if (!(name == rhs.name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_type_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_type_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_type_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_type_pargs() throw() {}
  
    const std::string* name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_type_result__isset {
    _ThriftHiveMetastore_get_type_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_type_result__isset;
  
  class ThriftHiveMetastore_get_type_result {
   public:
  
    ThriftHiveMetastore_get_type_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_type_result() throw() {}
  
    Type success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_type_result__isset __isset;
  
    void __set_success(const Type& val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_type_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_type_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_type_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_type_presult__isset {
    _ThriftHiveMetastore_get_type_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_type_presult__isset;
  
  class ThriftHiveMetastore_get_type_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_type_presult() throw() {}
  
    Type* success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_type_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_create_type_args__isset {
    _ThriftHiveMetastore_create_type_args__isset() : type(false) {}
    bool type;
  } _ThriftHiveMetastore_create_type_args__isset;
  
  class ThriftHiveMetastore_create_type_args {
   public:
  
    ThriftHiveMetastore_create_type_args() {
    }
  
    virtual ~ThriftHiveMetastore_create_type_args() throw() {}
  
    Type type;
  
    _ThriftHiveMetastore_create_type_args__isset __isset;
  
    void __set_type(const Type& val) {
      type = val;
    }
  
    bool operator == (const ThriftHiveMetastore_create_type_args & rhs) const
    {
      if (!(type == rhs.type))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_create_type_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_create_type_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_create_type_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_create_type_pargs() throw() {}
  
    const Type* type;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_create_type_result__isset {
    _ThriftHiveMetastore_create_type_result__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_create_type_result__isset;
  
  class ThriftHiveMetastore_create_type_result {
   public:
  
    ThriftHiveMetastore_create_type_result() : success(0) {
    }
  
    virtual ~ThriftHiveMetastore_create_type_result() throw() {}
  
    bool success;
    AlreadyExistsException o1;
    InvalidObjectException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_create_type_result__isset __isset;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const AlreadyExistsException& val) {
      o1 = val;
    }
  
    void __set_o2(const InvalidObjectException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_create_type_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_create_type_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_create_type_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_create_type_presult__isset {
    _ThriftHiveMetastore_create_type_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_create_type_presult__isset;
  
  class ThriftHiveMetastore_create_type_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_create_type_presult() throw() {}
  
    bool* success;
    AlreadyExistsException o1;
    InvalidObjectException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_create_type_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_type_args__isset {
    _ThriftHiveMetastore_drop_type_args__isset() : type(false) {}
    bool type;
  } _ThriftHiveMetastore_drop_type_args__isset;
  
  class ThriftHiveMetastore_drop_type_args {
   public:
  
    ThriftHiveMetastore_drop_type_args() : type() {
    }
  
    virtual ~ThriftHiveMetastore_drop_type_args() throw() {}
  
    std::string type;
  
    _ThriftHiveMetastore_drop_type_args__isset __isset;
  
    void __set_type(const std::string& val) {
      type = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_type_args & rhs) const
    {
      if (!(type == rhs.type))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_drop_type_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_type_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_drop_type_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_type_pargs() throw() {}
  
    const std::string* type;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_type_result__isset {
    _ThriftHiveMetastore_drop_type_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_drop_type_result__isset;
  
  class ThriftHiveMetastore_drop_type_result {
   public:
  
    ThriftHiveMetastore_drop_type_result() : success(0) {
    }
  
    virtual ~ThriftHiveMetastore_drop_type_result() throw() {}
  
    bool success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_drop_type_result__isset __isset;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_type_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_drop_type_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_type_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_type_presult__isset {
    _ThriftHiveMetastore_drop_type_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_drop_type_presult__isset;
  
  class ThriftHiveMetastore_drop_type_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_type_presult() throw() {}
  
    bool* success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_drop_type_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_type_all_args__isset {
    _ThriftHiveMetastore_get_type_all_args__isset() : name(false) {}
    bool name;
  } _ThriftHiveMetastore_get_type_all_args__isset;
  
  class ThriftHiveMetastore_get_type_all_args {
   public:
  
    ThriftHiveMetastore_get_type_all_args() : name() {
    }
  
    virtual ~ThriftHiveMetastore_get_type_all_args() throw() {}
  
    std::string name;
  
    _ThriftHiveMetastore_get_type_all_args__isset __isset;
  
    void __set_name(const std::string& val) {
      name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_type_all_args & rhs) const
    {
      if (!(name == rhs.name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_type_all_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_type_all_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_type_all_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_type_all_pargs() throw() {}
  
    const std::string* name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_type_all_result__isset {
    _ThriftHiveMetastore_get_type_all_result__isset() : success(false), o2(false) {}
    bool success;
    bool o2;
  } _ThriftHiveMetastore_get_type_all_result__isset;
  
  class ThriftHiveMetastore_get_type_all_result {
   public:
  
    ThriftHiveMetastore_get_type_all_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_type_all_result() throw() {}
  
    std::map<std::string, Type>  success;
    MetaException o2;
  
    _ThriftHiveMetastore_get_type_all_result__isset __isset;
  
    void __set_success(const std::map<std::string, Type> & val) {
      success = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_type_all_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_type_all_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_type_all_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_type_all_presult__isset {
    _ThriftHiveMetastore_get_type_all_presult__isset() : success(false), o2(false) {}
    bool success;
    bool o2;
  } _ThriftHiveMetastore_get_type_all_presult__isset;
  
  class ThriftHiveMetastore_get_type_all_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_type_all_presult() throw() {}
  
    std::map<std::string, Type> * success;
    MetaException o2;
  
    _ThriftHiveMetastore_get_type_all_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_fields_args__isset {
    _ThriftHiveMetastore_get_fields_args__isset() : db_name(false), table_name(false) {}
    bool db_name;
    bool table_name;
  } _ThriftHiveMetastore_get_fields_args__isset;
  
  class ThriftHiveMetastore_get_fields_args {
   public:
  
    ThriftHiveMetastore_get_fields_args() : db_name(), table_name() {
    }
  
    virtual ~ThriftHiveMetastore_get_fields_args() throw() {}
  
    std::string db_name;
    std::string table_name;
  
    _ThriftHiveMetastore_get_fields_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_table_name(const std::string& val) {
      table_name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_fields_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(table_name == rhs.table_name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_fields_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_fields_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_fields_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_fields_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* table_name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_fields_result__isset {
    _ThriftHiveMetastore_get_fields_result__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_get_fields_result__isset;
  
  class ThriftHiveMetastore_get_fields_result {
   public:
  
    ThriftHiveMetastore_get_fields_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_fields_result() throw() {}
  
    std::vector<FieldSchema>  success;
    MetaException o1;
    UnknownTableException o2;
    UnknownDBException o3;
  
    _ThriftHiveMetastore_get_fields_result__isset __isset;
  
    void __set_success(const std::vector<FieldSchema> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const UnknownTableException& val) {
      o2 = val;
    }
  
    void __set_o3(const UnknownDBException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_fields_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_get_fields_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_fields_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_fields_presult__isset {
    _ThriftHiveMetastore_get_fields_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_get_fields_presult__isset;
  
  class ThriftHiveMetastore_get_fields_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_fields_presult() throw() {}
  
    std::vector<FieldSchema> * success;
    MetaException o1;
    UnknownTableException o2;
    UnknownDBException o3;
  
    _ThriftHiveMetastore_get_fields_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_schema_args__isset {
    _ThriftHiveMetastore_get_schema_args__isset() : db_name(false), table_name(false) {}
    bool db_name;
    bool table_name;
  } _ThriftHiveMetastore_get_schema_args__isset;
  
  class ThriftHiveMetastore_get_schema_args {
   public:
  
    ThriftHiveMetastore_get_schema_args() : db_name(), table_name() {
    }
  
    virtual ~ThriftHiveMetastore_get_schema_args() throw() {}
  
    std::string db_name;
    std::string table_name;
  
    _ThriftHiveMetastore_get_schema_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_table_name(const std::string& val) {
      table_name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_schema_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(table_name == rhs.table_name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_schema_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_schema_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_schema_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_schema_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* table_name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_schema_result__isset {
    _ThriftHiveMetastore_get_schema_result__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_get_schema_result__isset;
  
  class ThriftHiveMetastore_get_schema_result {
   public:
  
    ThriftHiveMetastore_get_schema_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_schema_result() throw() {}
  
    std::vector<FieldSchema>  success;
    MetaException o1;
    UnknownTableException o2;
    UnknownDBException o3;
  
    _ThriftHiveMetastore_get_schema_result__isset __isset;
  
    void __set_success(const std::vector<FieldSchema> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const UnknownTableException& val) {
      o2 = val;
    }
  
    void __set_o3(const UnknownDBException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_schema_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_get_schema_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_schema_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_schema_presult__isset {
    _ThriftHiveMetastore_get_schema_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_get_schema_presult__isset;
  
  class ThriftHiveMetastore_get_schema_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_schema_presult() throw() {}
  
    std::vector<FieldSchema> * success;
    MetaException o1;
    UnknownTableException o2;
    UnknownDBException o3;
  
    _ThriftHiveMetastore_get_schema_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_create_table_args__isset {
    _ThriftHiveMetastore_create_table_args__isset() : tbl(false) {}
    bool tbl;
  } _ThriftHiveMetastore_create_table_args__isset;
  
  class ThriftHiveMetastore_create_table_args {
   public:
  
    ThriftHiveMetastore_create_table_args() {
    }
  
    virtual ~ThriftHiveMetastore_create_table_args() throw() {}
  
    Table tbl;
  
    _ThriftHiveMetastore_create_table_args__isset __isset;
  
    void __set_tbl(const Table& val) {
      tbl = val;
    }
  
    bool operator == (const ThriftHiveMetastore_create_table_args & rhs) const
    {
      if (!(tbl == rhs.tbl))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_create_table_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_create_table_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_create_table_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_create_table_pargs() throw() {}
  
    const Table* tbl;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_create_table_result__isset {
    _ThriftHiveMetastore_create_table_result__isset() : o1(false), o2(false), o3(false), o4(false) {}
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_create_table_result__isset;
  
  class ThriftHiveMetastore_create_table_result {
   public:
  
    ThriftHiveMetastore_create_table_result() {
    }
  
    virtual ~ThriftHiveMetastore_create_table_result() throw() {}
  
    AlreadyExistsException o1;
    InvalidObjectException o2;
    MetaException o3;
    NoSuchObjectException o4;
  
    _ThriftHiveMetastore_create_table_result__isset __isset;
  
    void __set_o1(const AlreadyExistsException& val) {
      o1 = val;
    }
  
    void __set_o2(const InvalidObjectException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    void __set_o4(const NoSuchObjectException& val) {
      o4 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_create_table_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      if (!(o3 == rhs.o3))
        return false;
      if (!(o4 == rhs.o4))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_create_table_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_create_table_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_create_table_presult__isset {
    _ThriftHiveMetastore_create_table_presult__isset() : o1(false), o2(false), o3(false), o4(false) {}
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_create_table_presult__isset;
  
  class ThriftHiveMetastore_create_table_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_create_table_presult() throw() {}
  
    AlreadyExistsException o1;
    InvalidObjectException o2;
    MetaException o3;
    NoSuchObjectException o4;
  
    _ThriftHiveMetastore_create_table_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_create_table_with_environment_context_args__isset {
    _ThriftHiveMetastore_create_table_with_environment_context_args__isset() : tbl(false), environment_context(false) {}
    bool tbl;
    bool environment_context;
  } _ThriftHiveMetastore_create_table_with_environment_context_args__isset;
  
  class ThriftHiveMetastore_create_table_with_environment_context_args {
   public:
  
    ThriftHiveMetastore_create_table_with_environment_context_args() {
    }
  
    virtual ~ThriftHiveMetastore_create_table_with_environment_context_args() throw() {}
  
    Table tbl;
    EnvironmentContext environment_context;
  
    _ThriftHiveMetastore_create_table_with_environment_context_args__isset __isset;
  
    void __set_tbl(const Table& val) {
      tbl = val;
    }
  
    void __set_environment_context(const EnvironmentContext& val) {
      environment_context = val;
    }
  
    bool operator == (const ThriftHiveMetastore_create_table_with_environment_context_args & rhs) const
    {
      if (!(tbl == rhs.tbl))
        return false;
      if (!(environment_context == rhs.environment_context))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_create_table_with_environment_context_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_create_table_with_environment_context_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_create_table_with_environment_context_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_create_table_with_environment_context_pargs() throw() {}
  
    const Table* tbl;
    const EnvironmentContext* environment_context;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_create_table_with_environment_context_result__isset {
    _ThriftHiveMetastore_create_table_with_environment_context_result__isset() : o1(false), o2(false), o3(false), o4(false) {}
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_create_table_with_environment_context_result__isset;
  
  class ThriftHiveMetastore_create_table_with_environment_context_result {
   public:
  
    ThriftHiveMetastore_create_table_with_environment_context_result() {
    }
  
    virtual ~ThriftHiveMetastore_create_table_with_environment_context_result() throw() {}
  
    AlreadyExistsException o1;
    InvalidObjectException o2;
    MetaException o3;
    NoSuchObjectException o4;
  
    _ThriftHiveMetastore_create_table_with_environment_context_result__isset __isset;
  
    void __set_o1(const AlreadyExistsException& val) {
      o1 = val;
    }
  
    void __set_o2(const InvalidObjectException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    void __set_o4(const NoSuchObjectException& val) {
      o4 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_create_table_with_environment_context_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      if (!(o3 == rhs.o3))
        return false;
      if (!(o4 == rhs.o4))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_create_table_with_environment_context_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_create_table_with_environment_context_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_create_table_with_environment_context_presult__isset {
    _ThriftHiveMetastore_create_table_with_environment_context_presult__isset() : o1(false), o2(false), o3(false), o4(false) {}
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_create_table_with_environment_context_presult__isset;
  
  class ThriftHiveMetastore_create_table_with_environment_context_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_create_table_with_environment_context_presult() throw() {}
  
    AlreadyExistsException o1;
    InvalidObjectException o2;
    MetaException o3;
    NoSuchObjectException o4;
  
    _ThriftHiveMetastore_create_table_with_environment_context_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_table_args__isset {
    _ThriftHiveMetastore_drop_table_args__isset() : dbname(false), name(false), deleteData(false) {}
    bool dbname;
    bool name;
    bool deleteData;
  } _ThriftHiveMetastore_drop_table_args__isset;
  
  class ThriftHiveMetastore_drop_table_args {
   public:
  
    ThriftHiveMetastore_drop_table_args() : dbname(), name(), deleteData(0) {
    }
  
    virtual ~ThriftHiveMetastore_drop_table_args() throw() {}
  
    std::string dbname;
    std::string name;
    bool deleteData;
  
    _ThriftHiveMetastore_drop_table_args__isset __isset;
  
    void __set_dbname(const std::string& val) {
      dbname = val;
    }
  
    void __set_name(const std::string& val) {
      name = val;
    }
  
    void __set_deleteData(const bool val) {
      deleteData = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_table_args & rhs) const
    {
      if (!(dbname == rhs.dbname))
        return false;
      if (!(name == rhs.name))
        return false;
      if (!(deleteData == rhs.deleteData))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_drop_table_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_table_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_drop_table_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_table_pargs() throw() {}
  
    const std::string* dbname;
    const std::string* name;
    const bool* deleteData;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_table_result__isset {
    _ThriftHiveMetastore_drop_table_result__isset() : o1(false), o3(false) {}
    bool o1;
    bool o3;
  } _ThriftHiveMetastore_drop_table_result__isset;
  
  class ThriftHiveMetastore_drop_table_result {
   public:
  
    ThriftHiveMetastore_drop_table_result() {
    }
  
    virtual ~ThriftHiveMetastore_drop_table_result() throw() {}
  
    NoSuchObjectException o1;
    MetaException o3;
  
    _ThriftHiveMetastore_drop_table_result__isset __isset;
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_table_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      if (!(o3 == rhs.o3))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_drop_table_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_table_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_table_presult__isset {
    _ThriftHiveMetastore_drop_table_presult__isset() : o1(false), o3(false) {}
    bool o1;
    bool o3;
  } _ThriftHiveMetastore_drop_table_presult__isset;
  
  class ThriftHiveMetastore_drop_table_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_table_presult() throw() {}
  
    NoSuchObjectException o1;
    MetaException o3;
  
    _ThriftHiveMetastore_drop_table_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_table_with_environment_context_args__isset {
    _ThriftHiveMetastore_drop_table_with_environment_context_args__isset() : dbname(false), name(false), deleteData(false), environment_context(false) {}
    bool dbname;
    bool name;
    bool deleteData;
    bool environment_context;
  } _ThriftHiveMetastore_drop_table_with_environment_context_args__isset;
  
  class ThriftHiveMetastore_drop_table_with_environment_context_args {
   public:
  
    ThriftHiveMetastore_drop_table_with_environment_context_args() : dbname(), name(), deleteData(0) {
    }
  
    virtual ~ThriftHiveMetastore_drop_table_with_environment_context_args() throw() {}
  
    std::string dbname;
    std::string name;
    bool deleteData;
    EnvironmentContext environment_context;
  
    _ThriftHiveMetastore_drop_table_with_environment_context_args__isset __isset;
  
    void __set_dbname(const std::string& val) {
      dbname = val;
    }
  
    void __set_name(const std::string& val) {
      name = val;
    }
  
    void __set_deleteData(const bool val) {
      deleteData = val;
    }
  
    void __set_environment_context(const EnvironmentContext& val) {
      environment_context = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_table_with_environment_context_args & rhs) const
    {
      if (!(dbname == rhs.dbname))
        return false;
      if (!(name == rhs.name))
        return false;
      if (!(deleteData == rhs.deleteData))
        return false;
      if (!(environment_context == rhs.environment_context))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_drop_table_with_environment_context_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_table_with_environment_context_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_drop_table_with_environment_context_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_table_with_environment_context_pargs() throw() {}
  
    const std::string* dbname;
    const std::string* name;
    const bool* deleteData;
    const EnvironmentContext* environment_context;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_table_with_environment_context_result__isset {
    _ThriftHiveMetastore_drop_table_with_environment_context_result__isset() : o1(false), o3(false) {}
    bool o1;
    bool o3;
  } _ThriftHiveMetastore_drop_table_with_environment_context_result__isset;
  
  class ThriftHiveMetastore_drop_table_with_environment_context_result {
   public:
  
    ThriftHiveMetastore_drop_table_with_environment_context_result() {
    }
  
    virtual ~ThriftHiveMetastore_drop_table_with_environment_context_result() throw() {}
  
    NoSuchObjectException o1;
    MetaException o3;
  
    _ThriftHiveMetastore_drop_table_with_environment_context_result__isset __isset;
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_table_with_environment_context_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      if (!(o3 == rhs.o3))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_drop_table_with_environment_context_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_table_with_environment_context_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_table_with_environment_context_presult__isset {
    _ThriftHiveMetastore_drop_table_with_environment_context_presult__isset() : o1(false), o3(false) {}
    bool o1;
    bool o3;
  } _ThriftHiveMetastore_drop_table_with_environment_context_presult__isset;
  
  class ThriftHiveMetastore_drop_table_with_environment_context_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_table_with_environment_context_presult() throw() {}
  
    NoSuchObjectException o1;
    MetaException o3;
  
    _ThriftHiveMetastore_drop_table_with_environment_context_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_tables_args__isset {
    _ThriftHiveMetastore_get_tables_args__isset() : db_name(false), pattern(false) {}
    bool db_name;
    bool pattern;
  } _ThriftHiveMetastore_get_tables_args__isset;
  
  class ThriftHiveMetastore_get_tables_args {
   public:
  
    ThriftHiveMetastore_get_tables_args() : db_name(), pattern() {
    }
  
    virtual ~ThriftHiveMetastore_get_tables_args() throw() {}
  
    std::string db_name;
    std::string pattern;
  
    _ThriftHiveMetastore_get_tables_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_pattern(const std::string& val) {
      pattern = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_tables_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(pattern == rhs.pattern))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_tables_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_tables_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_tables_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_tables_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* pattern;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_tables_result__isset {
    _ThriftHiveMetastore_get_tables_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_tables_result__isset;
  
  class ThriftHiveMetastore_get_tables_result {
   public:
  
    ThriftHiveMetastore_get_tables_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_tables_result() throw() {}
  
    std::vector<std::string>  success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_tables_result__isset __isset;
  
    void __set_success(const std::vector<std::string> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_tables_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_tables_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_tables_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_tables_presult__isset {
    _ThriftHiveMetastore_get_tables_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_tables_presult__isset;
  
  class ThriftHiveMetastore_get_tables_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_tables_presult() throw() {}
  
    std::vector<std::string> * success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_tables_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_all_tables_args__isset {
    _ThriftHiveMetastore_get_all_tables_args__isset() : db_name(false) {}
    bool db_name;
  } _ThriftHiveMetastore_get_all_tables_args__isset;
  
  class ThriftHiveMetastore_get_all_tables_args {
   public:
  
    ThriftHiveMetastore_get_all_tables_args() : db_name() {
    }
  
    virtual ~ThriftHiveMetastore_get_all_tables_args() throw() {}
  
    std::string db_name;
  
    _ThriftHiveMetastore_get_all_tables_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_all_tables_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_all_tables_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_all_tables_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_all_tables_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_all_tables_pargs() throw() {}
  
    const std::string* db_name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_all_tables_result__isset {
    _ThriftHiveMetastore_get_all_tables_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_all_tables_result__isset;
  
  class ThriftHiveMetastore_get_all_tables_result {
   public:
  
    ThriftHiveMetastore_get_all_tables_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_all_tables_result() throw() {}
  
    std::vector<std::string>  success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_all_tables_result__isset __isset;
  
    void __set_success(const std::vector<std::string> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_all_tables_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_all_tables_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_all_tables_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_all_tables_presult__isset {
    _ThriftHiveMetastore_get_all_tables_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_all_tables_presult__isset;
  
  class ThriftHiveMetastore_get_all_tables_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_all_tables_presult() throw() {}
  
    std::vector<std::string> * success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_all_tables_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_table_args__isset {
    _ThriftHiveMetastore_get_table_args__isset() : dbname(false), tbl_name(false) {}
    bool dbname;
    bool tbl_name;
  } _ThriftHiveMetastore_get_table_args__isset;
  
  class ThriftHiveMetastore_get_table_args {
   public:
  
    ThriftHiveMetastore_get_table_args() : dbname(), tbl_name() {
    }
  
    virtual ~ThriftHiveMetastore_get_table_args() throw() {}
  
    std::string dbname;
    std::string tbl_name;
  
    _ThriftHiveMetastore_get_table_args__isset __isset;
  
    void __set_dbname(const std::string& val) {
      dbname = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_table_args & rhs) const
    {
      if (!(dbname == rhs.dbname))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_table_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_table_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_table_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_table_pargs() throw() {}
  
    const std::string* dbname;
    const std::string* tbl_name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_table_result__isset {
    _ThriftHiveMetastore_get_table_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_table_result__isset;
  
  class ThriftHiveMetastore_get_table_result {
   public:
  
    ThriftHiveMetastore_get_table_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_table_result() throw() {}
  
    Table success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_table_result__isset __isset;
  
    void __set_success(const Table& val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_table_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_table_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_table_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_table_presult__isset {
    _ThriftHiveMetastore_get_table_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_table_presult__isset;
  
  class ThriftHiveMetastore_get_table_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_table_presult() throw() {}
  
    Table* success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_table_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_table_objects_by_name_args__isset {
    _ThriftHiveMetastore_get_table_objects_by_name_args__isset() : dbname(false), tbl_names(false) {}
    bool dbname;
    bool tbl_names;
  } _ThriftHiveMetastore_get_table_objects_by_name_args__isset;
  
  class ThriftHiveMetastore_get_table_objects_by_name_args {
   public:
  
    ThriftHiveMetastore_get_table_objects_by_name_args() : dbname() {
    }
  
    virtual ~ThriftHiveMetastore_get_table_objects_by_name_args() throw() {}
  
    std::string dbname;
    std::vector<std::string>  tbl_names;
  
    _ThriftHiveMetastore_get_table_objects_by_name_args__isset __isset;
  
    void __set_dbname(const std::string& val) {
      dbname = val;
    }
  
    void __set_tbl_names(const std::vector<std::string> & val) {
      tbl_names = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_table_objects_by_name_args & rhs) const
    {
      if (!(dbname == rhs.dbname))
        return false;
      if (!(tbl_names == rhs.tbl_names))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_table_objects_by_name_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_table_objects_by_name_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_table_objects_by_name_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_table_objects_by_name_pargs() throw() {}
  
    const std::string* dbname;
    const std::vector<std::string> * tbl_names;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_table_objects_by_name_result__isset {
    _ThriftHiveMetastore_get_table_objects_by_name_result__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_get_table_objects_by_name_result__isset;
  
  class ThriftHiveMetastore_get_table_objects_by_name_result {
   public:
  
    ThriftHiveMetastore_get_table_objects_by_name_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_table_objects_by_name_result() throw() {}
  
    std::vector<Table>  success;
    MetaException o1;
    InvalidOperationException o2;
    UnknownDBException o3;
  
    _ThriftHiveMetastore_get_table_objects_by_name_result__isset __isset;
  
    void __set_success(const std::vector<Table> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const InvalidOperationException& val) {
      o2 = val;
    }
  
    void __set_o3(const UnknownDBException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_table_objects_by_name_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_get_table_objects_by_name_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_table_objects_by_name_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_table_objects_by_name_presult__isset {
    _ThriftHiveMetastore_get_table_objects_by_name_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_get_table_objects_by_name_presult__isset;
  
  class ThriftHiveMetastore_get_table_objects_by_name_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_table_objects_by_name_presult() throw() {}
  
    std::vector<Table> * success;
    MetaException o1;
    InvalidOperationException o2;
    UnknownDBException o3;
  
    _ThriftHiveMetastore_get_table_objects_by_name_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_table_names_by_filter_args__isset {
    _ThriftHiveMetastore_get_table_names_by_filter_args__isset() : dbname(false), filter(false), max_tables(true) {}
    bool dbname;
    bool filter;
    bool max_tables;
  } _ThriftHiveMetastore_get_table_names_by_filter_args__isset;
  
  class ThriftHiveMetastore_get_table_names_by_filter_args {
   public:
  
    ThriftHiveMetastore_get_table_names_by_filter_args() : dbname(), filter(), max_tables(-1) {
    }
  
    virtual ~ThriftHiveMetastore_get_table_names_by_filter_args() throw() {}
  
    std::string dbname;
    std::string filter;
    int16_t max_tables;
  
    _ThriftHiveMetastore_get_table_names_by_filter_args__isset __isset;
  
    void __set_dbname(const std::string& val) {
      dbname = val;
    }
  
    void __set_filter(const std::string& val) {
      filter = val;
    }
  
    void __set_max_tables(const int16_t val) {
      max_tables = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_table_names_by_filter_args & rhs) const
    {
      if (!(dbname == rhs.dbname))
        return false;
      if (!(filter == rhs.filter))
        return false;
      if (!(max_tables == rhs.max_tables))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_table_names_by_filter_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_table_names_by_filter_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_table_names_by_filter_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_table_names_by_filter_pargs() throw() {}
  
    const std::string* dbname;
    const std::string* filter;
    const int16_t* max_tables;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_table_names_by_filter_result__isset {
    _ThriftHiveMetastore_get_table_names_by_filter_result__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_get_table_names_by_filter_result__isset;
  
  class ThriftHiveMetastore_get_table_names_by_filter_result {
   public:
  
    ThriftHiveMetastore_get_table_names_by_filter_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_table_names_by_filter_result() throw() {}
  
    std::vector<std::string>  success;
    MetaException o1;
    InvalidOperationException o2;
    UnknownDBException o3;
  
    _ThriftHiveMetastore_get_table_names_by_filter_result__isset __isset;
  
    void __set_success(const std::vector<std::string> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const InvalidOperationException& val) {
      o2 = val;
    }
  
    void __set_o3(const UnknownDBException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_table_names_by_filter_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_get_table_names_by_filter_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_table_names_by_filter_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_table_names_by_filter_presult__isset {
    _ThriftHiveMetastore_get_table_names_by_filter_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_get_table_names_by_filter_presult__isset;
  
  class ThriftHiveMetastore_get_table_names_by_filter_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_table_names_by_filter_presult() throw() {}
  
    std::vector<std::string> * success;
    MetaException o1;
    InvalidOperationException o2;
    UnknownDBException o3;
  
    _ThriftHiveMetastore_get_table_names_by_filter_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_table_args__isset {
    _ThriftHiveMetastore_alter_table_args__isset() : dbname(false), tbl_name(false), new_tbl(false) {}
    bool dbname;
    bool tbl_name;
    bool new_tbl;
  } _ThriftHiveMetastore_alter_table_args__isset;
  
  class ThriftHiveMetastore_alter_table_args {
   public:
  
    ThriftHiveMetastore_alter_table_args() : dbname(), tbl_name() {
    }
  
    virtual ~ThriftHiveMetastore_alter_table_args() throw() {}
  
    std::string dbname;
    std::string tbl_name;
    Table new_tbl;
  
    _ThriftHiveMetastore_alter_table_args__isset __isset;
  
    void __set_dbname(const std::string& val) {
      dbname = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_new_tbl(const Table& val) {
      new_tbl = val;
    }
  
    bool operator == (const ThriftHiveMetastore_alter_table_args & rhs) const
    {
      if (!(dbname == rhs.dbname))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(new_tbl == rhs.new_tbl))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_alter_table_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_alter_table_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_alter_table_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_alter_table_pargs() throw() {}
  
    const std::string* dbname;
    const std::string* tbl_name;
    const Table* new_tbl;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_table_result__isset {
    _ThriftHiveMetastore_alter_table_result__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_alter_table_result__isset;
  
  class ThriftHiveMetastore_alter_table_result {
   public:
  
    ThriftHiveMetastore_alter_table_result() {
    }
  
    virtual ~ThriftHiveMetastore_alter_table_result() throw() {}
  
    InvalidOperationException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_alter_table_result__isset __isset;
  
    void __set_o1(const InvalidOperationException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_alter_table_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_alter_table_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_alter_table_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_table_presult__isset {
    _ThriftHiveMetastore_alter_table_presult__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_alter_table_presult__isset;
  
  class ThriftHiveMetastore_alter_table_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_alter_table_presult() throw() {}
  
    InvalidOperationException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_alter_table_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_table_with_environment_context_args__isset {
    _ThriftHiveMetastore_alter_table_with_environment_context_args__isset() : dbname(false), tbl_name(false), new_tbl(false), environment_context(false) {}
    bool dbname;
    bool tbl_name;
    bool new_tbl;
    bool environment_context;
  } _ThriftHiveMetastore_alter_table_with_environment_context_args__isset;
  
  class ThriftHiveMetastore_alter_table_with_environment_context_args {
   public:
  
    ThriftHiveMetastore_alter_table_with_environment_context_args() : dbname(), tbl_name() {
    }
  
    virtual ~ThriftHiveMetastore_alter_table_with_environment_context_args() throw() {}
  
    std::string dbname;
    std::string tbl_name;
    Table new_tbl;
    EnvironmentContext environment_context;
  
    _ThriftHiveMetastore_alter_table_with_environment_context_args__isset __isset;
  
    void __set_dbname(const std::string& val) {
      dbname = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_new_tbl(const Table& val) {
      new_tbl = val;
    }
  
    void __set_environment_context(const EnvironmentContext& val) {
      environment_context = val;
    }
  
    bool operator == (const ThriftHiveMetastore_alter_table_with_environment_context_args & rhs) const
    {
      if (!(dbname == rhs.dbname))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(new_tbl == rhs.new_tbl))
        return false;
      if (!(environment_context == rhs.environment_context))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_alter_table_with_environment_context_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_alter_table_with_environment_context_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_alter_table_with_environment_context_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_alter_table_with_environment_context_pargs() throw() {}
  
    const std::string* dbname;
    const std::string* tbl_name;
    const Table* new_tbl;
    const EnvironmentContext* environment_context;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_table_with_environment_context_result__isset {
    _ThriftHiveMetastore_alter_table_with_environment_context_result__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_alter_table_with_environment_context_result__isset;
  
  class ThriftHiveMetastore_alter_table_with_environment_context_result {
   public:
  
    ThriftHiveMetastore_alter_table_with_environment_context_result() {
    }
  
    virtual ~ThriftHiveMetastore_alter_table_with_environment_context_result() throw() {}
  
    InvalidOperationException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_alter_table_with_environment_context_result__isset __isset;
  
    void __set_o1(const InvalidOperationException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_alter_table_with_environment_context_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_alter_table_with_environment_context_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_alter_table_with_environment_context_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_table_with_environment_context_presult__isset {
    _ThriftHiveMetastore_alter_table_with_environment_context_presult__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_alter_table_with_environment_context_presult__isset;
  
  class ThriftHiveMetastore_alter_table_with_environment_context_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_alter_table_with_environment_context_presult() throw() {}
  
    InvalidOperationException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_alter_table_with_environment_context_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_add_partition_args__isset {
    _ThriftHiveMetastore_add_partition_args__isset() : new_part(false) {}
    bool new_part;
  } _ThriftHiveMetastore_add_partition_args__isset;
  
  class ThriftHiveMetastore_add_partition_args {
   public:
  
    ThriftHiveMetastore_add_partition_args() {
    }
  
    virtual ~ThriftHiveMetastore_add_partition_args() throw() {}
  
    Partition new_part;
  
    _ThriftHiveMetastore_add_partition_args__isset __isset;
  
    void __set_new_part(const Partition& val) {
      new_part = val;
    }
  
    bool operator == (const ThriftHiveMetastore_add_partition_args & rhs) const
    {
      if (!(new_part == rhs.new_part))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_add_partition_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_add_partition_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_add_partition_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_add_partition_pargs() throw() {}
  
    const Partition* new_part;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_add_partition_result__isset {
    _ThriftHiveMetastore_add_partition_result__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_add_partition_result__isset;
  
  class ThriftHiveMetastore_add_partition_result {
   public:
  
    ThriftHiveMetastore_add_partition_result() {
    }
  
    virtual ~ThriftHiveMetastore_add_partition_result() throw() {}
  
    Partition success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_add_partition_result__isset __isset;
  
    void __set_success(const Partition& val) {
      success = val;
    }
  
    void __set_o1(const InvalidObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const AlreadyExistsException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_add_partition_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      if (!(o3 == rhs.o3))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_add_partition_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_add_partition_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_add_partition_presult__isset {
    _ThriftHiveMetastore_add_partition_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_add_partition_presult__isset;
  
  class ThriftHiveMetastore_add_partition_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_add_partition_presult() throw() {}
  
    Partition* success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_add_partition_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_add_partition_with_environment_context_args__isset {
    _ThriftHiveMetastore_add_partition_with_environment_context_args__isset() : new_part(false), environment_context(false) {}
    bool new_part;
    bool environment_context;
  } _ThriftHiveMetastore_add_partition_with_environment_context_args__isset;
  
  class ThriftHiveMetastore_add_partition_with_environment_context_args {
   public:
  
    ThriftHiveMetastore_add_partition_with_environment_context_args() {
    }
  
    virtual ~ThriftHiveMetastore_add_partition_with_environment_context_args() throw() {}
  
    Partition new_part;
    EnvironmentContext environment_context;
  
    _ThriftHiveMetastore_add_partition_with_environment_context_args__isset __isset;
  
    void __set_new_part(const Partition& val) {
      new_part = val;
    }
  
    void __set_environment_context(const EnvironmentContext& val) {
      environment_context = val;
    }
  
    bool operator == (const ThriftHiveMetastore_add_partition_with_environment_context_args & rhs) const
    {
      if (!(new_part == rhs.new_part))
        return false;
      if (!(environment_context == rhs.environment_context))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_add_partition_with_environment_context_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_add_partition_with_environment_context_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_add_partition_with_environment_context_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_add_partition_with_environment_context_pargs() throw() {}
  
    const Partition* new_part;
    const EnvironmentContext* environment_context;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_add_partition_with_environment_context_result__isset {
    _ThriftHiveMetastore_add_partition_with_environment_context_result__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_add_partition_with_environment_context_result__isset;
  
  class ThriftHiveMetastore_add_partition_with_environment_context_result {
   public:
  
    ThriftHiveMetastore_add_partition_with_environment_context_result() {
    }
  
    virtual ~ThriftHiveMetastore_add_partition_with_environment_context_result() throw() {}
  
    Partition success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_add_partition_with_environment_context_result__isset __isset;
  
    void __set_success(const Partition& val) {
      success = val;
    }
  
    void __set_o1(const InvalidObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const AlreadyExistsException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_add_partition_with_environment_context_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      if (!(o3 == rhs.o3))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_add_partition_with_environment_context_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_add_partition_with_environment_context_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_add_partition_with_environment_context_presult__isset {
    _ThriftHiveMetastore_add_partition_with_environment_context_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_add_partition_with_environment_context_presult__isset;
  
  class ThriftHiveMetastore_add_partition_with_environment_context_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_add_partition_with_environment_context_presult() throw() {}
  
    Partition* success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_add_partition_with_environment_context_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_add_partitions_args__isset {
    _ThriftHiveMetastore_add_partitions_args__isset() : new_parts(false) {}
    bool new_parts;
  } _ThriftHiveMetastore_add_partitions_args__isset;
  
  class ThriftHiveMetastore_add_partitions_args {
   public:
  
    ThriftHiveMetastore_add_partitions_args() {
    }
  
    virtual ~ThriftHiveMetastore_add_partitions_args() throw() {}
  
    std::vector<Partition>  new_parts;
  
    _ThriftHiveMetastore_add_partitions_args__isset __isset;
  
    void __set_new_parts(const std::vector<Partition> & val) {
      new_parts = val;
    }
  
    bool operator == (const ThriftHiveMetastore_add_partitions_args & rhs) const
    {
      if (!(new_parts == rhs.new_parts))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_add_partitions_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_add_partitions_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_add_partitions_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_add_partitions_pargs() throw() {}
  
    const std::vector<Partition> * new_parts;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_add_partitions_result__isset {
    _ThriftHiveMetastore_add_partitions_result__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_add_partitions_result__isset;
  
  class ThriftHiveMetastore_add_partitions_result {
   public:
  
    ThriftHiveMetastore_add_partitions_result() : success(0) {
    }
  
    virtual ~ThriftHiveMetastore_add_partitions_result() throw() {}
  
    int32_t success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_add_partitions_result__isset __isset;
  
    void __set_success(const int32_t val) {
      success = val;
    }
  
    void __set_o1(const InvalidObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const AlreadyExistsException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_add_partitions_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      if (!(o3 == rhs.o3))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_add_partitions_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_add_partitions_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_add_partitions_presult__isset {
    _ThriftHiveMetastore_add_partitions_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_add_partitions_presult__isset;
  
  class ThriftHiveMetastore_add_partitions_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_add_partitions_presult() throw() {}
  
    int32_t* success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_add_partitions_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_append_partition_args__isset {
    _ThriftHiveMetastore_append_partition_args__isset() : db_name(false), tbl_name(false), part_vals(false) {}
    bool db_name;
    bool tbl_name;
    bool part_vals;
  } _ThriftHiveMetastore_append_partition_args__isset;
  
  class ThriftHiveMetastore_append_partition_args {
   public:
  
    ThriftHiveMetastore_append_partition_args() : db_name(), tbl_name() {
    }
  
    virtual ~ThriftHiveMetastore_append_partition_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::vector<std::string>  part_vals;
  
    _ThriftHiveMetastore_append_partition_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_vals(const std::vector<std::string> & val) {
      part_vals = val;
    }
  
    bool operator == (const ThriftHiveMetastore_append_partition_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;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_append_partition_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_append_partition_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_append_partition_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_append_partition_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::vector<std::string> * part_vals;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_append_partition_result__isset {
    _ThriftHiveMetastore_append_partition_result__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_append_partition_result__isset;
  
  class ThriftHiveMetastore_append_partition_result {
   public:
  
    ThriftHiveMetastore_append_partition_result() {
    }
  
    virtual ~ThriftHiveMetastore_append_partition_result() throw() {}
  
    Partition success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_append_partition_result__isset __isset;
  
    void __set_success(const Partition& val) {
      success = val;
    }
  
    void __set_o1(const InvalidObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const AlreadyExistsException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_append_partition_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_append_partition_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_append_partition_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_append_partition_presult__isset {
    _ThriftHiveMetastore_append_partition_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_append_partition_presult__isset;
  
  class ThriftHiveMetastore_append_partition_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_append_partition_presult() throw() {}
  
    Partition* success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_append_partition_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_add_partitions_req_args__isset {
    _ThriftHiveMetastore_add_partitions_req_args__isset() : request(false) {}
    bool request;
  } _ThriftHiveMetastore_add_partitions_req_args__isset;
  
  class ThriftHiveMetastore_add_partitions_req_args {
   public:
  
    ThriftHiveMetastore_add_partitions_req_args() {
    }
  
    virtual ~ThriftHiveMetastore_add_partitions_req_args() throw() {}
  
    AddPartitionsRequest request;
  
    _ThriftHiveMetastore_add_partitions_req_args__isset __isset;
  
    void __set_request(const AddPartitionsRequest& val) {
      request = val;
    }
  
    bool operator == (const ThriftHiveMetastore_add_partitions_req_args & rhs) const
    {
      if (!(request == rhs.request))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_add_partitions_req_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_add_partitions_req_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_add_partitions_req_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_add_partitions_req_pargs() throw() {}
  
    const AddPartitionsRequest* request;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_add_partitions_req_result__isset {
    _ThriftHiveMetastore_add_partitions_req_result__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_add_partitions_req_result__isset;
  
  class ThriftHiveMetastore_add_partitions_req_result {
   public:
  
    ThriftHiveMetastore_add_partitions_req_result() {
    }
  
    virtual ~ThriftHiveMetastore_add_partitions_req_result() throw() {}
  
    AddPartitionsResult success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_add_partitions_req_result__isset __isset;
  
    void __set_success(const AddPartitionsResult& val) {
      success = val;
    }
  
    void __set_o1(const InvalidObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const AlreadyExistsException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_add_partitions_req_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      if (!(o3 == rhs.o3))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_add_partitions_req_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_add_partitions_req_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_add_partitions_req_presult__isset {
    _ThriftHiveMetastore_add_partitions_req_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_add_partitions_req_presult__isset;
  
  class ThriftHiveMetastore_add_partitions_req_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_add_partitions_req_presult() throw() {}
  
    AddPartitionsResult* success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_add_partitions_req_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_append_partition_with_environment_context_args__isset {
    _ThriftHiveMetastore_append_partition_with_environment_context_args__isset() : db_name(false), tbl_name(false), part_vals(false), environment_context(false) {}
    bool db_name;
    bool tbl_name;
    bool part_vals;
    bool environment_context;
  } _ThriftHiveMetastore_append_partition_with_environment_context_args__isset;
  
  class ThriftHiveMetastore_append_partition_with_environment_context_args {
   public:
  
    ThriftHiveMetastore_append_partition_with_environment_context_args() : db_name(), tbl_name() {
    }
  
    virtual ~ThriftHiveMetastore_append_partition_with_environment_context_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::vector<std::string>  part_vals;
    EnvironmentContext environment_context;
  
    _ThriftHiveMetastore_append_partition_with_environment_context_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_vals(const std::vector<std::string> & val) {
      part_vals = val;
    }
  
    void __set_environment_context(const EnvironmentContext& val) {
      environment_context = val;
    }
  
    bool operator == (const ThriftHiveMetastore_append_partition_with_environment_context_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 (!(environment_context == rhs.environment_context))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_append_partition_with_environment_context_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_append_partition_with_environment_context_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_append_partition_with_environment_context_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_append_partition_with_environment_context_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::vector<std::string> * part_vals;
    const EnvironmentContext* environment_context;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_append_partition_with_environment_context_result__isset {
    _ThriftHiveMetastore_append_partition_with_environment_context_result__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_append_partition_with_environment_context_result__isset;
  
  class ThriftHiveMetastore_append_partition_with_environment_context_result {
   public:
  
    ThriftHiveMetastore_append_partition_with_environment_context_result() {
    }
  
    virtual ~ThriftHiveMetastore_append_partition_with_environment_context_result() throw() {}
  
    Partition success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_append_partition_with_environment_context_result__isset __isset;
  
    void __set_success(const Partition& val) {
      success = val;
    }
  
    void __set_o1(const InvalidObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const AlreadyExistsException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_append_partition_with_environment_context_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_append_partition_with_environment_context_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_append_partition_with_environment_context_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_append_partition_with_environment_context_presult__isset {
    _ThriftHiveMetastore_append_partition_with_environment_context_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_append_partition_with_environment_context_presult__isset;
  
  class ThriftHiveMetastore_append_partition_with_environment_context_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_append_partition_with_environment_context_presult() throw() {}
  
    Partition* success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_append_partition_with_environment_context_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_append_partition_by_name_args__isset {
    _ThriftHiveMetastore_append_partition_by_name_args__isset() : db_name(false), tbl_name(false), part_name(false) {}
    bool db_name;
    bool tbl_name;
    bool part_name;
  } _ThriftHiveMetastore_append_partition_by_name_args__isset;
  
  class ThriftHiveMetastore_append_partition_by_name_args {
   public:
  
    ThriftHiveMetastore_append_partition_by_name_args() : db_name(), tbl_name(), part_name() {
    }
  
    virtual ~ThriftHiveMetastore_append_partition_by_name_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::string part_name;
  
    _ThriftHiveMetastore_append_partition_by_name_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_name(const std::string& val) {
      part_name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_append_partition_by_name_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(part_name == rhs.part_name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_append_partition_by_name_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_append_partition_by_name_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_append_partition_by_name_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_append_partition_by_name_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::string* part_name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_append_partition_by_name_result__isset {
    _ThriftHiveMetastore_append_partition_by_name_result__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_append_partition_by_name_result__isset;
  
  class ThriftHiveMetastore_append_partition_by_name_result {
   public:
  
    ThriftHiveMetastore_append_partition_by_name_result() {
    }
  
    virtual ~ThriftHiveMetastore_append_partition_by_name_result() throw() {}
  
    Partition success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_append_partition_by_name_result__isset __isset;
  
    void __set_success(const Partition& val) {
      success = val;
    }
  
    void __set_o1(const InvalidObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const AlreadyExistsException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_append_partition_by_name_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_append_partition_by_name_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_append_partition_by_name_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_append_partition_by_name_presult__isset {
    _ThriftHiveMetastore_append_partition_by_name_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_append_partition_by_name_presult__isset;
  
  class ThriftHiveMetastore_append_partition_by_name_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_append_partition_by_name_presult() throw() {}
  
    Partition* success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_append_partition_by_name_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_append_partition_by_name_with_environment_context_args__isset {
    _ThriftHiveMetastore_append_partition_by_name_with_environment_context_args__isset() : db_name(false), tbl_name(false), part_name(false), environment_context(false) {}
    bool db_name;
    bool tbl_name;
    bool part_name;
    bool environment_context;
  } _ThriftHiveMetastore_append_partition_by_name_with_environment_context_args__isset;
  
  class ThriftHiveMetastore_append_partition_by_name_with_environment_context_args {
   public:
  
    ThriftHiveMetastore_append_partition_by_name_with_environment_context_args() : db_name(), tbl_name(), part_name() {
    }
  
    virtual ~ThriftHiveMetastore_append_partition_by_name_with_environment_context_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::string part_name;
    EnvironmentContext environment_context;
  
    _ThriftHiveMetastore_append_partition_by_name_with_environment_context_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_name(const std::string& val) {
      part_name = val;
    }
  
    void __set_environment_context(const EnvironmentContext& val) {
      environment_context = val;
    }
  
    bool operator == (const ThriftHiveMetastore_append_partition_by_name_with_environment_context_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(part_name == rhs.part_name))
        return false;
      if (!(environment_context == rhs.environment_context))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_append_partition_by_name_with_environment_context_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_append_partition_by_name_with_environment_context_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_append_partition_by_name_with_environment_context_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_append_partition_by_name_with_environment_context_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::string* part_name;
    const EnvironmentContext* environment_context;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_append_partition_by_name_with_environment_context_result__isset {
    _ThriftHiveMetastore_append_partition_by_name_with_environment_context_result__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_append_partition_by_name_with_environment_context_result__isset;
  
  class ThriftHiveMetastore_append_partition_by_name_with_environment_context_result {
   public:
  
    ThriftHiveMetastore_append_partition_by_name_with_environment_context_result() {
    }
  
    virtual ~ThriftHiveMetastore_append_partition_by_name_with_environment_context_result() throw() {}
  
    Partition success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_append_partition_by_name_with_environment_context_result__isset __isset;
  
    void __set_success(const Partition& val) {
      success = val;
    }
  
    void __set_o1(const InvalidObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const AlreadyExistsException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_append_partition_by_name_with_environment_context_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_append_partition_by_name_with_environment_context_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_append_partition_by_name_with_environment_context_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult__isset {
    _ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult__isset;
  
  class ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult() throw() {}
  
    Partition* success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_append_partition_by_name_with_environment_context_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_partition_args__isset {
    _ThriftHiveMetastore_drop_partition_args__isset() : db_name(false), tbl_name(false), part_vals(false), deleteData(false) {}
    bool db_name;
    bool tbl_name;
    bool part_vals;
    bool deleteData;
  } _ThriftHiveMetastore_drop_partition_args__isset;
  
  class ThriftHiveMetastore_drop_partition_args {
   public:
  
    ThriftHiveMetastore_drop_partition_args() : db_name(), tbl_name(), deleteData(0) {
    }
  
    virtual ~ThriftHiveMetastore_drop_partition_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::vector<std::string>  part_vals;
    bool deleteData;
  
    _ThriftHiveMetastore_drop_partition_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_vals(const std::vector<std::string> & val) {
      part_vals = val;
    }
  
    void __set_deleteData(const bool val) {
      deleteData = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_partition_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 (!(deleteData == rhs.deleteData))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_drop_partition_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_partition_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_drop_partition_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_partition_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::vector<std::string> * part_vals;
    const bool* deleteData;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_partition_result__isset {
    _ThriftHiveMetastore_drop_partition_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_drop_partition_result__isset;
  
  class ThriftHiveMetastore_drop_partition_result {
   public:
  
    ThriftHiveMetastore_drop_partition_result() : success(0) {
    }
  
    virtual ~ThriftHiveMetastore_drop_partition_result() throw() {}
  
    bool success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_drop_partition_result__isset __isset;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_partition_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_drop_partition_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_partition_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_partition_presult__isset {
    _ThriftHiveMetastore_drop_partition_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_drop_partition_presult__isset;
  
  class ThriftHiveMetastore_drop_partition_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_partition_presult() throw() {}
  
    bool* success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_drop_partition_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_partition_with_environment_context_args__isset {
    _ThriftHiveMetastore_drop_partition_with_environment_context_args__isset() : db_name(false), tbl_name(false), part_vals(false), deleteData(false), environment_context(false) {}
    bool db_name;
    bool tbl_name;
    bool part_vals;
    bool deleteData;
    bool environment_context;
  } _ThriftHiveMetastore_drop_partition_with_environment_context_args__isset;
  
  class ThriftHiveMetastore_drop_partition_with_environment_context_args {
   public:
  
    ThriftHiveMetastore_drop_partition_with_environment_context_args() : db_name(), tbl_name(), deleteData(0) {
    }
  
    virtual ~ThriftHiveMetastore_drop_partition_with_environment_context_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::vector<std::string>  part_vals;
    bool deleteData;
    EnvironmentContext environment_context;
  
    _ThriftHiveMetastore_drop_partition_with_environment_context_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_vals(const std::vector<std::string> & val) {
      part_vals = val;
    }
  
    void __set_deleteData(const bool val) {
      deleteData = val;
    }
  
    void __set_environment_context(const EnvironmentContext& val) {
      environment_context = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_partition_with_environment_context_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 (!(deleteData == rhs.deleteData))
        return false;
      if (!(environment_context == rhs.environment_context))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_drop_partition_with_environment_context_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_partition_with_environment_context_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_drop_partition_with_environment_context_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_partition_with_environment_context_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::vector<std::string> * part_vals;
    const bool* deleteData;
    const EnvironmentContext* environment_context;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_partition_with_environment_context_result__isset {
    _ThriftHiveMetastore_drop_partition_with_environment_context_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_drop_partition_with_environment_context_result__isset;
  
  class ThriftHiveMetastore_drop_partition_with_environment_context_result {
   public:
  
    ThriftHiveMetastore_drop_partition_with_environment_context_result() : success(0) {
    }
  
    virtual ~ThriftHiveMetastore_drop_partition_with_environment_context_result() throw() {}
  
    bool success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_drop_partition_with_environment_context_result__isset __isset;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_partition_with_environment_context_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_drop_partition_with_environment_context_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_partition_with_environment_context_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_partition_with_environment_context_presult__isset {
    _ThriftHiveMetastore_drop_partition_with_environment_context_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_drop_partition_with_environment_context_presult__isset;
  
  class ThriftHiveMetastore_drop_partition_with_environment_context_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_partition_with_environment_context_presult() throw() {}
  
    bool* success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_drop_partition_with_environment_context_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_partition_by_name_args__isset {
    _ThriftHiveMetastore_drop_partition_by_name_args__isset() : db_name(false), tbl_name(false), part_name(false), deleteData(false) {}
    bool db_name;
    bool tbl_name;
    bool part_name;
    bool deleteData;
  } _ThriftHiveMetastore_drop_partition_by_name_args__isset;
  
  class ThriftHiveMetastore_drop_partition_by_name_args {
   public:
  
    ThriftHiveMetastore_drop_partition_by_name_args() : db_name(), tbl_name(), part_name(), deleteData(0) {
    }
  
    virtual ~ThriftHiveMetastore_drop_partition_by_name_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::string part_name;
    bool deleteData;
  
    _ThriftHiveMetastore_drop_partition_by_name_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_name(const std::string& val) {
      part_name = val;
    }
  
    void __set_deleteData(const bool val) {
      deleteData = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_partition_by_name_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(part_name == rhs.part_name))
        return false;
      if (!(deleteData == rhs.deleteData))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_drop_partition_by_name_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_partition_by_name_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_drop_partition_by_name_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_partition_by_name_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::string* part_name;
    const bool* deleteData;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_partition_by_name_result__isset {
    _ThriftHiveMetastore_drop_partition_by_name_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_drop_partition_by_name_result__isset;
  
  class ThriftHiveMetastore_drop_partition_by_name_result {
   public:
  
    ThriftHiveMetastore_drop_partition_by_name_result() : success(0) {
    }
  
    virtual ~ThriftHiveMetastore_drop_partition_by_name_result() throw() {}
  
    bool success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_drop_partition_by_name_result__isset __isset;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_partition_by_name_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_drop_partition_by_name_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_partition_by_name_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_partition_by_name_presult__isset {
    _ThriftHiveMetastore_drop_partition_by_name_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_drop_partition_by_name_presult__isset;
  
  class ThriftHiveMetastore_drop_partition_by_name_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_partition_by_name_presult() throw() {}
  
    bool* success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_drop_partition_by_name_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args__isset {
    _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args__isset() : db_name(false), tbl_name(false), part_name(false), deleteData(false), environment_context(false) {}
    bool db_name;
    bool tbl_name;
    bool part_name;
    bool deleteData;
    bool environment_context;
  } _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args__isset;
  
  class ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args {
   public:
  
    ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args() : db_name(), tbl_name(), part_name(), deleteData(0) {
    }
  
    virtual ~ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::string part_name;
    bool deleteData;
    EnvironmentContext environment_context;
  
    _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_name(const std::string& val) {
      part_name = val;
    }
  
    void __set_deleteData(const bool val) {
      deleteData = val;
    }
  
    void __set_environment_context(const EnvironmentContext& val) {
      environment_context = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(part_name == rhs.part_name))
        return false;
      if (!(deleteData == rhs.deleteData))
        return false;
      if (!(environment_context == rhs.environment_context))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_drop_partition_by_name_with_environment_context_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_partition_by_name_with_environment_context_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::string* part_name;
    const bool* deleteData;
    const EnvironmentContext* environment_context;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result__isset {
    _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result__isset;
  
  class ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result {
   public:
  
    ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result() : success(0) {
    }
  
    virtual ~ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result() throw() {}
  
    bool success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result__isset __isset;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_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_drop_partition_by_name_with_environment_context_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult__isset {
    _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult__isset;
  
  class ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult() throw() {}
  
    bool* success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_partitions_req_args__isset {
    _ThriftHiveMetastore_drop_partitions_req_args__isset() : req(false) {}
    bool req;
  } _ThriftHiveMetastore_drop_partitions_req_args__isset;
  
  class ThriftHiveMetastore_drop_partitions_req_args {
   public:
  
    ThriftHiveMetastore_drop_partitions_req_args() {
    }
  
    virtual ~ThriftHiveMetastore_drop_partitions_req_args() throw() {}
  
    DropPartitionsRequest req;
  
    _ThriftHiveMetastore_drop_partitions_req_args__isset __isset;
  
    void __set_req(const DropPartitionsRequest& val) {
      req = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_partitions_req_args & rhs) const
    {
      if (!(req == rhs.req))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_drop_partitions_req_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_partitions_req_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_drop_partitions_req_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_partitions_req_pargs() throw() {}
  
    const DropPartitionsRequest* req;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_partitions_req_result__isset {
    _ThriftHiveMetastore_drop_partitions_req_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_drop_partitions_req_result__isset;
  
  class ThriftHiveMetastore_drop_partitions_req_result {
   public:
  
    ThriftHiveMetastore_drop_partitions_req_result() {
    }
  
    virtual ~ThriftHiveMetastore_drop_partitions_req_result() throw() {}
  
    DropPartitionsResult success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_drop_partitions_req_result__isset __isset;
  
    void __set_success(const DropPartitionsResult& val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_partitions_req_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_drop_partitions_req_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_partitions_req_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_partitions_req_presult__isset {
    _ThriftHiveMetastore_drop_partitions_req_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_drop_partitions_req_presult__isset;
  
  class ThriftHiveMetastore_drop_partitions_req_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_partitions_req_presult() throw() {}
  
    DropPartitionsResult* success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_drop_partitions_req_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partition_args__isset {
    _ThriftHiveMetastore_get_partition_args__isset() : db_name(false), tbl_name(false), part_vals(false) {}
    bool db_name;
    bool tbl_name;
    bool part_vals;
  } _ThriftHiveMetastore_get_partition_args__isset;
  
  class ThriftHiveMetastore_get_partition_args {
   public:
  
    ThriftHiveMetastore_get_partition_args() : db_name(), tbl_name() {
    }
  
    virtual ~ThriftHiveMetastore_get_partition_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::vector<std::string>  part_vals;
  
    _ThriftHiveMetastore_get_partition_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_vals(const std::vector<std::string> & val) {
      part_vals = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partition_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;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_partition_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partition_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_partition_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partition_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::vector<std::string> * part_vals;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partition_result__isset {
    _ThriftHiveMetastore_get_partition_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partition_result__isset;
  
  class ThriftHiveMetastore_get_partition_result {
   public:
  
    ThriftHiveMetastore_get_partition_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_partition_result() throw() {}
  
    Partition success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_partition_result__isset __isset;
  
    void __set_success(const Partition& val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partition_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_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partition_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partition_presult__isset {
    _ThriftHiveMetastore_get_partition_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partition_presult__isset;
  
  class ThriftHiveMetastore_get_partition_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partition_presult() throw() {}
  
    Partition* success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_partition_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_exchange_partition_args__isset {
    _ThriftHiveMetastore_exchange_partition_args__isset() : partitionSpecs(false), source_db(false), source_table_name(false), dest_db(false), dest_table_name(false) {}
    bool partitionSpecs;
    bool source_db;
    bool source_table_name;
    bool dest_db;
    bool dest_table_name;
  } _ThriftHiveMetastore_exchange_partition_args__isset;
  
  class ThriftHiveMetastore_exchange_partition_args {
   public:
  
    ThriftHiveMetastore_exchange_partition_args() : source_db(), source_table_name(), dest_db(), dest_table_name() {
    }
  
    virtual ~ThriftHiveMetastore_exchange_partition_args() throw() {}
  
    std::map<std::string, std::string>  partitionSpecs;
    std::string source_db;
    std::string source_table_name;
    std::string dest_db;
    std::string dest_table_name;
  
    _ThriftHiveMetastore_exchange_partition_args__isset __isset;
  
    void __set_partitionSpecs(const std::map<std::string, std::string> & val) {
      partitionSpecs = val;
    }
  
    void __set_source_db(const std::string& val) {
      source_db = val;
    }
  
    void __set_source_table_name(const std::string& val) {
      source_table_name = val;
    }
  
    void __set_dest_db(const std::string& val) {
      dest_db = val;
    }
  
    void __set_dest_table_name(const std::string& val) {
      dest_table_name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_exchange_partition_args & rhs) const
    {
      if (!(partitionSpecs == rhs.partitionSpecs))
        return false;
      if (!(source_db == rhs.source_db))
        return false;
      if (!(source_table_name == rhs.source_table_name))
        return false;
      if (!(dest_db == rhs.dest_db))
        return false;
      if (!(dest_table_name == rhs.dest_table_name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_exchange_partition_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_exchange_partition_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_exchange_partition_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_exchange_partition_pargs() throw() {}
  
    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;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_exchange_partition_result__isset {
    _ThriftHiveMetastore_exchange_partition_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_exchange_partition_result__isset;
  
  class ThriftHiveMetastore_exchange_partition_result {
   public:
  
    ThriftHiveMetastore_exchange_partition_result() {
    }
  
    virtual ~ThriftHiveMetastore_exchange_partition_result() throw() {}
  
    Partition success;
    MetaException o1;
    NoSuchObjectException o2;
    InvalidObjectException o3;
    InvalidInputException o4;
  
    _ThriftHiveMetastore_exchange_partition_result__isset __isset;
  
    void __set_success(const Partition& val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    void __set_o3(const InvalidObjectException& val) {
      o3 = val;
    }
  
    void __set_o4(const InvalidInputException& val) {
      o4 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_exchange_partition_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;
      if (!(o4 == rhs.o4))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_exchange_partition_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_exchange_partition_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_exchange_partition_presult__isset {
    _ThriftHiveMetastore_exchange_partition_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_exchange_partition_presult__isset;
  
  class ThriftHiveMetastore_exchange_partition_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_exchange_partition_presult() throw() {}
  
    Partition* success;
    MetaException o1;
    NoSuchObjectException o2;
    InvalidObjectException o3;
    InvalidInputException o4;
  
    _ThriftHiveMetastore_exchange_partition_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  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;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_vals(const std::vector<std::string> & val) {
      part_vals = val;
    }
  
    void __set_user_name(const std::string& val) {
      user_name = val;
    }
  
    void __set_group_names(const std::vector<std::string> & val) {
      group_names = val;
    }
  
    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;
  
    void __set_success(const Partition& val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    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;
    bool tbl_name;
    bool part_name;
  } _ThriftHiveMetastore_get_partition_by_name_args__isset;
  
  class ThriftHiveMetastore_get_partition_by_name_args {
   public:
  
    ThriftHiveMetastore_get_partition_by_name_args() : db_name(), tbl_name(), part_name() {
    }
  
    virtual ~ThriftHiveMetastore_get_partition_by_name_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::string part_name;
  
    _ThriftHiveMetastore_get_partition_by_name_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_name(const std::string& val) {
      part_name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partition_by_name_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(part_name == rhs.part_name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_partition_by_name_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partition_by_name_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_partition_by_name_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partition_by_name_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::string* part_name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partition_by_name_result__isset {
    _ThriftHiveMetastore_get_partition_by_name_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partition_by_name_result__isset;
  
  class ThriftHiveMetastore_get_partition_by_name_result {
   public:
  
    ThriftHiveMetastore_get_partition_by_name_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_partition_by_name_result() throw() {}
  
    Partition success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_partition_by_name_result__isset __isset;
  
    void __set_success(const Partition& val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partition_by_name_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_by_name_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partition_by_name_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partition_by_name_presult__isset {
    _ThriftHiveMetastore_get_partition_by_name_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partition_by_name_presult__isset;
  
  class ThriftHiveMetastore_get_partition_by_name_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partition_by_name_presult() throw() {}
  
    Partition* success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_partition_by_name_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_args__isset {
    _ThriftHiveMetastore_get_partitions_args__isset() : db_name(false), tbl_name(false), max_parts(true) {}
    bool db_name;
    bool tbl_name;
    bool max_parts;
  } _ThriftHiveMetastore_get_partitions_args__isset;
  
  class ThriftHiveMetastore_get_partitions_args {
   public:
  
    ThriftHiveMetastore_get_partitions_args() : db_name(), tbl_name(), max_parts(-1) {
    }
  
    virtual ~ThriftHiveMetastore_get_partitions_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    int16_t max_parts;
  
    _ThriftHiveMetastore_get_partitions_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_max_parts(const int16_t val) {
      max_parts = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partitions_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;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_partitions_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partitions_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_partitions_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partitions_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const int16_t* max_parts;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_result__isset {
    _ThriftHiveMetastore_get_partitions_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partitions_result__isset;
  
  class ThriftHiveMetastore_get_partitions_result {
   public:
  
    ThriftHiveMetastore_get_partitions_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_partitions_result() throw() {}
  
    std::vector<Partition>  success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_get_partitions_result__isset __isset;
  
    void __set_success(const std::vector<Partition> & val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partitions_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_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partitions_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_presult__isset {
    _ThriftHiveMetastore_get_partitions_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partitions_presult__isset;
  
  class ThriftHiveMetastore_get_partitions_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partitions_presult() throw() {}
  
    std::vector<Partition> * success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_get_partitions_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_with_auth_args__isset {
    _ThriftHiveMetastore_get_partitions_with_auth_args__isset() : db_name(false), tbl_name(false), max_parts(true), 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;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_max_parts(const int16_t val) {
      max_parts = val;
    }
  
    void __set_user_name(const std::string& val) {
      user_name = val;
    }
  
    void __set_group_names(const std::vector<std::string> & val) {
      group_names = val;
    }
  
    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;
  
    void __set_success(const std::vector<Partition> & val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    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(true) {}
    bool db_name;
    bool tbl_name;
    bool max_parts;
  } _ThriftHiveMetastore_get_partition_names_args__isset;
  
  class ThriftHiveMetastore_get_partition_names_args {
   public:
  
    ThriftHiveMetastore_get_partition_names_args() : db_name(), tbl_name(), max_parts(-1) {
    }
  
    virtual ~ThriftHiveMetastore_get_partition_names_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    int16_t max_parts;
  
    _ThriftHiveMetastore_get_partition_names_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_max_parts(const int16_t val) {
      max_parts = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partition_names_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;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_partition_names_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partition_names_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_partition_names_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partition_names_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const int16_t* max_parts;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partition_names_result__isset {
    _ThriftHiveMetastore_get_partition_names_result__isset() : success(false), o2(false) {}
    bool success;
    bool o2;
  } _ThriftHiveMetastore_get_partition_names_result__isset;
  
  class ThriftHiveMetastore_get_partition_names_result {
   public:
  
    ThriftHiveMetastore_get_partition_names_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_partition_names_result() throw() {}
  
    std::vector<std::string>  success;
    MetaException o2;
  
    _ThriftHiveMetastore_get_partition_names_result__isset __isset;
  
    void __set_success(const std::vector<std::string> & val) {
      success = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partition_names_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_partition_names_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partition_names_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_presult__isset {
    _ThriftHiveMetastore_get_partition_names_presult__isset() : success(false), o2(false) {}
    bool success;
    bool o2;
  } _ThriftHiveMetastore_get_partition_names_presult__isset;
  
  class ThriftHiveMetastore_get_partition_names_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partition_names_presult() throw() {}
  
    std::vector<std::string> * success;
    MetaException o2;
  
    _ThriftHiveMetastore_get_partition_names_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_ps_args__isset {
    _ThriftHiveMetastore_get_partitions_ps_args__isset() : db_name(false), tbl_name(false), part_vals(false), max_parts(true) {}
    bool db_name;
    bool tbl_name;
    bool part_vals;
    bool max_parts;
  } _ThriftHiveMetastore_get_partitions_ps_args__isset;
  
  class ThriftHiveMetastore_get_partitions_ps_args {
   public:
  
    ThriftHiveMetastore_get_partitions_ps_args() : db_name(), tbl_name(), max_parts(-1) {
    }
  
    virtual ~ThriftHiveMetastore_get_partitions_ps_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::vector<std::string>  part_vals;
    int16_t max_parts;
  
    _ThriftHiveMetastore_get_partitions_ps_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_vals(const std::vector<std::string> & val) {
      part_vals = val;
    }
  
    void __set_max_parts(const int16_t val) {
      max_parts = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partitions_ps_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(part_vals == rhs.part_vals))
        return false;
      if (!(max_parts == rhs.max_parts))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_partitions_ps_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partitions_ps_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_partitions_ps_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partitions_ps_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::vector<std::string> * part_vals;
    const int16_t* max_parts;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_ps_result__isset {
    _ThriftHiveMetastore_get_partitions_ps_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partitions_ps_result__isset;
  
  class ThriftHiveMetastore_get_partitions_ps_result {
   public:
  
    ThriftHiveMetastore_get_partitions_ps_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_partitions_ps_result() throw() {}
  
    std::vector<Partition>  success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_partitions_ps_result__isset __isset;
  
    void __set_success(const std::vector<Partition> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partitions_ps_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_ps_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partitions_ps_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_ps_presult__isset {
    _ThriftHiveMetastore_get_partitions_ps_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partitions_ps_presult__isset;
  
  class ThriftHiveMetastore_get_partitions_ps_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partitions_ps_presult() throw() {}
  
    std::vector<Partition> * success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_partitions_ps_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  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(true), user_name(false), group_names(false) {}
    bool db_name;
    bool tbl_name;
    bool part_vals;
    bool max_parts;
    bool user_name;
    bool group_names;
  } _ThriftHiveMetastore_get_partitions_ps_with_auth_args__isset;
  
  class ThriftHiveMetastore_get_partitions_ps_with_auth_args {
   public:
  
    ThriftHiveMetastore_get_partitions_ps_with_auth_args() : db_name(), tbl_name(), max_parts(-1), user_name() {
    }
  
    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_partitions_ps_with_auth_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_vals(const std::vector<std::string> & val) {
      part_vals = val;
    }
  
    void __set_max_parts(const int16_t val) {
      max_parts = val;
    }
  
    void __set_user_name(const std::string& val) {
      user_name = val;
    }
  
    void __set_group_names(const std::vector<std::string> & val) {
      group_names = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partitions_ps_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 (!(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_ps_with_auth_args &rhs) const {
      return !(*this == rhs);
    }
  
    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;
  
  };
  
  
  class ThriftHiveMetastore_get_partitions_ps_with_auth_pargs {
   public:
  
  
    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_partitions_ps_with_auth_result__isset {
    _ThriftHiveMetastore_get_partitions_ps_with_auth_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partitions_ps_with_auth_result__isset;
  
  class ThriftHiveMetastore_get_partitions_ps_with_auth_result {
   public:
  
    ThriftHiveMetastore_get_partitions_ps_with_auth_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_partitions_ps_with_auth_result() throw() {}
  
    std::vector<Partition>  success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_get_partitions_ps_with_auth_result__isset __isset;
  
    void __set_success(const std::vector<Partition> & val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    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_partitions_ps_with_auth_result &rhs) const {
      return !(*this == rhs);
    }
  
    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_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(true) {}
    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;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_vals(const std::vector<std::string> & val) {
      part_vals = val;
    }
  
    void __set_max_parts(const int16_t val) {
      max_parts = val;
    }
  
    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), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _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;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_partition_names_ps_result__isset __isset;
  
    void __set_success(const std::vector<std::string> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partition_names_ps_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 {
      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), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partition_names_ps_presult__isset;
  
  class ThriftHiveMetastore_get_partition_names_ps_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partition_names_ps_presult() throw() {}
  
    std::vector<std::string> * success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_partition_names_ps_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_by_filter_args__isset {
    _ThriftHiveMetastore_get_partitions_by_filter_args__isset() : db_name(false), tbl_name(false), filter(false), max_parts(true) {}
    bool db_name;
    bool tbl_name;
    bool filter;
    bool max_parts;
  } _ThriftHiveMetastore_get_partitions_by_filter_args__isset;
  
  class ThriftHiveMetastore_get_partitions_by_filter_args {
   public:
  
    ThriftHiveMetastore_get_partitions_by_filter_args() : db_name(), tbl_name(), filter(), max_parts(-1) {
    }
  
    virtual ~ThriftHiveMetastore_get_partitions_by_filter_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::string filter;
    int16_t max_parts;
  
    _ThriftHiveMetastore_get_partitions_by_filter_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_filter(const std::string& val) {
      filter = val;
    }
  
    void __set_max_parts(const int16_t val) {
      max_parts = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partitions_by_filter_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(filter == rhs.filter))
        return false;
      if (!(max_parts == rhs.max_parts))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_partitions_by_filter_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partitions_by_filter_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_partitions_by_filter_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partitions_by_filter_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::string* filter;
    const int16_t* max_parts;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_by_filter_result__isset {
    _ThriftHiveMetastore_get_partitions_by_filter_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partitions_by_filter_result__isset;
  
  class ThriftHiveMetastore_get_partitions_by_filter_result {
   public:
  
    ThriftHiveMetastore_get_partitions_by_filter_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_partitions_by_filter_result() throw() {}
  
    std::vector<Partition>  success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_partitions_by_filter_result__isset __isset;
  
    void __set_success(const std::vector<Partition> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partitions_by_filter_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_by_filter_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partitions_by_filter_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_by_filter_presult__isset {
    _ThriftHiveMetastore_get_partitions_by_filter_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partitions_by_filter_presult__isset;
  
  class ThriftHiveMetastore_get_partitions_by_filter_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partitions_by_filter_presult() throw() {}
  
    std::vector<Partition> * success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_partitions_by_filter_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_by_expr_args__isset {
    _ThriftHiveMetastore_get_partitions_by_expr_args__isset() : req(false) {}
    bool req;
  } _ThriftHiveMetastore_get_partitions_by_expr_args__isset;
  
  class ThriftHiveMetastore_get_partitions_by_expr_args {
   public:
  
    ThriftHiveMetastore_get_partitions_by_expr_args() {
    }
  
    virtual ~ThriftHiveMetastore_get_partitions_by_expr_args() throw() {}
  
    PartitionsByExprRequest req;
  
    _ThriftHiveMetastore_get_partitions_by_expr_args__isset __isset;
  
    void __set_req(const PartitionsByExprRequest& val) {
      req = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partitions_by_expr_args & rhs) const
    {
      if (!(req == rhs.req))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_partitions_by_expr_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partitions_by_expr_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_partitions_by_expr_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partitions_by_expr_pargs() throw() {}
  
    const PartitionsByExprRequest* req;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_by_expr_result__isset {
    _ThriftHiveMetastore_get_partitions_by_expr_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partitions_by_expr_result__isset;
  
  class ThriftHiveMetastore_get_partitions_by_expr_result {
   public:
  
    ThriftHiveMetastore_get_partitions_by_expr_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_partitions_by_expr_result() throw() {}
  
    PartitionsByExprResult success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_partitions_by_expr_result__isset __isset;
  
    void __set_success(const PartitionsByExprResult& val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partitions_by_expr_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_by_expr_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partitions_by_expr_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_by_expr_presult__isset {
    _ThriftHiveMetastore_get_partitions_by_expr_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partitions_by_expr_presult__isset;
  
  class ThriftHiveMetastore_get_partitions_by_expr_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partitions_by_expr_presult() throw() {}
  
    PartitionsByExprResult* success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_partitions_by_expr_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_by_names_args__isset {
    _ThriftHiveMetastore_get_partitions_by_names_args__isset() : db_name(false), tbl_name(false), names(false) {}
    bool db_name;
    bool tbl_name;
    bool names;
  } _ThriftHiveMetastore_get_partitions_by_names_args__isset;
  
  class ThriftHiveMetastore_get_partitions_by_names_args {
   public:
  
    ThriftHiveMetastore_get_partitions_by_names_args() : db_name(), tbl_name() {
    }
  
    virtual ~ThriftHiveMetastore_get_partitions_by_names_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::vector<std::string>  names;
  
    _ThriftHiveMetastore_get_partitions_by_names_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_names(const std::vector<std::string> & val) {
      names = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partitions_by_names_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(names == rhs.names))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_partitions_by_names_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partitions_by_names_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_partitions_by_names_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partitions_by_names_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::vector<std::string> * names;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_by_names_result__isset {
    _ThriftHiveMetastore_get_partitions_by_names_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partitions_by_names_result__isset;
  
  class ThriftHiveMetastore_get_partitions_by_names_result {
   public:
  
    ThriftHiveMetastore_get_partitions_by_names_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_partitions_by_names_result() throw() {}
  
    std::vector<Partition>  success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_partitions_by_names_result__isset __isset;
  
    void __set_success(const std::vector<Partition> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partitions_by_names_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_by_names_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partitions_by_names_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_by_names_presult__isset {
    _ThriftHiveMetastore_get_partitions_by_names_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partitions_by_names_presult__isset;
  
  class ThriftHiveMetastore_get_partitions_by_names_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partitions_by_names_presult() throw() {}
  
    std::vector<Partition> * success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_partitions_by_names_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_partition_args__isset {
    _ThriftHiveMetastore_alter_partition_args__isset() : db_name(false), tbl_name(false), new_part(false) {}
    bool db_name;
    bool tbl_name;
    bool new_part;
  } _ThriftHiveMetastore_alter_partition_args__isset;
  
  class ThriftHiveMetastore_alter_partition_args {
   public:
  
    ThriftHiveMetastore_alter_partition_args() : db_name(), tbl_name() {
    }
  
    virtual ~ThriftHiveMetastore_alter_partition_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    Partition new_part;
  
    _ThriftHiveMetastore_alter_partition_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_new_part(const Partition& val) {
      new_part = val;
    }
  
    bool operator == (const ThriftHiveMetastore_alter_partition_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(new_part == rhs.new_part))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_alter_partition_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_alter_partition_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_alter_partition_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_alter_partition_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const Partition* new_part;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_partition_result__isset {
    _ThriftHiveMetastore_alter_partition_result__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_alter_partition_result__isset;
  
  class ThriftHiveMetastore_alter_partition_result {
   public:
  
    ThriftHiveMetastore_alter_partition_result() {
    }
  
    virtual ~ThriftHiveMetastore_alter_partition_result() throw() {}
  
    InvalidOperationException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_alter_partition_result__isset __isset;
  
    void __set_o1(const InvalidOperationException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_alter_partition_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_alter_partition_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_alter_partition_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_partition_presult__isset {
    _ThriftHiveMetastore_alter_partition_presult__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_alter_partition_presult__isset;
  
  class ThriftHiveMetastore_alter_partition_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_alter_partition_presult() throw() {}
  
    InvalidOperationException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_alter_partition_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_partitions_args__isset {
    _ThriftHiveMetastore_alter_partitions_args__isset() : db_name(false), tbl_name(false), new_parts(false) {}
    bool db_name;
    bool tbl_name;
    bool new_parts;
  } _ThriftHiveMetastore_alter_partitions_args__isset;
  
  class ThriftHiveMetastore_alter_partitions_args {
   public:
  
    ThriftHiveMetastore_alter_partitions_args() : db_name(), tbl_name() {
    }
  
    virtual ~ThriftHiveMetastore_alter_partitions_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::vector<Partition>  new_parts;
  
    _ThriftHiveMetastore_alter_partitions_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_new_parts(const std::vector<Partition> & val) {
      new_parts = val;
    }
  
    bool operator == (const ThriftHiveMetastore_alter_partitions_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(new_parts == rhs.new_parts))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_alter_partitions_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_alter_partitions_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_alter_partitions_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_alter_partitions_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::vector<Partition> * new_parts;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_partitions_result__isset {
    _ThriftHiveMetastore_alter_partitions_result__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_alter_partitions_result__isset;
  
  class ThriftHiveMetastore_alter_partitions_result {
   public:
  
    ThriftHiveMetastore_alter_partitions_result() {
    }
  
    virtual ~ThriftHiveMetastore_alter_partitions_result() throw() {}
  
    InvalidOperationException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_alter_partitions_result__isset __isset;
  
    void __set_o1(const InvalidOperationException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_alter_partitions_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_alter_partitions_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_alter_partitions_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_partitions_presult__isset {
    _ThriftHiveMetastore_alter_partitions_presult__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_alter_partitions_presult__isset;
  
  class ThriftHiveMetastore_alter_partitions_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_alter_partitions_presult() throw() {}
  
    InvalidOperationException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_alter_partitions_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_partition_with_environment_context_args__isset {
    _ThriftHiveMetastore_alter_partition_with_environment_context_args__isset() : db_name(false), tbl_name(false), new_part(false), environment_context(false) {}
    bool db_name;
    bool tbl_name;
    bool new_part;
    bool environment_context;
  } _ThriftHiveMetastore_alter_partition_with_environment_context_args__isset;
  
  class ThriftHiveMetastore_alter_partition_with_environment_context_args {
   public:
  
    ThriftHiveMetastore_alter_partition_with_environment_context_args() : db_name(), tbl_name() {
    }
  
    virtual ~ThriftHiveMetastore_alter_partition_with_environment_context_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    Partition new_part;
    EnvironmentContext environment_context;
  
    _ThriftHiveMetastore_alter_partition_with_environment_context_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_new_part(const Partition& val) {
      new_part = val;
    }
  
    void __set_environment_context(const EnvironmentContext& val) {
      environment_context = val;
    }
  
    bool operator == (const ThriftHiveMetastore_alter_partition_with_environment_context_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(new_part == rhs.new_part))
        return false;
      if (!(environment_context == rhs.environment_context))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_alter_partition_with_environment_context_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_alter_partition_with_environment_context_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_alter_partition_with_environment_context_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_alter_partition_with_environment_context_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const Partition* new_part;
    const EnvironmentContext* environment_context;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_partition_with_environment_context_result__isset {
    _ThriftHiveMetastore_alter_partition_with_environment_context_result__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_alter_partition_with_environment_context_result__isset;
  
  class ThriftHiveMetastore_alter_partition_with_environment_context_result {
   public:
  
    ThriftHiveMetastore_alter_partition_with_environment_context_result() {
    }
  
    virtual ~ThriftHiveMetastore_alter_partition_with_environment_context_result() throw() {}
  
    InvalidOperationException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_alter_partition_with_environment_context_result__isset __isset;
  
    void __set_o1(const InvalidOperationException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_alter_partition_with_environment_context_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_alter_partition_with_environment_context_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_alter_partition_with_environment_context_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_partition_with_environment_context_presult__isset {
    _ThriftHiveMetastore_alter_partition_with_environment_context_presult__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_alter_partition_with_environment_context_presult__isset;
  
  class ThriftHiveMetastore_alter_partition_with_environment_context_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_alter_partition_with_environment_context_presult() throw() {}
  
    InvalidOperationException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_alter_partition_with_environment_context_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_rename_partition_args__isset {
    _ThriftHiveMetastore_rename_partition_args__isset() : db_name(false), tbl_name(false), part_vals(false), new_part(false) {}
    bool db_name;
    bool tbl_name;
    bool part_vals;
    bool new_part;
  } _ThriftHiveMetastore_rename_partition_args__isset;
  
  class ThriftHiveMetastore_rename_partition_args {
   public:
  
    ThriftHiveMetastore_rename_partition_args() : db_name(), tbl_name() {
    }
  
    virtual ~ThriftHiveMetastore_rename_partition_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::vector<std::string>  part_vals;
    Partition new_part;
  
    _ThriftHiveMetastore_rename_partition_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_vals(const std::vector<std::string> & val) {
      part_vals = val;
    }
  
    void __set_new_part(const Partition& val) {
      new_part = val;
    }
  
    bool operator == (const ThriftHiveMetastore_rename_partition_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 (!(new_part == rhs.new_part))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_rename_partition_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_rename_partition_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_rename_partition_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_rename_partition_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::vector<std::string> * part_vals;
    const Partition* new_part;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_rename_partition_result__isset {
    _ThriftHiveMetastore_rename_partition_result__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_rename_partition_result__isset;
  
  class ThriftHiveMetastore_rename_partition_result {
   public:
  
    ThriftHiveMetastore_rename_partition_result() {
    }
  
    virtual ~ThriftHiveMetastore_rename_partition_result() throw() {}
  
    InvalidOperationException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_rename_partition_result__isset __isset;
  
    void __set_o1(const InvalidOperationException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_rename_partition_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_rename_partition_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_rename_partition_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_rename_partition_presult__isset {
    _ThriftHiveMetastore_rename_partition_presult__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_rename_partition_presult__isset;
  
  class ThriftHiveMetastore_rename_partition_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_rename_partition_presult() throw() {}
  
    InvalidOperationException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_rename_partition_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_partition_name_has_valid_characters_args__isset {
    _ThriftHiveMetastore_partition_name_has_valid_characters_args__isset() : part_vals(false), throw_exception(false) {}
    bool part_vals;
    bool throw_exception;
  } _ThriftHiveMetastore_partition_name_has_valid_characters_args__isset;
  
  class ThriftHiveMetastore_partition_name_has_valid_characters_args {
   public:
  
    ThriftHiveMetastore_partition_name_has_valid_characters_args() : throw_exception(0) {
    }
  
    virtual ~ThriftHiveMetastore_partition_name_has_valid_characters_args() throw() {}
  
    std::vector<std::string>  part_vals;
    bool throw_exception;
  
    _ThriftHiveMetastore_partition_name_has_valid_characters_args__isset __isset;
  
    void __set_part_vals(const std::vector<std::string> & val) {
      part_vals = val;
    }
  
    void __set_throw_exception(const bool val) {
      throw_exception = val;
    }
  
    bool operator == (const ThriftHiveMetastore_partition_name_has_valid_characters_args & rhs) const
    {
      if (!(part_vals == rhs.part_vals))
        return false;
      if (!(throw_exception == rhs.throw_exception))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_partition_name_has_valid_characters_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_partition_name_has_valid_characters_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_partition_name_has_valid_characters_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_partition_name_has_valid_characters_pargs() throw() {}
  
    const std::vector<std::string> * part_vals;
    const bool* throw_exception;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_partition_name_has_valid_characters_result__isset {
    _ThriftHiveMetastore_partition_name_has_valid_characters_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_partition_name_has_valid_characters_result__isset;
  
  class ThriftHiveMetastore_partition_name_has_valid_characters_result {
   public:
  
    ThriftHiveMetastore_partition_name_has_valid_characters_result() : success(0) {
    }
  
    virtual ~ThriftHiveMetastore_partition_name_has_valid_characters_result() throw() {}
  
    bool success;
    MetaException o1;
  
    _ThriftHiveMetastore_partition_name_has_valid_characters_result__isset __isset;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_partition_name_has_valid_characters_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_partition_name_has_valid_characters_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_partition_name_has_valid_characters_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_partition_name_has_valid_characters_presult__isset {
    _ThriftHiveMetastore_partition_name_has_valid_characters_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_partition_name_has_valid_characters_presult__isset;
  
  class ThriftHiveMetastore_partition_name_has_valid_characters_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_partition_name_has_valid_characters_presult() throw() {}
  
    bool* success;
    MetaException o1;
  
    _ThriftHiveMetastore_partition_name_has_valid_characters_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_config_value_args__isset {
    _ThriftHiveMetastore_get_config_value_args__isset() : name(false), defaultValue(false) {}
    bool name;
    bool defaultValue;
  } _ThriftHiveMetastore_get_config_value_args__isset;
  
  class ThriftHiveMetastore_get_config_value_args {
   public:
  
    ThriftHiveMetastore_get_config_value_args() : name(), defaultValue() {
    }
  
    virtual ~ThriftHiveMetastore_get_config_value_args() throw() {}
  
    std::string name;
    std::string defaultValue;
  
    _ThriftHiveMetastore_get_config_value_args__isset __isset;
  
    void __set_name(const std::string& val) {
      name = val;
    }
  
    void __set_defaultValue(const std::string& val) {
      defaultValue = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_config_value_args & rhs) const
    {
      if (!(name == rhs.name))
        return false;
      if (!(defaultValue == rhs.defaultValue))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_config_value_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_config_value_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_config_value_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_config_value_pargs() throw() {}
  
    const std::string* name;
    const std::string* defaultValue;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_config_value_result__isset {
    _ThriftHiveMetastore_get_config_value_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_config_value_result__isset;
  
  class ThriftHiveMetastore_get_config_value_result {
   public:
  
    ThriftHiveMetastore_get_config_value_result() : success() {
    }
  
    virtual ~ThriftHiveMetastore_get_config_value_result() throw() {}
  
    std::string success;
    ConfigValSecurityException o1;
  
    _ThriftHiveMetastore_get_config_value_result__isset __isset;
  
    void __set_success(const std::string& val) {
      success = val;
    }
  
    void __set_o1(const ConfigValSecurityException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_config_value_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_config_value_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_config_value_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_config_value_presult__isset {
    _ThriftHiveMetastore_get_config_value_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_config_value_presult__isset;
  
  class ThriftHiveMetastore_get_config_value_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_config_value_presult() throw() {}
  
    std::string* success;
    ConfigValSecurityException o1;
  
    _ThriftHiveMetastore_get_config_value_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_partition_name_to_vals_args__isset {
    _ThriftHiveMetastore_partition_name_to_vals_args__isset() : part_name(false) {}
    bool part_name;
  } _ThriftHiveMetastore_partition_name_to_vals_args__isset;
  
  class ThriftHiveMetastore_partition_name_to_vals_args {
   public:
  
    ThriftHiveMetastore_partition_name_to_vals_args() : part_name() {
    }
  
    virtual ~ThriftHiveMetastore_partition_name_to_vals_args() throw() {}
  
    std::string part_name;
  
    _ThriftHiveMetastore_partition_name_to_vals_args__isset __isset;
  
    void __set_part_name(const std::string& val) {
      part_name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_partition_name_to_vals_args & rhs) const
    {
      if (!(part_name == rhs.part_name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_partition_name_to_vals_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_partition_name_to_vals_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_partition_name_to_vals_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_partition_name_to_vals_pargs() throw() {}
  
    const std::string* part_name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_partition_name_to_vals_result__isset {
    _ThriftHiveMetastore_partition_name_to_vals_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_partition_name_to_vals_result__isset;
  
  class ThriftHiveMetastore_partition_name_to_vals_result {
   public:
  
    ThriftHiveMetastore_partition_name_to_vals_result() {
    }
  
    virtual ~ThriftHiveMetastore_partition_name_to_vals_result() throw() {}
  
    std::vector<std::string>  success;
    MetaException o1;
  
    _ThriftHiveMetastore_partition_name_to_vals_result__isset __isset;
  
    void __set_success(const std::vector<std::string> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_partition_name_to_vals_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_partition_name_to_vals_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_partition_name_to_vals_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_partition_name_to_vals_presult__isset {
    _ThriftHiveMetastore_partition_name_to_vals_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_partition_name_to_vals_presult__isset;
  
  class ThriftHiveMetastore_partition_name_to_vals_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_partition_name_to_vals_presult() throw() {}
  
    std::vector<std::string> * success;
    MetaException o1;
  
    _ThriftHiveMetastore_partition_name_to_vals_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_partition_name_to_spec_args__isset {
    _ThriftHiveMetastore_partition_name_to_spec_args__isset() : part_name(false) {}
    bool part_name;
  } _ThriftHiveMetastore_partition_name_to_spec_args__isset;
  
  class ThriftHiveMetastore_partition_name_to_spec_args {
   public:
  
    ThriftHiveMetastore_partition_name_to_spec_args() : part_name() {
    }
  
    virtual ~ThriftHiveMetastore_partition_name_to_spec_args() throw() {}
  
    std::string part_name;
  
    _ThriftHiveMetastore_partition_name_to_spec_args__isset __isset;
  
    void __set_part_name(const std::string& val) {
      part_name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_partition_name_to_spec_args & rhs) const
    {
      if (!(part_name == rhs.part_name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_partition_name_to_spec_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_partition_name_to_spec_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_partition_name_to_spec_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_partition_name_to_spec_pargs() throw() {}
  
    const std::string* part_name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_partition_name_to_spec_result__isset {
    _ThriftHiveMetastore_partition_name_to_spec_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_partition_name_to_spec_result__isset;
  
  class ThriftHiveMetastore_partition_name_to_spec_result {
   public:
  
    ThriftHiveMetastore_partition_name_to_spec_result() {
    }
  
    virtual ~ThriftHiveMetastore_partition_name_to_spec_result() throw() {}
  
    std::map<std::string, std::string>  success;
    MetaException o1;
  
    _ThriftHiveMetastore_partition_name_to_spec_result__isset __isset;
  
    void __set_success(const std::map<std::string, std::string> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_partition_name_to_spec_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_partition_name_to_spec_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_partition_name_to_spec_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_partition_name_to_spec_presult__isset {
    _ThriftHiveMetastore_partition_name_to_spec_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_partition_name_to_spec_presult__isset;
  
  class ThriftHiveMetastore_partition_name_to_spec_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_partition_name_to_spec_presult() throw() {}
  
    std::map<std::string, std::string> * success;
    MetaException o1;
  
    _ThriftHiveMetastore_partition_name_to_spec_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_markPartitionForEvent_args__isset {
    _ThriftHiveMetastore_markPartitionForEvent_args__isset() : db_name(false), tbl_name(false), part_vals(false), eventType(false) {}
    bool db_name;
    bool tbl_name;
    bool part_vals;
    bool eventType;
  } _ThriftHiveMetastore_markPartitionForEvent_args__isset;
  
  class ThriftHiveMetastore_markPartitionForEvent_args {
   public:
  
    ThriftHiveMetastore_markPartitionForEvent_args() : db_name(), tbl_name(), eventType((PartitionEventType::type)0) {
    }
  
    virtual ~ThriftHiveMetastore_markPartitionForEvent_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::map<std::string, std::string>  part_vals;
    PartitionEventType::type eventType;
  
    _ThriftHiveMetastore_markPartitionForEvent_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_vals(const std::map<std::string, std::string> & val) {
      part_vals = val;
    }
  
    void __set_eventType(const PartitionEventType::type val) {
      eventType = val;
    }
  
    bool operator == (const ThriftHiveMetastore_markPartitionForEvent_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 (!(eventType == rhs.eventType))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_markPartitionForEvent_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_markPartitionForEvent_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_markPartitionForEvent_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_markPartitionForEvent_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::map<std::string, std::string> * part_vals;
    const PartitionEventType::type* eventType;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_markPartitionForEvent_result__isset {
    _ThriftHiveMetastore_markPartitionForEvent_result__isset() : o1(false), o2(false), o3(false), o4(false), o5(false), o6(false) {}
    bool o1;
    bool o2;
    bool o3;
    bool o4;
    bool o5;
    bool o6;
  } _ThriftHiveMetastore_markPartitionForEvent_result__isset;
  
  class ThriftHiveMetastore_markPartitionForEvent_result {
   public:
  
    ThriftHiveMetastore_markPartitionForEvent_result() {
    }
  
    virtual ~ThriftHiveMetastore_markPartitionForEvent_result() throw() {}
  
    MetaException o1;
    NoSuchObjectException o2;
    UnknownDBException o3;
    UnknownTableException o4;
    UnknownPartitionException o5;
    InvalidPartitionException o6;
  
    _ThriftHiveMetastore_markPartitionForEvent_result__isset __isset;
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    void __set_o3(const UnknownDBException& val) {
      o3 = val;
    }
  
    void __set_o4(const UnknownTableException& val) {
      o4 = val;
    }
  
    void __set_o5(const UnknownPartitionException& val) {
      o5 = val;
    }
  
    void __set_o6(const InvalidPartitionException& val) {
      o6 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_markPartitionForEvent_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      if (!(o3 == rhs.o3))
        return false;
      if (!(o4 == rhs.o4))
        return false;
      if (!(o5 == rhs.o5))
        return false;
      if (!(o6 == rhs.o6))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_markPartitionForEvent_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_markPartitionForEvent_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_markPartitionForEvent_presult__isset {
    _ThriftHiveMetastore_markPartitionForEvent_presult__isset() : o1(false), o2(false), o3(false), o4(false), o5(false), o6(false) {}
    bool o1;
    bool o2;
    bool o3;
    bool o4;
    bool o5;
    bool o6;
  } _ThriftHiveMetastore_markPartitionForEvent_presult__isset;
  
  class ThriftHiveMetastore_markPartitionForEvent_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_markPartitionForEvent_presult() throw() {}
  
    MetaException o1;
    NoSuchObjectException o2;
    UnknownDBException o3;
    UnknownTableException o4;
    UnknownPartitionException o5;
    InvalidPartitionException o6;
  
    _ThriftHiveMetastore_markPartitionForEvent_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_isPartitionMarkedForEvent_args__isset {
    _ThriftHiveMetastore_isPartitionMarkedForEvent_args__isset() : db_name(false), tbl_name(false), part_vals(false), eventType(false) {}
    bool db_name;
    bool tbl_name;
    bool part_vals;
    bool eventType;
  } _ThriftHiveMetastore_isPartitionMarkedForEvent_args__isset;
  
  class ThriftHiveMetastore_isPartitionMarkedForEvent_args {
   public:
  
    ThriftHiveMetastore_isPartitionMarkedForEvent_args() : db_name(), tbl_name(), eventType((PartitionEventType::type)0) {
    }
  
    virtual ~ThriftHiveMetastore_isPartitionMarkedForEvent_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::map<std::string, std::string>  part_vals;
    PartitionEventType::type eventType;
  
    _ThriftHiveMetastore_isPartitionMarkedForEvent_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_vals(const std::map<std::string, std::string> & val) {
      part_vals = val;
    }
  
    void __set_eventType(const PartitionEventType::type val) {
      eventType = val;
    }
  
    bool operator == (const ThriftHiveMetastore_isPartitionMarkedForEvent_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 (!(eventType == rhs.eventType))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_isPartitionMarkedForEvent_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_isPartitionMarkedForEvent_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_isPartitionMarkedForEvent_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_isPartitionMarkedForEvent_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::map<std::string, std::string> * part_vals;
    const PartitionEventType::type* eventType;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_isPartitionMarkedForEvent_result__isset {
    _ThriftHiveMetastore_isPartitionMarkedForEvent_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false), o5(false), o6(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
    bool o4;
    bool o5;
    bool o6;
  } _ThriftHiveMetastore_isPartitionMarkedForEvent_result__isset;
  
  class ThriftHiveMetastore_isPartitionMarkedForEvent_result {
   public:
  
    ThriftHiveMetastore_isPartitionMarkedForEvent_result() : success(0) {
    }
  
    virtual ~ThriftHiveMetastore_isPartitionMarkedForEvent_result() throw() {}
  
    bool success;
    MetaException o1;
    NoSuchObjectException o2;
    UnknownDBException o3;
    UnknownTableException o4;
    UnknownPartitionException o5;
    InvalidPartitionException o6;
  
    _ThriftHiveMetastore_isPartitionMarkedForEvent_result__isset __isset;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    void __set_o3(const UnknownDBException& val) {
      o3 = val;
    }
  
    void __set_o4(const UnknownTableException& val) {
      o4 = val;
    }
  
    void __set_o5(const UnknownPartitionException& val) {
      o5 = val;
    }
  
    void __set_o6(const InvalidPartitionException& val) {
      o6 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_isPartitionMarkedForEvent_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;
      if (!(o4 == rhs.o4))
        return false;
      if (!(o5 == rhs.o5))
        return false;
      if (!(o6 == rhs.o6))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_isPartitionMarkedForEvent_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_isPartitionMarkedForEvent_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_isPartitionMarkedForEvent_presult__isset {
    _ThriftHiveMetastore_isPartitionMarkedForEvent_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false), o5(false), o6(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
    bool o4;
    bool o5;
    bool o6;
  } _ThriftHiveMetastore_isPartitionMarkedForEvent_presult__isset;
  
  class ThriftHiveMetastore_isPartitionMarkedForEvent_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_isPartitionMarkedForEvent_presult() throw() {}
  
    bool* success;
    MetaException o1;
    NoSuchObjectException o2;
    UnknownDBException o3;
    UnknownTableException o4;
    UnknownPartitionException o5;
    InvalidPartitionException o6;
  
    _ThriftHiveMetastore_isPartitionMarkedForEvent_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_add_index_args__isset {
    _ThriftHiveMetastore_add_index_args__isset() : new_index(false), index_table(false) {}
    bool new_index;
    bool index_table;
  } _ThriftHiveMetastore_add_index_args__isset;
  
  class ThriftHiveMetastore_add_index_args {
   public:
  
    ThriftHiveMetastore_add_index_args() {
    }
  
    virtual ~ThriftHiveMetastore_add_index_args() throw() {}
  
    Index new_index;
    Table index_table;
  
    _ThriftHiveMetastore_add_index_args__isset __isset;
  
    void __set_new_index(const Index& val) {
      new_index = val;
    }
  
    void __set_index_table(const Table& val) {
      index_table = val;
    }
  
    bool operator == (const ThriftHiveMetastore_add_index_args & rhs) const
    {
      if (!(new_index == rhs.new_index))
        return false;
      if (!(index_table == rhs.index_table))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_add_index_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_add_index_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_add_index_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_add_index_pargs() throw() {}
  
    const Index* new_index;
    const Table* index_table;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_add_index_result__isset {
    _ThriftHiveMetastore_add_index_result__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_add_index_result__isset;
  
  class ThriftHiveMetastore_add_index_result {
   public:
  
    ThriftHiveMetastore_add_index_result() {
    }
  
    virtual ~ThriftHiveMetastore_add_index_result() throw() {}
  
    Index success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_add_index_result__isset __isset;
  
    void __set_success(const Index& val) {
      success = val;
    }
  
    void __set_o1(const InvalidObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const AlreadyExistsException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_add_index_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      if (!(o3 == rhs.o3))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_add_index_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_add_index_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_add_index_presult__isset {
    _ThriftHiveMetastore_add_index_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
  } _ThriftHiveMetastore_add_index_presult__isset;
  
  class ThriftHiveMetastore_add_index_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_add_index_presult() throw() {}
  
    Index* success;
    InvalidObjectException o1;
    AlreadyExistsException o2;
    MetaException o3;
  
    _ThriftHiveMetastore_add_index_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_index_args__isset {
    _ThriftHiveMetastore_alter_index_args__isset() : dbname(false), base_tbl_name(false), idx_name(false), new_idx(false) {}
    bool dbname;
    bool base_tbl_name;
    bool idx_name;
    bool new_idx;
  } _ThriftHiveMetastore_alter_index_args__isset;
  
  class ThriftHiveMetastore_alter_index_args {
   public:
  
    ThriftHiveMetastore_alter_index_args() : dbname(), base_tbl_name(), idx_name() {
    }
  
    virtual ~ThriftHiveMetastore_alter_index_args() throw() {}
  
    std::string dbname;
    std::string base_tbl_name;
    std::string idx_name;
    Index new_idx;
  
    _ThriftHiveMetastore_alter_index_args__isset __isset;
  
    void __set_dbname(const std::string& val) {
      dbname = val;
    }
  
    void __set_base_tbl_name(const std::string& val) {
      base_tbl_name = val;
    }
  
    void __set_idx_name(const std::string& val) {
      idx_name = val;
    }
  
    void __set_new_idx(const Index& val) {
      new_idx = val;
    }
  
    bool operator == (const ThriftHiveMetastore_alter_index_args & rhs) const
    {
      if (!(dbname == rhs.dbname))
        return false;
      if (!(base_tbl_name == rhs.base_tbl_name))
        return false;
      if (!(idx_name == rhs.idx_name))
        return false;
      if (!(new_idx == rhs.new_idx))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_alter_index_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_alter_index_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_alter_index_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_alter_index_pargs() throw() {}
  
    const std::string* dbname;
    const std::string* base_tbl_name;
    const std::string* idx_name;
    const Index* new_idx;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_index_result__isset {
    _ThriftHiveMetastore_alter_index_result__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_alter_index_result__isset;
  
  class ThriftHiveMetastore_alter_index_result {
   public:
  
    ThriftHiveMetastore_alter_index_result() {
    }
  
    virtual ~ThriftHiveMetastore_alter_index_result() throw() {}
  
    InvalidOperationException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_alter_index_result__isset __isset;
  
    void __set_o1(const InvalidOperationException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_alter_index_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_alter_index_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_alter_index_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_index_presult__isset {
    _ThriftHiveMetastore_alter_index_presult__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_alter_index_presult__isset;
  
  class ThriftHiveMetastore_alter_index_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_alter_index_presult() throw() {}
  
    InvalidOperationException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_alter_index_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_index_by_name_args__isset {
    _ThriftHiveMetastore_drop_index_by_name_args__isset() : db_name(false), tbl_name(false), index_name(false), deleteData(false) {}
    bool db_name;
    bool tbl_name;
    bool index_name;
    bool deleteData;
  } _ThriftHiveMetastore_drop_index_by_name_args__isset;
  
  class ThriftHiveMetastore_drop_index_by_name_args {
   public:
  
    ThriftHiveMetastore_drop_index_by_name_args() : db_name(), tbl_name(), index_name(), deleteData(0) {
    }
  
    virtual ~ThriftHiveMetastore_drop_index_by_name_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::string index_name;
    bool deleteData;
  
    _ThriftHiveMetastore_drop_index_by_name_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_index_name(const std::string& val) {
      index_name = val;
    }
  
    void __set_deleteData(const bool val) {
      deleteData = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_index_by_name_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(index_name == rhs.index_name))
        return false;
      if (!(deleteData == rhs.deleteData))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_drop_index_by_name_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_index_by_name_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_drop_index_by_name_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_index_by_name_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::string* index_name;
    const bool* deleteData;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_index_by_name_result__isset {
    _ThriftHiveMetastore_drop_index_by_name_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_drop_index_by_name_result__isset;
  
  class ThriftHiveMetastore_drop_index_by_name_result {
   public:
  
    ThriftHiveMetastore_drop_index_by_name_result() : success(0) {
    }
  
    virtual ~ThriftHiveMetastore_drop_index_by_name_result() throw() {}
  
    bool success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_drop_index_by_name_result__isset __isset;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_index_by_name_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_drop_index_by_name_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_index_by_name_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_index_by_name_presult__isset {
    _ThriftHiveMetastore_drop_index_by_name_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_drop_index_by_name_presult__isset;
  
  class ThriftHiveMetastore_drop_index_by_name_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_index_by_name_presult() throw() {}
  
    bool* success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_drop_index_by_name_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_index_by_name_args__isset {
    _ThriftHiveMetastore_get_index_by_name_args__isset() : db_name(false), tbl_name(false), index_name(false) {}
    bool db_name;
    bool tbl_name;
    bool index_name;
  } _ThriftHiveMetastore_get_index_by_name_args__isset;
  
  class ThriftHiveMetastore_get_index_by_name_args {
   public:
  
    ThriftHiveMetastore_get_index_by_name_args() : db_name(), tbl_name(), index_name() {
    }
  
    virtual ~ThriftHiveMetastore_get_index_by_name_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::string index_name;
  
    _ThriftHiveMetastore_get_index_by_name_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_index_name(const std::string& val) {
      index_name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_index_by_name_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(index_name == rhs.index_name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_index_by_name_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_index_by_name_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_index_by_name_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_index_by_name_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::string* index_name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_index_by_name_result__isset {
    _ThriftHiveMetastore_get_index_by_name_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_index_by_name_result__isset;
  
  class ThriftHiveMetastore_get_index_by_name_result {
   public:
  
    ThriftHiveMetastore_get_index_by_name_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_index_by_name_result() throw() {}
  
    Index success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_index_by_name_result__isset __isset;
  
    void __set_success(const Index& val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_index_by_name_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_index_by_name_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_index_by_name_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_index_by_name_presult__isset {
    _ThriftHiveMetastore_get_index_by_name_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_index_by_name_presult__isset;
  
  class ThriftHiveMetastore_get_index_by_name_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_index_by_name_presult() throw() {}
  
    Index* success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_index_by_name_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_indexes_args__isset {
    _ThriftHiveMetastore_get_indexes_args__isset() : db_name(false), tbl_name(false), max_indexes(true) {}
    bool db_name;
    bool tbl_name;
    bool max_indexes;
  } _ThriftHiveMetastore_get_indexes_args__isset;
  
  class ThriftHiveMetastore_get_indexes_args {
   public:
  
    ThriftHiveMetastore_get_indexes_args() : db_name(), tbl_name(), max_indexes(-1) {
    }
  
    virtual ~ThriftHiveMetastore_get_indexes_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    int16_t max_indexes;
  
    _ThriftHiveMetastore_get_indexes_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_max_indexes(const int16_t val) {
      max_indexes = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_indexes_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(max_indexes == rhs.max_indexes))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_indexes_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_indexes_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_indexes_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_indexes_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const int16_t* max_indexes;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_indexes_result__isset {
    _ThriftHiveMetastore_get_indexes_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_indexes_result__isset;
  
  class ThriftHiveMetastore_get_indexes_result {
   public:
  
    ThriftHiveMetastore_get_indexes_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_indexes_result() throw() {}
  
    std::vector<Index>  success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_get_indexes_result__isset __isset;
  
    void __set_success(const std::vector<Index> & val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_indexes_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_indexes_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_indexes_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_indexes_presult__isset {
    _ThriftHiveMetastore_get_indexes_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_indexes_presult__isset;
  
  class ThriftHiveMetastore_get_indexes_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_indexes_presult() throw() {}
  
    std::vector<Index> * success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_get_indexes_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_index_names_args__isset {
    _ThriftHiveMetastore_get_index_names_args__isset() : db_name(false), tbl_name(false), max_indexes(true) {}
    bool db_name;
    bool tbl_name;
    bool max_indexes;
  } _ThriftHiveMetastore_get_index_names_args__isset;
  
  class ThriftHiveMetastore_get_index_names_args {
   public:
  
    ThriftHiveMetastore_get_index_names_args() : db_name(), tbl_name(), max_indexes(-1) {
    }
  
    virtual ~ThriftHiveMetastore_get_index_names_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    int16_t max_indexes;
  
    _ThriftHiveMetastore_get_index_names_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_max_indexes(const int16_t val) {
      max_indexes = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_index_names_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(max_indexes == rhs.max_indexes))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_index_names_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_index_names_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_index_names_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_index_names_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const int16_t* max_indexes;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_index_names_result__isset {
    _ThriftHiveMetastore_get_index_names_result__isset() : success(false), o2(false) {}
    bool success;
    bool o2;
  } _ThriftHiveMetastore_get_index_names_result__isset;
  
  class ThriftHiveMetastore_get_index_names_result {
   public:
  
    ThriftHiveMetastore_get_index_names_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_index_names_result() throw() {}
  
    std::vector<std::string>  success;
    MetaException o2;
  
    _ThriftHiveMetastore_get_index_names_result__isset __isset;
  
    void __set_success(const std::vector<std::string> & val) {
      success = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_index_names_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_index_names_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_index_names_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_index_names_presult__isset {
    _ThriftHiveMetastore_get_index_names_presult__isset() : success(false), o2(false) {}
    bool success;
    bool o2;
  } _ThriftHiveMetastore_get_index_names_presult__isset;
  
  class ThriftHiveMetastore_get_index_names_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_index_names_presult() throw() {}
  
    std::vector<std::string> * success;
    MetaException o2;
  
    _ThriftHiveMetastore_get_index_names_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_update_table_column_statistics_args__isset {
    _ThriftHiveMetastore_update_table_column_statistics_args__isset() : stats_obj(false) {}
    bool stats_obj;
  } _ThriftHiveMetastore_update_table_column_statistics_args__isset;
  
  class ThriftHiveMetastore_update_table_column_statistics_args {
   public:
  
    ThriftHiveMetastore_update_table_column_statistics_args() {
    }
  
    virtual ~ThriftHiveMetastore_update_table_column_statistics_args() throw() {}
  
    ColumnStatistics stats_obj;
  
    _ThriftHiveMetastore_update_table_column_statistics_args__isset __isset;
  
    void __set_stats_obj(const ColumnStatistics& val) {
      stats_obj = val;
    }
  
    bool operator == (const ThriftHiveMetastore_update_table_column_statistics_args & rhs) const
    {
      if (!(stats_obj == rhs.stats_obj))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_update_table_column_statistics_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_update_table_column_statistics_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_update_table_column_statistics_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_update_table_column_statistics_pargs() throw() {}
  
    const ColumnStatistics* stats_obj;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_update_table_column_statistics_result__isset {
    _ThriftHiveMetastore_update_table_column_statistics_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_update_table_column_statistics_result__isset;
  
  class ThriftHiveMetastore_update_table_column_statistics_result {
   public:
  
    ThriftHiveMetastore_update_table_column_statistics_result() : success(0) {
    }
  
    virtual ~ThriftHiveMetastore_update_table_column_statistics_result() throw() {}
  
    bool success;
    NoSuchObjectException o1;
    InvalidObjectException o2;
    MetaException o3;
    InvalidInputException o4;
  
    _ThriftHiveMetastore_update_table_column_statistics_result__isset __isset;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const InvalidObjectException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    void __set_o4(const InvalidInputException& val) {
      o4 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_update_table_column_statistics_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;
      if (!(o4 == rhs.o4))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_update_table_column_statistics_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_update_table_column_statistics_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_update_table_column_statistics_presult__isset {
    _ThriftHiveMetastore_update_table_column_statistics_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_update_table_column_statistics_presult__isset;
  
  class ThriftHiveMetastore_update_table_column_statistics_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_update_table_column_statistics_presult() throw() {}
  
    bool* success;
    NoSuchObjectException o1;
    InvalidObjectException o2;
    MetaException o3;
    InvalidInputException o4;
  
    _ThriftHiveMetastore_update_table_column_statistics_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_update_partition_column_statistics_args__isset {
    _ThriftHiveMetastore_update_partition_column_statistics_args__isset() : stats_obj(false) {}
    bool stats_obj;
  } _ThriftHiveMetastore_update_partition_column_statistics_args__isset;
  
  class ThriftHiveMetastore_update_partition_column_statistics_args {
   public:
  
    ThriftHiveMetastore_update_partition_column_statistics_args() {
    }
  
    virtual ~ThriftHiveMetastore_update_partition_column_statistics_args() throw() {}
  
    ColumnStatistics stats_obj;
  
    _ThriftHiveMetastore_update_partition_column_statistics_args__isset __isset;
  
    void __set_stats_obj(const ColumnStatistics& val) {
      stats_obj = val;
    }
  
    bool operator == (const ThriftHiveMetastore_update_partition_column_statistics_args & rhs) const
    {
      if (!(stats_obj == rhs.stats_obj))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_update_partition_column_statistics_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_update_partition_column_statistics_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_update_partition_column_statistics_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_update_partition_column_statistics_pargs() throw() {}
  
    const ColumnStatistics* stats_obj;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_update_partition_column_statistics_result__isset {
    _ThriftHiveMetastore_update_partition_column_statistics_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_update_partition_column_statistics_result__isset;
  
  class ThriftHiveMetastore_update_partition_column_statistics_result {
   public:
  
    ThriftHiveMetastore_update_partition_column_statistics_result() : success(0) {
    }
  
    virtual ~ThriftHiveMetastore_update_partition_column_statistics_result() throw() {}
  
    bool success;
    NoSuchObjectException o1;
    InvalidObjectException o2;
    MetaException o3;
    InvalidInputException o4;
  
    _ThriftHiveMetastore_update_partition_column_statistics_result__isset __isset;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const InvalidObjectException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    void __set_o4(const InvalidInputException& val) {
      o4 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_update_partition_column_statistics_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;
      if (!(o4 == rhs.o4))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_update_partition_column_statistics_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_update_partition_column_statistics_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_update_partition_column_statistics_presult__isset {
    _ThriftHiveMetastore_update_partition_column_statistics_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_update_partition_column_statistics_presult__isset;
  
  class ThriftHiveMetastore_update_partition_column_statistics_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_update_partition_column_statistics_presult() throw() {}
  
    bool* success;
    NoSuchObjectException o1;
    InvalidObjectException o2;
    MetaException o3;
    InvalidInputException o4;
  
    _ThriftHiveMetastore_update_partition_column_statistics_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_table_column_statistics_args__isset {
    _ThriftHiveMetastore_get_table_column_statistics_args__isset() : db_name(false), tbl_name(false), col_name(false) {}
    bool db_name;
    bool tbl_name;
    bool col_name;
  } _ThriftHiveMetastore_get_table_column_statistics_args__isset;
  
  class ThriftHiveMetastore_get_table_column_statistics_args {
   public:
  
    ThriftHiveMetastore_get_table_column_statistics_args() : db_name(), tbl_name(), col_name() {
    }
  
    virtual ~ThriftHiveMetastore_get_table_column_statistics_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::string col_name;
  
    _ThriftHiveMetastore_get_table_column_statistics_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_col_name(const std::string& val) {
      col_name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_table_column_statistics_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(col_name == rhs.col_name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_table_column_statistics_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_table_column_statistics_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_table_column_statistics_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_table_column_statistics_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::string* col_name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_table_column_statistics_result__isset {
    _ThriftHiveMetastore_get_table_column_statistics_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_get_table_column_statistics_result__isset;
  
  class ThriftHiveMetastore_get_table_column_statistics_result {
   public:
  
    ThriftHiveMetastore_get_table_column_statistics_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_table_column_statistics_result() throw() {}
  
    ColumnStatistics success;
    NoSuchObjectException o1;
    MetaException o2;
    InvalidInputException o3;
    InvalidObjectException o4;
  
    _ThriftHiveMetastore_get_table_column_statistics_result__isset __isset;
  
    void __set_success(const ColumnStatistics& val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    void __set_o3(const InvalidInputException& val) {
      o3 = val;
    }
  
    void __set_o4(const InvalidObjectException& val) {
      o4 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_table_column_statistics_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;
      if (!(o4 == rhs.o4))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_table_column_statistics_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_table_column_statistics_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_table_column_statistics_presult__isset {
    _ThriftHiveMetastore_get_table_column_statistics_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_get_table_column_statistics_presult__isset;
  
  class ThriftHiveMetastore_get_table_column_statistics_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_table_column_statistics_presult() throw() {}
  
    ColumnStatistics* success;
    NoSuchObjectException o1;
    MetaException o2;
    InvalidInputException o3;
    InvalidObjectException o4;
  
    _ThriftHiveMetastore_get_table_column_statistics_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partition_column_statistics_args__isset {
    _ThriftHiveMetastore_get_partition_column_statistics_args__isset() : db_name(false), tbl_name(false), part_name(false), col_name(false) {}
    bool db_name;
    bool tbl_name;
    bool part_name;
    bool col_name;
  } _ThriftHiveMetastore_get_partition_column_statistics_args__isset;
  
  class ThriftHiveMetastore_get_partition_column_statistics_args {
   public:
  
    ThriftHiveMetastore_get_partition_column_statistics_args() : db_name(), tbl_name(), part_name(), col_name() {
    }
  
    virtual ~ThriftHiveMetastore_get_partition_column_statistics_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::string part_name;
    std::string col_name;
  
    _ThriftHiveMetastore_get_partition_column_statistics_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_name(const std::string& val) {
      part_name = val;
    }
  
    void __set_col_name(const std::string& val) {
      col_name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partition_column_statistics_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(part_name == rhs.part_name))
        return false;
      if (!(col_name == rhs.col_name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_partition_column_statistics_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partition_column_statistics_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_partition_column_statistics_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partition_column_statistics_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::string* part_name;
    const std::string* col_name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partition_column_statistics_result__isset {
    _ThriftHiveMetastore_get_partition_column_statistics_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_get_partition_column_statistics_result__isset;
  
  class ThriftHiveMetastore_get_partition_column_statistics_result {
   public:
  
    ThriftHiveMetastore_get_partition_column_statistics_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_partition_column_statistics_result() throw() {}
  
    ColumnStatistics success;
    NoSuchObjectException o1;
    MetaException o2;
    InvalidInputException o3;
    InvalidObjectException o4;
  
    _ThriftHiveMetastore_get_partition_column_statistics_result__isset __isset;
  
    void __set_success(const ColumnStatistics& val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    void __set_o3(const InvalidInputException& val) {
      o3 = val;
    }
  
    void __set_o4(const InvalidObjectException& val) {
      o4 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partition_column_statistics_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;
      if (!(o4 == rhs.o4))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_partition_column_statistics_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partition_column_statistics_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partition_column_statistics_presult__isset {
    _ThriftHiveMetastore_get_partition_column_statistics_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_get_partition_column_statistics_presult__isset;
  
  class ThriftHiveMetastore_get_partition_column_statistics_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partition_column_statistics_presult() throw() {}
  
    ColumnStatistics* success;
    NoSuchObjectException o1;
    MetaException o2;
    InvalidInputException o3;
    InvalidObjectException o4;
  
    _ThriftHiveMetastore_get_partition_column_statistics_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_table_statistics_req_args__isset {
    _ThriftHiveMetastore_get_table_statistics_req_args__isset() : request(false) {}
    bool request;
  } _ThriftHiveMetastore_get_table_statistics_req_args__isset;
  
  class ThriftHiveMetastore_get_table_statistics_req_args {
   public:
  
    ThriftHiveMetastore_get_table_statistics_req_args() {
    }
  
    virtual ~ThriftHiveMetastore_get_table_statistics_req_args() throw() {}
  
    TableStatsRequest request;
  
    _ThriftHiveMetastore_get_table_statistics_req_args__isset __isset;
  
    void __set_request(const TableStatsRequest& val) {
      request = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_table_statistics_req_args & rhs) const
    {
      if (!(request == rhs.request))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_table_statistics_req_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_table_statistics_req_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_table_statistics_req_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_table_statistics_req_pargs() throw() {}
  
    const TableStatsRequest* request;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_table_statistics_req_result__isset {
    _ThriftHiveMetastore_get_table_statistics_req_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_table_statistics_req_result__isset;
  
  class ThriftHiveMetastore_get_table_statistics_req_result {
   public:
  
    ThriftHiveMetastore_get_table_statistics_req_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_table_statistics_req_result() throw() {}
  
    TableStatsResult success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_get_table_statistics_req_result__isset __isset;
  
    void __set_success(const TableStatsResult& val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_table_statistics_req_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_table_statistics_req_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_table_statistics_req_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_table_statistics_req_presult__isset {
    _ThriftHiveMetastore_get_table_statistics_req_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_table_statistics_req_presult__isset;
  
  class ThriftHiveMetastore_get_table_statistics_req_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_table_statistics_req_presult() throw() {}
  
    TableStatsResult* success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_get_table_statistics_req_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_statistics_req_args__isset {
    _ThriftHiveMetastore_get_partitions_statistics_req_args__isset() : request(false) {}
    bool request;
  } _ThriftHiveMetastore_get_partitions_statistics_req_args__isset;
  
  class ThriftHiveMetastore_get_partitions_statistics_req_args {
   public:
  
    ThriftHiveMetastore_get_partitions_statistics_req_args() {
    }
  
    virtual ~ThriftHiveMetastore_get_partitions_statistics_req_args() throw() {}
  
    PartitionsStatsRequest request;
  
    _ThriftHiveMetastore_get_partitions_statistics_req_args__isset __isset;
  
    void __set_request(const PartitionsStatsRequest& val) {
      request = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partitions_statistics_req_args & rhs) const
    {
      if (!(request == rhs.request))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_partitions_statistics_req_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partitions_statistics_req_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_partitions_statistics_req_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partitions_statistics_req_pargs() throw() {}
  
    const PartitionsStatsRequest* request;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_statistics_req_result__isset {
    _ThriftHiveMetastore_get_partitions_statistics_req_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partitions_statistics_req_result__isset;
  
  class ThriftHiveMetastore_get_partitions_statistics_req_result {
   public:
  
    ThriftHiveMetastore_get_partitions_statistics_req_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_partitions_statistics_req_result() throw() {}
  
    PartitionsStatsResult success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_get_partitions_statistics_req_result__isset __isset;
  
    void __set_success(const PartitionsStatsResult& val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_partitions_statistics_req_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_statistics_req_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_partitions_statistics_req_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_partitions_statistics_req_presult__isset {
    _ThriftHiveMetastore_get_partitions_statistics_req_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_partitions_statistics_req_presult__isset;
  
  class ThriftHiveMetastore_get_partitions_statistics_req_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_partitions_statistics_req_presult() throw() {}
  
    PartitionsStatsResult* success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_get_partitions_statistics_req_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_aggr_stats_for_args__isset {
    _ThriftHiveMetastore_get_aggr_stats_for_args__isset() : request(false) {}
    bool request;
  } _ThriftHiveMetastore_get_aggr_stats_for_args__isset;
  
  class ThriftHiveMetastore_get_aggr_stats_for_args {
   public:
  
    ThriftHiveMetastore_get_aggr_stats_for_args() {
    }
  
    virtual ~ThriftHiveMetastore_get_aggr_stats_for_args() throw() {}
  
    PartitionsStatsRequest request;
  
    _ThriftHiveMetastore_get_aggr_stats_for_args__isset __isset;
  
    void __set_request(const PartitionsStatsRequest& val) {
      request = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_aggr_stats_for_args & rhs) const
    {
      if (!(request == rhs.request))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_aggr_stats_for_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_aggr_stats_for_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_aggr_stats_for_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_aggr_stats_for_pargs() throw() {}
  
    const PartitionsStatsRequest* request;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_aggr_stats_for_result__isset {
    _ThriftHiveMetastore_get_aggr_stats_for_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_aggr_stats_for_result__isset;
  
  class ThriftHiveMetastore_get_aggr_stats_for_result {
   public:
  
    ThriftHiveMetastore_get_aggr_stats_for_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_aggr_stats_for_result() throw() {}
  
    AggrStats success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_get_aggr_stats_for_result__isset __isset;
  
    void __set_success(const AggrStats& val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_aggr_stats_for_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_aggr_stats_for_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_aggr_stats_for_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_aggr_stats_for_presult__isset {
    _ThriftHiveMetastore_get_aggr_stats_for_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_aggr_stats_for_presult__isset;
  
  class ThriftHiveMetastore_get_aggr_stats_for_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_aggr_stats_for_presult() throw() {}
  
    AggrStats* success;
    NoSuchObjectException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_get_aggr_stats_for_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_delete_partition_column_statistics_args__isset {
    _ThriftHiveMetastore_delete_partition_column_statistics_args__isset() : db_name(false), tbl_name(false), part_name(false), col_name(false) {}
    bool db_name;
    bool tbl_name;
    bool part_name;
    bool col_name;
  } _ThriftHiveMetastore_delete_partition_column_statistics_args__isset;
  
  class ThriftHiveMetastore_delete_partition_column_statistics_args {
   public:
  
    ThriftHiveMetastore_delete_partition_column_statistics_args() : db_name(), tbl_name(), part_name(), col_name() {
    }
  
    virtual ~ThriftHiveMetastore_delete_partition_column_statistics_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::string part_name;
    std::string col_name;
  
    _ThriftHiveMetastore_delete_partition_column_statistics_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_part_name(const std::string& val) {
      part_name = val;
    }
  
    void __set_col_name(const std::string& val) {
      col_name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_delete_partition_column_statistics_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(part_name == rhs.part_name))
        return false;
      if (!(col_name == rhs.col_name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_delete_partition_column_statistics_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_delete_partition_column_statistics_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_delete_partition_column_statistics_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_delete_partition_column_statistics_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::string* part_name;
    const std::string* col_name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_delete_partition_column_statistics_result__isset {
    _ThriftHiveMetastore_delete_partition_column_statistics_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_delete_partition_column_statistics_result__isset;
  
  class ThriftHiveMetastore_delete_partition_column_statistics_result {
   public:
  
    ThriftHiveMetastore_delete_partition_column_statistics_result() : success(0) {
    }
  
    virtual ~ThriftHiveMetastore_delete_partition_column_statistics_result() throw() {}
  
    bool success;
    NoSuchObjectException o1;
    MetaException o2;
    InvalidObjectException o3;
    InvalidInputException o4;
  
    _ThriftHiveMetastore_delete_partition_column_statistics_result__isset __isset;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    void __set_o3(const InvalidObjectException& val) {
      o3 = val;
    }
  
    void __set_o4(const InvalidInputException& val) {
      o4 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_delete_partition_column_statistics_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;
      if (!(o4 == rhs.o4))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_delete_partition_column_statistics_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_delete_partition_column_statistics_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_delete_partition_column_statistics_presult__isset {
    _ThriftHiveMetastore_delete_partition_column_statistics_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_delete_partition_column_statistics_presult__isset;
  
  class ThriftHiveMetastore_delete_partition_column_statistics_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_delete_partition_column_statistics_presult() throw() {}
  
    bool* success;
    NoSuchObjectException o1;
    MetaException o2;
    InvalidObjectException o3;
    InvalidInputException o4;
  
    _ThriftHiveMetastore_delete_partition_column_statistics_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_delete_table_column_statistics_args__isset {
    _ThriftHiveMetastore_delete_table_column_statistics_args__isset() : db_name(false), tbl_name(false), col_name(false) {}
    bool db_name;
    bool tbl_name;
    bool col_name;
  } _ThriftHiveMetastore_delete_table_column_statistics_args__isset;
  
  class ThriftHiveMetastore_delete_table_column_statistics_args {
   public:
  
    ThriftHiveMetastore_delete_table_column_statistics_args() : db_name(), tbl_name(), col_name() {
    }
  
    virtual ~ThriftHiveMetastore_delete_table_column_statistics_args() throw() {}
  
    std::string db_name;
    std::string tbl_name;
    std::string col_name;
  
    _ThriftHiveMetastore_delete_table_column_statistics_args__isset __isset;
  
    void __set_db_name(const std::string& val) {
      db_name = val;
    }
  
    void __set_tbl_name(const std::string& val) {
      tbl_name = val;
    }
  
    void __set_col_name(const std::string& val) {
      col_name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_delete_table_column_statistics_args & rhs) const
    {
      if (!(db_name == rhs.db_name))
        return false;
      if (!(tbl_name == rhs.tbl_name))
        return false;
      if (!(col_name == rhs.col_name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_delete_table_column_statistics_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_delete_table_column_statistics_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_delete_table_column_statistics_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_delete_table_column_statistics_pargs() throw() {}
  
    const std::string* db_name;
    const std::string* tbl_name;
    const std::string* col_name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_delete_table_column_statistics_result__isset {
    _ThriftHiveMetastore_delete_table_column_statistics_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_delete_table_column_statistics_result__isset;
  
  class ThriftHiveMetastore_delete_table_column_statistics_result {
   public:
  
    ThriftHiveMetastore_delete_table_column_statistics_result() : success(0) {
    }
  
    virtual ~ThriftHiveMetastore_delete_table_column_statistics_result() throw() {}
  
    bool success;
    NoSuchObjectException o1;
    MetaException o2;
    InvalidObjectException o3;
    InvalidInputException o4;
  
    _ThriftHiveMetastore_delete_table_column_statistics_result__isset __isset;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    void __set_o3(const InvalidObjectException& val) {
      o3 = val;
    }
  
    void __set_o4(const InvalidInputException& val) {
      o4 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_delete_table_column_statistics_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;
      if (!(o4 == rhs.o4))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_delete_table_column_statistics_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_delete_table_column_statistics_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_delete_table_column_statistics_presult__isset {
    _ThriftHiveMetastore_delete_table_column_statistics_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
    bool success;
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_delete_table_column_statistics_presult__isset;
  
  class ThriftHiveMetastore_delete_table_column_statistics_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_delete_table_column_statistics_presult() throw() {}
  
    bool* success;
    NoSuchObjectException o1;
    MetaException o2;
    InvalidObjectException o3;
    InvalidInputException o4;
  
    _ThriftHiveMetastore_delete_table_column_statistics_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_create_function_args__isset {
    _ThriftHiveMetastore_create_function_args__isset() : func(false) {}
    bool func;
  } _ThriftHiveMetastore_create_function_args__isset;
  
  class ThriftHiveMetastore_create_function_args {
   public:
  
    ThriftHiveMetastore_create_function_args() {
    }
  
    virtual ~ThriftHiveMetastore_create_function_args() throw() {}
  
    Function func;
  
    _ThriftHiveMetastore_create_function_args__isset __isset;
  
    void __set_func(const Function& val) {
      func = val;
    }
  
    bool operator == (const ThriftHiveMetastore_create_function_args & rhs) const
    {
      if (!(func == rhs.func))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_create_function_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_create_function_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_create_function_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_create_function_pargs() throw() {}
  
    const Function* func;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_create_function_result__isset {
    _ThriftHiveMetastore_create_function_result__isset() : o1(false), o2(false), o3(false), o4(false) {}
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_create_function_result__isset;
  
  class ThriftHiveMetastore_create_function_result {
   public:
  
    ThriftHiveMetastore_create_function_result() {
    }
  
    virtual ~ThriftHiveMetastore_create_function_result() throw() {}
  
    AlreadyExistsException o1;
    InvalidObjectException o2;
    MetaException o3;
    NoSuchObjectException o4;
  
    _ThriftHiveMetastore_create_function_result__isset __isset;
  
    void __set_o1(const AlreadyExistsException& val) {
      o1 = val;
    }
  
    void __set_o2(const InvalidObjectException& val) {
      o2 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    void __set_o4(const NoSuchObjectException& val) {
      o4 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_create_function_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      if (!(o3 == rhs.o3))
        return false;
      if (!(o4 == rhs.o4))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_create_function_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_create_function_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_create_function_presult__isset {
    _ThriftHiveMetastore_create_function_presult__isset() : o1(false), o2(false), o3(false), o4(false) {}
    bool o1;
    bool o2;
    bool o3;
    bool o4;
  } _ThriftHiveMetastore_create_function_presult__isset;
  
  class ThriftHiveMetastore_create_function_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_create_function_presult() throw() {}
  
    AlreadyExistsException o1;
    InvalidObjectException o2;
    MetaException o3;
    NoSuchObjectException o4;
  
    _ThriftHiveMetastore_create_function_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_function_args__isset {
    _ThriftHiveMetastore_drop_function_args__isset() : dbName(false), funcName(false) {}
    bool dbName;
    bool funcName;
  } _ThriftHiveMetastore_drop_function_args__isset;
  
  class ThriftHiveMetastore_drop_function_args {
   public:
  
    ThriftHiveMetastore_drop_function_args() : dbName(), funcName() {
    }
  
    virtual ~ThriftHiveMetastore_drop_function_args() throw() {}
  
    std::string dbName;
    std::string funcName;
  
    _ThriftHiveMetastore_drop_function_args__isset __isset;
  
    void __set_dbName(const std::string& val) {
      dbName = val;
    }
  
    void __set_funcName(const std::string& val) {
      funcName = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_function_args & rhs) const
    {
      if (!(dbName == rhs.dbName))
        return false;
      if (!(funcName == rhs.funcName))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_drop_function_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_function_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_drop_function_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_function_pargs() throw() {}
  
    const std::string* dbName;
    const std::string* funcName;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_function_result__isset {
    _ThriftHiveMetastore_drop_function_result__isset() : o1(false), o3(false) {}
    bool o1;
    bool o3;
  } _ThriftHiveMetastore_drop_function_result__isset;
  
  class ThriftHiveMetastore_drop_function_result {
   public:
  
    ThriftHiveMetastore_drop_function_result() {
    }
  
    virtual ~ThriftHiveMetastore_drop_function_result() throw() {}
  
    NoSuchObjectException o1;
    MetaException o3;
  
    _ThriftHiveMetastore_drop_function_result__isset __isset;
  
    void __set_o1(const NoSuchObjectException& val) {
      o1 = val;
    }
  
    void __set_o3(const MetaException& val) {
      o3 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_drop_function_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      if (!(o3 == rhs.o3))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_drop_function_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_drop_function_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_drop_function_presult__isset {
    _ThriftHiveMetastore_drop_function_presult__isset() : o1(false), o3(false) {}
    bool o1;
    bool o3;
  } _ThriftHiveMetastore_drop_function_presult__isset;
  
  class ThriftHiveMetastore_drop_function_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_drop_function_presult() throw() {}
  
    NoSuchObjectException o1;
    MetaException o3;
  
    _ThriftHiveMetastore_drop_function_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_function_args__isset {
    _ThriftHiveMetastore_alter_function_args__isset() : dbName(false), funcName(false), newFunc(false) {}
    bool dbName;
    bool funcName;
    bool newFunc;
  } _ThriftHiveMetastore_alter_function_args__isset;
  
  class ThriftHiveMetastore_alter_function_args {
   public:
  
    ThriftHiveMetastore_alter_function_args() : dbName(), funcName() {
    }
  
    virtual ~ThriftHiveMetastore_alter_function_args() throw() {}
  
    std::string dbName;
    std::string funcName;
    Function newFunc;
  
    _ThriftHiveMetastore_alter_function_args__isset __isset;
  
    void __set_dbName(const std::string& val) {
      dbName = val;
    }
  
    void __set_funcName(const std::string& val) {
      funcName = val;
    }
  
    void __set_newFunc(const Function& val) {
      newFunc = val;
    }
  
    bool operator == (const ThriftHiveMetastore_alter_function_args & rhs) const
    {
      if (!(dbName == rhs.dbName))
        return false;
      if (!(funcName == rhs.funcName))
        return false;
      if (!(newFunc == rhs.newFunc))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_alter_function_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_alter_function_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_alter_function_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_alter_function_pargs() throw() {}
  
    const std::string* dbName;
    const std::string* funcName;
    const Function* newFunc;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_function_result__isset {
    _ThriftHiveMetastore_alter_function_result__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_alter_function_result__isset;
  
  class ThriftHiveMetastore_alter_function_result {
   public:
  
    ThriftHiveMetastore_alter_function_result() {
    }
  
    virtual ~ThriftHiveMetastore_alter_function_result() throw() {}
  
    InvalidOperationException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_alter_function_result__isset __isset;
  
    void __set_o1(const InvalidOperationException& val) {
      o1 = val;
    }
  
    void __set_o2(const MetaException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_alter_function_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      if (!(o2 == rhs.o2))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_alter_function_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_alter_function_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_alter_function_presult__isset {
    _ThriftHiveMetastore_alter_function_presult__isset() : o1(false), o2(false) {}
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_alter_function_presult__isset;
  
  class ThriftHiveMetastore_alter_function_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_alter_function_presult() throw() {}
  
    InvalidOperationException o1;
    MetaException o2;
  
    _ThriftHiveMetastore_alter_function_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_functions_args__isset {
    _ThriftHiveMetastore_get_functions_args__isset() : dbName(false), pattern(false) {}
    bool dbName;
    bool pattern;
  } _ThriftHiveMetastore_get_functions_args__isset;
  
  class ThriftHiveMetastore_get_functions_args {
   public:
  
    ThriftHiveMetastore_get_functions_args() : dbName(), pattern() {
    }
  
    virtual ~ThriftHiveMetastore_get_functions_args() throw() {}
  
    std::string dbName;
    std::string pattern;
  
    _ThriftHiveMetastore_get_functions_args__isset __isset;
  
    void __set_dbName(const std::string& val) {
      dbName = val;
    }
  
    void __set_pattern(const std::string& val) {
      pattern = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_functions_args & rhs) const
    {
      if (!(dbName == rhs.dbName))
        return false;
      if (!(pattern == rhs.pattern))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_functions_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_functions_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_functions_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_functions_pargs() throw() {}
  
    const std::string* dbName;
    const std::string* pattern;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_functions_result__isset {
    _ThriftHiveMetastore_get_functions_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_functions_result__isset;
  
  class ThriftHiveMetastore_get_functions_result {
   public:
  
    ThriftHiveMetastore_get_functions_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_functions_result() throw() {}
  
    std::vector<std::string>  success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_functions_result__isset __isset;
  
    void __set_success(const std::vector<std::string> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_functions_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_functions_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_functions_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_functions_presult__isset {
    _ThriftHiveMetastore_get_functions_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_functions_presult__isset;
  
  class ThriftHiveMetastore_get_functions_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_functions_presult() throw() {}
  
    std::vector<std::string> * success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_functions_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_function_args__isset {
    _ThriftHiveMetastore_get_function_args__isset() : dbName(false), funcName(false) {}
    bool dbName;
    bool funcName;
  } _ThriftHiveMetastore_get_function_args__isset;
  
  class ThriftHiveMetastore_get_function_args {
   public:
  
    ThriftHiveMetastore_get_function_args() : dbName(), funcName() {
    }
  
    virtual ~ThriftHiveMetastore_get_function_args() throw() {}
  
    std::string dbName;
    std::string funcName;
  
    _ThriftHiveMetastore_get_function_args__isset __isset;
  
    void __set_dbName(const std::string& val) {
      dbName = val;
    }
  
    void __set_funcName(const std::string& val) {
      funcName = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_function_args & rhs) const
    {
      if (!(dbName == rhs.dbName))
        return false;
      if (!(funcName == rhs.funcName))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_function_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_function_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_function_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_function_pargs() throw() {}
  
    const std::string* dbName;
    const std::string* funcName;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_function_result__isset {
    _ThriftHiveMetastore_get_function_result__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_function_result__isset;
  
  class ThriftHiveMetastore_get_function_result {
   public:
  
    ThriftHiveMetastore_get_function_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_function_result() throw() {}
  
    Function success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_function_result__isset __isset;
  
    void __set_success(const Function& val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    void __set_o2(const NoSuchObjectException& val) {
      o2 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_function_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_function_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_function_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_function_presult__isset {
    _ThriftHiveMetastore_get_function_presult__isset() : success(false), o1(false), o2(false) {}
    bool success;
    bool o1;
    bool o2;
  } _ThriftHiveMetastore_get_function_presult__isset;
  
  class ThriftHiveMetastore_get_function_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_function_presult() throw() {}
  
    Function* success;
    MetaException o1;
    NoSuchObjectException o2;
  
    _ThriftHiveMetastore_get_function_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  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:
  
    ThriftHiveMetastore_create_role_args() {
    }
  
    virtual ~ThriftHiveMetastore_create_role_args() throw() {}
  
    Role role;
  
    _ThriftHiveMetastore_create_role_args__isset __isset;
  
    void __set_role(const Role& val) {
      role = val;
    }
  
    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;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    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;
  
    void __set_role_name(const std::string& val) {
      role_name = val;
    }
  
    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;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    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);
  
  };
  
  
  class ThriftHiveMetastore_get_role_names_args {
   public:
  
    ThriftHiveMetastore_get_role_names_args() {
    }
  
    virtual ~ThriftHiveMetastore_get_role_names_args() throw() {}
  
  
    bool operator == (const ThriftHiveMetastore_get_role_names_args & /* rhs */) const
    {
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_role_names_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_role_names_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_role_names_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_role_names_pargs() throw() {}
  
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_role_names_result__isset {
    _ThriftHiveMetastore_get_role_names_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_role_names_result__isset;
  
  class ThriftHiveMetastore_get_role_names_result {
   public:
  
    ThriftHiveMetastore_get_role_names_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_role_names_result() throw() {}
  
    std::vector<std::string>  success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_role_names_result__isset __isset;
  
    void __set_success(const std::vector<std::string> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_role_names_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_role_names_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_role_names_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_role_names_presult__isset {
    _ThriftHiveMetastore_get_role_names_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_role_names_presult__isset;
  
  class ThriftHiveMetastore_get_role_names_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_role_names_presult() throw() {}
  
    std::vector<std::string> * success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_role_names_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(), principal_type((PrincipalType::type)0), grantor(), grantorType((PrincipalType::type)0), 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;
  
    void __set_role_name(const std::string& val) {
      role_name = val;
    }
  
    void __set_principal_name(const std::string& val) {
      principal_name = val;
    }
  
    void __set_principal_type(const PrincipalType::type val) {
      principal_type = val;
    }
  
    void __set_grantor(const std::string& val) {
      grantor = val;
    }
  
    void __set_grantorType(const PrincipalType::type val) {
      grantorType = val;
    }
  
    void __set_grant_option(const bool val) {
      grant_option = val;
    }
  
    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;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    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(), principal_type((PrincipalType::type)0) {
    }
  
    virtual ~ThriftHiveMetastore_revoke_role_args() throw() {}
  
    std::string role_name;
    std::string principal_name;
    PrincipalType::type principal_type;
  
    _ThriftHiveMetastore_revoke_role_args__isset __isset;
  
    void __set_role_name(const std::string& val) {
      role_name = val;
    }
  
    void __set_principal_name(const std::string& val) {
      principal_name = val;
    }
  
    void __set_principal_type(const PrincipalType::type val) {
      principal_type = val;
    }
  
    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;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    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(), principal_type((PrincipalType::type)0) {
    }
  
    virtual ~ThriftHiveMetastore_list_roles_args() throw() {}
  
    std::string principal_name;
    PrincipalType::type principal_type;
  
    _ThriftHiveMetastore_list_roles_args__isset __isset;
  
    void __set_principal_name(const std::string& val) {
      principal_name = val;
    }
  
    void __set_principal_type(const PrincipalType::type val) {
      principal_type = val;
    }
  
    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;
  
    void __set_success(const std::vector<Role> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    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_grant_revoke_role_args__isset {
    _ThriftHiveMetastore_grant_revoke_role_args__isset() : request(false) {}
    bool request;
  } _ThriftHiveMetastore_grant_revoke_role_args__isset;
  
  class ThriftHiveMetastore_grant_revoke_role_args {
   public:
  
    ThriftHiveMetastore_grant_revoke_role_args() {
    }
  
    virtual ~ThriftHiveMetastore_grant_revoke_role_args() throw() {}
  
    GrantRevokeRoleRequest request;
  
    _ThriftHiveMetastore_grant_revoke_role_args__isset __isset;
  
    void __set_request(const GrantRevokeRoleRequest& val) {
      request = val;
    }
  
    bool operator == (const ThriftHiveMetastore_grant_revoke_role_args & rhs) const
    {
      if (!(request == rhs.request))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_grant_revoke_role_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_grant_revoke_role_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_grant_revoke_role_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_grant_revoke_role_pargs() throw() {}
  
    const GrantRevokeRoleRequest* request;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_grant_revoke_role_result__isset {
    _ThriftHiveMetastore_grant_revoke_role_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_grant_revoke_role_result__isset;
  
  class ThriftHiveMetastore_grant_revoke_role_result {
   public:
  
    ThriftHiveMetastore_grant_revoke_role_result() {
    }
  
    virtual ~ThriftHiveMetastore_grant_revoke_role_result() throw() {}
  
    GrantRevokeRoleResponse success;
    MetaException o1;
  
    _ThriftHiveMetastore_grant_revoke_role_result__isset __isset;
  
    void __set_success(const GrantRevokeRoleResponse& val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_grant_revoke_role_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_grant_revoke_role_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_grant_revoke_role_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_grant_revoke_role_presult__isset {
    _ThriftHiveMetastore_grant_revoke_role_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_grant_revoke_role_presult__isset;
  
  class ThriftHiveMetastore_grant_revoke_role_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_grant_revoke_role_presult() throw() {}
  
    GrantRevokeRoleResponse* success;
    MetaException o1;
  
    _ThriftHiveMetastore_grant_revoke_role_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_principals_in_role_args__isset {
    _ThriftHiveMetastore_get_principals_in_role_args__isset() : request(false) {}
    bool request;
  } _ThriftHiveMetastore_get_principals_in_role_args__isset;
  
  class ThriftHiveMetastore_get_principals_in_role_args {
   public:
  
    ThriftHiveMetastore_get_principals_in_role_args() {
    }
  
    virtual ~ThriftHiveMetastore_get_principals_in_role_args() throw() {}
  
    GetPrincipalsInRoleRequest request;
  
    _ThriftHiveMetastore_get_principals_in_role_args__isset __isset;
  
    void __set_request(const GetPrincipalsInRoleRequest& val) {
      request = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_principals_in_role_args & rhs) const
    {
      if (!(request == rhs.request))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_principals_in_role_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_principals_in_role_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_principals_in_role_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_principals_in_role_pargs() throw() {}
  
    const GetPrincipalsInRoleRequest* request;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_principals_in_role_result__isset {
    _ThriftHiveMetastore_get_principals_in_role_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_principals_in_role_result__isset;
  
  class ThriftHiveMetastore_get_principals_in_role_result {
   public:
  
    ThriftHiveMetastore_get_principals_in_role_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_principals_in_role_result() throw() {}
  
    GetPrincipalsInRoleResponse success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_principals_in_role_result__isset __isset;
  
    void __set_success(const GetPrincipalsInRoleResponse& val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_principals_in_role_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_principals_in_role_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_principals_in_role_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_principals_in_role_presult__isset {
    _ThriftHiveMetastore_get_principals_in_role_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_principals_in_role_presult__isset;
  
  class ThriftHiveMetastore_get_principals_in_role_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_principals_in_role_presult() throw() {}
  
    GetPrincipalsInRoleResponse* success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_principals_in_role_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_role_grants_for_principal_args__isset {
    _ThriftHiveMetastore_get_role_grants_for_principal_args__isset() : request(false) {}
    bool request;
  } _ThriftHiveMetastore_get_role_grants_for_principal_args__isset;
  
  class ThriftHiveMetastore_get_role_grants_for_principal_args {
   public:
  
    ThriftHiveMetastore_get_role_grants_for_principal_args() {
    }
  
    virtual ~ThriftHiveMetastore_get_role_grants_for_principal_args() throw() {}
  
    GetRoleGrantsForPrincipalRequest request;
  
    _ThriftHiveMetastore_get_role_grants_for_principal_args__isset __isset;
  
    void __set_request(const GetRoleGrantsForPrincipalRequest& val) {
      request = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_role_grants_for_principal_args & rhs) const
    {
      if (!(request == rhs.request))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_role_grants_for_principal_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_role_grants_for_principal_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_role_grants_for_principal_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_role_grants_for_principal_pargs() throw() {}
  
    const GetRoleGrantsForPrincipalRequest* request;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_role_grants_for_principal_result__isset {
    _ThriftHiveMetastore_get_role_grants_for_principal_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_role_grants_for_principal_result__isset;
  
  class ThriftHiveMetastore_get_role_grants_for_principal_result {
   public:
  
    ThriftHiveMetastore_get_role_grants_for_principal_result() {
    }
  
    virtual ~ThriftHiveMetastore_get_role_grants_for_principal_result() throw() {}
  
    GetRoleGrantsForPrincipalResponse success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_role_grants_for_principal_result__isset __isset;
  
    void __set_success(const GetRoleGrantsForPrincipalResponse& val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_role_grants_for_principal_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_role_grants_for_principal_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_role_grants_for_principal_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_role_grants_for_principal_presult__isset {
    _ThriftHiveMetastore_get_role_grants_for_principal_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_role_grants_for_principal_presult__isset;
  
  class ThriftHiveMetastore_get_role_grants_for_principal_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_role_grants_for_principal_presult() throw() {}
  
    GetRoleGrantsForPrincipalResponse* success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_role_grants_for_principal_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;
  
    void __set_hiveObject(const HiveObjectRef& val) {
      hiveObject = val;
    }
  
    void __set_user_name(const std::string& val) {
      user_name = val;
    }
  
    void __set_group_names(const std::vector<std::string> & val) {
      group_names = val;
    }
  
    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;
  
    void __set_success(const PrincipalPrivilegeSet& val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    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(), principal_type((PrincipalType::type)0) {
    }
  
    virtual ~ThriftHiveMetastore_list_privileges_args() throw() {}
  
    std::string principal_name;
    PrincipalType::type principal_type;
    HiveObjectRef hiveObject;
  
    _ThriftHiveMetastore_list_privileges_args__isset __isset;
  
    void __set_principal_name(const std::string& val) {
      principal_name = val;
    }
  
    void __set_principal_type(const PrincipalType::type val) {
      principal_type = val;
    }
  
    void __set_hiveObject(const HiveObjectRef& val) {
      hiveObject = val;
    }
  
    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;
  
    void __set_success(const std::vector<HiveObjectPrivilege> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    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;
  
    void __set_privileges(const PrivilegeBag& val) {
      privileges = val;
    }
  
    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;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    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;
  
    void __set_privileges(const PrivilegeBag& val) {
      privileges = val;
    }
  
    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;
  
    void __set_success(const bool val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    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);
  
  };
  
  typedef struct _ThriftHiveMetastore_grant_revoke_privileges_args__isset {
    _ThriftHiveMetastore_grant_revoke_privileges_args__isset() : request(false) {}
    bool request;
  } _ThriftHiveMetastore_grant_revoke_privileges_args__isset;
  
  class ThriftHiveMetastore_grant_revoke_privileges_args {
   public:
  
    ThriftHiveMetastore_grant_revoke_privileges_args() {
    }
  
    virtual ~ThriftHiveMetastore_grant_revoke_privileges_args() throw() {}
  
    GrantRevokePrivilegeRequest request;
  
    _ThriftHiveMetastore_grant_revoke_privileges_args__isset __isset;
  
    void __set_request(const GrantRevokePrivilegeRequest& val) {
      request = val;
    }
  
    bool operator == (const ThriftHiveMetastore_grant_revoke_privileges_args & rhs) const
    {
      if (!(request == rhs.request))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_grant_revoke_privileges_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_grant_revoke_privileges_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_grant_revoke_privileges_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_grant_revoke_privileges_pargs() throw() {}
  
    const GrantRevokePrivilegeRequest* request;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_grant_revoke_privileges_result__isset {
    _ThriftHiveMetastore_grant_revoke_privileges_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_grant_revoke_privileges_result__isset;
  
  class ThriftHiveMetastore_grant_revoke_privileges_result {
   public:
  
    ThriftHiveMetastore_grant_revoke_privileges_result() {
    }
  
    virtual ~ThriftHiveMetastore_grant_revoke_privileges_result() throw() {}
  
    GrantRevokePrivilegeResponse success;
    MetaException o1;
  
    _ThriftHiveMetastore_grant_revoke_privileges_result__isset __isset;
  
    void __set_success(const GrantRevokePrivilegeResponse& val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_grant_revoke_privileges_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_grant_revoke_privileges_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_grant_revoke_privileges_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_grant_revoke_privileges_presult__isset {
    _ThriftHiveMetastore_grant_revoke_privileges_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_grant_revoke_privileges_presult__isset;
  
  class ThriftHiveMetastore_grant_revoke_privileges_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_grant_revoke_privileges_presult() throw() {}
  
    GrantRevokePrivilegeResponse* success;
    MetaException o1;
  
    _ThriftHiveMetastore_grant_revoke_privileges_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_set_ugi_args__isset {
    _ThriftHiveMetastore_set_ugi_args__isset() : user_name(false), group_names(false) {}
    bool user_name;
    bool group_names;
  } _ThriftHiveMetastore_set_ugi_args__isset;
  
  class ThriftHiveMetastore_set_ugi_args {
   public:
  
    ThriftHiveMetastore_set_ugi_args() : user_name() {
    }
  
    virtual ~ThriftHiveMetastore_set_ugi_args() throw() {}
  
    std::string user_name;
    std::vector<std::string>  group_names;
  
    _ThriftHiveMetastore_set_ugi_args__isset __isset;
  
    void __set_user_name(const std::string& val) {
      user_name = val;
    }
  
    void __set_group_names(const std::vector<std::string> & val) {
      group_names = val;
    }
  
    bool operator == (const ThriftHiveMetastore_set_ugi_args & rhs) const
    {
      if (!(user_name == rhs.user_name))
        return false;
      if (!(group_names == rhs.group_names))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_set_ugi_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_set_ugi_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_set_ugi_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_set_ugi_pargs() throw() {}
  
    const std::string* user_name;
    const std::vector<std::string> * group_names;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_set_ugi_result__isset {
    _ThriftHiveMetastore_set_ugi_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_set_ugi_result__isset;
  
  class ThriftHiveMetastore_set_ugi_result {
   public:
  
    ThriftHiveMetastore_set_ugi_result() {
    }
  
    virtual ~ThriftHiveMetastore_set_ugi_result() throw() {}
  
    std::vector<std::string>  success;
    MetaException o1;
  
    _ThriftHiveMetastore_set_ugi_result__isset __isset;
  
    void __set_success(const std::vector<std::string> & val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_set_ugi_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_set_ugi_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_set_ugi_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_set_ugi_presult__isset {
    _ThriftHiveMetastore_set_ugi_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_set_ugi_presult__isset;
  
  class ThriftHiveMetastore_set_ugi_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_set_ugi_presult() throw() {}
  
    std::vector<std::string> * success;
    MetaException o1;
  
    _ThriftHiveMetastore_set_ugi_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_get_delegation_token_args__isset {
    _ThriftHiveMetastore_get_delegation_token_args__isset() : token_owner(false), renewer_kerberos_principal_name(false) {}
    bool token_owner;
    bool renewer_kerberos_principal_name;
  } _ThriftHiveMetastore_get_delegation_token_args__isset;
  
  class ThriftHiveMetastore_get_delegation_token_args {
   public:
  
    ThriftHiveMetastore_get_delegation_token_args() : token_owner(), renewer_kerberos_principal_name() {
    }
  
    virtual ~ThriftHiveMetastore_get_delegation_token_args() throw() {}
  
    std::string token_owner;
    std::string renewer_kerberos_principal_name;
  
    _ThriftHiveMetastore_get_delegation_token_args__isset __isset;
  
    void __set_token_owner(const std::string& val) {
      token_owner = val;
    }
  
    void __set_renewer_kerberos_principal_name(const std::string& val) {
      renewer_kerberos_principal_name = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_delegation_token_args & rhs) const
    {
      if (!(token_owner == rhs.token_owner))
        return false;
      if (!(renewer_kerberos_principal_name == rhs.renewer_kerberos_principal_name))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_delegation_token_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_delegation_token_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_get_delegation_token_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_delegation_token_pargs() throw() {}
  
    const std::string* token_owner;
    const std::string* renewer_kerberos_principal_name;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_delegation_token_result__isset {
    _ThriftHiveMetastore_get_delegation_token_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_delegation_token_result__isset;
  
  class ThriftHiveMetastore_get_delegation_token_result {
   public:
  
    ThriftHiveMetastore_get_delegation_token_result() : success() {
    }
  
    virtual ~ThriftHiveMetastore_get_delegation_token_result() throw() {}
  
    std::string success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_delegation_token_result__isset __isset;
  
    void __set_success(const std::string& val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_get_delegation_token_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_get_delegation_token_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_get_delegation_token_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_get_delegation_token_presult__isset {
    _ThriftHiveMetastore_get_delegation_token_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_get_delegation_token_presult__isset;
  
  class ThriftHiveMetastore_get_delegation_token_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_get_delegation_token_presult() throw() {}
  
    std::string* success;
    MetaException o1;
  
    _ThriftHiveMetastore_get_delegation_token_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_renew_delegation_token_args__isset {
    _ThriftHiveMetastore_renew_delegation_token_args__isset() : token_str_form(false) {}
    bool token_str_form;
  } _ThriftHiveMetastore_renew_delegation_token_args__isset;
  
  class ThriftHiveMetastore_renew_delegation_token_args {
   public:
  
    ThriftHiveMetastore_renew_delegation_token_args() : token_str_form() {
    }
  
    virtual ~ThriftHiveMetastore_renew_delegation_token_args() throw() {}
  
    std::string token_str_form;
  
    _ThriftHiveMetastore_renew_delegation_token_args__isset __isset;
  
    void __set_token_str_form(const std::string& val) {
      token_str_form = val;
    }
  
    bool operator == (const ThriftHiveMetastore_renew_delegation_token_args & rhs) const
    {
      if (!(token_str_form == rhs.token_str_form))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_renew_delegation_token_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_renew_delegation_token_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_renew_delegation_token_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_renew_delegation_token_pargs() throw() {}
  
    const std::string* token_str_form;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_renew_delegation_token_result__isset {
    _ThriftHiveMetastore_renew_delegation_token_result__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_renew_delegation_token_result__isset;
  
  class ThriftHiveMetastore_renew_delegation_token_result {
   public:
  
    ThriftHiveMetastore_renew_delegation_token_result() : success(0) {
    }
  
    virtual ~ThriftHiveMetastore_renew_delegation_token_result() throw() {}
  
    int64_t success;
    MetaException o1;
  
    _ThriftHiveMetastore_renew_delegation_token_result__isset __isset;
  
    void __set_success(const int64_t val) {
      success = val;
    }
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_renew_delegation_token_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_renew_delegation_token_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_renew_delegation_token_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_renew_delegation_token_presult__isset {
    _ThriftHiveMetastore_renew_delegation_token_presult__isset() : success(false), o1(false) {}
    bool success;
    bool o1;
  } _ThriftHiveMetastore_renew_delegation_token_presult__isset;
  
  class ThriftHiveMetastore_renew_delegation_token_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_renew_delegation_token_presult() throw() {}
  
    int64_t* success;
    MetaException o1;
  
    _ThriftHiveMetastore_renew_delegation_token_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  typedef struct _ThriftHiveMetastore_cancel_delegation_token_args__isset {
    _ThriftHiveMetastore_cancel_delegation_token_args__isset() : token_str_form(false) {}
    bool token_str_form;
  } _ThriftHiveMetastore_cancel_delegation_token_args__isset;
  
  class ThriftHiveMetastore_cancel_delegation_token_args {
   public:
  
    ThriftHiveMetastore_cancel_delegation_token_args() : token_str_form() {
    }
  
    virtual ~ThriftHiveMetastore_cancel_delegation_token_args() throw() {}
  
    std::string token_str_form;
  
    _ThriftHiveMetastore_cancel_delegation_token_args__isset __isset;
  
    void __set_token_str_form(const std::string& val) {
      token_str_form = val;
    }
  
    bool operator == (const ThriftHiveMetastore_cancel_delegation_token_args & rhs) const
    {
      if (!(token_str_form == rhs.token_str_form))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_cancel_delegation_token_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_cancel_delegation_token_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_cancel_delegation_token_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_cancel_delegation_token_pargs() throw() {}
  
    const std::string* token_str_form;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_cancel_delegation_token_result__isset {
    _ThriftHiveMetastore_cancel_delegation_token_result__isset() : o1(false) {}
    bool o1;
  } _ThriftHiveMetastore_cancel_delegation_token_result__isset;
  
  class ThriftHiveMetastore_cancel_delegation_token_result {
   public:
  
    ThriftHiveMetastore_cancel_delegation_token_result() {
    }
  
    virtual ~ThriftHiveMetastore_cancel_delegation_token_result() throw() {}
  
    MetaException o1;
  
    _ThriftHiveMetastore_cancel_delegation_token_result__isset __isset;
  
    void __set_o1(const MetaException& val) {
      o1 = val;
    }
  
    bool operator == (const ThriftHiveMetastore_cancel_delegation_token_result & rhs) const
    {
      if (!(o1 == rhs.o1))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_cancel_delegation_token_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_cancel_delegation_token_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_cancel_delegation_token_presult__isset {
    _ThriftHiveMetastore_cancel_delegation_token_presult__isset() : o1(false) {}
    bool o1;
  } _ThriftHiveMetastore_cancel_delegation_token_presult__isset;
  
  class ThriftHiveMetastore_cancel_delegation_token_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_cancel_delegation_token_presult() throw() {}
  
    MetaException o1;
  
    _ThriftHiveMetastore_cancel_delegation_token_presult__isset __isset;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  
  };
  
  
  class ThriftHiveMetastore_get_open_txns_args {
   public:
  
    ThriftHiveMetastore_get_open_txns_args() {
    }
  
    virtual ~ThriftHiveMetastore_get_open_txns_args() throw() {}
  
  
    bool operator == (const ThriftHiveMetastore_get_open_txns_args & /* rhs */) const
    {
      return true;
    }
    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_heartbeat_txn_range_args__isset {
    _ThriftHiveMetastore_heartbeat_txn_range_args__isset() : txns(false) {}
    bool txns;
  } _ThriftHiveMetastore_heartbeat_txn_range_args__isset;
  
  class ThriftHiveMetastore_heartbeat_txn_range_args {
   public:
  
    ThriftHiveMetastore_heartbeat_txn_range_args() {
    }
  
    virtual ~ThriftHiveMetastore_heartbeat_txn_range_args() throw() {}
  
    HeartbeatTxnRangeRequest txns;
  
    _ThriftHiveMetastore_heartbeat_txn_range_args__isset __isset;
  
    void __set_txns(const HeartbeatTxnRangeRequest& val) {
      txns = val;
    }
  
    bool operator == (const ThriftHiveMetastore_heartbeat_txn_range_args & rhs) const
    {
      if (!(txns == rhs.txns))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_heartbeat_txn_range_args &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_heartbeat_txn_range_args & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  
  class ThriftHiveMetastore_heartbeat_txn_range_pargs {
   public:
  
  
    virtual ~ThriftHiveMetastore_heartbeat_txn_range_pargs() throw() {}
  
    const HeartbeatTxnRangeRequest* txns;
  
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_heartbeat_txn_range_result__isset {
    _ThriftHiveMetastore_heartbeat_txn_range_result__isset() : success(false) {}
    bool success;
  } _ThriftHiveMetastore_heartbeat_txn_range_result__isset;
  
  class ThriftHiveMetastore_heartbeat_txn_range_result {
   public:
  
    ThriftHiveMetastore_heartbeat_txn_range_result() {
    }
  
    virtual ~ThriftHiveMetastore_heartbeat_txn_range_result() throw() {}
  
    HeartbeatTxnRangeResponse success;
  
    _ThriftHiveMetastore_heartbeat_txn_range_result__isset __isset;
  
    void __set_success(const HeartbeatTxnRangeResponse& val) {
      success = val;
    }
  
    bool operator == (const ThriftHiveMetastore_heartbeat_txn_range_result & rhs) const
    {
      if (!(success == rhs.success))
        return false;
      return true;
    }
    bool operator != (const ThriftHiveMetastore_heartbeat_txn_range_result &rhs) const {
      return !(*this == rhs);
    }
  
    bool operator < (const ThriftHiveMetastore_heartbeat_txn_range_result & ) const;
  
    uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
    uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;
  
  };
  
  typedef struct _ThriftHiveMetastore_heartbeat_txn_range_presult__isset {
    _ThriftHiveMetastore_heartbeat_txn_range_presult__isset() : success(false) {}
    bool success;
  } _ThriftHiveMetastore_heartbeat_txn_range_presult__isset;
  
  class ThriftHiveMetastore_heartbeat_txn_range_presult {
   public:
  
  
    virtual ~ThriftHiveMetastore_heartbeat_txn_range_presult() throw() {}
  
    HeartbeatTxnRangeResponse* success;
  
    _ThriftHiveMetastore_heartbeat_txn_range_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);
    void get_aggr_stats_for(AggrStats& _return, const PartitionsStatsRequest& request);
    void send_get_aggr_stats_for(const PartitionsStatsRequest& request);
    void recv_get_aggr_stats_for(AggrStats& _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();
    void create_function(const Function& func);
    void send_create_function(const Function& func);
    void recv_create_function();
    void drop_function(const std::string& dbName, const std::string& funcName);
    void send_drop_function(const std::string& dbName, const std::string& funcName);
    void recv_drop_function();
    void alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc);
    void send_alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc);
    void recv_alter_function();
    void get_functions(std::vector<std::string> & _return, const std::string& dbName, const std::string& pattern);
    void send_get_functions(const std::string& dbName, const std::string& pattern);
    void recv_get_functions(std::vector<std::string> & _return);
    void get_function(Function& _return, const std::string& dbName, const std::string& funcName);
    void send_get_function(const std::string& dbName, const std::string& funcName);
    void recv_get_function(Function& _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();
    void get_role_names(std::vector<std::string> & _return);
    void send_get_role_names();
    void recv_get_role_names(std::vector<std::string> & _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);
    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 grant_revoke_role(GrantRevokeRoleResponse& _return, const GrantRevokeRoleRequest& request);
    void send_grant_revoke_role(const GrantRevokeRoleRequest& request);
    void recv_grant_revoke_role(GrantRevokeRoleResponse& _return);
    void get_principals_in_role(GetPrincipalsInRoleResponse& _return, const GetPrincipalsInRoleRequest& request);
    void send_get_principals_in_role(const GetPrincipalsInRoleRequest& request);
    void recv_get_principals_in_role(GetPrincipalsInRoleResponse& _return);
    void get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const GetRoleGrantsForPrincipalRequest& request);
    void send_get_role_grants_for_principal(const GetRoleGrantsForPrincipalRequest& request);
    void recv_get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _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();
    void grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const GrantRevokePrivilegeRequest& request);
    void send_grant_revoke_privileges(const GrantRevokePrivilegeRequest& request);
    void recv_grant_revoke_privileges(GrantRevokePrivilegeResponse& _return);
    void set_ugi(std::vector<std::string> & _return, const std::string& user_name, const std::vector<std::string> & group_names);
    void send_set_ugi(const std::string& user_name, const std::vector<std::string> & group_names);
    void recv_set_ugi(std::vector<std::string> & _return);
    void get_delegation_token(std::string& _return, const std::string& token_owner, const std::string& renewer_kerberos_principal_name);
    void send_get_delegation_token(const std::string& token_owner, const std::string& renewer_kerberos_principal_name);
    void recv_get_delegation_token(std::string& _return);
    int64_t renew_delegation_token(const std::string& token_str_form);
    void send_renew_delegation_token(const std::string& token_str_form);
    int64_t recv_renew_delegation_token();
    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 heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns);
    void send_heartbeat_txn_range(const HeartbeatTxnRangeRequest& txns);
    void recv_heartbeat_txn_range(HeartbeatTxnRangeResponse& _return);
    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 {
   protected:
    boost::shared_ptr<ThriftHiveMetastoreIf> iface_;
    virtual bool dispatchCall(::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, const std::string& fname, int32_t seqid, void* callContext);
   private:
    typedef  void (ThriftHiveMetastoreProcessor::*ProcessFunction)(int32_t, ::apache::thrift::protocol::TProtocol*, ::apache::thrift::protocol::TProtocol*, void*);
    typedef std::map<std::string, ProcessFunction> ProcessMap;
    ProcessMap processMap_;
    void process_create_database(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_database(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_drop_database(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_databases(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_all_databases(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_alter_database(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_type(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_create_type(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_drop_type(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_type_all(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_fields(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_schema(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_create_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_create_table_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_drop_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_drop_table_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_tables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_all_tables(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_table_objects_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_table_names_by_filter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_alter_table(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_alter_table_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_add_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_add_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_add_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_append_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_add_partitions_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_append_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_append_partition_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_append_partition_by_name_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_drop_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_drop_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_drop_partition_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_drop_partition_by_name_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_drop_partitions_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_exchange_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_partition_with_auth(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_partition_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_partitions_with_auth(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_partition_names(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_partitions_ps(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_partitions_ps_with_auth(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_partition_names_ps(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_partitions_by_filter(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_partitions_by_expr(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_partitions_by_names(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_alter_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_alter_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_alter_partition_with_environment_context(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_rename_partition(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_partition_name_has_valid_characters(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_config_value(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_partition_name_to_vals(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_partition_name_to_spec(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_markPartitionForEvent(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_isPartitionMarkedForEvent(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_add_index(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_alter_index(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_drop_index_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_index_by_name(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_indexes(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_index_names(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_update_table_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_update_partition_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_table_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_partition_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_table_statistics_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_partitions_statistics_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_aggr_stats_for(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_delete_partition_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_delete_table_column_statistics(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_create_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_drop_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_alter_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_functions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_function(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_create_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_drop_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_role_names(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_grant_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_revoke_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_list_roles(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_grant_revoke_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_principals_in_role(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_role_grants_for_principal(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_get_privilege_set(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_list_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_grant_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_revoke_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_grant_revoke_privileges(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    void process_set_ugi(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
    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_heartbeat_txn_range(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),
      iface_(iface) {
      processMap_["create_database"] = &ThriftHiveMetastoreProcessor::process_create_database;
      processMap_["get_database"] = &ThriftHiveMetastoreProcessor::process_get_database;
      processMap_["drop_database"] = &ThriftHiveMetastoreProcessor::process_drop_database;
      processMap_["get_databases"] = &ThriftHiveMetastoreProcessor::process_get_databases;
      processMap_["get_all_databases"] = &ThriftHiveMetastoreProcessor::process_get_all_databases;
      processMap_["alter_database"] = &ThriftHiveMetastoreProcessor::process_alter_database;
      processMap_["get_type"] = &ThriftHiveMetastoreProcessor::process_get_type;
      processMap_["create_type"] = &ThriftHiveMetastoreProcessor::process_create_type;
      processMap_["drop_type"] = &ThriftHiveMetastoreProcessor::process_drop_type;
      processMap_["get_type_all"] = &ThriftHiveMetastoreProcessor::process_get_type_all;
      processMap_["get_fields"] = &ThriftHiveMetastoreProcessor::process_get_fields;
      processMap_["get_schema"] = &ThriftHiveMetastoreProcessor::process_get_schema;
      processMap_["create_table"] = &ThriftHiveMetastoreProcessor::process_create_table;
      processMap_["create_table_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_create_table_with_environment_context;
      processMap_["drop_table"] = &ThriftHiveMetastoreProcessor::process_drop_table;
      processMap_["drop_table_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_drop_table_with_environment_context;
      processMap_["get_tables"] = &ThriftHiveMetastoreProcessor::process_get_tables;
      processMap_["get_all_tables"] = &ThriftHiveMetastoreProcessor::process_get_all_tables;
      processMap_["get_table"] = &ThriftHiveMetastoreProcessor::process_get_table;
      processMap_["get_table_objects_by_name"] = &ThriftHiveMetastoreProcessor::process_get_table_objects_by_name;
      processMap_["get_table_names_by_filter"] = &ThriftHiveMetastoreProcessor::process_get_table_names_by_filter;
      processMap_["alter_table"] = &ThriftHiveMetastoreProcessor::process_alter_table;
      processMap_["alter_table_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_alter_table_with_environment_context;
      processMap_["add_partition"] = &ThriftHiveMetastoreProcessor::process_add_partition;
      processMap_["add_partition_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_add_partition_with_environment_context;
      processMap_["add_partitions"] = &ThriftHiveMetastoreProcessor::process_add_partitions;
      processMap_["append_partition"] = &ThriftHiveMetastoreProcessor::process_append_partition;
      processMap_["add_partitions_req"] = &ThriftHiveMetastoreProcessor::process_add_partitions_req;
      processMap_["append_partition_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_append_partition_with_environment_context;
      processMap_["append_partition_by_name"] = &ThriftHiveMetastoreProcessor::process_append_partition_by_name;
      processMap_["append_partition_by_name_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_append_partition_by_name_with_environment_context;
      processMap_["drop_partition"] = &ThriftHiveMetastoreProcessor::process_drop_partition;
      processMap_["drop_partition_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_drop_partition_with_environment_context;
      processMap_["drop_partition_by_name"] = &ThriftHiveMetastoreProcessor::process_drop_partition_by_name;
      processMap_["drop_partition_by_name_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_drop_partition_by_name_with_environment_context;
      processMap_["drop_partitions_req"] = &ThriftHiveMetastoreProcessor::process_drop_partitions_req;
      processMap_["get_partition"] = &ThriftHiveMetastoreProcessor::process_get_partition;
      processMap_["exchange_partition"] = &ThriftHiveMetastoreProcessor::process_exchange_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_["get_partitions_by_expr"] = &ThriftHiveMetastoreProcessor::process_get_partitions_by_expr;
      processMap_["get_partitions_by_names"] = &ThriftHiveMetastoreProcessor::process_get_partitions_by_names;
      processMap_["alter_partition"] = &ThriftHiveMetastoreProcessor::process_alter_partition;
      processMap_["alter_partitions"] = &ThriftHiveMetastoreProcessor::process_alter_partitions;
      processMap_["alter_partition_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_alter_partition_with_environment_context;
      processMap_["rename_partition"] = &ThriftHiveMetastoreProcessor::process_rename_partition;
      processMap_["partition_name_has_valid_characters"] = &ThriftHiveMetastoreProcessor::process_partition_name_has_valid_characters;
      processMap_["get_config_value"] = &ThriftHiveMetastoreProcessor::process_get_config_value;
      processMap_["partition_name_to_vals"] = &ThriftHiveMetastoreProcessor::process_partition_name_to_vals;
      processMap_["partition_name_to_spec"] = &ThriftHiveMetastoreProcessor::process_partition_name_to_spec;
      processMap_["markPartitionForEvent"] = &ThriftHiveMetastoreProcessor::process_markPartitionForEvent;
      processMap_["isPartitionMarkedForEvent"] = &ThriftHiveMetastoreProcessor::process_isPartitionMarkedForEvent;
      processMap_["add_index"] = &ThriftHiveMetastoreProcessor::process_add_index;
      processMap_["alter_index"] = &ThriftHiveMetastoreProcessor::process_alter_index;
      processMap_["drop_index_by_name"] = &ThriftHiveMetastoreProcessor::process_drop_index_by_name;
      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_["update_table_column_statistics"] = &ThriftHiveMetastoreProcessor::process_update_table_column_statistics;
      processMap_["update_partition_column_statistics"] = &ThriftHiveMetastoreProcessor::process_update_partition_column_statistics;
      processMap_["get_table_column_statistics"] = &ThriftHiveMetastoreProcessor::process_get_table_column_statistics;
      processMap_["get_partition_column_statistics"] = &ThriftHiveMetastoreProcessor::process_get_partition_column_statistics;
      processMap_["get_table_statistics_req"] = &ThriftHiveMetastoreProcessor::process_get_table_statistics_req;
      processMap_["get_partitions_statistics_req"] = &ThriftHiveMetastoreProcessor::process_get_partitions_statistics_req;
      processMap_["get_aggr_stats_for"] = &ThriftHiveMetastoreProcessor::process_get_aggr_stats_for;
      processMap_["delete_partition_column_statistics"] = &ThriftHiveMetastoreProcessor::process_delete_partition_column_statistics;
      processMap_["delete_table_column_statistics"] = &ThriftHiveMetastoreProcessor::process_delete_table_column_statistics;
      processMap_["create_function"] = &ThriftHiveMetastoreProcessor::process_create_function;
      processMap_["drop_function"] = &ThriftHiveMetastoreProcessor::process_drop_function;
      processMap_["alter_function"] = &ThriftHiveMetastoreProcessor::process_alter_function;
      processMap_["get_functions"] = &ThriftHiveMetastoreProcessor::process_get_functions;
      processMap_["get_function"] = &ThriftHiveMetastoreProcessor::process_get_function;
      processMap_["create_role"] = &ThriftHiveMetastoreProcessor::process_create_role;
      processMap_["drop_role"] = &ThriftHiveMetastoreProcessor::process_drop_role;
      processMap_["get_role_names"] = &ThriftHiveMetastoreProcessor::process_get_role_names;
      processMap_["grant_role"] = &ThriftHiveMetastoreProcessor::process_grant_role;
      processMap_["revoke_role"] = &ThriftHiveMetastoreProcessor::process_revoke_role;
      processMap_["list_roles"] = &ThriftHiveMetastoreProcessor::process_list_roles;
      processMap_["grant_revoke_role"] = &ThriftHiveMetastoreProcessor::process_grant_revoke_role;
      processMap_["get_principals_in_role"] = &ThriftHiveMetastoreProcessor::process_get_principals_in_role;
      processMap_["get_role_grants_for_principal"] = &ThriftHiveMetastoreProcessor::process_get_role_grants_for_principal;
      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;
      processMap_["grant_revoke_privileges"] = &ThriftHiveMetastoreProcessor::process_grant_revoke_privileges;
      processMap_["set_ugi"] = &ThriftHiveMetastoreProcessor::process_set_ugi;
      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_["heartbeat_txn_range"] = &ThriftHiveMetastoreProcessor::process_heartbeat_txn_range;
      processMap_["compact"] = &ThriftHiveMetastoreProcessor::process_compact;
      processMap_["show_compact"] = &ThriftHiveMetastoreProcessor::process_show_compact;
    }
  
    virtual ~ThriftHiveMetastoreProcessor() {}
  };
  
  class ThriftHiveMetastoreProcessorFactory : public ::apache::thrift::TProcessorFactory {
   public:
    ThriftHiveMetastoreProcessorFactory(const ::boost::shared_ptr< ThriftHiveMetastoreIfFactory >& handlerFactory) :
        handlerFactory_(handlerFactory) {}
  
    ::boost::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo);
  
   protected:
    ::boost::shared_ptr< ThriftHiveMetastoreIfFactory > handlerFactory_;
  };
  
  class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, public  ::facebook::fb303::FacebookServiceMultiface {
   public:
    ThriftHiveMetastoreMultiface(std::vector<boost::shared_ptr<ThriftHiveMetastoreIf> >& ifaces) : ifaces_(ifaces) {
      std::vector<boost::shared_ptr<ThriftHiveMetastoreIf> >::iterator iter;
      for (iter = ifaces.begin(); iter != ifaces.end(); ++iter) {
         ::facebook::fb303::FacebookServiceMultiface::add(*iter);
      }
    }
    virtual ~ThriftHiveMetastoreMultiface() {}
   protected:
    std::vector<boost::shared_ptr<ThriftHiveMetastoreIf> > ifaces_;
    ThriftHiveMetastoreMultiface() {}
    void add(boost::shared_ptr<ThriftHiveMetastoreIf> iface) {
       ::facebook::fb303::FacebookServiceMultiface::add(iface);
      ifaces_.push_back(iface);
    }
   public:
    void create_database(const Database& database) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->create_database(database);
      }
      ifaces_[i]->create_database(database);
    }
  
    void get_database(Database& _return, const std::string& name) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_database(_return, name);
      }
      ifaces_[i]->get_database(_return, name);
      return;
    }
  
    void drop_database(const std::string& name, const bool deleteData, const bool cascade) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->drop_database(name, deleteData, cascade);
      }
      ifaces_[i]->drop_database(name, deleteData, cascade);
    }
  
    void get_databases(std::vector<std::string> & _return, const std::string& pattern) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_databases(_return, pattern);
      }
      ifaces_[i]->get_databases(_return, pattern);
      return;
    }
  
    void get_all_databases(std::vector<std::string> & _return) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_all_databases(_return);
      }
      ifaces_[i]->get_all_databases(_return);
      return;
    }
  
    void alter_database(const std::string& dbname, const Database& db) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->alter_database(dbname, db);
      }
      ifaces_[i]->alter_database(dbname, db);
    }
  
    void get_type(Type& _return, const std::string& name) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_type(_return, name);
      }
      ifaces_[i]->get_type(_return, name);
      return;
    }
  
    bool create_type(const Type& type) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->create_type(type);
      }
      return ifaces_[i]->create_type(type);
    }
  
    bool drop_type(const std::string& type) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->drop_type(type);
      }
      return ifaces_[i]->drop_type(type);
    }
  
    void get_type_all(std::map<std::string, Type> & _return, const std::string& name) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_type_all(_return, name);
      }
      ifaces_[i]->get_type_all(_return, name);
      return;
    }
  
    void get_fields(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_fields(_return, db_name, table_name);
      }
      ifaces_[i]->get_fields(_return, db_name, table_name);
      return;
    }
  
    void get_schema(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_schema(_return, db_name, table_name);
      }
      ifaces_[i]->get_schema(_return, db_name, table_name);
      return;
    }
  
    void create_table(const Table& tbl) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->create_table(tbl);
      }
      ifaces_[i]->create_table(tbl);
    }
  
    void create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->create_table_with_environment_context(tbl, environment_context);
      }
      ifaces_[i]->create_table_with_environment_context(tbl, environment_context);
    }
  
    void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->drop_table(dbname, name, deleteData);
      }
      ifaces_[i]->drop_table(dbname, name, deleteData);
    }
  
    void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->drop_table_with_environment_context(dbname, name, deleteData, environment_context);
      }
      ifaces_[i]->drop_table_with_environment_context(dbname, name, deleteData, environment_context);
    }
  
    void get_tables(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_tables(_return, db_name, pattern);
      }
      ifaces_[i]->get_tables(_return, db_name, pattern);
      return;
    }
  
    void get_all_tables(std::vector<std::string> & _return, const std::string& db_name) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_all_tables(_return, db_name);
      }
      ifaces_[i]->get_all_tables(_return, db_name);
      return;
    }
  
    void get_table(Table& _return, const std::string& dbname, const std::string& tbl_name) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_table(_return, dbname, tbl_name);
      }
      ifaces_[i]->get_table(_return, dbname, tbl_name);
      return;
    }
  
    void get_table_objects_by_name(std::vector<Table> & _return, const std::string& dbname, const std::vector<std::string> & tbl_names) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_table_objects_by_name(_return, dbname, tbl_names);
      }
      ifaces_[i]->get_table_objects_by_name(_return, dbname, tbl_names);
      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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_table_names_by_filter(_return, dbname, filter, max_tables);
      }
      ifaces_[i]->get_table_names_by_filter(_return, dbname, filter, max_tables);
      return;
    }
  
    void alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->alter_table(dbname, tbl_name, new_tbl);
      }
      ifaces_[i]->alter_table(dbname, tbl_name, new_tbl);
    }
  
    void alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->alter_table_with_environment_context(dbname, tbl_name, new_tbl, environment_context);
      }
      ifaces_[i]->alter_table_with_environment_context(dbname, tbl_name, new_tbl, environment_context);
    }
  
    void add_partition(Partition& _return, const Partition& new_part) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->add_partition(_return, new_part);
      }
      ifaces_[i]->add_partition(_return, new_part);
      return;
    }
  
    void add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->add_partition_with_environment_context(_return, new_part, environment_context);
      }
      ifaces_[i]->add_partition_with_environment_context(_return, new_part, environment_context);
      return;
    }
  
    int32_t add_partitions(const std::vector<Partition> & new_parts) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->add_partitions(new_parts);
      }
      return ifaces_[i]->add_partitions(new_parts);
    }
  
    void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->append_partition(_return, db_name, tbl_name, part_vals);
      }
      ifaces_[i]->append_partition(_return, db_name, tbl_name, part_vals);
      return;
    }
  
    void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->add_partitions_req(_return, request);
      }
      ifaces_[i]->add_partitions_req(_return, request);
      return;
    }
  
    void append_partition_with_environment_context(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const EnvironmentContext& environment_context) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->append_partition_with_environment_context(_return, db_name, tbl_name, part_vals, environment_context);
      }
      ifaces_[i]->append_partition_with_environment_context(_return, db_name, tbl_name, part_vals, environment_context);
      return;
    }
  
    void append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->append_partition_by_name(_return, db_name, tbl_name, part_name);
      }
      ifaces_[i]->append_partition_by_name(_return, db_name, tbl_name, part_name);
      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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->append_partition_by_name_with_environment_context(_return, db_name, tbl_name, part_name, environment_context);
      }
      ifaces_[i]->append_partition_by_name_with_environment_context(_return, db_name, tbl_name, part_name, environment_context);
      return;
    }
  
    bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const bool deleteData) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->drop_partition(db_name, tbl_name, part_vals, deleteData);
      }
      return ifaces_[i]->drop_partition(db_name, tbl_name, part_vals, deleteData);
    }
  
    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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->drop_partition_with_environment_context(db_name, tbl_name, part_vals, deleteData, environment_context);
      }
      return ifaces_[i]->drop_partition_with_environment_context(db_name, tbl_name, part_vals, deleteData, 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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->drop_partition_by_name(db_name, tbl_name, part_name, deleteData);
      }
      return ifaces_[i]->drop_partition_by_name(db_name, tbl_name, part_name, deleteData);
    }
  
    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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->drop_partition_by_name_with_environment_context(db_name, tbl_name, part_name, deleteData, environment_context);
      }
      return ifaces_[i]->drop_partition_by_name_with_environment_context(db_name, tbl_name, part_name, deleteData, environment_context);
    }
  
    void drop_partitions_req(DropPartitionsResult& _return, const DropPartitionsRequest& req) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->drop_partitions_req(_return, req);
      }
      ifaces_[i]->drop_partitions_req(_return, req);
      return;
    }
  
    void get_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_partition(_return, db_name, tbl_name, part_vals);
      }
      ifaces_[i]->get_partition(_return, db_name, tbl_name, part_vals);
      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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->exchange_partition(_return, partitionSpecs, source_db, source_table_name, dest_db, dest_table_name);
      }
      ifaces_[i]->exchange_partition(_return, partitionSpecs, source_db, source_table_name, dest_db, dest_table_name);
      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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_partition_with_auth(_return, db_name, tbl_name, part_vals, user_name, group_names);
      }
      ifaces_[i]->get_partition_with_auth(_return, db_name, tbl_name, part_vals, user_name, 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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_partition_by_name(_return, db_name, tbl_name, part_name);
      }
      ifaces_[i]->get_partition_by_name(_return, db_name, tbl_name, 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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_partitions(_return, db_name, tbl_name, max_parts);
      }
      ifaces_[i]->get_partitions(_return, db_name, tbl_name, 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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_partitions_with_auth(_return, db_name, tbl_name, max_parts, user_name, group_names);
      }
      ifaces_[i]->get_partitions_with_auth(_return, db_name, tbl_name, max_parts, user_name, 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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_partition_names(_return, db_name, tbl_name, max_parts);
      }
      ifaces_[i]->get_partition_names(_return, db_name, tbl_name, 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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_partitions_ps(_return, db_name, tbl_name, part_vals, max_parts);
      }
      ifaces_[i]->get_partitions_ps(_return, db_name, tbl_name, part_vals, 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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_partitions_ps_with_auth(_return, db_name, tbl_name, part_vals, max_parts, user_name, group_names);
      }
      ifaces_[i]->get_partitions_ps_with_auth(_return, db_name, tbl_name, part_vals, max_parts, user_name, 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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_partition_names_ps(_return, db_name, tbl_name, part_vals, max_parts);
      }
      ifaces_[i]->get_partition_names_ps(_return, db_name, tbl_name, part_vals, max_parts);
      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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_partitions_by_filter(_return, db_name, tbl_name, filter, max_parts);
      }
      ifaces_[i]->get_partitions_by_filter(_return, db_name, tbl_name, filter, max_parts);
      return;
    }
  
    void get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_partitions_by_expr(_return, req);
      }
      ifaces_[i]->get_partitions_by_expr(_return, req);
      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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_partitions_by_names(_return, db_name, tbl_name, names);
      }
      ifaces_[i]->get_partitions_by_names(_return, db_name, tbl_name, names);
      return;
    }
  
    void alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->alter_partition(db_name, tbl_name, new_part);
      }
      ifaces_[i]->alter_partition(db_name, tbl_name, new_part);
    }
  
    void alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->alter_partitions(db_name, tbl_name, new_parts);
      }
      ifaces_[i]->alter_partitions(db_name, tbl_name, new_parts);
    }
  
    void alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->alter_partition_with_environment_context(db_name, tbl_name, new_part, environment_context);
      }
      ifaces_[i]->alter_partition_with_environment_context(db_name, tbl_name, new_part, 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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->rename_partition(db_name, tbl_name, part_vals, new_part);
      }
      ifaces_[i]->rename_partition(db_name, tbl_name, part_vals, new_part);
    }
  
    bool partition_name_has_valid_characters(const std::vector<std::string> & part_vals, const bool throw_exception) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->partition_name_has_valid_characters(part_vals, throw_exception);
      }
      return ifaces_[i]->partition_name_has_valid_characters(part_vals, throw_exception);
    }
  
    void get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_config_value(_return, name, defaultValue);
      }
      ifaces_[i]->get_config_value(_return, name, defaultValue);
      return;
    }
  
    void partition_name_to_vals(std::vector<std::string> & _return, const std::string& part_name) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->partition_name_to_vals(_return, part_name);
      }
      ifaces_[i]->partition_name_to_vals(_return, part_name);
      return;
    }
  
    void partition_name_to_spec(std::map<std::string, std::string> & _return, const std::string& part_name) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->partition_name_to_spec(_return, part_name);
      }
      ifaces_[i]->partition_name_to_spec(_return, part_name);
      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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->markPartitionForEvent(db_name, tbl_name, part_vals, eventType);
      }
      ifaces_[i]->markPartitionForEvent(db_name, tbl_name, part_vals, eventType);
    }
  
    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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->isPartitionMarkedForEvent(db_name, tbl_name, part_vals, eventType);
      }
      return ifaces_[i]->isPartitionMarkedForEvent(db_name, tbl_name, part_vals, eventType);
    }
  
    void add_index(Index& _return, const Index& new_index, const Table& index_table) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->add_index(_return, new_index, index_table);
      }
      ifaces_[i]->add_index(_return, new_index, index_table);
      return;
    }
  
    void alter_index(const std::string& dbname, const std::string& base_tbl_name, const std::string& idx_name, const Index& new_idx) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->alter_index(dbname, base_tbl_name, idx_name, new_idx);
      }
      ifaces_[i]->alter_index(dbname, base_tbl_name, idx_name, new_idx);
    }
  
    bool drop_index_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& index_name, const bool deleteData) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->drop_index_by_name(db_name, tbl_name, index_name, deleteData);
      }
      return ifaces_[i]->drop_index_by_name(db_name, tbl_name, index_name, deleteData);
    }
  
    void get_index_by_name(Index& _return, const std::string& db_name, const std::string& tbl_name, const std::string& index_name) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_index_by_name(_return, db_name, tbl_name, index_name);
      }
      ifaces_[i]->get_index_by_name(_return, db_name, tbl_name, index_name);
      return;
    }
  
    void get_indexes(std::vector<Index> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_indexes) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_indexes(_return, db_name, tbl_name, max_indexes);
      }
      ifaces_[i]->get_indexes(_return, db_name, tbl_name, max_indexes);
      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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_index_names(_return, db_name, tbl_name, max_indexes);
      }
      ifaces_[i]->get_index_names(_return, db_name, tbl_name, max_indexes);
      return;
    }
  
    bool update_table_column_statistics(const ColumnStatistics& stats_obj) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->update_table_column_statistics(stats_obj);
      }
      return ifaces_[i]->update_table_column_statistics(stats_obj);
    }
  
    bool update_partition_column_statistics(const ColumnStatistics& stats_obj) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->update_partition_column_statistics(stats_obj);
      }
      return ifaces_[i]->update_partition_column_statistics(stats_obj);
    }
  
    void get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_table_column_statistics(_return, db_name, tbl_name, col_name);
      }
      ifaces_[i]->get_table_column_statistics(_return, db_name, tbl_name, col_name);
      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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_partition_column_statistics(_return, db_name, tbl_name, part_name, col_name);
      }
      ifaces_[i]->get_partition_column_statistics(_return, db_name, tbl_name, part_name, col_name);
      return;
    }
  
    void get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_table_statistics_req(_return, request);
      }
      ifaces_[i]->get_table_statistics_req(_return, request);
      return;
    }
  
    void get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_partitions_statistics_req(_return, request);
      }
      ifaces_[i]->get_partitions_statistics_req(_return, request);
      return;
    }
  
    void get_aggr_stats_for(AggrStats& _return, const PartitionsStatsRequest& request) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_aggr_stats_for(_return, request);
      }
      ifaces_[i]->get_aggr_stats_for(_return, request);
      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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->delete_partition_column_statistics(db_name, tbl_name, part_name, col_name);
      }
      return ifaces_[i]->delete_partition_column_statistics(db_name, tbl_name, part_name, col_name);
    }
  
    bool delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->delete_table_column_statistics(db_name, tbl_name, col_name);
      }
      return ifaces_[i]->delete_table_column_statistics(db_name, tbl_name, col_name);
    }
  
    void create_function(const Function& func) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->create_function(func);
      }
      ifaces_[i]->create_function(func);
    }
  
    void drop_function(const std::string& dbName, const std::string& funcName) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->drop_function(dbName, funcName);
      }
      ifaces_[i]->drop_function(dbName, funcName);
    }
  
    void alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->alter_function(dbName, funcName, newFunc);
      }
      ifaces_[i]->alter_function(dbName, funcName, newFunc);
    }
  
    void get_functions(std::vector<std::string> & _return, const std::string& dbName, const std::string& pattern) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_functions(_return, dbName, pattern);
      }
      ifaces_[i]->get_functions(_return, dbName, pattern);
      return;
    }
  
    void get_function(Function& _return, const std::string& dbName, const std::string& funcName) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_function(_return, dbName, funcName);
      }
      ifaces_[i]->get_function(_return, dbName, funcName);
      return;
    }
  
    bool create_role(const Role& role) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->create_role(role);
      }
      return ifaces_[i]->create_role(role);
    }
  
    bool drop_role(const std::string& role_name) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->drop_role(role_name);
      }
      return ifaces_[i]->drop_role(role_name);
    }
  
    void get_role_names(std::vector<std::string> & _return) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_role_names(_return);
      }
      ifaces_[i]->get_role_names(_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) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->grant_role(role_name, principal_name, principal_type, grantor, grantorType, grant_option);
      }
      return ifaces_[i]->grant_role(role_name, principal_name, principal_type, grantor, grantorType, grant_option);
    }
  
    bool revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->revoke_role(role_name, principal_name, principal_type);
      }
      return ifaces_[i]->revoke_role(role_name, principal_name, principal_type);
    }
  
    void list_roles(std::vector<Role> & _return, const std::string& principal_name, const PrincipalType::type principal_type) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->list_roles(_return, principal_name, principal_type);
      }
      ifaces_[i]->list_roles(_return, principal_name, principal_type);
      return;
    }
  
    void grant_revoke_role(GrantRevokeRoleResponse& _return, const GrantRevokeRoleRequest& request) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->grant_revoke_role(_return, request);
      }
      ifaces_[i]->grant_revoke_role(_return, request);
      return;
    }
  
    void get_principals_in_role(GetPrincipalsInRoleResponse& _return, const GetPrincipalsInRoleRequest& request) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_principals_in_role(_return, request);
      }
      ifaces_[i]->get_principals_in_role(_return, request);
      return;
    }
  
    void get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const GetRoleGrantsForPrincipalRequest& request) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_role_grants_for_principal(_return, request);
      }
      ifaces_[i]->get_role_grants_for_principal(_return, request);
      return;
    }
  
    void get_privilege_set(PrincipalPrivilegeSet& _return, const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector<std::string> & group_names) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_privilege_set(_return, hiveObject, user_name, group_names);
      }
      ifaces_[i]->get_privilege_set(_return, hiveObject, user_name, group_names);
      return;
    }
  
    void list_privileges(std::vector<HiveObjectPrivilege> & _return, const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->list_privileges(_return, principal_name, principal_type, hiveObject);
      }
      ifaces_[i]->list_privileges(_return, principal_name, principal_type, hiveObject);
      return;
    }
  
    bool grant_privileges(const PrivilegeBag& privileges) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->grant_privileges(privileges);
      }
      return ifaces_[i]->grant_privileges(privileges);
    }
  
    bool revoke_privileges(const PrivilegeBag& privileges) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->revoke_privileges(privileges);
      }
      return ifaces_[i]->revoke_privileges(privileges);
    }
  
    void grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const GrantRevokePrivilegeRequest& request) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->grant_revoke_privileges(_return, request);
      }
      ifaces_[i]->grant_revoke_privileges(_return, request);
      return;
    }
  
    void set_ugi(std::vector<std::string> & _return, const std::string& user_name, const std::vector<std::string> & group_names) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->set_ugi(_return, user_name, group_names);
      }
      ifaces_[i]->set_ugi(_return, user_name, group_names);
      return;
    }
  
    void get_delegation_token(std::string& _return, const std::string& token_owner, const std::string& renewer_kerberos_principal_name) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->get_delegation_token(_return, token_owner, renewer_kerberos_principal_name);
      }
      ifaces_[i]->get_delegation_token(_return, token_owner, renewer_kerberos_principal_name);
      return;
    }
  
    int64_t renew_delegation_token(const std::string& token_str_form) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->renew_delegation_token(token_str_form);
      }
      return ifaces_[i]->renew_delegation_token(token_str_form);
    }
  
    void cancel_delegation_token(const std::string& token_str_form) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->cancel_delegation_token(token_str_form);
      }
      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);
      }
      ifaces_[i]->lock(_return, rqst);
      return;
    }
  
    void check_lock(LockResponse& _return, const CheckLockRequest& rqst) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->check_lock(_return, rqst);
      }
      ifaces_[i]->check_lock(_return, rqst);
      return;
    }
  
    void unlock(const UnlockRequest& rqst) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->unlock(rqst);
      }
      ifaces_[i]->unlock(rqst);
    }
  
    void show_locks(ShowLocksResponse& _return, const ShowLocksRequest& rqst) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->show_locks(_return, rqst);
      }
      ifaces_[i]->show_locks(_return, rqst);
      return;
    }
  
    void heartbeat(const HeartbeatRequest& ids) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->heartbeat(ids);
      }
      ifaces_[i]->heartbeat(ids);
    }
  
    void heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->heartbeat_txn_range(_return, txns);
      }
      ifaces_[i]->heartbeat_txn_range(_return, txns);
      return;
    }
  
    void compact(const CompactionRequest& rqst) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->compact(rqst);
      }
      ifaces_[i]->compact(rqst);
    }
  
    void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) {
      size_t sz = ifaces_.size();
      size_t i = 0;
      for (; i < (sz - 1); ++i) {
        ifaces_[i]->show_compact(_return, rqst);
      }
      ifaces_[i]->show_compact(_return, rqst);
      return;
    }
  
  };
  
  }}} // namespace
  
  #endif
  