Struct hive_metastore :: ThriftHiveMetastoreGenericClient Copy item path

impl<S: Service<ClientContext, ThriftHiveMetastoreRequestSend, Response = Option<ThriftHiveMetastoreResponseRecv>, Error = ClientError> + Send + Sync + 'static> ThriftHiveMetastoreGenericClient<S>

pub fn with_callopt<Opt: Apply<ClientContext>>( self, opt: Opt, ) -> ThriftHiveMetastoreOneShotClient<WithOptService<S, Opt>>

pub async fn get_meta_conf( &self, key: FastStr, ) -> Result<MaybeException<FastStr, ThriftHiveMetastoreGetMetaConfException>, ClientError>

pub async fn set_meta_conf( &self, key: FastStr, value: FastStr, ) -> Result<MaybeException<(), ThriftHiveMetastoreSetMetaConfException>, ClientError>

pub async fn create_database( &self, database: Database, ) -> Result<MaybeException<(), ThriftHiveMetastoreCreateDatabaseException>, ClientError>

pub async fn get_database( &self, name: FastStr, ) -> Result<MaybeException<Database, ThriftHiveMetastoreGetDatabaseException>, ClientError>

pub async fn drop_database( &self, name: FastStr, delete_data: bool, cascade: bool, ) -> Result<MaybeException<(), ThriftHiveMetastoreDropDatabaseException>, ClientError>

pub async fn get_databases( &self, pattern: FastStr, ) -> Result<MaybeException<Vec<FastStr>, ThriftHiveMetastoreGetDatabasesException>, ClientError>

pub async fn get_all_databases( &self, ) -> Result<MaybeException<Vec<FastStr>, ThriftHiveMetastoreGetAllDatabasesException>, ClientError>

pub async fn alter_database( &self, dbname: FastStr, db: Database, ) -> Result<MaybeException<(), ThriftHiveMetastoreAlterDatabaseException>, ClientError>

pub async fn get_type( &self, name: FastStr, ) -> Result<MaybeException<Type, ThriftHiveMetastoreGetTypeException>, ClientError>

pub async fn create_type( &self, type: Type, ) -> Result<MaybeException<bool, ThriftHiveMetastoreCreateTypeException>, ClientError>

pub async fn drop_type( &self, type: FastStr, ) -> Result<MaybeException<bool, ThriftHiveMetastoreDropTypeException>, ClientError>

pub async fn get_type_all( &self, name: FastStr, ) -> Result<MaybeException<AHashMap<FastStr, Type>, ThriftHiveMetastoreGetTypeAllException>, ClientError>

pub async fn get_fields( &self, db_name: FastStr, table_name: FastStr, ) -> Result<MaybeException<Vec<FieldSchema>, ThriftHiveMetastoreGetFieldsException>, ClientError>

pub async fn get_fields_with_environment_context( &self, db_name: FastStr, table_name: FastStr, environment_context: EnvironmentContext, ) -> Result<MaybeException<Vec<FieldSchema>, ThriftHiveMetastoreGetFieldsWithEnvironmentContextException>, ClientError>

pub async fn get_schema( &self, db_name: FastStr, table_name: FastStr, ) -> Result<MaybeException<Vec<FieldSchema>, ThriftHiveMetastoreGetSchemaException>, ClientError>

pub async fn get_schema_with_environment_context( &self, db_name: FastStr, table_name: FastStr, environment_context: EnvironmentContext, ) -> Result<MaybeException<Vec<FieldSchema>, ThriftHiveMetastoreGetSchemaWithEnvironmentContextException>, ClientError>

pub async fn create_table( &self, tbl: Table, ) -> Result<MaybeException<(), ThriftHiveMetastoreCreateTableException>, ClientError>

pub async fn create_table_with_environment_context( &self, tbl: Table, environment_context: EnvironmentContext, ) -> Result<MaybeException<(), ThriftHiveMetastoreCreateTableWithEnvironmentContextException>, ClientError>

pub async fn create_table_with_constraints( &self, tbl: Table, primary_keys: Vec<SqlPrimaryKey>, foreign_keys: Vec<SqlForeignKey>, ) -> Result<MaybeException<(), ThriftHiveMetastoreCreateTableWithConstraintsException>, ClientError>

