/**
 * 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 getMetaConf(std::string& _return, const std::string& key) = 0;
  virtual void setMetaConf(const std::string& key, const std::string& value) = 0;
  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_fields_with_environment_context(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) = 0;
  virtual void get_schema(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name) = 0;
  virtual void get_schema_with_environment_context(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) = 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 alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) = 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 int32_t add_partitions_pspec(const std::vector<PartitionSpec> & 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_partitions_pspec(std::vector<PartitionSpec> & _return, const std::string& db_name, const std::string& tbl_name, const int32_t max_parts) = 0;
  virtual void get_partition_names(std::vector<std::string> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) = 0;
  virtual void get_partitions_ps(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const int16_t max_parts) = 0;
  virtual void get_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_part_specs_by_filter(std::vector<PartitionSpec> & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_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 set_aggr_stats_for(const SetPartitionsStatsRequest& 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;
  virtual void add_dynamic_partitions(const AddDynamicPartitions& rqst) = 0;
  virtual void get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) = 0;
  virtual void get_current_notificationEventId(CurrentNotificationEventId& _return) = 0;
  virtual void fire_listener_event(FireEventResponse& _return, const FireEventRequest& 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 getMetaConf(std::string& /* _return */, const std::string& /* key */) {
    return;
  }
  void setMetaConf(const std::string& /* key */, const std::string& /* value */) {
    return;
  }
  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_fields_with_environment_context(std::vector<FieldSchema> & /* _return */, const std::string& /* db_name */, const std::string& /* table_name */, const EnvironmentContext& /* environment_context */) {
    return;
  }
  void get_schema(std::vector<FieldSchema> & /* _return */, const std::string& /* db_name */, const std::string& /* table_name */) {
    return;
  }
  void get_schema_with_environment_context(std::vector<FieldSchema> & /* _return */, const std::string& /* db_name */, const std::string& /* table_name */, const EnvironmentContext& /* environment_context */) {
    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 alter_table_with_cascade(const std::string& /* dbname */, const std::string& /* tbl_name */, const Table& /* new_tbl */, const bool /* cascade */) {
    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;
  }
  int32_t add_partitions_pspec(const std::vector<PartitionSpec> & /* 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_partitions_pspec(std::vector<PartitionSpec> & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const int32_t /* max_parts */) {
    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_part_specs_by_filter(std::vector<PartitionSpec> & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* filter */, const int32_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 set_aggr_stats_for(const SetPartitionsStatsRequest& /* request */) {
    bool _return = false;
    return _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;
  }
  void add_dynamic_partitions(const AddDynamicPartitions& /* rqst */) {
    return;
  }
  void get_next_notification(NotificationEventResponse& /* _return */, const NotificationEventRequest& /* rqst */) {
    return;
  }
  void get_current_notificationEventId(CurrentNotificationEventId& /* _return */) {
    return;
  }
  void fire_listener_event(FireEventResponse& /* _return */, const FireEventRequest& /* rqst */) {
    return;
  }
};

typedef struct _ThriftHiveMetastore_getMetaConf_args__isset {
  _ThriftHiveMetastore_getMetaConf_args__isset() : key(false) {}
  bool key;
} _ThriftHiveMetastore_getMetaConf_args__isset;

class ThriftHiveMetastore_getMetaConf_args {
 public:

  ThriftHiveMetastore_getMetaConf_args() : key() {
  }

  virtual ~ThriftHiveMetastore_getMetaConf_args() throw() {}

  std::string key;

  _ThriftHiveMetastore_getMetaConf_args__isset __isset;

  void __set_key(const std::string& val) {
    key = val;
  }

  bool operator == (const ThriftHiveMetastore_getMetaConf_args & rhs) const
  {
    if (!(key == rhs.key))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_getMetaConf_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_getMetaConf_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class ThriftHiveMetastore_getMetaConf_pargs {
 public:


  virtual ~ThriftHiveMetastore_getMetaConf_pargs() throw() {}

  const std::string* key;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_getMetaConf_result__isset {
  _ThriftHiveMetastore_getMetaConf_result__isset() : success(false), o1(false) {}
  bool success;
  bool o1;
} _ThriftHiveMetastore_getMetaConf_result__isset;

class ThriftHiveMetastore_getMetaConf_result {
 public:

  ThriftHiveMetastore_getMetaConf_result() : success() {
  }

  virtual ~ThriftHiveMetastore_getMetaConf_result() throw() {}

  std::string success;
  MetaException o1;

  _ThriftHiveMetastore_getMetaConf_result__isset __isset;

  void __set_success(const std::string& val) {
    success = val;
  }

  void __set_o1(const MetaException& val) {
    o1 = val;
  }

  bool operator == (const ThriftHiveMetastore_getMetaConf_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    if (!(o1 == rhs.o1))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_getMetaConf_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_getMetaConf_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_getMetaConf_presult__isset {
  _ThriftHiveMetastore_getMetaConf_presult__isset() : success(false), o1(false) {}
  bool success;
  bool o1;
} _ThriftHiveMetastore_getMetaConf_presult__isset;

class ThriftHiveMetastore_getMetaConf_presult {
 public:


  virtual ~ThriftHiveMetastore_getMetaConf_presult() throw() {}

  std::string* success;
  MetaException o1;

  _ThriftHiveMetastore_getMetaConf_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _ThriftHiveMetastore_setMetaConf_args__isset {
  _ThriftHiveMetastore_setMetaConf_args__isset() : key(false), value(false) {}
  bool key;
  bool value;
} _ThriftHiveMetastore_setMetaConf_args__isset;

class ThriftHiveMetastore_setMetaConf_args {
 public:

  ThriftHiveMetastore_setMetaConf_args() : key(), value() {
  }

  virtual ~ThriftHiveMetastore_setMetaConf_args() throw() {}

  std::string key;
  std::string value;

  _ThriftHiveMetastore_setMetaConf_args__isset __isset;

  void __set_key(const std::string& val) {
    key = val;
  }

  void __set_value(const std::string& val) {
    value = val;
  }

  bool operator == (const ThriftHiveMetastore_setMetaConf_args & rhs) const
  {
    if (!(key == rhs.key))
      return false;
    if (!(value == rhs.value))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_setMetaConf_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_setMetaConf_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class ThriftHiveMetastore_setMetaConf_pargs {
 public:


  virtual ~ThriftHiveMetastore_setMetaConf_pargs() throw() {}

  const std::string* key;
  const std::string* value;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_setMetaConf_result__isset {
  _ThriftHiveMetastore_setMetaConf_result__isset() : o1(false) {}
  bool o1;
} _ThriftHiveMetastore_setMetaConf_result__isset;

class ThriftHiveMetastore_setMetaConf_result {
 public:

  ThriftHiveMetastore_setMetaConf_result() {
  }

  virtual ~ThriftHiveMetastore_setMetaConf_result() throw() {}

  MetaException o1;

  _ThriftHiveMetastore_setMetaConf_result__isset __isset;

  void __set_o1(const MetaException& val) {
    o1 = val;
  }

  bool operator == (const ThriftHiveMetastore_setMetaConf_result & rhs) const
  {
    if (!(o1 == rhs.o1))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_setMetaConf_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_setMetaConf_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_setMetaConf_presult__isset {
  _ThriftHiveMetastore_setMetaConf_presult__isset() : o1(false) {}
  bool o1;
} _ThriftHiveMetastore_setMetaConf_presult__isset;

class ThriftHiveMetastore_setMetaConf_presult {
 public:


  virtual ~ThriftHiveMetastore_setMetaConf_presult() throw() {}

  MetaException o1;

  _ThriftHiveMetastore_setMetaConf_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

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_fields_with_environment_context_args__isset {
  _ThriftHiveMetastore_get_fields_with_environment_context_args__isset() : db_name(false), table_name(false), environment_context(false) {}
  bool db_name;
  bool table_name;
  bool environment_context;
} _ThriftHiveMetastore_get_fields_with_environment_context_args__isset;

class ThriftHiveMetastore_get_fields_with_environment_context_args {
 public:

  ThriftHiveMetastore_get_fields_with_environment_context_args() : db_name(), table_name() {
  }

  virtual ~ThriftHiveMetastore_get_fields_with_environment_context_args() throw() {}

  std::string db_name;
  std::string table_name;
  EnvironmentContext environment_context;

  _ThriftHiveMetastore_get_fields_with_environment_context_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;
  }

  void __set_environment_context(const EnvironmentContext& val) {
    environment_context = val;
  }

  bool operator == (const ThriftHiveMetastore_get_fields_with_environment_context_args & rhs) const
  {
    if (!(db_name == rhs.db_name))
      return false;
    if (!(table_name == rhs.table_name))
      return false;
    if (!(environment_context == rhs.environment_context))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_get_fields_with_environment_context_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_get_fields_with_environment_context_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class ThriftHiveMetastore_get_fields_with_environment_context_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_fields_with_environment_context_pargs() throw() {}

  const std::string* db_name;
  const std::string* table_name;
  const EnvironmentContext* environment_context;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_get_fields_with_environment_context_result__isset {
  _ThriftHiveMetastore_get_fields_with_environment_context_result__isset() : success(false), o1(false), o2(false), o3(false) {}
  bool success;
  bool o1;
  bool o2;
  bool o3;
} _ThriftHiveMetastore_get_fields_with_environment_context_result__isset;

class ThriftHiveMetastore_get_fields_with_environment_context_result {
 public:

  ThriftHiveMetastore_get_fields_with_environment_context_result() {
  }

  virtual ~ThriftHiveMetastore_get_fields_with_environment_context_result() throw() {}

  std::vector<FieldSchema>  success;
  MetaException o1;
  UnknownTableException o2;
  UnknownDBException o3;

  _ThriftHiveMetastore_get_fields_with_environment_context_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_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_get_fields_with_environment_context_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_get_fields_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_get_fields_with_environment_context_presult__isset {
  _ThriftHiveMetastore_get_fields_with_environment_context_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
  bool success;
  bool o1;
  bool o2;
  bool o3;
} _ThriftHiveMetastore_get_fields_with_environment_context_presult__isset;

class ThriftHiveMetastore_get_fields_with_environment_context_presult {
 public:


  virtual ~ThriftHiveMetastore_get_fields_with_environment_context_presult() throw() {}

  std::vector<FieldSchema> * success;
  MetaException o1;
  UnknownTableException o2;
  UnknownDBException o3;

  _ThriftHiveMetastore_get_fields_with_environment_context_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_get_schema_with_environment_context_args__isset {
  _ThriftHiveMetastore_get_schema_with_environment_context_args__isset() : db_name(false), table_name(false), environment_context(false) {}
  bool db_name;
  bool table_name;
  bool environment_context;
} _ThriftHiveMetastore_get_schema_with_environment_context_args__isset;

class ThriftHiveMetastore_get_schema_with_environment_context_args {
 public:

  ThriftHiveMetastore_get_schema_with_environment_context_args() : db_name(), table_name() {
  }

  virtual ~ThriftHiveMetastore_get_schema_with_environment_context_args() throw() {}

  std::string db_name;
  std::string table_name;
  EnvironmentContext environment_context;

  _ThriftHiveMetastore_get_schema_with_environment_context_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;
  }

  void __set_environment_context(const EnvironmentContext& val) {
    environment_context = val;
  }

  bool operator == (const ThriftHiveMetastore_get_schema_with_environment_context_args & rhs) const
  {
    if (!(db_name == rhs.db_name))
      return false;
    if (!(table_name == rhs.table_name))
      return false;
    if (!(environment_context == rhs.environment_context))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_get_schema_with_environment_context_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_get_schema_with_environment_context_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class ThriftHiveMetastore_get_schema_with_environment_context_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_schema_with_environment_context_pargs() throw() {}

  const std::string* db_name;
  const std::string* table_name;
  const EnvironmentContext* environment_context;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_get_schema_with_environment_context_result__isset {
  _ThriftHiveMetastore_get_schema_with_environment_context_result__isset() : success(false), o1(false), o2(false), o3(false) {}
  bool success;
  bool o1;
  bool o2;
  bool o3;
} _ThriftHiveMetastore_get_schema_with_environment_context_result__isset;

class ThriftHiveMetastore_get_schema_with_environment_context_result {
 public:

  ThriftHiveMetastore_get_schema_with_environment_context_result() {
  }

  virtual ~ThriftHiveMetastore_get_schema_with_environment_context_result() throw() {}

  std::vector<FieldSchema>  success;
  MetaException o1;
  UnknownTableException o2;
  UnknownDBException o3;

  _ThriftHiveMetastore_get_schema_with_environment_context_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_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_get_schema_with_environment_context_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_get_schema_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_get_schema_with_environment_context_presult__isset {
  _ThriftHiveMetastore_get_schema_with_environment_context_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
  bool success;
  bool o1;
  bool o2;
  bool o3;
} _ThriftHiveMetastore_get_schema_with_environment_context_presult__isset;

class ThriftHiveMetastore_get_schema_with_environment_context_presult {
 public:


  virtual ~ThriftHiveMetastore_get_schema_with_environment_context_presult() throw() {}

  std::vector<FieldSchema> * success;
  MetaException o1;
  UnknownTableException o2;
  UnknownDBException o3;

  _ThriftHiveMetastore_get_schema_with_environment_context_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_alter_table_with_cascade_args__isset {
  _ThriftHiveMetastore_alter_table_with_cascade_args__isset() : dbname(false), tbl_name(false), new_tbl(false), cascade(false) {}
  bool dbname;
  bool tbl_name;
  bool new_tbl;
  bool cascade;
} _ThriftHiveMetastore_alter_table_with_cascade_args__isset;

class ThriftHiveMetastore_alter_table_with_cascade_args {
 public:

  ThriftHiveMetastore_alter_table_with_cascade_args() : dbname(), tbl_name(), cascade(0) {
  }

  virtual ~ThriftHiveMetastore_alter_table_with_cascade_args() throw() {}

  std::string dbname;
  std::string tbl_name;
  Table new_tbl;
  bool cascade;

  _ThriftHiveMetastore_alter_table_with_cascade_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_cascade(const bool val) {
    cascade = val;
  }

  bool operator == (const ThriftHiveMetastore_alter_table_with_cascade_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 (!(cascade == rhs.cascade))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_alter_table_with_cascade_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_alter_table_with_cascade_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class ThriftHiveMetastore_alter_table_with_cascade_pargs {
 public:


  virtual ~ThriftHiveMetastore_alter_table_with_cascade_pargs() throw() {}

  const std::string* dbname;
  const std::string* tbl_name;
  const Table* new_tbl;
  const bool* cascade;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_alter_table_with_cascade_result__isset {
  _ThriftHiveMetastore_alter_table_with_cascade_result__isset() : o1(false), o2(false) {}
  bool o1;
  bool o2;
} _ThriftHiveMetastore_alter_table_with_cascade_result__isset;

class ThriftHiveMetastore_alter_table_with_cascade_result {
 public:

  ThriftHiveMetastore_alter_table_with_cascade_result() {
  }

  virtual ~ThriftHiveMetastore_alter_table_with_cascade_result() throw() {}

  InvalidOperationException o1;
  MetaException o2;

  _ThriftHiveMetastore_alter_table_with_cascade_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_cascade_result & rhs) const
  {
    if (!(o1 == rhs.o1))
      return false;
    if (!(o2 == rhs.o2))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_alter_table_with_cascade_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_alter_table_with_cascade_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_cascade_presult__isset {
  _ThriftHiveMetastore_alter_table_with_cascade_presult__isset() : o1(false), o2(false) {}
  bool o1;
  bool o2;
} _ThriftHiveMetastore_alter_table_with_cascade_presult__isset;

class ThriftHiveMetastore_alter_table_with_cascade_presult {
 public:


  virtual ~ThriftHiveMetastore_alter_table_with_cascade_presult() throw() {}

  InvalidOperationException o1;
  MetaException o2;

  _ThriftHiveMetastore_alter_table_with_cascade_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_add_partitions_pspec_args__isset {
  _ThriftHiveMetastore_add_partitions_pspec_args__isset() : new_parts(false) {}
  bool new_parts;
} _ThriftHiveMetastore_add_partitions_pspec_args__isset;

class ThriftHiveMetastore_add_partitions_pspec_args {
 public:

  ThriftHiveMetastore_add_partitions_pspec_args() {
  }

  virtual ~ThriftHiveMetastore_add_partitions_pspec_args() throw() {}

  std::vector<PartitionSpec>  new_parts;

  _ThriftHiveMetastore_add_partitions_pspec_args__isset __isset;

  void __set_new_parts(const std::vector<PartitionSpec> & val) {
    new_parts = val;
  }

  bool operator == (const ThriftHiveMetastore_add_partitions_pspec_args & rhs) const
  {
    if (!(new_parts == rhs.new_parts))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_add_partitions_pspec_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_add_partitions_pspec_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class ThriftHiveMetastore_add_partitions_pspec_pargs {
 public:


  virtual ~ThriftHiveMetastore_add_partitions_pspec_pargs() throw() {}

  const std::vector<PartitionSpec> * new_parts;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_add_partitions_pspec_result__isset {
  _ThriftHiveMetastore_add_partitions_pspec_result__isset() : success(false), o1(false), o2(false), o3(false) {}
  bool success;
  bool o1;
  bool o2;
  bool o3;
} _ThriftHiveMetastore_add_partitions_pspec_result__isset;

class ThriftHiveMetastore_add_partitions_pspec_result {
 public:

  ThriftHiveMetastore_add_partitions_pspec_result() : success(0) {
  }

  virtual ~ThriftHiveMetastore_add_partitions_pspec_result() throw() {}

  int32_t success;
  InvalidObjectException o1;
  AlreadyExistsException o2;
  MetaException o3;

  _ThriftHiveMetastore_add_partitions_pspec_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_pspec_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_pspec_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_add_partitions_pspec_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_add_partitions_pspec_presult__isset {
  _ThriftHiveMetastore_add_partitions_pspec_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
  bool success;
  bool o1;
  bool o2;
  bool o3;
} _ThriftHiveMetastore_add_partitions_pspec_presult__isset;

class ThriftHiveMetastore_add_partitions_pspec_presult {
 public:


  virtual ~ThriftHiveMetastore_add_partitions_pspec_presult() throw() {}

  int32_t* success;
  InvalidObjectException o1;
  AlreadyExistsException o2;
  MetaException o3;

  _ThriftHiveMetastore_add_partitions_pspec_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_partitions_pspec_args__isset {
  _ThriftHiveMetastore_get_partitions_pspec_args__isset() : db_name(false), tbl_name(false), max_parts(true) {}
  bool db_name;
  bool tbl_name;
  bool max_parts;
} _ThriftHiveMetastore_get_partitions_pspec_args__isset;

class ThriftHiveMetastore_get_partitions_pspec_args {
 public:

  ThriftHiveMetastore_get_partitions_pspec_args() : db_name(), tbl_name(), max_parts(-1) {
  }

  virtual ~ThriftHiveMetastore_get_partitions_pspec_args() throw() {}

  std::string db_name;
  std::string tbl_name;
  int32_t max_parts;

  _ThriftHiveMetastore_get_partitions_pspec_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 int32_t val) {
    max_parts = val;
  }

  bool operator == (const ThriftHiveMetastore_get_partitions_pspec_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_pspec_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_get_partitions_pspec_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class ThriftHiveMetastore_get_partitions_pspec_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_partitions_pspec_pargs() throw() {}

  const std::string* db_name;
  const std::string* tbl_name;
  const int32_t* max_parts;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_get_partitions_pspec_result__isset {
  _ThriftHiveMetastore_get_partitions_pspec_result__isset() : success(false), o1(false), o2(false) {}
  bool success;
  bool o1;
  bool o2;
} _ThriftHiveMetastore_get_partitions_pspec_result__isset;

class ThriftHiveMetastore_get_partitions_pspec_result {
 public:

  ThriftHiveMetastore_get_partitions_pspec_result() {
  }

  virtual ~ThriftHiveMetastore_get_partitions_pspec_result() throw() {}

  std::vector<PartitionSpec>  success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_partitions_pspec_result__isset __isset;

  void __set_success(const std::vector<PartitionSpec> & 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_pspec_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_pspec_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_get_partitions_pspec_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_get_partitions_pspec_presult__isset {
  _ThriftHiveMetastore_get_partitions_pspec_presult__isset() : success(false), o1(false), o2(false) {}
  bool success;
  bool o1;
  bool o2;
} _ThriftHiveMetastore_get_partitions_pspec_presult__isset;

class ThriftHiveMetastore_get_partitions_pspec_presult {
 public:


  virtual ~ThriftHiveMetastore_get_partitions_pspec_presult() throw() {}

  std::vector<PartitionSpec> * success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_partitions_pspec_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_part_specs_by_filter_args__isset {
  _ThriftHiveMetastore_get_part_specs_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_part_specs_by_filter_args__isset;

class ThriftHiveMetastore_get_part_specs_by_filter_args {
 public:

  ThriftHiveMetastore_get_part_specs_by_filter_args() : db_name(), tbl_name(), filter(), max_parts(-1) {
  }

  virtual ~ThriftHiveMetastore_get_part_specs_by_filter_args() throw() {}

  std::string db_name;
  std::string tbl_name;
  std::string filter;
  int32_t max_parts;

  _ThriftHiveMetastore_get_part_specs_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 int32_t val) {
    max_parts = val;
  }

  bool operator == (const ThriftHiveMetastore_get_part_specs_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_part_specs_by_filter_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_get_part_specs_by_filter_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class ThriftHiveMetastore_get_part_specs_by_filter_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_part_specs_by_filter_pargs() throw() {}

  const std::string* db_name;
  const std::string* tbl_name;
  const std::string* filter;
  const int32_t* max_parts;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_get_part_specs_by_filter_result__isset {
  _ThriftHiveMetastore_get_part_specs_by_filter_result__isset() : success(false), o1(false), o2(false) {}
  bool success;
  bool o1;
  bool o2;
} _ThriftHiveMetastore_get_part_specs_by_filter_result__isset;

class ThriftHiveMetastore_get_part_specs_by_filter_result {
 public:

  ThriftHiveMetastore_get_part_specs_by_filter_result() {
  }

  virtual ~ThriftHiveMetastore_get_part_specs_by_filter_result() throw() {}

  std::vector<PartitionSpec>  success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_part_specs_by_filter_result__isset __isset;

  void __set_success(const std::vector<PartitionSpec> & val) {
    success = val;
  }

  void __set_o1(const MetaException& val) {
    o1 = val;
  }

  void __set_o2(const NoSuchObjectException& val) {
    o2 = val;
  }

  bool operator == (const ThriftHiveMetastore_get_part_specs_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_part_specs_by_filter_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_get_part_specs_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_part_specs_by_filter_presult__isset {
  _ThriftHiveMetastore_get_part_specs_by_filter_presult__isset() : success(false), o1(false), o2(false) {}
  bool success;
  bool o1;
  bool o2;
} _ThriftHiveMetastore_get_part_specs_by_filter_presult__isset;

class ThriftHiveMetastore_get_part_specs_by_filter_presult {
 public:


  virtual ~ThriftHiveMetastore_get_part_specs_by_filter_presult() throw() {}

  std::vector<PartitionSpec> * success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_part_specs_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_set_aggr_stats_for_args__isset {
  _ThriftHiveMetastore_set_aggr_stats_for_args__isset() : request(false) {}
  bool request;
} _ThriftHiveMetastore_set_aggr_stats_for_args__isset;

class ThriftHiveMetastore_set_aggr_stats_for_args {
 public:

  ThriftHiveMetastore_set_aggr_stats_for_args() {
  }

  virtual ~ThriftHiveMetastore_set_aggr_stats_for_args() throw() {}

  SetPartitionsStatsRequest request;

  _ThriftHiveMetastore_set_aggr_stats_for_args__isset __isset;

  void __set_request(const SetPartitionsStatsRequest& val) {
    request = val;
  }

  bool operator == (const ThriftHiveMetastore_set_aggr_stats_for_args & rhs) const
  {
    if (!(request == rhs.request))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_set_aggr_stats_for_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_set_aggr_stats_for_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class ThriftHiveMetastore_set_aggr_stats_for_pargs {
 public:


  virtual ~ThriftHiveMetastore_set_aggr_stats_for_pargs() throw() {}

  const SetPartitionsStatsRequest* request;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_set_aggr_stats_for_result__isset {
  _ThriftHiveMetastore_set_aggr_stats_for_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
  bool success;
  bool o1;
  bool o2;
  bool o3;
  bool o4;
} _ThriftHiveMetastore_set_aggr_stats_for_result__isset;

class ThriftHiveMetastore_set_aggr_stats_for_result {
 public:

  ThriftHiveMetastore_set_aggr_stats_for_result() : success(0) {
  }

  virtual ~ThriftHiveMetastore_set_aggr_stats_for_result() throw() {}

  bool success;
  NoSuchObjectException o1;
  InvalidObjectException o2;
  MetaException o3;
  InvalidInputException o4;

  _ThriftHiveMetastore_set_aggr_stats_for_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_set_aggr_stats_for_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_set_aggr_stats_for_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_set_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_set_aggr_stats_for_presult__isset {
  _ThriftHiveMetastore_set_aggr_stats_for_presult__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
  bool success;
  bool o1;
  bool o2;
  bool o3;
  bool o4;
} _ThriftHiveMetastore_set_aggr_stats_for_presult__isset;

class ThriftHiveMetastore_set_aggr_stats_for_presult {
 public:


  virtual ~ThriftHiveMetastore_set_aggr_stats_for_presult() throw() {}

  bool* success;
  NoSuchObjectException o1;
  InvalidObjectException o2;
  MetaException o3;
  InvalidInputException o4;

  _ThriftHiveMetastore_set_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);

};

typedef struct _ThriftHiveMetastore_add_dynamic_partitions_args__isset {
  _ThriftHiveMetastore_add_dynamic_partitions_args__isset() : rqst(false) {}
  bool rqst;
} _ThriftHiveMetastore_add_dynamic_partitions_args__isset;

class ThriftHiveMetastore_add_dynamic_partitions_args {
 public:

  ThriftHiveMetastore_add_dynamic_partitions_args() {
  }

  virtual ~ThriftHiveMetastore_add_dynamic_partitions_args() throw() {}

  AddDynamicPartitions rqst;

  _ThriftHiveMetastore_add_dynamic_partitions_args__isset __isset;

  void __set_rqst(const AddDynamicPartitions& val) {
    rqst = val;
  }

  bool operator == (const ThriftHiveMetastore_add_dynamic_partitions_args & rhs) const
  {
    if (!(rqst == rhs.rqst))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_add_dynamic_partitions_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_add_dynamic_partitions_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class ThriftHiveMetastore_add_dynamic_partitions_pargs {
 public:


  virtual ~ThriftHiveMetastore_add_dynamic_partitions_pargs() throw() {}

  const AddDynamicPartitions* rqst;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_add_dynamic_partitions_result__isset {
  _ThriftHiveMetastore_add_dynamic_partitions_result__isset() : o1(false), o2(false) {}
  bool o1;
  bool o2;
} _ThriftHiveMetastore_add_dynamic_partitions_result__isset;

class ThriftHiveMetastore_add_dynamic_partitions_result {
 public:

  ThriftHiveMetastore_add_dynamic_partitions_result() {
  }

  virtual ~ThriftHiveMetastore_add_dynamic_partitions_result() throw() {}

  NoSuchTxnException o1;
  TxnAbortedException o2;

  _ThriftHiveMetastore_add_dynamic_partitions_result__isset __isset;

  void __set_o1(const NoSuchTxnException& val) {
    o1 = val;
  }

  void __set_o2(const TxnAbortedException& val) {
    o2 = val;
  }

  bool operator == (const ThriftHiveMetastore_add_dynamic_partitions_result & rhs) const
  {
    if (!(o1 == rhs.o1))
      return false;
    if (!(o2 == rhs.o2))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_add_dynamic_partitions_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_add_dynamic_partitions_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_add_dynamic_partitions_presult__isset {
  _ThriftHiveMetastore_add_dynamic_partitions_presult__isset() : o1(false), o2(false) {}
  bool o1;
  bool o2;
} _ThriftHiveMetastore_add_dynamic_partitions_presult__isset;

class ThriftHiveMetastore_add_dynamic_partitions_presult {
 public:


  virtual ~ThriftHiveMetastore_add_dynamic_partitions_presult() throw() {}

  NoSuchTxnException o1;
  TxnAbortedException o2;

  _ThriftHiveMetastore_add_dynamic_partitions_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _ThriftHiveMetastore_get_next_notification_args__isset {
  _ThriftHiveMetastore_get_next_notification_args__isset() : rqst(false) {}
  bool rqst;
} _ThriftHiveMetastore_get_next_notification_args__isset;

class ThriftHiveMetastore_get_next_notification_args {
 public:

  ThriftHiveMetastore_get_next_notification_args() {
  }

  virtual ~ThriftHiveMetastore_get_next_notification_args() throw() {}

  NotificationEventRequest rqst;

  _ThriftHiveMetastore_get_next_notification_args__isset __isset;

  void __set_rqst(const NotificationEventRequest& val) {
    rqst = val;
  }

  bool operator == (const ThriftHiveMetastore_get_next_notification_args & rhs) const
  {
    if (!(rqst == rhs.rqst))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_get_next_notification_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_get_next_notification_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class ThriftHiveMetastore_get_next_notification_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_next_notification_pargs() throw() {}

  const NotificationEventRequest* rqst;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_get_next_notification_result__isset {
  _ThriftHiveMetastore_get_next_notification_result__isset() : success(false) {}
  bool success;
} _ThriftHiveMetastore_get_next_notification_result__isset;

class ThriftHiveMetastore_get_next_notification_result {
 public:

  ThriftHiveMetastore_get_next_notification_result() {
  }

  virtual ~ThriftHiveMetastore_get_next_notification_result() throw() {}

  NotificationEventResponse success;

  _ThriftHiveMetastore_get_next_notification_result__isset __isset;

  void __set_success(const NotificationEventResponse& val) {
    success = val;
  }

  bool operator == (const ThriftHiveMetastore_get_next_notification_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_get_next_notification_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_get_next_notification_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_get_next_notification_presult__isset {
  _ThriftHiveMetastore_get_next_notification_presult__isset() : success(false) {}
  bool success;
} _ThriftHiveMetastore_get_next_notification_presult__isset;

class ThriftHiveMetastore_get_next_notification_presult {
 public:


  virtual ~ThriftHiveMetastore_get_next_notification_presult() throw() {}

  NotificationEventResponse* success;

  _ThriftHiveMetastore_get_next_notification_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};


class ThriftHiveMetastore_get_current_notificationEventId_args {
 public:

  ThriftHiveMetastore_get_current_notificationEventId_args() {
  }

  virtual ~ThriftHiveMetastore_get_current_notificationEventId_args() throw() {}


  bool operator == (const ThriftHiveMetastore_get_current_notificationEventId_args & /* rhs */) const
  {
    return true;
  }
  bool operator != (const ThriftHiveMetastore_get_current_notificationEventId_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_get_current_notificationEventId_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class ThriftHiveMetastore_get_current_notificationEventId_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_current_notificationEventId_pargs() throw() {}


  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_get_current_notificationEventId_result__isset {
  _ThriftHiveMetastore_get_current_notificationEventId_result__isset() : success(false) {}
  bool success;
} _ThriftHiveMetastore_get_current_notificationEventId_result__isset;

class ThriftHiveMetastore_get_current_notificationEventId_result {
 public:

  ThriftHiveMetastore_get_current_notificationEventId_result() {
  }

  virtual ~ThriftHiveMetastore_get_current_notificationEventId_result() throw() {}

  CurrentNotificationEventId success;

  _ThriftHiveMetastore_get_current_notificationEventId_result__isset __isset;

  void __set_success(const CurrentNotificationEventId& val) {
    success = val;
  }

  bool operator == (const ThriftHiveMetastore_get_current_notificationEventId_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_get_current_notificationEventId_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_get_current_notificationEventId_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_get_current_notificationEventId_presult__isset {
  _ThriftHiveMetastore_get_current_notificationEventId_presult__isset() : success(false) {}
  bool success;
} _ThriftHiveMetastore_get_current_notificationEventId_presult__isset;

class ThriftHiveMetastore_get_current_notificationEventId_presult {
 public:


  virtual ~ThriftHiveMetastore_get_current_notificationEventId_presult() throw() {}

  CurrentNotificationEventId* success;

  _ThriftHiveMetastore_get_current_notificationEventId_presult__isset __isset;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);

};

typedef struct _ThriftHiveMetastore_fire_listener_event_args__isset {
  _ThriftHiveMetastore_fire_listener_event_args__isset() : rqst(false) {}
  bool rqst;
} _ThriftHiveMetastore_fire_listener_event_args__isset;

class ThriftHiveMetastore_fire_listener_event_args {
 public:

  ThriftHiveMetastore_fire_listener_event_args() {
  }

  virtual ~ThriftHiveMetastore_fire_listener_event_args() throw() {}

  FireEventRequest rqst;

  _ThriftHiveMetastore_fire_listener_event_args__isset __isset;

  void __set_rqst(const FireEventRequest& val) {
    rqst = val;
  }

  bool operator == (const ThriftHiveMetastore_fire_listener_event_args & rhs) const
  {
    if (!(rqst == rhs.rqst))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_fire_listener_event_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_fire_listener_event_args & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};


class ThriftHiveMetastore_fire_listener_event_pargs {
 public:


  virtual ~ThriftHiveMetastore_fire_listener_event_pargs() throw() {}

  const FireEventRequest* rqst;

  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_fire_listener_event_result__isset {
  _ThriftHiveMetastore_fire_listener_event_result__isset() : success(false) {}
  bool success;
} _ThriftHiveMetastore_fire_listener_event_result__isset;

class ThriftHiveMetastore_fire_listener_event_result {
 public:

  ThriftHiveMetastore_fire_listener_event_result() {
  }

  virtual ~ThriftHiveMetastore_fire_listener_event_result() throw() {}

  FireEventResponse success;

  _ThriftHiveMetastore_fire_listener_event_result__isset __isset;

  void __set_success(const FireEventResponse& val) {
    success = val;
  }

  bool operator == (const ThriftHiveMetastore_fire_listener_event_result & rhs) const
  {
    if (!(success == rhs.success))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_fire_listener_event_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_fire_listener_event_result & ) const;

  uint32_t read(::apache::thrift::protocol::TProtocol* iprot);
  uint32_t write(::apache::thrift::protocol::TProtocol* oprot) const;

};

typedef struct _ThriftHiveMetastore_fire_listener_event_presult__isset {
  _ThriftHiveMetastore_fire_listener_event_presult__isset() : success(false) {}
  bool success;
} _ThriftHiveMetastore_fire_listener_event_presult__isset;

class ThriftHiveMetastore_fire_listener_event_presult {
 public:


  virtual ~ThriftHiveMetastore_fire_listener_event_presult() throw() {}

  FireEventResponse* success;

  _ThriftHiveMetastore_fire_listener_event_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 getMetaConf(std::string& _return, const std::string& key);
  void send_getMetaConf(const std::string& key);
  void recv_getMetaConf(std::string& _return);
  void setMetaConf(const std::string& key, const std::string& value);
  void send_setMetaConf(const std::string& key, const std::string& value);
  void recv_setMetaConf();
  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_fields_with_environment_context(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context);
  void send_get_fields_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context);
  void recv_get_fields_with_environment_context(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 get_schema_with_environment_context(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context);
  void send_get_schema_with_environment_context(const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context);
  void recv_get_schema_with_environment_context(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 alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade);
  void send_alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade);
  void recv_alter_table_with_cascade();
  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();
  int32_t add_partitions_pspec(const std::vector<PartitionSpec> & new_parts);
  void send_add_partitions_pspec(const std::vector<PartitionSpec> & new_parts);
  int32_t recv_add_partitions_pspec();
  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_partitions_pspec(std::vector<PartitionSpec> & _return, const std::string& db_name, const std::string& tbl_name, const int32_t max_parts);
  void send_get_partitions_pspec(const std::string& db_name, const std::string& tbl_name, const int32_t max_parts);
  void recv_get_partitions_pspec(std::vector<PartitionSpec> & _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_part_specs_by_filter(std::vector<PartitionSpec> & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts);
  void send_get_part_specs_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts);
  void recv_get_part_specs_by_filter(std::vector<PartitionSpec> & _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 set_aggr_stats_for(const SetPartitionsStatsRequest& request);
  void send_set_aggr_stats_for(const SetPartitionsStatsRequest& request);
  bool recv_set_aggr_stats_for();
  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);
  void add_dynamic_partitions(const AddDynamicPartitions& rqst);
  void send_add_dynamic_partitions(const AddDynamicPartitions& rqst);
  void recv_add_dynamic_partitions();
  void get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst);
  void send_get_next_notification(const NotificationEventRequest& rqst);
  void recv_get_next_notification(NotificationEventResponse& _return);
  void get_current_notificationEventId(CurrentNotificationEventId& _return);
  void send_get_current_notificationEventId();
  void recv_get_current_notificationEventId(CurrentNotificationEventId& _return);
  void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst);
  void send_fire_listener_event(const FireEventRequest& rqst);
  void recv_fire_listener_event(FireEventResponse& _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_getMetaConf(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_setMetaConf(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  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_fields_with_environment_context(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_get_schema_with_environment_context(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_alter_table_with_cascade(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_add_partitions_pspec(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_partitions_pspec(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_part_specs_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_set_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);
  void process_add_dynamic_partitions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_next_notification(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_current_notificationEventId(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_fire_listener_event(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_["getMetaConf"] = &ThriftHiveMetastoreProcessor::process_getMetaConf;
    processMap_["setMetaConf"] = &ThriftHiveMetastoreProcessor::process_setMetaConf;
    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_fields_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_get_fields_with_environment_context;
    processMap_["get_schema"] = &ThriftHiveMetastoreProcessor::process_get_schema;
    processMap_["get_schema_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_get_schema_with_environment_context;
    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_["alter_table_with_cascade"] = &ThriftHiveMetastoreProcessor::process_alter_table_with_cascade;
    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_["add_partitions_pspec"] = &ThriftHiveMetastoreProcessor::process_add_partitions_pspec;
    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_partitions_pspec"] = &ThriftHiveMetastoreProcessor::process_get_partitions_pspec;
    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_part_specs_by_filter"] = &ThriftHiveMetastoreProcessor::process_get_part_specs_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_["set_aggr_stats_for"] = &ThriftHiveMetastoreProcessor::process_set_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;
    processMap_["add_dynamic_partitions"] = &ThriftHiveMetastoreProcessor::process_add_dynamic_partitions;
    processMap_["get_next_notification"] = &ThriftHiveMetastoreProcessor::process_get_next_notification;
    processMap_["get_current_notificationEventId"] = &ThriftHiveMetastoreProcessor::process_get_current_notificationEventId;
    processMap_["fire_listener_event"] = &ThriftHiveMetastoreProcessor::process_fire_listener_event;
  }

  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 getMetaConf(std::string& _return, const std::string& key) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->getMetaConf(_return, key);
    }
    ifaces_[i]->getMetaConf(_return, key);
    return;
  }

  void setMetaConf(const std::string& key, const std::string& value) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->setMetaConf(key, value);
    }
    ifaces_[i]->setMetaConf(key, value);
  }

  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_fields_with_environment_context(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_fields_with_environment_context(_return, db_name, table_name, environment_context);
    }
    ifaces_[i]->get_fields_with_environment_context(_return, db_name, table_name, environment_context);
    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 get_schema_with_environment_context(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_schema_with_environment_context(_return, db_name, table_name, environment_context);
    }
    ifaces_[i]->get_schema_with_environment_context(_return, db_name, table_name, environment_context);
    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 alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->alter_table_with_cascade(dbname, tbl_name, new_tbl, cascade);
    }
    ifaces_[i]->alter_table_with_cascade(dbname, tbl_name, new_tbl, cascade);
  }

  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);
  }

  int32_t add_partitions_pspec(const std::vector<PartitionSpec> & new_parts) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->add_partitions_pspec(new_parts);
    }
    return ifaces_[i]->add_partitions_pspec(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_partitions_pspec(std::vector<PartitionSpec> & _return, const std::string& db_name, const std::string& tbl_name, const int32_t max_parts) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_partitions_pspec(_return, db_name, tbl_name, max_parts);
    }
    ifaces_[i]->get_partitions_pspec(_return, db_name, tbl_name, max_parts);
    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_part_specs_by_filter(std::vector<PartitionSpec> & _return, const std::string& db_name, const std::string& tbl_name, const std::string& filter, const int32_t max_parts) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_part_specs_by_filter(_return, db_name, tbl_name, filter, max_parts);
    }
    ifaces_[i]->get_part_specs_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 set_aggr_stats_for(const SetPartitionsStatsRequest& request) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->set_aggr_stats_for(request);
    }
    return ifaces_[i]->set_aggr_stats_for(request);
  }

  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;
  }

  void add_dynamic_partitions(const AddDynamicPartitions& rqst) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->add_dynamic_partitions(rqst);
    }
    ifaces_[i]->add_dynamic_partitions(rqst);
  }

  void get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_next_notification(_return, rqst);
    }
    ifaces_[i]->get_next_notification(_return, rqst);
    return;
  }

  void get_current_notificationEventId(CurrentNotificationEventId& _return) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_current_notificationEventId(_return);
    }
    ifaces_[i]->get_current_notificationEventId(_return);
    return;
  }

  void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->fire_listener_event(_return, rqst);
    }
    ifaces_[i]->fire_listener_event(_return, rqst);
    return;
  }

};

}}} // namespace

#endif