/**
 * Autogenerated by Thrift Compiler (0.16.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 <thrift/async/TConcurrentClientSyncInfo.h>
#include <memory>
#include "hive_metastore_types.h"
#include "FacebookService.h"

namespace Apache { namespace Hadoop { namespace Hive {

#ifdef _MSC_VER
  #pragma warning( push )
  #pragma warning (disable : 4250 ) //inheriting methods via dominance 
#endif

/**
 * This interface is live.
 */
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 bool init_schema(const std::string& dbType, const std::string& username, const std::string& password) = 0;
  virtual void create_catalog(const CreateCatalogRequest& catalog) = 0;
  virtual void alter_catalog(const AlterCatalogRequest& rqst) = 0;
  virtual void get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName) = 0;
  virtual void get_catalogs(GetCatalogsResponse& _return) = 0;
  virtual void drop_catalog(const DropCatalogRequest& catName) = 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 create_table_with_constraints(const Table& tbl, const std::vector<SQLPrimaryKey> & primaryKeys, const std::vector<SQLForeignKey> & foreignKeys, const std::vector<SQLUniqueConstraint> & uniqueConstraints, const std::vector<SQLNotNullConstraint> & notNullConstraints, const std::vector<SQLDefaultConstraint> & defaultConstraints, const std::vector<SQLCheckConstraint> & checkConstraints) = 0;
  virtual void drop_constraint(const DropConstraintRequest& req) = 0;
  virtual void add_primary_key(const AddPrimaryKeyRequest& req) = 0;
  virtual void add_foreign_key(const AddForeignKeyRequest& req) = 0;
  virtual void add_unique_constraint(const AddUniqueConstraintRequest& req) = 0;
  virtual void add_not_null_constraint(const AddNotNullConstraintRequest& req) = 0;
  virtual void add_default_constraint(const AddDefaultConstraintRequest& req) = 0;
  virtual void add_check_constraint(const AddCheckConstraintRequest& req) = 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 truncate_table(const std::string& dbName, const std::string& tableName, const std::vector<std::string> & partNames) = 0;
  virtual void get_tables(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern) = 0;
  virtual void get_tables_by_type(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType) = 0;
  virtual void get_materialized_views_for_rewriting(std::vector<std::string> & _return, const std::string& db_name) = 0;
  virtual void get_table_meta(std::vector<TableMeta> & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector<std::string> & tbl_types) = 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_req(GetTableResult& _return, const GetTableRequest& req) = 0;
  virtual void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req) = 0;
  virtual void get_materialization_invalidation_info(Materialization& _return, const CreationMetadata& creation_metadata, const std::string& validTxnList) = 0;
  virtual void update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) = 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 exchange_partitions(std::vector<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_partition_values(PartitionValuesResponse& _return, const PartitionValuesRequest& request) = 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 int32_t get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter) = 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_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts, const EnvironmentContext& environment_context) = 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 get_primary_keys(PrimaryKeysResponse& _return, const PrimaryKeysRequest& request) = 0;
  virtual void get_foreign_keys(ForeignKeysResponse& _return, const ForeignKeysRequest& request) = 0;
  virtual void get_unique_constraints(UniqueConstraintsResponse& _return, const UniqueConstraintsRequest& request) = 0;
  virtual void get_not_null_constraints(NotNullConstraintsResponse& _return, const NotNullConstraintsRequest& request) = 0;
  virtual void get_default_constraints(DefaultConstraintsResponse& _return, const DefaultConstraintsRequest& request) = 0;
  virtual void get_check_constraints(CheckConstraintsResponse& _return, const CheckConstraintsRequest& request) = 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 void get_all_functions(GetAllFunctionsResponse& _return) = 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 refresh_privileges(GrantRevokePrivilegeResponse& _return, const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest) = 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 bool add_token(const std::string& token_identifier, const std::string& delegation_token) = 0;
  virtual bool remove_token(const std::string& token_identifier) = 0;
  virtual void get_token(std::string& _return, const std::string& token_identifier) = 0;
  virtual void get_all_token_identifiers(std::vector<std::string> & _return) = 0;
  virtual int32_t add_master_key(const std::string& key) = 0;
  virtual void update_master_key(const int32_t seq_number, const std::string& key) = 0;
  virtual bool remove_master_key(const int32_t key_seq) = 0;
  virtual void get_master_keys(std::vector<std::string> & _return) = 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 abort_txns(const AbortTxnsRequest& rqst) = 0;
  virtual void commit_txn(const CommitTxnRequest& rqst) = 0;
  virtual void repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst) = 0;
  virtual void get_valid_write_ids(GetValidWriteIdsResponse& _return, const GetValidWriteIdsRequest& rqst) = 0;
  virtual void allocate_table_write_ids(AllocateTableWriteIdsResponse& _return, const AllocateTableWriteIdsRequest& 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 compact2(CompactionResponse& _return, 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 get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) = 0;
  virtual void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) = 0;
  virtual void flushCache() = 0;
  virtual void cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) = 0;
  virtual void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) = 0;
  virtual void get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) = 0;
  virtual void put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) = 0;
  virtual void clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) = 0;
  virtual void cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req) = 0;
  virtual void get_metastore_db_uuid(std::string& _return) = 0;
  virtual void create_resource_plan(WMCreateResourcePlanResponse& _return, const WMCreateResourcePlanRequest& request) = 0;
  virtual void get_resource_plan(WMGetResourcePlanResponse& _return, const WMGetResourcePlanRequest& request) = 0;
  virtual void get_active_resource_plan(WMGetActiveResourcePlanResponse& _return, const WMGetActiveResourcePlanRequest& request) = 0;
  virtual void get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const WMGetAllResourcePlanRequest& request) = 0;
  virtual void alter_resource_plan(WMAlterResourcePlanResponse& _return, const WMAlterResourcePlanRequest& request) = 0;
  virtual void validate_resource_plan(WMValidateResourcePlanResponse& _return, const WMValidateResourcePlanRequest& request) = 0;
  virtual void drop_resource_plan(WMDropResourcePlanResponse& _return, const WMDropResourcePlanRequest& request) = 0;
  virtual void create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) = 0;
  virtual void alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) = 0;
  virtual void drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) = 0;
  virtual void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) = 0;
  virtual void create_wm_pool(WMCreatePoolResponse& _return, const WMCreatePoolRequest& request) = 0;
  virtual void alter_wm_pool(WMAlterPoolResponse& _return, const WMAlterPoolRequest& request) = 0;
  virtual void drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request) = 0;
  virtual void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) = 0;
  virtual void drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) = 0;
  virtual void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) = 0;
  virtual void create_ischema(const ISchema& schema) = 0;
  virtual void alter_ischema(const AlterISchemaRequest& rqst) = 0;
  virtual void get_ischema(ISchema& _return, const ISchemaName& name) = 0;
  virtual void drop_ischema(const ISchemaName& name) = 0;
  virtual void add_schema_version(const SchemaVersion& schemaVersion) = 0;
  virtual void get_schema_version(SchemaVersion& _return, const SchemaVersionDescriptor& schemaVersion) = 0;
  virtual void get_schema_latest_version(SchemaVersion& _return, const ISchemaName& schemaName) = 0;
  virtual void get_schema_all_versions(std::vector<SchemaVersion> & _return, const ISchemaName& schemaName) = 0;
  virtual void drop_schema_version(const SchemaVersionDescriptor& schemaVersion) = 0;
  virtual void get_schemas_by_cols(FindSchemasByColsResp& _return, const FindSchemasByColsRqst& rqst) = 0;
  virtual void map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst) = 0;
  virtual void set_schema_version_state(const SetSchemaVersionStateRequest& rqst) = 0;
  virtual void add_serde(const SerDeInfo& serde) = 0;
  virtual void get_serde(SerDeInfo& _return, const GetSerdeRequest& rqst) = 0;
  virtual void get_lock_materialization_rebuild(LockResponse& _return, const std::string& dbName, const std::string& tableName, const int64_t txnId) = 0;
  virtual bool heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId) = 0;
  virtual void add_runtime_stats(const RuntimeStat& stat) = 0;
  virtual void get_runtime_stats(std::vector<RuntimeStat> & _return, const GetRuntimeStatsRequest& rqst) = 0;
};

class ThriftHiveMetastoreIfFactory : virtual public  ::facebook::fb303::FacebookServiceIfFactory {
 public:
  typedef ThriftHiveMetastoreIf Handler;

  virtual ~ThriftHiveMetastoreIfFactory() {}

  virtual ThriftHiveMetastoreIf* getHandler(const ::apache::thrift::TConnectionInfo& connInfo) override = 0;
  virtual void releaseHandler( ::facebook::fb303::FacebookServiceIf* /* handler */) override = 0;
  };

class ThriftHiveMetastoreIfSingletonFactory : virtual public ThriftHiveMetastoreIfFactory {
 public:
  ThriftHiveMetastoreIfSingletonFactory(const ::std::shared_ptr<ThriftHiveMetastoreIf>& iface) : iface_(iface) {}
  virtual ~ThriftHiveMetastoreIfSingletonFactory() {}

  virtual ThriftHiveMetastoreIf* getHandler(const ::apache::thrift::TConnectionInfo&) override {
    return iface_.get();
  }
  virtual void releaseHandler( ::facebook::fb303::FacebookServiceIf* /* handler */) override {}

 protected:
  ::std::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 */) override {
    return;
  }
  void setMetaConf(const std::string& /* key */, const std::string& /* value */) override {
    return;
  }
  bool init_schema(const std::string& /* dbType */, const std::string& /* username */, const std::string& /* password */) override {
    bool _return = false;
    return _return;
  }
  void create_catalog(const CreateCatalogRequest& /* catalog */) override {
    return;
  }
  void alter_catalog(const AlterCatalogRequest& /* rqst */) override {
    return;
  }
  void get_catalog(GetCatalogResponse& /* _return */, const GetCatalogRequest& /* catName */) override {
    return;
  }
  void get_catalogs(GetCatalogsResponse& /* _return */) override {
    return;
  }
  void drop_catalog(const DropCatalogRequest& /* catName */) override {
    return;
  }
  void create_database(const Database& /* database */) override {
    return;
  }
  void get_database(Database& /* _return */, const std::string& /* name */) override {
    return;
  }
  void drop_database(const std::string& /* name */, const bool /* deleteData */, const bool /* cascade */) override {
    return;
  }
  void get_databases(std::vector<std::string> & /* _return */, const std::string& /* pattern */) override {
    return;
  }
  void get_all_databases(std::vector<std::string> & /* _return */) override {
    return;
  }
  void alter_database(const std::string& /* dbname */, const Database& /* db */) override {
    return;
  }
  void get_type(Type& /* _return */, const std::string& /* name */) override {
    return;
  }
  bool create_type(const Type& /* type */) override {
    bool _return = false;
    return _return;
  }
  bool drop_type(const std::string& /* type */) override {
    bool _return = false;
    return _return;
  }
  void get_type_all(std::map<std::string, Type> & /* _return */, const std::string& /* name */) override {
    return;
  }
  void get_fields(std::vector<FieldSchema> & /* _return */, const std::string& /* db_name */, const std::string& /* table_name */) override {
    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 */) override {
    return;
  }
  void get_schema(std::vector<FieldSchema> & /* _return */, const std::string& /* db_name */, const std::string& /* table_name */) override {
    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 */) override {
    return;
  }
  void create_table(const Table& /* tbl */) override {
    return;
  }
  void create_table_with_environment_context(const Table& /* tbl */, const EnvironmentContext& /* environment_context */) override {
    return;
  }
  void create_table_with_constraints(const Table& /* tbl */, const std::vector<SQLPrimaryKey> & /* primaryKeys */, const std::vector<SQLForeignKey> & /* foreignKeys */, const std::vector<SQLUniqueConstraint> & /* uniqueConstraints */, const std::vector<SQLNotNullConstraint> & /* notNullConstraints */, const std::vector<SQLDefaultConstraint> & /* defaultConstraints */, const std::vector<SQLCheckConstraint> & /* checkConstraints */) override {
    return;
  }
  void drop_constraint(const DropConstraintRequest& /* req */) override {
    return;
  }
  void add_primary_key(const AddPrimaryKeyRequest& /* req */) override {
    return;
  }
  void add_foreign_key(const AddForeignKeyRequest& /* req */) override {
    return;
  }
  void add_unique_constraint(const AddUniqueConstraintRequest& /* req */) override {
    return;
  }
  void add_not_null_constraint(const AddNotNullConstraintRequest& /* req */) override {
    return;
  }
  void add_default_constraint(const AddDefaultConstraintRequest& /* req */) override {
    return;
  }
  void add_check_constraint(const AddCheckConstraintRequest& /* req */) override {
    return;
  }
  void drop_table(const std::string& /* dbname */, const std::string& /* name */, const bool /* deleteData */) override {
    return;
  }
  void drop_table_with_environment_context(const std::string& /* dbname */, const std::string& /* name */, const bool /* deleteData */, const EnvironmentContext& /* environment_context */) override {
    return;
  }
  void truncate_table(const std::string& /* dbName */, const std::string& /* tableName */, const std::vector<std::string> & /* partNames */) override {
    return;
  }
  void get_tables(std::vector<std::string> & /* _return */, const std::string& /* db_name */, const std::string& /* pattern */) override {
    return;
  }
  void get_tables_by_type(std::vector<std::string> & /* _return */, const std::string& /* db_name */, const std::string& /* pattern */, const std::string& /* tableType */) override {
    return;
  }
  void get_materialized_views_for_rewriting(std::vector<std::string> & /* _return */, const std::string& /* db_name */) override {
    return;
  }
  void get_table_meta(std::vector<TableMeta> & /* _return */, const std::string& /* db_patterns */, const std::string& /* tbl_patterns */, const std::vector<std::string> & /* tbl_types */) override {
    return;
  }
  void get_all_tables(std::vector<std::string> & /* _return */, const std::string& /* db_name */) override {
    return;
  }
  void get_table(Table& /* _return */, const std::string& /* dbname */, const std::string& /* tbl_name */) override {
    return;
  }
  void get_table_objects_by_name(std::vector<Table> & /* _return */, const std::string& /* dbname */, const std::vector<std::string> & /* tbl_names */) override {
    return;
  }
  void get_table_req(GetTableResult& /* _return */, const GetTableRequest& /* req */) override {
    return;
  }
  void get_table_objects_by_name_req(GetTablesResult& /* _return */, const GetTablesRequest& /* req */) override {
    return;
  }
  void get_materialization_invalidation_info(Materialization& /* _return */, const CreationMetadata& /* creation_metadata */, const std::string& /* validTxnList */) override {
    return;
  }
  void update_creation_metadata(const std::string& /* catName */, const std::string& /* dbname */, const std::string& /* tbl_name */, const CreationMetadata& /* creation_metadata */) override {
    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 */) override {
    return;
  }
  void alter_table(const std::string& /* dbname */, const std::string& /* tbl_name */, const Table& /* new_tbl */) override {
    return;
  }
  void alter_table_with_environment_context(const std::string& /* dbname */, const std::string& /* tbl_name */, const Table& /* new_tbl */, const EnvironmentContext& /* environment_context */) override {
    return;
  }
  void alter_table_with_cascade(const std::string& /* dbname */, const std::string& /* tbl_name */, const Table& /* new_tbl */, const bool /* cascade */) override {
    return;
  }
  void add_partition(Partition& /* _return */, const Partition& /* new_part */) override {
    return;
  }
  void add_partition_with_environment_context(Partition& /* _return */, const Partition& /* new_part */, const EnvironmentContext& /* environment_context */) override {
    return;
  }
  int32_t add_partitions(const std::vector<Partition> & /* new_parts */) override {
    int32_t _return = 0;
    return _return;
  }
  int32_t add_partitions_pspec(const std::vector<PartitionSpec> & /* new_parts */) override {
    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 */) override {
    return;
  }
  void add_partitions_req(AddPartitionsResult& /* _return */, const AddPartitionsRequest& /* request */) override {
    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 */) override {
    return;
  }
  void append_partition_by_name(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* part_name */) override {
    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 */) override {
    return;
  }
  bool drop_partition(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector<std::string> & /* part_vals */, const bool /* deleteData */) override {
    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 */) override {
    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 */) override {
    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 */) override {
    bool _return = false;
    return _return;
  }
  void drop_partitions_req(DropPartitionsResult& /* _return */, const DropPartitionsRequest& /* req */) override {
    return;
  }
  void get_partition(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector<std::string> & /* part_vals */) override {
    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 */) override {
    return;
  }
  void exchange_partitions(std::vector<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 */) override {
    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 */) override {
    return;
  }
  void get_partition_by_name(Partition& /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* part_name */) override {
    return;
  }
  void get_partitions(std::vector<Partition> & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const int16_t /* max_parts */) override {
    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 */) override {
    return;
  }
  void get_partitions_pspec(std::vector<PartitionSpec> & /* _return */, const std::string& /* db_name */, const std::string& /* tbl_name */, const int32_t /* max_parts */) override {
    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 */) override {
    return;
  }
  void get_partition_values(PartitionValuesResponse& /* _return */, const PartitionValuesRequest& /* request */) override {
    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 */) override {
    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 */) override {
    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 */) override {
    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 */) override {
    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 */) override {
    return;
  }
  void get_partitions_by_expr(PartitionsByExprResult& /* _return */, const PartitionsByExprRequest& /* req */) override {
    return;
  }
  int32_t get_num_partitions_by_filter(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::string& /* filter */) override {
    int32_t _return = 0;
    return _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 */) override {
    return;
  }
  void alter_partition(const std::string& /* db_name */, const std::string& /* tbl_name */, const Partition& /* new_part */) override {
    return;
  }
  void alter_partitions(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector<Partition> & /* new_parts */) override {
    return;
  }
  void alter_partitions_with_environment_context(const std::string& /* db_name */, const std::string& /* tbl_name */, const std::vector<Partition> & /* new_parts */, const EnvironmentContext& /* environment_context */) override {
    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 */) override {
    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 */) override {
    return;
  }
  bool partition_name_has_valid_characters(const std::vector<std::string> & /* part_vals */, const bool /* throw_exception */) override {
    bool _return = false;
    return _return;
  }
  void get_config_value(std::string& /* _return */, const std::string& /* name */, const std::string& /* defaultValue */) override {
    return;
  }
  void partition_name_to_vals(std::vector<std::string> & /* _return */, const std::string& /* part_name */) override {
    return;
  }
  void partition_name_to_spec(std::map<std::string, std::string> & /* _return */, const std::string& /* part_name */) override {
    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 */) override {
    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 */) override {
    bool _return = false;
    return _return;
  }
  void get_primary_keys(PrimaryKeysResponse& /* _return */, const PrimaryKeysRequest& /* request */) override {
    return;
  }
  void get_foreign_keys(ForeignKeysResponse& /* _return */, const ForeignKeysRequest& /* request */) override {
    return;
  }
  void get_unique_constraints(UniqueConstraintsResponse& /* _return */, const UniqueConstraintsRequest& /* request */) override {
    return;
  }
  void get_not_null_constraints(NotNullConstraintsResponse& /* _return */, const NotNullConstraintsRequest& /* request */) override {
    return;
  }
  void get_default_constraints(DefaultConstraintsResponse& /* _return */, const DefaultConstraintsRequest& /* request */) override {
    return;
  }
  void get_check_constraints(CheckConstraintsResponse& /* _return */, const CheckConstraintsRequest& /* request */) override {
    return;
  }
  bool update_table_column_statistics(const ColumnStatistics& /* stats_obj */) override {
    bool _return = false;
    return _return;
  }
  bool update_partition_column_statistics(const ColumnStatistics& /* stats_obj */) override {
    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 */) override {
    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 */) override {
    return;
  }
  void get_table_statistics_req(TableStatsResult& /* _return */, const TableStatsRequest& /* request */) override {
    return;
  }
  void get_partitions_statistics_req(PartitionsStatsResult& /* _return */, const PartitionsStatsRequest& /* request */) override {
    return;
  }
  void get_aggr_stats_for(AggrStats& /* _return */, const PartitionsStatsRequest& /* request */) override {
    return;
  }
  bool set_aggr_stats_for(const SetPartitionsStatsRequest& /* request */) override {
    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 */) override {
    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 */) override {
    bool _return = false;
    return _return;
  }
  void create_function(const Function& /* func */) override {
    return;
  }
  void drop_function(const std::string& /* dbName */, const std::string& /* funcName */) override {
    return;
  }
  void alter_function(const std::string& /* dbName */, const std::string& /* funcName */, const Function& /* newFunc */) override {
    return;
  }
  void get_functions(std::vector<std::string> & /* _return */, const std::string& /* dbName */, const std::string& /* pattern */) override {
    return;
  }
  void get_function(Function& /* _return */, const std::string& /* dbName */, const std::string& /* funcName */) override {
    return;
  }
  void get_all_functions(GetAllFunctionsResponse& /* _return */) override {
    return;
  }
  bool create_role(const Role& /* role */) override {
    bool _return = false;
    return _return;
  }
  bool drop_role(const std::string& /* role_name */) override {
    bool _return = false;
    return _return;
  }
  void get_role_names(std::vector<std::string> & /* _return */) override {
    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 */) override {
    bool _return = false;
    return _return;
  }
  bool revoke_role(const std::string& /* role_name */, const std::string& /* principal_name */, const PrincipalType::type /* principal_type */) override {
    bool _return = false;
    return _return;
  }
  void list_roles(std::vector<Role> & /* _return */, const std::string& /* principal_name */, const PrincipalType::type /* principal_type */) override {
    return;
  }
  void grant_revoke_role(GrantRevokeRoleResponse& /* _return */, const GrantRevokeRoleRequest& /* request */) override {
    return;
  }
  void get_principals_in_role(GetPrincipalsInRoleResponse& /* _return */, const GetPrincipalsInRoleRequest& /* request */) override {
    return;
  }
  void get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& /* _return */, const GetRoleGrantsForPrincipalRequest& /* request */) override {
    return;
  }
  void get_privilege_set(PrincipalPrivilegeSet& /* _return */, const HiveObjectRef& /* hiveObject */, const std::string& /* user_name */, const std::vector<std::string> & /* group_names */) override {
    return;
  }
  void list_privileges(std::vector<HiveObjectPrivilege> & /* _return */, const std::string& /* principal_name */, const PrincipalType::type /* principal_type */, const HiveObjectRef& /* hiveObject */) override {
    return;
  }
  bool grant_privileges(const PrivilegeBag& /* privileges */) override {
    bool _return = false;
    return _return;
  }
  bool revoke_privileges(const PrivilegeBag& /* privileges */) override {
    bool _return = false;
    return _return;
  }
  void grant_revoke_privileges(GrantRevokePrivilegeResponse& /* _return */, const GrantRevokePrivilegeRequest& /* request */) override {
    return;
  }
  void refresh_privileges(GrantRevokePrivilegeResponse& /* _return */, const HiveObjectRef& /* objToRefresh */, const std::string& /* authorizer */, const GrantRevokePrivilegeRequest& /* grantRequest */) override {
    return;
  }
  void set_ugi(std::vector<std::string> & /* _return */, const std::string& /* user_name */, const std::vector<std::string> & /* group_names */) override {
    return;
  }
  void get_delegation_token(std::string& /* _return */, const std::string& /* token_owner */, const std::string& /* renewer_kerberos_principal_name */) override {
    return;
  }
  int64_t renew_delegation_token(const std::string& /* token_str_form */) override {
    int64_t _return = 0;
    return _return;
  }
  void cancel_delegation_token(const std::string& /* token_str_form */) override {
    return;
  }
  bool add_token(const std::string& /* token_identifier */, const std::string& /* delegation_token */) override {
    bool _return = false;
    return _return;
  }
  bool remove_token(const std::string& /* token_identifier */) override {
    bool _return = false;
    return _return;
  }
  void get_token(std::string& /* _return */, const std::string& /* token_identifier */) override {
    return;
  }
  void get_all_token_identifiers(std::vector<std::string> & /* _return */) override {
    return;
  }
  int32_t add_master_key(const std::string& /* key */) override {
    int32_t _return = 0;
    return _return;
  }
  void update_master_key(const int32_t /* seq_number */, const std::string& /* key */) override {
    return;
  }
  bool remove_master_key(const int32_t /* key_seq */) override {
    bool _return = false;
    return _return;
  }
  void get_master_keys(std::vector<std::string> & /* _return */) override {
    return;
  }
  void get_open_txns(GetOpenTxnsResponse& /* _return */) override {
    return;
  }
  void get_open_txns_info(GetOpenTxnsInfoResponse& /* _return */) override {
    return;
  }
  void open_txns(OpenTxnsResponse& /* _return */, const OpenTxnRequest& /* rqst */) override {
    return;
  }
  void abort_txn(const AbortTxnRequest& /* rqst */) override {
    return;
  }
  void abort_txns(const AbortTxnsRequest& /* rqst */) override {
    return;
  }
  void commit_txn(const CommitTxnRequest& /* rqst */) override {
    return;
  }
  void repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& /* rqst */) override {
    return;
  }
  void get_valid_write_ids(GetValidWriteIdsResponse& /* _return */, const GetValidWriteIdsRequest& /* rqst */) override {
    return;
  }
  void allocate_table_write_ids(AllocateTableWriteIdsResponse& /* _return */, const AllocateTableWriteIdsRequest& /* rqst */) override {
    return;
  }
  void lock(LockResponse& /* _return */, const LockRequest& /* rqst */) override {
    return;
  }
  void check_lock(LockResponse& /* _return */, const CheckLockRequest& /* rqst */) override {
    return;
  }
  void unlock(const UnlockRequest& /* rqst */) override {
    return;
  }
  void show_locks(ShowLocksResponse& /* _return */, const ShowLocksRequest& /* rqst */) override {
    return;
  }
  void heartbeat(const HeartbeatRequest& /* ids */) override {
    return;
  }
  void heartbeat_txn_range(HeartbeatTxnRangeResponse& /* _return */, const HeartbeatTxnRangeRequest& /* txns */) override {
    return;
  }
  void compact(const CompactionRequest& /* rqst */) override {
    return;
  }
  void compact2(CompactionResponse& /* _return */, const CompactionRequest& /* rqst */) override {
    return;
  }
  void show_compact(ShowCompactResponse& /* _return */, const ShowCompactRequest& /* rqst */) override {
    return;
  }
  void add_dynamic_partitions(const AddDynamicPartitions& /* rqst */) override {
    return;
  }
  void get_next_notification(NotificationEventResponse& /* _return */, const NotificationEventRequest& /* rqst */) override {
    return;
  }
  void get_current_notificationEventId(CurrentNotificationEventId& /* _return */) override {
    return;
  }
  void get_notification_events_count(NotificationEventsCountResponse& /* _return */, const NotificationEventsCountRequest& /* rqst */) override {
    return;
  }
  void fire_listener_event(FireEventResponse& /* _return */, const FireEventRequest& /* rqst */) override {
    return;
  }
  void flushCache() override {
    return;
  }
  void cm_recycle(CmRecycleResponse& /* _return */, const CmRecycleRequest& /* request */) override {
    return;
  }
  void get_file_metadata_by_expr(GetFileMetadataByExprResult& /* _return */, const GetFileMetadataByExprRequest& /* req */) override {
    return;
  }
  void get_file_metadata(GetFileMetadataResult& /* _return */, const GetFileMetadataRequest& /* req */) override {
    return;
  }
  void put_file_metadata(PutFileMetadataResult& /* _return */, const PutFileMetadataRequest& /* req */) override {
    return;
  }
  void clear_file_metadata(ClearFileMetadataResult& /* _return */, const ClearFileMetadataRequest& /* req */) override {
    return;
  }
  void cache_file_metadata(CacheFileMetadataResult& /* _return */, const CacheFileMetadataRequest& /* req */) override {
    return;
  }
  void get_metastore_db_uuid(std::string& /* _return */) override {
    return;
  }
  void create_resource_plan(WMCreateResourcePlanResponse& /* _return */, const WMCreateResourcePlanRequest& /* request */) override {
    return;
  }
  void get_resource_plan(WMGetResourcePlanResponse& /* _return */, const WMGetResourcePlanRequest& /* request */) override {
    return;
  }
  void get_active_resource_plan(WMGetActiveResourcePlanResponse& /* _return */, const WMGetActiveResourcePlanRequest& /* request */) override {
    return;
  }
  void get_all_resource_plans(WMGetAllResourcePlanResponse& /* _return */, const WMGetAllResourcePlanRequest& /* request */) override {
    return;
  }
  void alter_resource_plan(WMAlterResourcePlanResponse& /* _return */, const WMAlterResourcePlanRequest& /* request */) override {
    return;
  }
  void validate_resource_plan(WMValidateResourcePlanResponse& /* _return */, const WMValidateResourcePlanRequest& /* request */) override {
    return;
  }
  void drop_resource_plan(WMDropResourcePlanResponse& /* _return */, const WMDropResourcePlanRequest& /* request */) override {
    return;
  }
  void create_wm_trigger(WMCreateTriggerResponse& /* _return */, const WMCreateTriggerRequest& /* request */) override {
    return;
  }
  void alter_wm_trigger(WMAlterTriggerResponse& /* _return */, const WMAlterTriggerRequest& /* request */) override {
    return;
  }
  void drop_wm_trigger(WMDropTriggerResponse& /* _return */, const WMDropTriggerRequest& /* request */) override {
    return;
  }
  void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& /* _return */, const WMGetTriggersForResourePlanRequest& /* request */) override {
    return;
  }
  void create_wm_pool(WMCreatePoolResponse& /* _return */, const WMCreatePoolRequest& /* request */) override {
    return;
  }
  void alter_wm_pool(WMAlterPoolResponse& /* _return */, const WMAlterPoolRequest& /* request */) override {
    return;
  }
  void drop_wm_pool(WMDropPoolResponse& /* _return */, const WMDropPoolRequest& /* request */) override {
    return;
  }
  void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& /* _return */, const WMCreateOrUpdateMappingRequest& /* request */) override {
    return;
  }
  void drop_wm_mapping(WMDropMappingResponse& /* _return */, const WMDropMappingRequest& /* request */) override {
    return;
  }
  void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& /* _return */, const WMCreateOrDropTriggerToPoolMappingRequest& /* request */) override {
    return;
  }
  void create_ischema(const ISchema& /* schema */) override {
    return;
  }
  void alter_ischema(const AlterISchemaRequest& /* rqst */) override {
    return;
  }
  void get_ischema(ISchema& /* _return */, const ISchemaName& /* name */) override {
    return;
  }
  void drop_ischema(const ISchemaName& /* name */) override {
    return;
  }
  void add_schema_version(const SchemaVersion& /* schemaVersion */) override {
    return;
  }
  void get_schema_version(SchemaVersion& /* _return */, const SchemaVersionDescriptor& /* schemaVersion */) override {
    return;
  }
  void get_schema_latest_version(SchemaVersion& /* _return */, const ISchemaName& /* schemaName */) override {
    return;
  }
  void get_schema_all_versions(std::vector<SchemaVersion> & /* _return */, const ISchemaName& /* schemaName */) override {
    return;
  }
  void drop_schema_version(const SchemaVersionDescriptor& /* schemaVersion */) override {
    return;
  }
  void get_schemas_by_cols(FindSchemasByColsResp& /* _return */, const FindSchemasByColsRqst& /* rqst */) override {
    return;
  }
  void map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& /* rqst */) override {
    return;
  }
  void set_schema_version_state(const SetSchemaVersionStateRequest& /* rqst */) override {
    return;
  }
  void add_serde(const SerDeInfo& /* serde */) override {
    return;
  }
  void get_serde(SerDeInfo& /* _return */, const GetSerdeRequest& /* rqst */) override {
    return;
  }
  void get_lock_materialization_rebuild(LockResponse& /* _return */, const std::string& /* dbName */, const std::string& /* tableName */, const int64_t /* txnId */) override {
    return;
  }
  bool heartbeat_lock_materialization_rebuild(const std::string& /* dbName */, const std::string& /* tableName */, const int64_t /* txnId */) override {
    bool _return = false;
    return _return;
  }
  void add_runtime_stats(const RuntimeStat& /* stat */) override {
    return;
  }
  void get_runtime_stats(std::vector<RuntimeStat> & /* _return */, const GetRuntimeStatsRequest& /* rqst */) override {
    return;
  }
};

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

class ThriftHiveMetastore_getMetaConf_args {
 public:

  ThriftHiveMetastore_getMetaConf_args(const ThriftHiveMetastore_getMetaConf_args&);
  ThriftHiveMetastore_getMetaConf_args& operator=(const ThriftHiveMetastore_getMetaConf_args&);
  ThriftHiveMetastore_getMetaConf_args() noexcept
                                       : key() {
  }

  virtual ~ThriftHiveMetastore_getMetaConf_args() noexcept;
  std::string key;

  _ThriftHiveMetastore_getMetaConf_args__isset __isset;

  void __set_key(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_getMetaConf_result__isset;

class ThriftHiveMetastore_getMetaConf_result {
 public:

  ThriftHiveMetastore_getMetaConf_result(const ThriftHiveMetastore_getMetaConf_result&);
  ThriftHiveMetastore_getMetaConf_result& operator=(const ThriftHiveMetastore_getMetaConf_result&);
  ThriftHiveMetastore_getMetaConf_result() noexcept
                                         : success() {
  }

  virtual ~ThriftHiveMetastore_getMetaConf_result() noexcept;
  std::string success;
  MetaException o1;

  _ThriftHiveMetastore_getMetaConf_result__isset __isset;

  void __set_success(const std::string& val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_getMetaConf_presult__isset;

class ThriftHiveMetastore_getMetaConf_presult {
 public:


  virtual ~ThriftHiveMetastore_getMetaConf_presult() noexcept;
  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 :1;
  bool value :1;
} _ThriftHiveMetastore_setMetaConf_args__isset;

class ThriftHiveMetastore_setMetaConf_args {
 public:

  ThriftHiveMetastore_setMetaConf_args(const ThriftHiveMetastore_setMetaConf_args&);
  ThriftHiveMetastore_setMetaConf_args& operator=(const ThriftHiveMetastore_setMetaConf_args&);
  ThriftHiveMetastore_setMetaConf_args() noexcept
                                       : key(),
                                         value() {
  }

  virtual ~ThriftHiveMetastore_setMetaConf_args() noexcept;
  std::string key;
  std::string value;

  _ThriftHiveMetastore_setMetaConf_args__isset __isset;

  void __set_key(const std::string& val);

  void __set_value(const std::string& 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() noexcept;
  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 :1;
} _ThriftHiveMetastore_setMetaConf_result__isset;

class ThriftHiveMetastore_setMetaConf_result {
 public:

  ThriftHiveMetastore_setMetaConf_result(const ThriftHiveMetastore_setMetaConf_result&);
  ThriftHiveMetastore_setMetaConf_result& operator=(const ThriftHiveMetastore_setMetaConf_result&);
  ThriftHiveMetastore_setMetaConf_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_setMetaConf_result() noexcept;
  MetaException o1;

  _ThriftHiveMetastore_setMetaConf_result__isset __isset;

  void __set_o1(const MetaException& 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 :1;
} _ThriftHiveMetastore_setMetaConf_presult__isset;

class ThriftHiveMetastore_setMetaConf_presult {
 public:


  virtual ~ThriftHiveMetastore_setMetaConf_presult() noexcept;
  MetaException o1;

  _ThriftHiveMetastore_setMetaConf_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_init_schema_args__isset {
  _ThriftHiveMetastore_init_schema_args__isset() : dbType(false), username(false), password(false) {}
  bool dbType :1;
  bool username :1;
  bool password :1;
} _ThriftHiveMetastore_init_schema_args__isset;

class ThriftHiveMetastore_init_schema_args {
 public:

  ThriftHiveMetastore_init_schema_args(const ThriftHiveMetastore_init_schema_args&);
  ThriftHiveMetastore_init_schema_args& operator=(const ThriftHiveMetastore_init_schema_args&);
  ThriftHiveMetastore_init_schema_args() noexcept
                                       : dbType(),
                                         username(),
                                         password() {
  }

  virtual ~ThriftHiveMetastore_init_schema_args() noexcept;
  std::string dbType;
  std::string username;
  std::string password;

  _ThriftHiveMetastore_init_schema_args__isset __isset;

  void __set_dbType(const std::string& val);

  void __set_username(const std::string& val);

  void __set_password(const std::string& val);

  bool operator == (const ThriftHiveMetastore_init_schema_args & rhs) const
  {
    if (!(dbType == rhs.dbType))
      return false;
    if (!(username == rhs.username))
      return false;
    if (!(password == rhs.password))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_init_schema_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_init_schema_args & ) const;

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

};


class ThriftHiveMetastore_init_schema_pargs {
 public:


  virtual ~ThriftHiveMetastore_init_schema_pargs() noexcept;
  const std::string* dbType;
  const std::string* username;
  const std::string* password;

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

};

typedef struct _ThriftHiveMetastore_init_schema_result__isset {
  _ThriftHiveMetastore_init_schema_result__isset() : success(false), ex(false) {}
  bool success :1;
  bool ex :1;
} _ThriftHiveMetastore_init_schema_result__isset;

class ThriftHiveMetastore_init_schema_result {
 public:

  ThriftHiveMetastore_init_schema_result(const ThriftHiveMetastore_init_schema_result&);
  ThriftHiveMetastore_init_schema_result& operator=(const ThriftHiveMetastore_init_schema_result&);
  ThriftHiveMetastore_init_schema_result() noexcept
                                         : success(0) {
  }

  virtual ~ThriftHiveMetastore_init_schema_result() noexcept;
  bool success;
  MetaException ex;

  _ThriftHiveMetastore_init_schema_result__isset __isset;

  void __set_success(const bool val);

  void __set_ex(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_init_schema_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_init_schema_presult__isset {
  _ThriftHiveMetastore_init_schema_presult__isset() : success(false), ex(false) {}
  bool success :1;
  bool ex :1;
} _ThriftHiveMetastore_init_schema_presult__isset;

class ThriftHiveMetastore_init_schema_presult {
 public:


  virtual ~ThriftHiveMetastore_init_schema_presult() noexcept;
  bool* success;
  MetaException ex;

  _ThriftHiveMetastore_init_schema_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_create_catalog_args__isset {
  _ThriftHiveMetastore_create_catalog_args__isset() : catalog(false) {}
  bool catalog :1;
} _ThriftHiveMetastore_create_catalog_args__isset;

class ThriftHiveMetastore_create_catalog_args {
 public:

  ThriftHiveMetastore_create_catalog_args(const ThriftHiveMetastore_create_catalog_args&);
  ThriftHiveMetastore_create_catalog_args& operator=(const ThriftHiveMetastore_create_catalog_args&);
  ThriftHiveMetastore_create_catalog_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_catalog_args() noexcept;
  CreateCatalogRequest catalog;

  _ThriftHiveMetastore_create_catalog_args__isset __isset;

  void __set_catalog(const CreateCatalogRequest& val);

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

  bool operator < (const ThriftHiveMetastore_create_catalog_args & ) const;

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

};


class ThriftHiveMetastore_create_catalog_pargs {
 public:


  virtual ~ThriftHiveMetastore_create_catalog_pargs() noexcept;
  const CreateCatalogRequest* catalog;

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

};

typedef struct _ThriftHiveMetastore_create_catalog_result__isset {
  _ThriftHiveMetastore_create_catalog_result__isset() : o1(false), o2(false), o3(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_create_catalog_result__isset;

class ThriftHiveMetastore_create_catalog_result {
 public:

  ThriftHiveMetastore_create_catalog_result(const ThriftHiveMetastore_create_catalog_result&);
  ThriftHiveMetastore_create_catalog_result& operator=(const ThriftHiveMetastore_create_catalog_result&);
  ThriftHiveMetastore_create_catalog_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_catalog_result() noexcept;
  AlreadyExistsException o1;
  InvalidObjectException o2;
  MetaException o3;

  _ThriftHiveMetastore_create_catalog_result__isset __isset;

  void __set_o1(const AlreadyExistsException& val);

  void __set_o2(const InvalidObjectException& val);

  void __set_o3(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_create_catalog_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_create_catalog_presult__isset {
  _ThriftHiveMetastore_create_catalog_presult__isset() : o1(false), o2(false), o3(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_create_catalog_presult__isset;

class ThriftHiveMetastore_create_catalog_presult {
 public:


  virtual ~ThriftHiveMetastore_create_catalog_presult() noexcept;
  AlreadyExistsException o1;
  InvalidObjectException o2;
  MetaException o3;

  _ThriftHiveMetastore_create_catalog_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_alter_catalog_args__isset {
  _ThriftHiveMetastore_alter_catalog_args__isset() : rqst(false) {}
  bool rqst :1;
} _ThriftHiveMetastore_alter_catalog_args__isset;

class ThriftHiveMetastore_alter_catalog_args {
 public:

  ThriftHiveMetastore_alter_catalog_args(const ThriftHiveMetastore_alter_catalog_args&);
  ThriftHiveMetastore_alter_catalog_args& operator=(const ThriftHiveMetastore_alter_catalog_args&);
  ThriftHiveMetastore_alter_catalog_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_catalog_args() noexcept;
  AlterCatalogRequest rqst;

  _ThriftHiveMetastore_alter_catalog_args__isset __isset;

  void __set_rqst(const AlterCatalogRequest& val);

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

  bool operator < (const ThriftHiveMetastore_alter_catalog_args & ) const;

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

};


class ThriftHiveMetastore_alter_catalog_pargs {
 public:


  virtual ~ThriftHiveMetastore_alter_catalog_pargs() noexcept;
  const AlterCatalogRequest* rqst;

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

};

typedef struct _ThriftHiveMetastore_alter_catalog_result__isset {
  _ThriftHiveMetastore_alter_catalog_result__isset() : o1(false), o2(false), o3(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_alter_catalog_result__isset;

class ThriftHiveMetastore_alter_catalog_result {
 public:

  ThriftHiveMetastore_alter_catalog_result(const ThriftHiveMetastore_alter_catalog_result&);
  ThriftHiveMetastore_alter_catalog_result& operator=(const ThriftHiveMetastore_alter_catalog_result&);
  ThriftHiveMetastore_alter_catalog_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_catalog_result() noexcept;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_alter_catalog_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const InvalidOperationException& val);

  void __set_o3(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_alter_catalog_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_alter_catalog_presult__isset {
  _ThriftHiveMetastore_alter_catalog_presult__isset() : o1(false), o2(false), o3(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_alter_catalog_presult__isset;

class ThriftHiveMetastore_alter_catalog_presult {
 public:


  virtual ~ThriftHiveMetastore_alter_catalog_presult() noexcept;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_alter_catalog_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_catalog_args__isset {
  _ThriftHiveMetastore_get_catalog_args__isset() : catName(false) {}
  bool catName :1;
} _ThriftHiveMetastore_get_catalog_args__isset;

class ThriftHiveMetastore_get_catalog_args {
 public:

  ThriftHiveMetastore_get_catalog_args(const ThriftHiveMetastore_get_catalog_args&);
  ThriftHiveMetastore_get_catalog_args& operator=(const ThriftHiveMetastore_get_catalog_args&);
  ThriftHiveMetastore_get_catalog_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_catalog_args() noexcept;
  GetCatalogRequest catName;

  _ThriftHiveMetastore_get_catalog_args__isset __isset;

  void __set_catName(const GetCatalogRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_catalog_args & ) const;

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

};


class ThriftHiveMetastore_get_catalog_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_catalog_pargs() noexcept;
  const GetCatalogRequest* catName;

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

};

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

class ThriftHiveMetastore_get_catalog_result {
 public:

  ThriftHiveMetastore_get_catalog_result(const ThriftHiveMetastore_get_catalog_result&);
  ThriftHiveMetastore_get_catalog_result& operator=(const ThriftHiveMetastore_get_catalog_result&);
  ThriftHiveMetastore_get_catalog_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_catalog_result() noexcept;
  GetCatalogResponse success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_catalog_result__isset __isset;

  void __set_success(const GetCatalogResponse& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_catalog_result & ) const;

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

};

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

class ThriftHiveMetastore_get_catalog_presult {
 public:


  virtual ~ThriftHiveMetastore_get_catalog_presult() noexcept;
  GetCatalogResponse* success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_catalog_presult__isset __isset;

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

};


class ThriftHiveMetastore_get_catalogs_args {
 public:

  ThriftHiveMetastore_get_catalogs_args(const ThriftHiveMetastore_get_catalogs_args&) noexcept;
  ThriftHiveMetastore_get_catalogs_args& operator=(const ThriftHiveMetastore_get_catalogs_args&) noexcept;
  ThriftHiveMetastore_get_catalogs_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_catalogs_args() noexcept;

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

  bool operator < (const ThriftHiveMetastore_get_catalogs_args & ) const;

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

};


class ThriftHiveMetastore_get_catalogs_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_catalogs_pargs() noexcept;

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

};

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

class ThriftHiveMetastore_get_catalogs_result {
 public:

  ThriftHiveMetastore_get_catalogs_result(const ThriftHiveMetastore_get_catalogs_result&);
  ThriftHiveMetastore_get_catalogs_result& operator=(const ThriftHiveMetastore_get_catalogs_result&);
  ThriftHiveMetastore_get_catalogs_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_catalogs_result() noexcept;
  GetCatalogsResponse success;
  MetaException o1;

  _ThriftHiveMetastore_get_catalogs_result__isset __isset;

  void __set_success(const GetCatalogsResponse& val);

  void __set_o1(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_catalogs_result & ) const;

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

};

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

class ThriftHiveMetastore_get_catalogs_presult {
 public:


  virtual ~ThriftHiveMetastore_get_catalogs_presult() noexcept;
  GetCatalogsResponse* success;
  MetaException o1;

  _ThriftHiveMetastore_get_catalogs_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_drop_catalog_args__isset {
  _ThriftHiveMetastore_drop_catalog_args__isset() : catName(false) {}
  bool catName :1;
} _ThriftHiveMetastore_drop_catalog_args__isset;

class ThriftHiveMetastore_drop_catalog_args {
 public:

  ThriftHiveMetastore_drop_catalog_args(const ThriftHiveMetastore_drop_catalog_args&);
  ThriftHiveMetastore_drop_catalog_args& operator=(const ThriftHiveMetastore_drop_catalog_args&);
  ThriftHiveMetastore_drop_catalog_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_catalog_args() noexcept;
  DropCatalogRequest catName;

  _ThriftHiveMetastore_drop_catalog_args__isset __isset;

  void __set_catName(const DropCatalogRequest& val);

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

  bool operator < (const ThriftHiveMetastore_drop_catalog_args & ) const;

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

};


class ThriftHiveMetastore_drop_catalog_pargs {
 public:


  virtual ~ThriftHiveMetastore_drop_catalog_pargs() noexcept;
  const DropCatalogRequest* catName;

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

};

typedef struct _ThriftHiveMetastore_drop_catalog_result__isset {
  _ThriftHiveMetastore_drop_catalog_result__isset() : o1(false), o2(false), o3(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_drop_catalog_result__isset;

class ThriftHiveMetastore_drop_catalog_result {
 public:

  ThriftHiveMetastore_drop_catalog_result(const ThriftHiveMetastore_drop_catalog_result&);
  ThriftHiveMetastore_drop_catalog_result& operator=(const ThriftHiveMetastore_drop_catalog_result&);
  ThriftHiveMetastore_drop_catalog_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_catalog_result() noexcept;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_drop_catalog_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const InvalidOperationException& val);

  void __set_o3(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_drop_catalog_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_drop_catalog_presult__isset {
  _ThriftHiveMetastore_drop_catalog_presult__isset() : o1(false), o2(false), o3(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_drop_catalog_presult__isset;

class ThriftHiveMetastore_drop_catalog_presult {
 public:


  virtual ~ThriftHiveMetastore_drop_catalog_presult() noexcept;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_drop_catalog_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 :1;
} _ThriftHiveMetastore_create_database_args__isset;

class ThriftHiveMetastore_create_database_args {
 public:

  ThriftHiveMetastore_create_database_args(const ThriftHiveMetastore_create_database_args&);
  ThriftHiveMetastore_create_database_args& operator=(const ThriftHiveMetastore_create_database_args&);
  ThriftHiveMetastore_create_database_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_database_args() noexcept;
  Database database;

  _ThriftHiveMetastore_create_database_args__isset __isset;

  void __set_database(const 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() noexcept;
  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 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_create_database_result__isset;

class ThriftHiveMetastore_create_database_result {
 public:

  ThriftHiveMetastore_create_database_result(const ThriftHiveMetastore_create_database_result&);
  ThriftHiveMetastore_create_database_result& operator=(const ThriftHiveMetastore_create_database_result&);
  ThriftHiveMetastore_create_database_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_database_result() noexcept;
  AlreadyExistsException o1;
  InvalidObjectException o2;
  MetaException o3;

  _ThriftHiveMetastore_create_database_result__isset __isset;

  void __set_o1(const AlreadyExistsException& val);

  void __set_o2(const InvalidObjectException& val);

  void __set_o3(const MetaException& 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 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_create_database_presult__isset;

class ThriftHiveMetastore_create_database_presult {
 public:


  virtual ~ThriftHiveMetastore_create_database_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_get_database_args__isset;

class ThriftHiveMetastore_get_database_args {
 public:

  ThriftHiveMetastore_get_database_args(const ThriftHiveMetastore_get_database_args&);
  ThriftHiveMetastore_get_database_args& operator=(const ThriftHiveMetastore_get_database_args&);
  ThriftHiveMetastore_get_database_args() noexcept
                                        : name() {
  }

  virtual ~ThriftHiveMetastore_get_database_args() noexcept;
  std::string name;

  _ThriftHiveMetastore_get_database_args__isset __isset;

  void __set_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_database_result__isset;

class ThriftHiveMetastore_get_database_result {
 public:

  ThriftHiveMetastore_get_database_result(const ThriftHiveMetastore_get_database_result&);
  ThriftHiveMetastore_get_database_result& operator=(const ThriftHiveMetastore_get_database_result&);
  ThriftHiveMetastore_get_database_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_database_result() noexcept;
  Database success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_database_result__isset __isset;

  void __set_success(const Database& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_database_presult__isset;

class ThriftHiveMetastore_get_database_presult {
 public:


  virtual ~ThriftHiveMetastore_get_database_presult() noexcept;
  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 :1;
  bool deleteData :1;
  bool cascade :1;
} _ThriftHiveMetastore_drop_database_args__isset;

class ThriftHiveMetastore_drop_database_args {
 public:

  ThriftHiveMetastore_drop_database_args(const ThriftHiveMetastore_drop_database_args&);
  ThriftHiveMetastore_drop_database_args& operator=(const ThriftHiveMetastore_drop_database_args&);
  ThriftHiveMetastore_drop_database_args() noexcept
                                         : name(),
                                           deleteData(0),
                                           cascade(0) {
  }

  virtual ~ThriftHiveMetastore_drop_database_args() noexcept;
  std::string name;
  bool deleteData;
  bool cascade;

  _ThriftHiveMetastore_drop_database_args__isset __isset;

  void __set_name(const std::string& val);

  void __set_deleteData(const bool val);

  void __set_cascade(const bool 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() noexcept;
  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 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_drop_database_result__isset;

class ThriftHiveMetastore_drop_database_result {
 public:

  ThriftHiveMetastore_drop_database_result(const ThriftHiveMetastore_drop_database_result&);
  ThriftHiveMetastore_drop_database_result& operator=(const ThriftHiveMetastore_drop_database_result&);
  ThriftHiveMetastore_drop_database_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_database_result() noexcept;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_drop_database_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const InvalidOperationException& val);

  void __set_o3(const MetaException& 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 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_drop_database_presult__isset;

class ThriftHiveMetastore_drop_database_presult {
 public:


  virtual ~ThriftHiveMetastore_drop_database_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_get_databases_args__isset;

class ThriftHiveMetastore_get_databases_args {
 public:

  ThriftHiveMetastore_get_databases_args(const ThriftHiveMetastore_get_databases_args&);
  ThriftHiveMetastore_get_databases_args& operator=(const ThriftHiveMetastore_get_databases_args&);
  ThriftHiveMetastore_get_databases_args() noexcept
                                         : pattern() {
  }

  virtual ~ThriftHiveMetastore_get_databases_args() noexcept;
  std::string pattern;

  _ThriftHiveMetastore_get_databases_args__isset __isset;

  void __set_pattern(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_databases_result__isset;

class ThriftHiveMetastore_get_databases_result {
 public:

  ThriftHiveMetastore_get_databases_result(const ThriftHiveMetastore_get_databases_result&);
  ThriftHiveMetastore_get_databases_result& operator=(const ThriftHiveMetastore_get_databases_result&);
  ThriftHiveMetastore_get_databases_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_databases_result() noexcept;
  std::vector<std::string>  success;
  MetaException o1;

  _ThriftHiveMetastore_get_databases_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_databases_presult__isset;

class ThriftHiveMetastore_get_databases_presult {
 public:


  virtual ~ThriftHiveMetastore_get_databases_presult() noexcept;
  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(const ThriftHiveMetastore_get_all_databases_args&) noexcept;
  ThriftHiveMetastore_get_all_databases_args& operator=(const ThriftHiveMetastore_get_all_databases_args&) noexcept;
  ThriftHiveMetastore_get_all_databases_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_all_databases_args() noexcept;

  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() noexcept;

  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_all_databases_result__isset;

class ThriftHiveMetastore_get_all_databases_result {
 public:

  ThriftHiveMetastore_get_all_databases_result(const ThriftHiveMetastore_get_all_databases_result&);
  ThriftHiveMetastore_get_all_databases_result& operator=(const ThriftHiveMetastore_get_all_databases_result&);
  ThriftHiveMetastore_get_all_databases_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_all_databases_result() noexcept;
  std::vector<std::string>  success;
  MetaException o1;

  _ThriftHiveMetastore_get_all_databases_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_all_databases_presult__isset;

class ThriftHiveMetastore_get_all_databases_presult {
 public:


  virtual ~ThriftHiveMetastore_get_all_databases_presult() noexcept;
  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 :1;
  bool db :1;
} _ThriftHiveMetastore_alter_database_args__isset;

class ThriftHiveMetastore_alter_database_args {
 public:

  ThriftHiveMetastore_alter_database_args(const ThriftHiveMetastore_alter_database_args&);
  ThriftHiveMetastore_alter_database_args& operator=(const ThriftHiveMetastore_alter_database_args&);
  ThriftHiveMetastore_alter_database_args() noexcept
                                          : dbname() {
  }

  virtual ~ThriftHiveMetastore_alter_database_args() noexcept;
  std::string dbname;
  Database db;

  _ThriftHiveMetastore_alter_database_args__isset __isset;

  void __set_dbname(const std::string& val);

  void __set_db(const Database& 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() noexcept;
  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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_alter_database_result__isset;

class ThriftHiveMetastore_alter_database_result {
 public:

  ThriftHiveMetastore_alter_database_result(const ThriftHiveMetastore_alter_database_result&);
  ThriftHiveMetastore_alter_database_result& operator=(const ThriftHiveMetastore_alter_database_result&);
  ThriftHiveMetastore_alter_database_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_database_result() noexcept;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_alter_database_result__isset __isset;

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& 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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_alter_database_presult__isset;

class ThriftHiveMetastore_alter_database_presult {
 public:


  virtual ~ThriftHiveMetastore_alter_database_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_get_type_args__isset;

class ThriftHiveMetastore_get_type_args {
 public:

  ThriftHiveMetastore_get_type_args(const ThriftHiveMetastore_get_type_args&);
  ThriftHiveMetastore_get_type_args& operator=(const ThriftHiveMetastore_get_type_args&);
  ThriftHiveMetastore_get_type_args() noexcept
                                    : name() {
  }

  virtual ~ThriftHiveMetastore_get_type_args() noexcept;
  std::string name;

  _ThriftHiveMetastore_get_type_args__isset __isset;

  void __set_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_type_result__isset;

class ThriftHiveMetastore_get_type_result {
 public:

  ThriftHiveMetastore_get_type_result(const ThriftHiveMetastore_get_type_result&);
  ThriftHiveMetastore_get_type_result& operator=(const ThriftHiveMetastore_get_type_result&);
  ThriftHiveMetastore_get_type_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_type_result() noexcept;
  Type success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_type_result__isset __isset;

  void __set_success(const Type& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_type_presult__isset;

class ThriftHiveMetastore_get_type_presult {
 public:


  virtual ~ThriftHiveMetastore_get_type_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_create_type_args__isset;

class ThriftHiveMetastore_create_type_args {
 public:

  ThriftHiveMetastore_create_type_args(const ThriftHiveMetastore_create_type_args&);
  ThriftHiveMetastore_create_type_args& operator=(const ThriftHiveMetastore_create_type_args&);
  ThriftHiveMetastore_create_type_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_type_args() noexcept;
  Type type;

  _ThriftHiveMetastore_create_type_args__isset __isset;

  void __set_type(const 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_create_type_result__isset;

class ThriftHiveMetastore_create_type_result {
 public:

  ThriftHiveMetastore_create_type_result(const ThriftHiveMetastore_create_type_result&);
  ThriftHiveMetastore_create_type_result& operator=(const ThriftHiveMetastore_create_type_result&);
  ThriftHiveMetastore_create_type_result() noexcept
                                         : success(0) {
  }

  virtual ~ThriftHiveMetastore_create_type_result() noexcept;
  bool success;
  AlreadyExistsException o1;
  InvalidObjectException o2;
  MetaException o3;

  _ThriftHiveMetastore_create_type_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const AlreadyExistsException& val);

  void __set_o2(const InvalidObjectException& val);

  void __set_o3(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_create_type_presult__isset;

class ThriftHiveMetastore_create_type_presult {
 public:


  virtual ~ThriftHiveMetastore_create_type_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_drop_type_args__isset;

class ThriftHiveMetastore_drop_type_args {
 public:

  ThriftHiveMetastore_drop_type_args(const ThriftHiveMetastore_drop_type_args&);
  ThriftHiveMetastore_drop_type_args& operator=(const ThriftHiveMetastore_drop_type_args&);
  ThriftHiveMetastore_drop_type_args() noexcept
                                     : type() {
  }

  virtual ~ThriftHiveMetastore_drop_type_args() noexcept;
  std::string type;

  _ThriftHiveMetastore_drop_type_args__isset __isset;

  void __set_type(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_drop_type_result__isset;

class ThriftHiveMetastore_drop_type_result {
 public:

  ThriftHiveMetastore_drop_type_result(const ThriftHiveMetastore_drop_type_result&);
  ThriftHiveMetastore_drop_type_result& operator=(const ThriftHiveMetastore_drop_type_result&);
  ThriftHiveMetastore_drop_type_result() noexcept
                                       : success(0) {
  }

  virtual ~ThriftHiveMetastore_drop_type_result() noexcept;
  bool success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_drop_type_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_drop_type_presult__isset;

class ThriftHiveMetastore_drop_type_presult {
 public:


  virtual ~ThriftHiveMetastore_drop_type_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_get_type_all_args__isset;

class ThriftHiveMetastore_get_type_all_args {
 public:

  ThriftHiveMetastore_get_type_all_args(const ThriftHiveMetastore_get_type_all_args&);
  ThriftHiveMetastore_get_type_all_args& operator=(const ThriftHiveMetastore_get_type_all_args&);
  ThriftHiveMetastore_get_type_all_args() noexcept
                                        : name() {
  }

  virtual ~ThriftHiveMetastore_get_type_all_args() noexcept;
  std::string name;

  _ThriftHiveMetastore_get_type_all_args__isset __isset;

  void __set_name(const std::string& 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() noexcept;
  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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_type_all_result__isset;

class ThriftHiveMetastore_get_type_all_result {
 public:

  ThriftHiveMetastore_get_type_all_result(const ThriftHiveMetastore_get_type_all_result&);
  ThriftHiveMetastore_get_type_all_result& operator=(const ThriftHiveMetastore_get_type_all_result&);
  ThriftHiveMetastore_get_type_all_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_type_all_result() noexcept;
  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);

  void __set_o2(const MetaException& 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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_type_all_presult__isset;

class ThriftHiveMetastore_get_type_all_presult {
 public:


  virtual ~ThriftHiveMetastore_get_type_all_presult() noexcept;
  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 :1;
  bool table_name :1;
} _ThriftHiveMetastore_get_fields_args__isset;

class ThriftHiveMetastore_get_fields_args {
 public:

  ThriftHiveMetastore_get_fields_args(const ThriftHiveMetastore_get_fields_args&);
  ThriftHiveMetastore_get_fields_args& operator=(const ThriftHiveMetastore_get_fields_args&);
  ThriftHiveMetastore_get_fields_args() noexcept
                                      : db_name(),
                                        table_name() {
  }

  virtual ~ThriftHiveMetastore_get_fields_args() noexcept;
  std::string db_name;
  std::string table_name;

  _ThriftHiveMetastore_get_fields_args__isset __isset;

  void __set_db_name(const std::string& val);

  void __set_table_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_get_fields_result__isset;

class ThriftHiveMetastore_get_fields_result {
 public:

  ThriftHiveMetastore_get_fields_result(const ThriftHiveMetastore_get_fields_result&);
  ThriftHiveMetastore_get_fields_result& operator=(const ThriftHiveMetastore_get_fields_result&);
  ThriftHiveMetastore_get_fields_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_fields_result() noexcept;
  std::vector<FieldSchema>  success;
  MetaException o1;
  UnknownTableException o2;
  UnknownDBException o3;

  _ThriftHiveMetastore_get_fields_result__isset __isset;

  void __set_success(const std::vector<FieldSchema> & val);

  void __set_o1(const MetaException& val);

  void __set_o2(const UnknownTableException& val);

  void __set_o3(const UnknownDBException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_get_fields_presult__isset;

class ThriftHiveMetastore_get_fields_presult {
 public:


  virtual ~ThriftHiveMetastore_get_fields_presult() noexcept;
  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 :1;
  bool table_name :1;
  bool environment_context :1;
} _ThriftHiveMetastore_get_fields_with_environment_context_args__isset;

class ThriftHiveMetastore_get_fields_with_environment_context_args {
 public:

  ThriftHiveMetastore_get_fields_with_environment_context_args(const ThriftHiveMetastore_get_fields_with_environment_context_args&);
  ThriftHiveMetastore_get_fields_with_environment_context_args& operator=(const ThriftHiveMetastore_get_fields_with_environment_context_args&);
  ThriftHiveMetastore_get_fields_with_environment_context_args() noexcept
                                                               : db_name(),
                                                                 table_name() {
  }

  virtual ~ThriftHiveMetastore_get_fields_with_environment_context_args() noexcept;
  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);

  void __set_table_name(const std::string& val);

  void __set_environment_context(const EnvironmentContext& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_get_fields_with_environment_context_result__isset;

class ThriftHiveMetastore_get_fields_with_environment_context_result {
 public:

  ThriftHiveMetastore_get_fields_with_environment_context_result(const ThriftHiveMetastore_get_fields_with_environment_context_result&);
  ThriftHiveMetastore_get_fields_with_environment_context_result& operator=(const ThriftHiveMetastore_get_fields_with_environment_context_result&);
  ThriftHiveMetastore_get_fields_with_environment_context_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_fields_with_environment_context_result() noexcept;
  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);

  void __set_o1(const MetaException& val);

  void __set_o2(const UnknownTableException& val);

  void __set_o3(const UnknownDBException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _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() noexcept;
  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 :1;
  bool table_name :1;
} _ThriftHiveMetastore_get_schema_args__isset;

class ThriftHiveMetastore_get_schema_args {
 public:

  ThriftHiveMetastore_get_schema_args(const ThriftHiveMetastore_get_schema_args&);
  ThriftHiveMetastore_get_schema_args& operator=(const ThriftHiveMetastore_get_schema_args&);
  ThriftHiveMetastore_get_schema_args() noexcept
                                      : db_name(),
                                        table_name() {
  }

  virtual ~ThriftHiveMetastore_get_schema_args() noexcept;
  std::string db_name;
  std::string table_name;

  _ThriftHiveMetastore_get_schema_args__isset __isset;

  void __set_db_name(const std::string& val);

  void __set_table_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_get_schema_result__isset;

class ThriftHiveMetastore_get_schema_result {
 public:

  ThriftHiveMetastore_get_schema_result(const ThriftHiveMetastore_get_schema_result&);
  ThriftHiveMetastore_get_schema_result& operator=(const ThriftHiveMetastore_get_schema_result&);
  ThriftHiveMetastore_get_schema_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_schema_result() noexcept;
  std::vector<FieldSchema>  success;
  MetaException o1;
  UnknownTableException o2;
  UnknownDBException o3;

  _ThriftHiveMetastore_get_schema_result__isset __isset;

  void __set_success(const std::vector<FieldSchema> & val);

  void __set_o1(const MetaException& val);

  void __set_o2(const UnknownTableException& val);

  void __set_o3(const UnknownDBException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_get_schema_presult__isset;

class ThriftHiveMetastore_get_schema_presult {
 public:


  virtual ~ThriftHiveMetastore_get_schema_presult() noexcept;
  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 :1;
  bool table_name :1;
  bool environment_context :1;
} _ThriftHiveMetastore_get_schema_with_environment_context_args__isset;

class ThriftHiveMetastore_get_schema_with_environment_context_args {
 public:

  ThriftHiveMetastore_get_schema_with_environment_context_args(const ThriftHiveMetastore_get_schema_with_environment_context_args&);
  ThriftHiveMetastore_get_schema_with_environment_context_args& operator=(const ThriftHiveMetastore_get_schema_with_environment_context_args&);
  ThriftHiveMetastore_get_schema_with_environment_context_args() noexcept
                                                               : db_name(),
                                                                 table_name() {
  }

  virtual ~ThriftHiveMetastore_get_schema_with_environment_context_args() noexcept;
  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);

  void __set_table_name(const std::string& val);

  void __set_environment_context(const EnvironmentContext& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_get_schema_with_environment_context_result__isset;

class ThriftHiveMetastore_get_schema_with_environment_context_result {
 public:

  ThriftHiveMetastore_get_schema_with_environment_context_result(const ThriftHiveMetastore_get_schema_with_environment_context_result&);
  ThriftHiveMetastore_get_schema_with_environment_context_result& operator=(const ThriftHiveMetastore_get_schema_with_environment_context_result&);
  ThriftHiveMetastore_get_schema_with_environment_context_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_schema_with_environment_context_result() noexcept;
  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);

  void __set_o1(const MetaException& val);

  void __set_o2(const UnknownTableException& val);

  void __set_o3(const UnknownDBException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _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() noexcept;
  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 :1;
} _ThriftHiveMetastore_create_table_args__isset;

class ThriftHiveMetastore_create_table_args {
 public:

  ThriftHiveMetastore_create_table_args(const ThriftHiveMetastore_create_table_args&);
  ThriftHiveMetastore_create_table_args& operator=(const ThriftHiveMetastore_create_table_args&);
  ThriftHiveMetastore_create_table_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_table_args() noexcept;
  Table tbl;

  _ThriftHiveMetastore_create_table_args__isset __isset;

  void __set_tbl(const Table& 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() noexcept;
  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 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_create_table_result__isset;

class ThriftHiveMetastore_create_table_result {
 public:

  ThriftHiveMetastore_create_table_result(const ThriftHiveMetastore_create_table_result&);
  ThriftHiveMetastore_create_table_result& operator=(const ThriftHiveMetastore_create_table_result&);
  ThriftHiveMetastore_create_table_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_table_result() noexcept;
  AlreadyExistsException o1;
  InvalidObjectException o2;
  MetaException o3;
  NoSuchObjectException o4;

  _ThriftHiveMetastore_create_table_result__isset __isset;

  void __set_o1(const AlreadyExistsException& val);

  void __set_o2(const InvalidObjectException& val);

  void __set_o3(const MetaException& val);

  void __set_o4(const NoSuchObjectException& 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 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_create_table_presult__isset;

class ThriftHiveMetastore_create_table_presult {
 public:


  virtual ~ThriftHiveMetastore_create_table_presult() noexcept;
  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 :1;
  bool environment_context :1;
} _ThriftHiveMetastore_create_table_with_environment_context_args__isset;

class ThriftHiveMetastore_create_table_with_environment_context_args {
 public:

  ThriftHiveMetastore_create_table_with_environment_context_args(const ThriftHiveMetastore_create_table_with_environment_context_args&);
  ThriftHiveMetastore_create_table_with_environment_context_args& operator=(const ThriftHiveMetastore_create_table_with_environment_context_args&);
  ThriftHiveMetastore_create_table_with_environment_context_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_table_with_environment_context_args() noexcept;
  Table tbl;
  EnvironmentContext environment_context;

  _ThriftHiveMetastore_create_table_with_environment_context_args__isset __isset;

  void __set_tbl(const Table& val);

  void __set_environment_context(const EnvironmentContext& 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() noexcept;
  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 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_create_table_with_environment_context_result__isset;

class ThriftHiveMetastore_create_table_with_environment_context_result {
 public:

  ThriftHiveMetastore_create_table_with_environment_context_result(const ThriftHiveMetastore_create_table_with_environment_context_result&);
  ThriftHiveMetastore_create_table_with_environment_context_result& operator=(const ThriftHiveMetastore_create_table_with_environment_context_result&);
  ThriftHiveMetastore_create_table_with_environment_context_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_table_with_environment_context_result() noexcept;
  AlreadyExistsException o1;
  InvalidObjectException o2;
  MetaException o3;
  NoSuchObjectException o4;

  _ThriftHiveMetastore_create_table_with_environment_context_result__isset __isset;

  void __set_o1(const AlreadyExistsException& val);

  void __set_o2(const InvalidObjectException& val);

  void __set_o3(const MetaException& val);

  void __set_o4(const NoSuchObjectException& 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 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _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() noexcept;
  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_create_table_with_constraints_args__isset {
  _ThriftHiveMetastore_create_table_with_constraints_args__isset() : tbl(false), primaryKeys(false), foreignKeys(false), uniqueConstraints(false), notNullConstraints(false), defaultConstraints(false), checkConstraints(false) {}
  bool tbl :1;
  bool primaryKeys :1;
  bool foreignKeys :1;
  bool uniqueConstraints :1;
  bool notNullConstraints :1;
  bool defaultConstraints :1;
  bool checkConstraints :1;
} _ThriftHiveMetastore_create_table_with_constraints_args__isset;

class ThriftHiveMetastore_create_table_with_constraints_args {
 public:

  ThriftHiveMetastore_create_table_with_constraints_args(const ThriftHiveMetastore_create_table_with_constraints_args&);
  ThriftHiveMetastore_create_table_with_constraints_args& operator=(const ThriftHiveMetastore_create_table_with_constraints_args&);
  ThriftHiveMetastore_create_table_with_constraints_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_table_with_constraints_args() noexcept;
  Table tbl;
  std::vector<SQLPrimaryKey>  primaryKeys;
  std::vector<SQLForeignKey>  foreignKeys;
  std::vector<SQLUniqueConstraint>  uniqueConstraints;
  std::vector<SQLNotNullConstraint>  notNullConstraints;
  std::vector<SQLDefaultConstraint>  defaultConstraints;
  std::vector<SQLCheckConstraint>  checkConstraints;

  _ThriftHiveMetastore_create_table_with_constraints_args__isset __isset;

  void __set_tbl(const Table& val);

  void __set_primaryKeys(const std::vector<SQLPrimaryKey> & val);

  void __set_foreignKeys(const std::vector<SQLForeignKey> & val);

  void __set_uniqueConstraints(const std::vector<SQLUniqueConstraint> & val);

  void __set_notNullConstraints(const std::vector<SQLNotNullConstraint> & val);

  void __set_defaultConstraints(const std::vector<SQLDefaultConstraint> & val);

  void __set_checkConstraints(const std::vector<SQLCheckConstraint> & val);

  bool operator == (const ThriftHiveMetastore_create_table_with_constraints_args & rhs) const
  {
    if (!(tbl == rhs.tbl))
      return false;
    if (!(primaryKeys == rhs.primaryKeys))
      return false;
    if (!(foreignKeys == rhs.foreignKeys))
      return false;
    if (!(uniqueConstraints == rhs.uniqueConstraints))
      return false;
    if (!(notNullConstraints == rhs.notNullConstraints))
      return false;
    if (!(defaultConstraints == rhs.defaultConstraints))
      return false;
    if (!(checkConstraints == rhs.checkConstraints))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_create_table_with_constraints_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_create_table_with_constraints_args & ) const;

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

};


class ThriftHiveMetastore_create_table_with_constraints_pargs {
 public:


  virtual ~ThriftHiveMetastore_create_table_with_constraints_pargs() noexcept;
  const Table* tbl;
  const std::vector<SQLPrimaryKey> * primaryKeys;
  const std::vector<SQLForeignKey> * foreignKeys;
  const std::vector<SQLUniqueConstraint> * uniqueConstraints;
  const std::vector<SQLNotNullConstraint> * notNullConstraints;
  const std::vector<SQLDefaultConstraint> * defaultConstraints;
  const std::vector<SQLCheckConstraint> * checkConstraints;

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

};

typedef struct _ThriftHiveMetastore_create_table_with_constraints_result__isset {
  _ThriftHiveMetastore_create_table_with_constraints_result__isset() : o1(false), o2(false), o3(false), o4(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_create_table_with_constraints_result__isset;

class ThriftHiveMetastore_create_table_with_constraints_result {
 public:

  ThriftHiveMetastore_create_table_with_constraints_result(const ThriftHiveMetastore_create_table_with_constraints_result&);
  ThriftHiveMetastore_create_table_with_constraints_result& operator=(const ThriftHiveMetastore_create_table_with_constraints_result&);
  ThriftHiveMetastore_create_table_with_constraints_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_table_with_constraints_result() noexcept;
  AlreadyExistsException o1;
  InvalidObjectException o2;
  MetaException o3;
  NoSuchObjectException o4;

  _ThriftHiveMetastore_create_table_with_constraints_result__isset __isset;

  void __set_o1(const AlreadyExistsException& val);

  void __set_o2(const InvalidObjectException& val);

  void __set_o3(const MetaException& val);

  void __set_o4(const NoSuchObjectException& val);

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

  bool operator < (const ThriftHiveMetastore_create_table_with_constraints_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_constraints_presult__isset {
  _ThriftHiveMetastore_create_table_with_constraints_presult__isset() : o1(false), o2(false), o3(false), o4(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_create_table_with_constraints_presult__isset;

class ThriftHiveMetastore_create_table_with_constraints_presult {
 public:


  virtual ~ThriftHiveMetastore_create_table_with_constraints_presult() noexcept;
  AlreadyExistsException o1;
  InvalidObjectException o2;
  MetaException o3;
  NoSuchObjectException o4;

  _ThriftHiveMetastore_create_table_with_constraints_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_drop_constraint_args__isset {
  _ThriftHiveMetastore_drop_constraint_args__isset() : req(false) {}
  bool req :1;
} _ThriftHiveMetastore_drop_constraint_args__isset;

class ThriftHiveMetastore_drop_constraint_args {
 public:

  ThriftHiveMetastore_drop_constraint_args(const ThriftHiveMetastore_drop_constraint_args&);
  ThriftHiveMetastore_drop_constraint_args& operator=(const ThriftHiveMetastore_drop_constraint_args&);
  ThriftHiveMetastore_drop_constraint_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_constraint_args() noexcept;
  DropConstraintRequest req;

  _ThriftHiveMetastore_drop_constraint_args__isset __isset;

  void __set_req(const DropConstraintRequest& val);

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

  bool operator < (const ThriftHiveMetastore_drop_constraint_args & ) const;

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

};


class ThriftHiveMetastore_drop_constraint_pargs {
 public:


  virtual ~ThriftHiveMetastore_drop_constraint_pargs() noexcept;
  const DropConstraintRequest* req;

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

};

typedef struct _ThriftHiveMetastore_drop_constraint_result__isset {
  _ThriftHiveMetastore_drop_constraint_result__isset() : o1(false), o3(false) {}
  bool o1 :1;
  bool o3 :1;
} _ThriftHiveMetastore_drop_constraint_result__isset;

class ThriftHiveMetastore_drop_constraint_result {
 public:

  ThriftHiveMetastore_drop_constraint_result(const ThriftHiveMetastore_drop_constraint_result&);
  ThriftHiveMetastore_drop_constraint_result& operator=(const ThriftHiveMetastore_drop_constraint_result&);
  ThriftHiveMetastore_drop_constraint_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_constraint_result() noexcept;
  NoSuchObjectException o1;
  MetaException o3;

  _ThriftHiveMetastore_drop_constraint_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o3(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_drop_constraint_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_drop_constraint_presult__isset {
  _ThriftHiveMetastore_drop_constraint_presult__isset() : o1(false), o3(false) {}
  bool o1 :1;
  bool o3 :1;
} _ThriftHiveMetastore_drop_constraint_presult__isset;

class ThriftHiveMetastore_drop_constraint_presult {
 public:


  virtual ~ThriftHiveMetastore_drop_constraint_presult() noexcept;
  NoSuchObjectException o1;
  MetaException o3;

  _ThriftHiveMetastore_drop_constraint_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_add_primary_key_args__isset {
  _ThriftHiveMetastore_add_primary_key_args__isset() : req(false) {}
  bool req :1;
} _ThriftHiveMetastore_add_primary_key_args__isset;

class ThriftHiveMetastore_add_primary_key_args {
 public:

  ThriftHiveMetastore_add_primary_key_args(const ThriftHiveMetastore_add_primary_key_args&);
  ThriftHiveMetastore_add_primary_key_args& operator=(const ThriftHiveMetastore_add_primary_key_args&);
  ThriftHiveMetastore_add_primary_key_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_primary_key_args() noexcept;
  AddPrimaryKeyRequest req;

  _ThriftHiveMetastore_add_primary_key_args__isset __isset;

  void __set_req(const AddPrimaryKeyRequest& val);

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

  bool operator < (const ThriftHiveMetastore_add_primary_key_args & ) const;

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

};


class ThriftHiveMetastore_add_primary_key_pargs {
 public:


  virtual ~ThriftHiveMetastore_add_primary_key_pargs() noexcept;
  const AddPrimaryKeyRequest* req;

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

};

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

class ThriftHiveMetastore_add_primary_key_result {
 public:

  ThriftHiveMetastore_add_primary_key_result(const ThriftHiveMetastore_add_primary_key_result&);
  ThriftHiveMetastore_add_primary_key_result& operator=(const ThriftHiveMetastore_add_primary_key_result&);
  ThriftHiveMetastore_add_primary_key_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_primary_key_result() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_add_primary_key_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_add_primary_key_result & ) const;

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

};

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

class ThriftHiveMetastore_add_primary_key_presult {
 public:


  virtual ~ThriftHiveMetastore_add_primary_key_presult() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_add_primary_key_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_add_foreign_key_args__isset {
  _ThriftHiveMetastore_add_foreign_key_args__isset() : req(false) {}
  bool req :1;
} _ThriftHiveMetastore_add_foreign_key_args__isset;

class ThriftHiveMetastore_add_foreign_key_args {
 public:

  ThriftHiveMetastore_add_foreign_key_args(const ThriftHiveMetastore_add_foreign_key_args&);
  ThriftHiveMetastore_add_foreign_key_args& operator=(const ThriftHiveMetastore_add_foreign_key_args&);
  ThriftHiveMetastore_add_foreign_key_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_foreign_key_args() noexcept;
  AddForeignKeyRequest req;

  _ThriftHiveMetastore_add_foreign_key_args__isset __isset;

  void __set_req(const AddForeignKeyRequest& val);

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

  bool operator < (const ThriftHiveMetastore_add_foreign_key_args & ) const;

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

};


class ThriftHiveMetastore_add_foreign_key_pargs {
 public:


  virtual ~ThriftHiveMetastore_add_foreign_key_pargs() noexcept;
  const AddForeignKeyRequest* req;

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

};

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

class ThriftHiveMetastore_add_foreign_key_result {
 public:

  ThriftHiveMetastore_add_foreign_key_result(const ThriftHiveMetastore_add_foreign_key_result&);
  ThriftHiveMetastore_add_foreign_key_result& operator=(const ThriftHiveMetastore_add_foreign_key_result&);
  ThriftHiveMetastore_add_foreign_key_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_foreign_key_result() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_add_foreign_key_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_add_foreign_key_result & ) const;

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

};

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

class ThriftHiveMetastore_add_foreign_key_presult {
 public:


  virtual ~ThriftHiveMetastore_add_foreign_key_presult() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_add_foreign_key_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_add_unique_constraint_args__isset {
  _ThriftHiveMetastore_add_unique_constraint_args__isset() : req(false) {}
  bool req :1;
} _ThriftHiveMetastore_add_unique_constraint_args__isset;

class ThriftHiveMetastore_add_unique_constraint_args {
 public:

  ThriftHiveMetastore_add_unique_constraint_args(const ThriftHiveMetastore_add_unique_constraint_args&);
  ThriftHiveMetastore_add_unique_constraint_args& operator=(const ThriftHiveMetastore_add_unique_constraint_args&);
  ThriftHiveMetastore_add_unique_constraint_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_unique_constraint_args() noexcept;
  AddUniqueConstraintRequest req;

  _ThriftHiveMetastore_add_unique_constraint_args__isset __isset;

  void __set_req(const AddUniqueConstraintRequest& val);

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

  bool operator < (const ThriftHiveMetastore_add_unique_constraint_args & ) const;

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

};


class ThriftHiveMetastore_add_unique_constraint_pargs {
 public:


  virtual ~ThriftHiveMetastore_add_unique_constraint_pargs() noexcept;
  const AddUniqueConstraintRequest* req;

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

};

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

class ThriftHiveMetastore_add_unique_constraint_result {
 public:

  ThriftHiveMetastore_add_unique_constraint_result(const ThriftHiveMetastore_add_unique_constraint_result&);
  ThriftHiveMetastore_add_unique_constraint_result& operator=(const ThriftHiveMetastore_add_unique_constraint_result&);
  ThriftHiveMetastore_add_unique_constraint_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_unique_constraint_result() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_add_unique_constraint_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_add_unique_constraint_result & ) const;

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

};

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

class ThriftHiveMetastore_add_unique_constraint_presult {
 public:


  virtual ~ThriftHiveMetastore_add_unique_constraint_presult() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_add_unique_constraint_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_add_not_null_constraint_args__isset {
  _ThriftHiveMetastore_add_not_null_constraint_args__isset() : req(false) {}
  bool req :1;
} _ThriftHiveMetastore_add_not_null_constraint_args__isset;

class ThriftHiveMetastore_add_not_null_constraint_args {
 public:

  ThriftHiveMetastore_add_not_null_constraint_args(const ThriftHiveMetastore_add_not_null_constraint_args&);
  ThriftHiveMetastore_add_not_null_constraint_args& operator=(const ThriftHiveMetastore_add_not_null_constraint_args&);
  ThriftHiveMetastore_add_not_null_constraint_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_not_null_constraint_args() noexcept;
  AddNotNullConstraintRequest req;

  _ThriftHiveMetastore_add_not_null_constraint_args__isset __isset;

  void __set_req(const AddNotNullConstraintRequest& val);

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

  bool operator < (const ThriftHiveMetastore_add_not_null_constraint_args & ) const;

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

};


class ThriftHiveMetastore_add_not_null_constraint_pargs {
 public:


  virtual ~ThriftHiveMetastore_add_not_null_constraint_pargs() noexcept;
  const AddNotNullConstraintRequest* req;

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

};

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

class ThriftHiveMetastore_add_not_null_constraint_result {
 public:

  ThriftHiveMetastore_add_not_null_constraint_result(const ThriftHiveMetastore_add_not_null_constraint_result&);
  ThriftHiveMetastore_add_not_null_constraint_result& operator=(const ThriftHiveMetastore_add_not_null_constraint_result&);
  ThriftHiveMetastore_add_not_null_constraint_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_not_null_constraint_result() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_add_not_null_constraint_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_add_not_null_constraint_result & ) const;

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

};

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

class ThriftHiveMetastore_add_not_null_constraint_presult {
 public:


  virtual ~ThriftHiveMetastore_add_not_null_constraint_presult() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_add_not_null_constraint_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_add_default_constraint_args__isset {
  _ThriftHiveMetastore_add_default_constraint_args__isset() : req(false) {}
  bool req :1;
} _ThriftHiveMetastore_add_default_constraint_args__isset;

class ThriftHiveMetastore_add_default_constraint_args {
 public:

  ThriftHiveMetastore_add_default_constraint_args(const ThriftHiveMetastore_add_default_constraint_args&);
  ThriftHiveMetastore_add_default_constraint_args& operator=(const ThriftHiveMetastore_add_default_constraint_args&);
  ThriftHiveMetastore_add_default_constraint_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_default_constraint_args() noexcept;
  AddDefaultConstraintRequest req;

  _ThriftHiveMetastore_add_default_constraint_args__isset __isset;

  void __set_req(const AddDefaultConstraintRequest& val);

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

  bool operator < (const ThriftHiveMetastore_add_default_constraint_args & ) const;

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

};


class ThriftHiveMetastore_add_default_constraint_pargs {
 public:


  virtual ~ThriftHiveMetastore_add_default_constraint_pargs() noexcept;
  const AddDefaultConstraintRequest* req;

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

};

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

class ThriftHiveMetastore_add_default_constraint_result {
 public:

  ThriftHiveMetastore_add_default_constraint_result(const ThriftHiveMetastore_add_default_constraint_result&);
  ThriftHiveMetastore_add_default_constraint_result& operator=(const ThriftHiveMetastore_add_default_constraint_result&);
  ThriftHiveMetastore_add_default_constraint_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_default_constraint_result() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_add_default_constraint_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_add_default_constraint_result & ) const;

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

};

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

class ThriftHiveMetastore_add_default_constraint_presult {
 public:


  virtual ~ThriftHiveMetastore_add_default_constraint_presult() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_add_default_constraint_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_add_check_constraint_args__isset {
  _ThriftHiveMetastore_add_check_constraint_args__isset() : req(false) {}
  bool req :1;
} _ThriftHiveMetastore_add_check_constraint_args__isset;

class ThriftHiveMetastore_add_check_constraint_args {
 public:

  ThriftHiveMetastore_add_check_constraint_args(const ThriftHiveMetastore_add_check_constraint_args&);
  ThriftHiveMetastore_add_check_constraint_args& operator=(const ThriftHiveMetastore_add_check_constraint_args&);
  ThriftHiveMetastore_add_check_constraint_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_check_constraint_args() noexcept;
  AddCheckConstraintRequest req;

  _ThriftHiveMetastore_add_check_constraint_args__isset __isset;

  void __set_req(const AddCheckConstraintRequest& val);

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

  bool operator < (const ThriftHiveMetastore_add_check_constraint_args & ) const;

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

};


class ThriftHiveMetastore_add_check_constraint_pargs {
 public:


  virtual ~ThriftHiveMetastore_add_check_constraint_pargs() noexcept;
  const AddCheckConstraintRequest* req;

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

};

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

class ThriftHiveMetastore_add_check_constraint_result {
 public:

  ThriftHiveMetastore_add_check_constraint_result(const ThriftHiveMetastore_add_check_constraint_result&);
  ThriftHiveMetastore_add_check_constraint_result& operator=(const ThriftHiveMetastore_add_check_constraint_result&);
  ThriftHiveMetastore_add_check_constraint_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_check_constraint_result() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_add_check_constraint_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_add_check_constraint_result & ) const;

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

};

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

class ThriftHiveMetastore_add_check_constraint_presult {
 public:


  virtual ~ThriftHiveMetastore_add_check_constraint_presult() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_add_check_constraint_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 :1;
  bool name :1;
  bool deleteData :1;
} _ThriftHiveMetastore_drop_table_args__isset;

class ThriftHiveMetastore_drop_table_args {
 public:

  ThriftHiveMetastore_drop_table_args(const ThriftHiveMetastore_drop_table_args&);
  ThriftHiveMetastore_drop_table_args& operator=(const ThriftHiveMetastore_drop_table_args&);
  ThriftHiveMetastore_drop_table_args() noexcept
                                      : dbname(),
                                        name(),
                                        deleteData(0) {
  }

  virtual ~ThriftHiveMetastore_drop_table_args() noexcept;
  std::string dbname;
  std::string name;
  bool deleteData;

  _ThriftHiveMetastore_drop_table_args__isset __isset;

  void __set_dbname(const std::string& val);

  void __set_name(const std::string& val);

  void __set_deleteData(const bool 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() noexcept;
  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 :1;
  bool o3 :1;
} _ThriftHiveMetastore_drop_table_result__isset;

class ThriftHiveMetastore_drop_table_result {
 public:

  ThriftHiveMetastore_drop_table_result(const ThriftHiveMetastore_drop_table_result&);
  ThriftHiveMetastore_drop_table_result& operator=(const ThriftHiveMetastore_drop_table_result&);
  ThriftHiveMetastore_drop_table_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_table_result() noexcept;
  NoSuchObjectException o1;
  MetaException o3;

  _ThriftHiveMetastore_drop_table_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o3(const MetaException& 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 :1;
  bool o3 :1;
} _ThriftHiveMetastore_drop_table_presult__isset;

class ThriftHiveMetastore_drop_table_presult {
 public:


  virtual ~ThriftHiveMetastore_drop_table_presult() noexcept;
  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 :1;
  bool name :1;
  bool deleteData :1;
  bool environment_context :1;
} _ThriftHiveMetastore_drop_table_with_environment_context_args__isset;

class ThriftHiveMetastore_drop_table_with_environment_context_args {
 public:

  ThriftHiveMetastore_drop_table_with_environment_context_args(const ThriftHiveMetastore_drop_table_with_environment_context_args&);
  ThriftHiveMetastore_drop_table_with_environment_context_args& operator=(const ThriftHiveMetastore_drop_table_with_environment_context_args&);
  ThriftHiveMetastore_drop_table_with_environment_context_args() noexcept
                                                               : dbname(),
                                                                 name(),
                                                                 deleteData(0) {
  }

  virtual ~ThriftHiveMetastore_drop_table_with_environment_context_args() noexcept;
  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);

  void __set_name(const std::string& val);

  void __set_deleteData(const bool val);

  void __set_environment_context(const EnvironmentContext& 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() noexcept;
  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 :1;
  bool o3 :1;
} _ThriftHiveMetastore_drop_table_with_environment_context_result__isset;

class ThriftHiveMetastore_drop_table_with_environment_context_result {
 public:

  ThriftHiveMetastore_drop_table_with_environment_context_result(const ThriftHiveMetastore_drop_table_with_environment_context_result&);
  ThriftHiveMetastore_drop_table_with_environment_context_result& operator=(const ThriftHiveMetastore_drop_table_with_environment_context_result&);
  ThriftHiveMetastore_drop_table_with_environment_context_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_table_with_environment_context_result() noexcept;
  NoSuchObjectException o1;
  MetaException o3;

  _ThriftHiveMetastore_drop_table_with_environment_context_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o3(const MetaException& 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 :1;
  bool o3 :1;
} _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() noexcept;
  NoSuchObjectException o1;
  MetaException o3;

  _ThriftHiveMetastore_drop_table_with_environment_context_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_truncate_table_args__isset {
  _ThriftHiveMetastore_truncate_table_args__isset() : dbName(false), tableName(false), partNames(false) {}
  bool dbName :1;
  bool tableName :1;
  bool partNames :1;
} _ThriftHiveMetastore_truncate_table_args__isset;

class ThriftHiveMetastore_truncate_table_args {
 public:

  ThriftHiveMetastore_truncate_table_args(const ThriftHiveMetastore_truncate_table_args&);
  ThriftHiveMetastore_truncate_table_args& operator=(const ThriftHiveMetastore_truncate_table_args&);
  ThriftHiveMetastore_truncate_table_args() noexcept
                                          : dbName(),
                                            tableName() {
  }

  virtual ~ThriftHiveMetastore_truncate_table_args() noexcept;
  std::string dbName;
  std::string tableName;
  std::vector<std::string>  partNames;

  _ThriftHiveMetastore_truncate_table_args__isset __isset;

  void __set_dbName(const std::string& val);

  void __set_tableName(const std::string& val);

  void __set_partNames(const std::vector<std::string> & val);

  bool operator == (const ThriftHiveMetastore_truncate_table_args & rhs) const
  {
    if (!(dbName == rhs.dbName))
      return false;
    if (!(tableName == rhs.tableName))
      return false;
    if (!(partNames == rhs.partNames))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_truncate_table_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_truncate_table_args & ) const;

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

};


class ThriftHiveMetastore_truncate_table_pargs {
 public:


  virtual ~ThriftHiveMetastore_truncate_table_pargs() noexcept;
  const std::string* dbName;
  const std::string* tableName;
  const std::vector<std::string> * partNames;

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

};

typedef struct _ThriftHiveMetastore_truncate_table_result__isset {
  _ThriftHiveMetastore_truncate_table_result__isset() : o1(false) {}
  bool o1 :1;
} _ThriftHiveMetastore_truncate_table_result__isset;

class ThriftHiveMetastore_truncate_table_result {
 public:

  ThriftHiveMetastore_truncate_table_result(const ThriftHiveMetastore_truncate_table_result&);
  ThriftHiveMetastore_truncate_table_result& operator=(const ThriftHiveMetastore_truncate_table_result&);
  ThriftHiveMetastore_truncate_table_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_truncate_table_result() noexcept;
  MetaException o1;

  _ThriftHiveMetastore_truncate_table_result__isset __isset;

  void __set_o1(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_truncate_table_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_truncate_table_presult__isset {
  _ThriftHiveMetastore_truncate_table_presult__isset() : o1(false) {}
  bool o1 :1;
} _ThriftHiveMetastore_truncate_table_presult__isset;

class ThriftHiveMetastore_truncate_table_presult {
 public:


  virtual ~ThriftHiveMetastore_truncate_table_presult() noexcept;
  MetaException o1;

  _ThriftHiveMetastore_truncate_table_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 :1;
  bool pattern :1;
} _ThriftHiveMetastore_get_tables_args__isset;

class ThriftHiveMetastore_get_tables_args {
 public:

  ThriftHiveMetastore_get_tables_args(const ThriftHiveMetastore_get_tables_args&);
  ThriftHiveMetastore_get_tables_args& operator=(const ThriftHiveMetastore_get_tables_args&);
  ThriftHiveMetastore_get_tables_args() noexcept
                                      : db_name(),
                                        pattern() {
  }

  virtual ~ThriftHiveMetastore_get_tables_args() noexcept;
  std::string db_name;
  std::string pattern;

  _ThriftHiveMetastore_get_tables_args__isset __isset;

  void __set_db_name(const std::string& val);

  void __set_pattern(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_tables_result__isset;

class ThriftHiveMetastore_get_tables_result {
 public:

  ThriftHiveMetastore_get_tables_result(const ThriftHiveMetastore_get_tables_result&);
  ThriftHiveMetastore_get_tables_result& operator=(const ThriftHiveMetastore_get_tables_result&);
  ThriftHiveMetastore_get_tables_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_tables_result() noexcept;
  std::vector<std::string>  success;
  MetaException o1;

  _ThriftHiveMetastore_get_tables_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_tables_presult__isset;

class ThriftHiveMetastore_get_tables_presult {
 public:


  virtual ~ThriftHiveMetastore_get_tables_presult() noexcept;
  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_tables_by_type_args__isset {
  _ThriftHiveMetastore_get_tables_by_type_args__isset() : db_name(false), pattern(false), tableType(false) {}
  bool db_name :1;
  bool pattern :1;
  bool tableType :1;
} _ThriftHiveMetastore_get_tables_by_type_args__isset;

class ThriftHiveMetastore_get_tables_by_type_args {
 public:

  ThriftHiveMetastore_get_tables_by_type_args(const ThriftHiveMetastore_get_tables_by_type_args&);
  ThriftHiveMetastore_get_tables_by_type_args& operator=(const ThriftHiveMetastore_get_tables_by_type_args&);
  ThriftHiveMetastore_get_tables_by_type_args() noexcept
                                              : db_name(),
                                                pattern(),
                                                tableType() {
  }

  virtual ~ThriftHiveMetastore_get_tables_by_type_args() noexcept;
  std::string db_name;
  std::string pattern;
  std::string tableType;

  _ThriftHiveMetastore_get_tables_by_type_args__isset __isset;

  void __set_db_name(const std::string& val);

  void __set_pattern(const std::string& val);

  void __set_tableType(const std::string& val);

  bool operator == (const ThriftHiveMetastore_get_tables_by_type_args & rhs) const
  {
    if (!(db_name == rhs.db_name))
      return false;
    if (!(pattern == rhs.pattern))
      return false;
    if (!(tableType == rhs.tableType))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_get_tables_by_type_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_get_tables_by_type_args & ) const;

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

};


class ThriftHiveMetastore_get_tables_by_type_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_tables_by_type_pargs() noexcept;
  const std::string* db_name;
  const std::string* pattern;
  const std::string* tableType;

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

};

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

class ThriftHiveMetastore_get_tables_by_type_result {
 public:

  ThriftHiveMetastore_get_tables_by_type_result(const ThriftHiveMetastore_get_tables_by_type_result&);
  ThriftHiveMetastore_get_tables_by_type_result& operator=(const ThriftHiveMetastore_get_tables_by_type_result&);
  ThriftHiveMetastore_get_tables_by_type_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_tables_by_type_result() noexcept;
  std::vector<std::string>  success;
  MetaException o1;

  _ThriftHiveMetastore_get_tables_by_type_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  void __set_o1(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_tables_by_type_result & ) const;

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

};

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

class ThriftHiveMetastore_get_tables_by_type_presult {
 public:


  virtual ~ThriftHiveMetastore_get_tables_by_type_presult() noexcept;
  std::vector<std::string> * success;
  MetaException o1;

  _ThriftHiveMetastore_get_tables_by_type_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_materialized_views_for_rewriting_args__isset {
  _ThriftHiveMetastore_get_materialized_views_for_rewriting_args__isset() : db_name(false) {}
  bool db_name :1;
} _ThriftHiveMetastore_get_materialized_views_for_rewriting_args__isset;

class ThriftHiveMetastore_get_materialized_views_for_rewriting_args {
 public:

  ThriftHiveMetastore_get_materialized_views_for_rewriting_args(const ThriftHiveMetastore_get_materialized_views_for_rewriting_args&);
  ThriftHiveMetastore_get_materialized_views_for_rewriting_args& operator=(const ThriftHiveMetastore_get_materialized_views_for_rewriting_args&);
  ThriftHiveMetastore_get_materialized_views_for_rewriting_args() noexcept
                                                                : db_name() {
  }

  virtual ~ThriftHiveMetastore_get_materialized_views_for_rewriting_args() noexcept;
  std::string db_name;

  _ThriftHiveMetastore_get_materialized_views_for_rewriting_args__isset __isset;

  void __set_db_name(const std::string& val);

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

  bool operator < (const ThriftHiveMetastore_get_materialized_views_for_rewriting_args & ) const;

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

};


class ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_materialized_views_for_rewriting_pargs() noexcept;
  const std::string* db_name;

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

};

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

class ThriftHiveMetastore_get_materialized_views_for_rewriting_result {
 public:

  ThriftHiveMetastore_get_materialized_views_for_rewriting_result(const ThriftHiveMetastore_get_materialized_views_for_rewriting_result&);
  ThriftHiveMetastore_get_materialized_views_for_rewriting_result& operator=(const ThriftHiveMetastore_get_materialized_views_for_rewriting_result&);
  ThriftHiveMetastore_get_materialized_views_for_rewriting_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_materialized_views_for_rewriting_result() noexcept;
  std::vector<std::string>  success;
  MetaException o1;

  _ThriftHiveMetastore_get_materialized_views_for_rewriting_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  void __set_o1(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_materialized_views_for_rewriting_result & ) const;

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

};

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

class ThriftHiveMetastore_get_materialized_views_for_rewriting_presult {
 public:


  virtual ~ThriftHiveMetastore_get_materialized_views_for_rewriting_presult() noexcept;
  std::vector<std::string> * success;
  MetaException o1;

  _ThriftHiveMetastore_get_materialized_views_for_rewriting_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_table_meta_args__isset {
  _ThriftHiveMetastore_get_table_meta_args__isset() : db_patterns(false), tbl_patterns(false), tbl_types(false) {}
  bool db_patterns :1;
  bool tbl_patterns :1;
  bool tbl_types :1;
} _ThriftHiveMetastore_get_table_meta_args__isset;

class ThriftHiveMetastore_get_table_meta_args {
 public:

  ThriftHiveMetastore_get_table_meta_args(const ThriftHiveMetastore_get_table_meta_args&);
  ThriftHiveMetastore_get_table_meta_args& operator=(const ThriftHiveMetastore_get_table_meta_args&);
  ThriftHiveMetastore_get_table_meta_args() noexcept
                                          : db_patterns(),
                                            tbl_patterns() {
  }

  virtual ~ThriftHiveMetastore_get_table_meta_args() noexcept;
  std::string db_patterns;
  std::string tbl_patterns;
  std::vector<std::string>  tbl_types;

  _ThriftHiveMetastore_get_table_meta_args__isset __isset;

  void __set_db_patterns(const std::string& val);

  void __set_tbl_patterns(const std::string& val);

  void __set_tbl_types(const std::vector<std::string> & val);

  bool operator == (const ThriftHiveMetastore_get_table_meta_args & rhs) const
  {
    if (!(db_patterns == rhs.db_patterns))
      return false;
    if (!(tbl_patterns == rhs.tbl_patterns))
      return false;
    if (!(tbl_types == rhs.tbl_types))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_get_table_meta_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_get_table_meta_args & ) const;

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

};


class ThriftHiveMetastore_get_table_meta_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_table_meta_pargs() noexcept;
  const std::string* db_patterns;
  const std::string* tbl_patterns;
  const std::vector<std::string> * tbl_types;

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

};

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

class ThriftHiveMetastore_get_table_meta_result {
 public:

  ThriftHiveMetastore_get_table_meta_result(const ThriftHiveMetastore_get_table_meta_result&);
  ThriftHiveMetastore_get_table_meta_result& operator=(const ThriftHiveMetastore_get_table_meta_result&);
  ThriftHiveMetastore_get_table_meta_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_table_meta_result() noexcept;
  std::vector<TableMeta>  success;
  MetaException o1;

  _ThriftHiveMetastore_get_table_meta_result__isset __isset;

  void __set_success(const std::vector<TableMeta> & val);

  void __set_o1(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_table_meta_result & ) const;

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

};

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

class ThriftHiveMetastore_get_table_meta_presult {
 public:


  virtual ~ThriftHiveMetastore_get_table_meta_presult() noexcept;
  std::vector<TableMeta> * success;
  MetaException o1;

  _ThriftHiveMetastore_get_table_meta_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 :1;
} _ThriftHiveMetastore_get_all_tables_args__isset;

class ThriftHiveMetastore_get_all_tables_args {
 public:

  ThriftHiveMetastore_get_all_tables_args(const ThriftHiveMetastore_get_all_tables_args&);
  ThriftHiveMetastore_get_all_tables_args& operator=(const ThriftHiveMetastore_get_all_tables_args&);
  ThriftHiveMetastore_get_all_tables_args() noexcept
                                          : db_name() {
  }

  virtual ~ThriftHiveMetastore_get_all_tables_args() noexcept;
  std::string db_name;

  _ThriftHiveMetastore_get_all_tables_args__isset __isset;

  void __set_db_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_all_tables_result__isset;

class ThriftHiveMetastore_get_all_tables_result {
 public:

  ThriftHiveMetastore_get_all_tables_result(const ThriftHiveMetastore_get_all_tables_result&);
  ThriftHiveMetastore_get_all_tables_result& operator=(const ThriftHiveMetastore_get_all_tables_result&);
  ThriftHiveMetastore_get_all_tables_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_all_tables_result() noexcept;
  std::vector<std::string>  success;
  MetaException o1;

  _ThriftHiveMetastore_get_all_tables_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_all_tables_presult__isset;

class ThriftHiveMetastore_get_all_tables_presult {
 public:


  virtual ~ThriftHiveMetastore_get_all_tables_presult() noexcept;
  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 :1;
  bool tbl_name :1;
} _ThriftHiveMetastore_get_table_args__isset;

class ThriftHiveMetastore_get_table_args {
 public:

  ThriftHiveMetastore_get_table_args(const ThriftHiveMetastore_get_table_args&);
  ThriftHiveMetastore_get_table_args& operator=(const ThriftHiveMetastore_get_table_args&);
  ThriftHiveMetastore_get_table_args() noexcept
                                     : dbname(),
                                       tbl_name() {
  }

  virtual ~ThriftHiveMetastore_get_table_args() noexcept;
  std::string dbname;
  std::string tbl_name;

  _ThriftHiveMetastore_get_table_args__isset __isset;

  void __set_dbname(const std::string& val);

  void __set_tbl_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_table_result__isset;

class ThriftHiveMetastore_get_table_result {
 public:

  ThriftHiveMetastore_get_table_result(const ThriftHiveMetastore_get_table_result&);
  ThriftHiveMetastore_get_table_result& operator=(const ThriftHiveMetastore_get_table_result&);
  ThriftHiveMetastore_get_table_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_table_result() noexcept;
  Table success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_table_result__isset __isset;

  void __set_success(const Table& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_table_presult__isset;

class ThriftHiveMetastore_get_table_presult {
 public:


  virtual ~ThriftHiveMetastore_get_table_presult() noexcept;
  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 :1;
  bool tbl_names :1;
} _ThriftHiveMetastore_get_table_objects_by_name_args__isset;

class ThriftHiveMetastore_get_table_objects_by_name_args {
 public:

  ThriftHiveMetastore_get_table_objects_by_name_args(const ThriftHiveMetastore_get_table_objects_by_name_args&);
  ThriftHiveMetastore_get_table_objects_by_name_args& operator=(const ThriftHiveMetastore_get_table_objects_by_name_args&);
  ThriftHiveMetastore_get_table_objects_by_name_args() noexcept
                                                     : dbname() {
  }

  virtual ~ThriftHiveMetastore_get_table_objects_by_name_args() noexcept;
  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);

  void __set_tbl_names(const std::vector<std::string> & 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() noexcept;
  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) {}
  bool success :1;
} _ThriftHiveMetastore_get_table_objects_by_name_result__isset;

class ThriftHiveMetastore_get_table_objects_by_name_result {
 public:

  ThriftHiveMetastore_get_table_objects_by_name_result(const ThriftHiveMetastore_get_table_objects_by_name_result&);
  ThriftHiveMetastore_get_table_objects_by_name_result& operator=(const ThriftHiveMetastore_get_table_objects_by_name_result&);
  ThriftHiveMetastore_get_table_objects_by_name_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_table_objects_by_name_result() noexcept;
  std::vector<Table>  success;

  _ThriftHiveMetastore_get_table_objects_by_name_result__isset __isset;

  void __set_success(const std::vector<Table> & val);

  bool operator == (const ThriftHiveMetastore_get_table_objects_by_name_result & rhs) const
  {
    if (!(success == rhs.success))
      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) {}
  bool success :1;
} _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() noexcept;
  std::vector<Table> * success;

  _ThriftHiveMetastore_get_table_objects_by_name_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_table_req_args__isset {
  _ThriftHiveMetastore_get_table_req_args__isset() : req(false) {}
  bool req :1;
} _ThriftHiveMetastore_get_table_req_args__isset;

class ThriftHiveMetastore_get_table_req_args {
 public:

  ThriftHiveMetastore_get_table_req_args(const ThriftHiveMetastore_get_table_req_args&);
  ThriftHiveMetastore_get_table_req_args& operator=(const ThriftHiveMetastore_get_table_req_args&);
  ThriftHiveMetastore_get_table_req_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_table_req_args() noexcept;
  GetTableRequest req;

  _ThriftHiveMetastore_get_table_req_args__isset __isset;

  void __set_req(const GetTableRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_table_req_args & ) const;

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

};


class ThriftHiveMetastore_get_table_req_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_table_req_pargs() noexcept;
  const GetTableRequest* req;

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

};

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

class ThriftHiveMetastore_get_table_req_result {
 public:

  ThriftHiveMetastore_get_table_req_result(const ThriftHiveMetastore_get_table_req_result&);
  ThriftHiveMetastore_get_table_req_result& operator=(const ThriftHiveMetastore_get_table_req_result&);
  ThriftHiveMetastore_get_table_req_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_table_req_result() noexcept;
  GetTableResult success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_table_req_result__isset __isset;

  void __set_success(const GetTableResult& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& val);

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

  bool operator < (const ThriftHiveMetastore_get_table_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_req_presult__isset {
  _ThriftHiveMetastore_get_table_req_presult__isset() : success(false), o1(false), o2(false) {}
  bool success :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_table_req_presult__isset;

class ThriftHiveMetastore_get_table_req_presult {
 public:


  virtual ~ThriftHiveMetastore_get_table_req_presult() noexcept;
  GetTableResult* success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_table_req_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_table_objects_by_name_req_args__isset {
  _ThriftHiveMetastore_get_table_objects_by_name_req_args__isset() : req(false) {}
  bool req :1;
} _ThriftHiveMetastore_get_table_objects_by_name_req_args__isset;

class ThriftHiveMetastore_get_table_objects_by_name_req_args {
 public:

  ThriftHiveMetastore_get_table_objects_by_name_req_args(const ThriftHiveMetastore_get_table_objects_by_name_req_args&);
  ThriftHiveMetastore_get_table_objects_by_name_req_args& operator=(const ThriftHiveMetastore_get_table_objects_by_name_req_args&);
  ThriftHiveMetastore_get_table_objects_by_name_req_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_table_objects_by_name_req_args() noexcept;
  GetTablesRequest req;

  _ThriftHiveMetastore_get_table_objects_by_name_req_args__isset __isset;

  void __set_req(const GetTablesRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_table_objects_by_name_req_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_req_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_table_objects_by_name_req_pargs() noexcept;
  const GetTablesRequest* req;

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

};

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

class ThriftHiveMetastore_get_table_objects_by_name_req_result {
 public:

  ThriftHiveMetastore_get_table_objects_by_name_req_result(const ThriftHiveMetastore_get_table_objects_by_name_req_result&);
  ThriftHiveMetastore_get_table_objects_by_name_req_result& operator=(const ThriftHiveMetastore_get_table_objects_by_name_req_result&);
  ThriftHiveMetastore_get_table_objects_by_name_req_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_table_objects_by_name_req_result() noexcept;
  GetTablesResult success;
  MetaException o1;
  InvalidOperationException o2;
  UnknownDBException o3;

  _ThriftHiveMetastore_get_table_objects_by_name_req_result__isset __isset;

  void __set_success(const GetTablesResult& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const InvalidOperationException& val);

  void __set_o3(const UnknownDBException& val);

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

  bool operator < (const ThriftHiveMetastore_get_table_objects_by_name_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_objects_by_name_req_presult__isset {
  _ThriftHiveMetastore_get_table_objects_by_name_req_presult__isset() : success(false), o1(false), o2(false), o3(false) {}
  bool success :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_get_table_objects_by_name_req_presult__isset;

class ThriftHiveMetastore_get_table_objects_by_name_req_presult {
 public:


  virtual ~ThriftHiveMetastore_get_table_objects_by_name_req_presult() noexcept;
  GetTablesResult* success;
  MetaException o1;
  InvalidOperationException o2;
  UnknownDBException o3;

  _ThriftHiveMetastore_get_table_objects_by_name_req_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_materialization_invalidation_info_args__isset {
  _ThriftHiveMetastore_get_materialization_invalidation_info_args__isset() : creation_metadata(false), validTxnList(false) {}
  bool creation_metadata :1;
  bool validTxnList :1;
} _ThriftHiveMetastore_get_materialization_invalidation_info_args__isset;

class ThriftHiveMetastore_get_materialization_invalidation_info_args {
 public:

  ThriftHiveMetastore_get_materialization_invalidation_info_args(const ThriftHiveMetastore_get_materialization_invalidation_info_args&);
  ThriftHiveMetastore_get_materialization_invalidation_info_args& operator=(const ThriftHiveMetastore_get_materialization_invalidation_info_args&);
  ThriftHiveMetastore_get_materialization_invalidation_info_args() noexcept
                                                                 : validTxnList() {
  }

  virtual ~ThriftHiveMetastore_get_materialization_invalidation_info_args() noexcept;
  CreationMetadata creation_metadata;
  std::string validTxnList;

  _ThriftHiveMetastore_get_materialization_invalidation_info_args__isset __isset;

  void __set_creation_metadata(const CreationMetadata& val);

  void __set_validTxnList(const std::string& val);

  bool operator == (const ThriftHiveMetastore_get_materialization_invalidation_info_args & rhs) const
  {
    if (!(creation_metadata == rhs.creation_metadata))
      return false;
    if (!(validTxnList == rhs.validTxnList))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_get_materialization_invalidation_info_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_get_materialization_invalidation_info_args & ) const;

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

};


class ThriftHiveMetastore_get_materialization_invalidation_info_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_materialization_invalidation_info_pargs() noexcept;
  const CreationMetadata* creation_metadata;
  const std::string* validTxnList;

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

};

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

class ThriftHiveMetastore_get_materialization_invalidation_info_result {
 public:

  ThriftHiveMetastore_get_materialization_invalidation_info_result(const ThriftHiveMetastore_get_materialization_invalidation_info_result&);
  ThriftHiveMetastore_get_materialization_invalidation_info_result& operator=(const ThriftHiveMetastore_get_materialization_invalidation_info_result&);
  ThriftHiveMetastore_get_materialization_invalidation_info_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_materialization_invalidation_info_result() noexcept;
  Materialization success;
  MetaException o1;
  InvalidOperationException o2;
  UnknownDBException o3;

  _ThriftHiveMetastore_get_materialization_invalidation_info_result__isset __isset;

  void __set_success(const Materialization& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const InvalidOperationException& val);

  void __set_o3(const UnknownDBException& val);

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

  bool operator < (const ThriftHiveMetastore_get_materialization_invalidation_info_result & ) const;

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

};

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

class ThriftHiveMetastore_get_materialization_invalidation_info_presult {
 public:


  virtual ~ThriftHiveMetastore_get_materialization_invalidation_info_presult() noexcept;
  Materialization* success;
  MetaException o1;
  InvalidOperationException o2;
  UnknownDBException o3;

  _ThriftHiveMetastore_get_materialization_invalidation_info_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_update_creation_metadata_args__isset {
  _ThriftHiveMetastore_update_creation_metadata_args__isset() : catName(false), dbname(false), tbl_name(false), creation_metadata(false) {}
  bool catName :1;
  bool dbname :1;
  bool tbl_name :1;
  bool creation_metadata :1;
} _ThriftHiveMetastore_update_creation_metadata_args__isset;

class ThriftHiveMetastore_update_creation_metadata_args {
 public:

  ThriftHiveMetastore_update_creation_metadata_args(const ThriftHiveMetastore_update_creation_metadata_args&);
  ThriftHiveMetastore_update_creation_metadata_args& operator=(const ThriftHiveMetastore_update_creation_metadata_args&);
  ThriftHiveMetastore_update_creation_metadata_args() noexcept
                                                    : catName(),
                                                      dbname(),
                                                      tbl_name() {
  }

  virtual ~ThriftHiveMetastore_update_creation_metadata_args() noexcept;
  std::string catName;
  std::string dbname;
  std::string tbl_name;
  CreationMetadata creation_metadata;

  _ThriftHiveMetastore_update_creation_metadata_args__isset __isset;

  void __set_catName(const std::string& val);

  void __set_dbname(const std::string& val);

  void __set_tbl_name(const std::string& val);

  void __set_creation_metadata(const CreationMetadata& val);

  bool operator == (const ThriftHiveMetastore_update_creation_metadata_args & rhs) const
  {
    if (!(catName == rhs.catName))
      return false;
    if (!(dbname == rhs.dbname))
      return false;
    if (!(tbl_name == rhs.tbl_name))
      return false;
    if (!(creation_metadata == rhs.creation_metadata))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_update_creation_metadata_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_update_creation_metadata_args & ) const;

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

};


class ThriftHiveMetastore_update_creation_metadata_pargs {
 public:


  virtual ~ThriftHiveMetastore_update_creation_metadata_pargs() noexcept;
  const std::string* catName;
  const std::string* dbname;
  const std::string* tbl_name;
  const CreationMetadata* creation_metadata;

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

};

typedef struct _ThriftHiveMetastore_update_creation_metadata_result__isset {
  _ThriftHiveMetastore_update_creation_metadata_result__isset() : o1(false), o2(false), o3(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_update_creation_metadata_result__isset;

class ThriftHiveMetastore_update_creation_metadata_result {
 public:

  ThriftHiveMetastore_update_creation_metadata_result(const ThriftHiveMetastore_update_creation_metadata_result&);
  ThriftHiveMetastore_update_creation_metadata_result& operator=(const ThriftHiveMetastore_update_creation_metadata_result&);
  ThriftHiveMetastore_update_creation_metadata_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_update_creation_metadata_result() noexcept;
  MetaException o1;
  InvalidOperationException o2;
  UnknownDBException o3;

  _ThriftHiveMetastore_update_creation_metadata_result__isset __isset;

  void __set_o1(const MetaException& val);

  void __set_o2(const InvalidOperationException& val);

  void __set_o3(const UnknownDBException& val);

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

  bool operator < (const ThriftHiveMetastore_update_creation_metadata_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_update_creation_metadata_presult__isset {
  _ThriftHiveMetastore_update_creation_metadata_presult__isset() : o1(false), o2(false), o3(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_update_creation_metadata_presult__isset;

class ThriftHiveMetastore_update_creation_metadata_presult {
 public:


  virtual ~ThriftHiveMetastore_update_creation_metadata_presult() noexcept;
  MetaException o1;
  InvalidOperationException o2;
  UnknownDBException o3;

  _ThriftHiveMetastore_update_creation_metadata_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 :1;
  bool filter :1;
  bool max_tables :1;
} _ThriftHiveMetastore_get_table_names_by_filter_args__isset;

class ThriftHiveMetastore_get_table_names_by_filter_args {
 public:

  ThriftHiveMetastore_get_table_names_by_filter_args(const ThriftHiveMetastore_get_table_names_by_filter_args&);
  ThriftHiveMetastore_get_table_names_by_filter_args& operator=(const ThriftHiveMetastore_get_table_names_by_filter_args&);
  ThriftHiveMetastore_get_table_names_by_filter_args() noexcept
                                                     : dbname(),
                                                       filter(),
                                                       max_tables(-1) {
  }

  virtual ~ThriftHiveMetastore_get_table_names_by_filter_args() noexcept;
  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);

  void __set_filter(const std::string& val);

  void __set_max_tables(const int16_t 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_get_table_names_by_filter_result__isset;

class ThriftHiveMetastore_get_table_names_by_filter_result {
 public:

  ThriftHiveMetastore_get_table_names_by_filter_result(const ThriftHiveMetastore_get_table_names_by_filter_result&);
  ThriftHiveMetastore_get_table_names_by_filter_result& operator=(const ThriftHiveMetastore_get_table_names_by_filter_result&);
  ThriftHiveMetastore_get_table_names_by_filter_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_table_names_by_filter_result() noexcept;
  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);

  void __set_o1(const MetaException& val);

  void __set_o2(const InvalidOperationException& val);

  void __set_o3(const UnknownDBException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _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() noexcept;
  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 :1;
  bool tbl_name :1;
  bool new_tbl :1;
} _ThriftHiveMetastore_alter_table_args__isset;

class ThriftHiveMetastore_alter_table_args {
 public:

  ThriftHiveMetastore_alter_table_args(const ThriftHiveMetastore_alter_table_args&);
  ThriftHiveMetastore_alter_table_args& operator=(const ThriftHiveMetastore_alter_table_args&);
  ThriftHiveMetastore_alter_table_args() noexcept
                                       : dbname(),
                                         tbl_name() {
  }

  virtual ~ThriftHiveMetastore_alter_table_args() noexcept;
  std::string dbname;
  std::string tbl_name;
  Table new_tbl;

  _ThriftHiveMetastore_alter_table_args__isset __isset;

  void __set_dbname(const std::string& val);

  void __set_tbl_name(const std::string& val);

  void __set_new_tbl(const Table& 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() noexcept;
  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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_alter_table_result__isset;

class ThriftHiveMetastore_alter_table_result {
 public:

  ThriftHiveMetastore_alter_table_result(const ThriftHiveMetastore_alter_table_result&);
  ThriftHiveMetastore_alter_table_result& operator=(const ThriftHiveMetastore_alter_table_result&);
  ThriftHiveMetastore_alter_table_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_table_result() noexcept;
  InvalidOperationException o1;
  MetaException o2;

  _ThriftHiveMetastore_alter_table_result__isset __isset;

  void __set_o1(const InvalidOperationException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_alter_table_presult__isset;

class ThriftHiveMetastore_alter_table_presult {
 public:


  virtual ~ThriftHiveMetastore_alter_table_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool new_tbl :1;
  bool environment_context :1;
} _ThriftHiveMetastore_alter_table_with_environment_context_args__isset;

class ThriftHiveMetastore_alter_table_with_environment_context_args {
 public:

  ThriftHiveMetastore_alter_table_with_environment_context_args(const ThriftHiveMetastore_alter_table_with_environment_context_args&);
  ThriftHiveMetastore_alter_table_with_environment_context_args& operator=(const ThriftHiveMetastore_alter_table_with_environment_context_args&);
  ThriftHiveMetastore_alter_table_with_environment_context_args() noexcept
                                                                : dbname(),
                                                                  tbl_name() {
  }

  virtual ~ThriftHiveMetastore_alter_table_with_environment_context_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_new_tbl(const Table& val);

  void __set_environment_context(const EnvironmentContext& 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() noexcept;
  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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_alter_table_with_environment_context_result__isset;

class ThriftHiveMetastore_alter_table_with_environment_context_result {
 public:

  ThriftHiveMetastore_alter_table_with_environment_context_result(const ThriftHiveMetastore_alter_table_with_environment_context_result&);
  ThriftHiveMetastore_alter_table_with_environment_context_result& operator=(const ThriftHiveMetastore_alter_table_with_environment_context_result&);
  ThriftHiveMetastore_alter_table_with_environment_context_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_table_with_environment_context_result() noexcept;
  InvalidOperationException o1;
  MetaException o2;

  _ThriftHiveMetastore_alter_table_with_environment_context_result__isset __isset;

  void __set_o1(const InvalidOperationException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o2 :1;
} _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() noexcept;
  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 :1;
  bool tbl_name :1;
  bool new_tbl :1;
  bool cascade :1;
} _ThriftHiveMetastore_alter_table_with_cascade_args__isset;

class ThriftHiveMetastore_alter_table_with_cascade_args {
 public:

  ThriftHiveMetastore_alter_table_with_cascade_args(const ThriftHiveMetastore_alter_table_with_cascade_args&);
  ThriftHiveMetastore_alter_table_with_cascade_args& operator=(const ThriftHiveMetastore_alter_table_with_cascade_args&);
  ThriftHiveMetastore_alter_table_with_cascade_args() noexcept
                                                    : dbname(),
                                                      tbl_name(),
                                                      cascade(0) {
  }

  virtual ~ThriftHiveMetastore_alter_table_with_cascade_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_new_tbl(const Table& val);

  void __set_cascade(const bool 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() noexcept;
  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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_alter_table_with_cascade_result__isset;

class ThriftHiveMetastore_alter_table_with_cascade_result {
 public:

  ThriftHiveMetastore_alter_table_with_cascade_result(const ThriftHiveMetastore_alter_table_with_cascade_result&);
  ThriftHiveMetastore_alter_table_with_cascade_result& operator=(const ThriftHiveMetastore_alter_table_with_cascade_result&);
  ThriftHiveMetastore_alter_table_with_cascade_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_table_with_cascade_result() noexcept;
  InvalidOperationException o1;
  MetaException o2;

  _ThriftHiveMetastore_alter_table_with_cascade_result__isset __isset;

  void __set_o1(const InvalidOperationException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_alter_table_with_cascade_presult__isset;

class ThriftHiveMetastore_alter_table_with_cascade_presult {
 public:


  virtual ~ThriftHiveMetastore_alter_table_with_cascade_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_add_partition_args__isset;

class ThriftHiveMetastore_add_partition_args {
 public:

  ThriftHiveMetastore_add_partition_args(const ThriftHiveMetastore_add_partition_args&);
  ThriftHiveMetastore_add_partition_args& operator=(const ThriftHiveMetastore_add_partition_args&);
  ThriftHiveMetastore_add_partition_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_partition_args() noexcept;
  Partition new_part;

  _ThriftHiveMetastore_add_partition_args__isset __isset;

  void __set_new_part(const Partition& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_add_partition_result__isset;

class ThriftHiveMetastore_add_partition_result {
 public:

  ThriftHiveMetastore_add_partition_result(const ThriftHiveMetastore_add_partition_result&);
  ThriftHiveMetastore_add_partition_result& operator=(const ThriftHiveMetastore_add_partition_result&);
  ThriftHiveMetastore_add_partition_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_partition_result() noexcept;
  Partition success;
  InvalidObjectException o1;
  AlreadyExistsException o2;
  MetaException o3;

  _ThriftHiveMetastore_add_partition_result__isset __isset;

  void __set_success(const Partition& val);

  void __set_o1(const InvalidObjectException& val);

  void __set_o2(const AlreadyExistsException& val);

  void __set_o3(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_add_partition_presult__isset;

class ThriftHiveMetastore_add_partition_presult {
 public:


  virtual ~ThriftHiveMetastore_add_partition_presult() noexcept;
  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 :1;
  bool environment_context :1;
} _ThriftHiveMetastore_add_partition_with_environment_context_args__isset;

class ThriftHiveMetastore_add_partition_with_environment_context_args {
 public:

  ThriftHiveMetastore_add_partition_with_environment_context_args(const ThriftHiveMetastore_add_partition_with_environment_context_args&);
  ThriftHiveMetastore_add_partition_with_environment_context_args& operator=(const ThriftHiveMetastore_add_partition_with_environment_context_args&);
  ThriftHiveMetastore_add_partition_with_environment_context_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_partition_with_environment_context_args() noexcept;
  Partition new_part;
  EnvironmentContext environment_context;

  _ThriftHiveMetastore_add_partition_with_environment_context_args__isset __isset;

  void __set_new_part(const Partition& val);

  void __set_environment_context(const EnvironmentContext& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_add_partition_with_environment_context_result__isset;

class ThriftHiveMetastore_add_partition_with_environment_context_result {
 public:

  ThriftHiveMetastore_add_partition_with_environment_context_result(const ThriftHiveMetastore_add_partition_with_environment_context_result&);
  ThriftHiveMetastore_add_partition_with_environment_context_result& operator=(const ThriftHiveMetastore_add_partition_with_environment_context_result&);
  ThriftHiveMetastore_add_partition_with_environment_context_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_partition_with_environment_context_result() noexcept;
  Partition success;
  InvalidObjectException o1;
  AlreadyExistsException o2;
  MetaException o3;

  _ThriftHiveMetastore_add_partition_with_environment_context_result__isset __isset;

  void __set_success(const Partition& val);

  void __set_o1(const InvalidObjectException& val);

  void __set_o2(const AlreadyExistsException& val);

  void __set_o3(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _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() noexcept;
  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 :1;
} _ThriftHiveMetastore_add_partitions_args__isset;

class ThriftHiveMetastore_add_partitions_args {
 public:

  ThriftHiveMetastore_add_partitions_args(const ThriftHiveMetastore_add_partitions_args&);
  ThriftHiveMetastore_add_partitions_args& operator=(const ThriftHiveMetastore_add_partitions_args&);
  ThriftHiveMetastore_add_partitions_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_partitions_args() noexcept;
  std::vector<Partition>  new_parts;

  _ThriftHiveMetastore_add_partitions_args__isset __isset;

  void __set_new_parts(const std::vector<Partition> & 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_add_partitions_result__isset;

class ThriftHiveMetastore_add_partitions_result {
 public:

  ThriftHiveMetastore_add_partitions_result(const ThriftHiveMetastore_add_partitions_result&);
  ThriftHiveMetastore_add_partitions_result& operator=(const ThriftHiveMetastore_add_partitions_result&);
  ThriftHiveMetastore_add_partitions_result() noexcept
                                            : success(0) {
  }

  virtual ~ThriftHiveMetastore_add_partitions_result() noexcept;
  int32_t success;
  InvalidObjectException o1;
  AlreadyExistsException o2;
  MetaException o3;

  _ThriftHiveMetastore_add_partitions_result__isset __isset;

  void __set_success(const int32_t val);

  void __set_o1(const InvalidObjectException& val);

  void __set_o2(const AlreadyExistsException& val);

  void __set_o3(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_add_partitions_presult__isset;

class ThriftHiveMetastore_add_partitions_presult {
 public:


  virtual ~ThriftHiveMetastore_add_partitions_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_add_partitions_pspec_args__isset;

class ThriftHiveMetastore_add_partitions_pspec_args {
 public:

  ThriftHiveMetastore_add_partitions_pspec_args(const ThriftHiveMetastore_add_partitions_pspec_args&);
  ThriftHiveMetastore_add_partitions_pspec_args& operator=(const ThriftHiveMetastore_add_partitions_pspec_args&);
  ThriftHiveMetastore_add_partitions_pspec_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_partitions_pspec_args() noexcept;
  std::vector<PartitionSpec>  new_parts;

  _ThriftHiveMetastore_add_partitions_pspec_args__isset __isset;

  void __set_new_parts(const std::vector<PartitionSpec> & 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_add_partitions_pspec_result__isset;

class ThriftHiveMetastore_add_partitions_pspec_result {
 public:

  ThriftHiveMetastore_add_partitions_pspec_result(const ThriftHiveMetastore_add_partitions_pspec_result&);
  ThriftHiveMetastore_add_partitions_pspec_result& operator=(const ThriftHiveMetastore_add_partitions_pspec_result&);
  ThriftHiveMetastore_add_partitions_pspec_result() noexcept
                                                  : success(0) {
  }

  virtual ~ThriftHiveMetastore_add_partitions_pspec_result() noexcept;
  int32_t success;
  InvalidObjectException o1;
  AlreadyExistsException o2;
  MetaException o3;

  _ThriftHiveMetastore_add_partitions_pspec_result__isset __isset;

  void __set_success(const int32_t val);

  void __set_o1(const InvalidObjectException& val);

  void __set_o2(const AlreadyExistsException& val);

  void __set_o3(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_add_partitions_pspec_presult__isset;

class ThriftHiveMetastore_add_partitions_pspec_presult {
 public:


  virtual ~ThriftHiveMetastore_add_partitions_pspec_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_vals :1;
} _ThriftHiveMetastore_append_partition_args__isset;

class ThriftHiveMetastore_append_partition_args {
 public:

  ThriftHiveMetastore_append_partition_args(const ThriftHiveMetastore_append_partition_args&);
  ThriftHiveMetastore_append_partition_args& operator=(const ThriftHiveMetastore_append_partition_args&);
  ThriftHiveMetastore_append_partition_args() noexcept
                                            : db_name(),
                                              tbl_name() {
  }

  virtual ~ThriftHiveMetastore_append_partition_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_vals(const std::vector<std::string> & 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_append_partition_result__isset;

class ThriftHiveMetastore_append_partition_result {
 public:

  ThriftHiveMetastore_append_partition_result(const ThriftHiveMetastore_append_partition_result&);
  ThriftHiveMetastore_append_partition_result& operator=(const ThriftHiveMetastore_append_partition_result&);
  ThriftHiveMetastore_append_partition_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_append_partition_result() noexcept;
  Partition success;
  InvalidObjectException o1;
  AlreadyExistsException o2;
  MetaException o3;

  _ThriftHiveMetastore_append_partition_result__isset __isset;

  void __set_success(const Partition& val);

  void __set_o1(const InvalidObjectException& val);

  void __set_o2(const AlreadyExistsException& val);

  void __set_o3(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_append_partition_presult__isset;

class ThriftHiveMetastore_append_partition_presult {
 public:


  virtual ~ThriftHiveMetastore_append_partition_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_add_partitions_req_args__isset;

class ThriftHiveMetastore_add_partitions_req_args {
 public:

  ThriftHiveMetastore_add_partitions_req_args(const ThriftHiveMetastore_add_partitions_req_args&);
  ThriftHiveMetastore_add_partitions_req_args& operator=(const ThriftHiveMetastore_add_partitions_req_args&);
  ThriftHiveMetastore_add_partitions_req_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_partitions_req_args() noexcept;
  AddPartitionsRequest request;

  _ThriftHiveMetastore_add_partitions_req_args__isset __isset;

  void __set_request(const AddPartitionsRequest& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_add_partitions_req_result__isset;

class ThriftHiveMetastore_add_partitions_req_result {
 public:

  ThriftHiveMetastore_add_partitions_req_result(const ThriftHiveMetastore_add_partitions_req_result&);
  ThriftHiveMetastore_add_partitions_req_result& operator=(const ThriftHiveMetastore_add_partitions_req_result&);
  ThriftHiveMetastore_add_partitions_req_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_partitions_req_result() noexcept;
  AddPartitionsResult success;
  InvalidObjectException o1;
  AlreadyExistsException o2;
  MetaException o3;

  _ThriftHiveMetastore_add_partitions_req_result__isset __isset;

  void __set_success(const AddPartitionsResult& val);

  void __set_o1(const InvalidObjectException& val);

  void __set_o2(const AlreadyExistsException& val);

  void __set_o3(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_add_partitions_req_presult__isset;

class ThriftHiveMetastore_add_partitions_req_presult {
 public:


  virtual ~ThriftHiveMetastore_add_partitions_req_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_vals :1;
  bool environment_context :1;
} _ThriftHiveMetastore_append_partition_with_environment_context_args__isset;

class ThriftHiveMetastore_append_partition_with_environment_context_args {
 public:

  ThriftHiveMetastore_append_partition_with_environment_context_args(const ThriftHiveMetastore_append_partition_with_environment_context_args&);
  ThriftHiveMetastore_append_partition_with_environment_context_args& operator=(const ThriftHiveMetastore_append_partition_with_environment_context_args&);
  ThriftHiveMetastore_append_partition_with_environment_context_args() noexcept
                                                                     : db_name(),
                                                                       tbl_name() {
  }

  virtual ~ThriftHiveMetastore_append_partition_with_environment_context_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_vals(const std::vector<std::string> & val);

  void __set_environment_context(const EnvironmentContext& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_append_partition_with_environment_context_result__isset;

class ThriftHiveMetastore_append_partition_with_environment_context_result {
 public:

  ThriftHiveMetastore_append_partition_with_environment_context_result(const ThriftHiveMetastore_append_partition_with_environment_context_result&);
  ThriftHiveMetastore_append_partition_with_environment_context_result& operator=(const ThriftHiveMetastore_append_partition_with_environment_context_result&);
  ThriftHiveMetastore_append_partition_with_environment_context_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_append_partition_with_environment_context_result() noexcept;
  Partition success;
  InvalidObjectException o1;
  AlreadyExistsException o2;
  MetaException o3;

  _ThriftHiveMetastore_append_partition_with_environment_context_result__isset __isset;

  void __set_success(const Partition& val);

  void __set_o1(const InvalidObjectException& val);

  void __set_o2(const AlreadyExistsException& val);

  void __set_o3(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _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() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_name :1;
} _ThriftHiveMetastore_append_partition_by_name_args__isset;

class ThriftHiveMetastore_append_partition_by_name_args {
 public:

  ThriftHiveMetastore_append_partition_by_name_args(const ThriftHiveMetastore_append_partition_by_name_args&);
  ThriftHiveMetastore_append_partition_by_name_args& operator=(const ThriftHiveMetastore_append_partition_by_name_args&);
  ThriftHiveMetastore_append_partition_by_name_args() noexcept
                                                    : db_name(),
                                                      tbl_name(),
                                                      part_name() {
  }

  virtual ~ThriftHiveMetastore_append_partition_by_name_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_append_partition_by_name_result__isset;

class ThriftHiveMetastore_append_partition_by_name_result {
 public:

  ThriftHiveMetastore_append_partition_by_name_result(const ThriftHiveMetastore_append_partition_by_name_result&);
  ThriftHiveMetastore_append_partition_by_name_result& operator=(const ThriftHiveMetastore_append_partition_by_name_result&);
  ThriftHiveMetastore_append_partition_by_name_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_append_partition_by_name_result() noexcept;
  Partition success;
  InvalidObjectException o1;
  AlreadyExistsException o2;
  MetaException o3;

  _ThriftHiveMetastore_append_partition_by_name_result__isset __isset;

  void __set_success(const Partition& val);

  void __set_o1(const InvalidObjectException& val);

  void __set_o2(const AlreadyExistsException& val);

  void __set_o3(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_append_partition_by_name_presult__isset;

class ThriftHiveMetastore_append_partition_by_name_presult {
 public:


  virtual ~ThriftHiveMetastore_append_partition_by_name_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_name :1;
  bool environment_context :1;
} _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(const ThriftHiveMetastore_append_partition_by_name_with_environment_context_args&);
  ThriftHiveMetastore_append_partition_by_name_with_environment_context_args& operator=(const ThriftHiveMetastore_append_partition_by_name_with_environment_context_args&);
  ThriftHiveMetastore_append_partition_by_name_with_environment_context_args() noexcept
                                                                             : db_name(),
                                                                               tbl_name(),
                                                                               part_name() {
  }

  virtual ~ThriftHiveMetastore_append_partition_by_name_with_environment_context_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_name(const std::string& val);

  void __set_environment_context(const EnvironmentContext& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _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(const ThriftHiveMetastore_append_partition_by_name_with_environment_context_result&);
  ThriftHiveMetastore_append_partition_by_name_with_environment_context_result& operator=(const ThriftHiveMetastore_append_partition_by_name_with_environment_context_result&);
  ThriftHiveMetastore_append_partition_by_name_with_environment_context_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_append_partition_by_name_with_environment_context_result() noexcept;
  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);

  void __set_o1(const InvalidObjectException& val);

  void __set_o2(const AlreadyExistsException& val);

  void __set_o3(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _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() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_vals :1;
  bool deleteData :1;
} _ThriftHiveMetastore_drop_partition_args__isset;

class ThriftHiveMetastore_drop_partition_args {
 public:

  ThriftHiveMetastore_drop_partition_args(const ThriftHiveMetastore_drop_partition_args&);
  ThriftHiveMetastore_drop_partition_args& operator=(const ThriftHiveMetastore_drop_partition_args&);
  ThriftHiveMetastore_drop_partition_args() noexcept
                                          : db_name(),
                                            tbl_name(),
                                            deleteData(0) {
  }

  virtual ~ThriftHiveMetastore_drop_partition_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_vals(const std::vector<std::string> & val);

  void __set_deleteData(const bool 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_drop_partition_result__isset;

class ThriftHiveMetastore_drop_partition_result {
 public:

  ThriftHiveMetastore_drop_partition_result(const ThriftHiveMetastore_drop_partition_result&);
  ThriftHiveMetastore_drop_partition_result& operator=(const ThriftHiveMetastore_drop_partition_result&);
  ThriftHiveMetastore_drop_partition_result() noexcept
                                            : success(0) {
  }

  virtual ~ThriftHiveMetastore_drop_partition_result() noexcept;
  bool success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_drop_partition_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_drop_partition_presult__isset;

class ThriftHiveMetastore_drop_partition_presult {
 public:


  virtual ~ThriftHiveMetastore_drop_partition_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_vals :1;
  bool deleteData :1;
  bool environment_context :1;
} _ThriftHiveMetastore_drop_partition_with_environment_context_args__isset;

class ThriftHiveMetastore_drop_partition_with_environment_context_args {
 public:

  ThriftHiveMetastore_drop_partition_with_environment_context_args(const ThriftHiveMetastore_drop_partition_with_environment_context_args&);
  ThriftHiveMetastore_drop_partition_with_environment_context_args& operator=(const ThriftHiveMetastore_drop_partition_with_environment_context_args&);
  ThriftHiveMetastore_drop_partition_with_environment_context_args() noexcept
                                                                   : db_name(),
                                                                     tbl_name(),
                                                                     deleteData(0) {
  }

  virtual ~ThriftHiveMetastore_drop_partition_with_environment_context_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_vals(const std::vector<std::string> & val);

  void __set_deleteData(const bool val);

  void __set_environment_context(const EnvironmentContext& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_drop_partition_with_environment_context_result__isset;

class ThriftHiveMetastore_drop_partition_with_environment_context_result {
 public:

  ThriftHiveMetastore_drop_partition_with_environment_context_result(const ThriftHiveMetastore_drop_partition_with_environment_context_result&);
  ThriftHiveMetastore_drop_partition_with_environment_context_result& operator=(const ThriftHiveMetastore_drop_partition_with_environment_context_result&);
  ThriftHiveMetastore_drop_partition_with_environment_context_result() noexcept
                                                                     : success(0) {
  }

  virtual ~ThriftHiveMetastore_drop_partition_with_environment_context_result() noexcept;
  bool success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_drop_partition_with_environment_context_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _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() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_name :1;
  bool deleteData :1;
} _ThriftHiveMetastore_drop_partition_by_name_args__isset;

class ThriftHiveMetastore_drop_partition_by_name_args {
 public:

  ThriftHiveMetastore_drop_partition_by_name_args(const ThriftHiveMetastore_drop_partition_by_name_args&);
  ThriftHiveMetastore_drop_partition_by_name_args& operator=(const ThriftHiveMetastore_drop_partition_by_name_args&);
  ThriftHiveMetastore_drop_partition_by_name_args() noexcept
                                                  : db_name(),
                                                    tbl_name(),
                                                    part_name(),
                                                    deleteData(0) {
  }

  virtual ~ThriftHiveMetastore_drop_partition_by_name_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_name(const std::string& val);

  void __set_deleteData(const bool 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_drop_partition_by_name_result__isset;

class ThriftHiveMetastore_drop_partition_by_name_result {
 public:

  ThriftHiveMetastore_drop_partition_by_name_result(const ThriftHiveMetastore_drop_partition_by_name_result&);
  ThriftHiveMetastore_drop_partition_by_name_result& operator=(const ThriftHiveMetastore_drop_partition_by_name_result&);
  ThriftHiveMetastore_drop_partition_by_name_result() noexcept
                                                    : success(0) {
  }

  virtual ~ThriftHiveMetastore_drop_partition_by_name_result() noexcept;
  bool success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_drop_partition_by_name_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_drop_partition_by_name_presult__isset;

class ThriftHiveMetastore_drop_partition_by_name_presult {
 public:


  virtual ~ThriftHiveMetastore_drop_partition_by_name_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_name :1;
  bool deleteData :1;
  bool environment_context :1;
} _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(const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args&);
  ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args& operator=(const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args&);
  ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args() noexcept
                                                                           : db_name(),
                                                                             tbl_name(),
                                                                             part_name(),
                                                                             deleteData(0) {
  }

  virtual ~ThriftHiveMetastore_drop_partition_by_name_with_environment_context_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_name(const std::string& val);

  void __set_deleteData(const bool val);

  void __set_environment_context(const EnvironmentContext& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _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(const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result&);
  ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result& operator=(const ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result&);
  ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result() noexcept
                                                                             : success(0) {
  }

  virtual ~ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result() noexcept;
  bool success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_drop_partition_by_name_with_environment_context_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _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() noexcept;
  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 :1;
} _ThriftHiveMetastore_drop_partitions_req_args__isset;

class ThriftHiveMetastore_drop_partitions_req_args {
 public:

  ThriftHiveMetastore_drop_partitions_req_args(const ThriftHiveMetastore_drop_partitions_req_args&);
  ThriftHiveMetastore_drop_partitions_req_args& operator=(const ThriftHiveMetastore_drop_partitions_req_args&);
  ThriftHiveMetastore_drop_partitions_req_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_partitions_req_args() noexcept;
  DropPartitionsRequest req;

  _ThriftHiveMetastore_drop_partitions_req_args__isset __isset;

  void __set_req(const DropPartitionsRequest& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_drop_partitions_req_result__isset;

class ThriftHiveMetastore_drop_partitions_req_result {
 public:

  ThriftHiveMetastore_drop_partitions_req_result(const ThriftHiveMetastore_drop_partitions_req_result&);
  ThriftHiveMetastore_drop_partitions_req_result& operator=(const ThriftHiveMetastore_drop_partitions_req_result&);
  ThriftHiveMetastore_drop_partitions_req_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_partitions_req_result() noexcept;
  DropPartitionsResult success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_drop_partitions_req_result__isset __isset;

  void __set_success(const DropPartitionsResult& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_drop_partitions_req_presult__isset;

class ThriftHiveMetastore_drop_partitions_req_presult {
 public:


  virtual ~ThriftHiveMetastore_drop_partitions_req_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_vals :1;
} _ThriftHiveMetastore_get_partition_args__isset;

class ThriftHiveMetastore_get_partition_args {
 public:

  ThriftHiveMetastore_get_partition_args(const ThriftHiveMetastore_get_partition_args&);
  ThriftHiveMetastore_get_partition_args& operator=(const ThriftHiveMetastore_get_partition_args&);
  ThriftHiveMetastore_get_partition_args() noexcept
                                         : db_name(),
                                           tbl_name() {
  }

  virtual ~ThriftHiveMetastore_get_partition_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_vals(const std::vector<std::string> & 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partition_result__isset;

class ThriftHiveMetastore_get_partition_result {
 public:

  ThriftHiveMetastore_get_partition_result(const ThriftHiveMetastore_get_partition_result&);
  ThriftHiveMetastore_get_partition_result& operator=(const ThriftHiveMetastore_get_partition_result&);
  ThriftHiveMetastore_get_partition_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partition_result() noexcept;
  Partition success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_partition_result__isset __isset;

  void __set_success(const Partition& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partition_presult__isset;

class ThriftHiveMetastore_get_partition_presult {
 public:


  virtual ~ThriftHiveMetastore_get_partition_presult() noexcept;
  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 :1;
  bool source_db :1;
  bool source_table_name :1;
  bool dest_db :1;
  bool dest_table_name :1;
} _ThriftHiveMetastore_exchange_partition_args__isset;

class ThriftHiveMetastore_exchange_partition_args {
 public:

  ThriftHiveMetastore_exchange_partition_args(const ThriftHiveMetastore_exchange_partition_args&);
  ThriftHiveMetastore_exchange_partition_args& operator=(const ThriftHiveMetastore_exchange_partition_args&);
  ThriftHiveMetastore_exchange_partition_args() noexcept
                                              : source_db(),
                                                source_table_name(),
                                                dest_db(),
                                                dest_table_name() {
  }

  virtual ~ThriftHiveMetastore_exchange_partition_args() noexcept;
  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);

  void __set_source_db(const std::string& val);

  void __set_source_table_name(const std::string& val);

  void __set_dest_db(const std::string& val);

  void __set_dest_table_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_exchange_partition_result__isset;

class ThriftHiveMetastore_exchange_partition_result {
 public:

  ThriftHiveMetastore_exchange_partition_result(const ThriftHiveMetastore_exchange_partition_result&);
  ThriftHiveMetastore_exchange_partition_result& operator=(const ThriftHiveMetastore_exchange_partition_result&);
  ThriftHiveMetastore_exchange_partition_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_exchange_partition_result() noexcept;
  Partition success;
  MetaException o1;
  NoSuchObjectException o2;
  InvalidObjectException o3;
  InvalidInputException o4;

  _ThriftHiveMetastore_exchange_partition_result__isset __isset;

  void __set_success(const Partition& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& val);

  void __set_o3(const InvalidObjectException& val);

  void __set_o4(const InvalidInputException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_exchange_partition_presult__isset;

class ThriftHiveMetastore_exchange_partition_presult {
 public:


  virtual ~ThriftHiveMetastore_exchange_partition_presult() noexcept;
  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_exchange_partitions_args__isset {
  _ThriftHiveMetastore_exchange_partitions_args__isset() : partitionSpecs(false), source_db(false), source_table_name(false), dest_db(false), dest_table_name(false) {}
  bool partitionSpecs :1;
  bool source_db :1;
  bool source_table_name :1;
  bool dest_db :1;
  bool dest_table_name :1;
} _ThriftHiveMetastore_exchange_partitions_args__isset;

class ThriftHiveMetastore_exchange_partitions_args {
 public:

  ThriftHiveMetastore_exchange_partitions_args(const ThriftHiveMetastore_exchange_partitions_args&);
  ThriftHiveMetastore_exchange_partitions_args& operator=(const ThriftHiveMetastore_exchange_partitions_args&);
  ThriftHiveMetastore_exchange_partitions_args() noexcept
                                               : source_db(),
                                                 source_table_name(),
                                                 dest_db(),
                                                 dest_table_name() {
  }

  virtual ~ThriftHiveMetastore_exchange_partitions_args() noexcept;
  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_partitions_args__isset __isset;

  void __set_partitionSpecs(const std::map<std::string, std::string> & val);

  void __set_source_db(const std::string& val);

  void __set_source_table_name(const std::string& val);

  void __set_dest_db(const std::string& val);

  void __set_dest_table_name(const std::string& val);

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

  bool operator < (const ThriftHiveMetastore_exchange_partitions_args & ) const;

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

};


class ThriftHiveMetastore_exchange_partitions_pargs {
 public:


  virtual ~ThriftHiveMetastore_exchange_partitions_pargs() noexcept;
  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_partitions_result__isset {
  _ThriftHiveMetastore_exchange_partitions_result__isset() : success(false), o1(false), o2(false), o3(false), o4(false) {}
  bool success :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_exchange_partitions_result__isset;

class ThriftHiveMetastore_exchange_partitions_result {
 public:

  ThriftHiveMetastore_exchange_partitions_result(const ThriftHiveMetastore_exchange_partitions_result&);
  ThriftHiveMetastore_exchange_partitions_result& operator=(const ThriftHiveMetastore_exchange_partitions_result&);
  ThriftHiveMetastore_exchange_partitions_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_exchange_partitions_result() noexcept;
  std::vector<Partition>  success;
  MetaException o1;
  NoSuchObjectException o2;
  InvalidObjectException o3;
  InvalidInputException o4;

  _ThriftHiveMetastore_exchange_partitions_result__isset __isset;

  void __set_success(const std::vector<Partition> & val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& val);

  void __set_o3(const InvalidObjectException& val);

  void __set_o4(const InvalidInputException& val);

  bool operator == (const ThriftHiveMetastore_exchange_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;
    if (!(o4 == rhs.o4))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_exchange_partitions_result &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_exchange_partitions_result & ) const;

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

};

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

class ThriftHiveMetastore_exchange_partitions_presult {
 public:


  virtual ~ThriftHiveMetastore_exchange_partitions_presult() noexcept;
  std::vector<Partition> * success;
  MetaException o1;
  NoSuchObjectException o2;
  InvalidObjectException o3;
  InvalidInputException o4;

  _ThriftHiveMetastore_exchange_partitions_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 :1;
  bool tbl_name :1;
  bool part_vals :1;
  bool user_name :1;
  bool group_names :1;
} _ThriftHiveMetastore_get_partition_with_auth_args__isset;

class ThriftHiveMetastore_get_partition_with_auth_args {
 public:

  ThriftHiveMetastore_get_partition_with_auth_args(const ThriftHiveMetastore_get_partition_with_auth_args&);
  ThriftHiveMetastore_get_partition_with_auth_args& operator=(const ThriftHiveMetastore_get_partition_with_auth_args&);
  ThriftHiveMetastore_get_partition_with_auth_args() noexcept
                                                   : db_name(),
                                                     tbl_name(),
                                                     user_name() {
  }

  virtual ~ThriftHiveMetastore_get_partition_with_auth_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_vals(const std::vector<std::string> & val);

  void __set_user_name(const std::string& val);

  void __set_group_names(const std::vector<std::string> & 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partition_with_auth_result__isset;

class ThriftHiveMetastore_get_partition_with_auth_result {
 public:

  ThriftHiveMetastore_get_partition_with_auth_result(const ThriftHiveMetastore_get_partition_with_auth_result&);
  ThriftHiveMetastore_get_partition_with_auth_result& operator=(const ThriftHiveMetastore_get_partition_with_auth_result&);
  ThriftHiveMetastore_get_partition_with_auth_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partition_with_auth_result() noexcept;
  Partition success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_partition_with_auth_result__isset __isset;

  void __set_success(const Partition& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partition_with_auth_presult__isset;

class ThriftHiveMetastore_get_partition_with_auth_presult {
 public:


  virtual ~ThriftHiveMetastore_get_partition_with_auth_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_name :1;
} _ThriftHiveMetastore_get_partition_by_name_args__isset;

class ThriftHiveMetastore_get_partition_by_name_args {
 public:

  ThriftHiveMetastore_get_partition_by_name_args(const ThriftHiveMetastore_get_partition_by_name_args&);
  ThriftHiveMetastore_get_partition_by_name_args& operator=(const ThriftHiveMetastore_get_partition_by_name_args&);
  ThriftHiveMetastore_get_partition_by_name_args() noexcept
                                                 : db_name(),
                                                   tbl_name(),
                                                   part_name() {
  }

  virtual ~ThriftHiveMetastore_get_partition_by_name_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partition_by_name_result__isset;

class ThriftHiveMetastore_get_partition_by_name_result {
 public:

  ThriftHiveMetastore_get_partition_by_name_result(const ThriftHiveMetastore_get_partition_by_name_result&);
  ThriftHiveMetastore_get_partition_by_name_result& operator=(const ThriftHiveMetastore_get_partition_by_name_result&);
  ThriftHiveMetastore_get_partition_by_name_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partition_by_name_result() noexcept;
  Partition success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_partition_by_name_result__isset __isset;

  void __set_success(const Partition& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partition_by_name_presult__isset;

class ThriftHiveMetastore_get_partition_by_name_presult {
 public:


  virtual ~ThriftHiveMetastore_get_partition_by_name_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool max_parts :1;
} _ThriftHiveMetastore_get_partitions_args__isset;

class ThriftHiveMetastore_get_partitions_args {
 public:

  ThriftHiveMetastore_get_partitions_args(const ThriftHiveMetastore_get_partitions_args&);
  ThriftHiveMetastore_get_partitions_args& operator=(const ThriftHiveMetastore_get_partitions_args&);
  ThriftHiveMetastore_get_partitions_args() noexcept
                                          : db_name(),
                                            tbl_name(),
                                            max_parts(-1) {
  }

  virtual ~ThriftHiveMetastore_get_partitions_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_max_parts(const int16_t 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_result__isset;

class ThriftHiveMetastore_get_partitions_result {
 public:

  ThriftHiveMetastore_get_partitions_result(const ThriftHiveMetastore_get_partitions_result&);
  ThriftHiveMetastore_get_partitions_result& operator=(const ThriftHiveMetastore_get_partitions_result&);
  ThriftHiveMetastore_get_partitions_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partitions_result() noexcept;
  std::vector<Partition>  success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_partitions_result__isset __isset;

  void __set_success(const std::vector<Partition> & val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_presult__isset;

class ThriftHiveMetastore_get_partitions_presult {
 public:


  virtual ~ThriftHiveMetastore_get_partitions_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool max_parts :1;
  bool user_name :1;
  bool group_names :1;
} _ThriftHiveMetastore_get_partitions_with_auth_args__isset;

class ThriftHiveMetastore_get_partitions_with_auth_args {
 public:

  ThriftHiveMetastore_get_partitions_with_auth_args(const ThriftHiveMetastore_get_partitions_with_auth_args&);
  ThriftHiveMetastore_get_partitions_with_auth_args& operator=(const ThriftHiveMetastore_get_partitions_with_auth_args&);
  ThriftHiveMetastore_get_partitions_with_auth_args() noexcept
                                                    : db_name(),
                                                      tbl_name(),
                                                      max_parts(-1),
                                                      user_name() {
  }

  virtual ~ThriftHiveMetastore_get_partitions_with_auth_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_max_parts(const int16_t val);

  void __set_user_name(const std::string& val);

  void __set_group_names(const std::vector<std::string> & 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_with_auth_result__isset;

class ThriftHiveMetastore_get_partitions_with_auth_result {
 public:

  ThriftHiveMetastore_get_partitions_with_auth_result(const ThriftHiveMetastore_get_partitions_with_auth_result&);
  ThriftHiveMetastore_get_partitions_with_auth_result& operator=(const ThriftHiveMetastore_get_partitions_with_auth_result&);
  ThriftHiveMetastore_get_partitions_with_auth_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partitions_with_auth_result() noexcept;
  std::vector<Partition>  success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_partitions_with_auth_result__isset __isset;

  void __set_success(const std::vector<Partition> & val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_with_auth_presult__isset;

class ThriftHiveMetastore_get_partitions_with_auth_presult {
 public:


  virtual ~ThriftHiveMetastore_get_partitions_with_auth_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool max_parts :1;
} _ThriftHiveMetastore_get_partitions_pspec_args__isset;

class ThriftHiveMetastore_get_partitions_pspec_args {
 public:

  ThriftHiveMetastore_get_partitions_pspec_args(const ThriftHiveMetastore_get_partitions_pspec_args&);
  ThriftHiveMetastore_get_partitions_pspec_args& operator=(const ThriftHiveMetastore_get_partitions_pspec_args&);
  ThriftHiveMetastore_get_partitions_pspec_args() noexcept
                                                : db_name(),
                                                  tbl_name(),
                                                  max_parts(-1) {
  }

  virtual ~ThriftHiveMetastore_get_partitions_pspec_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_max_parts(const int32_t 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_pspec_result__isset;

class ThriftHiveMetastore_get_partitions_pspec_result {
 public:

  ThriftHiveMetastore_get_partitions_pspec_result(const ThriftHiveMetastore_get_partitions_pspec_result&);
  ThriftHiveMetastore_get_partitions_pspec_result& operator=(const ThriftHiveMetastore_get_partitions_pspec_result&);
  ThriftHiveMetastore_get_partitions_pspec_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partitions_pspec_result() noexcept;
  std::vector<PartitionSpec>  success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_partitions_pspec_result__isset __isset;

  void __set_success(const std::vector<PartitionSpec> & val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_pspec_presult__isset;

class ThriftHiveMetastore_get_partitions_pspec_presult {
 public:


  virtual ~ThriftHiveMetastore_get_partitions_pspec_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool max_parts :1;
} _ThriftHiveMetastore_get_partition_names_args__isset;

class ThriftHiveMetastore_get_partition_names_args {
 public:

  ThriftHiveMetastore_get_partition_names_args(const ThriftHiveMetastore_get_partition_names_args&);
  ThriftHiveMetastore_get_partition_names_args& operator=(const ThriftHiveMetastore_get_partition_names_args&);
  ThriftHiveMetastore_get_partition_names_args() noexcept
                                               : db_name(),
                                                 tbl_name(),
                                                 max_parts(-1) {
  }

  virtual ~ThriftHiveMetastore_get_partition_names_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_max_parts(const int16_t 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() noexcept;
  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), o1(false), o2(false) {}
  bool success :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partition_names_result__isset;

class ThriftHiveMetastore_get_partition_names_result {
 public:

  ThriftHiveMetastore_get_partition_names_result(const ThriftHiveMetastore_get_partition_names_result&);
  ThriftHiveMetastore_get_partition_names_result& operator=(const ThriftHiveMetastore_get_partition_names_result&);
  ThriftHiveMetastore_get_partition_names_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partition_names_result() noexcept;
  std::vector<std::string>  success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_partition_names_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

  bool operator == (const ThriftHiveMetastore_get_partition_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_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), o1(false), o2(false) {}
  bool success :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partition_names_presult__isset;

class ThriftHiveMetastore_get_partition_names_presult {
 public:


  virtual ~ThriftHiveMetastore_get_partition_names_presult() noexcept;
  std::vector<std::string> * success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_partition_names_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_partition_values_args__isset {
  _ThriftHiveMetastore_get_partition_values_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_get_partition_values_args__isset;

class ThriftHiveMetastore_get_partition_values_args {
 public:

  ThriftHiveMetastore_get_partition_values_args(const ThriftHiveMetastore_get_partition_values_args&);
  ThriftHiveMetastore_get_partition_values_args& operator=(const ThriftHiveMetastore_get_partition_values_args&);
  ThriftHiveMetastore_get_partition_values_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partition_values_args() noexcept;
  PartitionValuesRequest request;

  _ThriftHiveMetastore_get_partition_values_args__isset __isset;

  void __set_request(const PartitionValuesRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_partition_values_args & ) const;

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

};


class ThriftHiveMetastore_get_partition_values_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_partition_values_pargs() noexcept;
  const PartitionValuesRequest* request;

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

};

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

class ThriftHiveMetastore_get_partition_values_result {
 public:

  ThriftHiveMetastore_get_partition_values_result(const ThriftHiveMetastore_get_partition_values_result&);
  ThriftHiveMetastore_get_partition_values_result& operator=(const ThriftHiveMetastore_get_partition_values_result&);
  ThriftHiveMetastore_get_partition_values_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partition_values_result() noexcept;
  PartitionValuesResponse success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_partition_values_result__isset __isset;

  void __set_success(const PartitionValuesResponse& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& val);

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

  bool operator < (const ThriftHiveMetastore_get_partition_values_result & ) const;

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

};

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

class ThriftHiveMetastore_get_partition_values_presult {
 public:


  virtual ~ThriftHiveMetastore_get_partition_values_presult() noexcept;
  PartitionValuesResponse* success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_partition_values_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 :1;
  bool tbl_name :1;
  bool part_vals :1;
  bool max_parts :1;
} _ThriftHiveMetastore_get_partitions_ps_args__isset;

class ThriftHiveMetastore_get_partitions_ps_args {
 public:

  ThriftHiveMetastore_get_partitions_ps_args(const ThriftHiveMetastore_get_partitions_ps_args&);
  ThriftHiveMetastore_get_partitions_ps_args& operator=(const ThriftHiveMetastore_get_partitions_ps_args&);
  ThriftHiveMetastore_get_partitions_ps_args() noexcept
                                             : db_name(),
                                               tbl_name(),
                                               max_parts(-1) {
  }

  virtual ~ThriftHiveMetastore_get_partitions_ps_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_vals(const std::vector<std::string> & val);

  void __set_max_parts(const int16_t 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_ps_result__isset;

class ThriftHiveMetastore_get_partitions_ps_result {
 public:

  ThriftHiveMetastore_get_partitions_ps_result(const ThriftHiveMetastore_get_partitions_ps_result&);
  ThriftHiveMetastore_get_partitions_ps_result& operator=(const ThriftHiveMetastore_get_partitions_ps_result&);
  ThriftHiveMetastore_get_partitions_ps_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partitions_ps_result() noexcept;
  std::vector<Partition>  success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_partitions_ps_result__isset __isset;

  void __set_success(const std::vector<Partition> & val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_ps_presult__isset;

class ThriftHiveMetastore_get_partitions_ps_presult {
 public:


  virtual ~ThriftHiveMetastore_get_partitions_ps_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_vals :1;
  bool max_parts :1;
  bool user_name :1;
  bool group_names :1;
} _ThriftHiveMetastore_get_partitions_ps_with_auth_args__isset;

class ThriftHiveMetastore_get_partitions_ps_with_auth_args {
 public:

  ThriftHiveMetastore_get_partitions_ps_with_auth_args(const ThriftHiveMetastore_get_partitions_ps_with_auth_args&);
  ThriftHiveMetastore_get_partitions_ps_with_auth_args& operator=(const ThriftHiveMetastore_get_partitions_ps_with_auth_args&);
  ThriftHiveMetastore_get_partitions_ps_with_auth_args() noexcept
                                                       : db_name(),
                                                         tbl_name(),
                                                         max_parts(-1),
                                                         user_name() {
  }

  virtual ~ThriftHiveMetastore_get_partitions_ps_with_auth_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_vals(const std::vector<std::string> & val);

  void __set_max_parts(const int16_t val);

  void __set_user_name(const std::string& val);

  void __set_group_names(const std::vector<std::string> & 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_ps_with_auth_result__isset;

class ThriftHiveMetastore_get_partitions_ps_with_auth_result {
 public:

  ThriftHiveMetastore_get_partitions_ps_with_auth_result(const ThriftHiveMetastore_get_partitions_ps_with_auth_result&);
  ThriftHiveMetastore_get_partitions_ps_with_auth_result& operator=(const ThriftHiveMetastore_get_partitions_ps_with_auth_result&);
  ThriftHiveMetastore_get_partitions_ps_with_auth_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partitions_ps_with_auth_result() noexcept;
  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);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _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() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_vals :1;
  bool max_parts :1;
} _ThriftHiveMetastore_get_partition_names_ps_args__isset;

class ThriftHiveMetastore_get_partition_names_ps_args {
 public:

  ThriftHiveMetastore_get_partition_names_ps_args(const ThriftHiveMetastore_get_partition_names_ps_args&);
  ThriftHiveMetastore_get_partition_names_ps_args& operator=(const ThriftHiveMetastore_get_partition_names_ps_args&);
  ThriftHiveMetastore_get_partition_names_ps_args() noexcept
                                                  : db_name(),
                                                    tbl_name(),
                                                    max_parts(-1) {
  }

  virtual ~ThriftHiveMetastore_get_partition_names_ps_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_vals(const std::vector<std::string> & val);

  void __set_max_parts(const int16_t 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partition_names_ps_result__isset;

class ThriftHiveMetastore_get_partition_names_ps_result {
 public:

  ThriftHiveMetastore_get_partition_names_ps_result(const ThriftHiveMetastore_get_partition_names_ps_result&);
  ThriftHiveMetastore_get_partition_names_ps_result& operator=(const ThriftHiveMetastore_get_partition_names_ps_result&);
  ThriftHiveMetastore_get_partition_names_ps_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partition_names_ps_result() noexcept;
  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);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partition_names_ps_presult__isset;

class ThriftHiveMetastore_get_partition_names_ps_presult {
 public:


  virtual ~ThriftHiveMetastore_get_partition_names_ps_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool filter :1;
  bool max_parts :1;
} _ThriftHiveMetastore_get_partitions_by_filter_args__isset;

class ThriftHiveMetastore_get_partitions_by_filter_args {
 public:

  ThriftHiveMetastore_get_partitions_by_filter_args(const ThriftHiveMetastore_get_partitions_by_filter_args&);
  ThriftHiveMetastore_get_partitions_by_filter_args& operator=(const ThriftHiveMetastore_get_partitions_by_filter_args&);
  ThriftHiveMetastore_get_partitions_by_filter_args() noexcept
                                                    : db_name(),
                                                      tbl_name(),
                                                      filter(),
                                                      max_parts(-1) {
  }

  virtual ~ThriftHiveMetastore_get_partitions_by_filter_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_filter(const std::string& val);

  void __set_max_parts(const int16_t 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_by_filter_result__isset;

class ThriftHiveMetastore_get_partitions_by_filter_result {
 public:

  ThriftHiveMetastore_get_partitions_by_filter_result(const ThriftHiveMetastore_get_partitions_by_filter_result&);
  ThriftHiveMetastore_get_partitions_by_filter_result& operator=(const ThriftHiveMetastore_get_partitions_by_filter_result&);
  ThriftHiveMetastore_get_partitions_by_filter_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partitions_by_filter_result() noexcept;
  std::vector<Partition>  success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_partitions_by_filter_result__isset __isset;

  void __set_success(const std::vector<Partition> & val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_by_filter_presult__isset;

class ThriftHiveMetastore_get_partitions_by_filter_presult {
 public:


  virtual ~ThriftHiveMetastore_get_partitions_by_filter_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool filter :1;
  bool max_parts :1;
} _ThriftHiveMetastore_get_part_specs_by_filter_args__isset;

class ThriftHiveMetastore_get_part_specs_by_filter_args {
 public:

  ThriftHiveMetastore_get_part_specs_by_filter_args(const ThriftHiveMetastore_get_part_specs_by_filter_args&);
  ThriftHiveMetastore_get_part_specs_by_filter_args& operator=(const ThriftHiveMetastore_get_part_specs_by_filter_args&);
  ThriftHiveMetastore_get_part_specs_by_filter_args() noexcept
                                                    : db_name(),
                                                      tbl_name(),
                                                      filter(),
                                                      max_parts(-1) {
  }

  virtual ~ThriftHiveMetastore_get_part_specs_by_filter_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_filter(const std::string& val);

  void __set_max_parts(const int32_t 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_part_specs_by_filter_result__isset;

class ThriftHiveMetastore_get_part_specs_by_filter_result {
 public:

  ThriftHiveMetastore_get_part_specs_by_filter_result(const ThriftHiveMetastore_get_part_specs_by_filter_result&);
  ThriftHiveMetastore_get_part_specs_by_filter_result& operator=(const ThriftHiveMetastore_get_part_specs_by_filter_result&);
  ThriftHiveMetastore_get_part_specs_by_filter_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_part_specs_by_filter_result() noexcept;
  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);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _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() noexcept;
  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 :1;
} _ThriftHiveMetastore_get_partitions_by_expr_args__isset;

class ThriftHiveMetastore_get_partitions_by_expr_args {
 public:

  ThriftHiveMetastore_get_partitions_by_expr_args(const ThriftHiveMetastore_get_partitions_by_expr_args&);
  ThriftHiveMetastore_get_partitions_by_expr_args& operator=(const ThriftHiveMetastore_get_partitions_by_expr_args&);
  ThriftHiveMetastore_get_partitions_by_expr_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partitions_by_expr_args() noexcept;
  PartitionsByExprRequest req;

  _ThriftHiveMetastore_get_partitions_by_expr_args__isset __isset;

  void __set_req(const PartitionsByExprRequest& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_by_expr_result__isset;

class ThriftHiveMetastore_get_partitions_by_expr_result {
 public:

  ThriftHiveMetastore_get_partitions_by_expr_result(const ThriftHiveMetastore_get_partitions_by_expr_result&);
  ThriftHiveMetastore_get_partitions_by_expr_result& operator=(const ThriftHiveMetastore_get_partitions_by_expr_result&);
  ThriftHiveMetastore_get_partitions_by_expr_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partitions_by_expr_result() noexcept;
  PartitionsByExprResult success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_partitions_by_expr_result__isset __isset;

  void __set_success(const PartitionsByExprResult& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_by_expr_presult__isset;

class ThriftHiveMetastore_get_partitions_by_expr_presult {
 public:


  virtual ~ThriftHiveMetastore_get_partitions_by_expr_presult() noexcept;
  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_num_partitions_by_filter_args__isset {
  _ThriftHiveMetastore_get_num_partitions_by_filter_args__isset() : db_name(false), tbl_name(false), filter(false) {}
  bool db_name :1;
  bool tbl_name :1;
  bool filter :1;
} _ThriftHiveMetastore_get_num_partitions_by_filter_args__isset;

class ThriftHiveMetastore_get_num_partitions_by_filter_args {
 public:

  ThriftHiveMetastore_get_num_partitions_by_filter_args(const ThriftHiveMetastore_get_num_partitions_by_filter_args&);
  ThriftHiveMetastore_get_num_partitions_by_filter_args& operator=(const ThriftHiveMetastore_get_num_partitions_by_filter_args&);
  ThriftHiveMetastore_get_num_partitions_by_filter_args() noexcept
                                                        : db_name(),
                                                          tbl_name(),
                                                          filter() {
  }

  virtual ~ThriftHiveMetastore_get_num_partitions_by_filter_args() noexcept;
  std::string db_name;
  std::string tbl_name;
  std::string filter;

  _ThriftHiveMetastore_get_num_partitions_by_filter_args__isset __isset;

  void __set_db_name(const std::string& val);

  void __set_tbl_name(const std::string& val);

  void __set_filter(const std::string& val);

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

  bool operator < (const ThriftHiveMetastore_get_num_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_num_partitions_by_filter_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_num_partitions_by_filter_pargs() noexcept;
  const std::string* db_name;
  const std::string* tbl_name;
  const std::string* filter;

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

};

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

class ThriftHiveMetastore_get_num_partitions_by_filter_result {
 public:

  ThriftHiveMetastore_get_num_partitions_by_filter_result(const ThriftHiveMetastore_get_num_partitions_by_filter_result&);
  ThriftHiveMetastore_get_num_partitions_by_filter_result& operator=(const ThriftHiveMetastore_get_num_partitions_by_filter_result&);
  ThriftHiveMetastore_get_num_partitions_by_filter_result() noexcept
                                                          : success(0) {
  }

  virtual ~ThriftHiveMetastore_get_num_partitions_by_filter_result() noexcept;
  int32_t success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_num_partitions_by_filter_result__isset __isset;

  void __set_success(const int32_t val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& val);

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

  bool operator < (const ThriftHiveMetastore_get_num_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_num_partitions_by_filter_presult__isset {
  _ThriftHiveMetastore_get_num_partitions_by_filter_presult__isset() : success(false), o1(false), o2(false) {}
  bool success :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_num_partitions_by_filter_presult__isset;

class ThriftHiveMetastore_get_num_partitions_by_filter_presult {
 public:


  virtual ~ThriftHiveMetastore_get_num_partitions_by_filter_presult() noexcept;
  int32_t* success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_num_partitions_by_filter_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 :1;
  bool tbl_name :1;
  bool names :1;
} _ThriftHiveMetastore_get_partitions_by_names_args__isset;

class ThriftHiveMetastore_get_partitions_by_names_args {
 public:

  ThriftHiveMetastore_get_partitions_by_names_args(const ThriftHiveMetastore_get_partitions_by_names_args&);
  ThriftHiveMetastore_get_partitions_by_names_args& operator=(const ThriftHiveMetastore_get_partitions_by_names_args&);
  ThriftHiveMetastore_get_partitions_by_names_args() noexcept
                                                   : db_name(),
                                                     tbl_name() {
  }

  virtual ~ThriftHiveMetastore_get_partitions_by_names_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_names(const std::vector<std::string> & 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_by_names_result__isset;

class ThriftHiveMetastore_get_partitions_by_names_result {
 public:

  ThriftHiveMetastore_get_partitions_by_names_result(const ThriftHiveMetastore_get_partitions_by_names_result&);
  ThriftHiveMetastore_get_partitions_by_names_result& operator=(const ThriftHiveMetastore_get_partitions_by_names_result&);
  ThriftHiveMetastore_get_partitions_by_names_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partitions_by_names_result() noexcept;
  std::vector<Partition>  success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_partitions_by_names_result__isset __isset;

  void __set_success(const std::vector<Partition> & val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_by_names_presult__isset;

class ThriftHiveMetastore_get_partitions_by_names_presult {
 public:


  virtual ~ThriftHiveMetastore_get_partitions_by_names_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool new_part :1;
} _ThriftHiveMetastore_alter_partition_args__isset;

class ThriftHiveMetastore_alter_partition_args {
 public:

  ThriftHiveMetastore_alter_partition_args(const ThriftHiveMetastore_alter_partition_args&);
  ThriftHiveMetastore_alter_partition_args& operator=(const ThriftHiveMetastore_alter_partition_args&);
  ThriftHiveMetastore_alter_partition_args() noexcept
                                           : db_name(),
                                             tbl_name() {
  }

  virtual ~ThriftHiveMetastore_alter_partition_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_new_part(const Partition& 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() noexcept;
  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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_alter_partition_result__isset;

class ThriftHiveMetastore_alter_partition_result {
 public:

  ThriftHiveMetastore_alter_partition_result(const ThriftHiveMetastore_alter_partition_result&);
  ThriftHiveMetastore_alter_partition_result& operator=(const ThriftHiveMetastore_alter_partition_result&);
  ThriftHiveMetastore_alter_partition_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_partition_result() noexcept;
  InvalidOperationException o1;
  MetaException o2;

  _ThriftHiveMetastore_alter_partition_result__isset __isset;

  void __set_o1(const InvalidOperationException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_alter_partition_presult__isset;

class ThriftHiveMetastore_alter_partition_presult {
 public:


  virtual ~ThriftHiveMetastore_alter_partition_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool new_parts :1;
} _ThriftHiveMetastore_alter_partitions_args__isset;

class ThriftHiveMetastore_alter_partitions_args {
 public:

  ThriftHiveMetastore_alter_partitions_args(const ThriftHiveMetastore_alter_partitions_args&);
  ThriftHiveMetastore_alter_partitions_args& operator=(const ThriftHiveMetastore_alter_partitions_args&);
  ThriftHiveMetastore_alter_partitions_args() noexcept
                                            : db_name(),
                                              tbl_name() {
  }

  virtual ~ThriftHiveMetastore_alter_partitions_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_new_parts(const std::vector<Partition> & 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() noexcept;
  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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_alter_partitions_result__isset;

class ThriftHiveMetastore_alter_partitions_result {
 public:

  ThriftHiveMetastore_alter_partitions_result(const ThriftHiveMetastore_alter_partitions_result&);
  ThriftHiveMetastore_alter_partitions_result& operator=(const ThriftHiveMetastore_alter_partitions_result&);
  ThriftHiveMetastore_alter_partitions_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_partitions_result() noexcept;
  InvalidOperationException o1;
  MetaException o2;

  _ThriftHiveMetastore_alter_partitions_result__isset __isset;

  void __set_o1(const InvalidOperationException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_alter_partitions_presult__isset;

class ThriftHiveMetastore_alter_partitions_presult {
 public:


  virtual ~ThriftHiveMetastore_alter_partitions_presult() noexcept;
  InvalidOperationException o1;
  MetaException o2;

  _ThriftHiveMetastore_alter_partitions_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_alter_partitions_with_environment_context_args__isset {
  _ThriftHiveMetastore_alter_partitions_with_environment_context_args__isset() : db_name(false), tbl_name(false), new_parts(false), environment_context(false) {}
  bool db_name :1;
  bool tbl_name :1;
  bool new_parts :1;
  bool environment_context :1;
} _ThriftHiveMetastore_alter_partitions_with_environment_context_args__isset;

class ThriftHiveMetastore_alter_partitions_with_environment_context_args {
 public:

  ThriftHiveMetastore_alter_partitions_with_environment_context_args(const ThriftHiveMetastore_alter_partitions_with_environment_context_args&);
  ThriftHiveMetastore_alter_partitions_with_environment_context_args& operator=(const ThriftHiveMetastore_alter_partitions_with_environment_context_args&);
  ThriftHiveMetastore_alter_partitions_with_environment_context_args() noexcept
                                                                     : db_name(),
                                                                       tbl_name() {
  }

  virtual ~ThriftHiveMetastore_alter_partitions_with_environment_context_args() noexcept;
  std::string db_name;
  std::string tbl_name;
  std::vector<Partition>  new_parts;
  EnvironmentContext environment_context;

  _ThriftHiveMetastore_alter_partitions_with_environment_context_args__isset __isset;

  void __set_db_name(const std::string& val);

  void __set_tbl_name(const std::string& val);

  void __set_new_parts(const std::vector<Partition> & val);

  void __set_environment_context(const EnvironmentContext& val);

  bool operator == (const ThriftHiveMetastore_alter_partitions_with_environment_context_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;
    if (!(environment_context == rhs.environment_context))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_alter_partitions_with_environment_context_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_alter_partitions_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_partitions_with_environment_context_pargs {
 public:


  virtual ~ThriftHiveMetastore_alter_partitions_with_environment_context_pargs() noexcept;
  const std::string* db_name;
  const std::string* tbl_name;
  const std::vector<Partition> * new_parts;
  const EnvironmentContext* environment_context;

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

};

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

class ThriftHiveMetastore_alter_partitions_with_environment_context_result {
 public:

  ThriftHiveMetastore_alter_partitions_with_environment_context_result(const ThriftHiveMetastore_alter_partitions_with_environment_context_result&);
  ThriftHiveMetastore_alter_partitions_with_environment_context_result& operator=(const ThriftHiveMetastore_alter_partitions_with_environment_context_result&);
  ThriftHiveMetastore_alter_partitions_with_environment_context_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_partitions_with_environment_context_result() noexcept;
  InvalidOperationException o1;
  MetaException o2;

  _ThriftHiveMetastore_alter_partitions_with_environment_context_result__isset __isset;

  void __set_o1(const InvalidOperationException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_alter_partitions_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_partitions_with_environment_context_presult__isset {
  _ThriftHiveMetastore_alter_partitions_with_environment_context_presult__isset() : o1(false), o2(false) {}
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_alter_partitions_with_environment_context_presult__isset;

class ThriftHiveMetastore_alter_partitions_with_environment_context_presult {
 public:


  virtual ~ThriftHiveMetastore_alter_partitions_with_environment_context_presult() noexcept;
  InvalidOperationException o1;
  MetaException o2;

  _ThriftHiveMetastore_alter_partitions_with_environment_context_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 :1;
  bool tbl_name :1;
  bool new_part :1;
  bool environment_context :1;
} _ThriftHiveMetastore_alter_partition_with_environment_context_args__isset;

class ThriftHiveMetastore_alter_partition_with_environment_context_args {
 public:

  ThriftHiveMetastore_alter_partition_with_environment_context_args(const ThriftHiveMetastore_alter_partition_with_environment_context_args&);
  ThriftHiveMetastore_alter_partition_with_environment_context_args& operator=(const ThriftHiveMetastore_alter_partition_with_environment_context_args&);
  ThriftHiveMetastore_alter_partition_with_environment_context_args() noexcept
                                                                    : db_name(),
                                                                      tbl_name() {
  }

  virtual ~ThriftHiveMetastore_alter_partition_with_environment_context_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_new_part(const Partition& val);

  void __set_environment_context(const EnvironmentContext& 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() noexcept;
  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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_alter_partition_with_environment_context_result__isset;

class ThriftHiveMetastore_alter_partition_with_environment_context_result {
 public:

  ThriftHiveMetastore_alter_partition_with_environment_context_result(const ThriftHiveMetastore_alter_partition_with_environment_context_result&);
  ThriftHiveMetastore_alter_partition_with_environment_context_result& operator=(const ThriftHiveMetastore_alter_partition_with_environment_context_result&);
  ThriftHiveMetastore_alter_partition_with_environment_context_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_partition_with_environment_context_result() noexcept;
  InvalidOperationException o1;
  MetaException o2;

  _ThriftHiveMetastore_alter_partition_with_environment_context_result__isset __isset;

  void __set_o1(const InvalidOperationException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o2 :1;
} _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() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_vals :1;
  bool new_part :1;
} _ThriftHiveMetastore_rename_partition_args__isset;

class ThriftHiveMetastore_rename_partition_args {
 public:

  ThriftHiveMetastore_rename_partition_args(const ThriftHiveMetastore_rename_partition_args&);
  ThriftHiveMetastore_rename_partition_args& operator=(const ThriftHiveMetastore_rename_partition_args&);
  ThriftHiveMetastore_rename_partition_args() noexcept
                                            : db_name(),
                                              tbl_name() {
  }

  virtual ~ThriftHiveMetastore_rename_partition_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_vals(const std::vector<std::string> & val);

  void __set_new_part(const Partition& 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() noexcept;
  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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_rename_partition_result__isset;

class ThriftHiveMetastore_rename_partition_result {
 public:

  ThriftHiveMetastore_rename_partition_result(const ThriftHiveMetastore_rename_partition_result&);
  ThriftHiveMetastore_rename_partition_result& operator=(const ThriftHiveMetastore_rename_partition_result&);
  ThriftHiveMetastore_rename_partition_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_rename_partition_result() noexcept;
  InvalidOperationException o1;
  MetaException o2;

  _ThriftHiveMetastore_rename_partition_result__isset __isset;

  void __set_o1(const InvalidOperationException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_rename_partition_presult__isset;

class ThriftHiveMetastore_rename_partition_presult {
 public:


  virtual ~ThriftHiveMetastore_rename_partition_presult() noexcept;
  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 :1;
  bool throw_exception :1;
} _ThriftHiveMetastore_partition_name_has_valid_characters_args__isset;

class ThriftHiveMetastore_partition_name_has_valid_characters_args {
 public:

  ThriftHiveMetastore_partition_name_has_valid_characters_args(const ThriftHiveMetastore_partition_name_has_valid_characters_args&);
  ThriftHiveMetastore_partition_name_has_valid_characters_args& operator=(const ThriftHiveMetastore_partition_name_has_valid_characters_args&);
  ThriftHiveMetastore_partition_name_has_valid_characters_args() noexcept
                                                               : throw_exception(0) {
  }

  virtual ~ThriftHiveMetastore_partition_name_has_valid_characters_args() noexcept;
  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);

  void __set_throw_exception(const bool 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_partition_name_has_valid_characters_result__isset;

class ThriftHiveMetastore_partition_name_has_valid_characters_result {
 public:

  ThriftHiveMetastore_partition_name_has_valid_characters_result(const ThriftHiveMetastore_partition_name_has_valid_characters_result&);
  ThriftHiveMetastore_partition_name_has_valid_characters_result& operator=(const ThriftHiveMetastore_partition_name_has_valid_characters_result&);
  ThriftHiveMetastore_partition_name_has_valid_characters_result() noexcept
                                                                 : success(0) {
  }

  virtual ~ThriftHiveMetastore_partition_name_has_valid_characters_result() noexcept;
  bool success;
  MetaException o1;

  _ThriftHiveMetastore_partition_name_has_valid_characters_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _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() noexcept;
  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 :1;
  bool defaultValue :1;
} _ThriftHiveMetastore_get_config_value_args__isset;

class ThriftHiveMetastore_get_config_value_args {
 public:

  ThriftHiveMetastore_get_config_value_args(const ThriftHiveMetastore_get_config_value_args&);
  ThriftHiveMetastore_get_config_value_args& operator=(const ThriftHiveMetastore_get_config_value_args&);
  ThriftHiveMetastore_get_config_value_args() noexcept
                                            : name(),
                                              defaultValue() {
  }

  virtual ~ThriftHiveMetastore_get_config_value_args() noexcept;
  std::string name;
  std::string defaultValue;

  _ThriftHiveMetastore_get_config_value_args__isset __isset;

  void __set_name(const std::string& val);

  void __set_defaultValue(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_config_value_result__isset;

class ThriftHiveMetastore_get_config_value_result {
 public:

  ThriftHiveMetastore_get_config_value_result(const ThriftHiveMetastore_get_config_value_result&);
  ThriftHiveMetastore_get_config_value_result& operator=(const ThriftHiveMetastore_get_config_value_result&);
  ThriftHiveMetastore_get_config_value_result() noexcept
                                              : success() {
  }

  virtual ~ThriftHiveMetastore_get_config_value_result() noexcept;
  std::string success;
  ConfigValSecurityException o1;

  _ThriftHiveMetastore_get_config_value_result__isset __isset;

  void __set_success(const std::string& val);

  void __set_o1(const ConfigValSecurityException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_config_value_presult__isset;

class ThriftHiveMetastore_get_config_value_presult {
 public:


  virtual ~ThriftHiveMetastore_get_config_value_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_partition_name_to_vals_args__isset;

class ThriftHiveMetastore_partition_name_to_vals_args {
 public:

  ThriftHiveMetastore_partition_name_to_vals_args(const ThriftHiveMetastore_partition_name_to_vals_args&);
  ThriftHiveMetastore_partition_name_to_vals_args& operator=(const ThriftHiveMetastore_partition_name_to_vals_args&);
  ThriftHiveMetastore_partition_name_to_vals_args() noexcept
                                                  : part_name() {
  }

  virtual ~ThriftHiveMetastore_partition_name_to_vals_args() noexcept;
  std::string part_name;

  _ThriftHiveMetastore_partition_name_to_vals_args__isset __isset;

  void __set_part_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_partition_name_to_vals_result__isset;

class ThriftHiveMetastore_partition_name_to_vals_result {
 public:

  ThriftHiveMetastore_partition_name_to_vals_result(const ThriftHiveMetastore_partition_name_to_vals_result&);
  ThriftHiveMetastore_partition_name_to_vals_result& operator=(const ThriftHiveMetastore_partition_name_to_vals_result&);
  ThriftHiveMetastore_partition_name_to_vals_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_partition_name_to_vals_result() noexcept;
  std::vector<std::string>  success;
  MetaException o1;

  _ThriftHiveMetastore_partition_name_to_vals_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_partition_name_to_vals_presult__isset;

class ThriftHiveMetastore_partition_name_to_vals_presult {
 public:


  virtual ~ThriftHiveMetastore_partition_name_to_vals_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_partition_name_to_spec_args__isset;

class ThriftHiveMetastore_partition_name_to_spec_args {
 public:

  ThriftHiveMetastore_partition_name_to_spec_args(const ThriftHiveMetastore_partition_name_to_spec_args&);
  ThriftHiveMetastore_partition_name_to_spec_args& operator=(const ThriftHiveMetastore_partition_name_to_spec_args&);
  ThriftHiveMetastore_partition_name_to_spec_args() noexcept
                                                  : part_name() {
  }

  virtual ~ThriftHiveMetastore_partition_name_to_spec_args() noexcept;
  std::string part_name;

  _ThriftHiveMetastore_partition_name_to_spec_args__isset __isset;

  void __set_part_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_partition_name_to_spec_result__isset;

class ThriftHiveMetastore_partition_name_to_spec_result {
 public:

  ThriftHiveMetastore_partition_name_to_spec_result(const ThriftHiveMetastore_partition_name_to_spec_result&);
  ThriftHiveMetastore_partition_name_to_spec_result& operator=(const ThriftHiveMetastore_partition_name_to_spec_result&);
  ThriftHiveMetastore_partition_name_to_spec_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_partition_name_to_spec_result() noexcept;
  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);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_partition_name_to_spec_presult__isset;

class ThriftHiveMetastore_partition_name_to_spec_presult {
 public:


  virtual ~ThriftHiveMetastore_partition_name_to_spec_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_vals :1;
  bool eventType :1;
} _ThriftHiveMetastore_markPartitionForEvent_args__isset;

class ThriftHiveMetastore_markPartitionForEvent_args {
 public:

  ThriftHiveMetastore_markPartitionForEvent_args(const ThriftHiveMetastore_markPartitionForEvent_args&);
  ThriftHiveMetastore_markPartitionForEvent_args& operator=(const ThriftHiveMetastore_markPartitionForEvent_args&);
  ThriftHiveMetastore_markPartitionForEvent_args() noexcept
                                                 : db_name(),
                                                   tbl_name(),
                                                   eventType(static_cast<PartitionEventType::type>(0)) {
  }

  virtual ~ThriftHiveMetastore_markPartitionForEvent_args() noexcept;
  std::string db_name;
  std::string tbl_name;
  std::map<std::string, std::string>  part_vals;
  /**
   * 
   * @see PartitionEventType
   */
  PartitionEventType::type eventType;

  _ThriftHiveMetastore_markPartitionForEvent_args__isset __isset;

  void __set_db_name(const std::string& val);

  void __set_tbl_name(const std::string& val);

  void __set_part_vals(const std::map<std::string, std::string> & val);

  void __set_eventType(const PartitionEventType::type 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() noexcept;
  const std::string* db_name;
  const std::string* tbl_name;
  const std::map<std::string, std::string> * part_vals;
  /**
   * 
   * @see PartitionEventType
   */
  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 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
  bool o5 :1;
  bool o6 :1;
} _ThriftHiveMetastore_markPartitionForEvent_result__isset;

class ThriftHiveMetastore_markPartitionForEvent_result {
 public:

  ThriftHiveMetastore_markPartitionForEvent_result(const ThriftHiveMetastore_markPartitionForEvent_result&);
  ThriftHiveMetastore_markPartitionForEvent_result& operator=(const ThriftHiveMetastore_markPartitionForEvent_result&);
  ThriftHiveMetastore_markPartitionForEvent_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_markPartitionForEvent_result() noexcept;
  MetaException o1;
  NoSuchObjectException o2;
  UnknownDBException o3;
  UnknownTableException o4;
  UnknownPartitionException o5;
  InvalidPartitionException o6;

  _ThriftHiveMetastore_markPartitionForEvent_result__isset __isset;

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& val);

  void __set_o3(const UnknownDBException& val);

  void __set_o4(const UnknownTableException& val);

  void __set_o5(const UnknownPartitionException& val);

  void __set_o6(const InvalidPartitionException& 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 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
  bool o5 :1;
  bool o6 :1;
} _ThriftHiveMetastore_markPartitionForEvent_presult__isset;

class ThriftHiveMetastore_markPartitionForEvent_presult {
 public:


  virtual ~ThriftHiveMetastore_markPartitionForEvent_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_vals :1;
  bool eventType :1;
} _ThriftHiveMetastore_isPartitionMarkedForEvent_args__isset;

class ThriftHiveMetastore_isPartitionMarkedForEvent_args {
 public:

  ThriftHiveMetastore_isPartitionMarkedForEvent_args(const ThriftHiveMetastore_isPartitionMarkedForEvent_args&);
  ThriftHiveMetastore_isPartitionMarkedForEvent_args& operator=(const ThriftHiveMetastore_isPartitionMarkedForEvent_args&);
  ThriftHiveMetastore_isPartitionMarkedForEvent_args() noexcept
                                                     : db_name(),
                                                       tbl_name(),
                                                       eventType(static_cast<PartitionEventType::type>(0)) {
  }

  virtual ~ThriftHiveMetastore_isPartitionMarkedForEvent_args() noexcept;
  std::string db_name;
  std::string tbl_name;
  std::map<std::string, std::string>  part_vals;
  /**
   * 
   * @see PartitionEventType
   */
  PartitionEventType::type eventType;

  _ThriftHiveMetastore_isPartitionMarkedForEvent_args__isset __isset;

  void __set_db_name(const std::string& val);

  void __set_tbl_name(const std::string& val);

  void __set_part_vals(const std::map<std::string, std::string> & val);

  void __set_eventType(const PartitionEventType::type 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() noexcept;
  const std::string* db_name;
  const std::string* tbl_name;
  const std::map<std::string, std::string> * part_vals;
  /**
   * 
   * @see PartitionEventType
   */
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
  bool o5 :1;
  bool o6 :1;
} _ThriftHiveMetastore_isPartitionMarkedForEvent_result__isset;

class ThriftHiveMetastore_isPartitionMarkedForEvent_result {
 public:

  ThriftHiveMetastore_isPartitionMarkedForEvent_result(const ThriftHiveMetastore_isPartitionMarkedForEvent_result&);
  ThriftHiveMetastore_isPartitionMarkedForEvent_result& operator=(const ThriftHiveMetastore_isPartitionMarkedForEvent_result&);
  ThriftHiveMetastore_isPartitionMarkedForEvent_result() noexcept
                                                       : success(0) {
  }

  virtual ~ThriftHiveMetastore_isPartitionMarkedForEvent_result() noexcept;
  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);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& val);

  void __set_o3(const UnknownDBException& val);

  void __set_o4(const UnknownTableException& val);

  void __set_o5(const UnknownPartitionException& val);

  void __set_o6(const InvalidPartitionException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
  bool o5 :1;
  bool o6 :1;
} _ThriftHiveMetastore_isPartitionMarkedForEvent_presult__isset;

class ThriftHiveMetastore_isPartitionMarkedForEvent_presult {
 public:


  virtual ~ThriftHiveMetastore_isPartitionMarkedForEvent_presult() noexcept;
  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_get_primary_keys_args__isset {
  _ThriftHiveMetastore_get_primary_keys_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_get_primary_keys_args__isset;

class ThriftHiveMetastore_get_primary_keys_args {
 public:

  ThriftHiveMetastore_get_primary_keys_args(const ThriftHiveMetastore_get_primary_keys_args&);
  ThriftHiveMetastore_get_primary_keys_args& operator=(const ThriftHiveMetastore_get_primary_keys_args&);
  ThriftHiveMetastore_get_primary_keys_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_primary_keys_args() noexcept;
  PrimaryKeysRequest request;

  _ThriftHiveMetastore_get_primary_keys_args__isset __isset;

  void __set_request(const PrimaryKeysRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_primary_keys_args & ) const;

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

};


class ThriftHiveMetastore_get_primary_keys_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_primary_keys_pargs() noexcept;
  const PrimaryKeysRequest* request;

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

};

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

class ThriftHiveMetastore_get_primary_keys_result {
 public:

  ThriftHiveMetastore_get_primary_keys_result(const ThriftHiveMetastore_get_primary_keys_result&);
  ThriftHiveMetastore_get_primary_keys_result& operator=(const ThriftHiveMetastore_get_primary_keys_result&);
  ThriftHiveMetastore_get_primary_keys_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_primary_keys_result() noexcept;
  PrimaryKeysResponse success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_primary_keys_result__isset __isset;

  void __set_success(const PrimaryKeysResponse& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& val);

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

  bool operator < (const ThriftHiveMetastore_get_primary_keys_result & ) const;

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

};

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

class ThriftHiveMetastore_get_primary_keys_presult {
 public:


  virtual ~ThriftHiveMetastore_get_primary_keys_presult() noexcept;
  PrimaryKeysResponse* success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_primary_keys_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_foreign_keys_args__isset {
  _ThriftHiveMetastore_get_foreign_keys_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_get_foreign_keys_args__isset;

class ThriftHiveMetastore_get_foreign_keys_args {
 public:

  ThriftHiveMetastore_get_foreign_keys_args(const ThriftHiveMetastore_get_foreign_keys_args&);
  ThriftHiveMetastore_get_foreign_keys_args& operator=(const ThriftHiveMetastore_get_foreign_keys_args&);
  ThriftHiveMetastore_get_foreign_keys_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_foreign_keys_args() noexcept;
  ForeignKeysRequest request;

  _ThriftHiveMetastore_get_foreign_keys_args__isset __isset;

  void __set_request(const ForeignKeysRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_foreign_keys_args & ) const;

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

};


class ThriftHiveMetastore_get_foreign_keys_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_foreign_keys_pargs() noexcept;
  const ForeignKeysRequest* request;

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

};

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

class ThriftHiveMetastore_get_foreign_keys_result {
 public:

  ThriftHiveMetastore_get_foreign_keys_result(const ThriftHiveMetastore_get_foreign_keys_result&);
  ThriftHiveMetastore_get_foreign_keys_result& operator=(const ThriftHiveMetastore_get_foreign_keys_result&);
  ThriftHiveMetastore_get_foreign_keys_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_foreign_keys_result() noexcept;
  ForeignKeysResponse success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_foreign_keys_result__isset __isset;

  void __set_success(const ForeignKeysResponse& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& val);

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

  bool operator < (const ThriftHiveMetastore_get_foreign_keys_result & ) const;

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

};

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

class ThriftHiveMetastore_get_foreign_keys_presult {
 public:


  virtual ~ThriftHiveMetastore_get_foreign_keys_presult() noexcept;
  ForeignKeysResponse* success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_foreign_keys_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_unique_constraints_args__isset {
  _ThriftHiveMetastore_get_unique_constraints_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_get_unique_constraints_args__isset;

class ThriftHiveMetastore_get_unique_constraints_args {
 public:

  ThriftHiveMetastore_get_unique_constraints_args(const ThriftHiveMetastore_get_unique_constraints_args&);
  ThriftHiveMetastore_get_unique_constraints_args& operator=(const ThriftHiveMetastore_get_unique_constraints_args&);
  ThriftHiveMetastore_get_unique_constraints_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_unique_constraints_args() noexcept;
  UniqueConstraintsRequest request;

  _ThriftHiveMetastore_get_unique_constraints_args__isset __isset;

  void __set_request(const UniqueConstraintsRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_unique_constraints_args & ) const;

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

};


class ThriftHiveMetastore_get_unique_constraints_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_unique_constraints_pargs() noexcept;
  const UniqueConstraintsRequest* request;

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

};

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

class ThriftHiveMetastore_get_unique_constraints_result {
 public:

  ThriftHiveMetastore_get_unique_constraints_result(const ThriftHiveMetastore_get_unique_constraints_result&);
  ThriftHiveMetastore_get_unique_constraints_result& operator=(const ThriftHiveMetastore_get_unique_constraints_result&);
  ThriftHiveMetastore_get_unique_constraints_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_unique_constraints_result() noexcept;
  UniqueConstraintsResponse success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_unique_constraints_result__isset __isset;

  void __set_success(const UniqueConstraintsResponse& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& val);

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

  bool operator < (const ThriftHiveMetastore_get_unique_constraints_result & ) const;

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

};

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

class ThriftHiveMetastore_get_unique_constraints_presult {
 public:


  virtual ~ThriftHiveMetastore_get_unique_constraints_presult() noexcept;
  UniqueConstraintsResponse* success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_unique_constraints_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_not_null_constraints_args__isset {
  _ThriftHiveMetastore_get_not_null_constraints_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_get_not_null_constraints_args__isset;

class ThriftHiveMetastore_get_not_null_constraints_args {
 public:

  ThriftHiveMetastore_get_not_null_constraints_args(const ThriftHiveMetastore_get_not_null_constraints_args&);
  ThriftHiveMetastore_get_not_null_constraints_args& operator=(const ThriftHiveMetastore_get_not_null_constraints_args&);
  ThriftHiveMetastore_get_not_null_constraints_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_not_null_constraints_args() noexcept;
  NotNullConstraintsRequest request;

  _ThriftHiveMetastore_get_not_null_constraints_args__isset __isset;

  void __set_request(const NotNullConstraintsRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_not_null_constraints_args & ) const;

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

};


class ThriftHiveMetastore_get_not_null_constraints_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_not_null_constraints_pargs() noexcept;
  const NotNullConstraintsRequest* request;

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

};

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

class ThriftHiveMetastore_get_not_null_constraints_result {
 public:

  ThriftHiveMetastore_get_not_null_constraints_result(const ThriftHiveMetastore_get_not_null_constraints_result&);
  ThriftHiveMetastore_get_not_null_constraints_result& operator=(const ThriftHiveMetastore_get_not_null_constraints_result&);
  ThriftHiveMetastore_get_not_null_constraints_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_not_null_constraints_result() noexcept;
  NotNullConstraintsResponse success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_not_null_constraints_result__isset __isset;

  void __set_success(const NotNullConstraintsResponse& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& val);

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

  bool operator < (const ThriftHiveMetastore_get_not_null_constraints_result & ) const;

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

};

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

class ThriftHiveMetastore_get_not_null_constraints_presult {
 public:


  virtual ~ThriftHiveMetastore_get_not_null_constraints_presult() noexcept;
  NotNullConstraintsResponse* success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_not_null_constraints_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_default_constraints_args__isset {
  _ThriftHiveMetastore_get_default_constraints_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_get_default_constraints_args__isset;

class ThriftHiveMetastore_get_default_constraints_args {
 public:

  ThriftHiveMetastore_get_default_constraints_args(const ThriftHiveMetastore_get_default_constraints_args&);
  ThriftHiveMetastore_get_default_constraints_args& operator=(const ThriftHiveMetastore_get_default_constraints_args&);
  ThriftHiveMetastore_get_default_constraints_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_default_constraints_args() noexcept;
  DefaultConstraintsRequest request;

  _ThriftHiveMetastore_get_default_constraints_args__isset __isset;

  void __set_request(const DefaultConstraintsRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_default_constraints_args & ) const;

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

};


class ThriftHiveMetastore_get_default_constraints_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_default_constraints_pargs() noexcept;
  const DefaultConstraintsRequest* request;

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

};

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

class ThriftHiveMetastore_get_default_constraints_result {
 public:

  ThriftHiveMetastore_get_default_constraints_result(const ThriftHiveMetastore_get_default_constraints_result&);
  ThriftHiveMetastore_get_default_constraints_result& operator=(const ThriftHiveMetastore_get_default_constraints_result&);
  ThriftHiveMetastore_get_default_constraints_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_default_constraints_result() noexcept;
  DefaultConstraintsResponse success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_default_constraints_result__isset __isset;

  void __set_success(const DefaultConstraintsResponse& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& val);

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

  bool operator < (const ThriftHiveMetastore_get_default_constraints_result & ) const;

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

};

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

class ThriftHiveMetastore_get_default_constraints_presult {
 public:


  virtual ~ThriftHiveMetastore_get_default_constraints_presult() noexcept;
  DefaultConstraintsResponse* success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_default_constraints_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_check_constraints_args__isset {
  _ThriftHiveMetastore_get_check_constraints_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_get_check_constraints_args__isset;

class ThriftHiveMetastore_get_check_constraints_args {
 public:

  ThriftHiveMetastore_get_check_constraints_args(const ThriftHiveMetastore_get_check_constraints_args&);
  ThriftHiveMetastore_get_check_constraints_args& operator=(const ThriftHiveMetastore_get_check_constraints_args&);
  ThriftHiveMetastore_get_check_constraints_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_check_constraints_args() noexcept;
  CheckConstraintsRequest request;

  _ThriftHiveMetastore_get_check_constraints_args__isset __isset;

  void __set_request(const CheckConstraintsRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_check_constraints_args & ) const;

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

};


class ThriftHiveMetastore_get_check_constraints_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_check_constraints_pargs() noexcept;
  const CheckConstraintsRequest* request;

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

};

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

class ThriftHiveMetastore_get_check_constraints_result {
 public:

  ThriftHiveMetastore_get_check_constraints_result(const ThriftHiveMetastore_get_check_constraints_result&);
  ThriftHiveMetastore_get_check_constraints_result& operator=(const ThriftHiveMetastore_get_check_constraints_result&);
  ThriftHiveMetastore_get_check_constraints_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_check_constraints_result() noexcept;
  CheckConstraintsResponse success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_check_constraints_result__isset __isset;

  void __set_success(const CheckConstraintsResponse& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& val);

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

  bool operator < (const ThriftHiveMetastore_get_check_constraints_result & ) const;

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

};

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

class ThriftHiveMetastore_get_check_constraints_presult {
 public:


  virtual ~ThriftHiveMetastore_get_check_constraints_presult() noexcept;
  CheckConstraintsResponse* success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_check_constraints_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 :1;
} _ThriftHiveMetastore_update_table_column_statistics_args__isset;

class ThriftHiveMetastore_update_table_column_statistics_args {
 public:

  ThriftHiveMetastore_update_table_column_statistics_args(const ThriftHiveMetastore_update_table_column_statistics_args&);
  ThriftHiveMetastore_update_table_column_statistics_args& operator=(const ThriftHiveMetastore_update_table_column_statistics_args&);
  ThriftHiveMetastore_update_table_column_statistics_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_update_table_column_statistics_args() noexcept;
  ColumnStatistics stats_obj;

  _ThriftHiveMetastore_update_table_column_statistics_args__isset __isset;

  void __set_stats_obj(const ColumnStatistics& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_update_table_column_statistics_result__isset;

class ThriftHiveMetastore_update_table_column_statistics_result {
 public:

  ThriftHiveMetastore_update_table_column_statistics_result(const ThriftHiveMetastore_update_table_column_statistics_result&);
  ThriftHiveMetastore_update_table_column_statistics_result& operator=(const ThriftHiveMetastore_update_table_column_statistics_result&);
  ThriftHiveMetastore_update_table_column_statistics_result() noexcept
                                                            : success(0) {
  }

  virtual ~ThriftHiveMetastore_update_table_column_statistics_result() noexcept;
  bool success;
  NoSuchObjectException o1;
  InvalidObjectException o2;
  MetaException o3;
  InvalidInputException o4;

  _ThriftHiveMetastore_update_table_column_statistics_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const InvalidObjectException& val);

  void __set_o3(const MetaException& val);

  void __set_o4(const InvalidInputException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_update_table_column_statistics_presult__isset;

class ThriftHiveMetastore_update_table_column_statistics_presult {
 public:


  virtual ~ThriftHiveMetastore_update_table_column_statistics_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_update_partition_column_statistics_args__isset;

class ThriftHiveMetastore_update_partition_column_statistics_args {
 public:

  ThriftHiveMetastore_update_partition_column_statistics_args(const ThriftHiveMetastore_update_partition_column_statistics_args&);
  ThriftHiveMetastore_update_partition_column_statistics_args& operator=(const ThriftHiveMetastore_update_partition_column_statistics_args&);
  ThriftHiveMetastore_update_partition_column_statistics_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_update_partition_column_statistics_args() noexcept;
  ColumnStatistics stats_obj;

  _ThriftHiveMetastore_update_partition_column_statistics_args__isset __isset;

  void __set_stats_obj(const ColumnStatistics& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_update_partition_column_statistics_result__isset;

class ThriftHiveMetastore_update_partition_column_statistics_result {
 public:

  ThriftHiveMetastore_update_partition_column_statistics_result(const ThriftHiveMetastore_update_partition_column_statistics_result&);
  ThriftHiveMetastore_update_partition_column_statistics_result& operator=(const ThriftHiveMetastore_update_partition_column_statistics_result&);
  ThriftHiveMetastore_update_partition_column_statistics_result() noexcept
                                                                : success(0) {
  }

  virtual ~ThriftHiveMetastore_update_partition_column_statistics_result() noexcept;
  bool success;
  NoSuchObjectException o1;
  InvalidObjectException o2;
  MetaException o3;
  InvalidInputException o4;

  _ThriftHiveMetastore_update_partition_column_statistics_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const InvalidObjectException& val);

  void __set_o3(const MetaException& val);

  void __set_o4(const InvalidInputException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_update_partition_column_statistics_presult__isset;

class ThriftHiveMetastore_update_partition_column_statistics_presult {
 public:


  virtual ~ThriftHiveMetastore_update_partition_column_statistics_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool col_name :1;
} _ThriftHiveMetastore_get_table_column_statistics_args__isset;

class ThriftHiveMetastore_get_table_column_statistics_args {
 public:

  ThriftHiveMetastore_get_table_column_statistics_args(const ThriftHiveMetastore_get_table_column_statistics_args&);
  ThriftHiveMetastore_get_table_column_statistics_args& operator=(const ThriftHiveMetastore_get_table_column_statistics_args&);
  ThriftHiveMetastore_get_table_column_statistics_args() noexcept
                                                       : db_name(),
                                                         tbl_name(),
                                                         col_name() {
  }

  virtual ~ThriftHiveMetastore_get_table_column_statistics_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_col_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_get_table_column_statistics_result__isset;

class ThriftHiveMetastore_get_table_column_statistics_result {
 public:

  ThriftHiveMetastore_get_table_column_statistics_result(const ThriftHiveMetastore_get_table_column_statistics_result&);
  ThriftHiveMetastore_get_table_column_statistics_result& operator=(const ThriftHiveMetastore_get_table_column_statistics_result&);
  ThriftHiveMetastore_get_table_column_statistics_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_table_column_statistics_result() noexcept;
  ColumnStatistics success;
  NoSuchObjectException o1;
  MetaException o2;
  InvalidInputException o3;
  InvalidObjectException o4;

  _ThriftHiveMetastore_get_table_column_statistics_result__isset __isset;

  void __set_success(const ColumnStatistics& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

  void __set_o3(const InvalidInputException& val);

  void __set_o4(const InvalidObjectException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_get_table_column_statistics_presult__isset;

class ThriftHiveMetastore_get_table_column_statistics_presult {
 public:


  virtual ~ThriftHiveMetastore_get_table_column_statistics_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_name :1;
  bool col_name :1;
} _ThriftHiveMetastore_get_partition_column_statistics_args__isset;

class ThriftHiveMetastore_get_partition_column_statistics_args {
 public:

  ThriftHiveMetastore_get_partition_column_statistics_args(const ThriftHiveMetastore_get_partition_column_statistics_args&);
  ThriftHiveMetastore_get_partition_column_statistics_args& operator=(const ThriftHiveMetastore_get_partition_column_statistics_args&);
  ThriftHiveMetastore_get_partition_column_statistics_args() noexcept
                                                           : db_name(),
                                                             tbl_name(),
                                                             part_name(),
                                                             col_name() {
  }

  virtual ~ThriftHiveMetastore_get_partition_column_statistics_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_name(const std::string& val);

  void __set_col_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_get_partition_column_statistics_result__isset;

class ThriftHiveMetastore_get_partition_column_statistics_result {
 public:

  ThriftHiveMetastore_get_partition_column_statistics_result(const ThriftHiveMetastore_get_partition_column_statistics_result&);
  ThriftHiveMetastore_get_partition_column_statistics_result& operator=(const ThriftHiveMetastore_get_partition_column_statistics_result&);
  ThriftHiveMetastore_get_partition_column_statistics_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partition_column_statistics_result() noexcept;
  ColumnStatistics success;
  NoSuchObjectException o1;
  MetaException o2;
  InvalidInputException o3;
  InvalidObjectException o4;

  _ThriftHiveMetastore_get_partition_column_statistics_result__isset __isset;

  void __set_success(const ColumnStatistics& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

  void __set_o3(const InvalidInputException& val);

  void __set_o4(const InvalidObjectException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_get_partition_column_statistics_presult__isset;

class ThriftHiveMetastore_get_partition_column_statistics_presult {
 public:


  virtual ~ThriftHiveMetastore_get_partition_column_statistics_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_get_table_statistics_req_args__isset;

class ThriftHiveMetastore_get_table_statistics_req_args {
 public:

  ThriftHiveMetastore_get_table_statistics_req_args(const ThriftHiveMetastore_get_table_statistics_req_args&);
  ThriftHiveMetastore_get_table_statistics_req_args& operator=(const ThriftHiveMetastore_get_table_statistics_req_args&);
  ThriftHiveMetastore_get_table_statistics_req_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_table_statistics_req_args() noexcept;
  TableStatsRequest request;

  _ThriftHiveMetastore_get_table_statistics_req_args__isset __isset;

  void __set_request(const TableStatsRequest& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_table_statistics_req_result__isset;

class ThriftHiveMetastore_get_table_statistics_req_result {
 public:

  ThriftHiveMetastore_get_table_statistics_req_result(const ThriftHiveMetastore_get_table_statistics_req_result&);
  ThriftHiveMetastore_get_table_statistics_req_result& operator=(const ThriftHiveMetastore_get_table_statistics_req_result&);
  ThriftHiveMetastore_get_table_statistics_req_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_table_statistics_req_result() noexcept;
  TableStatsResult success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_table_statistics_req_result__isset __isset;

  void __set_success(const TableStatsResult& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_table_statistics_req_presult__isset;

class ThriftHiveMetastore_get_table_statistics_req_presult {
 public:


  virtual ~ThriftHiveMetastore_get_table_statistics_req_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_get_partitions_statistics_req_args__isset;

class ThriftHiveMetastore_get_partitions_statistics_req_args {
 public:

  ThriftHiveMetastore_get_partitions_statistics_req_args(const ThriftHiveMetastore_get_partitions_statistics_req_args&);
  ThriftHiveMetastore_get_partitions_statistics_req_args& operator=(const ThriftHiveMetastore_get_partitions_statistics_req_args&);
  ThriftHiveMetastore_get_partitions_statistics_req_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partitions_statistics_req_args() noexcept;
  PartitionsStatsRequest request;

  _ThriftHiveMetastore_get_partitions_statistics_req_args__isset __isset;

  void __set_request(const PartitionsStatsRequest& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_statistics_req_result__isset;

class ThriftHiveMetastore_get_partitions_statistics_req_result {
 public:

  ThriftHiveMetastore_get_partitions_statistics_req_result(const ThriftHiveMetastore_get_partitions_statistics_req_result&);
  ThriftHiveMetastore_get_partitions_statistics_req_result& operator=(const ThriftHiveMetastore_get_partitions_statistics_req_result&);
  ThriftHiveMetastore_get_partitions_statistics_req_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_partitions_statistics_req_result() noexcept;
  PartitionsStatsResult success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_partitions_statistics_req_result__isset __isset;

  void __set_success(const PartitionsStatsResult& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_partitions_statistics_req_presult__isset;

class ThriftHiveMetastore_get_partitions_statistics_req_presult {
 public:


  virtual ~ThriftHiveMetastore_get_partitions_statistics_req_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_get_aggr_stats_for_args__isset;

class ThriftHiveMetastore_get_aggr_stats_for_args {
 public:

  ThriftHiveMetastore_get_aggr_stats_for_args(const ThriftHiveMetastore_get_aggr_stats_for_args&);
  ThriftHiveMetastore_get_aggr_stats_for_args& operator=(const ThriftHiveMetastore_get_aggr_stats_for_args&);
  ThriftHiveMetastore_get_aggr_stats_for_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_aggr_stats_for_args() noexcept;
  PartitionsStatsRequest request;

  _ThriftHiveMetastore_get_aggr_stats_for_args__isset __isset;

  void __set_request(const PartitionsStatsRequest& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_aggr_stats_for_result__isset;

class ThriftHiveMetastore_get_aggr_stats_for_result {
 public:

  ThriftHiveMetastore_get_aggr_stats_for_result(const ThriftHiveMetastore_get_aggr_stats_for_result&);
  ThriftHiveMetastore_get_aggr_stats_for_result& operator=(const ThriftHiveMetastore_get_aggr_stats_for_result&);
  ThriftHiveMetastore_get_aggr_stats_for_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_aggr_stats_for_result() noexcept;
  AggrStats success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_aggr_stats_for_result__isset __isset;

  void __set_success(const AggrStats& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_aggr_stats_for_presult__isset;

class ThriftHiveMetastore_get_aggr_stats_for_presult {
 public:


  virtual ~ThriftHiveMetastore_get_aggr_stats_for_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_set_aggr_stats_for_args__isset;

class ThriftHiveMetastore_set_aggr_stats_for_args {
 public:

  ThriftHiveMetastore_set_aggr_stats_for_args(const ThriftHiveMetastore_set_aggr_stats_for_args&);
  ThriftHiveMetastore_set_aggr_stats_for_args& operator=(const ThriftHiveMetastore_set_aggr_stats_for_args&);
  ThriftHiveMetastore_set_aggr_stats_for_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_set_aggr_stats_for_args() noexcept;
  SetPartitionsStatsRequest request;

  _ThriftHiveMetastore_set_aggr_stats_for_args__isset __isset;

  void __set_request(const SetPartitionsStatsRequest& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_set_aggr_stats_for_result__isset;

class ThriftHiveMetastore_set_aggr_stats_for_result {
 public:

  ThriftHiveMetastore_set_aggr_stats_for_result(const ThriftHiveMetastore_set_aggr_stats_for_result&);
  ThriftHiveMetastore_set_aggr_stats_for_result& operator=(const ThriftHiveMetastore_set_aggr_stats_for_result&);
  ThriftHiveMetastore_set_aggr_stats_for_result() noexcept
                                                : success(0) {
  }

  virtual ~ThriftHiveMetastore_set_aggr_stats_for_result() noexcept;
  bool success;
  NoSuchObjectException o1;
  InvalidObjectException o2;
  MetaException o3;
  InvalidInputException o4;

  _ThriftHiveMetastore_set_aggr_stats_for_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const InvalidObjectException& val);

  void __set_o3(const MetaException& val);

  void __set_o4(const InvalidInputException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_set_aggr_stats_for_presult__isset;

class ThriftHiveMetastore_set_aggr_stats_for_presult {
 public:


  virtual ~ThriftHiveMetastore_set_aggr_stats_for_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool part_name :1;
  bool col_name :1;
} _ThriftHiveMetastore_delete_partition_column_statistics_args__isset;

class ThriftHiveMetastore_delete_partition_column_statistics_args {
 public:

  ThriftHiveMetastore_delete_partition_column_statistics_args(const ThriftHiveMetastore_delete_partition_column_statistics_args&);
  ThriftHiveMetastore_delete_partition_column_statistics_args& operator=(const ThriftHiveMetastore_delete_partition_column_statistics_args&);
  ThriftHiveMetastore_delete_partition_column_statistics_args() noexcept
                                                              : db_name(),
                                                                tbl_name(),
                                                                part_name(),
                                                                col_name() {
  }

  virtual ~ThriftHiveMetastore_delete_partition_column_statistics_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_part_name(const std::string& val);

  void __set_col_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_delete_partition_column_statistics_result__isset;

class ThriftHiveMetastore_delete_partition_column_statistics_result {
 public:

  ThriftHiveMetastore_delete_partition_column_statistics_result(const ThriftHiveMetastore_delete_partition_column_statistics_result&);
  ThriftHiveMetastore_delete_partition_column_statistics_result& operator=(const ThriftHiveMetastore_delete_partition_column_statistics_result&);
  ThriftHiveMetastore_delete_partition_column_statistics_result() noexcept
                                                                : success(0) {
  }

  virtual ~ThriftHiveMetastore_delete_partition_column_statistics_result() noexcept;
  bool success;
  NoSuchObjectException o1;
  MetaException o2;
  InvalidObjectException o3;
  InvalidInputException o4;

  _ThriftHiveMetastore_delete_partition_column_statistics_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

  void __set_o3(const InvalidObjectException& val);

  void __set_o4(const InvalidInputException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_delete_partition_column_statistics_presult__isset;

class ThriftHiveMetastore_delete_partition_column_statistics_presult {
 public:


  virtual ~ThriftHiveMetastore_delete_partition_column_statistics_presult() noexcept;
  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 :1;
  bool tbl_name :1;
  bool col_name :1;
} _ThriftHiveMetastore_delete_table_column_statistics_args__isset;

class ThriftHiveMetastore_delete_table_column_statistics_args {
 public:

  ThriftHiveMetastore_delete_table_column_statistics_args(const ThriftHiveMetastore_delete_table_column_statistics_args&);
  ThriftHiveMetastore_delete_table_column_statistics_args& operator=(const ThriftHiveMetastore_delete_table_column_statistics_args&);
  ThriftHiveMetastore_delete_table_column_statistics_args() noexcept
                                                          : db_name(),
                                                            tbl_name(),
                                                            col_name() {
  }

  virtual ~ThriftHiveMetastore_delete_table_column_statistics_args() noexcept;
  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);

  void __set_tbl_name(const std::string& val);

  void __set_col_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_delete_table_column_statistics_result__isset;

class ThriftHiveMetastore_delete_table_column_statistics_result {
 public:

  ThriftHiveMetastore_delete_table_column_statistics_result(const ThriftHiveMetastore_delete_table_column_statistics_result&);
  ThriftHiveMetastore_delete_table_column_statistics_result& operator=(const ThriftHiveMetastore_delete_table_column_statistics_result&);
  ThriftHiveMetastore_delete_table_column_statistics_result() noexcept
                                                            : success(0) {
  }

  virtual ~ThriftHiveMetastore_delete_table_column_statistics_result() noexcept;
  bool success;
  NoSuchObjectException o1;
  MetaException o2;
  InvalidObjectException o3;
  InvalidInputException o4;

  _ThriftHiveMetastore_delete_table_column_statistics_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

  void __set_o3(const InvalidObjectException& val);

  void __set_o4(const InvalidInputException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_delete_table_column_statistics_presult__isset;

class ThriftHiveMetastore_delete_table_column_statistics_presult {
 public:


  virtual ~ThriftHiveMetastore_delete_table_column_statistics_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_create_function_args__isset;

class ThriftHiveMetastore_create_function_args {
 public:

  ThriftHiveMetastore_create_function_args(const ThriftHiveMetastore_create_function_args&);
  ThriftHiveMetastore_create_function_args& operator=(const ThriftHiveMetastore_create_function_args&);
  ThriftHiveMetastore_create_function_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_function_args() noexcept;
  Function func;

  _ThriftHiveMetastore_create_function_args__isset __isset;

  void __set_func(const Function& 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() noexcept;
  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 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_create_function_result__isset;

class ThriftHiveMetastore_create_function_result {
 public:

  ThriftHiveMetastore_create_function_result(const ThriftHiveMetastore_create_function_result&);
  ThriftHiveMetastore_create_function_result& operator=(const ThriftHiveMetastore_create_function_result&);
  ThriftHiveMetastore_create_function_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_function_result() noexcept;
  AlreadyExistsException o1;
  InvalidObjectException o2;
  MetaException o3;
  NoSuchObjectException o4;

  _ThriftHiveMetastore_create_function_result__isset __isset;

  void __set_o1(const AlreadyExistsException& val);

  void __set_o2(const InvalidObjectException& val);

  void __set_o3(const MetaException& val);

  void __set_o4(const NoSuchObjectException& 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 :1;
  bool o2 :1;
  bool o3 :1;
  bool o4 :1;
} _ThriftHiveMetastore_create_function_presult__isset;

class ThriftHiveMetastore_create_function_presult {
 public:


  virtual ~ThriftHiveMetastore_create_function_presult() noexcept;
  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 :1;
  bool funcName :1;
} _ThriftHiveMetastore_drop_function_args__isset;

class ThriftHiveMetastore_drop_function_args {
 public:

  ThriftHiveMetastore_drop_function_args(const ThriftHiveMetastore_drop_function_args&);
  ThriftHiveMetastore_drop_function_args& operator=(const ThriftHiveMetastore_drop_function_args&);
  ThriftHiveMetastore_drop_function_args() noexcept
                                         : dbName(),
                                           funcName() {
  }

  virtual ~ThriftHiveMetastore_drop_function_args() noexcept;
  std::string dbName;
  std::string funcName;

  _ThriftHiveMetastore_drop_function_args__isset __isset;

  void __set_dbName(const std::string& val);

  void __set_funcName(const std::string& 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() noexcept;
  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 :1;
  bool o3 :1;
} _ThriftHiveMetastore_drop_function_result__isset;

class ThriftHiveMetastore_drop_function_result {
 public:

  ThriftHiveMetastore_drop_function_result(const ThriftHiveMetastore_drop_function_result&);
  ThriftHiveMetastore_drop_function_result& operator=(const ThriftHiveMetastore_drop_function_result&);
  ThriftHiveMetastore_drop_function_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_function_result() noexcept;
  NoSuchObjectException o1;
  MetaException o3;

  _ThriftHiveMetastore_drop_function_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o3(const MetaException& 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 :1;
  bool o3 :1;
} _ThriftHiveMetastore_drop_function_presult__isset;

class ThriftHiveMetastore_drop_function_presult {
 public:


  virtual ~ThriftHiveMetastore_drop_function_presult() noexcept;
  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 :1;
  bool funcName :1;
  bool newFunc :1;
} _ThriftHiveMetastore_alter_function_args__isset;

class ThriftHiveMetastore_alter_function_args {
 public:

  ThriftHiveMetastore_alter_function_args(const ThriftHiveMetastore_alter_function_args&);
  ThriftHiveMetastore_alter_function_args& operator=(const ThriftHiveMetastore_alter_function_args&);
  ThriftHiveMetastore_alter_function_args() noexcept
                                          : dbName(),
                                            funcName() {
  }

  virtual ~ThriftHiveMetastore_alter_function_args() noexcept;
  std::string dbName;
  std::string funcName;
  Function newFunc;

  _ThriftHiveMetastore_alter_function_args__isset __isset;

  void __set_dbName(const std::string& val);

  void __set_funcName(const std::string& val);

  void __set_newFunc(const Function& 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() noexcept;
  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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_alter_function_result__isset;

class ThriftHiveMetastore_alter_function_result {
 public:

  ThriftHiveMetastore_alter_function_result(const ThriftHiveMetastore_alter_function_result&);
  ThriftHiveMetastore_alter_function_result& operator=(const ThriftHiveMetastore_alter_function_result&);
  ThriftHiveMetastore_alter_function_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_function_result() noexcept;
  InvalidOperationException o1;
  MetaException o2;

  _ThriftHiveMetastore_alter_function_result__isset __isset;

  void __set_o1(const InvalidOperationException& val);

  void __set_o2(const MetaException& 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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_alter_function_presult__isset;

class ThriftHiveMetastore_alter_function_presult {
 public:


  virtual ~ThriftHiveMetastore_alter_function_presult() noexcept;
  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 :1;
  bool pattern :1;
} _ThriftHiveMetastore_get_functions_args__isset;

class ThriftHiveMetastore_get_functions_args {
 public:

  ThriftHiveMetastore_get_functions_args(const ThriftHiveMetastore_get_functions_args&);
  ThriftHiveMetastore_get_functions_args& operator=(const ThriftHiveMetastore_get_functions_args&);
  ThriftHiveMetastore_get_functions_args() noexcept
                                         : dbName(),
                                           pattern() {
  }

  virtual ~ThriftHiveMetastore_get_functions_args() noexcept;
  std::string dbName;
  std::string pattern;

  _ThriftHiveMetastore_get_functions_args__isset __isset;

  void __set_dbName(const std::string& val);

  void __set_pattern(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_functions_result__isset;

class ThriftHiveMetastore_get_functions_result {
 public:

  ThriftHiveMetastore_get_functions_result(const ThriftHiveMetastore_get_functions_result&);
  ThriftHiveMetastore_get_functions_result& operator=(const ThriftHiveMetastore_get_functions_result&);
  ThriftHiveMetastore_get_functions_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_functions_result() noexcept;
  std::vector<std::string>  success;
  MetaException o1;

  _ThriftHiveMetastore_get_functions_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_functions_presult__isset;

class ThriftHiveMetastore_get_functions_presult {
 public:


  virtual ~ThriftHiveMetastore_get_functions_presult() noexcept;
  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 :1;
  bool funcName :1;
} _ThriftHiveMetastore_get_function_args__isset;

class ThriftHiveMetastore_get_function_args {
 public:

  ThriftHiveMetastore_get_function_args(const ThriftHiveMetastore_get_function_args&);
  ThriftHiveMetastore_get_function_args& operator=(const ThriftHiveMetastore_get_function_args&);
  ThriftHiveMetastore_get_function_args() noexcept
                                        : dbName(),
                                          funcName() {
  }

  virtual ~ThriftHiveMetastore_get_function_args() noexcept;
  std::string dbName;
  std::string funcName;

  _ThriftHiveMetastore_get_function_args__isset __isset;

  void __set_dbName(const std::string& val);

  void __set_funcName(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_function_result__isset;

class ThriftHiveMetastore_get_function_result {
 public:

  ThriftHiveMetastore_get_function_result(const ThriftHiveMetastore_get_function_result&);
  ThriftHiveMetastore_get_function_result& operator=(const ThriftHiveMetastore_get_function_result&);
  ThriftHiveMetastore_get_function_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_function_result() noexcept;
  Function success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_function_result__isset __isset;

  void __set_success(const Function& val);

  void __set_o1(const MetaException& val);

  void __set_o2(const NoSuchObjectException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_function_presult__isset;

class ThriftHiveMetastore_get_function_presult {
 public:


  virtual ~ThriftHiveMetastore_get_function_presult() noexcept;
  Function* success;
  MetaException o1;
  NoSuchObjectException o2;

  _ThriftHiveMetastore_get_function_presult__isset __isset;

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

};


class ThriftHiveMetastore_get_all_functions_args {
 public:

  ThriftHiveMetastore_get_all_functions_args(const ThriftHiveMetastore_get_all_functions_args&) noexcept;
  ThriftHiveMetastore_get_all_functions_args& operator=(const ThriftHiveMetastore_get_all_functions_args&) noexcept;
  ThriftHiveMetastore_get_all_functions_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_all_functions_args() noexcept;

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

  bool operator < (const ThriftHiveMetastore_get_all_functions_args & ) const;

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

};


class ThriftHiveMetastore_get_all_functions_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_all_functions_pargs() noexcept;

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

};

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

class ThriftHiveMetastore_get_all_functions_result {
 public:

  ThriftHiveMetastore_get_all_functions_result(const ThriftHiveMetastore_get_all_functions_result&);
  ThriftHiveMetastore_get_all_functions_result& operator=(const ThriftHiveMetastore_get_all_functions_result&);
  ThriftHiveMetastore_get_all_functions_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_all_functions_result() noexcept;
  GetAllFunctionsResponse success;
  MetaException o1;

  _ThriftHiveMetastore_get_all_functions_result__isset __isset;

  void __set_success(const GetAllFunctionsResponse& val);

  void __set_o1(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_all_functions_result & ) const;

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

};

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

class ThriftHiveMetastore_get_all_functions_presult {
 public:


  virtual ~ThriftHiveMetastore_get_all_functions_presult() noexcept;
  GetAllFunctionsResponse* success;
  MetaException o1;

  _ThriftHiveMetastore_get_all_functions_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 :1;
} _ThriftHiveMetastore_create_role_args__isset;

class ThriftHiveMetastore_create_role_args {
 public:

  ThriftHiveMetastore_create_role_args(const ThriftHiveMetastore_create_role_args&);
  ThriftHiveMetastore_create_role_args& operator=(const ThriftHiveMetastore_create_role_args&);
  ThriftHiveMetastore_create_role_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_role_args() noexcept;
  Role role;

  _ThriftHiveMetastore_create_role_args__isset __isset;

  void __set_role(const 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_create_role_result__isset;

class ThriftHiveMetastore_create_role_result {
 public:

  ThriftHiveMetastore_create_role_result(const ThriftHiveMetastore_create_role_result&);
  ThriftHiveMetastore_create_role_result& operator=(const ThriftHiveMetastore_create_role_result&);
  ThriftHiveMetastore_create_role_result() noexcept
                                         : success(0) {
  }

  virtual ~ThriftHiveMetastore_create_role_result() noexcept;
  bool success;
  MetaException o1;

  _ThriftHiveMetastore_create_role_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_create_role_presult__isset;

class ThriftHiveMetastore_create_role_presult {
 public:


  virtual ~ThriftHiveMetastore_create_role_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_drop_role_args__isset;

class ThriftHiveMetastore_drop_role_args {
 public:

  ThriftHiveMetastore_drop_role_args(const ThriftHiveMetastore_drop_role_args&);
  ThriftHiveMetastore_drop_role_args& operator=(const ThriftHiveMetastore_drop_role_args&);
  ThriftHiveMetastore_drop_role_args() noexcept
                                     : role_name() {
  }

  virtual ~ThriftHiveMetastore_drop_role_args() noexcept;
  std::string role_name;

  _ThriftHiveMetastore_drop_role_args__isset __isset;

  void __set_role_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_drop_role_result__isset;

class ThriftHiveMetastore_drop_role_result {
 public:

  ThriftHiveMetastore_drop_role_result(const ThriftHiveMetastore_drop_role_result&);
  ThriftHiveMetastore_drop_role_result& operator=(const ThriftHiveMetastore_drop_role_result&);
  ThriftHiveMetastore_drop_role_result() noexcept
                                       : success(0) {
  }

  virtual ~ThriftHiveMetastore_drop_role_result() noexcept;
  bool success;
  MetaException o1;

  _ThriftHiveMetastore_drop_role_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_drop_role_presult__isset;

class ThriftHiveMetastore_drop_role_presult {
 public:


  virtual ~ThriftHiveMetastore_drop_role_presult() noexcept;
  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(const ThriftHiveMetastore_get_role_names_args&) noexcept;
  ThriftHiveMetastore_get_role_names_args& operator=(const ThriftHiveMetastore_get_role_names_args&) noexcept;
  ThriftHiveMetastore_get_role_names_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_role_names_args() noexcept;

  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() noexcept;

  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_role_names_result__isset;

class ThriftHiveMetastore_get_role_names_result {
 public:

  ThriftHiveMetastore_get_role_names_result(const ThriftHiveMetastore_get_role_names_result&);
  ThriftHiveMetastore_get_role_names_result& operator=(const ThriftHiveMetastore_get_role_names_result&);
  ThriftHiveMetastore_get_role_names_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_role_names_result() noexcept;
  std::vector<std::string>  success;
  MetaException o1;

  _ThriftHiveMetastore_get_role_names_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_role_names_presult__isset;

class ThriftHiveMetastore_get_role_names_presult {
 public:


  virtual ~ThriftHiveMetastore_get_role_names_presult() noexcept;
  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 :1;
  bool principal_name :1;
  bool principal_type :1;
  bool grantor :1;
  bool grantorType :1;
  bool grant_option :1;
} _ThriftHiveMetastore_grant_role_args__isset;

class ThriftHiveMetastore_grant_role_args {
 public:

  ThriftHiveMetastore_grant_role_args(const ThriftHiveMetastore_grant_role_args&);
  ThriftHiveMetastore_grant_role_args& operator=(const ThriftHiveMetastore_grant_role_args&);
  ThriftHiveMetastore_grant_role_args() noexcept
                                      : role_name(),
                                        principal_name(),
                                        principal_type(static_cast<PrincipalType::type>(0)),
                                        grantor(),
                                        grantorType(static_cast<PrincipalType::type>(0)),
                                        grant_option(0) {
  }

  virtual ~ThriftHiveMetastore_grant_role_args() noexcept;
  std::string role_name;
  std::string principal_name;
  /**
   * 
   * @see PrincipalType
   */
  PrincipalType::type principal_type;
  std::string grantor;
  /**
   * 
   * @see PrincipalType
   */
  PrincipalType::type grantorType;
  bool grant_option;

  _ThriftHiveMetastore_grant_role_args__isset __isset;

  void __set_role_name(const std::string& val);

  void __set_principal_name(const std::string& val);

  void __set_principal_type(const PrincipalType::type val);

  void __set_grantor(const std::string& val);

  void __set_grantorType(const PrincipalType::type val);

  void __set_grant_option(const bool 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() noexcept;
  const std::string* role_name;
  const std::string* principal_name;
  /**
   * 
   * @see PrincipalType
   */
  const PrincipalType::type* principal_type;
  const std::string* grantor;
  /**
   * 
   * @see PrincipalType
   */
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_grant_role_result__isset;

class ThriftHiveMetastore_grant_role_result {
 public:

  ThriftHiveMetastore_grant_role_result(const ThriftHiveMetastore_grant_role_result&);
  ThriftHiveMetastore_grant_role_result& operator=(const ThriftHiveMetastore_grant_role_result&);
  ThriftHiveMetastore_grant_role_result() noexcept
                                        : success(0) {
  }

  virtual ~ThriftHiveMetastore_grant_role_result() noexcept;
  bool success;
  MetaException o1;

  _ThriftHiveMetastore_grant_role_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_grant_role_presult__isset;

class ThriftHiveMetastore_grant_role_presult {
 public:


  virtual ~ThriftHiveMetastore_grant_role_presult() noexcept;
  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 :1;
  bool principal_name :1;
  bool principal_type :1;
} _ThriftHiveMetastore_revoke_role_args__isset;

class ThriftHiveMetastore_revoke_role_args {
 public:

  ThriftHiveMetastore_revoke_role_args(const ThriftHiveMetastore_revoke_role_args&);
  ThriftHiveMetastore_revoke_role_args& operator=(const ThriftHiveMetastore_revoke_role_args&);
  ThriftHiveMetastore_revoke_role_args() noexcept
                                       : role_name(),
                                         principal_name(),
                                         principal_type(static_cast<PrincipalType::type>(0)) {
  }

  virtual ~ThriftHiveMetastore_revoke_role_args() noexcept;
  std::string role_name;
  std::string principal_name;
  /**
   * 
   * @see PrincipalType
   */
  PrincipalType::type principal_type;

  _ThriftHiveMetastore_revoke_role_args__isset __isset;

  void __set_role_name(const std::string& val);

  void __set_principal_name(const std::string& val);

  void __set_principal_type(const PrincipalType::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() noexcept;
  const std::string* role_name;
  const std::string* principal_name;
  /**
   * 
   * @see PrincipalType
   */
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_revoke_role_result__isset;

class ThriftHiveMetastore_revoke_role_result {
 public:

  ThriftHiveMetastore_revoke_role_result(const ThriftHiveMetastore_revoke_role_result&);
  ThriftHiveMetastore_revoke_role_result& operator=(const ThriftHiveMetastore_revoke_role_result&);
  ThriftHiveMetastore_revoke_role_result() noexcept
                                         : success(0) {
  }

  virtual ~ThriftHiveMetastore_revoke_role_result() noexcept;
  bool success;
  MetaException o1;

  _ThriftHiveMetastore_revoke_role_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_revoke_role_presult__isset;

class ThriftHiveMetastore_revoke_role_presult {
 public:


  virtual ~ThriftHiveMetastore_revoke_role_presult() noexcept;
  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 :1;
  bool principal_type :1;
} _ThriftHiveMetastore_list_roles_args__isset;

class ThriftHiveMetastore_list_roles_args {
 public:

  ThriftHiveMetastore_list_roles_args(const ThriftHiveMetastore_list_roles_args&);
  ThriftHiveMetastore_list_roles_args& operator=(const ThriftHiveMetastore_list_roles_args&);
  ThriftHiveMetastore_list_roles_args() noexcept
                                      : principal_name(),
                                        principal_type(static_cast<PrincipalType::type>(0)) {
  }

  virtual ~ThriftHiveMetastore_list_roles_args() noexcept;
  std::string principal_name;
  /**
   * 
   * @see PrincipalType
   */
  PrincipalType::type principal_type;

  _ThriftHiveMetastore_list_roles_args__isset __isset;

  void __set_principal_name(const std::string& val);

  void __set_principal_type(const PrincipalType::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() noexcept;
  const std::string* principal_name;
  /**
   * 
   * @see PrincipalType
   */
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_list_roles_result__isset;

class ThriftHiveMetastore_list_roles_result {
 public:

  ThriftHiveMetastore_list_roles_result(const ThriftHiveMetastore_list_roles_result&);
  ThriftHiveMetastore_list_roles_result& operator=(const ThriftHiveMetastore_list_roles_result&);
  ThriftHiveMetastore_list_roles_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_list_roles_result() noexcept;
  std::vector<Role>  success;
  MetaException o1;

  _ThriftHiveMetastore_list_roles_result__isset __isset;

  void __set_success(const std::vector<Role> & val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_list_roles_presult__isset;

class ThriftHiveMetastore_list_roles_presult {
 public:


  virtual ~ThriftHiveMetastore_list_roles_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_grant_revoke_role_args__isset;

class ThriftHiveMetastore_grant_revoke_role_args {
 public:

  ThriftHiveMetastore_grant_revoke_role_args(const ThriftHiveMetastore_grant_revoke_role_args&);
  ThriftHiveMetastore_grant_revoke_role_args& operator=(const ThriftHiveMetastore_grant_revoke_role_args&);
  ThriftHiveMetastore_grant_revoke_role_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_grant_revoke_role_args() noexcept;
  GrantRevokeRoleRequest request;

  _ThriftHiveMetastore_grant_revoke_role_args__isset __isset;

  void __set_request(const GrantRevokeRoleRequest& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_grant_revoke_role_result__isset;

class ThriftHiveMetastore_grant_revoke_role_result {
 public:

  ThriftHiveMetastore_grant_revoke_role_result(const ThriftHiveMetastore_grant_revoke_role_result&);
  ThriftHiveMetastore_grant_revoke_role_result& operator=(const ThriftHiveMetastore_grant_revoke_role_result&);
  ThriftHiveMetastore_grant_revoke_role_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_grant_revoke_role_result() noexcept;
  GrantRevokeRoleResponse success;
  MetaException o1;

  _ThriftHiveMetastore_grant_revoke_role_result__isset __isset;

  void __set_success(const GrantRevokeRoleResponse& val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_grant_revoke_role_presult__isset;

class ThriftHiveMetastore_grant_revoke_role_presult {
 public:


  virtual ~ThriftHiveMetastore_grant_revoke_role_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_get_principals_in_role_args__isset;

class ThriftHiveMetastore_get_principals_in_role_args {
 public:

  ThriftHiveMetastore_get_principals_in_role_args(const ThriftHiveMetastore_get_principals_in_role_args&);
  ThriftHiveMetastore_get_principals_in_role_args& operator=(const ThriftHiveMetastore_get_principals_in_role_args&);
  ThriftHiveMetastore_get_principals_in_role_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_principals_in_role_args() noexcept;
  GetPrincipalsInRoleRequest request;

  _ThriftHiveMetastore_get_principals_in_role_args__isset __isset;

  void __set_request(const GetPrincipalsInRoleRequest& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_principals_in_role_result__isset;

class ThriftHiveMetastore_get_principals_in_role_result {
 public:

  ThriftHiveMetastore_get_principals_in_role_result(const ThriftHiveMetastore_get_principals_in_role_result&);
  ThriftHiveMetastore_get_principals_in_role_result& operator=(const ThriftHiveMetastore_get_principals_in_role_result&);
  ThriftHiveMetastore_get_principals_in_role_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_principals_in_role_result() noexcept;
  GetPrincipalsInRoleResponse success;
  MetaException o1;

  _ThriftHiveMetastore_get_principals_in_role_result__isset __isset;

  void __set_success(const GetPrincipalsInRoleResponse& val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_principals_in_role_presult__isset;

class ThriftHiveMetastore_get_principals_in_role_presult {
 public:


  virtual ~ThriftHiveMetastore_get_principals_in_role_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_get_role_grants_for_principal_args__isset;

class ThriftHiveMetastore_get_role_grants_for_principal_args {
 public:

  ThriftHiveMetastore_get_role_grants_for_principal_args(const ThriftHiveMetastore_get_role_grants_for_principal_args&);
  ThriftHiveMetastore_get_role_grants_for_principal_args& operator=(const ThriftHiveMetastore_get_role_grants_for_principal_args&);
  ThriftHiveMetastore_get_role_grants_for_principal_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_role_grants_for_principal_args() noexcept;
  GetRoleGrantsForPrincipalRequest request;

  _ThriftHiveMetastore_get_role_grants_for_principal_args__isset __isset;

  void __set_request(const GetRoleGrantsForPrincipalRequest& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_role_grants_for_principal_result__isset;

class ThriftHiveMetastore_get_role_grants_for_principal_result {
 public:

  ThriftHiveMetastore_get_role_grants_for_principal_result(const ThriftHiveMetastore_get_role_grants_for_principal_result&);
  ThriftHiveMetastore_get_role_grants_for_principal_result& operator=(const ThriftHiveMetastore_get_role_grants_for_principal_result&);
  ThriftHiveMetastore_get_role_grants_for_principal_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_role_grants_for_principal_result() noexcept;
  GetRoleGrantsForPrincipalResponse success;
  MetaException o1;

  _ThriftHiveMetastore_get_role_grants_for_principal_result__isset __isset;

  void __set_success(const GetRoleGrantsForPrincipalResponse& val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _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() noexcept;
  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 :1;
  bool user_name :1;
  bool group_names :1;
} _ThriftHiveMetastore_get_privilege_set_args__isset;

class ThriftHiveMetastore_get_privilege_set_args {
 public:

  ThriftHiveMetastore_get_privilege_set_args(const ThriftHiveMetastore_get_privilege_set_args&);
  ThriftHiveMetastore_get_privilege_set_args& operator=(const ThriftHiveMetastore_get_privilege_set_args&);
  ThriftHiveMetastore_get_privilege_set_args() noexcept
                                             : user_name() {
  }

  virtual ~ThriftHiveMetastore_get_privilege_set_args() noexcept;
  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);

  void __set_user_name(const std::string& val);

  void __set_group_names(const std::vector<std::string> & 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_privilege_set_result__isset;

class ThriftHiveMetastore_get_privilege_set_result {
 public:

  ThriftHiveMetastore_get_privilege_set_result(const ThriftHiveMetastore_get_privilege_set_result&);
  ThriftHiveMetastore_get_privilege_set_result& operator=(const ThriftHiveMetastore_get_privilege_set_result&);
  ThriftHiveMetastore_get_privilege_set_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_privilege_set_result() noexcept;
  PrincipalPrivilegeSet success;
  MetaException o1;

  _ThriftHiveMetastore_get_privilege_set_result__isset __isset;

  void __set_success(const PrincipalPrivilegeSet& val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_privilege_set_presult__isset;

class ThriftHiveMetastore_get_privilege_set_presult {
 public:


  virtual ~ThriftHiveMetastore_get_privilege_set_presult() noexcept;
  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 :1;
  bool principal_type :1;
  bool hiveObject :1;
} _ThriftHiveMetastore_list_privileges_args__isset;

class ThriftHiveMetastore_list_privileges_args {
 public:

  ThriftHiveMetastore_list_privileges_args(const ThriftHiveMetastore_list_privileges_args&);
  ThriftHiveMetastore_list_privileges_args& operator=(const ThriftHiveMetastore_list_privileges_args&);
  ThriftHiveMetastore_list_privileges_args() noexcept
                                           : principal_name(),
                                             principal_type(static_cast<PrincipalType::type>(0)) {
  }

  virtual ~ThriftHiveMetastore_list_privileges_args() noexcept;
  std::string principal_name;
  /**
   * 
   * @see PrincipalType
   */
  PrincipalType::type principal_type;
  HiveObjectRef hiveObject;

  _ThriftHiveMetastore_list_privileges_args__isset __isset;

  void __set_principal_name(const std::string& val);

  void __set_principal_type(const PrincipalType::type val);

  void __set_hiveObject(const HiveObjectRef& 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() noexcept;
  const std::string* principal_name;
  /**
   * 
   * @see PrincipalType
   */
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_list_privileges_result__isset;

class ThriftHiveMetastore_list_privileges_result {
 public:

  ThriftHiveMetastore_list_privileges_result(const ThriftHiveMetastore_list_privileges_result&);
  ThriftHiveMetastore_list_privileges_result& operator=(const ThriftHiveMetastore_list_privileges_result&);
  ThriftHiveMetastore_list_privileges_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_list_privileges_result() noexcept;
  std::vector<HiveObjectPrivilege>  success;
  MetaException o1;

  _ThriftHiveMetastore_list_privileges_result__isset __isset;

  void __set_success(const std::vector<HiveObjectPrivilege> & val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_list_privileges_presult__isset;

class ThriftHiveMetastore_list_privileges_presult {
 public:


  virtual ~ThriftHiveMetastore_list_privileges_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_grant_privileges_args__isset;

class ThriftHiveMetastore_grant_privileges_args {
 public:

  ThriftHiveMetastore_grant_privileges_args(const ThriftHiveMetastore_grant_privileges_args&);
  ThriftHiveMetastore_grant_privileges_args& operator=(const ThriftHiveMetastore_grant_privileges_args&);
  ThriftHiveMetastore_grant_privileges_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_grant_privileges_args() noexcept;
  PrivilegeBag privileges;

  _ThriftHiveMetastore_grant_privileges_args__isset __isset;

  void __set_privileges(const PrivilegeBag& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_grant_privileges_result__isset;

class ThriftHiveMetastore_grant_privileges_result {
 public:

  ThriftHiveMetastore_grant_privileges_result(const ThriftHiveMetastore_grant_privileges_result&);
  ThriftHiveMetastore_grant_privileges_result& operator=(const ThriftHiveMetastore_grant_privileges_result&);
  ThriftHiveMetastore_grant_privileges_result() noexcept
                                              : success(0) {
  }

  virtual ~ThriftHiveMetastore_grant_privileges_result() noexcept;
  bool success;
  MetaException o1;

  _ThriftHiveMetastore_grant_privileges_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_grant_privileges_presult__isset;

class ThriftHiveMetastore_grant_privileges_presult {
 public:


  virtual ~ThriftHiveMetastore_grant_privileges_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_revoke_privileges_args__isset;

class ThriftHiveMetastore_revoke_privileges_args {
 public:

  ThriftHiveMetastore_revoke_privileges_args(const ThriftHiveMetastore_revoke_privileges_args&);
  ThriftHiveMetastore_revoke_privileges_args& operator=(const ThriftHiveMetastore_revoke_privileges_args&);
  ThriftHiveMetastore_revoke_privileges_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_revoke_privileges_args() noexcept;
  PrivilegeBag privileges;

  _ThriftHiveMetastore_revoke_privileges_args__isset __isset;

  void __set_privileges(const PrivilegeBag& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_revoke_privileges_result__isset;

class ThriftHiveMetastore_revoke_privileges_result {
 public:

  ThriftHiveMetastore_revoke_privileges_result(const ThriftHiveMetastore_revoke_privileges_result&);
  ThriftHiveMetastore_revoke_privileges_result& operator=(const ThriftHiveMetastore_revoke_privileges_result&);
  ThriftHiveMetastore_revoke_privileges_result() noexcept
                                               : success(0) {
  }

  virtual ~ThriftHiveMetastore_revoke_privileges_result() noexcept;
  bool success;
  MetaException o1;

  _ThriftHiveMetastore_revoke_privileges_result__isset __isset;

  void __set_success(const bool val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_revoke_privileges_presult__isset;

class ThriftHiveMetastore_revoke_privileges_presult {
 public:


  virtual ~ThriftHiveMetastore_revoke_privileges_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_grant_revoke_privileges_args__isset;

class ThriftHiveMetastore_grant_revoke_privileges_args {
 public:

  ThriftHiveMetastore_grant_revoke_privileges_args(const ThriftHiveMetastore_grant_revoke_privileges_args&);
  ThriftHiveMetastore_grant_revoke_privileges_args& operator=(const ThriftHiveMetastore_grant_revoke_privileges_args&);
  ThriftHiveMetastore_grant_revoke_privileges_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_grant_revoke_privileges_args() noexcept;
  GrantRevokePrivilegeRequest request;

  _ThriftHiveMetastore_grant_revoke_privileges_args__isset __isset;

  void __set_request(const GrantRevokePrivilegeRequest& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_grant_revoke_privileges_result__isset;

class ThriftHiveMetastore_grant_revoke_privileges_result {
 public:

  ThriftHiveMetastore_grant_revoke_privileges_result(const ThriftHiveMetastore_grant_revoke_privileges_result&);
  ThriftHiveMetastore_grant_revoke_privileges_result& operator=(const ThriftHiveMetastore_grant_revoke_privileges_result&);
  ThriftHiveMetastore_grant_revoke_privileges_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_grant_revoke_privileges_result() noexcept;
  GrantRevokePrivilegeResponse success;
  MetaException o1;

  _ThriftHiveMetastore_grant_revoke_privileges_result__isset __isset;

  void __set_success(const GrantRevokePrivilegeResponse& val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_grant_revoke_privileges_presult__isset;

class ThriftHiveMetastore_grant_revoke_privileges_presult {
 public:


  virtual ~ThriftHiveMetastore_grant_revoke_privileges_presult() noexcept;
  GrantRevokePrivilegeResponse* success;
  MetaException o1;

  _ThriftHiveMetastore_grant_revoke_privileges_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_refresh_privileges_args__isset {
  _ThriftHiveMetastore_refresh_privileges_args__isset() : objToRefresh(false), authorizer(false), grantRequest(false) {}
  bool objToRefresh :1;
  bool authorizer :1;
  bool grantRequest :1;
} _ThriftHiveMetastore_refresh_privileges_args__isset;

class ThriftHiveMetastore_refresh_privileges_args {
 public:

  ThriftHiveMetastore_refresh_privileges_args(const ThriftHiveMetastore_refresh_privileges_args&);
  ThriftHiveMetastore_refresh_privileges_args& operator=(const ThriftHiveMetastore_refresh_privileges_args&);
  ThriftHiveMetastore_refresh_privileges_args() noexcept
                                              : authorizer() {
  }

  virtual ~ThriftHiveMetastore_refresh_privileges_args() noexcept;
  HiveObjectRef objToRefresh;
  std::string authorizer;
  GrantRevokePrivilegeRequest grantRequest;

  _ThriftHiveMetastore_refresh_privileges_args__isset __isset;

  void __set_objToRefresh(const HiveObjectRef& val);

  void __set_authorizer(const std::string& val);

  void __set_grantRequest(const GrantRevokePrivilegeRequest& val);

  bool operator == (const ThriftHiveMetastore_refresh_privileges_args & rhs) const
  {
    if (!(objToRefresh == rhs.objToRefresh))
      return false;
    if (!(authorizer == rhs.authorizer))
      return false;
    if (!(grantRequest == rhs.grantRequest))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_refresh_privileges_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_refresh_privileges_args & ) const;

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

};


class ThriftHiveMetastore_refresh_privileges_pargs {
 public:


  virtual ~ThriftHiveMetastore_refresh_privileges_pargs() noexcept;
  const HiveObjectRef* objToRefresh;
  const std::string* authorizer;
  const GrantRevokePrivilegeRequest* grantRequest;

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

};

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

class ThriftHiveMetastore_refresh_privileges_result {
 public:

  ThriftHiveMetastore_refresh_privileges_result(const ThriftHiveMetastore_refresh_privileges_result&);
  ThriftHiveMetastore_refresh_privileges_result& operator=(const ThriftHiveMetastore_refresh_privileges_result&);
  ThriftHiveMetastore_refresh_privileges_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_refresh_privileges_result() noexcept;
  GrantRevokePrivilegeResponse success;
  MetaException o1;

  _ThriftHiveMetastore_refresh_privileges_result__isset __isset;

  void __set_success(const GrantRevokePrivilegeResponse& val);

  void __set_o1(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_refresh_privileges_result & ) const;

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

};

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

class ThriftHiveMetastore_refresh_privileges_presult {
 public:


  virtual ~ThriftHiveMetastore_refresh_privileges_presult() noexcept;
  GrantRevokePrivilegeResponse* success;
  MetaException o1;

  _ThriftHiveMetastore_refresh_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 :1;
  bool group_names :1;
} _ThriftHiveMetastore_set_ugi_args__isset;

class ThriftHiveMetastore_set_ugi_args {
 public:

  ThriftHiveMetastore_set_ugi_args(const ThriftHiveMetastore_set_ugi_args&);
  ThriftHiveMetastore_set_ugi_args& operator=(const ThriftHiveMetastore_set_ugi_args&);
  ThriftHiveMetastore_set_ugi_args() noexcept
                                   : user_name() {
  }

  virtual ~ThriftHiveMetastore_set_ugi_args() noexcept;
  std::string user_name;
  std::vector<std::string>  group_names;

  _ThriftHiveMetastore_set_ugi_args__isset __isset;

  void __set_user_name(const std::string& val);

  void __set_group_names(const std::vector<std::string> & 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_set_ugi_result__isset;

class ThriftHiveMetastore_set_ugi_result {
 public:

  ThriftHiveMetastore_set_ugi_result(const ThriftHiveMetastore_set_ugi_result&);
  ThriftHiveMetastore_set_ugi_result& operator=(const ThriftHiveMetastore_set_ugi_result&);
  ThriftHiveMetastore_set_ugi_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_set_ugi_result() noexcept;
  std::vector<std::string>  success;
  MetaException o1;

  _ThriftHiveMetastore_set_ugi_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_set_ugi_presult__isset;

class ThriftHiveMetastore_set_ugi_presult {
 public:


  virtual ~ThriftHiveMetastore_set_ugi_presult() noexcept;
  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 :1;
  bool renewer_kerberos_principal_name :1;
} _ThriftHiveMetastore_get_delegation_token_args__isset;

class ThriftHiveMetastore_get_delegation_token_args {
 public:

  ThriftHiveMetastore_get_delegation_token_args(const ThriftHiveMetastore_get_delegation_token_args&);
  ThriftHiveMetastore_get_delegation_token_args& operator=(const ThriftHiveMetastore_get_delegation_token_args&);
  ThriftHiveMetastore_get_delegation_token_args() noexcept
                                                : token_owner(),
                                                  renewer_kerberos_principal_name() {
  }

  virtual ~ThriftHiveMetastore_get_delegation_token_args() noexcept;
  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);

  void __set_renewer_kerberos_principal_name(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_delegation_token_result__isset;

class ThriftHiveMetastore_get_delegation_token_result {
 public:

  ThriftHiveMetastore_get_delegation_token_result(const ThriftHiveMetastore_get_delegation_token_result&);
  ThriftHiveMetastore_get_delegation_token_result& operator=(const ThriftHiveMetastore_get_delegation_token_result&);
  ThriftHiveMetastore_get_delegation_token_result() noexcept
                                                  : success() {
  }

  virtual ~ThriftHiveMetastore_get_delegation_token_result() noexcept;
  std::string success;
  MetaException o1;

  _ThriftHiveMetastore_get_delegation_token_result__isset __isset;

  void __set_success(const std::string& val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_get_delegation_token_presult__isset;

class ThriftHiveMetastore_get_delegation_token_presult {
 public:


  virtual ~ThriftHiveMetastore_get_delegation_token_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_renew_delegation_token_args__isset;

class ThriftHiveMetastore_renew_delegation_token_args {
 public:

  ThriftHiveMetastore_renew_delegation_token_args(const ThriftHiveMetastore_renew_delegation_token_args&);
  ThriftHiveMetastore_renew_delegation_token_args& operator=(const ThriftHiveMetastore_renew_delegation_token_args&);
  ThriftHiveMetastore_renew_delegation_token_args() noexcept
                                                  : token_str_form() {
  }

  virtual ~ThriftHiveMetastore_renew_delegation_token_args() noexcept;
  std::string token_str_form;

  _ThriftHiveMetastore_renew_delegation_token_args__isset __isset;

  void __set_token_str_form(const std::string& 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() noexcept;
  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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_renew_delegation_token_result__isset;

class ThriftHiveMetastore_renew_delegation_token_result {
 public:

  ThriftHiveMetastore_renew_delegation_token_result(const ThriftHiveMetastore_renew_delegation_token_result&);
  ThriftHiveMetastore_renew_delegation_token_result& operator=(const ThriftHiveMetastore_renew_delegation_token_result&);
  ThriftHiveMetastore_renew_delegation_token_result() noexcept
                                                    : success(0) {
  }

  virtual ~ThriftHiveMetastore_renew_delegation_token_result() noexcept;
  int64_t success;
  MetaException o1;

  _ThriftHiveMetastore_renew_delegation_token_result__isset __isset;

  void __set_success(const int64_t val);

  void __set_o1(const MetaException& 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 :1;
  bool o1 :1;
} _ThriftHiveMetastore_renew_delegation_token_presult__isset;

class ThriftHiveMetastore_renew_delegation_token_presult {
 public:


  virtual ~ThriftHiveMetastore_renew_delegation_token_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_cancel_delegation_token_args__isset;

class ThriftHiveMetastore_cancel_delegation_token_args {
 public:

  ThriftHiveMetastore_cancel_delegation_token_args(const ThriftHiveMetastore_cancel_delegation_token_args&);
  ThriftHiveMetastore_cancel_delegation_token_args& operator=(const ThriftHiveMetastore_cancel_delegation_token_args&);
  ThriftHiveMetastore_cancel_delegation_token_args() noexcept
                                                   : token_str_form() {
  }

  virtual ~ThriftHiveMetastore_cancel_delegation_token_args() noexcept;
  std::string token_str_form;

  _ThriftHiveMetastore_cancel_delegation_token_args__isset __isset;

  void __set_token_str_form(const std::string& 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() noexcept;
  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 :1;
} _ThriftHiveMetastore_cancel_delegation_token_result__isset;

class ThriftHiveMetastore_cancel_delegation_token_result {
 public:

  ThriftHiveMetastore_cancel_delegation_token_result(const ThriftHiveMetastore_cancel_delegation_token_result&);
  ThriftHiveMetastore_cancel_delegation_token_result& operator=(const ThriftHiveMetastore_cancel_delegation_token_result&);
  ThriftHiveMetastore_cancel_delegation_token_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_cancel_delegation_token_result() noexcept;
  MetaException o1;

  _ThriftHiveMetastore_cancel_delegation_token_result__isset __isset;

  void __set_o1(const MetaException& 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 :1;
} _ThriftHiveMetastore_cancel_delegation_token_presult__isset;

class ThriftHiveMetastore_cancel_delegation_token_presult {
 public:


  virtual ~ThriftHiveMetastore_cancel_delegation_token_presult() noexcept;
  MetaException o1;

  _ThriftHiveMetastore_cancel_delegation_token_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_add_token_args__isset {
  _ThriftHiveMetastore_add_token_args__isset() : token_identifier(false), delegation_token(false) {}
  bool token_identifier :1;
  bool delegation_token :1;
} _ThriftHiveMetastore_add_token_args__isset;

class ThriftHiveMetastore_add_token_args {
 public:

  ThriftHiveMetastore_add_token_args(const ThriftHiveMetastore_add_token_args&);
  ThriftHiveMetastore_add_token_args& operator=(const ThriftHiveMetastore_add_token_args&);
  ThriftHiveMetastore_add_token_args() noexcept
                                     : token_identifier(),
                                       delegation_token() {
  }

  virtual ~ThriftHiveMetastore_add_token_args() noexcept;
  std::string token_identifier;
  std::string delegation_token;

  _ThriftHiveMetastore_add_token_args__isset __isset;

  void __set_token_identifier(const std::string& val);

  void __set_delegation_token(const std::string& val);

  bool operator == (const ThriftHiveMetastore_add_token_args & rhs) const
  {
    if (!(token_identifier == rhs.token_identifier))
      return false;
    if (!(delegation_token == rhs.delegation_token))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_add_token_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_add_token_args & ) const;

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

};


class ThriftHiveMetastore_add_token_pargs {
 public:


  virtual ~ThriftHiveMetastore_add_token_pargs() noexcept;
  const std::string* token_identifier;
  const std::string* delegation_token;

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

};

typedef struct _ThriftHiveMetastore_add_token_result__isset {
  _ThriftHiveMetastore_add_token_result__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_add_token_result__isset;

class ThriftHiveMetastore_add_token_result {
 public:

  ThriftHiveMetastore_add_token_result(const ThriftHiveMetastore_add_token_result&) noexcept;
  ThriftHiveMetastore_add_token_result& operator=(const ThriftHiveMetastore_add_token_result&) noexcept;
  ThriftHiveMetastore_add_token_result() noexcept
                                       : success(0) {
  }

  virtual ~ThriftHiveMetastore_add_token_result() noexcept;
  bool success;

  _ThriftHiveMetastore_add_token_result__isset __isset;

  void __set_success(const bool val);

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

  bool operator < (const ThriftHiveMetastore_add_token_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_add_token_presult__isset {
  _ThriftHiveMetastore_add_token_presult__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_add_token_presult__isset;

class ThriftHiveMetastore_add_token_presult {
 public:


  virtual ~ThriftHiveMetastore_add_token_presult() noexcept;
  bool* success;

  _ThriftHiveMetastore_add_token_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_remove_token_args__isset {
  _ThriftHiveMetastore_remove_token_args__isset() : token_identifier(false) {}
  bool token_identifier :1;
} _ThriftHiveMetastore_remove_token_args__isset;

class ThriftHiveMetastore_remove_token_args {
 public:

  ThriftHiveMetastore_remove_token_args(const ThriftHiveMetastore_remove_token_args&);
  ThriftHiveMetastore_remove_token_args& operator=(const ThriftHiveMetastore_remove_token_args&);
  ThriftHiveMetastore_remove_token_args() noexcept
                                        : token_identifier() {
  }

  virtual ~ThriftHiveMetastore_remove_token_args() noexcept;
  std::string token_identifier;

  _ThriftHiveMetastore_remove_token_args__isset __isset;

  void __set_token_identifier(const std::string& val);

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

  bool operator < (const ThriftHiveMetastore_remove_token_args & ) const;

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

};


class ThriftHiveMetastore_remove_token_pargs {
 public:


  virtual ~ThriftHiveMetastore_remove_token_pargs() noexcept;
  const std::string* token_identifier;

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

};

typedef struct _ThriftHiveMetastore_remove_token_result__isset {
  _ThriftHiveMetastore_remove_token_result__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_remove_token_result__isset;

class ThriftHiveMetastore_remove_token_result {
 public:

  ThriftHiveMetastore_remove_token_result(const ThriftHiveMetastore_remove_token_result&) noexcept;
  ThriftHiveMetastore_remove_token_result& operator=(const ThriftHiveMetastore_remove_token_result&) noexcept;
  ThriftHiveMetastore_remove_token_result() noexcept
                                          : success(0) {
  }

  virtual ~ThriftHiveMetastore_remove_token_result() noexcept;
  bool success;

  _ThriftHiveMetastore_remove_token_result__isset __isset;

  void __set_success(const bool val);

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

  bool operator < (const ThriftHiveMetastore_remove_token_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_remove_token_presult__isset {
  _ThriftHiveMetastore_remove_token_presult__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_remove_token_presult__isset;

class ThriftHiveMetastore_remove_token_presult {
 public:


  virtual ~ThriftHiveMetastore_remove_token_presult() noexcept;
  bool* success;

  _ThriftHiveMetastore_remove_token_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_token_args__isset {
  _ThriftHiveMetastore_get_token_args__isset() : token_identifier(false) {}
  bool token_identifier :1;
} _ThriftHiveMetastore_get_token_args__isset;

class ThriftHiveMetastore_get_token_args {
 public:

  ThriftHiveMetastore_get_token_args(const ThriftHiveMetastore_get_token_args&);
  ThriftHiveMetastore_get_token_args& operator=(const ThriftHiveMetastore_get_token_args&);
  ThriftHiveMetastore_get_token_args() noexcept
                                     : token_identifier() {
  }

  virtual ~ThriftHiveMetastore_get_token_args() noexcept;
  std::string token_identifier;

  _ThriftHiveMetastore_get_token_args__isset __isset;

  void __set_token_identifier(const std::string& val);

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

  bool operator < (const ThriftHiveMetastore_get_token_args & ) const;

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

};


class ThriftHiveMetastore_get_token_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_token_pargs() noexcept;
  const std::string* token_identifier;

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

};

typedef struct _ThriftHiveMetastore_get_token_result__isset {
  _ThriftHiveMetastore_get_token_result__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_get_token_result__isset;

class ThriftHiveMetastore_get_token_result {
 public:

  ThriftHiveMetastore_get_token_result(const ThriftHiveMetastore_get_token_result&);
  ThriftHiveMetastore_get_token_result& operator=(const ThriftHiveMetastore_get_token_result&);
  ThriftHiveMetastore_get_token_result() noexcept
                                       : success() {
  }

  virtual ~ThriftHiveMetastore_get_token_result() noexcept;
  std::string success;

  _ThriftHiveMetastore_get_token_result__isset __isset;

  void __set_success(const std::string& val);

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

  bool operator < (const ThriftHiveMetastore_get_token_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_get_token_presult__isset {
  _ThriftHiveMetastore_get_token_presult__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_get_token_presult__isset;

class ThriftHiveMetastore_get_token_presult {
 public:


  virtual ~ThriftHiveMetastore_get_token_presult() noexcept;
  std::string* success;

  _ThriftHiveMetastore_get_token_presult__isset __isset;

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

};


class ThriftHiveMetastore_get_all_token_identifiers_args {
 public:

  ThriftHiveMetastore_get_all_token_identifiers_args(const ThriftHiveMetastore_get_all_token_identifiers_args&) noexcept;
  ThriftHiveMetastore_get_all_token_identifiers_args& operator=(const ThriftHiveMetastore_get_all_token_identifiers_args&) noexcept;
  ThriftHiveMetastore_get_all_token_identifiers_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_all_token_identifiers_args() noexcept;

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

  bool operator < (const ThriftHiveMetastore_get_all_token_identifiers_args & ) const;

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

};


class ThriftHiveMetastore_get_all_token_identifiers_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_all_token_identifiers_pargs() noexcept;

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

};

typedef struct _ThriftHiveMetastore_get_all_token_identifiers_result__isset {
  _ThriftHiveMetastore_get_all_token_identifiers_result__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_get_all_token_identifiers_result__isset;

class ThriftHiveMetastore_get_all_token_identifiers_result {
 public:

  ThriftHiveMetastore_get_all_token_identifiers_result(const ThriftHiveMetastore_get_all_token_identifiers_result&);
  ThriftHiveMetastore_get_all_token_identifiers_result& operator=(const ThriftHiveMetastore_get_all_token_identifiers_result&);
  ThriftHiveMetastore_get_all_token_identifiers_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_all_token_identifiers_result() noexcept;
  std::vector<std::string>  success;

  _ThriftHiveMetastore_get_all_token_identifiers_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

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

  bool operator < (const ThriftHiveMetastore_get_all_token_identifiers_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_get_all_token_identifiers_presult__isset {
  _ThriftHiveMetastore_get_all_token_identifiers_presult__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_get_all_token_identifiers_presult__isset;

class ThriftHiveMetastore_get_all_token_identifiers_presult {
 public:


  virtual ~ThriftHiveMetastore_get_all_token_identifiers_presult() noexcept;
  std::vector<std::string> * success;

  _ThriftHiveMetastore_get_all_token_identifiers_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_add_master_key_args__isset {
  _ThriftHiveMetastore_add_master_key_args__isset() : key(false) {}
  bool key :1;
} _ThriftHiveMetastore_add_master_key_args__isset;

class ThriftHiveMetastore_add_master_key_args {
 public:

  ThriftHiveMetastore_add_master_key_args(const ThriftHiveMetastore_add_master_key_args&);
  ThriftHiveMetastore_add_master_key_args& operator=(const ThriftHiveMetastore_add_master_key_args&);
  ThriftHiveMetastore_add_master_key_args() noexcept
                                          : key() {
  }

  virtual ~ThriftHiveMetastore_add_master_key_args() noexcept;
  std::string key;

  _ThriftHiveMetastore_add_master_key_args__isset __isset;

  void __set_key(const std::string& val);

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

  bool operator < (const ThriftHiveMetastore_add_master_key_args & ) const;

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

};


class ThriftHiveMetastore_add_master_key_pargs {
 public:


  virtual ~ThriftHiveMetastore_add_master_key_pargs() noexcept;
  const std::string* key;

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

};

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

class ThriftHiveMetastore_add_master_key_result {
 public:

  ThriftHiveMetastore_add_master_key_result(const ThriftHiveMetastore_add_master_key_result&);
  ThriftHiveMetastore_add_master_key_result& operator=(const ThriftHiveMetastore_add_master_key_result&);
  ThriftHiveMetastore_add_master_key_result() noexcept
                                            : success(0) {
  }

  virtual ~ThriftHiveMetastore_add_master_key_result() noexcept;
  int32_t success;
  MetaException o1;

  _ThriftHiveMetastore_add_master_key_result__isset __isset;

  void __set_success(const int32_t val);

  void __set_o1(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_add_master_key_result & ) const;

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

};

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

class ThriftHiveMetastore_add_master_key_presult {
 public:


  virtual ~ThriftHiveMetastore_add_master_key_presult() noexcept;
  int32_t* success;
  MetaException o1;

  _ThriftHiveMetastore_add_master_key_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_update_master_key_args__isset {
  _ThriftHiveMetastore_update_master_key_args__isset() : seq_number(false), key(false) {}
  bool seq_number :1;
  bool key :1;
} _ThriftHiveMetastore_update_master_key_args__isset;

class ThriftHiveMetastore_update_master_key_args {
 public:

  ThriftHiveMetastore_update_master_key_args(const ThriftHiveMetastore_update_master_key_args&);
  ThriftHiveMetastore_update_master_key_args& operator=(const ThriftHiveMetastore_update_master_key_args&);
  ThriftHiveMetastore_update_master_key_args() noexcept
                                             : seq_number(0),
                                               key() {
  }

  virtual ~ThriftHiveMetastore_update_master_key_args() noexcept;
  int32_t seq_number;
  std::string key;

  _ThriftHiveMetastore_update_master_key_args__isset __isset;

  void __set_seq_number(const int32_t val);

  void __set_key(const std::string& val);

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

  bool operator < (const ThriftHiveMetastore_update_master_key_args & ) const;

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

};


class ThriftHiveMetastore_update_master_key_pargs {
 public:


  virtual ~ThriftHiveMetastore_update_master_key_pargs() noexcept;
  const int32_t* seq_number;
  const std::string* key;

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

};

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

class ThriftHiveMetastore_update_master_key_result {
 public:

  ThriftHiveMetastore_update_master_key_result(const ThriftHiveMetastore_update_master_key_result&);
  ThriftHiveMetastore_update_master_key_result& operator=(const ThriftHiveMetastore_update_master_key_result&);
  ThriftHiveMetastore_update_master_key_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_update_master_key_result() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_update_master_key_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_update_master_key_result & ) const;

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

};

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

class ThriftHiveMetastore_update_master_key_presult {
 public:


  virtual ~ThriftHiveMetastore_update_master_key_presult() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_update_master_key_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_remove_master_key_args__isset {
  _ThriftHiveMetastore_remove_master_key_args__isset() : key_seq(false) {}
  bool key_seq :1;
} _ThriftHiveMetastore_remove_master_key_args__isset;

class ThriftHiveMetastore_remove_master_key_args {
 public:

  ThriftHiveMetastore_remove_master_key_args(const ThriftHiveMetastore_remove_master_key_args&) noexcept;
  ThriftHiveMetastore_remove_master_key_args& operator=(const ThriftHiveMetastore_remove_master_key_args&) noexcept;
  ThriftHiveMetastore_remove_master_key_args() noexcept
                                             : key_seq(0) {
  }

  virtual ~ThriftHiveMetastore_remove_master_key_args() noexcept;
  int32_t key_seq;

  _ThriftHiveMetastore_remove_master_key_args__isset __isset;

  void __set_key_seq(const int32_t val);

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

  bool operator < (const ThriftHiveMetastore_remove_master_key_args & ) const;

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

};


class ThriftHiveMetastore_remove_master_key_pargs {
 public:


  virtual ~ThriftHiveMetastore_remove_master_key_pargs() noexcept;
  const int32_t* key_seq;

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

};

typedef struct _ThriftHiveMetastore_remove_master_key_result__isset {
  _ThriftHiveMetastore_remove_master_key_result__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_remove_master_key_result__isset;

class ThriftHiveMetastore_remove_master_key_result {
 public:

  ThriftHiveMetastore_remove_master_key_result(const ThriftHiveMetastore_remove_master_key_result&) noexcept;
  ThriftHiveMetastore_remove_master_key_result& operator=(const ThriftHiveMetastore_remove_master_key_result&) noexcept;
  ThriftHiveMetastore_remove_master_key_result() noexcept
                                               : success(0) {
  }

  virtual ~ThriftHiveMetastore_remove_master_key_result() noexcept;
  bool success;

  _ThriftHiveMetastore_remove_master_key_result__isset __isset;

  void __set_success(const bool val);

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

  bool operator < (const ThriftHiveMetastore_remove_master_key_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_remove_master_key_presult__isset {
  _ThriftHiveMetastore_remove_master_key_presult__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_remove_master_key_presult__isset;

class ThriftHiveMetastore_remove_master_key_presult {
 public:


  virtual ~ThriftHiveMetastore_remove_master_key_presult() noexcept;
  bool* success;

  _ThriftHiveMetastore_remove_master_key_presult__isset __isset;

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

};


class ThriftHiveMetastore_get_master_keys_args {
 public:

  ThriftHiveMetastore_get_master_keys_args(const ThriftHiveMetastore_get_master_keys_args&) noexcept;
  ThriftHiveMetastore_get_master_keys_args& operator=(const ThriftHiveMetastore_get_master_keys_args&) noexcept;
  ThriftHiveMetastore_get_master_keys_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_master_keys_args() noexcept;

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

  bool operator < (const ThriftHiveMetastore_get_master_keys_args & ) const;

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

};


class ThriftHiveMetastore_get_master_keys_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_master_keys_pargs() noexcept;

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

};

typedef struct _ThriftHiveMetastore_get_master_keys_result__isset {
  _ThriftHiveMetastore_get_master_keys_result__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_get_master_keys_result__isset;

class ThriftHiveMetastore_get_master_keys_result {
 public:

  ThriftHiveMetastore_get_master_keys_result(const ThriftHiveMetastore_get_master_keys_result&);
  ThriftHiveMetastore_get_master_keys_result& operator=(const ThriftHiveMetastore_get_master_keys_result&);
  ThriftHiveMetastore_get_master_keys_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_master_keys_result() noexcept;
  std::vector<std::string>  success;

  _ThriftHiveMetastore_get_master_keys_result__isset __isset;

  void __set_success(const std::vector<std::string> & val);

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

  bool operator < (const ThriftHiveMetastore_get_master_keys_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_get_master_keys_presult__isset {
  _ThriftHiveMetastore_get_master_keys_presult__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_get_master_keys_presult__isset;

class ThriftHiveMetastore_get_master_keys_presult {
 public:


  virtual ~ThriftHiveMetastore_get_master_keys_presult() noexcept;
  std::vector<std::string> * success;

  _ThriftHiveMetastore_get_master_keys_presult__isset __isset;

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

};


class ThriftHiveMetastore_get_open_txns_args {
 public:

  ThriftHiveMetastore_get_open_txns_args(const ThriftHiveMetastore_get_open_txns_args&) noexcept;
  ThriftHiveMetastore_get_open_txns_args& operator=(const ThriftHiveMetastore_get_open_txns_args&) noexcept;
  ThriftHiveMetastore_get_open_txns_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_open_txns_args() noexcept;

  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() noexcept;

  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 :1;
} _ThriftHiveMetastore_get_open_txns_result__isset;

class ThriftHiveMetastore_get_open_txns_result {
 public:

  ThriftHiveMetastore_get_open_txns_result(const ThriftHiveMetastore_get_open_txns_result&);
  ThriftHiveMetastore_get_open_txns_result& operator=(const ThriftHiveMetastore_get_open_txns_result&);
  ThriftHiveMetastore_get_open_txns_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_open_txns_result() noexcept;
  GetOpenTxnsResponse success;

  _ThriftHiveMetastore_get_open_txns_result__isset __isset;

  void __set_success(const GetOpenTxnsResponse& 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 :1;
} _ThriftHiveMetastore_get_open_txns_presult__isset;

class ThriftHiveMetastore_get_open_txns_presult {
 public:


  virtual ~ThriftHiveMetastore_get_open_txns_presult() noexcept;
  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(const ThriftHiveMetastore_get_open_txns_info_args&) noexcept;
  ThriftHiveMetastore_get_open_txns_info_args& operator=(const ThriftHiveMetastore_get_open_txns_info_args&) noexcept;
  ThriftHiveMetastore_get_open_txns_info_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_open_txns_info_args() noexcept;

  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() noexcept;

  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 :1;
} _ThriftHiveMetastore_get_open_txns_info_result__isset;

class ThriftHiveMetastore_get_open_txns_info_result {
 public:

  ThriftHiveMetastore_get_open_txns_info_result(const ThriftHiveMetastore_get_open_txns_info_result&);
  ThriftHiveMetastore_get_open_txns_info_result& operator=(const ThriftHiveMetastore_get_open_txns_info_result&);
  ThriftHiveMetastore_get_open_txns_info_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_open_txns_info_result() noexcept;
  GetOpenTxnsInfoResponse success;

  _ThriftHiveMetastore_get_open_txns_info_result__isset __isset;

  void __set_success(const GetOpenTxnsInfoResponse& 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 :1;
} _ThriftHiveMetastore_get_open_txns_info_presult__isset;

class ThriftHiveMetastore_get_open_txns_info_presult {
 public:


  virtual ~ThriftHiveMetastore_get_open_txns_info_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_open_txns_args__isset;

class ThriftHiveMetastore_open_txns_args {
 public:

  ThriftHiveMetastore_open_txns_args(const ThriftHiveMetastore_open_txns_args&);
  ThriftHiveMetastore_open_txns_args& operator=(const ThriftHiveMetastore_open_txns_args&);
  ThriftHiveMetastore_open_txns_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_open_txns_args() noexcept;
  OpenTxnRequest rqst;

  _ThriftHiveMetastore_open_txns_args__isset __isset;

  void __set_rqst(const OpenTxnRequest& 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() noexcept;
  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 :1;
} _ThriftHiveMetastore_open_txns_result__isset;

class ThriftHiveMetastore_open_txns_result {
 public:

  ThriftHiveMetastore_open_txns_result(const ThriftHiveMetastore_open_txns_result&);
  ThriftHiveMetastore_open_txns_result& operator=(const ThriftHiveMetastore_open_txns_result&);
  ThriftHiveMetastore_open_txns_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_open_txns_result() noexcept;
  OpenTxnsResponse success;

  _ThriftHiveMetastore_open_txns_result__isset __isset;

  void __set_success(const OpenTxnsResponse& 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 :1;
} _ThriftHiveMetastore_open_txns_presult__isset;

class ThriftHiveMetastore_open_txns_presult {
 public:


  virtual ~ThriftHiveMetastore_open_txns_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_abort_txn_args__isset;

class ThriftHiveMetastore_abort_txn_args {
 public:

  ThriftHiveMetastore_abort_txn_args(const ThriftHiveMetastore_abort_txn_args&);
  ThriftHiveMetastore_abort_txn_args& operator=(const ThriftHiveMetastore_abort_txn_args&);
  ThriftHiveMetastore_abort_txn_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_abort_txn_args() noexcept;
  AbortTxnRequest rqst;

  _ThriftHiveMetastore_abort_txn_args__isset __isset;

  void __set_rqst(const AbortTxnRequest& 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() noexcept;
  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 :1;
} _ThriftHiveMetastore_abort_txn_result__isset;

class ThriftHiveMetastore_abort_txn_result {
 public:

  ThriftHiveMetastore_abort_txn_result(const ThriftHiveMetastore_abort_txn_result&);
  ThriftHiveMetastore_abort_txn_result& operator=(const ThriftHiveMetastore_abort_txn_result&);
  ThriftHiveMetastore_abort_txn_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_abort_txn_result() noexcept;
  NoSuchTxnException o1;

  _ThriftHiveMetastore_abort_txn_result__isset __isset;

  void __set_o1(const NoSuchTxnException& 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 :1;
} _ThriftHiveMetastore_abort_txn_presult__isset;

class ThriftHiveMetastore_abort_txn_presult {
 public:


  virtual ~ThriftHiveMetastore_abort_txn_presult() noexcept;
  NoSuchTxnException o1;

  _ThriftHiveMetastore_abort_txn_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_abort_txns_args__isset {
  _ThriftHiveMetastore_abort_txns_args__isset() : rqst(false) {}
  bool rqst :1;
} _ThriftHiveMetastore_abort_txns_args__isset;

class ThriftHiveMetastore_abort_txns_args {
 public:

  ThriftHiveMetastore_abort_txns_args(const ThriftHiveMetastore_abort_txns_args&);
  ThriftHiveMetastore_abort_txns_args& operator=(const ThriftHiveMetastore_abort_txns_args&);
  ThriftHiveMetastore_abort_txns_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_abort_txns_args() noexcept;
  AbortTxnsRequest rqst;

  _ThriftHiveMetastore_abort_txns_args__isset __isset;

  void __set_rqst(const AbortTxnsRequest& val);

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

  bool operator < (const ThriftHiveMetastore_abort_txns_args & ) const;

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

};


class ThriftHiveMetastore_abort_txns_pargs {
 public:


  virtual ~ThriftHiveMetastore_abort_txns_pargs() noexcept;
  const AbortTxnsRequest* rqst;

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

};

typedef struct _ThriftHiveMetastore_abort_txns_result__isset {
  _ThriftHiveMetastore_abort_txns_result__isset() : o1(false) {}
  bool o1 :1;
} _ThriftHiveMetastore_abort_txns_result__isset;

class ThriftHiveMetastore_abort_txns_result {
 public:

  ThriftHiveMetastore_abort_txns_result(const ThriftHiveMetastore_abort_txns_result&);
  ThriftHiveMetastore_abort_txns_result& operator=(const ThriftHiveMetastore_abort_txns_result&);
  ThriftHiveMetastore_abort_txns_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_abort_txns_result() noexcept;
  NoSuchTxnException o1;

  _ThriftHiveMetastore_abort_txns_result__isset __isset;

  void __set_o1(const NoSuchTxnException& val);

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

  bool operator < (const ThriftHiveMetastore_abort_txns_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_abort_txns_presult__isset {
  _ThriftHiveMetastore_abort_txns_presult__isset() : o1(false) {}
  bool o1 :1;
} _ThriftHiveMetastore_abort_txns_presult__isset;

class ThriftHiveMetastore_abort_txns_presult {
 public:


  virtual ~ThriftHiveMetastore_abort_txns_presult() noexcept;
  NoSuchTxnException o1;

  _ThriftHiveMetastore_abort_txns_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 :1;
} _ThriftHiveMetastore_commit_txn_args__isset;

class ThriftHiveMetastore_commit_txn_args {
 public:

  ThriftHiveMetastore_commit_txn_args(const ThriftHiveMetastore_commit_txn_args&);
  ThriftHiveMetastore_commit_txn_args& operator=(const ThriftHiveMetastore_commit_txn_args&);
  ThriftHiveMetastore_commit_txn_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_commit_txn_args() noexcept;
  CommitTxnRequest rqst;

  _ThriftHiveMetastore_commit_txn_args__isset __isset;

  void __set_rqst(const CommitTxnRequest& 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() noexcept;
  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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_commit_txn_result__isset;

class ThriftHiveMetastore_commit_txn_result {
 public:

  ThriftHiveMetastore_commit_txn_result(const ThriftHiveMetastore_commit_txn_result&);
  ThriftHiveMetastore_commit_txn_result& operator=(const ThriftHiveMetastore_commit_txn_result&);
  ThriftHiveMetastore_commit_txn_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_commit_txn_result() noexcept;
  NoSuchTxnException o1;
  TxnAbortedException o2;

  _ThriftHiveMetastore_commit_txn_result__isset __isset;

  void __set_o1(const NoSuchTxnException& val);

  void __set_o2(const TxnAbortedException& 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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_commit_txn_presult__isset;

class ThriftHiveMetastore_commit_txn_presult {
 public:


  virtual ~ThriftHiveMetastore_commit_txn_presult() noexcept;
  NoSuchTxnException o1;
  TxnAbortedException o2;

  _ThriftHiveMetastore_commit_txn_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_repl_tbl_writeid_state_args__isset {
  _ThriftHiveMetastore_repl_tbl_writeid_state_args__isset() : rqst(false) {}
  bool rqst :1;
} _ThriftHiveMetastore_repl_tbl_writeid_state_args__isset;

class ThriftHiveMetastore_repl_tbl_writeid_state_args {
 public:

  ThriftHiveMetastore_repl_tbl_writeid_state_args(const ThriftHiveMetastore_repl_tbl_writeid_state_args&);
  ThriftHiveMetastore_repl_tbl_writeid_state_args& operator=(const ThriftHiveMetastore_repl_tbl_writeid_state_args&);
  ThriftHiveMetastore_repl_tbl_writeid_state_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_repl_tbl_writeid_state_args() noexcept;
  ReplTblWriteIdStateRequest rqst;

  _ThriftHiveMetastore_repl_tbl_writeid_state_args__isset __isset;

  void __set_rqst(const ReplTblWriteIdStateRequest& val);

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

  bool operator < (const ThriftHiveMetastore_repl_tbl_writeid_state_args & ) const;

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

};


class ThriftHiveMetastore_repl_tbl_writeid_state_pargs {
 public:


  virtual ~ThriftHiveMetastore_repl_tbl_writeid_state_pargs() noexcept;
  const ReplTblWriteIdStateRequest* rqst;

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

};


class ThriftHiveMetastore_repl_tbl_writeid_state_result {
 public:

  ThriftHiveMetastore_repl_tbl_writeid_state_result(const ThriftHiveMetastore_repl_tbl_writeid_state_result&) noexcept;
  ThriftHiveMetastore_repl_tbl_writeid_state_result& operator=(const ThriftHiveMetastore_repl_tbl_writeid_state_result&) noexcept;
  ThriftHiveMetastore_repl_tbl_writeid_state_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_repl_tbl_writeid_state_result() noexcept;

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

  bool operator < (const ThriftHiveMetastore_repl_tbl_writeid_state_result & ) const;

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

};


class ThriftHiveMetastore_repl_tbl_writeid_state_presult {
 public:


  virtual ~ThriftHiveMetastore_repl_tbl_writeid_state_presult() noexcept;

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

};

typedef struct _ThriftHiveMetastore_get_valid_write_ids_args__isset {
  _ThriftHiveMetastore_get_valid_write_ids_args__isset() : rqst(false) {}
  bool rqst :1;
} _ThriftHiveMetastore_get_valid_write_ids_args__isset;

class ThriftHiveMetastore_get_valid_write_ids_args {
 public:

  ThriftHiveMetastore_get_valid_write_ids_args(const ThriftHiveMetastore_get_valid_write_ids_args&);
  ThriftHiveMetastore_get_valid_write_ids_args& operator=(const ThriftHiveMetastore_get_valid_write_ids_args&);
  ThriftHiveMetastore_get_valid_write_ids_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_valid_write_ids_args() noexcept;
  GetValidWriteIdsRequest rqst;

  _ThriftHiveMetastore_get_valid_write_ids_args__isset __isset;

  void __set_rqst(const GetValidWriteIdsRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_valid_write_ids_args & ) const;

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

};


class ThriftHiveMetastore_get_valid_write_ids_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_valid_write_ids_pargs() noexcept;
  const GetValidWriteIdsRequest* rqst;

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

};

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

class ThriftHiveMetastore_get_valid_write_ids_result {
 public:

  ThriftHiveMetastore_get_valid_write_ids_result(const ThriftHiveMetastore_get_valid_write_ids_result&);
  ThriftHiveMetastore_get_valid_write_ids_result& operator=(const ThriftHiveMetastore_get_valid_write_ids_result&);
  ThriftHiveMetastore_get_valid_write_ids_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_valid_write_ids_result() noexcept;
  GetValidWriteIdsResponse success;
  NoSuchTxnException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_valid_write_ids_result__isset __isset;

  void __set_success(const GetValidWriteIdsResponse& val);

  void __set_o1(const NoSuchTxnException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_valid_write_ids_result & ) const;

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

};

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

class ThriftHiveMetastore_get_valid_write_ids_presult {
 public:


  virtual ~ThriftHiveMetastore_get_valid_write_ids_presult() noexcept;
  GetValidWriteIdsResponse* success;
  NoSuchTxnException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_valid_write_ids_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_allocate_table_write_ids_args__isset {
  _ThriftHiveMetastore_allocate_table_write_ids_args__isset() : rqst(false) {}
  bool rqst :1;
} _ThriftHiveMetastore_allocate_table_write_ids_args__isset;

class ThriftHiveMetastore_allocate_table_write_ids_args {
 public:

  ThriftHiveMetastore_allocate_table_write_ids_args(const ThriftHiveMetastore_allocate_table_write_ids_args&);
  ThriftHiveMetastore_allocate_table_write_ids_args& operator=(const ThriftHiveMetastore_allocate_table_write_ids_args&);
  ThriftHiveMetastore_allocate_table_write_ids_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_allocate_table_write_ids_args() noexcept;
  AllocateTableWriteIdsRequest rqst;

  _ThriftHiveMetastore_allocate_table_write_ids_args__isset __isset;

  void __set_rqst(const AllocateTableWriteIdsRequest& val);

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

  bool operator < (const ThriftHiveMetastore_allocate_table_write_ids_args & ) const;

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

};


class ThriftHiveMetastore_allocate_table_write_ids_pargs {
 public:


  virtual ~ThriftHiveMetastore_allocate_table_write_ids_pargs() noexcept;
  const AllocateTableWriteIdsRequest* rqst;

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

};

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

class ThriftHiveMetastore_allocate_table_write_ids_result {
 public:

  ThriftHiveMetastore_allocate_table_write_ids_result(const ThriftHiveMetastore_allocate_table_write_ids_result&);
  ThriftHiveMetastore_allocate_table_write_ids_result& operator=(const ThriftHiveMetastore_allocate_table_write_ids_result&);
  ThriftHiveMetastore_allocate_table_write_ids_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_allocate_table_write_ids_result() noexcept;
  AllocateTableWriteIdsResponse success;
  NoSuchTxnException o1;
  TxnAbortedException o2;
  MetaException o3;

  _ThriftHiveMetastore_allocate_table_write_ids_result__isset __isset;

  void __set_success(const AllocateTableWriteIdsResponse& val);

  void __set_o1(const NoSuchTxnException& val);

  void __set_o2(const TxnAbortedException& val);

  void __set_o3(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_allocate_table_write_ids_result & ) const;

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

};

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

class ThriftHiveMetastore_allocate_table_write_ids_presult {
 public:


  virtual ~ThriftHiveMetastore_allocate_table_write_ids_presult() noexcept;
  AllocateTableWriteIdsResponse* success;
  NoSuchTxnException o1;
  TxnAbortedException o2;
  MetaException o3;

  _ThriftHiveMetastore_allocate_table_write_ids_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 :1;
} _ThriftHiveMetastore_lock_args__isset;

class ThriftHiveMetastore_lock_args {
 public:

  ThriftHiveMetastore_lock_args(const ThriftHiveMetastore_lock_args&);
  ThriftHiveMetastore_lock_args& operator=(const ThriftHiveMetastore_lock_args&);
  ThriftHiveMetastore_lock_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_lock_args() noexcept;
  LockRequest rqst;

  _ThriftHiveMetastore_lock_args__isset __isset;

  void __set_rqst(const LockRequest& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_lock_result__isset;

class ThriftHiveMetastore_lock_result {
 public:

  ThriftHiveMetastore_lock_result(const ThriftHiveMetastore_lock_result&);
  ThriftHiveMetastore_lock_result& operator=(const ThriftHiveMetastore_lock_result&);
  ThriftHiveMetastore_lock_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_lock_result() noexcept;
  LockResponse success;
  NoSuchTxnException o1;
  TxnAbortedException o2;

  _ThriftHiveMetastore_lock_result__isset __isset;

  void __set_success(const LockResponse& val);

  void __set_o1(const NoSuchTxnException& val);

  void __set_o2(const TxnAbortedException& 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 :1;
  bool o1 :1;
  bool o2 :1;
} _ThriftHiveMetastore_lock_presult__isset;

class ThriftHiveMetastore_lock_presult {
 public:


  virtual ~ThriftHiveMetastore_lock_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_check_lock_args__isset;

class ThriftHiveMetastore_check_lock_args {
 public:

  ThriftHiveMetastore_check_lock_args(const ThriftHiveMetastore_check_lock_args&) noexcept;
  ThriftHiveMetastore_check_lock_args& operator=(const ThriftHiveMetastore_check_lock_args&) noexcept;
  ThriftHiveMetastore_check_lock_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_check_lock_args() noexcept;
  CheckLockRequest rqst;

  _ThriftHiveMetastore_check_lock_args__isset __isset;

  void __set_rqst(const CheckLockRequest& 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() noexcept;
  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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_check_lock_result__isset;

class ThriftHiveMetastore_check_lock_result {
 public:

  ThriftHiveMetastore_check_lock_result(const ThriftHiveMetastore_check_lock_result&);
  ThriftHiveMetastore_check_lock_result& operator=(const ThriftHiveMetastore_check_lock_result&);
  ThriftHiveMetastore_check_lock_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_check_lock_result() noexcept;
  LockResponse success;
  NoSuchTxnException o1;
  TxnAbortedException o2;
  NoSuchLockException o3;

  _ThriftHiveMetastore_check_lock_result__isset __isset;

  void __set_success(const LockResponse& val);

  void __set_o1(const NoSuchTxnException& val);

  void __set_o2(const TxnAbortedException& val);

  void __set_o3(const NoSuchLockException& 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 :1;
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_check_lock_presult__isset;

class ThriftHiveMetastore_check_lock_presult {
 public:


  virtual ~ThriftHiveMetastore_check_lock_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_unlock_args__isset;

class ThriftHiveMetastore_unlock_args {
 public:

  ThriftHiveMetastore_unlock_args(const ThriftHiveMetastore_unlock_args&) noexcept;
  ThriftHiveMetastore_unlock_args& operator=(const ThriftHiveMetastore_unlock_args&) noexcept;
  ThriftHiveMetastore_unlock_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_unlock_args() noexcept;
  UnlockRequest rqst;

  _ThriftHiveMetastore_unlock_args__isset __isset;

  void __set_rqst(const UnlockRequest& 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() noexcept;
  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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_unlock_result__isset;

class ThriftHiveMetastore_unlock_result {
 public:

  ThriftHiveMetastore_unlock_result(const ThriftHiveMetastore_unlock_result&);
  ThriftHiveMetastore_unlock_result& operator=(const ThriftHiveMetastore_unlock_result&);
  ThriftHiveMetastore_unlock_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_unlock_result() noexcept;
  NoSuchLockException o1;
  TxnOpenException o2;

  _ThriftHiveMetastore_unlock_result__isset __isset;

  void __set_o1(const NoSuchLockException& val);

  void __set_o2(const TxnOpenException& 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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_unlock_presult__isset;

class ThriftHiveMetastore_unlock_presult {
 public:


  virtual ~ThriftHiveMetastore_unlock_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_show_locks_args__isset;

class ThriftHiveMetastore_show_locks_args {
 public:

  ThriftHiveMetastore_show_locks_args(const ThriftHiveMetastore_show_locks_args&);
  ThriftHiveMetastore_show_locks_args& operator=(const ThriftHiveMetastore_show_locks_args&);
  ThriftHiveMetastore_show_locks_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_show_locks_args() noexcept;
  ShowLocksRequest rqst;

  _ThriftHiveMetastore_show_locks_args__isset __isset;

  void __set_rqst(const ShowLocksRequest& 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() noexcept;
  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 :1;
} _ThriftHiveMetastore_show_locks_result__isset;

class ThriftHiveMetastore_show_locks_result {
 public:

  ThriftHiveMetastore_show_locks_result(const ThriftHiveMetastore_show_locks_result&);
  ThriftHiveMetastore_show_locks_result& operator=(const ThriftHiveMetastore_show_locks_result&);
  ThriftHiveMetastore_show_locks_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_show_locks_result() noexcept;
  ShowLocksResponse success;

  _ThriftHiveMetastore_show_locks_result__isset __isset;

  void __set_success(const ShowLocksResponse& 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 :1;
} _ThriftHiveMetastore_show_locks_presult__isset;

class ThriftHiveMetastore_show_locks_presult {
 public:


  virtual ~ThriftHiveMetastore_show_locks_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_heartbeat_args__isset;

class ThriftHiveMetastore_heartbeat_args {
 public:

  ThriftHiveMetastore_heartbeat_args(const ThriftHiveMetastore_heartbeat_args&) noexcept;
  ThriftHiveMetastore_heartbeat_args& operator=(const ThriftHiveMetastore_heartbeat_args&) noexcept;
  ThriftHiveMetastore_heartbeat_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_heartbeat_args() noexcept;
  HeartbeatRequest ids;

  _ThriftHiveMetastore_heartbeat_args__isset __isset;

  void __set_ids(const HeartbeatRequest& 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() noexcept;
  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 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_heartbeat_result__isset;

class ThriftHiveMetastore_heartbeat_result {
 public:

  ThriftHiveMetastore_heartbeat_result(const ThriftHiveMetastore_heartbeat_result&);
  ThriftHiveMetastore_heartbeat_result& operator=(const ThriftHiveMetastore_heartbeat_result&);
  ThriftHiveMetastore_heartbeat_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_heartbeat_result() noexcept;
  NoSuchLockException o1;
  NoSuchTxnException o2;
  TxnAbortedException o3;

  _ThriftHiveMetastore_heartbeat_result__isset __isset;

  void __set_o1(const NoSuchLockException& val);

  void __set_o2(const NoSuchTxnException& val);

  void __set_o3(const TxnAbortedException& 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 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_heartbeat_presult__isset;

class ThriftHiveMetastore_heartbeat_presult {
 public:


  virtual ~ThriftHiveMetastore_heartbeat_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_heartbeat_txn_range_args__isset;

class ThriftHiveMetastore_heartbeat_txn_range_args {
 public:

  ThriftHiveMetastore_heartbeat_txn_range_args(const ThriftHiveMetastore_heartbeat_txn_range_args&) noexcept;
  ThriftHiveMetastore_heartbeat_txn_range_args& operator=(const ThriftHiveMetastore_heartbeat_txn_range_args&) noexcept;
  ThriftHiveMetastore_heartbeat_txn_range_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_heartbeat_txn_range_args() noexcept;
  HeartbeatTxnRangeRequest txns;

  _ThriftHiveMetastore_heartbeat_txn_range_args__isset __isset;

  void __set_txns(const HeartbeatTxnRangeRequest& 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() noexcept;
  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 :1;
} _ThriftHiveMetastore_heartbeat_txn_range_result__isset;

class ThriftHiveMetastore_heartbeat_txn_range_result {
 public:

  ThriftHiveMetastore_heartbeat_txn_range_result(const ThriftHiveMetastore_heartbeat_txn_range_result&);
  ThriftHiveMetastore_heartbeat_txn_range_result& operator=(const ThriftHiveMetastore_heartbeat_txn_range_result&);
  ThriftHiveMetastore_heartbeat_txn_range_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_heartbeat_txn_range_result() noexcept;
  HeartbeatTxnRangeResponse success;

  _ThriftHiveMetastore_heartbeat_txn_range_result__isset __isset;

  void __set_success(const HeartbeatTxnRangeResponse& 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 :1;
} _ThriftHiveMetastore_heartbeat_txn_range_presult__isset;

class ThriftHiveMetastore_heartbeat_txn_range_presult {
 public:


  virtual ~ThriftHiveMetastore_heartbeat_txn_range_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_compact_args__isset;

class ThriftHiveMetastore_compact_args {
 public:

  ThriftHiveMetastore_compact_args(const ThriftHiveMetastore_compact_args&);
  ThriftHiveMetastore_compact_args& operator=(const ThriftHiveMetastore_compact_args&);
  ThriftHiveMetastore_compact_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_compact_args() noexcept;
  CompactionRequest rqst;

  _ThriftHiveMetastore_compact_args__isset __isset;

  void __set_rqst(const CompactionRequest& 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() noexcept;
  const CompactionRequest* rqst;

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

};


class ThriftHiveMetastore_compact_result {
 public:

  ThriftHiveMetastore_compact_result(const ThriftHiveMetastore_compact_result&) noexcept;
  ThriftHiveMetastore_compact_result& operator=(const ThriftHiveMetastore_compact_result&) noexcept;
  ThriftHiveMetastore_compact_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_compact_result() noexcept;

  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() noexcept;

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

};

typedef struct _ThriftHiveMetastore_compact2_args__isset {
  _ThriftHiveMetastore_compact2_args__isset() : rqst(false) {}
  bool rqst :1;
} _ThriftHiveMetastore_compact2_args__isset;

class ThriftHiveMetastore_compact2_args {
 public:

  ThriftHiveMetastore_compact2_args(const ThriftHiveMetastore_compact2_args&);
  ThriftHiveMetastore_compact2_args& operator=(const ThriftHiveMetastore_compact2_args&);
  ThriftHiveMetastore_compact2_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_compact2_args() noexcept;
  CompactionRequest rqst;

  _ThriftHiveMetastore_compact2_args__isset __isset;

  void __set_rqst(const CompactionRequest& val);

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

  bool operator < (const ThriftHiveMetastore_compact2_args & ) const;

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

};


class ThriftHiveMetastore_compact2_pargs {
 public:


  virtual ~ThriftHiveMetastore_compact2_pargs() noexcept;
  const CompactionRequest* rqst;

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

};

typedef struct _ThriftHiveMetastore_compact2_result__isset {
  _ThriftHiveMetastore_compact2_result__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_compact2_result__isset;

class ThriftHiveMetastore_compact2_result {
 public:

  ThriftHiveMetastore_compact2_result(const ThriftHiveMetastore_compact2_result&);
  ThriftHiveMetastore_compact2_result& operator=(const ThriftHiveMetastore_compact2_result&);
  ThriftHiveMetastore_compact2_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_compact2_result() noexcept;
  CompactionResponse success;

  _ThriftHiveMetastore_compact2_result__isset __isset;

  void __set_success(const CompactionResponse& val);

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

  bool operator < (const ThriftHiveMetastore_compact2_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_compact2_presult__isset {
  _ThriftHiveMetastore_compact2_presult__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_compact2_presult__isset;

class ThriftHiveMetastore_compact2_presult {
 public:


  virtual ~ThriftHiveMetastore_compact2_presult() noexcept;
  CompactionResponse* success;

  _ThriftHiveMetastore_compact2_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_show_compact_args__isset {
  _ThriftHiveMetastore_show_compact_args__isset() : rqst(false) {}
  bool rqst :1;
} _ThriftHiveMetastore_show_compact_args__isset;

class ThriftHiveMetastore_show_compact_args {
 public:

  ThriftHiveMetastore_show_compact_args(const ThriftHiveMetastore_show_compact_args&) noexcept;
  ThriftHiveMetastore_show_compact_args& operator=(const ThriftHiveMetastore_show_compact_args&) noexcept;
  ThriftHiveMetastore_show_compact_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_show_compact_args() noexcept;
  ShowCompactRequest rqst;

  _ThriftHiveMetastore_show_compact_args__isset __isset;

  void __set_rqst(const ShowCompactRequest& 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() noexcept;
  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 :1;
} _ThriftHiveMetastore_show_compact_result__isset;

class ThriftHiveMetastore_show_compact_result {
 public:

  ThriftHiveMetastore_show_compact_result(const ThriftHiveMetastore_show_compact_result&);
  ThriftHiveMetastore_show_compact_result& operator=(const ThriftHiveMetastore_show_compact_result&);
  ThriftHiveMetastore_show_compact_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_show_compact_result() noexcept;
  ShowCompactResponse success;

  _ThriftHiveMetastore_show_compact_result__isset __isset;

  void __set_success(const ShowCompactResponse& 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 :1;
} _ThriftHiveMetastore_show_compact_presult__isset;

class ThriftHiveMetastore_show_compact_presult {
 public:


  virtual ~ThriftHiveMetastore_show_compact_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_add_dynamic_partitions_args__isset;

class ThriftHiveMetastore_add_dynamic_partitions_args {
 public:

  ThriftHiveMetastore_add_dynamic_partitions_args(const ThriftHiveMetastore_add_dynamic_partitions_args&);
  ThriftHiveMetastore_add_dynamic_partitions_args& operator=(const ThriftHiveMetastore_add_dynamic_partitions_args&);
  ThriftHiveMetastore_add_dynamic_partitions_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_dynamic_partitions_args() noexcept;
  AddDynamicPartitions rqst;

  _ThriftHiveMetastore_add_dynamic_partitions_args__isset __isset;

  void __set_rqst(const AddDynamicPartitions& 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() noexcept;
  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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_add_dynamic_partitions_result__isset;

class ThriftHiveMetastore_add_dynamic_partitions_result {
 public:

  ThriftHiveMetastore_add_dynamic_partitions_result(const ThriftHiveMetastore_add_dynamic_partitions_result&);
  ThriftHiveMetastore_add_dynamic_partitions_result& operator=(const ThriftHiveMetastore_add_dynamic_partitions_result&);
  ThriftHiveMetastore_add_dynamic_partitions_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_dynamic_partitions_result() noexcept;
  NoSuchTxnException o1;
  TxnAbortedException o2;

  _ThriftHiveMetastore_add_dynamic_partitions_result__isset __isset;

  void __set_o1(const NoSuchTxnException& val);

  void __set_o2(const TxnAbortedException& 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 :1;
  bool o2 :1;
} _ThriftHiveMetastore_add_dynamic_partitions_presult__isset;

class ThriftHiveMetastore_add_dynamic_partitions_presult {
 public:


  virtual ~ThriftHiveMetastore_add_dynamic_partitions_presult() noexcept;
  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 :1;
} _ThriftHiveMetastore_get_next_notification_args__isset;

class ThriftHiveMetastore_get_next_notification_args {
 public:

  ThriftHiveMetastore_get_next_notification_args(const ThriftHiveMetastore_get_next_notification_args&) noexcept;
  ThriftHiveMetastore_get_next_notification_args& operator=(const ThriftHiveMetastore_get_next_notification_args&) noexcept;
  ThriftHiveMetastore_get_next_notification_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_next_notification_args() noexcept;
  NotificationEventRequest rqst;

  _ThriftHiveMetastore_get_next_notification_args__isset __isset;

  void __set_rqst(const NotificationEventRequest& 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() noexcept;
  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 :1;
} _ThriftHiveMetastore_get_next_notification_result__isset;

class ThriftHiveMetastore_get_next_notification_result {
 public:

  ThriftHiveMetastore_get_next_notification_result(const ThriftHiveMetastore_get_next_notification_result&);
  ThriftHiveMetastore_get_next_notification_result& operator=(const ThriftHiveMetastore_get_next_notification_result&);
  ThriftHiveMetastore_get_next_notification_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_next_notification_result() noexcept;
  NotificationEventResponse success;

  _ThriftHiveMetastore_get_next_notification_result__isset __isset;

  void __set_success(const NotificationEventResponse& 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 :1;
} _ThriftHiveMetastore_get_next_notification_presult__isset;

class ThriftHiveMetastore_get_next_notification_presult {
 public:


  virtual ~ThriftHiveMetastore_get_next_notification_presult() noexcept;
  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(const ThriftHiveMetastore_get_current_notificationEventId_args&) noexcept;
  ThriftHiveMetastore_get_current_notificationEventId_args& operator=(const ThriftHiveMetastore_get_current_notificationEventId_args&) noexcept;
  ThriftHiveMetastore_get_current_notificationEventId_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_current_notificationEventId_args() noexcept;

  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() noexcept;

  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 :1;
} _ThriftHiveMetastore_get_current_notificationEventId_result__isset;

class ThriftHiveMetastore_get_current_notificationEventId_result {
 public:

  ThriftHiveMetastore_get_current_notificationEventId_result(const ThriftHiveMetastore_get_current_notificationEventId_result&) noexcept;
  ThriftHiveMetastore_get_current_notificationEventId_result& operator=(const ThriftHiveMetastore_get_current_notificationEventId_result&) noexcept;
  ThriftHiveMetastore_get_current_notificationEventId_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_current_notificationEventId_result() noexcept;
  CurrentNotificationEventId success;

  _ThriftHiveMetastore_get_current_notificationEventId_result__isset __isset;

  void __set_success(const CurrentNotificationEventId& 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 :1;
} _ThriftHiveMetastore_get_current_notificationEventId_presult__isset;

class ThriftHiveMetastore_get_current_notificationEventId_presult {
 public:


  virtual ~ThriftHiveMetastore_get_current_notificationEventId_presult() noexcept;
  CurrentNotificationEventId* success;

  _ThriftHiveMetastore_get_current_notificationEventId_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_notification_events_count_args__isset {
  _ThriftHiveMetastore_get_notification_events_count_args__isset() : rqst(false) {}
  bool rqst :1;
} _ThriftHiveMetastore_get_notification_events_count_args__isset;

class ThriftHiveMetastore_get_notification_events_count_args {
 public:

  ThriftHiveMetastore_get_notification_events_count_args(const ThriftHiveMetastore_get_notification_events_count_args&);
  ThriftHiveMetastore_get_notification_events_count_args& operator=(const ThriftHiveMetastore_get_notification_events_count_args&);
  ThriftHiveMetastore_get_notification_events_count_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_notification_events_count_args() noexcept;
  NotificationEventsCountRequest rqst;

  _ThriftHiveMetastore_get_notification_events_count_args__isset __isset;

  void __set_rqst(const NotificationEventsCountRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_notification_events_count_args & ) const;

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

};


class ThriftHiveMetastore_get_notification_events_count_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_notification_events_count_pargs() noexcept;
  const NotificationEventsCountRequest* rqst;

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

};

typedef struct _ThriftHiveMetastore_get_notification_events_count_result__isset {
  _ThriftHiveMetastore_get_notification_events_count_result__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_get_notification_events_count_result__isset;

class ThriftHiveMetastore_get_notification_events_count_result {
 public:

  ThriftHiveMetastore_get_notification_events_count_result(const ThriftHiveMetastore_get_notification_events_count_result&) noexcept;
  ThriftHiveMetastore_get_notification_events_count_result& operator=(const ThriftHiveMetastore_get_notification_events_count_result&) noexcept;
  ThriftHiveMetastore_get_notification_events_count_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_notification_events_count_result() noexcept;
  NotificationEventsCountResponse success;

  _ThriftHiveMetastore_get_notification_events_count_result__isset __isset;

  void __set_success(const NotificationEventsCountResponse& val);

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

  bool operator < (const ThriftHiveMetastore_get_notification_events_count_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_get_notification_events_count_presult__isset {
  _ThriftHiveMetastore_get_notification_events_count_presult__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_get_notification_events_count_presult__isset;

class ThriftHiveMetastore_get_notification_events_count_presult {
 public:


  virtual ~ThriftHiveMetastore_get_notification_events_count_presult() noexcept;
  NotificationEventsCountResponse* success;

  _ThriftHiveMetastore_get_notification_events_count_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 :1;
} _ThriftHiveMetastore_fire_listener_event_args__isset;

class ThriftHiveMetastore_fire_listener_event_args {
 public:

  ThriftHiveMetastore_fire_listener_event_args(const ThriftHiveMetastore_fire_listener_event_args&);
  ThriftHiveMetastore_fire_listener_event_args& operator=(const ThriftHiveMetastore_fire_listener_event_args&);
  ThriftHiveMetastore_fire_listener_event_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_fire_listener_event_args() noexcept;
  FireEventRequest rqst;

  _ThriftHiveMetastore_fire_listener_event_args__isset __isset;

  void __set_rqst(const FireEventRequest& 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() noexcept;
  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 :1;
} _ThriftHiveMetastore_fire_listener_event_result__isset;

class ThriftHiveMetastore_fire_listener_event_result {
 public:

  ThriftHiveMetastore_fire_listener_event_result(const ThriftHiveMetastore_fire_listener_event_result&) noexcept;
  ThriftHiveMetastore_fire_listener_event_result& operator=(const ThriftHiveMetastore_fire_listener_event_result&) noexcept;
  ThriftHiveMetastore_fire_listener_event_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_fire_listener_event_result() noexcept;
  FireEventResponse success;

  _ThriftHiveMetastore_fire_listener_event_result__isset __isset;

  void __set_success(const FireEventResponse& 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 :1;
} _ThriftHiveMetastore_fire_listener_event_presult__isset;

class ThriftHiveMetastore_fire_listener_event_presult {
 public:


  virtual ~ThriftHiveMetastore_fire_listener_event_presult() noexcept;
  FireEventResponse* success;

  _ThriftHiveMetastore_fire_listener_event_presult__isset __isset;

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

};


class ThriftHiveMetastore_flushCache_args {
 public:

  ThriftHiveMetastore_flushCache_args(const ThriftHiveMetastore_flushCache_args&) noexcept;
  ThriftHiveMetastore_flushCache_args& operator=(const ThriftHiveMetastore_flushCache_args&) noexcept;
  ThriftHiveMetastore_flushCache_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_flushCache_args() noexcept;

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

  bool operator < (const ThriftHiveMetastore_flushCache_args & ) const;

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

};


class ThriftHiveMetastore_flushCache_pargs {
 public:


  virtual ~ThriftHiveMetastore_flushCache_pargs() noexcept;

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

};


class ThriftHiveMetastore_flushCache_result {
 public:

  ThriftHiveMetastore_flushCache_result(const ThriftHiveMetastore_flushCache_result&) noexcept;
  ThriftHiveMetastore_flushCache_result& operator=(const ThriftHiveMetastore_flushCache_result&) noexcept;
  ThriftHiveMetastore_flushCache_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_flushCache_result() noexcept;

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

  bool operator < (const ThriftHiveMetastore_flushCache_result & ) const;

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

};


class ThriftHiveMetastore_flushCache_presult {
 public:


  virtual ~ThriftHiveMetastore_flushCache_presult() noexcept;

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

};

typedef struct _ThriftHiveMetastore_cm_recycle_args__isset {
  _ThriftHiveMetastore_cm_recycle_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_cm_recycle_args__isset;

class ThriftHiveMetastore_cm_recycle_args {
 public:

  ThriftHiveMetastore_cm_recycle_args(const ThriftHiveMetastore_cm_recycle_args&);
  ThriftHiveMetastore_cm_recycle_args& operator=(const ThriftHiveMetastore_cm_recycle_args&);
  ThriftHiveMetastore_cm_recycle_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_cm_recycle_args() noexcept;
  CmRecycleRequest request;

  _ThriftHiveMetastore_cm_recycle_args__isset __isset;

  void __set_request(const CmRecycleRequest& val);

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

  bool operator < (const ThriftHiveMetastore_cm_recycle_args & ) const;

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

};


class ThriftHiveMetastore_cm_recycle_pargs {
 public:


  virtual ~ThriftHiveMetastore_cm_recycle_pargs() noexcept;
  const CmRecycleRequest* request;

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

};

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

class ThriftHiveMetastore_cm_recycle_result {
 public:

  ThriftHiveMetastore_cm_recycle_result(const ThriftHiveMetastore_cm_recycle_result&);
  ThriftHiveMetastore_cm_recycle_result& operator=(const ThriftHiveMetastore_cm_recycle_result&);
  ThriftHiveMetastore_cm_recycle_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_cm_recycle_result() noexcept;
  CmRecycleResponse success;
  MetaException o1;

  _ThriftHiveMetastore_cm_recycle_result__isset __isset;

  void __set_success(const CmRecycleResponse& val);

  void __set_o1(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_cm_recycle_result & ) const;

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

};

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

class ThriftHiveMetastore_cm_recycle_presult {
 public:


  virtual ~ThriftHiveMetastore_cm_recycle_presult() noexcept;
  CmRecycleResponse* success;
  MetaException o1;

  _ThriftHiveMetastore_cm_recycle_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_file_metadata_by_expr_args__isset {
  _ThriftHiveMetastore_get_file_metadata_by_expr_args__isset() : req(false) {}
  bool req :1;
} _ThriftHiveMetastore_get_file_metadata_by_expr_args__isset;

class ThriftHiveMetastore_get_file_metadata_by_expr_args {
 public:

  ThriftHiveMetastore_get_file_metadata_by_expr_args(const ThriftHiveMetastore_get_file_metadata_by_expr_args&);
  ThriftHiveMetastore_get_file_metadata_by_expr_args& operator=(const ThriftHiveMetastore_get_file_metadata_by_expr_args&);
  ThriftHiveMetastore_get_file_metadata_by_expr_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_file_metadata_by_expr_args() noexcept;
  GetFileMetadataByExprRequest req;

  _ThriftHiveMetastore_get_file_metadata_by_expr_args__isset __isset;

  void __set_req(const GetFileMetadataByExprRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_file_metadata_by_expr_args & ) const;

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

};


class ThriftHiveMetastore_get_file_metadata_by_expr_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_file_metadata_by_expr_pargs() noexcept;
  const GetFileMetadataByExprRequest* req;

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

};

typedef struct _ThriftHiveMetastore_get_file_metadata_by_expr_result__isset {
  _ThriftHiveMetastore_get_file_metadata_by_expr_result__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_get_file_metadata_by_expr_result__isset;

class ThriftHiveMetastore_get_file_metadata_by_expr_result {
 public:

  ThriftHiveMetastore_get_file_metadata_by_expr_result(const ThriftHiveMetastore_get_file_metadata_by_expr_result&);
  ThriftHiveMetastore_get_file_metadata_by_expr_result& operator=(const ThriftHiveMetastore_get_file_metadata_by_expr_result&);
  ThriftHiveMetastore_get_file_metadata_by_expr_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_file_metadata_by_expr_result() noexcept;
  GetFileMetadataByExprResult success;

  _ThriftHiveMetastore_get_file_metadata_by_expr_result__isset __isset;

  void __set_success(const GetFileMetadataByExprResult& val);

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

  bool operator < (const ThriftHiveMetastore_get_file_metadata_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_file_metadata_by_expr_presult__isset {
  _ThriftHiveMetastore_get_file_metadata_by_expr_presult__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_get_file_metadata_by_expr_presult__isset;

class ThriftHiveMetastore_get_file_metadata_by_expr_presult {
 public:


  virtual ~ThriftHiveMetastore_get_file_metadata_by_expr_presult() noexcept;
  GetFileMetadataByExprResult* success;

  _ThriftHiveMetastore_get_file_metadata_by_expr_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_file_metadata_args__isset {
  _ThriftHiveMetastore_get_file_metadata_args__isset() : req(false) {}
  bool req :1;
} _ThriftHiveMetastore_get_file_metadata_args__isset;

class ThriftHiveMetastore_get_file_metadata_args {
 public:

  ThriftHiveMetastore_get_file_metadata_args(const ThriftHiveMetastore_get_file_metadata_args&);
  ThriftHiveMetastore_get_file_metadata_args& operator=(const ThriftHiveMetastore_get_file_metadata_args&);
  ThriftHiveMetastore_get_file_metadata_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_file_metadata_args() noexcept;
  GetFileMetadataRequest req;

  _ThriftHiveMetastore_get_file_metadata_args__isset __isset;

  void __set_req(const GetFileMetadataRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_file_metadata_args & ) const;

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

};


class ThriftHiveMetastore_get_file_metadata_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_file_metadata_pargs() noexcept;
  const GetFileMetadataRequest* req;

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

};

typedef struct _ThriftHiveMetastore_get_file_metadata_result__isset {
  _ThriftHiveMetastore_get_file_metadata_result__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_get_file_metadata_result__isset;

class ThriftHiveMetastore_get_file_metadata_result {
 public:

  ThriftHiveMetastore_get_file_metadata_result(const ThriftHiveMetastore_get_file_metadata_result&);
  ThriftHiveMetastore_get_file_metadata_result& operator=(const ThriftHiveMetastore_get_file_metadata_result&);
  ThriftHiveMetastore_get_file_metadata_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_file_metadata_result() noexcept;
  GetFileMetadataResult success;

  _ThriftHiveMetastore_get_file_metadata_result__isset __isset;

  void __set_success(const GetFileMetadataResult& val);

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

  bool operator < (const ThriftHiveMetastore_get_file_metadata_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_get_file_metadata_presult__isset {
  _ThriftHiveMetastore_get_file_metadata_presult__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_get_file_metadata_presult__isset;

class ThriftHiveMetastore_get_file_metadata_presult {
 public:


  virtual ~ThriftHiveMetastore_get_file_metadata_presult() noexcept;
  GetFileMetadataResult* success;

  _ThriftHiveMetastore_get_file_metadata_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_put_file_metadata_args__isset {
  _ThriftHiveMetastore_put_file_metadata_args__isset() : req(false) {}
  bool req :1;
} _ThriftHiveMetastore_put_file_metadata_args__isset;

class ThriftHiveMetastore_put_file_metadata_args {
 public:

  ThriftHiveMetastore_put_file_metadata_args(const ThriftHiveMetastore_put_file_metadata_args&);
  ThriftHiveMetastore_put_file_metadata_args& operator=(const ThriftHiveMetastore_put_file_metadata_args&);
  ThriftHiveMetastore_put_file_metadata_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_put_file_metadata_args() noexcept;
  PutFileMetadataRequest req;

  _ThriftHiveMetastore_put_file_metadata_args__isset __isset;

  void __set_req(const PutFileMetadataRequest& val);

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

  bool operator < (const ThriftHiveMetastore_put_file_metadata_args & ) const;

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

};


class ThriftHiveMetastore_put_file_metadata_pargs {
 public:


  virtual ~ThriftHiveMetastore_put_file_metadata_pargs() noexcept;
  const PutFileMetadataRequest* req;

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

};

typedef struct _ThriftHiveMetastore_put_file_metadata_result__isset {
  _ThriftHiveMetastore_put_file_metadata_result__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_put_file_metadata_result__isset;

class ThriftHiveMetastore_put_file_metadata_result {
 public:

  ThriftHiveMetastore_put_file_metadata_result(const ThriftHiveMetastore_put_file_metadata_result&) noexcept;
  ThriftHiveMetastore_put_file_metadata_result& operator=(const ThriftHiveMetastore_put_file_metadata_result&) noexcept;
  ThriftHiveMetastore_put_file_metadata_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_put_file_metadata_result() noexcept;
  PutFileMetadataResult success;

  _ThriftHiveMetastore_put_file_metadata_result__isset __isset;

  void __set_success(const PutFileMetadataResult& val);

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

  bool operator < (const ThriftHiveMetastore_put_file_metadata_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_put_file_metadata_presult__isset {
  _ThriftHiveMetastore_put_file_metadata_presult__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_put_file_metadata_presult__isset;

class ThriftHiveMetastore_put_file_metadata_presult {
 public:


  virtual ~ThriftHiveMetastore_put_file_metadata_presult() noexcept;
  PutFileMetadataResult* success;

  _ThriftHiveMetastore_put_file_metadata_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_clear_file_metadata_args__isset {
  _ThriftHiveMetastore_clear_file_metadata_args__isset() : req(false) {}
  bool req :1;
} _ThriftHiveMetastore_clear_file_metadata_args__isset;

class ThriftHiveMetastore_clear_file_metadata_args {
 public:

  ThriftHiveMetastore_clear_file_metadata_args(const ThriftHiveMetastore_clear_file_metadata_args&);
  ThriftHiveMetastore_clear_file_metadata_args& operator=(const ThriftHiveMetastore_clear_file_metadata_args&);
  ThriftHiveMetastore_clear_file_metadata_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_clear_file_metadata_args() noexcept;
  ClearFileMetadataRequest req;

  _ThriftHiveMetastore_clear_file_metadata_args__isset __isset;

  void __set_req(const ClearFileMetadataRequest& val);

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

  bool operator < (const ThriftHiveMetastore_clear_file_metadata_args & ) const;

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

};


class ThriftHiveMetastore_clear_file_metadata_pargs {
 public:


  virtual ~ThriftHiveMetastore_clear_file_metadata_pargs() noexcept;
  const ClearFileMetadataRequest* req;

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

};

typedef struct _ThriftHiveMetastore_clear_file_metadata_result__isset {
  _ThriftHiveMetastore_clear_file_metadata_result__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_clear_file_metadata_result__isset;

class ThriftHiveMetastore_clear_file_metadata_result {
 public:

  ThriftHiveMetastore_clear_file_metadata_result(const ThriftHiveMetastore_clear_file_metadata_result&) noexcept;
  ThriftHiveMetastore_clear_file_metadata_result& operator=(const ThriftHiveMetastore_clear_file_metadata_result&) noexcept;
  ThriftHiveMetastore_clear_file_metadata_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_clear_file_metadata_result() noexcept;
  ClearFileMetadataResult success;

  _ThriftHiveMetastore_clear_file_metadata_result__isset __isset;

  void __set_success(const ClearFileMetadataResult& val);

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

  bool operator < (const ThriftHiveMetastore_clear_file_metadata_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_clear_file_metadata_presult__isset {
  _ThriftHiveMetastore_clear_file_metadata_presult__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_clear_file_metadata_presult__isset;

class ThriftHiveMetastore_clear_file_metadata_presult {
 public:


  virtual ~ThriftHiveMetastore_clear_file_metadata_presult() noexcept;
  ClearFileMetadataResult* success;

  _ThriftHiveMetastore_clear_file_metadata_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_cache_file_metadata_args__isset {
  _ThriftHiveMetastore_cache_file_metadata_args__isset() : req(false) {}
  bool req :1;
} _ThriftHiveMetastore_cache_file_metadata_args__isset;

class ThriftHiveMetastore_cache_file_metadata_args {
 public:

  ThriftHiveMetastore_cache_file_metadata_args(const ThriftHiveMetastore_cache_file_metadata_args&);
  ThriftHiveMetastore_cache_file_metadata_args& operator=(const ThriftHiveMetastore_cache_file_metadata_args&);
  ThriftHiveMetastore_cache_file_metadata_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_cache_file_metadata_args() noexcept;
  CacheFileMetadataRequest req;

  _ThriftHiveMetastore_cache_file_metadata_args__isset __isset;

  void __set_req(const CacheFileMetadataRequest& val);

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

  bool operator < (const ThriftHiveMetastore_cache_file_metadata_args & ) const;

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

};


class ThriftHiveMetastore_cache_file_metadata_pargs {
 public:


  virtual ~ThriftHiveMetastore_cache_file_metadata_pargs() noexcept;
  const CacheFileMetadataRequest* req;

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

};

typedef struct _ThriftHiveMetastore_cache_file_metadata_result__isset {
  _ThriftHiveMetastore_cache_file_metadata_result__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_cache_file_metadata_result__isset;

class ThriftHiveMetastore_cache_file_metadata_result {
 public:

  ThriftHiveMetastore_cache_file_metadata_result(const ThriftHiveMetastore_cache_file_metadata_result&) noexcept;
  ThriftHiveMetastore_cache_file_metadata_result& operator=(const ThriftHiveMetastore_cache_file_metadata_result&) noexcept;
  ThriftHiveMetastore_cache_file_metadata_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_cache_file_metadata_result() noexcept;
  CacheFileMetadataResult success;

  _ThriftHiveMetastore_cache_file_metadata_result__isset __isset;

  void __set_success(const CacheFileMetadataResult& val);

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

  bool operator < (const ThriftHiveMetastore_cache_file_metadata_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_cache_file_metadata_presult__isset {
  _ThriftHiveMetastore_cache_file_metadata_presult__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_cache_file_metadata_presult__isset;

class ThriftHiveMetastore_cache_file_metadata_presult {
 public:


  virtual ~ThriftHiveMetastore_cache_file_metadata_presult() noexcept;
  CacheFileMetadataResult* success;

  _ThriftHiveMetastore_cache_file_metadata_presult__isset __isset;

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

};


class ThriftHiveMetastore_get_metastore_db_uuid_args {
 public:

  ThriftHiveMetastore_get_metastore_db_uuid_args(const ThriftHiveMetastore_get_metastore_db_uuid_args&) noexcept;
  ThriftHiveMetastore_get_metastore_db_uuid_args& operator=(const ThriftHiveMetastore_get_metastore_db_uuid_args&) noexcept;
  ThriftHiveMetastore_get_metastore_db_uuid_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_metastore_db_uuid_args() noexcept;

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

  bool operator < (const ThriftHiveMetastore_get_metastore_db_uuid_args & ) const;

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

};


class ThriftHiveMetastore_get_metastore_db_uuid_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_metastore_db_uuid_pargs() noexcept;

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

};

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

class ThriftHiveMetastore_get_metastore_db_uuid_result {
 public:

  ThriftHiveMetastore_get_metastore_db_uuid_result(const ThriftHiveMetastore_get_metastore_db_uuid_result&);
  ThriftHiveMetastore_get_metastore_db_uuid_result& operator=(const ThriftHiveMetastore_get_metastore_db_uuid_result&);
  ThriftHiveMetastore_get_metastore_db_uuid_result() noexcept
                                                   : success() {
  }

  virtual ~ThriftHiveMetastore_get_metastore_db_uuid_result() noexcept;
  std::string success;
  MetaException o1;

  _ThriftHiveMetastore_get_metastore_db_uuid_result__isset __isset;

  void __set_success(const std::string& val);

  void __set_o1(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_metastore_db_uuid_result & ) const;

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

};

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

class ThriftHiveMetastore_get_metastore_db_uuid_presult {
 public:


  virtual ~ThriftHiveMetastore_get_metastore_db_uuid_presult() noexcept;
  std::string* success;
  MetaException o1;

  _ThriftHiveMetastore_get_metastore_db_uuid_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_create_resource_plan_args__isset {
  _ThriftHiveMetastore_create_resource_plan_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_create_resource_plan_args__isset;

class ThriftHiveMetastore_create_resource_plan_args {
 public:

  ThriftHiveMetastore_create_resource_plan_args(const ThriftHiveMetastore_create_resource_plan_args&);
  ThriftHiveMetastore_create_resource_plan_args& operator=(const ThriftHiveMetastore_create_resource_plan_args&);
  ThriftHiveMetastore_create_resource_plan_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_resource_plan_args() noexcept;
  WMCreateResourcePlanRequest request;

  _ThriftHiveMetastore_create_resource_plan_args__isset __isset;

  void __set_request(const WMCreateResourcePlanRequest& val);

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

  bool operator < (const ThriftHiveMetastore_create_resource_plan_args & ) const;

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

};


class ThriftHiveMetastore_create_resource_plan_pargs {
 public:


  virtual ~ThriftHiveMetastore_create_resource_plan_pargs() noexcept;
  const WMCreateResourcePlanRequest* request;

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

};

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

class ThriftHiveMetastore_create_resource_plan_result {
 public:

  ThriftHiveMetastore_create_resource_plan_result(const ThriftHiveMetastore_create_resource_plan_result&);
  ThriftHiveMetastore_create_resource_plan_result& operator=(const ThriftHiveMetastore_create_resource_plan_result&);
  ThriftHiveMetastore_create_resource_plan_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_resource_plan_result() noexcept;
  WMCreateResourcePlanResponse success;
  AlreadyExistsException o1;
  InvalidObjectException o2;
  MetaException o3;

  _ThriftHiveMetastore_create_resource_plan_result__isset __isset;

  void __set_success(const WMCreateResourcePlanResponse& val);

  void __set_o1(const AlreadyExistsException& val);

  void __set_o2(const InvalidObjectException& val);

  void __set_o3(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_create_resource_plan_result & ) const;

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

};

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

class ThriftHiveMetastore_create_resource_plan_presult {
 public:


  virtual ~ThriftHiveMetastore_create_resource_plan_presult() noexcept;
  WMCreateResourcePlanResponse* success;
  AlreadyExistsException o1;
  InvalidObjectException o2;
  MetaException o3;

  _ThriftHiveMetastore_create_resource_plan_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_resource_plan_args__isset {
  _ThriftHiveMetastore_get_resource_plan_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_get_resource_plan_args__isset;

class ThriftHiveMetastore_get_resource_plan_args {
 public:

  ThriftHiveMetastore_get_resource_plan_args(const ThriftHiveMetastore_get_resource_plan_args&);
  ThriftHiveMetastore_get_resource_plan_args& operator=(const ThriftHiveMetastore_get_resource_plan_args&);
  ThriftHiveMetastore_get_resource_plan_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_resource_plan_args() noexcept;
  WMGetResourcePlanRequest request;

  _ThriftHiveMetastore_get_resource_plan_args__isset __isset;

  void __set_request(const WMGetResourcePlanRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_resource_plan_args & ) const;

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

};


class ThriftHiveMetastore_get_resource_plan_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_resource_plan_pargs() noexcept;
  const WMGetResourcePlanRequest* request;

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

};

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

class ThriftHiveMetastore_get_resource_plan_result {
 public:

  ThriftHiveMetastore_get_resource_plan_result(const ThriftHiveMetastore_get_resource_plan_result&);
  ThriftHiveMetastore_get_resource_plan_result& operator=(const ThriftHiveMetastore_get_resource_plan_result&);
  ThriftHiveMetastore_get_resource_plan_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_resource_plan_result() noexcept;
  WMGetResourcePlanResponse success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_resource_plan_result__isset __isset;

  void __set_success(const WMGetResourcePlanResponse& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_resource_plan_result & ) const;

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

};

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

class ThriftHiveMetastore_get_resource_plan_presult {
 public:


  virtual ~ThriftHiveMetastore_get_resource_plan_presult() noexcept;
  WMGetResourcePlanResponse* success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_resource_plan_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_active_resource_plan_args__isset {
  _ThriftHiveMetastore_get_active_resource_plan_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_get_active_resource_plan_args__isset;

class ThriftHiveMetastore_get_active_resource_plan_args {
 public:

  ThriftHiveMetastore_get_active_resource_plan_args(const ThriftHiveMetastore_get_active_resource_plan_args&) noexcept;
  ThriftHiveMetastore_get_active_resource_plan_args& operator=(const ThriftHiveMetastore_get_active_resource_plan_args&) noexcept;
  ThriftHiveMetastore_get_active_resource_plan_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_active_resource_plan_args() noexcept;
  WMGetActiveResourcePlanRequest request;

  _ThriftHiveMetastore_get_active_resource_plan_args__isset __isset;

  void __set_request(const WMGetActiveResourcePlanRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_active_resource_plan_args & ) const;

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

};


class ThriftHiveMetastore_get_active_resource_plan_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_active_resource_plan_pargs() noexcept;
  const WMGetActiveResourcePlanRequest* request;

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

};

typedef struct _ThriftHiveMetastore_get_active_resource_plan_result__isset {
  _ThriftHiveMetastore_get_active_resource_plan_result__isset() : success(false), o2(false) {}
  bool success :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_active_resource_plan_result__isset;

class ThriftHiveMetastore_get_active_resource_plan_result {
 public:

  ThriftHiveMetastore_get_active_resource_plan_result(const ThriftHiveMetastore_get_active_resource_plan_result&);
  ThriftHiveMetastore_get_active_resource_plan_result& operator=(const ThriftHiveMetastore_get_active_resource_plan_result&);
  ThriftHiveMetastore_get_active_resource_plan_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_active_resource_plan_result() noexcept;
  WMGetActiveResourcePlanResponse success;
  MetaException o2;

  _ThriftHiveMetastore_get_active_resource_plan_result__isset __isset;

  void __set_success(const WMGetActiveResourcePlanResponse& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_active_resource_plan_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_get_active_resource_plan_presult__isset {
  _ThriftHiveMetastore_get_active_resource_plan_presult__isset() : success(false), o2(false) {}
  bool success :1;
  bool o2 :1;
} _ThriftHiveMetastore_get_active_resource_plan_presult__isset;

class ThriftHiveMetastore_get_active_resource_plan_presult {
 public:


  virtual ~ThriftHiveMetastore_get_active_resource_plan_presult() noexcept;
  WMGetActiveResourcePlanResponse* success;
  MetaException o2;

  _ThriftHiveMetastore_get_active_resource_plan_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_all_resource_plans_args__isset {
  _ThriftHiveMetastore_get_all_resource_plans_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_get_all_resource_plans_args__isset;

class ThriftHiveMetastore_get_all_resource_plans_args {
 public:

  ThriftHiveMetastore_get_all_resource_plans_args(const ThriftHiveMetastore_get_all_resource_plans_args&) noexcept;
  ThriftHiveMetastore_get_all_resource_plans_args& operator=(const ThriftHiveMetastore_get_all_resource_plans_args&) noexcept;
  ThriftHiveMetastore_get_all_resource_plans_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_all_resource_plans_args() noexcept;
  WMGetAllResourcePlanRequest request;

  _ThriftHiveMetastore_get_all_resource_plans_args__isset __isset;

  void __set_request(const WMGetAllResourcePlanRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_all_resource_plans_args & ) const;

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

};


class ThriftHiveMetastore_get_all_resource_plans_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_all_resource_plans_pargs() noexcept;
  const WMGetAllResourcePlanRequest* request;

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

};

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

class ThriftHiveMetastore_get_all_resource_plans_result {
 public:

  ThriftHiveMetastore_get_all_resource_plans_result(const ThriftHiveMetastore_get_all_resource_plans_result&);
  ThriftHiveMetastore_get_all_resource_plans_result& operator=(const ThriftHiveMetastore_get_all_resource_plans_result&);
  ThriftHiveMetastore_get_all_resource_plans_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_all_resource_plans_result() noexcept;
  WMGetAllResourcePlanResponse success;
  MetaException o1;

  _ThriftHiveMetastore_get_all_resource_plans_result__isset __isset;

  void __set_success(const WMGetAllResourcePlanResponse& val);

  void __set_o1(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_all_resource_plans_result & ) const;

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

};

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

class ThriftHiveMetastore_get_all_resource_plans_presult {
 public:


  virtual ~ThriftHiveMetastore_get_all_resource_plans_presult() noexcept;
  WMGetAllResourcePlanResponse* success;
  MetaException o1;

  _ThriftHiveMetastore_get_all_resource_plans_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_alter_resource_plan_args__isset {
  _ThriftHiveMetastore_alter_resource_plan_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_alter_resource_plan_args__isset;

class ThriftHiveMetastore_alter_resource_plan_args {
 public:

  ThriftHiveMetastore_alter_resource_plan_args(const ThriftHiveMetastore_alter_resource_plan_args&);
  ThriftHiveMetastore_alter_resource_plan_args& operator=(const ThriftHiveMetastore_alter_resource_plan_args&);
  ThriftHiveMetastore_alter_resource_plan_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_resource_plan_args() noexcept;
  WMAlterResourcePlanRequest request;

  _ThriftHiveMetastore_alter_resource_plan_args__isset __isset;

  void __set_request(const WMAlterResourcePlanRequest& val);

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

  bool operator < (const ThriftHiveMetastore_alter_resource_plan_args & ) const;

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

};


class ThriftHiveMetastore_alter_resource_plan_pargs {
 public:


  virtual ~ThriftHiveMetastore_alter_resource_plan_pargs() noexcept;
  const WMAlterResourcePlanRequest* request;

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

};

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

class ThriftHiveMetastore_alter_resource_plan_result {
 public:

  ThriftHiveMetastore_alter_resource_plan_result(const ThriftHiveMetastore_alter_resource_plan_result&);
  ThriftHiveMetastore_alter_resource_plan_result& operator=(const ThriftHiveMetastore_alter_resource_plan_result&);
  ThriftHiveMetastore_alter_resource_plan_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_resource_plan_result() noexcept;
  WMAlterResourcePlanResponse success;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_alter_resource_plan_result__isset __isset;

  void __set_success(const WMAlterResourcePlanResponse& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const InvalidOperationException& val);

  void __set_o3(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_alter_resource_plan_result & ) const;

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

};

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

class ThriftHiveMetastore_alter_resource_plan_presult {
 public:


  virtual ~ThriftHiveMetastore_alter_resource_plan_presult() noexcept;
  WMAlterResourcePlanResponse* success;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_alter_resource_plan_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_validate_resource_plan_args__isset {
  _ThriftHiveMetastore_validate_resource_plan_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_validate_resource_plan_args__isset;

class ThriftHiveMetastore_validate_resource_plan_args {
 public:

  ThriftHiveMetastore_validate_resource_plan_args(const ThriftHiveMetastore_validate_resource_plan_args&);
  ThriftHiveMetastore_validate_resource_plan_args& operator=(const ThriftHiveMetastore_validate_resource_plan_args&);
  ThriftHiveMetastore_validate_resource_plan_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_validate_resource_plan_args() noexcept;
  WMValidateResourcePlanRequest request;

  _ThriftHiveMetastore_validate_resource_plan_args__isset __isset;

  void __set_request(const WMValidateResourcePlanRequest& val);

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

  bool operator < (const ThriftHiveMetastore_validate_resource_plan_args & ) const;

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

};


class ThriftHiveMetastore_validate_resource_plan_pargs {
 public:


  virtual ~ThriftHiveMetastore_validate_resource_plan_pargs() noexcept;
  const WMValidateResourcePlanRequest* request;

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

};

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

class ThriftHiveMetastore_validate_resource_plan_result {
 public:

  ThriftHiveMetastore_validate_resource_plan_result(const ThriftHiveMetastore_validate_resource_plan_result&);
  ThriftHiveMetastore_validate_resource_plan_result& operator=(const ThriftHiveMetastore_validate_resource_plan_result&);
  ThriftHiveMetastore_validate_resource_plan_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_validate_resource_plan_result() noexcept;
  WMValidateResourcePlanResponse success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_validate_resource_plan_result__isset __isset;

  void __set_success(const WMValidateResourcePlanResponse& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_validate_resource_plan_result & ) const;

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

};

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

class ThriftHiveMetastore_validate_resource_plan_presult {
 public:


  virtual ~ThriftHiveMetastore_validate_resource_plan_presult() noexcept;
  WMValidateResourcePlanResponse* success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_validate_resource_plan_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_drop_resource_plan_args__isset {
  _ThriftHiveMetastore_drop_resource_plan_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_drop_resource_plan_args__isset;

class ThriftHiveMetastore_drop_resource_plan_args {
 public:

  ThriftHiveMetastore_drop_resource_plan_args(const ThriftHiveMetastore_drop_resource_plan_args&);
  ThriftHiveMetastore_drop_resource_plan_args& operator=(const ThriftHiveMetastore_drop_resource_plan_args&);
  ThriftHiveMetastore_drop_resource_plan_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_resource_plan_args() noexcept;
  WMDropResourcePlanRequest request;

  _ThriftHiveMetastore_drop_resource_plan_args__isset __isset;

  void __set_request(const WMDropResourcePlanRequest& val);

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

  bool operator < (const ThriftHiveMetastore_drop_resource_plan_args & ) const;

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

};


class ThriftHiveMetastore_drop_resource_plan_pargs {
 public:


  virtual ~ThriftHiveMetastore_drop_resource_plan_pargs() noexcept;
  const WMDropResourcePlanRequest* request;

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

};

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

class ThriftHiveMetastore_drop_resource_plan_result {
 public:

  ThriftHiveMetastore_drop_resource_plan_result(const ThriftHiveMetastore_drop_resource_plan_result&);
  ThriftHiveMetastore_drop_resource_plan_result& operator=(const ThriftHiveMetastore_drop_resource_plan_result&);
  ThriftHiveMetastore_drop_resource_plan_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_resource_plan_result() noexcept;
  WMDropResourcePlanResponse success;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_drop_resource_plan_result__isset __isset;

  void __set_success(const WMDropResourcePlanResponse& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const InvalidOperationException& val);

  void __set_o3(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_drop_resource_plan_result & ) const;

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

};

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

class ThriftHiveMetastore_drop_resource_plan_presult {
 public:


  virtual ~ThriftHiveMetastore_drop_resource_plan_presult() noexcept;
  WMDropResourcePlanResponse* success;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_drop_resource_plan_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_create_wm_trigger_args__isset {
  _ThriftHiveMetastore_create_wm_trigger_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_create_wm_trigger_args__isset;

class ThriftHiveMetastore_create_wm_trigger_args {
 public:

  ThriftHiveMetastore_create_wm_trigger_args(const ThriftHiveMetastore_create_wm_trigger_args&);
  ThriftHiveMetastore_create_wm_trigger_args& operator=(const ThriftHiveMetastore_create_wm_trigger_args&);
  ThriftHiveMetastore_create_wm_trigger_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_wm_trigger_args() noexcept;
  WMCreateTriggerRequest request;

  _ThriftHiveMetastore_create_wm_trigger_args__isset __isset;

  void __set_request(const WMCreateTriggerRequest& val);

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

  bool operator < (const ThriftHiveMetastore_create_wm_trigger_args & ) const;

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

};


class ThriftHiveMetastore_create_wm_trigger_pargs {
 public:


  virtual ~ThriftHiveMetastore_create_wm_trigger_pargs() noexcept;
  const WMCreateTriggerRequest* request;

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

};

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

class ThriftHiveMetastore_create_wm_trigger_result {
 public:

  ThriftHiveMetastore_create_wm_trigger_result(const ThriftHiveMetastore_create_wm_trigger_result&);
  ThriftHiveMetastore_create_wm_trigger_result& operator=(const ThriftHiveMetastore_create_wm_trigger_result&);
  ThriftHiveMetastore_create_wm_trigger_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_wm_trigger_result() noexcept;
  WMCreateTriggerResponse success;
  AlreadyExistsException o1;
  NoSuchObjectException o2;
  InvalidObjectException o3;
  MetaException o4;

  _ThriftHiveMetastore_create_wm_trigger_result__isset __isset;

  void __set_success(const WMCreateTriggerResponse& val);

  void __set_o1(const AlreadyExistsException& val);

  void __set_o2(const NoSuchObjectException& val);

  void __set_o3(const InvalidObjectException& val);

  void __set_o4(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_create_wm_trigger_result & ) const;

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

};

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

class ThriftHiveMetastore_create_wm_trigger_presult {
 public:


  virtual ~ThriftHiveMetastore_create_wm_trigger_presult() noexcept;
  WMCreateTriggerResponse* success;
  AlreadyExistsException o1;
  NoSuchObjectException o2;
  InvalidObjectException o3;
  MetaException o4;

  _ThriftHiveMetastore_create_wm_trigger_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_alter_wm_trigger_args__isset {
  _ThriftHiveMetastore_alter_wm_trigger_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_alter_wm_trigger_args__isset;

class ThriftHiveMetastore_alter_wm_trigger_args {
 public:

  ThriftHiveMetastore_alter_wm_trigger_args(const ThriftHiveMetastore_alter_wm_trigger_args&);
  ThriftHiveMetastore_alter_wm_trigger_args& operator=(const ThriftHiveMetastore_alter_wm_trigger_args&);
  ThriftHiveMetastore_alter_wm_trigger_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_wm_trigger_args() noexcept;
  WMAlterTriggerRequest request;

  _ThriftHiveMetastore_alter_wm_trigger_args__isset __isset;

  void __set_request(const WMAlterTriggerRequest& val);

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

  bool operator < (const ThriftHiveMetastore_alter_wm_trigger_args & ) const;

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

};


class ThriftHiveMetastore_alter_wm_trigger_pargs {
 public:


  virtual ~ThriftHiveMetastore_alter_wm_trigger_pargs() noexcept;
  const WMAlterTriggerRequest* request;

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

};

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

class ThriftHiveMetastore_alter_wm_trigger_result {
 public:

  ThriftHiveMetastore_alter_wm_trigger_result(const ThriftHiveMetastore_alter_wm_trigger_result&);
  ThriftHiveMetastore_alter_wm_trigger_result& operator=(const ThriftHiveMetastore_alter_wm_trigger_result&);
  ThriftHiveMetastore_alter_wm_trigger_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_wm_trigger_result() noexcept;
  WMAlterTriggerResponse success;
  NoSuchObjectException o1;
  InvalidObjectException o2;
  MetaException o3;

  _ThriftHiveMetastore_alter_wm_trigger_result__isset __isset;

  void __set_success(const WMAlterTriggerResponse& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const InvalidObjectException& val);

  void __set_o3(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_alter_wm_trigger_result & ) const;

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

};

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

class ThriftHiveMetastore_alter_wm_trigger_presult {
 public:


  virtual ~ThriftHiveMetastore_alter_wm_trigger_presult() noexcept;
  WMAlterTriggerResponse* success;
  NoSuchObjectException o1;
  InvalidObjectException o2;
  MetaException o3;

  _ThriftHiveMetastore_alter_wm_trigger_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_drop_wm_trigger_args__isset {
  _ThriftHiveMetastore_drop_wm_trigger_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_drop_wm_trigger_args__isset;

class ThriftHiveMetastore_drop_wm_trigger_args {
 public:

  ThriftHiveMetastore_drop_wm_trigger_args(const ThriftHiveMetastore_drop_wm_trigger_args&);
  ThriftHiveMetastore_drop_wm_trigger_args& operator=(const ThriftHiveMetastore_drop_wm_trigger_args&);
  ThriftHiveMetastore_drop_wm_trigger_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_wm_trigger_args() noexcept;
  WMDropTriggerRequest request;

  _ThriftHiveMetastore_drop_wm_trigger_args__isset __isset;

  void __set_request(const WMDropTriggerRequest& val);

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

  bool operator < (const ThriftHiveMetastore_drop_wm_trigger_args & ) const;

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

};


class ThriftHiveMetastore_drop_wm_trigger_pargs {
 public:


  virtual ~ThriftHiveMetastore_drop_wm_trigger_pargs() noexcept;
  const WMDropTriggerRequest* request;

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

};

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

class ThriftHiveMetastore_drop_wm_trigger_result {
 public:

  ThriftHiveMetastore_drop_wm_trigger_result(const ThriftHiveMetastore_drop_wm_trigger_result&);
  ThriftHiveMetastore_drop_wm_trigger_result& operator=(const ThriftHiveMetastore_drop_wm_trigger_result&);
  ThriftHiveMetastore_drop_wm_trigger_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_wm_trigger_result() noexcept;
  WMDropTriggerResponse success;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_drop_wm_trigger_result__isset __isset;

  void __set_success(const WMDropTriggerResponse& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const InvalidOperationException& val);

  void __set_o3(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_drop_wm_trigger_result & ) const;

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

};

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

class ThriftHiveMetastore_drop_wm_trigger_presult {
 public:


  virtual ~ThriftHiveMetastore_drop_wm_trigger_presult() noexcept;
  WMDropTriggerResponse* success;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_drop_wm_trigger_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_triggers_for_resourceplan_args__isset {
  _ThriftHiveMetastore_get_triggers_for_resourceplan_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_get_triggers_for_resourceplan_args__isset;

class ThriftHiveMetastore_get_triggers_for_resourceplan_args {
 public:

  ThriftHiveMetastore_get_triggers_for_resourceplan_args(const ThriftHiveMetastore_get_triggers_for_resourceplan_args&);
  ThriftHiveMetastore_get_triggers_for_resourceplan_args& operator=(const ThriftHiveMetastore_get_triggers_for_resourceplan_args&);
  ThriftHiveMetastore_get_triggers_for_resourceplan_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_triggers_for_resourceplan_args() noexcept;
  WMGetTriggersForResourePlanRequest request;

  _ThriftHiveMetastore_get_triggers_for_resourceplan_args__isset __isset;

  void __set_request(const WMGetTriggersForResourePlanRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_triggers_for_resourceplan_args & ) const;

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

};


class ThriftHiveMetastore_get_triggers_for_resourceplan_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_triggers_for_resourceplan_pargs() noexcept;
  const WMGetTriggersForResourePlanRequest* request;

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

};

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

class ThriftHiveMetastore_get_triggers_for_resourceplan_result {
 public:

  ThriftHiveMetastore_get_triggers_for_resourceplan_result(const ThriftHiveMetastore_get_triggers_for_resourceplan_result&);
  ThriftHiveMetastore_get_triggers_for_resourceplan_result& operator=(const ThriftHiveMetastore_get_triggers_for_resourceplan_result&);
  ThriftHiveMetastore_get_triggers_for_resourceplan_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_triggers_for_resourceplan_result() noexcept;
  WMGetTriggersForResourePlanResponse success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_triggers_for_resourceplan_result__isset __isset;

  void __set_success(const WMGetTriggersForResourePlanResponse& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_triggers_for_resourceplan_result & ) const;

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

};

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

class ThriftHiveMetastore_get_triggers_for_resourceplan_presult {
 public:


  virtual ~ThriftHiveMetastore_get_triggers_for_resourceplan_presult() noexcept;
  WMGetTriggersForResourePlanResponse* success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_triggers_for_resourceplan_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_create_wm_pool_args__isset {
  _ThriftHiveMetastore_create_wm_pool_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_create_wm_pool_args__isset;

class ThriftHiveMetastore_create_wm_pool_args {
 public:

  ThriftHiveMetastore_create_wm_pool_args(const ThriftHiveMetastore_create_wm_pool_args&);
  ThriftHiveMetastore_create_wm_pool_args& operator=(const ThriftHiveMetastore_create_wm_pool_args&);
  ThriftHiveMetastore_create_wm_pool_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_wm_pool_args() noexcept;
  WMCreatePoolRequest request;

  _ThriftHiveMetastore_create_wm_pool_args__isset __isset;

  void __set_request(const WMCreatePoolRequest& val);

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

  bool operator < (const ThriftHiveMetastore_create_wm_pool_args & ) const;

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

};


class ThriftHiveMetastore_create_wm_pool_pargs {
 public:


  virtual ~ThriftHiveMetastore_create_wm_pool_pargs() noexcept;
  const WMCreatePoolRequest* request;

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

};

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

class ThriftHiveMetastore_create_wm_pool_result {
 public:

  ThriftHiveMetastore_create_wm_pool_result(const ThriftHiveMetastore_create_wm_pool_result&);
  ThriftHiveMetastore_create_wm_pool_result& operator=(const ThriftHiveMetastore_create_wm_pool_result&);
  ThriftHiveMetastore_create_wm_pool_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_wm_pool_result() noexcept;
  WMCreatePoolResponse success;
  AlreadyExistsException o1;
  NoSuchObjectException o2;
  InvalidObjectException o3;
  MetaException o4;

  _ThriftHiveMetastore_create_wm_pool_result__isset __isset;

  void __set_success(const WMCreatePoolResponse& val);

  void __set_o1(const AlreadyExistsException& val);

  void __set_o2(const NoSuchObjectException& val);

  void __set_o3(const InvalidObjectException& val);

  void __set_o4(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_create_wm_pool_result & ) const;

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

};

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

class ThriftHiveMetastore_create_wm_pool_presult {
 public:


  virtual ~ThriftHiveMetastore_create_wm_pool_presult() noexcept;
  WMCreatePoolResponse* success;
  AlreadyExistsException o1;
  NoSuchObjectException o2;
  InvalidObjectException o3;
  MetaException o4;

  _ThriftHiveMetastore_create_wm_pool_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_alter_wm_pool_args__isset {
  _ThriftHiveMetastore_alter_wm_pool_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_alter_wm_pool_args__isset;

class ThriftHiveMetastore_alter_wm_pool_args {
 public:

  ThriftHiveMetastore_alter_wm_pool_args(const ThriftHiveMetastore_alter_wm_pool_args&);
  ThriftHiveMetastore_alter_wm_pool_args& operator=(const ThriftHiveMetastore_alter_wm_pool_args&);
  ThriftHiveMetastore_alter_wm_pool_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_wm_pool_args() noexcept;
  WMAlterPoolRequest request;

  _ThriftHiveMetastore_alter_wm_pool_args__isset __isset;

  void __set_request(const WMAlterPoolRequest& val);

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

  bool operator < (const ThriftHiveMetastore_alter_wm_pool_args & ) const;

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

};


class ThriftHiveMetastore_alter_wm_pool_pargs {
 public:


  virtual ~ThriftHiveMetastore_alter_wm_pool_pargs() noexcept;
  const WMAlterPoolRequest* request;

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

};

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

class ThriftHiveMetastore_alter_wm_pool_result {
 public:

  ThriftHiveMetastore_alter_wm_pool_result(const ThriftHiveMetastore_alter_wm_pool_result&);
  ThriftHiveMetastore_alter_wm_pool_result& operator=(const ThriftHiveMetastore_alter_wm_pool_result&);
  ThriftHiveMetastore_alter_wm_pool_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_wm_pool_result() noexcept;
  WMAlterPoolResponse success;
  AlreadyExistsException o1;
  NoSuchObjectException o2;
  InvalidObjectException o3;
  MetaException o4;

  _ThriftHiveMetastore_alter_wm_pool_result__isset __isset;

  void __set_success(const WMAlterPoolResponse& val);

  void __set_o1(const AlreadyExistsException& val);

  void __set_o2(const NoSuchObjectException& val);

  void __set_o3(const InvalidObjectException& val);

  void __set_o4(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_alter_wm_pool_result & ) const;

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

};

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

class ThriftHiveMetastore_alter_wm_pool_presult {
 public:


  virtual ~ThriftHiveMetastore_alter_wm_pool_presult() noexcept;
  WMAlterPoolResponse* success;
  AlreadyExistsException o1;
  NoSuchObjectException o2;
  InvalidObjectException o3;
  MetaException o4;

  _ThriftHiveMetastore_alter_wm_pool_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_drop_wm_pool_args__isset {
  _ThriftHiveMetastore_drop_wm_pool_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_drop_wm_pool_args__isset;

class ThriftHiveMetastore_drop_wm_pool_args {
 public:

  ThriftHiveMetastore_drop_wm_pool_args(const ThriftHiveMetastore_drop_wm_pool_args&);
  ThriftHiveMetastore_drop_wm_pool_args& operator=(const ThriftHiveMetastore_drop_wm_pool_args&);
  ThriftHiveMetastore_drop_wm_pool_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_wm_pool_args() noexcept;
  WMDropPoolRequest request;

  _ThriftHiveMetastore_drop_wm_pool_args__isset __isset;

  void __set_request(const WMDropPoolRequest& val);

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

  bool operator < (const ThriftHiveMetastore_drop_wm_pool_args & ) const;

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

};


class ThriftHiveMetastore_drop_wm_pool_pargs {
 public:


  virtual ~ThriftHiveMetastore_drop_wm_pool_pargs() noexcept;
  const WMDropPoolRequest* request;

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

};

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

class ThriftHiveMetastore_drop_wm_pool_result {
 public:

  ThriftHiveMetastore_drop_wm_pool_result(const ThriftHiveMetastore_drop_wm_pool_result&);
  ThriftHiveMetastore_drop_wm_pool_result& operator=(const ThriftHiveMetastore_drop_wm_pool_result&);
  ThriftHiveMetastore_drop_wm_pool_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_wm_pool_result() noexcept;
  WMDropPoolResponse success;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_drop_wm_pool_result__isset __isset;

  void __set_success(const WMDropPoolResponse& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const InvalidOperationException& val);

  void __set_o3(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_drop_wm_pool_result & ) const;

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

};

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

class ThriftHiveMetastore_drop_wm_pool_presult {
 public:


  virtual ~ThriftHiveMetastore_drop_wm_pool_presult() noexcept;
  WMDropPoolResponse* success;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_drop_wm_pool_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_create_or_update_wm_mapping_args__isset {
  _ThriftHiveMetastore_create_or_update_wm_mapping_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_create_or_update_wm_mapping_args__isset;

class ThriftHiveMetastore_create_or_update_wm_mapping_args {
 public:

  ThriftHiveMetastore_create_or_update_wm_mapping_args(const ThriftHiveMetastore_create_or_update_wm_mapping_args&);
  ThriftHiveMetastore_create_or_update_wm_mapping_args& operator=(const ThriftHiveMetastore_create_or_update_wm_mapping_args&);
  ThriftHiveMetastore_create_or_update_wm_mapping_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_or_update_wm_mapping_args() noexcept;
  WMCreateOrUpdateMappingRequest request;

  _ThriftHiveMetastore_create_or_update_wm_mapping_args__isset __isset;

  void __set_request(const WMCreateOrUpdateMappingRequest& val);

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

  bool operator < (const ThriftHiveMetastore_create_or_update_wm_mapping_args & ) const;

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

};


class ThriftHiveMetastore_create_or_update_wm_mapping_pargs {
 public:


  virtual ~ThriftHiveMetastore_create_or_update_wm_mapping_pargs() noexcept;
  const WMCreateOrUpdateMappingRequest* request;

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

};

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

class ThriftHiveMetastore_create_or_update_wm_mapping_result {
 public:

  ThriftHiveMetastore_create_or_update_wm_mapping_result(const ThriftHiveMetastore_create_or_update_wm_mapping_result&);
  ThriftHiveMetastore_create_or_update_wm_mapping_result& operator=(const ThriftHiveMetastore_create_or_update_wm_mapping_result&);
  ThriftHiveMetastore_create_or_update_wm_mapping_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_or_update_wm_mapping_result() noexcept;
  WMCreateOrUpdateMappingResponse success;
  AlreadyExistsException o1;
  NoSuchObjectException o2;
  InvalidObjectException o3;
  MetaException o4;

  _ThriftHiveMetastore_create_or_update_wm_mapping_result__isset __isset;

  void __set_success(const WMCreateOrUpdateMappingResponse& val);

  void __set_o1(const AlreadyExistsException& val);

  void __set_o2(const NoSuchObjectException& val);

  void __set_o3(const InvalidObjectException& val);

  void __set_o4(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_create_or_update_wm_mapping_result & ) const;

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

};

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

class ThriftHiveMetastore_create_or_update_wm_mapping_presult {
 public:


  virtual ~ThriftHiveMetastore_create_or_update_wm_mapping_presult() noexcept;
  WMCreateOrUpdateMappingResponse* success;
  AlreadyExistsException o1;
  NoSuchObjectException o2;
  InvalidObjectException o3;
  MetaException o4;

  _ThriftHiveMetastore_create_or_update_wm_mapping_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_drop_wm_mapping_args__isset {
  _ThriftHiveMetastore_drop_wm_mapping_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_drop_wm_mapping_args__isset;

class ThriftHiveMetastore_drop_wm_mapping_args {
 public:

  ThriftHiveMetastore_drop_wm_mapping_args(const ThriftHiveMetastore_drop_wm_mapping_args&);
  ThriftHiveMetastore_drop_wm_mapping_args& operator=(const ThriftHiveMetastore_drop_wm_mapping_args&);
  ThriftHiveMetastore_drop_wm_mapping_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_wm_mapping_args() noexcept;
  WMDropMappingRequest request;

  _ThriftHiveMetastore_drop_wm_mapping_args__isset __isset;

  void __set_request(const WMDropMappingRequest& val);

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

  bool operator < (const ThriftHiveMetastore_drop_wm_mapping_args & ) const;

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

};


class ThriftHiveMetastore_drop_wm_mapping_pargs {
 public:


  virtual ~ThriftHiveMetastore_drop_wm_mapping_pargs() noexcept;
  const WMDropMappingRequest* request;

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

};

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

class ThriftHiveMetastore_drop_wm_mapping_result {
 public:

  ThriftHiveMetastore_drop_wm_mapping_result(const ThriftHiveMetastore_drop_wm_mapping_result&);
  ThriftHiveMetastore_drop_wm_mapping_result& operator=(const ThriftHiveMetastore_drop_wm_mapping_result&);
  ThriftHiveMetastore_drop_wm_mapping_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_wm_mapping_result() noexcept;
  WMDropMappingResponse success;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_drop_wm_mapping_result__isset __isset;

  void __set_success(const WMDropMappingResponse& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const InvalidOperationException& val);

  void __set_o3(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_drop_wm_mapping_result & ) const;

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

};

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

class ThriftHiveMetastore_drop_wm_mapping_presult {
 public:


  virtual ~ThriftHiveMetastore_drop_wm_mapping_presult() noexcept;
  WMDropMappingResponse* success;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_drop_wm_mapping_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args__isset {
  _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args__isset() : request(false) {}
  bool request :1;
} _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args__isset;

class ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args {
 public:

  ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args(const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args&);
  ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args& operator=(const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args&);
  ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args() noexcept;
  WMCreateOrDropTriggerToPoolMappingRequest request;

  _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args__isset __isset;

  void __set_request(const WMCreateOrDropTriggerToPoolMappingRequest& val);

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

  bool operator < (const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_args & ) const;

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

};


class ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs {
 public:


  virtual ~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_pargs() noexcept;
  const WMCreateOrDropTriggerToPoolMappingRequest* request;

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

};

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

class ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result {
 public:

  ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result(const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result&);
  ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result& operator=(const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result&);
  ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result() noexcept;
  WMCreateOrDropTriggerToPoolMappingResponse success;
  AlreadyExistsException o1;
  NoSuchObjectException o2;
  InvalidObjectException o3;
  MetaException o4;

  _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result__isset __isset;

  void __set_success(const WMCreateOrDropTriggerToPoolMappingResponse& val);

  void __set_o1(const AlreadyExistsException& val);

  void __set_o2(const NoSuchObjectException& val);

  void __set_o3(const InvalidObjectException& val);

  void __set_o4(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_result & ) const;

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

};

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

class ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult {
 public:


  virtual ~ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult() noexcept;
  WMCreateOrDropTriggerToPoolMappingResponse* success;
  AlreadyExistsException o1;
  NoSuchObjectException o2;
  InvalidObjectException o3;
  MetaException o4;

  _ThriftHiveMetastore_create_or_drop_wm_trigger_to_pool_mapping_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_create_ischema_args__isset {
  _ThriftHiveMetastore_create_ischema_args__isset() : schema(false) {}
  bool schema :1;
} _ThriftHiveMetastore_create_ischema_args__isset;

class ThriftHiveMetastore_create_ischema_args {
 public:

  ThriftHiveMetastore_create_ischema_args(const ThriftHiveMetastore_create_ischema_args&);
  ThriftHiveMetastore_create_ischema_args& operator=(const ThriftHiveMetastore_create_ischema_args&);
  ThriftHiveMetastore_create_ischema_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_ischema_args() noexcept;
  ISchema schema;

  _ThriftHiveMetastore_create_ischema_args__isset __isset;

  void __set_schema(const ISchema& val);

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

  bool operator < (const ThriftHiveMetastore_create_ischema_args & ) const;

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

};


class ThriftHiveMetastore_create_ischema_pargs {
 public:


  virtual ~ThriftHiveMetastore_create_ischema_pargs() noexcept;
  const ISchema* schema;

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

};

typedef struct _ThriftHiveMetastore_create_ischema_result__isset {
  _ThriftHiveMetastore_create_ischema_result__isset() : o1(false), o2(false), o3(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_create_ischema_result__isset;

class ThriftHiveMetastore_create_ischema_result {
 public:

  ThriftHiveMetastore_create_ischema_result(const ThriftHiveMetastore_create_ischema_result&);
  ThriftHiveMetastore_create_ischema_result& operator=(const ThriftHiveMetastore_create_ischema_result&);
  ThriftHiveMetastore_create_ischema_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_create_ischema_result() noexcept;
  AlreadyExistsException o1;
  NoSuchObjectException o2;
  MetaException o3;

  _ThriftHiveMetastore_create_ischema_result__isset __isset;

  void __set_o1(const AlreadyExistsException& val);

  void __set_o2(const NoSuchObjectException& val);

  void __set_o3(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_create_ischema_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_create_ischema_presult__isset {
  _ThriftHiveMetastore_create_ischema_presult__isset() : o1(false), o2(false), o3(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_create_ischema_presult__isset;

class ThriftHiveMetastore_create_ischema_presult {
 public:


  virtual ~ThriftHiveMetastore_create_ischema_presult() noexcept;
  AlreadyExistsException o1;
  NoSuchObjectException o2;
  MetaException o3;

  _ThriftHiveMetastore_create_ischema_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_alter_ischema_args__isset {
  _ThriftHiveMetastore_alter_ischema_args__isset() : rqst(false) {}
  bool rqst :1;
} _ThriftHiveMetastore_alter_ischema_args__isset;

class ThriftHiveMetastore_alter_ischema_args {
 public:

  ThriftHiveMetastore_alter_ischema_args(const ThriftHiveMetastore_alter_ischema_args&);
  ThriftHiveMetastore_alter_ischema_args& operator=(const ThriftHiveMetastore_alter_ischema_args&);
  ThriftHiveMetastore_alter_ischema_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_ischema_args() noexcept;
  AlterISchemaRequest rqst;

  _ThriftHiveMetastore_alter_ischema_args__isset __isset;

  void __set_rqst(const AlterISchemaRequest& val);

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

  bool operator < (const ThriftHiveMetastore_alter_ischema_args & ) const;

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

};


class ThriftHiveMetastore_alter_ischema_pargs {
 public:


  virtual ~ThriftHiveMetastore_alter_ischema_pargs() noexcept;
  const AlterISchemaRequest* rqst;

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

};

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

class ThriftHiveMetastore_alter_ischema_result {
 public:

  ThriftHiveMetastore_alter_ischema_result(const ThriftHiveMetastore_alter_ischema_result&);
  ThriftHiveMetastore_alter_ischema_result& operator=(const ThriftHiveMetastore_alter_ischema_result&);
  ThriftHiveMetastore_alter_ischema_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_alter_ischema_result() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_alter_ischema_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_alter_ischema_result & ) const;

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

};

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

class ThriftHiveMetastore_alter_ischema_presult {
 public:


  virtual ~ThriftHiveMetastore_alter_ischema_presult() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_alter_ischema_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_ischema_args__isset {
  _ThriftHiveMetastore_get_ischema_args__isset() : name(false) {}
  bool name :1;
} _ThriftHiveMetastore_get_ischema_args__isset;

class ThriftHiveMetastore_get_ischema_args {
 public:

  ThriftHiveMetastore_get_ischema_args(const ThriftHiveMetastore_get_ischema_args&);
  ThriftHiveMetastore_get_ischema_args& operator=(const ThriftHiveMetastore_get_ischema_args&);
  ThriftHiveMetastore_get_ischema_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_ischema_args() noexcept;
  ISchemaName name;

  _ThriftHiveMetastore_get_ischema_args__isset __isset;

  void __set_name(const ISchemaName& val);

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

  bool operator < (const ThriftHiveMetastore_get_ischema_args & ) const;

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

};


class ThriftHiveMetastore_get_ischema_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_ischema_pargs() noexcept;
  const ISchemaName* name;

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

};

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

class ThriftHiveMetastore_get_ischema_result {
 public:

  ThriftHiveMetastore_get_ischema_result(const ThriftHiveMetastore_get_ischema_result&);
  ThriftHiveMetastore_get_ischema_result& operator=(const ThriftHiveMetastore_get_ischema_result&);
  ThriftHiveMetastore_get_ischema_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_ischema_result() noexcept;
  ISchema success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_ischema_result__isset __isset;

  void __set_success(const ISchema& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_ischema_result & ) const;

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

};

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

class ThriftHiveMetastore_get_ischema_presult {
 public:


  virtual ~ThriftHiveMetastore_get_ischema_presult() noexcept;
  ISchema* success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_ischema_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_drop_ischema_args__isset {
  _ThriftHiveMetastore_drop_ischema_args__isset() : name(false) {}
  bool name :1;
} _ThriftHiveMetastore_drop_ischema_args__isset;

class ThriftHiveMetastore_drop_ischema_args {
 public:

  ThriftHiveMetastore_drop_ischema_args(const ThriftHiveMetastore_drop_ischema_args&);
  ThriftHiveMetastore_drop_ischema_args& operator=(const ThriftHiveMetastore_drop_ischema_args&);
  ThriftHiveMetastore_drop_ischema_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_ischema_args() noexcept;
  ISchemaName name;

  _ThriftHiveMetastore_drop_ischema_args__isset __isset;

  void __set_name(const ISchemaName& val);

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

  bool operator < (const ThriftHiveMetastore_drop_ischema_args & ) const;

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

};


class ThriftHiveMetastore_drop_ischema_pargs {
 public:


  virtual ~ThriftHiveMetastore_drop_ischema_pargs() noexcept;
  const ISchemaName* name;

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

};

typedef struct _ThriftHiveMetastore_drop_ischema_result__isset {
  _ThriftHiveMetastore_drop_ischema_result__isset() : o1(false), o2(false), o3(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_drop_ischema_result__isset;

class ThriftHiveMetastore_drop_ischema_result {
 public:

  ThriftHiveMetastore_drop_ischema_result(const ThriftHiveMetastore_drop_ischema_result&);
  ThriftHiveMetastore_drop_ischema_result& operator=(const ThriftHiveMetastore_drop_ischema_result&);
  ThriftHiveMetastore_drop_ischema_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_ischema_result() noexcept;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_drop_ischema_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const InvalidOperationException& val);

  void __set_o3(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_drop_ischema_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_drop_ischema_presult__isset {
  _ThriftHiveMetastore_drop_ischema_presult__isset() : o1(false), o2(false), o3(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_drop_ischema_presult__isset;

class ThriftHiveMetastore_drop_ischema_presult {
 public:


  virtual ~ThriftHiveMetastore_drop_ischema_presult() noexcept;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_drop_ischema_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_add_schema_version_args__isset {
  _ThriftHiveMetastore_add_schema_version_args__isset() : schemaVersion(false) {}
  bool schemaVersion :1;
} _ThriftHiveMetastore_add_schema_version_args__isset;

class ThriftHiveMetastore_add_schema_version_args {
 public:

  ThriftHiveMetastore_add_schema_version_args(const ThriftHiveMetastore_add_schema_version_args&);
  ThriftHiveMetastore_add_schema_version_args& operator=(const ThriftHiveMetastore_add_schema_version_args&);
  ThriftHiveMetastore_add_schema_version_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_schema_version_args() noexcept;
  SchemaVersion schemaVersion;

  _ThriftHiveMetastore_add_schema_version_args__isset __isset;

  void __set_schemaVersion(const SchemaVersion& val);

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

  bool operator < (const ThriftHiveMetastore_add_schema_version_args & ) const;

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

};


class ThriftHiveMetastore_add_schema_version_pargs {
 public:


  virtual ~ThriftHiveMetastore_add_schema_version_pargs() noexcept;
  const SchemaVersion* schemaVersion;

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

};

typedef struct _ThriftHiveMetastore_add_schema_version_result__isset {
  _ThriftHiveMetastore_add_schema_version_result__isset() : o1(false), o2(false), o3(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_add_schema_version_result__isset;

class ThriftHiveMetastore_add_schema_version_result {
 public:

  ThriftHiveMetastore_add_schema_version_result(const ThriftHiveMetastore_add_schema_version_result&);
  ThriftHiveMetastore_add_schema_version_result& operator=(const ThriftHiveMetastore_add_schema_version_result&);
  ThriftHiveMetastore_add_schema_version_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_schema_version_result() noexcept;
  AlreadyExistsException o1;
  NoSuchObjectException o2;
  MetaException o3;

  _ThriftHiveMetastore_add_schema_version_result__isset __isset;

  void __set_o1(const AlreadyExistsException& val);

  void __set_o2(const NoSuchObjectException& val);

  void __set_o3(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_add_schema_version_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_add_schema_version_presult__isset {
  _ThriftHiveMetastore_add_schema_version_presult__isset() : o1(false), o2(false), o3(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_add_schema_version_presult__isset;

class ThriftHiveMetastore_add_schema_version_presult {
 public:


  virtual ~ThriftHiveMetastore_add_schema_version_presult() noexcept;
  AlreadyExistsException o1;
  NoSuchObjectException o2;
  MetaException o3;

  _ThriftHiveMetastore_add_schema_version_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_schema_version_args__isset {
  _ThriftHiveMetastore_get_schema_version_args__isset() : schemaVersion(false) {}
  bool schemaVersion :1;
} _ThriftHiveMetastore_get_schema_version_args__isset;

class ThriftHiveMetastore_get_schema_version_args {
 public:

  ThriftHiveMetastore_get_schema_version_args(const ThriftHiveMetastore_get_schema_version_args&);
  ThriftHiveMetastore_get_schema_version_args& operator=(const ThriftHiveMetastore_get_schema_version_args&);
  ThriftHiveMetastore_get_schema_version_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_schema_version_args() noexcept;
  SchemaVersionDescriptor schemaVersion;

  _ThriftHiveMetastore_get_schema_version_args__isset __isset;

  void __set_schemaVersion(const SchemaVersionDescriptor& val);

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

  bool operator < (const ThriftHiveMetastore_get_schema_version_args & ) const;

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

};


class ThriftHiveMetastore_get_schema_version_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_schema_version_pargs() noexcept;
  const SchemaVersionDescriptor* schemaVersion;

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

};

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

class ThriftHiveMetastore_get_schema_version_result {
 public:

  ThriftHiveMetastore_get_schema_version_result(const ThriftHiveMetastore_get_schema_version_result&);
  ThriftHiveMetastore_get_schema_version_result& operator=(const ThriftHiveMetastore_get_schema_version_result&);
  ThriftHiveMetastore_get_schema_version_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_schema_version_result() noexcept;
  SchemaVersion success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_schema_version_result__isset __isset;

  void __set_success(const SchemaVersion& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_schema_version_result & ) const;

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

};

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

class ThriftHiveMetastore_get_schema_version_presult {
 public:


  virtual ~ThriftHiveMetastore_get_schema_version_presult() noexcept;
  SchemaVersion* success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_schema_version_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_schema_latest_version_args__isset {
  _ThriftHiveMetastore_get_schema_latest_version_args__isset() : schemaName(false) {}
  bool schemaName :1;
} _ThriftHiveMetastore_get_schema_latest_version_args__isset;

class ThriftHiveMetastore_get_schema_latest_version_args {
 public:

  ThriftHiveMetastore_get_schema_latest_version_args(const ThriftHiveMetastore_get_schema_latest_version_args&);
  ThriftHiveMetastore_get_schema_latest_version_args& operator=(const ThriftHiveMetastore_get_schema_latest_version_args&);
  ThriftHiveMetastore_get_schema_latest_version_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_schema_latest_version_args() noexcept;
  ISchemaName schemaName;

  _ThriftHiveMetastore_get_schema_latest_version_args__isset __isset;

  void __set_schemaName(const ISchemaName& val);

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

  bool operator < (const ThriftHiveMetastore_get_schema_latest_version_args & ) const;

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

};


class ThriftHiveMetastore_get_schema_latest_version_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_schema_latest_version_pargs() noexcept;
  const ISchemaName* schemaName;

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

};

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

class ThriftHiveMetastore_get_schema_latest_version_result {
 public:

  ThriftHiveMetastore_get_schema_latest_version_result(const ThriftHiveMetastore_get_schema_latest_version_result&);
  ThriftHiveMetastore_get_schema_latest_version_result& operator=(const ThriftHiveMetastore_get_schema_latest_version_result&);
  ThriftHiveMetastore_get_schema_latest_version_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_schema_latest_version_result() noexcept;
  SchemaVersion success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_schema_latest_version_result__isset __isset;

  void __set_success(const SchemaVersion& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_schema_latest_version_result & ) const;

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

};

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

class ThriftHiveMetastore_get_schema_latest_version_presult {
 public:


  virtual ~ThriftHiveMetastore_get_schema_latest_version_presult() noexcept;
  SchemaVersion* success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_schema_latest_version_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_schema_all_versions_args__isset {
  _ThriftHiveMetastore_get_schema_all_versions_args__isset() : schemaName(false) {}
  bool schemaName :1;
} _ThriftHiveMetastore_get_schema_all_versions_args__isset;

class ThriftHiveMetastore_get_schema_all_versions_args {
 public:

  ThriftHiveMetastore_get_schema_all_versions_args(const ThriftHiveMetastore_get_schema_all_versions_args&);
  ThriftHiveMetastore_get_schema_all_versions_args& operator=(const ThriftHiveMetastore_get_schema_all_versions_args&);
  ThriftHiveMetastore_get_schema_all_versions_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_schema_all_versions_args() noexcept;
  ISchemaName schemaName;

  _ThriftHiveMetastore_get_schema_all_versions_args__isset __isset;

  void __set_schemaName(const ISchemaName& val);

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

  bool operator < (const ThriftHiveMetastore_get_schema_all_versions_args & ) const;

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

};


class ThriftHiveMetastore_get_schema_all_versions_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_schema_all_versions_pargs() noexcept;
  const ISchemaName* schemaName;

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

};

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

class ThriftHiveMetastore_get_schema_all_versions_result {
 public:

  ThriftHiveMetastore_get_schema_all_versions_result(const ThriftHiveMetastore_get_schema_all_versions_result&);
  ThriftHiveMetastore_get_schema_all_versions_result& operator=(const ThriftHiveMetastore_get_schema_all_versions_result&);
  ThriftHiveMetastore_get_schema_all_versions_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_schema_all_versions_result() noexcept;
  std::vector<SchemaVersion>  success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_schema_all_versions_result__isset __isset;

  void __set_success(const std::vector<SchemaVersion> & val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_schema_all_versions_result & ) const;

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

};

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

class ThriftHiveMetastore_get_schema_all_versions_presult {
 public:


  virtual ~ThriftHiveMetastore_get_schema_all_versions_presult() noexcept;
  std::vector<SchemaVersion> * success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_schema_all_versions_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_drop_schema_version_args__isset {
  _ThriftHiveMetastore_drop_schema_version_args__isset() : schemaVersion(false) {}
  bool schemaVersion :1;
} _ThriftHiveMetastore_drop_schema_version_args__isset;

class ThriftHiveMetastore_drop_schema_version_args {
 public:

  ThriftHiveMetastore_drop_schema_version_args(const ThriftHiveMetastore_drop_schema_version_args&);
  ThriftHiveMetastore_drop_schema_version_args& operator=(const ThriftHiveMetastore_drop_schema_version_args&);
  ThriftHiveMetastore_drop_schema_version_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_schema_version_args() noexcept;
  SchemaVersionDescriptor schemaVersion;

  _ThriftHiveMetastore_drop_schema_version_args__isset __isset;

  void __set_schemaVersion(const SchemaVersionDescriptor& val);

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

  bool operator < (const ThriftHiveMetastore_drop_schema_version_args & ) const;

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

};


class ThriftHiveMetastore_drop_schema_version_pargs {
 public:


  virtual ~ThriftHiveMetastore_drop_schema_version_pargs() noexcept;
  const SchemaVersionDescriptor* schemaVersion;

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

};

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

class ThriftHiveMetastore_drop_schema_version_result {
 public:

  ThriftHiveMetastore_drop_schema_version_result(const ThriftHiveMetastore_drop_schema_version_result&);
  ThriftHiveMetastore_drop_schema_version_result& operator=(const ThriftHiveMetastore_drop_schema_version_result&);
  ThriftHiveMetastore_drop_schema_version_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_drop_schema_version_result() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_drop_schema_version_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_drop_schema_version_result & ) const;

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

};

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

class ThriftHiveMetastore_drop_schema_version_presult {
 public:


  virtual ~ThriftHiveMetastore_drop_schema_version_presult() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_drop_schema_version_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_schemas_by_cols_args__isset {
  _ThriftHiveMetastore_get_schemas_by_cols_args__isset() : rqst(false) {}
  bool rqst :1;
} _ThriftHiveMetastore_get_schemas_by_cols_args__isset;

class ThriftHiveMetastore_get_schemas_by_cols_args {
 public:

  ThriftHiveMetastore_get_schemas_by_cols_args(const ThriftHiveMetastore_get_schemas_by_cols_args&);
  ThriftHiveMetastore_get_schemas_by_cols_args& operator=(const ThriftHiveMetastore_get_schemas_by_cols_args&);
  ThriftHiveMetastore_get_schemas_by_cols_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_schemas_by_cols_args() noexcept;
  FindSchemasByColsRqst rqst;

  _ThriftHiveMetastore_get_schemas_by_cols_args__isset __isset;

  void __set_rqst(const FindSchemasByColsRqst& val);

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

  bool operator < (const ThriftHiveMetastore_get_schemas_by_cols_args & ) const;

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

};


class ThriftHiveMetastore_get_schemas_by_cols_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_schemas_by_cols_pargs() noexcept;
  const FindSchemasByColsRqst* rqst;

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

};

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

class ThriftHiveMetastore_get_schemas_by_cols_result {
 public:

  ThriftHiveMetastore_get_schemas_by_cols_result(const ThriftHiveMetastore_get_schemas_by_cols_result&);
  ThriftHiveMetastore_get_schemas_by_cols_result& operator=(const ThriftHiveMetastore_get_schemas_by_cols_result&);
  ThriftHiveMetastore_get_schemas_by_cols_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_schemas_by_cols_result() noexcept;
  FindSchemasByColsResp success;
  MetaException o1;

  _ThriftHiveMetastore_get_schemas_by_cols_result__isset __isset;

  void __set_success(const FindSchemasByColsResp& val);

  void __set_o1(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_schemas_by_cols_result & ) const;

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

};

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

class ThriftHiveMetastore_get_schemas_by_cols_presult {
 public:


  virtual ~ThriftHiveMetastore_get_schemas_by_cols_presult() noexcept;
  FindSchemasByColsResp* success;
  MetaException o1;

  _ThriftHiveMetastore_get_schemas_by_cols_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_map_schema_version_to_serde_args__isset {
  _ThriftHiveMetastore_map_schema_version_to_serde_args__isset() : rqst(false) {}
  bool rqst :1;
} _ThriftHiveMetastore_map_schema_version_to_serde_args__isset;

class ThriftHiveMetastore_map_schema_version_to_serde_args {
 public:

  ThriftHiveMetastore_map_schema_version_to_serde_args(const ThriftHiveMetastore_map_schema_version_to_serde_args&);
  ThriftHiveMetastore_map_schema_version_to_serde_args& operator=(const ThriftHiveMetastore_map_schema_version_to_serde_args&);
  ThriftHiveMetastore_map_schema_version_to_serde_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_map_schema_version_to_serde_args() noexcept;
  MapSchemaVersionToSerdeRequest rqst;

  _ThriftHiveMetastore_map_schema_version_to_serde_args__isset __isset;

  void __set_rqst(const MapSchemaVersionToSerdeRequest& val);

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

  bool operator < (const ThriftHiveMetastore_map_schema_version_to_serde_args & ) const;

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

};


class ThriftHiveMetastore_map_schema_version_to_serde_pargs {
 public:


  virtual ~ThriftHiveMetastore_map_schema_version_to_serde_pargs() noexcept;
  const MapSchemaVersionToSerdeRequest* rqst;

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

};

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

class ThriftHiveMetastore_map_schema_version_to_serde_result {
 public:

  ThriftHiveMetastore_map_schema_version_to_serde_result(const ThriftHiveMetastore_map_schema_version_to_serde_result&);
  ThriftHiveMetastore_map_schema_version_to_serde_result& operator=(const ThriftHiveMetastore_map_schema_version_to_serde_result&);
  ThriftHiveMetastore_map_schema_version_to_serde_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_map_schema_version_to_serde_result() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_map_schema_version_to_serde_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_map_schema_version_to_serde_result & ) const;

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

};

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

class ThriftHiveMetastore_map_schema_version_to_serde_presult {
 public:


  virtual ~ThriftHiveMetastore_map_schema_version_to_serde_presult() noexcept;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_map_schema_version_to_serde_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_set_schema_version_state_args__isset {
  _ThriftHiveMetastore_set_schema_version_state_args__isset() : rqst(false) {}
  bool rqst :1;
} _ThriftHiveMetastore_set_schema_version_state_args__isset;

class ThriftHiveMetastore_set_schema_version_state_args {
 public:

  ThriftHiveMetastore_set_schema_version_state_args(const ThriftHiveMetastore_set_schema_version_state_args&);
  ThriftHiveMetastore_set_schema_version_state_args& operator=(const ThriftHiveMetastore_set_schema_version_state_args&);
  ThriftHiveMetastore_set_schema_version_state_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_set_schema_version_state_args() noexcept;
  SetSchemaVersionStateRequest rqst;

  _ThriftHiveMetastore_set_schema_version_state_args__isset __isset;

  void __set_rqst(const SetSchemaVersionStateRequest& val);

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

  bool operator < (const ThriftHiveMetastore_set_schema_version_state_args & ) const;

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

};


class ThriftHiveMetastore_set_schema_version_state_pargs {
 public:


  virtual ~ThriftHiveMetastore_set_schema_version_state_pargs() noexcept;
  const SetSchemaVersionStateRequest* rqst;

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

};

typedef struct _ThriftHiveMetastore_set_schema_version_state_result__isset {
  _ThriftHiveMetastore_set_schema_version_state_result__isset() : o1(false), o2(false), o3(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_set_schema_version_state_result__isset;

class ThriftHiveMetastore_set_schema_version_state_result {
 public:

  ThriftHiveMetastore_set_schema_version_state_result(const ThriftHiveMetastore_set_schema_version_state_result&);
  ThriftHiveMetastore_set_schema_version_state_result& operator=(const ThriftHiveMetastore_set_schema_version_state_result&);
  ThriftHiveMetastore_set_schema_version_state_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_set_schema_version_state_result() noexcept;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_set_schema_version_state_result__isset __isset;

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const InvalidOperationException& val);

  void __set_o3(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_set_schema_version_state_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_set_schema_version_state_presult__isset {
  _ThriftHiveMetastore_set_schema_version_state_presult__isset() : o1(false), o2(false), o3(false) {}
  bool o1 :1;
  bool o2 :1;
  bool o3 :1;
} _ThriftHiveMetastore_set_schema_version_state_presult__isset;

class ThriftHiveMetastore_set_schema_version_state_presult {
 public:


  virtual ~ThriftHiveMetastore_set_schema_version_state_presult() noexcept;
  NoSuchObjectException o1;
  InvalidOperationException o2;
  MetaException o3;

  _ThriftHiveMetastore_set_schema_version_state_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_add_serde_args__isset {
  _ThriftHiveMetastore_add_serde_args__isset() : serde(false) {}
  bool serde :1;
} _ThriftHiveMetastore_add_serde_args__isset;

class ThriftHiveMetastore_add_serde_args {
 public:

  ThriftHiveMetastore_add_serde_args(const ThriftHiveMetastore_add_serde_args&);
  ThriftHiveMetastore_add_serde_args& operator=(const ThriftHiveMetastore_add_serde_args&);
  ThriftHiveMetastore_add_serde_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_serde_args() noexcept;
  SerDeInfo serde;

  _ThriftHiveMetastore_add_serde_args__isset __isset;

  void __set_serde(const SerDeInfo& val);

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

  bool operator < (const ThriftHiveMetastore_add_serde_args & ) const;

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

};


class ThriftHiveMetastore_add_serde_pargs {
 public:


  virtual ~ThriftHiveMetastore_add_serde_pargs() noexcept;
  const SerDeInfo* serde;

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

};

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

class ThriftHiveMetastore_add_serde_result {
 public:

  ThriftHiveMetastore_add_serde_result(const ThriftHiveMetastore_add_serde_result&);
  ThriftHiveMetastore_add_serde_result& operator=(const ThriftHiveMetastore_add_serde_result&);
  ThriftHiveMetastore_add_serde_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_serde_result() noexcept;
  AlreadyExistsException o1;
  MetaException o2;

  _ThriftHiveMetastore_add_serde_result__isset __isset;

  void __set_o1(const AlreadyExistsException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_add_serde_result & ) const;

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

};

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

class ThriftHiveMetastore_add_serde_presult {
 public:


  virtual ~ThriftHiveMetastore_add_serde_presult() noexcept;
  AlreadyExistsException o1;
  MetaException o2;

  _ThriftHiveMetastore_add_serde_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_serde_args__isset {
  _ThriftHiveMetastore_get_serde_args__isset() : rqst(false) {}
  bool rqst :1;
} _ThriftHiveMetastore_get_serde_args__isset;

class ThriftHiveMetastore_get_serde_args {
 public:

  ThriftHiveMetastore_get_serde_args(const ThriftHiveMetastore_get_serde_args&);
  ThriftHiveMetastore_get_serde_args& operator=(const ThriftHiveMetastore_get_serde_args&);
  ThriftHiveMetastore_get_serde_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_serde_args() noexcept;
  GetSerdeRequest rqst;

  _ThriftHiveMetastore_get_serde_args__isset __isset;

  void __set_rqst(const GetSerdeRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_serde_args & ) const;

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

};


class ThriftHiveMetastore_get_serde_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_serde_pargs() noexcept;
  const GetSerdeRequest* rqst;

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

};

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

class ThriftHiveMetastore_get_serde_result {
 public:

  ThriftHiveMetastore_get_serde_result(const ThriftHiveMetastore_get_serde_result&);
  ThriftHiveMetastore_get_serde_result& operator=(const ThriftHiveMetastore_get_serde_result&);
  ThriftHiveMetastore_get_serde_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_serde_result() noexcept;
  SerDeInfo success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_serde_result__isset __isset;

  void __set_success(const SerDeInfo& val);

  void __set_o1(const NoSuchObjectException& val);

  void __set_o2(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_serde_result & ) const;

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

};

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

class ThriftHiveMetastore_get_serde_presult {
 public:


  virtual ~ThriftHiveMetastore_get_serde_presult() noexcept;
  SerDeInfo* success;
  NoSuchObjectException o1;
  MetaException o2;

  _ThriftHiveMetastore_get_serde_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_lock_materialization_rebuild_args__isset {
  _ThriftHiveMetastore_get_lock_materialization_rebuild_args__isset() : dbName(false), tableName(false), txnId(false) {}
  bool dbName :1;
  bool tableName :1;
  bool txnId :1;
} _ThriftHiveMetastore_get_lock_materialization_rebuild_args__isset;

class ThriftHiveMetastore_get_lock_materialization_rebuild_args {
 public:

  ThriftHiveMetastore_get_lock_materialization_rebuild_args(const ThriftHiveMetastore_get_lock_materialization_rebuild_args&);
  ThriftHiveMetastore_get_lock_materialization_rebuild_args& operator=(const ThriftHiveMetastore_get_lock_materialization_rebuild_args&);
  ThriftHiveMetastore_get_lock_materialization_rebuild_args() noexcept
                                                            : dbName(),
                                                              tableName(),
                                                              txnId(0) {
  }

  virtual ~ThriftHiveMetastore_get_lock_materialization_rebuild_args() noexcept;
  std::string dbName;
  std::string tableName;
  int64_t txnId;

  _ThriftHiveMetastore_get_lock_materialization_rebuild_args__isset __isset;

  void __set_dbName(const std::string& val);

  void __set_tableName(const std::string& val);

  void __set_txnId(const int64_t val);

  bool operator == (const ThriftHiveMetastore_get_lock_materialization_rebuild_args & rhs) const
  {
    if (!(dbName == rhs.dbName))
      return false;
    if (!(tableName == rhs.tableName))
      return false;
    if (!(txnId == rhs.txnId))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_get_lock_materialization_rebuild_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_get_lock_materialization_rebuild_args & ) const;

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

};


class ThriftHiveMetastore_get_lock_materialization_rebuild_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_lock_materialization_rebuild_pargs() noexcept;
  const std::string* dbName;
  const std::string* tableName;
  const int64_t* txnId;

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

};

typedef struct _ThriftHiveMetastore_get_lock_materialization_rebuild_result__isset {
  _ThriftHiveMetastore_get_lock_materialization_rebuild_result__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_get_lock_materialization_rebuild_result__isset;

class ThriftHiveMetastore_get_lock_materialization_rebuild_result {
 public:

  ThriftHiveMetastore_get_lock_materialization_rebuild_result(const ThriftHiveMetastore_get_lock_materialization_rebuild_result&) noexcept;
  ThriftHiveMetastore_get_lock_materialization_rebuild_result& operator=(const ThriftHiveMetastore_get_lock_materialization_rebuild_result&) noexcept;
  ThriftHiveMetastore_get_lock_materialization_rebuild_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_lock_materialization_rebuild_result() noexcept;
  LockResponse success;

  _ThriftHiveMetastore_get_lock_materialization_rebuild_result__isset __isset;

  void __set_success(const LockResponse& val);

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

  bool operator < (const ThriftHiveMetastore_get_lock_materialization_rebuild_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_get_lock_materialization_rebuild_presult__isset {
  _ThriftHiveMetastore_get_lock_materialization_rebuild_presult__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_get_lock_materialization_rebuild_presult__isset;

class ThriftHiveMetastore_get_lock_materialization_rebuild_presult {
 public:


  virtual ~ThriftHiveMetastore_get_lock_materialization_rebuild_presult() noexcept;
  LockResponse* success;

  _ThriftHiveMetastore_get_lock_materialization_rebuild_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args__isset {
  _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args__isset() : dbName(false), tableName(false), txnId(false) {}
  bool dbName :1;
  bool tableName :1;
  bool txnId :1;
} _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args__isset;

class ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args {
 public:

  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args(const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args&);
  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args& operator=(const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args&);
  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args() noexcept
                                                                  : dbName(),
                                                                    tableName(),
                                                                    txnId(0) {
  }

  virtual ~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args() noexcept;
  std::string dbName;
  std::string tableName;
  int64_t txnId;

  _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args__isset __isset;

  void __set_dbName(const std::string& val);

  void __set_tableName(const std::string& val);

  void __set_txnId(const int64_t val);

  bool operator == (const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args & rhs) const
  {
    if (!(dbName == rhs.dbName))
      return false;
    if (!(tableName == rhs.tableName))
      return false;
    if (!(txnId == rhs.txnId))
      return false;
    return true;
  }
  bool operator != (const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args &rhs) const {
    return !(*this == rhs);
  }

  bool operator < (const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_args & ) const;

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

};


class ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs {
 public:


  virtual ~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_pargs() noexcept;
  const std::string* dbName;
  const std::string* tableName;
  const int64_t* txnId;

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

};

typedef struct _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result__isset {
  _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result__isset;

class ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result {
 public:

  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result(const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result&) noexcept;
  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result& operator=(const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result&) noexcept;
  ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result() noexcept
                                                                    : success(0) {
  }

  virtual ~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result() noexcept;
  bool success;

  _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result__isset __isset;

  void __set_success(const bool val);

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

  bool operator < (const ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult__isset {
  _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult__isset() : success(false) {}
  bool success :1;
} _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult__isset;

class ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult {
 public:


  virtual ~ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult() noexcept;
  bool* success;

  _ThriftHiveMetastore_heartbeat_lock_materialization_rebuild_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_add_runtime_stats_args__isset {
  _ThriftHiveMetastore_add_runtime_stats_args__isset() : stat(false) {}
  bool stat :1;
} _ThriftHiveMetastore_add_runtime_stats_args__isset;

class ThriftHiveMetastore_add_runtime_stats_args {
 public:

  ThriftHiveMetastore_add_runtime_stats_args(const ThriftHiveMetastore_add_runtime_stats_args&);
  ThriftHiveMetastore_add_runtime_stats_args& operator=(const ThriftHiveMetastore_add_runtime_stats_args&);
  ThriftHiveMetastore_add_runtime_stats_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_runtime_stats_args() noexcept;
  RuntimeStat stat;

  _ThriftHiveMetastore_add_runtime_stats_args__isset __isset;

  void __set_stat(const RuntimeStat& val);

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

  bool operator < (const ThriftHiveMetastore_add_runtime_stats_args & ) const;

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

};


class ThriftHiveMetastore_add_runtime_stats_pargs {
 public:


  virtual ~ThriftHiveMetastore_add_runtime_stats_pargs() noexcept;
  const RuntimeStat* stat;

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

};

typedef struct _ThriftHiveMetastore_add_runtime_stats_result__isset {
  _ThriftHiveMetastore_add_runtime_stats_result__isset() : o1(false) {}
  bool o1 :1;
} _ThriftHiveMetastore_add_runtime_stats_result__isset;

class ThriftHiveMetastore_add_runtime_stats_result {
 public:

  ThriftHiveMetastore_add_runtime_stats_result(const ThriftHiveMetastore_add_runtime_stats_result&);
  ThriftHiveMetastore_add_runtime_stats_result& operator=(const ThriftHiveMetastore_add_runtime_stats_result&);
  ThriftHiveMetastore_add_runtime_stats_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_add_runtime_stats_result() noexcept;
  MetaException o1;

  _ThriftHiveMetastore_add_runtime_stats_result__isset __isset;

  void __set_o1(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_add_runtime_stats_result & ) const;

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

};

typedef struct _ThriftHiveMetastore_add_runtime_stats_presult__isset {
  _ThriftHiveMetastore_add_runtime_stats_presult__isset() : o1(false) {}
  bool o1 :1;
} _ThriftHiveMetastore_add_runtime_stats_presult__isset;

class ThriftHiveMetastore_add_runtime_stats_presult {
 public:


  virtual ~ThriftHiveMetastore_add_runtime_stats_presult() noexcept;
  MetaException o1;

  _ThriftHiveMetastore_add_runtime_stats_presult__isset __isset;

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

};

typedef struct _ThriftHiveMetastore_get_runtime_stats_args__isset {
  _ThriftHiveMetastore_get_runtime_stats_args__isset() : rqst(false) {}
  bool rqst :1;
} _ThriftHiveMetastore_get_runtime_stats_args__isset;

class ThriftHiveMetastore_get_runtime_stats_args {
 public:

  ThriftHiveMetastore_get_runtime_stats_args(const ThriftHiveMetastore_get_runtime_stats_args&) noexcept;
  ThriftHiveMetastore_get_runtime_stats_args& operator=(const ThriftHiveMetastore_get_runtime_stats_args&) noexcept;
  ThriftHiveMetastore_get_runtime_stats_args() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_runtime_stats_args() noexcept;
  GetRuntimeStatsRequest rqst;

  _ThriftHiveMetastore_get_runtime_stats_args__isset __isset;

  void __set_rqst(const GetRuntimeStatsRequest& val);

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

  bool operator < (const ThriftHiveMetastore_get_runtime_stats_args & ) const;

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

};


class ThriftHiveMetastore_get_runtime_stats_pargs {
 public:


  virtual ~ThriftHiveMetastore_get_runtime_stats_pargs() noexcept;
  const GetRuntimeStatsRequest* rqst;

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

};

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

class ThriftHiveMetastore_get_runtime_stats_result {
 public:

  ThriftHiveMetastore_get_runtime_stats_result(const ThriftHiveMetastore_get_runtime_stats_result&);
  ThriftHiveMetastore_get_runtime_stats_result& operator=(const ThriftHiveMetastore_get_runtime_stats_result&);
  ThriftHiveMetastore_get_runtime_stats_result() noexcept {
  }

  virtual ~ThriftHiveMetastore_get_runtime_stats_result() noexcept;
  std::vector<RuntimeStat>  success;
  MetaException o1;

  _ThriftHiveMetastore_get_runtime_stats_result__isset __isset;

  void __set_success(const std::vector<RuntimeStat> & val);

  void __set_o1(const MetaException& val);

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

  bool operator < (const ThriftHiveMetastore_get_runtime_stats_result & ) const;

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

};

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

class ThriftHiveMetastore_get_runtime_stats_presult {
 public:


  virtual ~ThriftHiveMetastore_get_runtime_stats_presult() noexcept;
  std::vector<RuntimeStat> * success;
  MetaException o1;

  _ThriftHiveMetastore_get_runtime_stats_presult__isset __isset;

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

};

class ThriftHiveMetastoreClient : virtual public ThriftHiveMetastoreIf, public  ::facebook::fb303::FacebookServiceClient {
 public:
  ThriftHiveMetastoreClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot) :
     ::facebook::fb303::FacebookServiceClient(prot, prot) {}
  ThriftHiveMetastoreClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot) :     ::facebook::fb303::FacebookServiceClient(iprot, oprot) {}
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  void getMetaConf(std::string& _return, const std::string& key) override;
  void send_getMetaConf(const std::string& key);
  void recv_getMetaConf(std::string& _return);
  void setMetaConf(const std::string& key, const std::string& value) override;
  void send_setMetaConf(const std::string& key, const std::string& value);
  void recv_setMetaConf();
  bool init_schema(const std::string& dbType, const std::string& username, const std::string& password) override;
  void send_init_schema(const std::string& dbType, const std::string& username, const std::string& password);
  bool recv_init_schema();
  void create_catalog(const CreateCatalogRequest& catalog) override;
  void send_create_catalog(const CreateCatalogRequest& catalog);
  void recv_create_catalog();
  void alter_catalog(const AlterCatalogRequest& rqst) override;
  void send_alter_catalog(const AlterCatalogRequest& rqst);
  void recv_alter_catalog();
  void get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName) override;
  void send_get_catalog(const GetCatalogRequest& catName);
  void recv_get_catalog(GetCatalogResponse& _return);
  void get_catalogs(GetCatalogsResponse& _return) override;
  void send_get_catalogs();
  void recv_get_catalogs(GetCatalogsResponse& _return);
  void drop_catalog(const DropCatalogRequest& catName) override;
  void send_drop_catalog(const DropCatalogRequest& catName);
  void recv_drop_catalog();
  void create_database(const Database& database) override;
  void send_create_database(const Database& database);
  void recv_create_database();
  void get_database(Database& _return, const std::string& name) override;
  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) override;
  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) override;
  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) override;
  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) override;
  void send_alter_database(const std::string& dbname, const Database& db);
  void recv_alter_database();
  void get_type(Type& _return, const std::string& name) override;
  void send_get_type(const std::string& name);
  void recv_get_type(Type& _return);
  bool create_type(const Type& type) override;
  void send_create_type(const Type& type);
  bool recv_create_type();
  bool drop_type(const std::string& type) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  void send_create_table(const Table& tbl);
  void recv_create_table();
  void create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context) override;
  void send_create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context);
  void recv_create_table_with_environment_context();
  void create_table_with_constraints(const Table& tbl, const std::vector<SQLPrimaryKey> & primaryKeys, const std::vector<SQLForeignKey> & foreignKeys, const std::vector<SQLUniqueConstraint> & uniqueConstraints, const std::vector<SQLNotNullConstraint> & notNullConstraints, const std::vector<SQLDefaultConstraint> & defaultConstraints, const std::vector<SQLCheckConstraint> & checkConstraints) override;
  void send_create_table_with_constraints(const Table& tbl, const std::vector<SQLPrimaryKey> & primaryKeys, const std::vector<SQLForeignKey> & foreignKeys, const std::vector<SQLUniqueConstraint> & uniqueConstraints, const std::vector<SQLNotNullConstraint> & notNullConstraints, const std::vector<SQLDefaultConstraint> & defaultConstraints, const std::vector<SQLCheckConstraint> & checkConstraints);
  void recv_create_table_with_constraints();
  void drop_constraint(const DropConstraintRequest& req) override;
  void send_drop_constraint(const DropConstraintRequest& req);
  void recv_drop_constraint();
  void add_primary_key(const AddPrimaryKeyRequest& req) override;
  void send_add_primary_key(const AddPrimaryKeyRequest& req);
  void recv_add_primary_key();
  void add_foreign_key(const AddForeignKeyRequest& req) override;
  void send_add_foreign_key(const AddForeignKeyRequest& req);
  void recv_add_foreign_key();
  void add_unique_constraint(const AddUniqueConstraintRequest& req) override;
  void send_add_unique_constraint(const AddUniqueConstraintRequest& req);
  void recv_add_unique_constraint();
  void add_not_null_constraint(const AddNotNullConstraintRequest& req) override;
  void send_add_not_null_constraint(const AddNotNullConstraintRequest& req);
  void recv_add_not_null_constraint();
  void add_default_constraint(const AddDefaultConstraintRequest& req) override;
  void send_add_default_constraint(const AddDefaultConstraintRequest& req);
  void recv_add_default_constraint();
  void add_check_constraint(const AddCheckConstraintRequest& req) override;
  void send_add_check_constraint(const AddCheckConstraintRequest& req);
  void recv_add_check_constraint();
  void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) override;
  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) override;
  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 truncate_table(const std::string& dbName, const std::string& tableName, const std::vector<std::string> & partNames) override;
  void send_truncate_table(const std::string& dbName, const std::string& tableName, const std::vector<std::string> & partNames);
  void recv_truncate_table();
  void get_tables(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern) override;
  void send_get_tables(const std::string& db_name, const std::string& pattern);
  void recv_get_tables(std::vector<std::string> & _return);
  void get_tables_by_type(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType) override;
  void send_get_tables_by_type(const std::string& db_name, const std::string& pattern, const std::string& tableType);
  void recv_get_tables_by_type(std::vector<std::string> & _return);
  void get_materialized_views_for_rewriting(std::vector<std::string> & _return, const std::string& db_name) override;
  void send_get_materialized_views_for_rewriting(const std::string& db_name);
  void recv_get_materialized_views_for_rewriting(std::vector<std::string> & _return);
  void get_table_meta(std::vector<TableMeta> & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector<std::string> & tbl_types) override;
  void send_get_table_meta(const std::string& db_patterns, const std::string& tbl_patterns, const std::vector<std::string> & tbl_types);
  void recv_get_table_meta(std::vector<TableMeta> & _return);
  void get_all_tables(std::vector<std::string> & _return, const std::string& db_name) override;
  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) override;
  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) override;
  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_req(GetTableResult& _return, const GetTableRequest& req) override;
  void send_get_table_req(const GetTableRequest& req);
  void recv_get_table_req(GetTableResult& _return);
  void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req) override;
  void send_get_table_objects_by_name_req(const GetTablesRequest& req);
  void recv_get_table_objects_by_name_req(GetTablesResult& _return);
  void get_materialization_invalidation_info(Materialization& _return, const CreationMetadata& creation_metadata, const std::string& validTxnList) override;
  void send_get_materialization_invalidation_info(const CreationMetadata& creation_metadata, const std::string& validTxnList);
  void recv_get_materialization_invalidation_info(Materialization& _return);
  void update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) override;
  void send_update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata);
  void recv_update_creation_metadata();
  void get_table_names_by_filter(std::vector<std::string> & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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 exchange_partitions(std::vector<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) override;
  void send_exchange_partitions(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_partitions(std::vector<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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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_partition_values(PartitionValuesResponse& _return, const PartitionValuesRequest& request) override;
  void send_get_partition_values(const PartitionValuesRequest& request);
  void recv_get_partition_values(PartitionValuesResponse& _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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  void send_get_partitions_by_expr(const PartitionsByExprRequest& req);
  void recv_get_partitions_by_expr(PartitionsByExprResult& _return);
  int32_t get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter) override;
  void send_get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter);
  int32_t recv_get_num_partitions_by_filter();
  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) override;
  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) override;
  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) override;
  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_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts, const EnvironmentContext& environment_context) override;
  void send_alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts, const EnvironmentContext& environment_context);
  void recv_alter_partitions_with_environment_context();
  void alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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 get_primary_keys(PrimaryKeysResponse& _return, const PrimaryKeysRequest& request) override;
  void send_get_primary_keys(const PrimaryKeysRequest& request);
  void recv_get_primary_keys(PrimaryKeysResponse& _return);
  void get_foreign_keys(ForeignKeysResponse& _return, const ForeignKeysRequest& request) override;
  void send_get_foreign_keys(const ForeignKeysRequest& request);
  void recv_get_foreign_keys(ForeignKeysResponse& _return);
  void get_unique_constraints(UniqueConstraintsResponse& _return, const UniqueConstraintsRequest& request) override;
  void send_get_unique_constraints(const UniqueConstraintsRequest& request);
  void recv_get_unique_constraints(UniqueConstraintsResponse& _return);
  void get_not_null_constraints(NotNullConstraintsResponse& _return, const NotNullConstraintsRequest& request) override;
  void send_get_not_null_constraints(const NotNullConstraintsRequest& request);
  void recv_get_not_null_constraints(NotNullConstraintsResponse& _return);
  void get_default_constraints(DefaultConstraintsResponse& _return, const DefaultConstraintsRequest& request) override;
  void send_get_default_constraints(const DefaultConstraintsRequest& request);
  void recv_get_default_constraints(DefaultConstraintsResponse& _return);
  void get_check_constraints(CheckConstraintsResponse& _return, const CheckConstraintsRequest& request) override;
  void send_get_check_constraints(const CheckConstraintsRequest& request);
  void recv_get_check_constraints(CheckConstraintsResponse& _return);
  bool update_table_column_statistics(const ColumnStatistics& stats_obj) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  void send_create_function(const Function& func);
  void recv_create_function();
  void drop_function(const std::string& dbName, const std::string& funcName) override;
  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) override;
  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) override;
  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) override;
  void send_get_function(const std::string& dbName, const std::string& funcName);
  void recv_get_function(Function& _return);
  void get_all_functions(GetAllFunctionsResponse& _return) override;
  void send_get_all_functions();
  void recv_get_all_functions(GetAllFunctionsResponse& _return);
  bool create_role(const Role& role) override;
  void send_create_role(const Role& role);
  bool recv_create_role();
  bool drop_role(const std::string& role_name) override;
  void send_drop_role(const std::string& role_name);
  bool recv_drop_role();
  void get_role_names(std::vector<std::string> & _return) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  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) override;
  void send_grant_privileges(const PrivilegeBag& privileges);
  bool recv_grant_privileges();
  bool revoke_privileges(const PrivilegeBag& privileges) override;
  void send_revoke_privileges(const PrivilegeBag& privileges);
  bool recv_revoke_privileges();
  void grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const GrantRevokePrivilegeRequest& request) override;
  void send_grant_revoke_privileges(const GrantRevokePrivilegeRequest& request);
  void recv_grant_revoke_privileges(GrantRevokePrivilegeResponse& _return);
  void refresh_privileges(GrantRevokePrivilegeResponse& _return, const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest) override;
  void send_refresh_privileges(const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest);
  void recv_refresh_privileges(GrantRevokePrivilegeResponse& _return);
  void set_ugi(std::vector<std::string> & _return, const std::string& user_name, const std::vector<std::string> & group_names) override;
  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) override;
  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) override;
  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) override;
  void send_cancel_delegation_token(const std::string& token_str_form);
  void recv_cancel_delegation_token();
  bool add_token(const std::string& token_identifier, const std::string& delegation_token) override;
  void send_add_token(const std::string& token_identifier, const std::string& delegation_token);
  bool recv_add_token();
  bool remove_token(const std::string& token_identifier) override;
  void send_remove_token(const std::string& token_identifier);
  bool recv_remove_token();
  void get_token(std::string& _return, const std::string& token_identifier) override;
  void send_get_token(const std::string& token_identifier);
  void recv_get_token(std::string& _return);
  void get_all_token_identifiers(std::vector<std::string> & _return) override;
  void send_get_all_token_identifiers();
  void recv_get_all_token_identifiers(std::vector<std::string> & _return);
  int32_t add_master_key(const std::string& key) override;
  void send_add_master_key(const std::string& key);
  int32_t recv_add_master_key();
  void update_master_key(const int32_t seq_number, const std::string& key) override;
  void send_update_master_key(const int32_t seq_number, const std::string& key);
  void recv_update_master_key();
  bool remove_master_key(const int32_t key_seq) override;
  void send_remove_master_key(const int32_t key_seq);
  bool recv_remove_master_key();
  void get_master_keys(std::vector<std::string> & _return) override;
  void send_get_master_keys();
  void recv_get_master_keys(std::vector<std::string> & _return);
  void get_open_txns(GetOpenTxnsResponse& _return) override;
  void send_get_open_txns();
  void recv_get_open_txns(GetOpenTxnsResponse& _return);
  void get_open_txns_info(GetOpenTxnsInfoResponse& _return) override;
  void send_get_open_txns_info();
  void recv_get_open_txns_info(GetOpenTxnsInfoResponse& _return);
  void open_txns(OpenTxnsResponse& _return, const OpenTxnRequest& rqst) override;
  void send_open_txns(const OpenTxnRequest& rqst);
  void recv_open_txns(OpenTxnsResponse& _return);
  void abort_txn(const AbortTxnRequest& rqst) override;
  void send_abort_txn(const AbortTxnRequest& rqst);
  void recv_abort_txn();
  void abort_txns(const AbortTxnsRequest& rqst) override;
  void send_abort_txns(const AbortTxnsRequest& rqst);
  void recv_abort_txns();
  void commit_txn(const CommitTxnRequest& rqst) override;
  void send_commit_txn(const CommitTxnRequest& rqst);
  void recv_commit_txn();
  void repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst) override;
  void send_repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst);
  void recv_repl_tbl_writeid_state();
  void get_valid_write_ids(GetValidWriteIdsResponse& _return, const GetValidWriteIdsRequest& rqst) override;
  void send_get_valid_write_ids(const GetValidWriteIdsRequest& rqst);
  void recv_get_valid_write_ids(GetValidWriteIdsResponse& _return);
  void allocate_table_write_ids(AllocateTableWriteIdsResponse& _return, const AllocateTableWriteIdsRequest& rqst) override;
  void send_allocate_table_write_ids(const AllocateTableWriteIdsRequest& rqst);
  void recv_allocate_table_write_ids(AllocateTableWriteIdsResponse& _return);
  void lock(LockResponse& _return, const LockRequest& rqst) override;
  void send_lock(const LockRequest& rqst);
  void recv_lock(LockResponse& _return);
  void check_lock(LockResponse& _return, const CheckLockRequest& rqst) override;
  void send_check_lock(const CheckLockRequest& rqst);
  void recv_check_lock(LockResponse& _return);
  void unlock(const UnlockRequest& rqst) override;
  void send_unlock(const UnlockRequest& rqst);
  void recv_unlock();
  void show_locks(ShowLocksResponse& _return, const ShowLocksRequest& rqst) override;
  void send_show_locks(const ShowLocksRequest& rqst);
  void recv_show_locks(ShowLocksResponse& _return);
  void heartbeat(const HeartbeatRequest& ids) override;
  void send_heartbeat(const HeartbeatRequest& ids);
  void recv_heartbeat();
  void heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) override;
  void send_heartbeat_txn_range(const HeartbeatTxnRangeRequest& txns);
  void recv_heartbeat_txn_range(HeartbeatTxnRangeResponse& _return);
  void compact(const CompactionRequest& rqst) override;
  void send_compact(const CompactionRequest& rqst);
  void recv_compact();
  void compact2(CompactionResponse& _return, const CompactionRequest& rqst) override;
  void send_compact2(const CompactionRequest& rqst);
  void recv_compact2(CompactionResponse& _return);
  void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) override;
  void send_show_compact(const ShowCompactRequest& rqst);
  void recv_show_compact(ShowCompactResponse& _return);
  void add_dynamic_partitions(const AddDynamicPartitions& rqst) override;
  void send_add_dynamic_partitions(const AddDynamicPartitions& rqst);
  void recv_add_dynamic_partitions();
  void get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) override;
  void send_get_next_notification(const NotificationEventRequest& rqst);
  void recv_get_next_notification(NotificationEventResponse& _return);
  void get_current_notificationEventId(CurrentNotificationEventId& _return) override;
  void send_get_current_notificationEventId();
  void recv_get_current_notificationEventId(CurrentNotificationEventId& _return);
  void get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) override;
  void send_get_notification_events_count(const NotificationEventsCountRequest& rqst);
  void recv_get_notification_events_count(NotificationEventsCountResponse& _return);
  void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) override;
  void send_fire_listener_event(const FireEventRequest& rqst);
  void recv_fire_listener_event(FireEventResponse& _return);
  void flushCache() override;
  void send_flushCache();
  void recv_flushCache();
  void cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) override;
  void send_cm_recycle(const CmRecycleRequest& request);
  void recv_cm_recycle(CmRecycleResponse& _return);
  void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) override;
  void send_get_file_metadata_by_expr(const GetFileMetadataByExprRequest& req);
  void recv_get_file_metadata_by_expr(GetFileMetadataByExprResult& _return);
  void get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) override;
  void send_get_file_metadata(const GetFileMetadataRequest& req);
  void recv_get_file_metadata(GetFileMetadataResult& _return);
  void put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) override;
  void send_put_file_metadata(const PutFileMetadataRequest& req);
  void recv_put_file_metadata(PutFileMetadataResult& _return);
  void clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) override;
  void send_clear_file_metadata(const ClearFileMetadataRequest& req);
  void recv_clear_file_metadata(ClearFileMetadataResult& _return);
  void cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req) override;
  void send_cache_file_metadata(const CacheFileMetadataRequest& req);
  void recv_cache_file_metadata(CacheFileMetadataResult& _return);
  void get_metastore_db_uuid(std::string& _return) override;
  void send_get_metastore_db_uuid();
  void recv_get_metastore_db_uuid(std::string& _return);
  void create_resource_plan(WMCreateResourcePlanResponse& _return, const WMCreateResourcePlanRequest& request) override;
  void send_create_resource_plan(const WMCreateResourcePlanRequest& request);
  void recv_create_resource_plan(WMCreateResourcePlanResponse& _return);
  void get_resource_plan(WMGetResourcePlanResponse& _return, const WMGetResourcePlanRequest& request) override;
  void send_get_resource_plan(const WMGetResourcePlanRequest& request);
  void recv_get_resource_plan(WMGetResourcePlanResponse& _return);
  void get_active_resource_plan(WMGetActiveResourcePlanResponse& _return, const WMGetActiveResourcePlanRequest& request) override;
  void send_get_active_resource_plan(const WMGetActiveResourcePlanRequest& request);
  void recv_get_active_resource_plan(WMGetActiveResourcePlanResponse& _return);
  void get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const WMGetAllResourcePlanRequest& request) override;
  void send_get_all_resource_plans(const WMGetAllResourcePlanRequest& request);
  void recv_get_all_resource_plans(WMGetAllResourcePlanResponse& _return);
  void alter_resource_plan(WMAlterResourcePlanResponse& _return, const WMAlterResourcePlanRequest& request) override;
  void send_alter_resource_plan(const WMAlterResourcePlanRequest& request);
  void recv_alter_resource_plan(WMAlterResourcePlanResponse& _return);
  void validate_resource_plan(WMValidateResourcePlanResponse& _return, const WMValidateResourcePlanRequest& request) override;
  void send_validate_resource_plan(const WMValidateResourcePlanRequest& request);
  void recv_validate_resource_plan(WMValidateResourcePlanResponse& _return);
  void drop_resource_plan(WMDropResourcePlanResponse& _return, const WMDropResourcePlanRequest& request) override;
  void send_drop_resource_plan(const WMDropResourcePlanRequest& request);
  void recv_drop_resource_plan(WMDropResourcePlanResponse& _return);
  void create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) override;
  void send_create_wm_trigger(const WMCreateTriggerRequest& request);
  void recv_create_wm_trigger(WMCreateTriggerResponse& _return);
  void alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) override;
  void send_alter_wm_trigger(const WMAlterTriggerRequest& request);
  void recv_alter_wm_trigger(WMAlterTriggerResponse& _return);
  void drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) override;
  void send_drop_wm_trigger(const WMDropTriggerRequest& request);
  void recv_drop_wm_trigger(WMDropTriggerResponse& _return);
  void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) override;
  void send_get_triggers_for_resourceplan(const WMGetTriggersForResourePlanRequest& request);
  void recv_get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return);
  void create_wm_pool(WMCreatePoolResponse& _return, const WMCreatePoolRequest& request) override;
  void send_create_wm_pool(const WMCreatePoolRequest& request);
  void recv_create_wm_pool(WMCreatePoolResponse& _return);
  void alter_wm_pool(WMAlterPoolResponse& _return, const WMAlterPoolRequest& request) override;
  void send_alter_wm_pool(const WMAlterPoolRequest& request);
  void recv_alter_wm_pool(WMAlterPoolResponse& _return);
  void drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request) override;
  void send_drop_wm_pool(const WMDropPoolRequest& request);
  void recv_drop_wm_pool(WMDropPoolResponse& _return);
  void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) override;
  void send_create_or_update_wm_mapping(const WMCreateOrUpdateMappingRequest& request);
  void recv_create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return);
  void drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) override;
  void send_drop_wm_mapping(const WMDropMappingRequest& request);
  void recv_drop_wm_mapping(WMDropMappingResponse& _return);
  void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) override;
  void send_create_or_drop_wm_trigger_to_pool_mapping(const WMCreateOrDropTriggerToPoolMappingRequest& request);
  void recv_create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return);
  void create_ischema(const ISchema& schema) override;
  void send_create_ischema(const ISchema& schema);
  void recv_create_ischema();
  void alter_ischema(const AlterISchemaRequest& rqst) override;
  void send_alter_ischema(const AlterISchemaRequest& rqst);
  void recv_alter_ischema();
  void get_ischema(ISchema& _return, const ISchemaName& name) override;
  void send_get_ischema(const ISchemaName& name);
  void recv_get_ischema(ISchema& _return);
  void drop_ischema(const ISchemaName& name) override;
  void send_drop_ischema(const ISchemaName& name);
  void recv_drop_ischema();
  void add_schema_version(const SchemaVersion& schemaVersion) override;
  void send_add_schema_version(const SchemaVersion& schemaVersion);
  void recv_add_schema_version();
  void get_schema_version(SchemaVersion& _return, const SchemaVersionDescriptor& schemaVersion) override;
  void send_get_schema_version(const SchemaVersionDescriptor& schemaVersion);
  void recv_get_schema_version(SchemaVersion& _return);
  void get_schema_latest_version(SchemaVersion& _return, const ISchemaName& schemaName) override;
  void send_get_schema_latest_version(const ISchemaName& schemaName);
  void recv_get_schema_latest_version(SchemaVersion& _return);
  void get_schema_all_versions(std::vector<SchemaVersion> & _return, const ISchemaName& schemaName) override;
  void send_get_schema_all_versions(const ISchemaName& schemaName);
  void recv_get_schema_all_versions(std::vector<SchemaVersion> & _return);
  void drop_schema_version(const SchemaVersionDescriptor& schemaVersion) override;
  void send_drop_schema_version(const SchemaVersionDescriptor& schemaVersion);
  void recv_drop_schema_version();
  void get_schemas_by_cols(FindSchemasByColsResp& _return, const FindSchemasByColsRqst& rqst) override;
  void send_get_schemas_by_cols(const FindSchemasByColsRqst& rqst);
  void recv_get_schemas_by_cols(FindSchemasByColsResp& _return);
  void map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst) override;
  void send_map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst);
  void recv_map_schema_version_to_serde();
  void set_schema_version_state(const SetSchemaVersionStateRequest& rqst) override;
  void send_set_schema_version_state(const SetSchemaVersionStateRequest& rqst);
  void recv_set_schema_version_state();
  void add_serde(const SerDeInfo& serde) override;
  void send_add_serde(const SerDeInfo& serde);
  void recv_add_serde();
  void get_serde(SerDeInfo& _return, const GetSerdeRequest& rqst) override;
  void send_get_serde(const GetSerdeRequest& rqst);
  void recv_get_serde(SerDeInfo& _return);
  void get_lock_materialization_rebuild(LockResponse& _return, const std::string& dbName, const std::string& tableName, const int64_t txnId) override;
  void send_get_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId);
  void recv_get_lock_materialization_rebuild(LockResponse& _return);
  bool heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId) override;
  void send_heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId);
  bool recv_heartbeat_lock_materialization_rebuild();
  void add_runtime_stats(const RuntimeStat& stat) override;
  void send_add_runtime_stats(const RuntimeStat& stat);
  void recv_add_runtime_stats();
  void get_runtime_stats(std::vector<RuntimeStat> & _return, const GetRuntimeStatsRequest& rqst) override;
  void send_get_runtime_stats(const GetRuntimeStatsRequest& rqst);
  void recv_get_runtime_stats(std::vector<RuntimeStat> & _return);
};

class ThriftHiveMetastoreProcessor : public  ::facebook::fb303::FacebookServiceProcessor {
 protected:
  ::std::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) override;
 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_init_schema(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_create_catalog(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_alter_catalog(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_catalog(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_catalogs(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_drop_catalog(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_create_table_with_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_drop_constraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_add_primary_key(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_add_foreign_key(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_add_unique_constraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_add_not_null_constraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_add_default_constraint(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_add_check_constraint(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_truncate_table(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_tables_by_type(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_materialized_views_for_rewriting(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_table_meta(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_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_table_objects_by_name_req(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_materialization_invalidation_info(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_update_creation_metadata(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_exchange_partitions(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_partition_values(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_num_partitions_by_filter(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_partitions_with_environment_context(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_get_primary_keys(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_foreign_keys(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_unique_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_not_null_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_default_constraints(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_check_constraints(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_get_all_functions(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_refresh_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_add_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_remove_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_token(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_all_token_identifiers(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_add_master_key(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_update_master_key(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_remove_master_key(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_master_keys(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_abort_txns(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_repl_tbl_writeid_state(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_valid_write_ids(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_allocate_table_write_ids(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_compact2(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_get_notification_events_count(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);
  void process_flushCache(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_cm_recycle(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_file_metadata_by_expr(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_put_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_clear_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_cache_file_metadata(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_metastore_db_uuid(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_create_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_active_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_all_resource_plans(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_alter_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_validate_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_drop_resource_plan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_create_wm_trigger(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_alter_wm_trigger(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_drop_wm_trigger(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_triggers_for_resourceplan(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_create_wm_pool(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_alter_wm_pool(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_drop_wm_pool(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_create_or_update_wm_mapping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_drop_wm_mapping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_create_or_drop_wm_trigger_to_pool_mapping(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_create_ischema(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_alter_ischema(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_ischema(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_drop_ischema(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_add_schema_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_schema_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_schema_latest_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_schema_all_versions(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_drop_schema_version(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_schemas_by_cols(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_map_schema_version_to_serde(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_set_schema_version_state(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_add_serde(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_serde(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_lock_materialization_rebuild(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_heartbeat_lock_materialization_rebuild(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_add_runtime_stats(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
  void process_get_runtime_stats(int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, ::apache::thrift::protocol::TProtocol* oprot, void* callContext);
 public:
  ThriftHiveMetastoreProcessor(::std::shared_ptr<ThriftHiveMetastoreIf> iface) :
     ::facebook::fb303::FacebookServiceProcessor(iface),
    iface_(iface) {
    processMap_["getMetaConf"] = &ThriftHiveMetastoreProcessor::process_getMetaConf;
    processMap_["setMetaConf"] = &ThriftHiveMetastoreProcessor::process_setMetaConf;
    processMap_["init_schema"] = &ThriftHiveMetastoreProcessor::process_init_schema;
    processMap_["create_catalog"] = &ThriftHiveMetastoreProcessor::process_create_catalog;
    processMap_["alter_catalog"] = &ThriftHiveMetastoreProcessor::process_alter_catalog;
    processMap_["get_catalog"] = &ThriftHiveMetastoreProcessor::process_get_catalog;
    processMap_["get_catalogs"] = &ThriftHiveMetastoreProcessor::process_get_catalogs;
    processMap_["drop_catalog"] = &ThriftHiveMetastoreProcessor::process_drop_catalog;
    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_["create_table_with_constraints"] = &ThriftHiveMetastoreProcessor::process_create_table_with_constraints;
    processMap_["drop_constraint"] = &ThriftHiveMetastoreProcessor::process_drop_constraint;
    processMap_["add_primary_key"] = &ThriftHiveMetastoreProcessor::process_add_primary_key;
    processMap_["add_foreign_key"] = &ThriftHiveMetastoreProcessor::process_add_foreign_key;
    processMap_["add_unique_constraint"] = &ThriftHiveMetastoreProcessor::process_add_unique_constraint;
    processMap_["add_not_null_constraint"] = &ThriftHiveMetastoreProcessor::process_add_not_null_constraint;
    processMap_["add_default_constraint"] = &ThriftHiveMetastoreProcessor::process_add_default_constraint;
    processMap_["add_check_constraint"] = &ThriftHiveMetastoreProcessor::process_add_check_constraint;
    processMap_["drop_table"] = &ThriftHiveMetastoreProcessor::process_drop_table;
    processMap_["drop_table_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_drop_table_with_environment_context;
    processMap_["truncate_table"] = &ThriftHiveMetastoreProcessor::process_truncate_table;
    processMap_["get_tables"] = &ThriftHiveMetastoreProcessor::process_get_tables;
    processMap_["get_tables_by_type"] = &ThriftHiveMetastoreProcessor::process_get_tables_by_type;
    processMap_["get_materialized_views_for_rewriting"] = &ThriftHiveMetastoreProcessor::process_get_materialized_views_for_rewriting;
    processMap_["get_table_meta"] = &ThriftHiveMetastoreProcessor::process_get_table_meta;
    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_req"] = &ThriftHiveMetastoreProcessor::process_get_table_req;
    processMap_["get_table_objects_by_name_req"] = &ThriftHiveMetastoreProcessor::process_get_table_objects_by_name_req;
    processMap_["get_materialization_invalidation_info"] = &ThriftHiveMetastoreProcessor::process_get_materialization_invalidation_info;
    processMap_["update_creation_metadata"] = &ThriftHiveMetastoreProcessor::process_update_creation_metadata;
    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_["exchange_partitions"] = &ThriftHiveMetastoreProcessor::process_exchange_partitions;
    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_partition_values"] = &ThriftHiveMetastoreProcessor::process_get_partition_values;
    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_num_partitions_by_filter"] = &ThriftHiveMetastoreProcessor::process_get_num_partitions_by_filter;
    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_partitions_with_environment_context"] = &ThriftHiveMetastoreProcessor::process_alter_partitions_with_environment_context;
    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_["get_primary_keys"] = &ThriftHiveMetastoreProcessor::process_get_primary_keys;
    processMap_["get_foreign_keys"] = &ThriftHiveMetastoreProcessor::process_get_foreign_keys;
    processMap_["get_unique_constraints"] = &ThriftHiveMetastoreProcessor::process_get_unique_constraints;
    processMap_["get_not_null_constraints"] = &ThriftHiveMetastoreProcessor::process_get_not_null_constraints;
    processMap_["get_default_constraints"] = &ThriftHiveMetastoreProcessor::process_get_default_constraints;
    processMap_["get_check_constraints"] = &ThriftHiveMetastoreProcessor::process_get_check_constraints;
    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_["get_all_functions"] = &ThriftHiveMetastoreProcessor::process_get_all_functions;
    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_["refresh_privileges"] = &ThriftHiveMetastoreProcessor::process_refresh_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_["add_token"] = &ThriftHiveMetastoreProcessor::process_add_token;
    processMap_["remove_token"] = &ThriftHiveMetastoreProcessor::process_remove_token;
    processMap_["get_token"] = &ThriftHiveMetastoreProcessor::process_get_token;
    processMap_["get_all_token_identifiers"] = &ThriftHiveMetastoreProcessor::process_get_all_token_identifiers;
    processMap_["add_master_key"] = &ThriftHiveMetastoreProcessor::process_add_master_key;
    processMap_["update_master_key"] = &ThriftHiveMetastoreProcessor::process_update_master_key;
    processMap_["remove_master_key"] = &ThriftHiveMetastoreProcessor::process_remove_master_key;
    processMap_["get_master_keys"] = &ThriftHiveMetastoreProcessor::process_get_master_keys;
    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_["abort_txns"] = &ThriftHiveMetastoreProcessor::process_abort_txns;
    processMap_["commit_txn"] = &ThriftHiveMetastoreProcessor::process_commit_txn;
    processMap_["repl_tbl_writeid_state"] = &ThriftHiveMetastoreProcessor::process_repl_tbl_writeid_state;
    processMap_["get_valid_write_ids"] = &ThriftHiveMetastoreProcessor::process_get_valid_write_ids;
    processMap_["allocate_table_write_ids"] = &ThriftHiveMetastoreProcessor::process_allocate_table_write_ids;
    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_["compact2"] = &ThriftHiveMetastoreProcessor::process_compact2;
    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_["get_notification_events_count"] = &ThriftHiveMetastoreProcessor::process_get_notification_events_count;
    processMap_["fire_listener_event"] = &ThriftHiveMetastoreProcessor::process_fire_listener_event;
    processMap_["flushCache"] = &ThriftHiveMetastoreProcessor::process_flushCache;
    processMap_["cm_recycle"] = &ThriftHiveMetastoreProcessor::process_cm_recycle;
    processMap_["get_file_metadata_by_expr"] = &ThriftHiveMetastoreProcessor::process_get_file_metadata_by_expr;
    processMap_["get_file_metadata"] = &ThriftHiveMetastoreProcessor::process_get_file_metadata;
    processMap_["put_file_metadata"] = &ThriftHiveMetastoreProcessor::process_put_file_metadata;
    processMap_["clear_file_metadata"] = &ThriftHiveMetastoreProcessor::process_clear_file_metadata;
    processMap_["cache_file_metadata"] = &ThriftHiveMetastoreProcessor::process_cache_file_metadata;
    processMap_["get_metastore_db_uuid"] = &ThriftHiveMetastoreProcessor::process_get_metastore_db_uuid;
    processMap_["create_resource_plan"] = &ThriftHiveMetastoreProcessor::process_create_resource_plan;
    processMap_["get_resource_plan"] = &ThriftHiveMetastoreProcessor::process_get_resource_plan;
    processMap_["get_active_resource_plan"] = &ThriftHiveMetastoreProcessor::process_get_active_resource_plan;
    processMap_["get_all_resource_plans"] = &ThriftHiveMetastoreProcessor::process_get_all_resource_plans;
    processMap_["alter_resource_plan"] = &ThriftHiveMetastoreProcessor::process_alter_resource_plan;
    processMap_["validate_resource_plan"] = &ThriftHiveMetastoreProcessor::process_validate_resource_plan;
    processMap_["drop_resource_plan"] = &ThriftHiveMetastoreProcessor::process_drop_resource_plan;
    processMap_["create_wm_trigger"] = &ThriftHiveMetastoreProcessor::process_create_wm_trigger;
    processMap_["alter_wm_trigger"] = &ThriftHiveMetastoreProcessor::process_alter_wm_trigger;
    processMap_["drop_wm_trigger"] = &ThriftHiveMetastoreProcessor::process_drop_wm_trigger;
    processMap_["get_triggers_for_resourceplan"] = &ThriftHiveMetastoreProcessor::process_get_triggers_for_resourceplan;
    processMap_["create_wm_pool"] = &ThriftHiveMetastoreProcessor::process_create_wm_pool;
    processMap_["alter_wm_pool"] = &ThriftHiveMetastoreProcessor::process_alter_wm_pool;
    processMap_["drop_wm_pool"] = &ThriftHiveMetastoreProcessor::process_drop_wm_pool;
    processMap_["create_or_update_wm_mapping"] = &ThriftHiveMetastoreProcessor::process_create_or_update_wm_mapping;
    processMap_["drop_wm_mapping"] = &ThriftHiveMetastoreProcessor::process_drop_wm_mapping;
    processMap_["create_or_drop_wm_trigger_to_pool_mapping"] = &ThriftHiveMetastoreProcessor::process_create_or_drop_wm_trigger_to_pool_mapping;
    processMap_["create_ischema"] = &ThriftHiveMetastoreProcessor::process_create_ischema;
    processMap_["alter_ischema"] = &ThriftHiveMetastoreProcessor::process_alter_ischema;
    processMap_["get_ischema"] = &ThriftHiveMetastoreProcessor::process_get_ischema;
    processMap_["drop_ischema"] = &ThriftHiveMetastoreProcessor::process_drop_ischema;
    processMap_["add_schema_version"] = &ThriftHiveMetastoreProcessor::process_add_schema_version;
    processMap_["get_schema_version"] = &ThriftHiveMetastoreProcessor::process_get_schema_version;
    processMap_["get_schema_latest_version"] = &ThriftHiveMetastoreProcessor::process_get_schema_latest_version;
    processMap_["get_schema_all_versions"] = &ThriftHiveMetastoreProcessor::process_get_schema_all_versions;
    processMap_["drop_schema_version"] = &ThriftHiveMetastoreProcessor::process_drop_schema_version;
    processMap_["get_schemas_by_cols"] = &ThriftHiveMetastoreProcessor::process_get_schemas_by_cols;
    processMap_["map_schema_version_to_serde"] = &ThriftHiveMetastoreProcessor::process_map_schema_version_to_serde;
    processMap_["set_schema_version_state"] = &ThriftHiveMetastoreProcessor::process_set_schema_version_state;
    processMap_["add_serde"] = &ThriftHiveMetastoreProcessor::process_add_serde;
    processMap_["get_serde"] = &ThriftHiveMetastoreProcessor::process_get_serde;
    processMap_["get_lock_materialization_rebuild"] = &ThriftHiveMetastoreProcessor::process_get_lock_materialization_rebuild;
    processMap_["heartbeat_lock_materialization_rebuild"] = &ThriftHiveMetastoreProcessor::process_heartbeat_lock_materialization_rebuild;
    processMap_["add_runtime_stats"] = &ThriftHiveMetastoreProcessor::process_add_runtime_stats;
    processMap_["get_runtime_stats"] = &ThriftHiveMetastoreProcessor::process_get_runtime_stats;
  }

  virtual ~ThriftHiveMetastoreProcessor() {}
};

class ThriftHiveMetastoreProcessorFactory : public ::apache::thrift::TProcessorFactory {
 public:
  ThriftHiveMetastoreProcessorFactory(const ::std::shared_ptr< ThriftHiveMetastoreIfFactory >& handlerFactory) noexcept :
      handlerFactory_(handlerFactory) {}

  ::std::shared_ptr< ::apache::thrift::TProcessor > getProcessor(const ::apache::thrift::TConnectionInfo& connInfo) override;

 protected:
  ::std::shared_ptr< ThriftHiveMetastoreIfFactory > handlerFactory_;
};

class ThriftHiveMetastoreMultiface : virtual public ThriftHiveMetastoreIf, public  ::facebook::fb303::FacebookServiceMultiface {
 public:
  ThriftHiveMetastoreMultiface(std::vector<std::shared_ptr<ThriftHiveMetastoreIf> >& ifaces) : ifaces_(ifaces) {
    std::vector<std::shared_ptr<ThriftHiveMetastoreIf> >::iterator iter;
    for (iter = ifaces.begin(); iter != ifaces.end(); ++iter) {
       ::facebook::fb303::FacebookServiceMultiface::add(*iter);
    }
  }
  virtual ~ThriftHiveMetastoreMultiface() {}
 protected:
  std::vector<std::shared_ptr<ThriftHiveMetastoreIf> > ifaces_;
  ThriftHiveMetastoreMultiface() {}
  void add(::std::shared_ptr<ThriftHiveMetastoreIf> iface) {
     ::facebook::fb303::FacebookServiceMultiface::add(iface);
    ifaces_.push_back(iface);
  }
 public:
  void getMetaConf(std::string& _return, const std::string& key) override {
    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) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->setMetaConf(key, value);
    }
    ifaces_[i]->setMetaConf(key, value);
  }

  bool init_schema(const std::string& dbType, const std::string& username, const std::string& password) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->init_schema(dbType, username, password);
    }
    return ifaces_[i]->init_schema(dbType, username, password);
  }

  void create_catalog(const CreateCatalogRequest& catalog) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->create_catalog(catalog);
    }
    ifaces_[i]->create_catalog(catalog);
  }

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

  void get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_catalog(_return, catName);
    }
    ifaces_[i]->get_catalog(_return, catName);
    return;
  }

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

  void drop_catalog(const DropCatalogRequest& catName) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->drop_catalog(catName);
    }
    ifaces_[i]->drop_catalog(catName);
  }

  void create_database(const Database& database) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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 create_table_with_constraints(const Table& tbl, const std::vector<SQLPrimaryKey> & primaryKeys, const std::vector<SQLForeignKey> & foreignKeys, const std::vector<SQLUniqueConstraint> & uniqueConstraints, const std::vector<SQLNotNullConstraint> & notNullConstraints, const std::vector<SQLDefaultConstraint> & defaultConstraints, const std::vector<SQLCheckConstraint> & checkConstraints) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->create_table_with_constraints(tbl, primaryKeys, foreignKeys, uniqueConstraints, notNullConstraints, defaultConstraints, checkConstraints);
    }
    ifaces_[i]->create_table_with_constraints(tbl, primaryKeys, foreignKeys, uniqueConstraints, notNullConstraints, defaultConstraints, checkConstraints);
  }

  void drop_constraint(const DropConstraintRequest& req) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->drop_constraint(req);
    }
    ifaces_[i]->drop_constraint(req);
  }

  void add_primary_key(const AddPrimaryKeyRequest& req) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->add_primary_key(req);
    }
    ifaces_[i]->add_primary_key(req);
  }

  void add_foreign_key(const AddForeignKeyRequest& req) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->add_foreign_key(req);
    }
    ifaces_[i]->add_foreign_key(req);
  }

  void add_unique_constraint(const AddUniqueConstraintRequest& req) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->add_unique_constraint(req);
    }
    ifaces_[i]->add_unique_constraint(req);
  }

  void add_not_null_constraint(const AddNotNullConstraintRequest& req) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->add_not_null_constraint(req);
    }
    ifaces_[i]->add_not_null_constraint(req);
  }

  void add_default_constraint(const AddDefaultConstraintRequest& req) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->add_default_constraint(req);
    }
    ifaces_[i]->add_default_constraint(req);
  }

  void add_check_constraint(const AddCheckConstraintRequest& req) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->add_check_constraint(req);
    }
    ifaces_[i]->add_check_constraint(req);
  }

  void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) override {
    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) override {
    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 truncate_table(const std::string& dbName, const std::string& tableName, const std::vector<std::string> & partNames) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->truncate_table(dbName, tableName, partNames);
    }
    ifaces_[i]->truncate_table(dbName, tableName, partNames);
  }

  void get_tables(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern) override {
    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_tables_by_type(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_tables_by_type(_return, db_name, pattern, tableType);
    }
    ifaces_[i]->get_tables_by_type(_return, db_name, pattern, tableType);
    return;
  }

  void get_materialized_views_for_rewriting(std::vector<std::string> & _return, const std::string& db_name) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_materialized_views_for_rewriting(_return, db_name);
    }
    ifaces_[i]->get_materialized_views_for_rewriting(_return, db_name);
    return;
  }

  void get_table_meta(std::vector<TableMeta> & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector<std::string> & tbl_types) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_table_meta(_return, db_patterns, tbl_patterns, tbl_types);
    }
    ifaces_[i]->get_table_meta(_return, db_patterns, tbl_patterns, tbl_types);
    return;
  }

  void get_all_tables(std::vector<std::string> & _return, const std::string& db_name) override {
    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) override {
    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) override {
    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_req(GetTableResult& _return, const GetTableRequest& req) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_table_req(_return, req);
    }
    ifaces_[i]->get_table_req(_return, req);
    return;
  }

  void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_table_objects_by_name_req(_return, req);
    }
    ifaces_[i]->get_table_objects_by_name_req(_return, req);
    return;
  }

  void get_materialization_invalidation_info(Materialization& _return, const CreationMetadata& creation_metadata, const std::string& validTxnList) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_materialization_invalidation_info(_return, creation_metadata, validTxnList);
    }
    ifaces_[i]->get_materialization_invalidation_info(_return, creation_metadata, validTxnList);
    return;
  }

  void update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->update_creation_metadata(catName, dbname, tbl_name, creation_metadata);
    }
    ifaces_[i]->update_creation_metadata(catName, dbname, tbl_name, creation_metadata);
  }

  void get_table_names_by_filter(std::vector<std::string> & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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 exchange_partitions(std::vector<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) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->exchange_partitions(_return, partitionSpecs, source_db, source_table_name, dest_db, dest_table_name);
    }
    ifaces_[i]->exchange_partitions(_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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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_partition_values(PartitionValuesResponse& _return, const PartitionValuesRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_partition_values(_return, request);
    }
    ifaces_[i]->get_partition_values(_return, request);
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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;
  }

  int32_t get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_num_partitions_by_filter(db_name, tbl_name, filter);
    }
    return ifaces_[i]->get_num_partitions_by_filter(db_name, tbl_name, filter);
  }

  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) override {
    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) override {
    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) override {
    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_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts, const EnvironmentContext& environment_context) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->alter_partitions_with_environment_context(db_name, tbl_name, new_parts, environment_context);
    }
    ifaces_[i]->alter_partitions_with_environment_context(db_name, tbl_name, new_parts, environment_context);
  }

  void alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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 get_primary_keys(PrimaryKeysResponse& _return, const PrimaryKeysRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_primary_keys(_return, request);
    }
    ifaces_[i]->get_primary_keys(_return, request);
    return;
  }

  void get_foreign_keys(ForeignKeysResponse& _return, const ForeignKeysRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_foreign_keys(_return, request);
    }
    ifaces_[i]->get_foreign_keys(_return, request);
    return;
  }

  void get_unique_constraints(UniqueConstraintsResponse& _return, const UniqueConstraintsRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_unique_constraints(_return, request);
    }
    ifaces_[i]->get_unique_constraints(_return, request);
    return;
  }

  void get_not_null_constraints(NotNullConstraintsResponse& _return, const NotNullConstraintsRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_not_null_constraints(_return, request);
    }
    ifaces_[i]->get_not_null_constraints(_return, request);
    return;
  }

  void get_default_constraints(DefaultConstraintsResponse& _return, const DefaultConstraintsRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_default_constraints(_return, request);
    }
    ifaces_[i]->get_default_constraints(_return, request);
    return;
  }

  void get_check_constraints(CheckConstraintsResponse& _return, const CheckConstraintsRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_check_constraints(_return, request);
    }
    ifaces_[i]->get_check_constraints(_return, request);
    return;
  }

  bool update_table_column_statistics(const ColumnStatistics& stats_obj) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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;
  }

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

  bool create_role(const Role& role) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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 refresh_privileges(GrantRevokePrivilegeResponse& _return, const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->refresh_privileges(_return, objToRefresh, authorizer, grantRequest);
    }
    ifaces_[i]->refresh_privileges(_return, objToRefresh, authorizer, grantRequest);
    return;
  }

  void set_ugi(std::vector<std::string> & _return, const std::string& user_name, const std::vector<std::string> & group_names) override {
    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) override {
    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) override {
    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) override {
    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);
  }

  bool add_token(const std::string& token_identifier, const std::string& delegation_token) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->add_token(token_identifier, delegation_token);
    }
    return ifaces_[i]->add_token(token_identifier, delegation_token);
  }

  bool remove_token(const std::string& token_identifier) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->remove_token(token_identifier);
    }
    return ifaces_[i]->remove_token(token_identifier);
  }

  void get_token(std::string& _return, const std::string& token_identifier) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_token(_return, token_identifier);
    }
    ifaces_[i]->get_token(_return, token_identifier);
    return;
  }

  void get_all_token_identifiers(std::vector<std::string> & _return) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_all_token_identifiers(_return);
    }
    ifaces_[i]->get_all_token_identifiers(_return);
    return;
  }

  int32_t add_master_key(const std::string& key) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->add_master_key(key);
    }
    return ifaces_[i]->add_master_key(key);
  }

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

  bool remove_master_key(const int32_t key_seq) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->remove_master_key(key_seq);
    }
    return ifaces_[i]->remove_master_key(key_seq);
  }

  void get_master_keys(std::vector<std::string> & _return) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_master_keys(_return);
    }
    ifaces_[i]->get_master_keys(_return);
    return;
  }

  void get_open_txns(GetOpenTxnsResponse& _return) override {
    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) override {
    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) override {
    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) override {
    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 abort_txns(const AbortTxnsRequest& rqst) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->abort_txns(rqst);
    }
    ifaces_[i]->abort_txns(rqst);
  }

  void commit_txn(const CommitTxnRequest& rqst) override {
    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 repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->repl_tbl_writeid_state(rqst);
    }
    ifaces_[i]->repl_tbl_writeid_state(rqst);
  }

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

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

  void lock(LockResponse& _return, const LockRequest& rqst) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    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) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->compact(rqst);
    }
    ifaces_[i]->compact(rqst);
  }

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

  void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) override {
    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) override {
    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) override {
    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) override {
    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 get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_notification_events_count(_return, rqst);
    }
    ifaces_[i]->get_notification_events_count(_return, rqst);
    return;
  }

  void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) override {
    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;
  }

  void flushCache() override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->flushCache();
    }
    ifaces_[i]->flushCache();
  }

  void cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->cm_recycle(_return, request);
    }
    ifaces_[i]->cm_recycle(_return, request);
    return;
  }

  void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_file_metadata_by_expr(_return, req);
    }
    ifaces_[i]->get_file_metadata_by_expr(_return, req);
    return;
  }

  void get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_file_metadata(_return, req);
    }
    ifaces_[i]->get_file_metadata(_return, req);
    return;
  }

  void put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->put_file_metadata(_return, req);
    }
    ifaces_[i]->put_file_metadata(_return, req);
    return;
  }

  void clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->clear_file_metadata(_return, req);
    }
    ifaces_[i]->clear_file_metadata(_return, req);
    return;
  }

  void cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->cache_file_metadata(_return, req);
    }
    ifaces_[i]->cache_file_metadata(_return, req);
    return;
  }

  void get_metastore_db_uuid(std::string& _return) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_metastore_db_uuid(_return);
    }
    ifaces_[i]->get_metastore_db_uuid(_return);
    return;
  }

  void create_resource_plan(WMCreateResourcePlanResponse& _return, const WMCreateResourcePlanRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->create_resource_plan(_return, request);
    }
    ifaces_[i]->create_resource_plan(_return, request);
    return;
  }

  void get_resource_plan(WMGetResourcePlanResponse& _return, const WMGetResourcePlanRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_resource_plan(_return, request);
    }
    ifaces_[i]->get_resource_plan(_return, request);
    return;
  }

  void get_active_resource_plan(WMGetActiveResourcePlanResponse& _return, const WMGetActiveResourcePlanRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_active_resource_plan(_return, request);
    }
    ifaces_[i]->get_active_resource_plan(_return, request);
    return;
  }

  void get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const WMGetAllResourcePlanRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_all_resource_plans(_return, request);
    }
    ifaces_[i]->get_all_resource_plans(_return, request);
    return;
  }

  void alter_resource_plan(WMAlterResourcePlanResponse& _return, const WMAlterResourcePlanRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->alter_resource_plan(_return, request);
    }
    ifaces_[i]->alter_resource_plan(_return, request);
    return;
  }

  void validate_resource_plan(WMValidateResourcePlanResponse& _return, const WMValidateResourcePlanRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->validate_resource_plan(_return, request);
    }
    ifaces_[i]->validate_resource_plan(_return, request);
    return;
  }

  void drop_resource_plan(WMDropResourcePlanResponse& _return, const WMDropResourcePlanRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->drop_resource_plan(_return, request);
    }
    ifaces_[i]->drop_resource_plan(_return, request);
    return;
  }

  void create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->create_wm_trigger(_return, request);
    }
    ifaces_[i]->create_wm_trigger(_return, request);
    return;
  }

  void alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->alter_wm_trigger(_return, request);
    }
    ifaces_[i]->alter_wm_trigger(_return, request);
    return;
  }

  void drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->drop_wm_trigger(_return, request);
    }
    ifaces_[i]->drop_wm_trigger(_return, request);
    return;
  }

  void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_triggers_for_resourceplan(_return, request);
    }
    ifaces_[i]->get_triggers_for_resourceplan(_return, request);
    return;
  }

  void create_wm_pool(WMCreatePoolResponse& _return, const WMCreatePoolRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->create_wm_pool(_return, request);
    }
    ifaces_[i]->create_wm_pool(_return, request);
    return;
  }

  void alter_wm_pool(WMAlterPoolResponse& _return, const WMAlterPoolRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->alter_wm_pool(_return, request);
    }
    ifaces_[i]->alter_wm_pool(_return, request);
    return;
  }

  void drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->drop_wm_pool(_return, request);
    }
    ifaces_[i]->drop_wm_pool(_return, request);
    return;
  }

  void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->create_or_update_wm_mapping(_return, request);
    }
    ifaces_[i]->create_or_update_wm_mapping(_return, request);
    return;
  }

  void drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->drop_wm_mapping(_return, request);
    }
    ifaces_[i]->drop_wm_mapping(_return, request);
    return;
  }

  void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->create_or_drop_wm_trigger_to_pool_mapping(_return, request);
    }
    ifaces_[i]->create_or_drop_wm_trigger_to_pool_mapping(_return, request);
    return;
  }

  void create_ischema(const ISchema& schema) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->create_ischema(schema);
    }
    ifaces_[i]->create_ischema(schema);
  }

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

  void get_ischema(ISchema& _return, const ISchemaName& name) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_ischema(_return, name);
    }
    ifaces_[i]->get_ischema(_return, name);
    return;
  }

  void drop_ischema(const ISchemaName& name) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->drop_ischema(name);
    }
    ifaces_[i]->drop_ischema(name);
  }

  void add_schema_version(const SchemaVersion& schemaVersion) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->add_schema_version(schemaVersion);
    }
    ifaces_[i]->add_schema_version(schemaVersion);
  }

  void get_schema_version(SchemaVersion& _return, const SchemaVersionDescriptor& schemaVersion) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_schema_version(_return, schemaVersion);
    }
    ifaces_[i]->get_schema_version(_return, schemaVersion);
    return;
  }

  void get_schema_latest_version(SchemaVersion& _return, const ISchemaName& schemaName) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_schema_latest_version(_return, schemaName);
    }
    ifaces_[i]->get_schema_latest_version(_return, schemaName);
    return;
  }

  void get_schema_all_versions(std::vector<SchemaVersion> & _return, const ISchemaName& schemaName) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_schema_all_versions(_return, schemaName);
    }
    ifaces_[i]->get_schema_all_versions(_return, schemaName);
    return;
  }

  void drop_schema_version(const SchemaVersionDescriptor& schemaVersion) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->drop_schema_version(schemaVersion);
    }
    ifaces_[i]->drop_schema_version(schemaVersion);
  }

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

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

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

  void add_serde(const SerDeInfo& serde) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->add_serde(serde);
    }
    ifaces_[i]->add_serde(serde);
  }

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

  void get_lock_materialization_rebuild(LockResponse& _return, const std::string& dbName, const std::string& tableName, const int64_t txnId) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_lock_materialization_rebuild(_return, dbName, tableName, txnId);
    }
    ifaces_[i]->get_lock_materialization_rebuild(_return, dbName, tableName, txnId);
    return;
  }

  bool heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->heartbeat_lock_materialization_rebuild(dbName, tableName, txnId);
    }
    return ifaces_[i]->heartbeat_lock_materialization_rebuild(dbName, tableName, txnId);
  }

  void add_runtime_stats(const RuntimeStat& stat) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->add_runtime_stats(stat);
    }
    ifaces_[i]->add_runtime_stats(stat);
  }

  void get_runtime_stats(std::vector<RuntimeStat> & _return, const GetRuntimeStatsRequest& rqst) override {
    size_t sz = ifaces_.size();
    size_t i = 0;
    for (; i < (sz - 1); ++i) {
      ifaces_[i]->get_runtime_stats(_return, rqst);
    }
    ifaces_[i]->get_runtime_stats(_return, rqst);
    return;
  }

};

// The 'concurrent' client is a thread safe client that correctly handles
// out of order responses.  It is slower than the regular client, so should
// only be used when you need to share a connection among multiple threads
class ThriftHiveMetastoreConcurrentClient : virtual public ThriftHiveMetastoreIf, public  ::facebook::fb303::FacebookServiceConcurrentClient {
 public:
  ThriftHiveMetastoreConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> prot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) :
     ::facebook::fb303::FacebookServiceConcurrentClient(prot, prot, sync) {}
  ThriftHiveMetastoreConcurrentClient(std::shared_ptr< ::apache::thrift::protocol::TProtocol> iprot, std::shared_ptr< ::apache::thrift::protocol::TProtocol> oprot, std::shared_ptr<::apache::thrift::async::TConcurrentClientSyncInfo> sync) :     ::facebook::fb303::FacebookServiceConcurrentClient(iprot, oprot, sync) {}
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getInputProtocol() {
    return piprot_;
  }
  std::shared_ptr< ::apache::thrift::protocol::TProtocol> getOutputProtocol() {
    return poprot_;
  }
  void getMetaConf(std::string& _return, const std::string& key) override;
  int32_t send_getMetaConf(const std::string& key);
  void recv_getMetaConf(std::string& _return, const int32_t seqid);
  void setMetaConf(const std::string& key, const std::string& value) override;
  int32_t send_setMetaConf(const std::string& key, const std::string& value);
  void recv_setMetaConf(const int32_t seqid);
  bool init_schema(const std::string& dbType, const std::string& username, const std::string& password) override;
  int32_t send_init_schema(const std::string& dbType, const std::string& username, const std::string& password);
  bool recv_init_schema(const int32_t seqid);
  void create_catalog(const CreateCatalogRequest& catalog) override;
  int32_t send_create_catalog(const CreateCatalogRequest& catalog);
  void recv_create_catalog(const int32_t seqid);
  void alter_catalog(const AlterCatalogRequest& rqst) override;
  int32_t send_alter_catalog(const AlterCatalogRequest& rqst);
  void recv_alter_catalog(const int32_t seqid);
  void get_catalog(GetCatalogResponse& _return, const GetCatalogRequest& catName) override;
  int32_t send_get_catalog(const GetCatalogRequest& catName);
  void recv_get_catalog(GetCatalogResponse& _return, const int32_t seqid);
  void get_catalogs(GetCatalogsResponse& _return) override;
  int32_t send_get_catalogs();
  void recv_get_catalogs(GetCatalogsResponse& _return, const int32_t seqid);
  void drop_catalog(const DropCatalogRequest& catName) override;
  int32_t send_drop_catalog(const DropCatalogRequest& catName);
  void recv_drop_catalog(const int32_t seqid);
  void create_database(const Database& database) override;
  int32_t send_create_database(const Database& database);
  void recv_create_database(const int32_t seqid);
  void get_database(Database& _return, const std::string& name) override;
  int32_t send_get_database(const std::string& name);
  void recv_get_database(Database& _return, const int32_t seqid);
  void drop_database(const std::string& name, const bool deleteData, const bool cascade) override;
  int32_t send_drop_database(const std::string& name, const bool deleteData, const bool cascade);
  void recv_drop_database(const int32_t seqid);
  void get_databases(std::vector<std::string> & _return, const std::string& pattern) override;
  int32_t send_get_databases(const std::string& pattern);
  void recv_get_databases(std::vector<std::string> & _return, const int32_t seqid);
  void get_all_databases(std::vector<std::string> & _return) override;
  int32_t send_get_all_databases();
  void recv_get_all_databases(std::vector<std::string> & _return, const int32_t seqid);
  void alter_database(const std::string& dbname, const Database& db) override;
  int32_t send_alter_database(const std::string& dbname, const Database& db);
  void recv_alter_database(const int32_t seqid);
  void get_type(Type& _return, const std::string& name) override;
  int32_t send_get_type(const std::string& name);
  void recv_get_type(Type& _return, const int32_t seqid);
  bool create_type(const Type& type) override;
  int32_t send_create_type(const Type& type);
  bool recv_create_type(const int32_t seqid);
  bool drop_type(const std::string& type) override;
  int32_t send_drop_type(const std::string& type);
  bool recv_drop_type(const int32_t seqid);
  void get_type_all(std::map<std::string, Type> & _return, const std::string& name) override;
  int32_t send_get_type_all(const std::string& name);
  void recv_get_type_all(std::map<std::string, Type> & _return, const int32_t seqid);
  void get_fields(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name) override;
  int32_t send_get_fields(const std::string& db_name, const std::string& table_name);
  void recv_get_fields(std::vector<FieldSchema> & _return, const int32_t seqid);
  void get_fields_with_environment_context(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) override;
  int32_t 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, const int32_t seqid);
  void get_schema(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name) override;
  int32_t send_get_schema(const std::string& db_name, const std::string& table_name);
  void recv_get_schema(std::vector<FieldSchema> & _return, const int32_t seqid);
  void get_schema_with_environment_context(std::vector<FieldSchema> & _return, const std::string& db_name, const std::string& table_name, const EnvironmentContext& environment_context) override;
  int32_t 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, const int32_t seqid);
  void create_table(const Table& tbl) override;
  int32_t send_create_table(const Table& tbl);
  void recv_create_table(const int32_t seqid);
  void create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context) override;
  int32_t send_create_table_with_environment_context(const Table& tbl, const EnvironmentContext& environment_context);
  void recv_create_table_with_environment_context(const int32_t seqid);
  void create_table_with_constraints(const Table& tbl, const std::vector<SQLPrimaryKey> & primaryKeys, const std::vector<SQLForeignKey> & foreignKeys, const std::vector<SQLUniqueConstraint> & uniqueConstraints, const std::vector<SQLNotNullConstraint> & notNullConstraints, const std::vector<SQLDefaultConstraint> & defaultConstraints, const std::vector<SQLCheckConstraint> & checkConstraints) override;
  int32_t send_create_table_with_constraints(const Table& tbl, const std::vector<SQLPrimaryKey> & primaryKeys, const std::vector<SQLForeignKey> & foreignKeys, const std::vector<SQLUniqueConstraint> & uniqueConstraints, const std::vector<SQLNotNullConstraint> & notNullConstraints, const std::vector<SQLDefaultConstraint> & defaultConstraints, const std::vector<SQLCheckConstraint> & checkConstraints);
  void recv_create_table_with_constraints(const int32_t seqid);
  void drop_constraint(const DropConstraintRequest& req) override;
  int32_t send_drop_constraint(const DropConstraintRequest& req);
  void recv_drop_constraint(const int32_t seqid);
  void add_primary_key(const AddPrimaryKeyRequest& req) override;
  int32_t send_add_primary_key(const AddPrimaryKeyRequest& req);
  void recv_add_primary_key(const int32_t seqid);
  void add_foreign_key(const AddForeignKeyRequest& req) override;
  int32_t send_add_foreign_key(const AddForeignKeyRequest& req);
  void recv_add_foreign_key(const int32_t seqid);
  void add_unique_constraint(const AddUniqueConstraintRequest& req) override;
  int32_t send_add_unique_constraint(const AddUniqueConstraintRequest& req);
  void recv_add_unique_constraint(const int32_t seqid);
  void add_not_null_constraint(const AddNotNullConstraintRequest& req) override;
  int32_t send_add_not_null_constraint(const AddNotNullConstraintRequest& req);
  void recv_add_not_null_constraint(const int32_t seqid);
  void add_default_constraint(const AddDefaultConstraintRequest& req) override;
  int32_t send_add_default_constraint(const AddDefaultConstraintRequest& req);
  void recv_add_default_constraint(const int32_t seqid);
  void add_check_constraint(const AddCheckConstraintRequest& req) override;
  int32_t send_add_check_constraint(const AddCheckConstraintRequest& req);
  void recv_add_check_constraint(const int32_t seqid);
  void drop_table(const std::string& dbname, const std::string& name, const bool deleteData) override;
  int32_t send_drop_table(const std::string& dbname, const std::string& name, const bool deleteData);
  void recv_drop_table(const int32_t seqid);
  void drop_table_with_environment_context(const std::string& dbname, const std::string& name, const bool deleteData, const EnvironmentContext& environment_context) override;
  int32_t 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(const int32_t seqid);
  void truncate_table(const std::string& dbName, const std::string& tableName, const std::vector<std::string> & partNames) override;
  int32_t send_truncate_table(const std::string& dbName, const std::string& tableName, const std::vector<std::string> & partNames);
  void recv_truncate_table(const int32_t seqid);
  void get_tables(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern) override;
  int32_t send_get_tables(const std::string& db_name, const std::string& pattern);
  void recv_get_tables(std::vector<std::string> & _return, const int32_t seqid);
  void get_tables_by_type(std::vector<std::string> & _return, const std::string& db_name, const std::string& pattern, const std::string& tableType) override;
  int32_t send_get_tables_by_type(const std::string& db_name, const std::string& pattern, const std::string& tableType);
  void recv_get_tables_by_type(std::vector<std::string> & _return, const int32_t seqid);
  void get_materialized_views_for_rewriting(std::vector<std::string> & _return, const std::string& db_name) override;
  int32_t send_get_materialized_views_for_rewriting(const std::string& db_name);
  void recv_get_materialized_views_for_rewriting(std::vector<std::string> & _return, const int32_t seqid);
  void get_table_meta(std::vector<TableMeta> & _return, const std::string& db_patterns, const std::string& tbl_patterns, const std::vector<std::string> & tbl_types) override;
  int32_t send_get_table_meta(const std::string& db_patterns, const std::string& tbl_patterns, const std::vector<std::string> & tbl_types);
  void recv_get_table_meta(std::vector<TableMeta> & _return, const int32_t seqid);
  void get_all_tables(std::vector<std::string> & _return, const std::string& db_name) override;
  int32_t send_get_all_tables(const std::string& db_name);
  void recv_get_all_tables(std::vector<std::string> & _return, const int32_t seqid);
  void get_table(Table& _return, const std::string& dbname, const std::string& tbl_name) override;
  int32_t send_get_table(const std::string& dbname, const std::string& tbl_name);
  void recv_get_table(Table& _return, const int32_t seqid);
  void get_table_objects_by_name(std::vector<Table> & _return, const std::string& dbname, const std::vector<std::string> & tbl_names) override;
  int32_t 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, const int32_t seqid);
  void get_table_req(GetTableResult& _return, const GetTableRequest& req) override;
  int32_t send_get_table_req(const GetTableRequest& req);
  void recv_get_table_req(GetTableResult& _return, const int32_t seqid);
  void get_table_objects_by_name_req(GetTablesResult& _return, const GetTablesRequest& req) override;
  int32_t send_get_table_objects_by_name_req(const GetTablesRequest& req);
  void recv_get_table_objects_by_name_req(GetTablesResult& _return, const int32_t seqid);
  void get_materialization_invalidation_info(Materialization& _return, const CreationMetadata& creation_metadata, const std::string& validTxnList) override;
  int32_t send_get_materialization_invalidation_info(const CreationMetadata& creation_metadata, const std::string& validTxnList);
  void recv_get_materialization_invalidation_info(Materialization& _return, const int32_t seqid);
  void update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata) override;
  int32_t send_update_creation_metadata(const std::string& catName, const std::string& dbname, const std::string& tbl_name, const CreationMetadata& creation_metadata);
  void recv_update_creation_metadata(const int32_t seqid);
  void get_table_names_by_filter(std::vector<std::string> & _return, const std::string& dbname, const std::string& filter, const int16_t max_tables) override;
  int32_t 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, const int32_t seqid);
  void alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl) override;
  int32_t send_alter_table(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl);
  void recv_alter_table(const int32_t seqid);
  void alter_table_with_environment_context(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const EnvironmentContext& environment_context) override;
  int32_t 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(const int32_t seqid);
  void alter_table_with_cascade(const std::string& dbname, const std::string& tbl_name, const Table& new_tbl, const bool cascade) override;
  int32_t 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(const int32_t seqid);
  void add_partition(Partition& _return, const Partition& new_part) override;
  int32_t send_add_partition(const Partition& new_part);
  void recv_add_partition(Partition& _return, const int32_t seqid);
  void add_partition_with_environment_context(Partition& _return, const Partition& new_part, const EnvironmentContext& environment_context) override;
  int32_t send_add_partition_with_environment_context(const Partition& new_part, const EnvironmentContext& environment_context);
  void recv_add_partition_with_environment_context(Partition& _return, const int32_t seqid);
  int32_t add_partitions(const std::vector<Partition> & new_parts) override;
  int32_t send_add_partitions(const std::vector<Partition> & new_parts);
  int32_t recv_add_partitions(const int32_t seqid);
  int32_t add_partitions_pspec(const std::vector<PartitionSpec> & new_parts) override;
  int32_t send_add_partitions_pspec(const std::vector<PartitionSpec> & new_parts);
  int32_t recv_add_partitions_pspec(const int32_t seqid);
  void append_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals) override;
  int32_t 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, const int32_t seqid);
  void add_partitions_req(AddPartitionsResult& _return, const AddPartitionsRequest& request) override;
  int32_t send_add_partitions_req(const AddPartitionsRequest& request);
  void recv_add_partitions_req(AddPartitionsResult& _return, const int32_t seqid);
  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) override;
  int32_t 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, const int32_t seqid);
  void append_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) override;
  int32_t 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, const int32_t seqid);
  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) override;
  int32_t 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, const int32_t seqid);
  bool drop_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const bool deleteData) override;
  int32_t 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(const int32_t seqid);
  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) override;
  int32_t 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(const int32_t seqid);
  bool drop_partition_by_name(const std::string& db_name, const std::string& tbl_name, const std::string& part_name, const bool deleteData) override;
  int32_t 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(const int32_t seqid);
  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) override;
  int32_t 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(const int32_t seqid);
  void drop_partitions_req(DropPartitionsResult& _return, const DropPartitionsRequest& req) override;
  int32_t send_drop_partitions_req(const DropPartitionsRequest& req);
  void recv_drop_partitions_req(DropPartitionsResult& _return, const int32_t seqid);
  void get_partition(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals) override;
  int32_t 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, const int32_t seqid);
  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) override;
  int32_t 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, const int32_t seqid);
  void exchange_partitions(std::vector<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) override;
  int32_t send_exchange_partitions(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_partitions(std::vector<Partition> & _return, const int32_t seqid);
  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) override;
  int32_t 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, const int32_t seqid);
  void get_partition_by_name(Partition& _return, const std::string& db_name, const std::string& tbl_name, const std::string& part_name) override;
  int32_t 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, const int32_t seqid);
  void get_partitions(std::vector<Partition> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) override;
  int32_t 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, const int32_t seqid);
  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) override;
  int32_t 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, const int32_t seqid);
  void get_partitions_pspec(std::vector<PartitionSpec> & _return, const std::string& db_name, const std::string& tbl_name, const int32_t max_parts) override;
  int32_t 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, const int32_t seqid);
  void get_partition_names(std::vector<std::string> & _return, const std::string& db_name, const std::string& tbl_name, const int16_t max_parts) override;
  int32_t 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, const int32_t seqid);
  void get_partition_values(PartitionValuesResponse& _return, const PartitionValuesRequest& request) override;
  int32_t send_get_partition_values(const PartitionValuesRequest& request);
  void recv_get_partition_values(PartitionValuesResponse& _return, const int32_t seqid);
  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) override;
  int32_t 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, const int32_t seqid);
  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) override;
  int32_t 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, const int32_t seqid);
  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) override;
  int32_t 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, const int32_t seqid);
  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) override;
  int32_t 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, const int32_t seqid);
  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) override;
  int32_t 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, const int32_t seqid);
  void get_partitions_by_expr(PartitionsByExprResult& _return, const PartitionsByExprRequest& req) override;
  int32_t send_get_partitions_by_expr(const PartitionsByExprRequest& req);
  void recv_get_partitions_by_expr(PartitionsByExprResult& _return, const int32_t seqid);
  int32_t get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter) override;
  int32_t send_get_num_partitions_by_filter(const std::string& db_name, const std::string& tbl_name, const std::string& filter);
  int32_t recv_get_num_partitions_by_filter(const int32_t seqid);
  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) override;
  int32_t 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, const int32_t seqid);
  void alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part) override;
  int32_t send_alter_partition(const std::string& db_name, const std::string& tbl_name, const Partition& new_part);
  void recv_alter_partition(const int32_t seqid);
  void alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts) override;
  int32_t send_alter_partitions(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts);
  void recv_alter_partitions(const int32_t seqid);
  void alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts, const EnvironmentContext& environment_context) override;
  int32_t send_alter_partitions_with_environment_context(const std::string& db_name, const std::string& tbl_name, const std::vector<Partition> & new_parts, const EnvironmentContext& environment_context);
  void recv_alter_partitions_with_environment_context(const int32_t seqid);
  void alter_partition_with_environment_context(const std::string& db_name, const std::string& tbl_name, const Partition& new_part, const EnvironmentContext& environment_context) override;
  int32_t 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(const int32_t seqid);
  void rename_partition(const std::string& db_name, const std::string& tbl_name, const std::vector<std::string> & part_vals, const Partition& new_part) override;
  int32_t 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(const int32_t seqid);
  bool partition_name_has_valid_characters(const std::vector<std::string> & part_vals, const bool throw_exception) override;
  int32_t send_partition_name_has_valid_characters(const std::vector<std::string> & part_vals, const bool throw_exception);
  bool recv_partition_name_has_valid_characters(const int32_t seqid);
  void get_config_value(std::string& _return, const std::string& name, const std::string& defaultValue) override;
  int32_t send_get_config_value(const std::string& name, const std::string& defaultValue);
  void recv_get_config_value(std::string& _return, const int32_t seqid);
  void partition_name_to_vals(std::vector<std::string> & _return, const std::string& part_name) override;
  int32_t send_partition_name_to_vals(const std::string& part_name);
  void recv_partition_name_to_vals(std::vector<std::string> & _return, const int32_t seqid);
  void partition_name_to_spec(std::map<std::string, std::string> & _return, const std::string& part_name) override;
  int32_t send_partition_name_to_spec(const std::string& part_name);
  void recv_partition_name_to_spec(std::map<std::string, std::string> & _return, const int32_t seqid);
  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) override;
  int32_t 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(const int32_t seqid);
  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) override;
  int32_t 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(const int32_t seqid);
  void get_primary_keys(PrimaryKeysResponse& _return, const PrimaryKeysRequest& request) override;
  int32_t send_get_primary_keys(const PrimaryKeysRequest& request);
  void recv_get_primary_keys(PrimaryKeysResponse& _return, const int32_t seqid);
  void get_foreign_keys(ForeignKeysResponse& _return, const ForeignKeysRequest& request) override;
  int32_t send_get_foreign_keys(const ForeignKeysRequest& request);
  void recv_get_foreign_keys(ForeignKeysResponse& _return, const int32_t seqid);
  void get_unique_constraints(UniqueConstraintsResponse& _return, const UniqueConstraintsRequest& request) override;
  int32_t send_get_unique_constraints(const UniqueConstraintsRequest& request);
  void recv_get_unique_constraints(UniqueConstraintsResponse& _return, const int32_t seqid);
  void get_not_null_constraints(NotNullConstraintsResponse& _return, const NotNullConstraintsRequest& request) override;
  int32_t send_get_not_null_constraints(const NotNullConstraintsRequest& request);
  void recv_get_not_null_constraints(NotNullConstraintsResponse& _return, const int32_t seqid);
  void get_default_constraints(DefaultConstraintsResponse& _return, const DefaultConstraintsRequest& request) override;
  int32_t send_get_default_constraints(const DefaultConstraintsRequest& request);
  void recv_get_default_constraints(DefaultConstraintsResponse& _return, const int32_t seqid);
  void get_check_constraints(CheckConstraintsResponse& _return, const CheckConstraintsRequest& request) override;
  int32_t send_get_check_constraints(const CheckConstraintsRequest& request);
  void recv_get_check_constraints(CheckConstraintsResponse& _return, const int32_t seqid);
  bool update_table_column_statistics(const ColumnStatistics& stats_obj) override;
  int32_t send_update_table_column_statistics(const ColumnStatistics& stats_obj);
  bool recv_update_table_column_statistics(const int32_t seqid);
  bool update_partition_column_statistics(const ColumnStatistics& stats_obj) override;
  int32_t send_update_partition_column_statistics(const ColumnStatistics& stats_obj);
  bool recv_update_partition_column_statistics(const int32_t seqid);
  void get_table_column_statistics(ColumnStatistics& _return, const std::string& db_name, const std::string& tbl_name, const std::string& col_name) override;
  int32_t 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, const int32_t seqid);
  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) override;
  int32_t 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, const int32_t seqid);
  void get_table_statistics_req(TableStatsResult& _return, const TableStatsRequest& request) override;
  int32_t send_get_table_statistics_req(const TableStatsRequest& request);
  void recv_get_table_statistics_req(TableStatsResult& _return, const int32_t seqid);
  void get_partitions_statistics_req(PartitionsStatsResult& _return, const PartitionsStatsRequest& request) override;
  int32_t send_get_partitions_statistics_req(const PartitionsStatsRequest& request);
  void recv_get_partitions_statistics_req(PartitionsStatsResult& _return, const int32_t seqid);
  void get_aggr_stats_for(AggrStats& _return, const PartitionsStatsRequest& request) override;
  int32_t send_get_aggr_stats_for(const PartitionsStatsRequest& request);
  void recv_get_aggr_stats_for(AggrStats& _return, const int32_t seqid);
  bool set_aggr_stats_for(const SetPartitionsStatsRequest& request) override;
  int32_t send_set_aggr_stats_for(const SetPartitionsStatsRequest& request);
  bool recv_set_aggr_stats_for(const int32_t seqid);
  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) override;
  int32_t 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(const int32_t seqid);
  bool delete_table_column_statistics(const std::string& db_name, const std::string& tbl_name, const std::string& col_name) override;
  int32_t 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(const int32_t seqid);
  void create_function(const Function& func) override;
  int32_t send_create_function(const Function& func);
  void recv_create_function(const int32_t seqid);
  void drop_function(const std::string& dbName, const std::string& funcName) override;
  int32_t send_drop_function(const std::string& dbName, const std::string& funcName);
  void recv_drop_function(const int32_t seqid);
  void alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc) override;
  int32_t send_alter_function(const std::string& dbName, const std::string& funcName, const Function& newFunc);
  void recv_alter_function(const int32_t seqid);
  void get_functions(std::vector<std::string> & _return, const std::string& dbName, const std::string& pattern) override;
  int32_t send_get_functions(const std::string& dbName, const std::string& pattern);
  void recv_get_functions(std::vector<std::string> & _return, const int32_t seqid);
  void get_function(Function& _return, const std::string& dbName, const std::string& funcName) override;
  int32_t send_get_function(const std::string& dbName, const std::string& funcName);
  void recv_get_function(Function& _return, const int32_t seqid);
  void get_all_functions(GetAllFunctionsResponse& _return) override;
  int32_t send_get_all_functions();
  void recv_get_all_functions(GetAllFunctionsResponse& _return, const int32_t seqid);
  bool create_role(const Role& role) override;
  int32_t send_create_role(const Role& role);
  bool recv_create_role(const int32_t seqid);
  bool drop_role(const std::string& role_name) override;
  int32_t send_drop_role(const std::string& role_name);
  bool recv_drop_role(const int32_t seqid);
  void get_role_names(std::vector<std::string> & _return) override;
  int32_t send_get_role_names();
  void recv_get_role_names(std::vector<std::string> & _return, const int32_t seqid);
  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) override;
  int32_t 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(const int32_t seqid);
  bool revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type) override;
  int32_t send_revoke_role(const std::string& role_name, const std::string& principal_name, const PrincipalType::type principal_type);
  bool recv_revoke_role(const int32_t seqid);
  void list_roles(std::vector<Role> & _return, const std::string& principal_name, const PrincipalType::type principal_type) override;
  int32_t send_list_roles(const std::string& principal_name, const PrincipalType::type principal_type);
  void recv_list_roles(std::vector<Role> & _return, const int32_t seqid);
  void grant_revoke_role(GrantRevokeRoleResponse& _return, const GrantRevokeRoleRequest& request) override;
  int32_t send_grant_revoke_role(const GrantRevokeRoleRequest& request);
  void recv_grant_revoke_role(GrantRevokeRoleResponse& _return, const int32_t seqid);
  void get_principals_in_role(GetPrincipalsInRoleResponse& _return, const GetPrincipalsInRoleRequest& request) override;
  int32_t send_get_principals_in_role(const GetPrincipalsInRoleRequest& request);
  void recv_get_principals_in_role(GetPrincipalsInRoleResponse& _return, const int32_t seqid);
  void get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const GetRoleGrantsForPrincipalRequest& request) override;
  int32_t send_get_role_grants_for_principal(const GetRoleGrantsForPrincipalRequest& request);
  void recv_get_role_grants_for_principal(GetRoleGrantsForPrincipalResponse& _return, const int32_t seqid);
  void get_privilege_set(PrincipalPrivilegeSet& _return, const HiveObjectRef& hiveObject, const std::string& user_name, const std::vector<std::string> & group_names) override;
  int32_t 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, const int32_t seqid);
  void list_privileges(std::vector<HiveObjectPrivilege> & _return, const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject) override;
  int32_t send_list_privileges(const std::string& principal_name, const PrincipalType::type principal_type, const HiveObjectRef& hiveObject);
  void recv_list_privileges(std::vector<HiveObjectPrivilege> & _return, const int32_t seqid);
  bool grant_privileges(const PrivilegeBag& privileges) override;
  int32_t send_grant_privileges(const PrivilegeBag& privileges);
  bool recv_grant_privileges(const int32_t seqid);
  bool revoke_privileges(const PrivilegeBag& privileges) override;
  int32_t send_revoke_privileges(const PrivilegeBag& privileges);
  bool recv_revoke_privileges(const int32_t seqid);
  void grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const GrantRevokePrivilegeRequest& request) override;
  int32_t send_grant_revoke_privileges(const GrantRevokePrivilegeRequest& request);
  void recv_grant_revoke_privileges(GrantRevokePrivilegeResponse& _return, const int32_t seqid);
  void refresh_privileges(GrantRevokePrivilegeResponse& _return, const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest) override;
  int32_t send_refresh_privileges(const HiveObjectRef& objToRefresh, const std::string& authorizer, const GrantRevokePrivilegeRequest& grantRequest);
  void recv_refresh_privileges(GrantRevokePrivilegeResponse& _return, const int32_t seqid);
  void set_ugi(std::vector<std::string> & _return, const std::string& user_name, const std::vector<std::string> & group_names) override;
  int32_t send_set_ugi(const std::string& user_name, const std::vector<std::string> & group_names);
  void recv_set_ugi(std::vector<std::string> & _return, const int32_t seqid);
  void get_delegation_token(std::string& _return, const std::string& token_owner, const std::string& renewer_kerberos_principal_name) override;
  int32_t send_get_delegation_token(const std::string& token_owner, const std::string& renewer_kerberos_principal_name);
  void recv_get_delegation_token(std::string& _return, const int32_t seqid);
  int64_t renew_delegation_token(const std::string& token_str_form) override;
  int32_t send_renew_delegation_token(const std::string& token_str_form);
  int64_t recv_renew_delegation_token(const int32_t seqid);
  void cancel_delegation_token(const std::string& token_str_form) override;
  int32_t send_cancel_delegation_token(const std::string& token_str_form);
  void recv_cancel_delegation_token(const int32_t seqid);
  bool add_token(const std::string& token_identifier, const std::string& delegation_token) override;
  int32_t send_add_token(const std::string& token_identifier, const std::string& delegation_token);
  bool recv_add_token(const int32_t seqid);
  bool remove_token(const std::string& token_identifier) override;
  int32_t send_remove_token(const std::string& token_identifier);
  bool recv_remove_token(const int32_t seqid);
  void get_token(std::string& _return, const std::string& token_identifier) override;
  int32_t send_get_token(const std::string& token_identifier);
  void recv_get_token(std::string& _return, const int32_t seqid);
  void get_all_token_identifiers(std::vector<std::string> & _return) override;
  int32_t send_get_all_token_identifiers();
  void recv_get_all_token_identifiers(std::vector<std::string> & _return, const int32_t seqid);
  int32_t add_master_key(const std::string& key) override;
  int32_t send_add_master_key(const std::string& key);
  int32_t recv_add_master_key(const int32_t seqid);
  void update_master_key(const int32_t seq_number, const std::string& key) override;
  int32_t send_update_master_key(const int32_t seq_number, const std::string& key);
  void recv_update_master_key(const int32_t seqid);
  bool remove_master_key(const int32_t key_seq) override;
  int32_t send_remove_master_key(const int32_t key_seq);
  bool recv_remove_master_key(const int32_t seqid);
  void get_master_keys(std::vector<std::string> & _return) override;
  int32_t send_get_master_keys();
  void recv_get_master_keys(std::vector<std::string> & _return, const int32_t seqid);
  void get_open_txns(GetOpenTxnsResponse& _return) override;
  int32_t send_get_open_txns();
  void recv_get_open_txns(GetOpenTxnsResponse& _return, const int32_t seqid);
  void get_open_txns_info(GetOpenTxnsInfoResponse& _return) override;
  int32_t send_get_open_txns_info();
  void recv_get_open_txns_info(GetOpenTxnsInfoResponse& _return, const int32_t seqid);
  void open_txns(OpenTxnsResponse& _return, const OpenTxnRequest& rqst) override;
  int32_t send_open_txns(const OpenTxnRequest& rqst);
  void recv_open_txns(OpenTxnsResponse& _return, const int32_t seqid);
  void abort_txn(const AbortTxnRequest& rqst) override;
  int32_t send_abort_txn(const AbortTxnRequest& rqst);
  void recv_abort_txn(const int32_t seqid);
  void abort_txns(const AbortTxnsRequest& rqst) override;
  int32_t send_abort_txns(const AbortTxnsRequest& rqst);
  void recv_abort_txns(const int32_t seqid);
  void commit_txn(const CommitTxnRequest& rqst) override;
  int32_t send_commit_txn(const CommitTxnRequest& rqst);
  void recv_commit_txn(const int32_t seqid);
  void repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst) override;
  int32_t send_repl_tbl_writeid_state(const ReplTblWriteIdStateRequest& rqst);
  void recv_repl_tbl_writeid_state(const int32_t seqid);
  void get_valid_write_ids(GetValidWriteIdsResponse& _return, const GetValidWriteIdsRequest& rqst) override;
  int32_t send_get_valid_write_ids(const GetValidWriteIdsRequest& rqst);
  void recv_get_valid_write_ids(GetValidWriteIdsResponse& _return, const int32_t seqid);
  void allocate_table_write_ids(AllocateTableWriteIdsResponse& _return, const AllocateTableWriteIdsRequest& rqst) override;
  int32_t send_allocate_table_write_ids(const AllocateTableWriteIdsRequest& rqst);
  void recv_allocate_table_write_ids(AllocateTableWriteIdsResponse& _return, const int32_t seqid);
  void lock(LockResponse& _return, const LockRequest& rqst) override;
  int32_t send_lock(const LockRequest& rqst);
  void recv_lock(LockResponse& _return, const int32_t seqid);
  void check_lock(LockResponse& _return, const CheckLockRequest& rqst) override;
  int32_t send_check_lock(const CheckLockRequest& rqst);
  void recv_check_lock(LockResponse& _return, const int32_t seqid);
  void unlock(const UnlockRequest& rqst) override;
  int32_t send_unlock(const UnlockRequest& rqst);
  void recv_unlock(const int32_t seqid);
  void show_locks(ShowLocksResponse& _return, const ShowLocksRequest& rqst) override;
  int32_t send_show_locks(const ShowLocksRequest& rqst);
  void recv_show_locks(ShowLocksResponse& _return, const int32_t seqid);
  void heartbeat(const HeartbeatRequest& ids) override;
  int32_t send_heartbeat(const HeartbeatRequest& ids);
  void recv_heartbeat(const int32_t seqid);
  void heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const HeartbeatTxnRangeRequest& txns) override;
  int32_t send_heartbeat_txn_range(const HeartbeatTxnRangeRequest& txns);
  void recv_heartbeat_txn_range(HeartbeatTxnRangeResponse& _return, const int32_t seqid);
  void compact(const CompactionRequest& rqst) override;
  int32_t send_compact(const CompactionRequest& rqst);
  void recv_compact(const int32_t seqid);
  void compact2(CompactionResponse& _return, const CompactionRequest& rqst) override;
  int32_t send_compact2(const CompactionRequest& rqst);
  void recv_compact2(CompactionResponse& _return, const int32_t seqid);
  void show_compact(ShowCompactResponse& _return, const ShowCompactRequest& rqst) override;
  int32_t send_show_compact(const ShowCompactRequest& rqst);
  void recv_show_compact(ShowCompactResponse& _return, const int32_t seqid);
  void add_dynamic_partitions(const AddDynamicPartitions& rqst) override;
  int32_t send_add_dynamic_partitions(const AddDynamicPartitions& rqst);
  void recv_add_dynamic_partitions(const int32_t seqid);
  void get_next_notification(NotificationEventResponse& _return, const NotificationEventRequest& rqst) override;
  int32_t send_get_next_notification(const NotificationEventRequest& rqst);
  void recv_get_next_notification(NotificationEventResponse& _return, const int32_t seqid);
  void get_current_notificationEventId(CurrentNotificationEventId& _return) override;
  int32_t send_get_current_notificationEventId();
  void recv_get_current_notificationEventId(CurrentNotificationEventId& _return, const int32_t seqid);
  void get_notification_events_count(NotificationEventsCountResponse& _return, const NotificationEventsCountRequest& rqst) override;
  int32_t send_get_notification_events_count(const NotificationEventsCountRequest& rqst);
  void recv_get_notification_events_count(NotificationEventsCountResponse& _return, const int32_t seqid);
  void fire_listener_event(FireEventResponse& _return, const FireEventRequest& rqst) override;
  int32_t send_fire_listener_event(const FireEventRequest& rqst);
  void recv_fire_listener_event(FireEventResponse& _return, const int32_t seqid);
  void flushCache() override;
  int32_t send_flushCache();
  void recv_flushCache(const int32_t seqid);
  void cm_recycle(CmRecycleResponse& _return, const CmRecycleRequest& request) override;
  int32_t send_cm_recycle(const CmRecycleRequest& request);
  void recv_cm_recycle(CmRecycleResponse& _return, const int32_t seqid);
  void get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const GetFileMetadataByExprRequest& req) override;
  int32_t send_get_file_metadata_by_expr(const GetFileMetadataByExprRequest& req);
  void recv_get_file_metadata_by_expr(GetFileMetadataByExprResult& _return, const int32_t seqid);
  void get_file_metadata(GetFileMetadataResult& _return, const GetFileMetadataRequest& req) override;
  int32_t send_get_file_metadata(const GetFileMetadataRequest& req);
  void recv_get_file_metadata(GetFileMetadataResult& _return, const int32_t seqid);
  void put_file_metadata(PutFileMetadataResult& _return, const PutFileMetadataRequest& req) override;
  int32_t send_put_file_metadata(const PutFileMetadataRequest& req);
  void recv_put_file_metadata(PutFileMetadataResult& _return, const int32_t seqid);
  void clear_file_metadata(ClearFileMetadataResult& _return, const ClearFileMetadataRequest& req) override;
  int32_t send_clear_file_metadata(const ClearFileMetadataRequest& req);
  void recv_clear_file_metadata(ClearFileMetadataResult& _return, const int32_t seqid);
  void cache_file_metadata(CacheFileMetadataResult& _return, const CacheFileMetadataRequest& req) override;
  int32_t send_cache_file_metadata(const CacheFileMetadataRequest& req);
  void recv_cache_file_metadata(CacheFileMetadataResult& _return, const int32_t seqid);
  void get_metastore_db_uuid(std::string& _return) override;
  int32_t send_get_metastore_db_uuid();
  void recv_get_metastore_db_uuid(std::string& _return, const int32_t seqid);
  void create_resource_plan(WMCreateResourcePlanResponse& _return, const WMCreateResourcePlanRequest& request) override;
  int32_t send_create_resource_plan(const WMCreateResourcePlanRequest& request);
  void recv_create_resource_plan(WMCreateResourcePlanResponse& _return, const int32_t seqid);
  void get_resource_plan(WMGetResourcePlanResponse& _return, const WMGetResourcePlanRequest& request) override;
  int32_t send_get_resource_plan(const WMGetResourcePlanRequest& request);
  void recv_get_resource_plan(WMGetResourcePlanResponse& _return, const int32_t seqid);
  void get_active_resource_plan(WMGetActiveResourcePlanResponse& _return, const WMGetActiveResourcePlanRequest& request) override;
  int32_t send_get_active_resource_plan(const WMGetActiveResourcePlanRequest& request);
  void recv_get_active_resource_plan(WMGetActiveResourcePlanResponse& _return, const int32_t seqid);
  void get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const WMGetAllResourcePlanRequest& request) override;
  int32_t send_get_all_resource_plans(const WMGetAllResourcePlanRequest& request);
  void recv_get_all_resource_plans(WMGetAllResourcePlanResponse& _return, const int32_t seqid);
  void alter_resource_plan(WMAlterResourcePlanResponse& _return, const WMAlterResourcePlanRequest& request) override;
  int32_t send_alter_resource_plan(const WMAlterResourcePlanRequest& request);
  void recv_alter_resource_plan(WMAlterResourcePlanResponse& _return, const int32_t seqid);
  void validate_resource_plan(WMValidateResourcePlanResponse& _return, const WMValidateResourcePlanRequest& request) override;
  int32_t send_validate_resource_plan(const WMValidateResourcePlanRequest& request);
  void recv_validate_resource_plan(WMValidateResourcePlanResponse& _return, const int32_t seqid);
  void drop_resource_plan(WMDropResourcePlanResponse& _return, const WMDropResourcePlanRequest& request) override;
  int32_t send_drop_resource_plan(const WMDropResourcePlanRequest& request);
  void recv_drop_resource_plan(WMDropResourcePlanResponse& _return, const int32_t seqid);
  void create_wm_trigger(WMCreateTriggerResponse& _return, const WMCreateTriggerRequest& request) override;
  int32_t send_create_wm_trigger(const WMCreateTriggerRequest& request);
  void recv_create_wm_trigger(WMCreateTriggerResponse& _return, const int32_t seqid);
  void alter_wm_trigger(WMAlterTriggerResponse& _return, const WMAlterTriggerRequest& request) override;
  int32_t send_alter_wm_trigger(const WMAlterTriggerRequest& request);
  void recv_alter_wm_trigger(WMAlterTriggerResponse& _return, const int32_t seqid);
  void drop_wm_trigger(WMDropTriggerResponse& _return, const WMDropTriggerRequest& request) override;
  int32_t send_drop_wm_trigger(const WMDropTriggerRequest& request);
  void recv_drop_wm_trigger(WMDropTriggerResponse& _return, const int32_t seqid);
  void get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const WMGetTriggersForResourePlanRequest& request) override;
  int32_t send_get_triggers_for_resourceplan(const WMGetTriggersForResourePlanRequest& request);
  void recv_get_triggers_for_resourceplan(WMGetTriggersForResourePlanResponse& _return, const int32_t seqid);
  void create_wm_pool(WMCreatePoolResponse& _return, const WMCreatePoolRequest& request) override;
  int32_t send_create_wm_pool(const WMCreatePoolRequest& request);
  void recv_create_wm_pool(WMCreatePoolResponse& _return, const int32_t seqid);
  void alter_wm_pool(WMAlterPoolResponse& _return, const WMAlterPoolRequest& request) override;
  int32_t send_alter_wm_pool(const WMAlterPoolRequest& request);
  void recv_alter_wm_pool(WMAlterPoolResponse& _return, const int32_t seqid);
  void drop_wm_pool(WMDropPoolResponse& _return, const WMDropPoolRequest& request) override;
  int32_t send_drop_wm_pool(const WMDropPoolRequest& request);
  void recv_drop_wm_pool(WMDropPoolResponse& _return, const int32_t seqid);
  void create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const WMCreateOrUpdateMappingRequest& request) override;
  int32_t send_create_or_update_wm_mapping(const WMCreateOrUpdateMappingRequest& request);
  void recv_create_or_update_wm_mapping(WMCreateOrUpdateMappingResponse& _return, const int32_t seqid);
  void drop_wm_mapping(WMDropMappingResponse& _return, const WMDropMappingRequest& request) override;
  int32_t send_drop_wm_mapping(const WMDropMappingRequest& request);
  void recv_drop_wm_mapping(WMDropMappingResponse& _return, const int32_t seqid);
  void create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const WMCreateOrDropTriggerToPoolMappingRequest& request) override;
  int32_t send_create_or_drop_wm_trigger_to_pool_mapping(const WMCreateOrDropTriggerToPoolMappingRequest& request);
  void recv_create_or_drop_wm_trigger_to_pool_mapping(WMCreateOrDropTriggerToPoolMappingResponse& _return, const int32_t seqid);
  void create_ischema(const ISchema& schema) override;
  int32_t send_create_ischema(const ISchema& schema);
  void recv_create_ischema(const int32_t seqid);
  void alter_ischema(const AlterISchemaRequest& rqst) override;
  int32_t send_alter_ischema(const AlterISchemaRequest& rqst);
  void recv_alter_ischema(const int32_t seqid);
  void get_ischema(ISchema& _return, const ISchemaName& name) override;
  int32_t send_get_ischema(const ISchemaName& name);
  void recv_get_ischema(ISchema& _return, const int32_t seqid);
  void drop_ischema(const ISchemaName& name) override;
  int32_t send_drop_ischema(const ISchemaName& name);
  void recv_drop_ischema(const int32_t seqid);
  void add_schema_version(const SchemaVersion& schemaVersion) override;
  int32_t send_add_schema_version(const SchemaVersion& schemaVersion);
  void recv_add_schema_version(const int32_t seqid);
  void get_schema_version(SchemaVersion& _return, const SchemaVersionDescriptor& schemaVersion) override;
  int32_t send_get_schema_version(const SchemaVersionDescriptor& schemaVersion);
  void recv_get_schema_version(SchemaVersion& _return, const int32_t seqid);
  void get_schema_latest_version(SchemaVersion& _return, const ISchemaName& schemaName) override;
  int32_t send_get_schema_latest_version(const ISchemaName& schemaName);
  void recv_get_schema_latest_version(SchemaVersion& _return, const int32_t seqid);
  void get_schema_all_versions(std::vector<SchemaVersion> & _return, const ISchemaName& schemaName) override;
  int32_t send_get_schema_all_versions(const ISchemaName& schemaName);
  void recv_get_schema_all_versions(std::vector<SchemaVersion> & _return, const int32_t seqid);
  void drop_schema_version(const SchemaVersionDescriptor& schemaVersion) override;
  int32_t send_drop_schema_version(const SchemaVersionDescriptor& schemaVersion);
  void recv_drop_schema_version(const int32_t seqid);
  void get_schemas_by_cols(FindSchemasByColsResp& _return, const FindSchemasByColsRqst& rqst) override;
  int32_t send_get_schemas_by_cols(const FindSchemasByColsRqst& rqst);
  void recv_get_schemas_by_cols(FindSchemasByColsResp& _return, const int32_t seqid);
  void map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst) override;
  int32_t send_map_schema_version_to_serde(const MapSchemaVersionToSerdeRequest& rqst);
  void recv_map_schema_version_to_serde(const int32_t seqid);
  void set_schema_version_state(const SetSchemaVersionStateRequest& rqst) override;
  int32_t send_set_schema_version_state(const SetSchemaVersionStateRequest& rqst);
  void recv_set_schema_version_state(const int32_t seqid);
  void add_serde(const SerDeInfo& serde) override;
  int32_t send_add_serde(const SerDeInfo& serde);
  void recv_add_serde(const int32_t seqid);
  void get_serde(SerDeInfo& _return, const GetSerdeRequest& rqst) override;
  int32_t send_get_serde(const GetSerdeRequest& rqst);
  void recv_get_serde(SerDeInfo& _return, const int32_t seqid);
  void get_lock_materialization_rebuild(LockResponse& _return, const std::string& dbName, const std::string& tableName, const int64_t txnId) override;
  int32_t send_get_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId);
  void recv_get_lock_materialization_rebuild(LockResponse& _return, const int32_t seqid);
  bool heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId) override;
  int32_t send_heartbeat_lock_materialization_rebuild(const std::string& dbName, const std::string& tableName, const int64_t txnId);
  bool recv_heartbeat_lock_materialization_rebuild(const int32_t seqid);
  void add_runtime_stats(const RuntimeStat& stat) override;
  int32_t send_add_runtime_stats(const RuntimeStat& stat);
  void recv_add_runtime_stats(const int32_t seqid);
  void get_runtime_stats(std::vector<RuntimeStat> & _return, const GetRuntimeStatsRequest& rqst) override;
  int32_t send_get_runtime_stats(const GetRuntimeStatsRequest& rqst);
  void recv_get_runtime_stats(std::vector<RuntimeStat> & _return, const int32_t seqid);
};

#ifdef _MSC_VER
  #pragma warning( pop )
#endif

}}} // namespace

#endif