pub async fn drop_constraint( &self, req: DropConstraintRequest, ) -> Result<MaybeException<(), ThriftHiveMetastoreDropConstraintException>, ClientError>

pub async fn add_primary_key( &self, req: AddPrimaryKeyRequest, ) -> Result<MaybeException<(), ThriftHiveMetastoreAddPrimaryKeyException>, ClientError>

pub async fn add_foreign_key( &self, req: AddForeignKeyRequest, ) -> Result<MaybeException<(), ThriftHiveMetastoreAddForeignKeyException>, ClientError>

pub async fn drop_table( &self, dbname: FastStr, name: FastStr, delete_data: bool, ) -> Result<MaybeException<(), ThriftHiveMetastoreDropTableException>, ClientError>

pub async fn drop_table_with_environment_context( &self, dbname: FastStr, name: FastStr, delete_data: bool, environment_context: EnvironmentContext, ) -> Result<MaybeException<(), ThriftHiveMetastoreDropTableWithEnvironmentContextException>, ClientError>

pub async fn get_tables( &self, db_name: FastStr, pattern: FastStr, ) -> Result<MaybeException<Vec<FastStr>, ThriftHiveMetastoreGetTablesException>, ClientError>

pub async fn get_tables_by_type( &self, db_name: FastStr, pattern: FastStr, table_type: FastStr, ) -> Result<MaybeException<Vec<FastStr>, ThriftHiveMetastoreGetTablesByTypeException>, ClientError>

pub async fn get_table_meta( &self, db_patterns: FastStr, tbl_patterns: FastStr, tbl_types: Vec<FastStr>, ) -> Result<MaybeException<Vec<TableMeta>, ThriftHiveMetastoreGetTableMetaException>, ClientError>

pub async fn get_all_tables( &self, db_name: FastStr, ) -> Result<MaybeException<Vec<FastStr>, ThriftHiveMetastoreGetAllTablesException>, ClientError>

pub async fn get_table( &self, dbname: FastStr, tbl_name: FastStr, ) -> Result<MaybeException<Table, ThriftHiveMetastoreGetTableException>, ClientError>

pub async fn get_table_objects_by_name( &self, dbname: FastStr, tbl_names: Vec<FastStr>, ) -> Result<MaybeException<Vec<Table>, ThriftHiveMetastoreGetTableObjectsByNameException>, ClientError>

pub async fn get_table_req( &self, req: GetTableRequest, ) -> Result<MaybeException<GetTableResult, ThriftHiveMetastoreGetTableReqException>, ClientError>

pub async fn get_table_objects_by_name_req( &self, req: GetTablesRequest, ) -> Result<MaybeException<GetTablesResult, ThriftHiveMetastoreGetTableObjectsByNameReqException>, ClientError>

pub async fn get_table_names_by_filter( &self, dbname: FastStr, filter: FastStr, max_tables: i16, ) -> Result<MaybeException<Vec<FastStr>, ThriftHiveMetastoreGetTableNamesByFilterException>, ClientError>

pub async fn alter_table( &self, dbname: FastStr, tbl_name: FastStr, new_tbl: Table, ) -> Result<MaybeException<(), ThriftHiveMetastoreAlterTableException>, ClientError>

pub async fn alter_table_with_environment_context( &self, dbname: FastStr, tbl_name: FastStr, new_tbl: Table, environment_context: EnvironmentContext, ) -> Result<MaybeException<(), ThriftHiveMetastoreAlterTableWithEnvironmentContextException>, ClientError>

pub async fn alter_table_with_cascade( &self, dbname: FastStr, tbl_name: FastStr, new_tbl: Table, cascade: bool, ) -> Result<MaybeException<(), ThriftHiveMetastoreAlterTableWithCascadeException>, ClientError>

pub async fn add_partition( &self, new_part: Partition, ) -> Result<MaybeException<Partition, ThriftHiveMetastoreAddPartitionException>, ClientError>

pub async fn add_partition_with_environment_context( &self, new_part: Partition, environment_context: EnvironmentContext, ) -> Result<MaybeException<Partition, ThriftHiveMetastoreAddPartitionWithEnvironmentContextException>, ClientError>

pub async fn add_partitions( &self, new_parts: Vec<Partition>, ) -> Result<MaybeException<i32, ThriftHiveMetastoreAddPartitionsException>, ClientError>

pub async fn add_partitions_pspec( &self, new_parts: Vec<PartitionSpec>, ) -> Result<MaybeException<i32, ThriftHiveMetastoreAddPartitionsPspecException>, ClientError>

pub async fn append_partition( &self, db_name: FastStr, tbl_name: FastStr, part_vals: Vec<FastStr>, ) -> Result<MaybeException<Partition, ThriftHiveMetastoreAppendPartitionException>, ClientError>

pub async fn add_partitions_req( &self, request: AddPartitionsRequest, ) -> Result<MaybeException<AddPartitionsResult, ThriftHiveMetastoreAddPartitionsReqException>, ClientError>

pub async fn append_partition_with_environment_context( &self, db_name: FastStr, tbl_name: FastStr, part_vals: Vec<FastStr>, environment_context: EnvironmentContext, ) -> Result<MaybeException<Partition, ThriftHiveMetastoreAppendPartitionWithEnvironmentContextException>, ClientError>

pub async fn append_partition_by_name( &self, db_name: FastStr, tbl_name: FastStr, part_name: FastStr, ) -> Result<MaybeException<Partition, ThriftHiveMetastoreAppendPartitionByNameException>, ClientError>

pub async fn append_partition_by_name_with_environment_context( &self, db_name: FastStr, tbl_name: FastStr, part_name: FastStr, environment_context: EnvironmentContext, ) -> Result<MaybeException<Partition, ThriftHiveMetastoreAppendPartitionByNameWithEnvironmentContextException>, ClientError>

pub async fn drop_partition( &self, db_name: FastStr, tbl_name: FastStr, part_vals: Vec<FastStr>, delete_data: bool, ) -> Result<MaybeException<bool, ThriftHiveMetastoreDropPartitionException>, ClientError>

pub async fn drop_partition_with_environment_context( &self, db_name: FastStr, tbl_name: FastStr, part_vals: Vec<FastStr>, delete_data: bool, environment_context: EnvironmentContext, ) -> Result<MaybeException<bool, ThriftHiveMetastoreDropPartitionWithEnvironmentContextException>, ClientError>

pub async fn drop_partition_by_name( &self, db_name: FastStr, tbl_name: FastStr, part_name: FastStr, delete_data: bool, ) -> Result<MaybeException<bool, ThriftHiveMetastoreDropPartitionByNameException>, ClientError>

pub async fn drop_partition_by_name_with_environment_context( &self, db_name: FastStr, tbl_name: FastStr, part_name: FastStr, delete_data: bool, environment_context: EnvironmentContext, ) -> Result<MaybeException<bool, ThriftHiveMetastoreDropPartitionByNameWithEnvironmentContextException>, ClientError>

pub async fn drop_partitions_req( &self, req: DropPartitionsRequest, ) -> Result<MaybeException<DropPartitionsResult, ThriftHiveMetastoreDropPartitionsReqException>, ClientError>

pub async fn get_partition( &self, db_name: FastStr, tbl_name: FastStr, part_vals: Vec<FastStr>, ) -> Result<MaybeException<Partition, ThriftHiveMetastoreGetPartitionException>, ClientError>

pub async fn exchange_partition( &self, partition_specs: AHashMap<FastStr, FastStr>, source_db: FastStr, source_table_name: FastStr, dest_db: FastStr, dest_table_name: FastStr, ) -> Result<MaybeException<Partition, ThriftHiveMetastoreExchangePartitionException>, ClientError>

pub async fn exchange_partitions( &self, partition_specs: AHashMap<FastStr, FastStr>, source_db: FastStr, source_table_name: FastStr, dest_db: FastStr, dest_table_name: FastStr, ) -> Result<MaybeException<Vec<Partition>, ThriftHiveMetastoreExchangePartitionsException>, ClientError>

pub async fn get_partition_with_auth( &self, db_name: FastStr, tbl_name: FastStr, part_vals: Vec<FastStr>, user_name: FastStr, group_names: Vec<FastStr>, ) -> Result<MaybeException<Partition, ThriftHiveMetastoreGetPartitionWithAuthException>, ClientError>

pub async fn get_partition_by_name( &self, db_name: FastStr, tbl_name: FastStr, part_name: FastStr, ) -> Result<MaybeException<Partition, ThriftHiveMetastoreGetPartitionByNameException>, ClientError>

pub async fn get_partitions( &self, db_name: FastStr, tbl_name: FastStr, max_parts: i16, ) -> Result<MaybeException<Vec<Partition>, ThriftHiveMetastoreGetPartitionsException>, ClientError>

pub async fn get_partitions_with_auth( &self, db_name: FastStr, tbl_name: FastStr, max_parts: i16, user_name: FastStr, group_names: Vec<FastStr>, ) -> Result<MaybeException<Vec<Partition>, ThriftHiveMetastoreGetPartitionsWithAuthException>, ClientError>

pub async fn get_partitions_pspec( &self, db_name: FastStr, tbl_name: FastStr, max_parts: i32, ) -> Result<MaybeException<Vec<PartitionSpec>, ThriftHiveMetastoreGetPartitionsPspecException>, ClientError>

pub async fn get_partition_names( &self, db_name: FastStr, tbl_name: FastStr, max_parts: i16, ) -> Result<MaybeException<Vec<FastStr>, ThriftHiveMetastoreGetPartitionNamesException>, ClientError>

pub async fn get_partition_values( &self, request: PartitionValuesRequest, ) -> Result<MaybeException<PartitionValuesResponse, ThriftHiveMetastoreGetPartitionValuesException>, ClientError>

pub async fn get_partitions_ps( &self, db_name: FastStr, tbl_name: FastStr, part_vals: Vec<FastStr>, max_parts: i16, ) -> Result<MaybeException<Vec<Partition>, ThriftHiveMetastoreGetPartitionsPsException>, ClientError>

pub async fn get_partitions_ps_with_auth( &self, db_name: FastStr, tbl_name: FastStr, part_vals: Vec<FastStr>, max_parts: i16, user_name: FastStr, group_names: Vec<FastStr>, ) -> Result<MaybeException<Vec<Partition>, ThriftHiveMetastoreGetPartitionsPsWithAuthException>, ClientError>

pub async fn get_partition_names_ps( &self, db_name: FastStr, tbl_name: FastStr, part_vals: Vec<FastStr>, max_parts: i16, ) -> Result<MaybeException<Vec<FastStr>, ThriftHiveMetastoreGetPartitionNamesPsException>, ClientError>

pub async fn get_partitions_by_filter( &self, db_name: FastStr, tbl_name: FastStr, filter: FastStr, max_parts: i16, ) -> Result<MaybeException<Vec<Partition>, ThriftHiveMetastoreGetPartitionsByFilterException>, ClientError>

pub async fn get_part_specs_by_filter( &self, db_name: FastStr, tbl_name: FastStr, filter: FastStr, max_parts: i32, ) -> Result<MaybeException<Vec<PartitionSpec>, ThriftHiveMetastoreGetPartSpecsByFilterException>, ClientError>

pub async fn get_partitions_by_expr( &self, req: PartitionsByExprRequest, ) -> Result<MaybeException<PartitionsByExprResult, ThriftHiveMetastoreGetPartitionsByExprException>, ClientError>

pub async fn get_num_partitions_by_filter( &self, db_name: FastStr, tbl_name: FastStr, filter: FastStr, ) -> Result<MaybeException<i32, ThriftHiveMetastoreGetNumPartitionsByFilterException>, ClientError>

pub async fn get_partitions_by_names( &self, db_name: FastStr, tbl_name: FastStr, names: Vec<FastStr>, ) -> Result<MaybeException<Vec<Partition>, ThriftHiveMetastoreGetPartitionsByNamesException>, ClientError>

pub async fn alter_partition( &self, db_name: FastStr, tbl_name: FastStr, new_part: Partition, ) -> Result<MaybeException<(), ThriftHiveMetastoreAlterPartitionException>, ClientError>

pub async fn alter_partitions( &self, db_name: FastStr, tbl_name: FastStr, new_parts: Vec<Partition>, ) -> Result<MaybeException<(), ThriftHiveMetastoreAlterPartitionsException>, ClientError>

pub async fn alter_partitions_with_environment_context( &self, db_name: FastStr, tbl_name: FastStr, new_parts: Vec<Partition>, environment_context: EnvironmentContext, ) -> Result<MaybeException<(), ThriftHiveMetastoreAlterPartitionsWithEnvironmentContextException>, ClientError>

pub async fn alter_partition_with_environment_context( &self, db_name: FastStr, tbl_name: FastStr, new_part: Partition, environment_context: EnvironmentContext, ) -> Result<MaybeException<(), ThriftHiveMetastoreAlterPartitionWithEnvironmentContextException>, ClientError>

pub async fn rename_partition( &self, db_name: FastStr, tbl_name: FastStr, part_vals: Vec<FastStr>, new_part: Partition, ) -> Result<MaybeException<(), ThriftHiveMetastoreRenamePartitionException>, ClientError>

pub async fn partition_name_has_valid_characters( &self, part_vals: Vec<FastStr>, throw_exception: bool, ) -> Result<MaybeException<bool, ThriftHiveMetastorePartitionNameHasValidCharactersException>, ClientError>

pub async fn get_config_value( &self, name: FastStr, default_value: FastStr, ) -> Result<MaybeException<FastStr, ThriftHiveMetastoreGetConfigValueException>, ClientError>

pub async fn partition_name_to_vals( &self, part_name: FastStr, ) -> Result<MaybeException<Vec<FastStr>, ThriftHiveMetastorePartitionNameToValsException>, ClientError>

pub async fn partition_name_to_spec( &self, part_name: FastStr, ) -> Result<MaybeException<AHashMap<FastStr, FastStr>, ThriftHiveMetastorePartitionNameToSpecException>, ClientError>

pub async fn mark_partition_for_event( &self, db_name: FastStr, tbl_name: FastStr, part_vals: AHashMap<FastStr, FastStr>, event_type: PartitionEventType, ) -> Result<MaybeException<(), ThriftHiveMetastoreMarkPartitionForEventException>, ClientError>

pub async fn is_partition_marked_for_event( &self, db_name: FastStr, tbl_name: FastStr, part_vals: AHashMap<FastStr, FastStr>, event_type: PartitionEventType, ) -> Result<MaybeException<bool, ThriftHiveMetastoreIsPartitionMarkedForEventException>, ClientError>

pub async fn add_index( &self, new_index: Index, index_table: Table, ) -> Result<MaybeException<Index, ThriftHiveMetastoreAddIndexException>, ClientError>

pub async fn alter_index( &self, dbname: FastStr, base_tbl_name: FastStr, idx_name: FastStr, new_idx: Index, ) -> Result<MaybeException<(), ThriftHiveMetastoreAlterIndexException>, ClientError>

pub async fn drop_index_by_name( &self, db_name: FastStr, tbl_name: FastStr, index_name: FastStr, delete_data: bool, ) -> Result<MaybeException<bool, ThriftHiveMetastoreDropIndexByNameException>, ClientError>

pub async fn get_index_by_name( &self, db_name: FastStr, tbl_name: FastStr, index_name: FastStr, ) -> Result<MaybeException<Index, ThriftHiveMetastoreGetIndexByNameException>, ClientError>

pub async fn get_indexes( &self, db_name: FastStr, tbl_name: FastStr, max_indexes: i16, ) -> Result<MaybeException<Vec<Index>, ThriftHiveMetastoreGetIndexesException>, ClientError>

pub async fn get_index_names( &self, db_name: FastStr, tbl_name: FastStr, max_indexes: i16, ) -> Result<MaybeException<Vec<FastStr>, ThriftHiveMetastoreGetIndexNamesException>, ClientError>

pub async fn get_primary_keys( &self, request: PrimaryKeysRequest, ) -> Result<MaybeException<PrimaryKeysResponse, ThriftHiveMetastoreGetPrimaryKeysException>, ClientError>

pub async fn get_foreign_keys( &self, request: ForeignKeysRequest, ) -> Result<MaybeException<ForeignKeysResponse, ThriftHiveMetastoreGetForeignKeysException>, ClientError>

pub async fn update_table_column_statistics( &self, stats_obj: ColumnStatistics, ) -> Result<MaybeException<bool, ThriftHiveMetastoreUpdateTableColumnStatisticsException>, ClientError>

pub async fn update_partition_column_statistics( &self, stats_obj: ColumnStatistics, ) -> Result<MaybeException<bool, ThriftHiveMetastoreUpdatePartitionColumnStatisticsException>, ClientError>

pub async fn get_table_column_statistics( &self, db_name: FastStr, tbl_name: FastStr, col_name: FastStr, ) -> Result<MaybeException<ColumnStatistics, ThriftHiveMetastoreGetTableColumnStatisticsException>, ClientError>

pub async fn get_partition_column_statistics( &self, db_name: FastStr, tbl_name: FastStr, part_name: FastStr, col_name: FastStr, ) -> Result<MaybeException<ColumnStatistics, ThriftHiveMetastoreGetPartitionColumnStatisticsException>, ClientError>

pub async fn get_table_statistics_req( &self, request: TableStatsRequest, ) -> Result<MaybeException<TableStatsResult, ThriftHiveMetastoreGetTableStatisticsReqException>, ClientError>

pub async fn get_partitions_statistics_req( &self, request: PartitionsStatsRequest, ) -> Result<MaybeException<PartitionsStatsResult, ThriftHiveMetastoreGetPartitionsStatisticsReqException>, ClientError>

pub async fn get_aggr_stats_for( &self, request: PartitionsStatsRequest, ) -> Result<MaybeException<AggrStats, ThriftHiveMetastoreGetAggrStatsForException>, ClientError>

pub async fn set_aggr_stats_for( &self, request: SetPartitionsStatsRequest, ) -> Result<MaybeException<bool, ThriftHiveMetastoreSetAggrStatsForException>, ClientError>

pub async fn delete_partition_column_statistics( &self, db_name: FastStr, tbl_name: FastStr, part_name: FastStr, col_name: FastStr, ) -> Result<MaybeException<bool, ThriftHiveMetastoreDeletePartitionColumnStatisticsException>, ClientError>

pub async fn delete_table_column_statistics( &self, db_name: FastStr, tbl_name: FastStr, col_name: FastStr, ) -> Result<MaybeException<bool, ThriftHiveMetastoreDeleteTableColumnStatisticsException>, ClientError>

pub async fn create_function( &self, func: Function, ) -> Result<MaybeException<(), ThriftHiveMetastoreCreateFunctionException>, ClientError>

pub async fn drop_function( &self, db_name: FastStr, func_name: FastStr, ) -> Result<MaybeException<(), ThriftHiveMetastoreDropFunctionException>, ClientError>

pub async fn alter_function( &self, db_name: FastStr, func_name: FastStr, new_func: Function, ) -> Result<MaybeException<(), ThriftHiveMetastoreAlterFunctionException>, ClientError>

pub async fn get_functions( &self, db_name: FastStr, pattern: FastStr, ) -> Result<MaybeException<Vec<FastStr>, ThriftHiveMetastoreGetFunctionsException>, ClientError>

pub async fn get_function( &self, db_name: FastStr, func_name: FastStr, ) -> Result<MaybeException<Function, ThriftHiveMetastoreGetFunctionException>, ClientError>

pub async fn get_all_functions( &self, ) -> Result<MaybeException<GetAllFunctionsResponse, ThriftHiveMetastoreGetAllFunctionsException>, ClientError>

pub async fn create_role( &self, role: Role, ) -> Result<MaybeException<bool, ThriftHiveMetastoreCreateRoleException>, ClientError>

pub async fn drop_role( &self, role_name: FastStr, ) -> Result<MaybeException<bool, ThriftHiveMetastoreDropRoleException>, ClientError>

pub async fn get_role_names( &self, ) -> Result<MaybeException<Vec<FastStr>, ThriftHiveMetastoreGetRoleNamesException>, ClientError>

pub async fn grant_role( &self, role_name: FastStr, principal_name: FastStr, principal_type: PrincipalType, grantor: FastStr, grantor_type: PrincipalType, grant_option: bool, ) -> Result<MaybeException<bool, ThriftHiveMetastoreGrantRoleException>, ClientError>

pub async fn revoke_role( &self, role_name: FastStr, principal_name: FastStr, principal_type: PrincipalType, ) -> Result<MaybeException<bool, ThriftHiveMetastoreRevokeRoleException>, ClientError>

pub async fn list_roles( &self, principal_name: FastStr, principal_type: PrincipalType, ) -> Result<MaybeException<Vec<Role>, ThriftHiveMetastoreListRolesException>, ClientError>

pub async fn grant_revoke_role( &self, request: GrantRevokeRoleRequest, ) -> Result<MaybeException<GrantRevokeRoleResponse, ThriftHiveMetastoreGrantRevokeRoleException>, ClientError>

pub async fn get_principals_in_role( &self, request: GetPrincipalsInRoleRequest, ) -> Result<MaybeException<GetPrincipalsInRoleResponse, ThriftHiveMetastoreGetPrincipalsInRoleException>, ClientError>

pub async fn get_role_grants_for_principal( &self, request: GetRoleGrantsForPrincipalRequest, ) -> Result<MaybeException<GetRoleGrantsForPrincipalResponse, ThriftHiveMetastoreGetRoleGrantsForPrincipalException>, ClientError>

pub async fn get_privilege_set( &self, hive_object: HiveObjectRef, user_name: FastStr, group_names: Vec<FastStr>, ) -> Result<MaybeException<PrincipalPrivilegeSet, ThriftHiveMetastoreGetPrivilegeSetException>, ClientError>

pub async fn list_privileges( &self, principal_name: FastStr, principal_type: PrincipalType, hive_object: HiveObjectRef, ) -> Result<MaybeException<Vec<HiveObjectPrivilege>, ThriftHiveMetastoreListPrivilegesException>, ClientError>

pub async fn grant_privileges( &self, privileges: PrivilegeBag, ) -> Result<MaybeException<bool, ThriftHiveMetastoreGrantPrivilegesException>, ClientError>

pub async fn revoke_privileges( &self, privileges: PrivilegeBag, ) -> Result<MaybeException<bool, ThriftHiveMetastoreRevokePrivilegesException>, ClientError>

pub async fn grant_revoke_privileges( &self, request: GrantRevokePrivilegeRequest, ) -> Result<MaybeException<GrantRevokePrivilegeResponse, ThriftHiveMetastoreGrantRevokePrivilegesException>, ClientError>

pub async fn set_ugi( &self, user_name: FastStr, group_names: Vec<FastStr>, ) -> Result<MaybeException<Vec<FastStr>, ThriftHiveMetastoreSetUgiException>, ClientError>

pub async fn get_delegation_token( &self, token_owner: FastStr, renewer_kerberos_principal_name: FastStr, ) -> Result<MaybeException<FastStr, ThriftHiveMetastoreGetDelegationTokenException>, ClientError>

pub async fn renew_delegation_token( &self, token_str_form: FastStr, ) -> Result<MaybeException<i64, ThriftHiveMetastoreRenewDelegationTokenException>, ClientError>

pub async fn cancel_delegation_token( &self, token_str_form: FastStr, ) -> Result<MaybeException<(), ThriftHiveMetastoreCancelDelegationTokenException>, ClientError>

pub async fn add_token( &self, token_identifier: FastStr, delegation_token: FastStr, ) -> Result<bool, ClientError>

pub async fn remove_token( &self, token_identifier: FastStr, ) -> Result<bool, ClientError>

pub async fn get_token( &self, token_identifier: FastStr, ) -> Result<FastStr, ClientError>

pub async fn get_all_token_identifiers( &self, ) -> Result<Vec<FastStr>, ClientError>

pub async fn add_master_key( &self, key: FastStr, ) -> Result<MaybeException<i32, ThriftHiveMetastoreAddMasterKeyException>, ClientError>

pub async fn update_master_key( &self, seq_number: i32, key: FastStr, ) -> Result<MaybeException<(), ThriftHiveMetastoreUpdateMasterKeyException>, ClientError>

pub async fn remove_master_key(&self, key_seq: i32) -> Result<bool, ClientError>

pub async fn get_master_keys(&self) -> Result<Vec<FastStr>, ClientError>

pub async fn get_open_txns(&self) -> Result<GetOpenTxnsResponse, ClientError>

pub async fn get_open_txns_info( &self, ) -> Result<GetOpenTxnsInfoResponse, ClientError>

pub async fn open_txns( &self, rqst: OpenTxnRequest, ) -> Result<OpenTxnsResponse, ClientError>

pub async fn abort_txn( &self, rqst: AbortTxnRequest, ) -> Result<MaybeException<(), ThriftHiveMetastoreAbortTxnException>, ClientError>

pub async fn abort_txns( &self, rqst: AbortTxnsRequest, ) -> Result<MaybeException<(), ThriftHiveMetastoreAbortTxnsException>, ClientError>

pub async fn commit_txn( &self, rqst: CommitTxnRequest, ) -> Result<MaybeException<(), ThriftHiveMetastoreCommitTxnException>, ClientError>

pub async fn lock( &self, rqst: LockRequest, ) -> Result<MaybeException<LockResponse, ThriftHiveMetastoreLockException>, ClientError>

pub async fn check_lock( &self, rqst: CheckLockRequest, ) -> Result<MaybeException<LockResponse, ThriftHiveMetastoreCheckLockException>, ClientError>

pub async fn unlock( &self, rqst: UnlockRequest, ) -> Result<MaybeException<(), ThriftHiveMetastoreUnlockException>, ClientError>

pub async fn show_locks( &self, rqst: ShowLocksRequest, ) -> Result<ShowLocksResponse, ClientError>

pub async fn heartbeat( &self, ids: HeartbeatRequest, ) -> Result<MaybeException<(), ThriftHiveMetastoreHeartbeatException>, ClientError>

pub async fn heartbeat_txn_range( &self, txns: HeartbeatTxnRangeRequest, ) -> Result<HeartbeatTxnRangeResponse, ClientError>

pub async fn compact(&self, rqst: CompactionRequest) -> Result<(), ClientError>

pub async fn compact2( &self, rqst: CompactionRequest, ) -> Result<CompactionResponse, ClientError>

pub async fn show_compact( &self, rqst: ShowCompactRequest, ) -> Result<ShowCompactResponse, ClientError>

pub async fn add_dynamic_partitions( &self, rqst: AddDynamicPartitions, ) -> Result<MaybeException<(), ThriftHiveMetastoreAddDynamicPartitionsException>, ClientError>

pub async fn get_next_notification( &self, rqst: NotificationEventRequest, ) -> Result<NotificationEventResponse, ClientError>

pub async fn get_current_notification_event_id( &self, ) -> Result<CurrentNotificationEventId, ClientError>

pub async fn fire_listener_event( &self, rqst: FireEventRequest, ) -> Result<FireEventResponse, ClientError>

pub async fn flush_cache(&self) -> Result<(), ClientError>

pub async fn get_file_metadata_by_expr( &self, req: GetFileMetadataByExprRequest, ) -> Result<GetFileMetadataByExprResult, ClientError>

pub async fn get_file_metadata( &self, req: GetFileMetadataRequest, ) -> Result<GetFileMetadataResult, ClientError>

pub async fn put_file_metadata( &self, req: PutFileMetadataRequest, ) -> Result<PutFileMetadataResult, ClientError>

pub async fn clear_file_metadata( &self, req: ClearFileMetadataRequest, ) -> Result<ClearFileMetadataResult, ClientError>

pub async fn cache_file_metadata( &self, req: CacheFileMetadataRequest, ) -> Result<CacheFileMetadataResult, ClientError>

Trait Implementations§

impl<S: Clone> Clone for ThriftHiveMetastoreGenericClient<S>

fn clone(&self) -> ThriftHiveMetastoreGenericClient<S>

Returns a copy of the value. Read more

1.0.0 · source§

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source. Read more

Auto Trait Implementations§

impl<S> Freeze for ThriftHiveMetastoreGenericClient<S>
where S: Freeze,

impl<S> RefUnwindSafe for ThriftHiveMetastoreGenericClient<S>
where S: RefUnwindSafe,

impl<S> UnwindSafe for ThriftHiveMetastoreGenericClient<S>
where S: UnwindSafe,

Blanket Implementations§

impl<T> Any for T
where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more

impl<T> Borrow<T> for T
where T: ?Sized,

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more

impl<T> From<T> for T

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

Instruments this type with the provided Span, returning an Instrumented wrapper. Read more

fn in_current_span(self) -> Instrumented<Self>

Instruments this type with the current Span, returning an Instrumented wrapper. Read more

impl<T, U> Into<U> for T
where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

impl<T> ToOwned for T
where T: Clone,

type Owned = T

The resulting type after obtaining ownership.

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more

impl<T, U> TryFrom<U> for T
where U: Into<T>,

type Error = Infallible

The type returned in the event of a conversion error.

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

fn vzip(self) -> V

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

Attaches the provided Subscriber to this type, returning a WithDispatch wrapper. Read more