Package com.oracle.bmc.databasemanagement

Interface DbManagementAsync

  • All Superinterfaces:
    AutoCloseable
    All Known Implementing Classes:
    DbManagementAsyncClient
    @Generated(value="OracleSDKGenerator",
           comments="API Version: 20201101")
public interface DbManagementAsync
extends AutoCloseable
    Use the Database Management API to monitor and manage resources such as Oracle Databases, MySQL Databases, and External Database Systems.

    For more information, see Database Management.

    • Method Detail

      • refreshClient

        void refreshClient()
        Rebuilds the client from scratch.

        Useful to refresh certificates.

      • setEndpoint

        void setEndpoint​(String endpoint)
        Sets the endpoint to call (ex, https://www.example.com).
        Parameters:
        endpoint - The endpoint of the serice.

      • getEndpoint

        String getEndpoint()
        Gets the set endpoint for REST call (ex, https://www.example.com)

      • setRegion

        void setRegion​(Region region)
        Sets the region to call (ex, Region.US_PHOENIX_1).

        Note, this will call setEndpoint after resolving the endpoint. If the service is not available in this region, however, an IllegalArgumentException will be raised.

        Parameters:
        region - The region of the service.

      • setRegion

        void setRegion​(String regionId)
        Sets the region to call (ex, ‘us-phoenix-1’).

        Note, this will first try to map the region ID to a known Region and call setRegion.

        If no known Region could be determined, it will create an endpoint based on the default endpoint format (Region.formatDefaultRegionEndpoint(Service, String) and then call setEndpoint.

        Parameters:
        regionId - The public region ID.

      • useRealmSpecificEndpointTemplate

        void useRealmSpecificEndpointTemplate​(boolean realmSpecificEndpointTemplateEnabled)
        Determines whether realm specific endpoint should be used or not.

        Set realmSpecificEndpointTemplateEnabled to “true” if the user wants to enable use of realm specific endpoint template, otherwise set it to “false”

        Parameters:
        realmSpecificEndpointTemplateEnabled - flag to enable the use of realm specific endpoint template

      • addDataFiles

        Future<AddDataFilesResponse> addDataFiles​(AddDataFilesRequest request,
                                          AsyncHandler<AddDataFilesRequest,​AddDataFilesResponse> handler)
        Adds data files or temp files to the tablespace.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • addmTasks

        Future<AddmTasksResponse> addmTasks​(AddmTasksRequest request,
                                    AsyncHandler<AddmTasksRequest,​AddmTasksResponse> handler)
        Lists the metadata for each ADDM task who’s end snapshot time falls within the provided start and end time.

        Details include the name of the ADDM task, description, user, status and creation date time.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • changeDatabaseParameters

        Future<ChangeDatabaseParametersResponse> changeDatabaseParameters​(ChangeDatabaseParametersRequest request,
                                                                  AsyncHandler<ChangeDatabaseParametersRequest,​ChangeDatabaseParametersResponse> handler)
        Changes database parameter values.

        There are two kinds of database parameters:

        - Dynamic parameters: They can be changed for the current Oracle Database instance. The changes take effect immediately. - Static parameters: They cannot be changed for the current instance. You must change these parameters and then restart the database before changes take effect.

        *Note:** If the instance is started using a text initialization parameter file, the parameter changes are applicable only for the current instance. You must update them manually to be passed to a future instance.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • changeJobCompartment

        Future<ChangeJobCompartmentResponse> changeJobCompartment​(ChangeJobCompartmentRequest request,
                                                          AsyncHandler<ChangeJobCompartmentRequest,​ChangeJobCompartmentResponse> handler)
        Moves a job.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • changePlanRetention

        Future<ChangePlanRetentionResponse> changePlanRetention​(ChangePlanRetentionRequest request,
                                                        AsyncHandler<ChangePlanRetentionRequest,​ChangePlanRetentionResponse> handler)
        Changes the retention period of unused plans.

        The period can range between 5 and 523 weeks.

        The database purges plans that have not been used for longer than the plan retention period.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • changeSpaceBudget

        Future<ChangeSpaceBudgetResponse> changeSpaceBudget​(ChangeSpaceBudgetRequest request,
                                                    AsyncHandler<ChangeSpaceBudgetRequest,​ChangeSpaceBudgetResponse> handler)
        Changes the disk space limit for the SQL Management Base.

        The allowable range for this limit is between 1% and 50%.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createCloudDbSystem

        Future<CreateCloudDbSystemResponse> createCloudDbSystem​(CreateCloudDbSystemRequest request,
                                                        AsyncHandler<CreateCloudDbSystemRequest,​CreateCloudDbSystemResponse> handler)
        Creates a cloud DB system and its related resources.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createExternalDbSystem

        Future<CreateExternalDbSystemResponse> createExternalDbSystem​(CreateExternalDbSystemRequest request,
                                                              AsyncHandler<CreateExternalDbSystemRequest,​CreateExternalDbSystemResponse> handler)
        Creates an external DB system and its related resources.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createExternalExadataInfrastructure

        Future<CreateExternalExadataInfrastructureResponse> createExternalExadataInfrastructure​(CreateExternalExadataInfrastructureRequest request,
                                                                                        AsyncHandler<CreateExternalExadataInfrastructureRequest,​CreateExternalExadataInfrastructureResponse> handler)
        Creates an OCI resource for the Exadata infrastructure and enables the Monitoring service for the Exadata infrastructure.

        The following resource/subresources are created: Infrastructure Storage server connectors Storage servers Storage grids

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createJob

        Future<CreateJobResponse> createJob​(CreateJobRequest request,
                                    AsyncHandler<CreateJobRequest,​CreateJobResponse> handler)
        Creates a job to be executed on a Managed Database or Managed Database Group.

        Only one of the parameters, managedDatabaseId or managedDatabaseGroupId should be provided as input in CreateJobDetails resource in request body.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createManagedDatabaseGroup

        Future<CreateManagedDatabaseGroupResponse> createManagedDatabaseGroup​(CreateManagedDatabaseGroupRequest request,
                                                                      AsyncHandler<CreateManagedDatabaseGroupRequest,​CreateManagedDatabaseGroupResponse> handler)
        Creates a Managed Database Group.

        The group does not contain any Managed Databases when it is created, and they must be added later.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createNamedCredential

        Future<CreateNamedCredentialResponse> createNamedCredential​(CreateNamedCredentialRequest request,
                                                            AsyncHandler<CreateNamedCredentialRequest,​CreateNamedCredentialResponse> handler)
        Creates a named credential.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • createTablespace

        Future<CreateTablespaceResponse> createTablespace​(CreateTablespaceRequest request,
                                                  AsyncHandler<CreateTablespaceRequest,​CreateTablespaceResponse> handler)
        Creates a tablespace within the Managed Database specified by managedDatabaseId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteCloudDbSystem

        Future<DeleteCloudDbSystemResponse> deleteCloudDbSystem​(DeleteCloudDbSystemRequest request,
                                                        AsyncHandler<DeleteCloudDbSystemRequest,​DeleteCloudDbSystemResponse> handler)
        Deletes the cloud DB system specified by cloudDbSystemId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteExternalDbSystem

        Future<DeleteExternalDbSystemResponse> deleteExternalDbSystem​(DeleteExternalDbSystemRequest request,
                                                              AsyncHandler<DeleteExternalDbSystemRequest,​DeleteExternalDbSystemResponse> handler)
        Deletes the external DB system specified by externalDbSystemId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteJob

        Future<DeleteJobResponse> deleteJob​(DeleteJobRequest request,
                                    AsyncHandler<DeleteJobRequest,​DeleteJobResponse> handler)
        Deletes the job specified by jobId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteManagedDatabaseGroup

        Future<DeleteManagedDatabaseGroupResponse> deleteManagedDatabaseGroup​(DeleteManagedDatabaseGroupRequest request,
                                                                      AsyncHandler<DeleteManagedDatabaseGroupRequest,​DeleteManagedDatabaseGroupResponse> handler)
        Deletes the Managed Database Group specified by managedDatabaseGroupId.

        If the group contains Managed Databases, then it cannot be deleted.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • deleteNamedCredential

        Future<DeleteNamedCredentialResponse> deleteNamedCredential​(DeleteNamedCredentialRequest request,
                                                            AsyncHandler<DeleteNamedCredentialRequest,​DeleteNamedCredentialResponse> handler)
        Deletes the named credential specified by namedCredentialId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • disableExternalExadataInfrastructureManagement

        Future<DisableExternalExadataInfrastructureManagementResponse> disableExternalExadataInfrastructureManagement​(DisableExternalExadataInfrastructureManagementRequest request,
                                                                                                              AsyncHandler<DisableExternalExadataInfrastructureManagementRequest,​DisableExternalExadataInfrastructureManagementResponse> handler)
        Disables Database Management for the Exadata infrastructure specified by externalExadataInfrastructureId.

        It covers the following components:

        - Exadata infrastructure - Exadata storage grid - Exadata storage server

        Note that Database Management will not be disabled for the DB systems within the Exadata infrastructure and should be disabled explicitly, if required.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • disableSqlPlanBaselinesUsage

        Future<DisableSqlPlanBaselinesUsageResponse> disableSqlPlanBaselinesUsage​(DisableSqlPlanBaselinesUsageRequest request,
                                                                          AsyncHandler<DisableSqlPlanBaselinesUsageRequest,​DisableSqlPlanBaselinesUsageResponse> handler)
        Disables the use of SQL plan baselines stored in SQL Management Base.

        When disabled, the optimizer does not use any SQL plan baselines.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • discoverExternalExadataInfrastructure

        Future<DiscoverExternalExadataInfrastructureResponse> discoverExternalExadataInfrastructure​(DiscoverExternalExadataInfrastructureRequest request,
                                                                                            AsyncHandler<DiscoverExternalExadataInfrastructureRequest,​DiscoverExternalExadataInfrastructureResponse> handler)
        Completes the Exadata system prechecking on the following:

        - Verifies if the DB systems are valid RAC DB systems or return 400 status code with NON_RAC_DATABASE_SYSTEM error code. - Verifies if the ASM connector defined for each DB system or return 400 status code with CONNECTOR_NOT_DEFINED error code. - Verifies if the agents associated with ASM are valid and could be used for the Exadata storage servers or return 400 status code with INVALID_AGENT error code. - Verifies if it is an Exadata system or return 400 status code with INVALID_EXADATA_SYSTEM error code.

        Starts the discovery process for the Exadata system infrastructure. The following resources/components are discovered

        - Exadata storage servers from each DB systems - Exadata storage grid for all Exadata storage servers - Exadata infrastructure

        The same API covers both new discovery and rediscovery cases. For the new discovery case, new managed resources/sub-resources are created or the existing ones are overridden. For rediscovery case, the existing managed resources/sub-resources are checked to find out which ones should be added or which ones should be removed based on the unique key defined for each resource/sub-resource.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • dropSqlPlanBaselines

        Future<DropSqlPlanBaselinesResponse> dropSqlPlanBaselines​(DropSqlPlanBaselinesRequest request,
                                                          AsyncHandler<DropSqlPlanBaselinesRequest,​DropSqlPlanBaselinesResponse> handler)
        Drops a single plan or all plans associated with a SQL statement.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • dropTablespace

        Future<DropTablespaceResponse> dropTablespace​(DropTablespaceRequest request,
                                              AsyncHandler<DropTablespaceRequest,​DropTablespaceResponse> handler)
        Drops the tablespace specified by tablespaceName within the Managed Database specified by managedDatabaseId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • enableAutomaticInitialPlanCapture

        Future<EnableAutomaticInitialPlanCaptureResponse> enableAutomaticInitialPlanCapture​(EnableAutomaticInitialPlanCaptureRequest request,
                                                                                    AsyncHandler<EnableAutomaticInitialPlanCaptureRequest,​EnableAutomaticInitialPlanCaptureResponse> handler)
        Enables automatic initial plan capture.

        When enabled, the database checks whether executed SQL statements are eligible for automatic capture. It creates initial plan baselines for eligible statements.

        By default, the database creates a SQL plan baseline for every eligible repeatable statement, including all recursive SQL and monitoring SQL. Thus, automatic capture may result in the creation of an extremely large number of plan baselines. To limit the statements that are eligible for plan baselines, configure filters.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • enableAutomaticSpmEvolveAdvisorTask

        Future<EnableAutomaticSpmEvolveAdvisorTaskResponse> enableAutomaticSpmEvolveAdvisorTask​(EnableAutomaticSpmEvolveAdvisorTaskRequest request,
                                                                                        AsyncHandler<EnableAutomaticSpmEvolveAdvisorTaskRequest,​EnableAutomaticSpmEvolveAdvisorTaskResponse> handler)
        Enables the Automatic SPM Evolve Advisor task.

        By default, the automatic task SYS_AUTO_SPM_EVOLVE_TASK runs every day in the scheduled maintenance window.

        The SPM Evolve Advisor performs the following tasks:

        - Checks AWR for top SQL - Looks for alternative plans in all available sources - Adds unaccepted plans to the plan history - Tests the execution of as many plans as possible during the maintenance window - Adds the alternative plan to the baseline if it performs better than the current plan

        One client controls both Automatic SQL Tuning Advisor and Automatic SPM Evolve Advisor. Thus, the same task enables or disables both.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • enableHighFrequencyAutomaticSpmEvolveAdvisorTask

        Future<EnableHighFrequencyAutomaticSpmEvolveAdvisorTaskResponse> enableHighFrequencyAutomaticSpmEvolveAdvisorTask​(EnableHighFrequencyAutomaticSpmEvolveAdvisorTaskRequest request,
                                                                                                                  AsyncHandler<EnableHighFrequencyAutomaticSpmEvolveAdvisorTaskRequest,​EnableHighFrequencyAutomaticSpmEvolveAdvisorTaskResponse> handler)
        Enables the high-frequency Automatic SPM Evolve Advisor task.

        The high-frequency task runs every hour and runs for no longer than 30 minutes. These settings are not configurable.

        The high-frequency task complements the standard Automatic SPM Evolve Advisor task. They are independent and are scheduled through two different frameworks.

        It is available only on Oracle Exadata Database Machine, Oracle Database Exadata Cloud Service (ExaCS) and Oracle Database Exadata Cloud@Customer (ExaCC).

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • enableSqlPlanBaselinesUsage

        Future<EnableSqlPlanBaselinesUsageResponse> enableSqlPlanBaselinesUsage​(EnableSqlPlanBaselinesUsageRequest request,
                                                                        AsyncHandler<EnableSqlPlanBaselinesUsageRequest,​EnableSqlPlanBaselinesUsageResponse> handler)
        Enables the use of SQL plan baselines stored in SQL Management Base.

        When enabled, the optimizer uses SQL plan baselines to select plans to avoid potential performance regressions.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • generateAwrSnapshot

        Future<GenerateAwrSnapshotResponse> generateAwrSnapshot​(GenerateAwrSnapshotRequest request,
                                                        AsyncHandler<GenerateAwrSnapshotRequest,​GenerateAwrSnapshotResponse> handler)
        Creates an AWR snapshot for the target database.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getAwrDbReport

        Future<GetAwrDbReportResponse> getAwrDbReport​(GetAwrDbReportRequest request,
                                              AsyncHandler<GetAwrDbReportRequest,​GetAwrDbReportResponse> handler)
        Gets the AWR report for the specified database.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getAwrDbSqlReport

        Future<GetAwrDbSqlReportResponse> getAwrDbSqlReport​(GetAwrDbSqlReportRequest request,
                                                    AsyncHandler<GetAwrDbSqlReportRequest,​GetAwrDbSqlReportResponse> handler)
        Gets the SQL health check report for one SQL of the specified database.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getCloudAsm

        Future<GetCloudAsmResponse> getCloudAsm​(GetCloudAsmRequest request,
                                        AsyncHandler<GetCloudAsmRequest,​GetCloudAsmResponse> handler)
        Gets the details for the cloud ASM specified by cloudAsmId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getCloudAsmConfiguration

        Future<GetCloudAsmConfigurationResponse> getCloudAsmConfiguration​(GetCloudAsmConfigurationRequest request,
                                                                  AsyncHandler<GetCloudAsmConfigurationRequest,​GetCloudAsmConfigurationResponse> handler)
        Gets configuration details including disk groups for the cloud ASM specified by cloudAsmId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getCloudAsmInstance

        Future<GetCloudAsmInstanceResponse> getCloudAsmInstance​(GetCloudAsmInstanceRequest request,
                                                        AsyncHandler<GetCloudAsmInstanceRequest,​GetCloudAsmInstanceResponse> handler)
        Gets the details for the cloud ASM instance specified by cloudAsmInstanceId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getCloudCluster

        Future<GetCloudClusterResponse> getCloudCluster​(GetCloudClusterRequest request,
                                                AsyncHandler<GetCloudClusterRequest,​GetCloudClusterResponse> handler)
        Gets the details for the cloud cluster specified by cloudClusterId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getCloudClusterInstance

        Future<GetCloudClusterInstanceResponse> getCloudClusterInstance​(GetCloudClusterInstanceRequest request,
                                                                AsyncHandler<GetCloudClusterInstanceRequest,​GetCloudClusterInstanceResponse> handler)
        Gets the details for the cloud cluster instance specified by cloudClusterInstanceId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getCloudDbHome

        Future<GetCloudDbHomeResponse> getCloudDbHome​(GetCloudDbHomeRequest request,
                                              AsyncHandler<GetCloudDbHomeRequest,​GetCloudDbHomeResponse> handler)
        Gets the details for the cloud DB home specified by cloudDbHomeId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getCloudDbNode

        Future<GetCloudDbNodeResponse> getCloudDbNode​(GetCloudDbNodeRequest request,
                                              AsyncHandler<GetCloudDbNodeRequest,​GetCloudDbNodeResponse> handler)
        Gets the details for the cloud DB node specified by cloudDbNodeId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getCloudDbSystem

        Future<GetCloudDbSystemResponse> getCloudDbSystem​(GetCloudDbSystemRequest request,
                                                  AsyncHandler<GetCloudDbSystemRequest,​GetCloudDbSystemResponse> handler)
        Gets the details for the cloud DB system specified by cloudDbSystemId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getCloudDbSystemConnector

        Future<GetCloudDbSystemConnectorResponse> getCloudDbSystemConnector​(GetCloudDbSystemConnectorRequest request,
                                                                    AsyncHandler<GetCloudDbSystemConnectorRequest,​GetCloudDbSystemConnectorResponse> handler)
        Gets the details for the cloud connector specified by cloudDbSystemConnectorId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getCloudDbSystemDiscovery

        Future<GetCloudDbSystemDiscoveryResponse> getCloudDbSystemDiscovery​(GetCloudDbSystemDiscoveryRequest request,
                                                                    AsyncHandler<GetCloudDbSystemDiscoveryRequest,​GetCloudDbSystemDiscoveryResponse> handler)
        Gets the details for the cloud DB system discovery resource specified by cloudDbSystemDiscoveryId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getCloudListener

        Future<GetCloudListenerResponse> getCloudListener​(GetCloudListenerRequest request,
                                                  AsyncHandler<GetCloudListenerRequest,​GetCloudListenerResponse> handler)
        Gets the details for the cloud listener specified by cloudListenerId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getClusterCacheMetric

        Future<GetClusterCacheMetricResponse> getClusterCacheMetric​(GetClusterCacheMetricRequest request,
                                                            AsyncHandler<GetClusterCacheMetricRequest,​GetClusterCacheMetricResponse> handler)
        Gets the metrics related to cluster cache for the Oracle Real Application Clusters (Oracle RAC) database specified by managedDatabaseId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getDatabaseFleetBackupMetrics

        Future<GetDatabaseFleetBackupMetricsResponse> getDatabaseFleetBackupMetrics​(GetDatabaseFleetBackupMetricsRequest request,
                                                                            AsyncHandler<GetDatabaseFleetBackupMetricsRequest,​GetDatabaseFleetBackupMetricsResponse> handler)
        Gets the fleet of container databases (CDBs) and their backup details and metrics, in a compartment or Database Group.

        The databaseHostedIn query parameter must be provided to list either cloud or external databases. Either the CompartmentId or the ManagedDatabaseGroupId query parameters must be provided to retrieve the HA and backup metrics.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getDatabaseFleetDataguardMetrics

        Future<GetDatabaseFleetDataguardMetricsResponse> getDatabaseFleetDataguardMetrics​(GetDatabaseFleetDataguardMetricsRequest request,
                                                                                  AsyncHandler<GetDatabaseFleetDataguardMetricsRequest,​GetDatabaseFleetDataguardMetricsResponse> handler)
        Gets the fleet of Oracle Data Guard-enabled container databases (CDBs) along with Data Guard metrics and standby databases, in a compartment or Database Group.

        Either the CompartmentId or the ManagedDatabaseGroupId query parameters must be provided to retrieve the list of databases and Data Guard metrics.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getDatabaseFleetHaOverviewMetrics

        Future<GetDatabaseFleetHaOverviewMetricsResponse> getDatabaseFleetHaOverviewMetrics​(GetDatabaseFleetHaOverviewMetricsRequest request,
                                                                                    AsyncHandler<GetDatabaseFleetHaOverviewMetricsRequest,​GetDatabaseFleetHaOverviewMetricsResponse> handler)
        Gets the fleet of container databases (CDBs) and their HA and backup metrics in a compartment or in a Database Group.

        Either the CompartmentId or the ManagedDatabaseGroupId query parameters must be provided to retrieve the HA and backup metrics.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getDatabaseFleetHealthMetrics

        Future<GetDatabaseFleetHealthMetricsResponse> getDatabaseFleetHealthMetrics​(GetDatabaseFleetHealthMetricsRequest request,
                                                                            AsyncHandler<GetDatabaseFleetHealthMetricsRequest,​GetDatabaseFleetHealthMetricsResponse> handler)
        Gets the health metrics for a fleet of databases in a compartment or in a Managed Database Group.

        Either the CompartmentId or the ManagedDatabaseGroupId query parameters must be provided to retrieve the health metrics.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getDatabaseHomeMetrics

        Future<GetDatabaseHomeMetricsResponse> getDatabaseHomeMetrics​(GetDatabaseHomeMetricsRequest request,
                                                              AsyncHandler<GetDatabaseHomeMetricsRequest,​GetDatabaseHomeMetricsResponse> handler)
        Gets a summary of the activity and resource usage metrics like DB Time, CPU, User I/O, Wait, Storage, and Memory for a Managed Database.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getDataguardPerformanceMetrics

        Future<GetDataguardPerformanceMetricsResponse> getDataguardPerformanceMetrics​(GetDataguardPerformanceMetricsRequest request,
                                                                              AsyncHandler<GetDataguardPerformanceMetricsRequest,​GetDataguardPerformanceMetricsResponse> handler)
        Gets a historical summary of the Database Guard performance metrics for Managed Databases.

        If the peerDatabaseCompartmentId is specified, then the metrics are only retrieved from the specified compartment. If the peerDatabaseCompartmentId is not specified, then the metrics are retrieved from the compartment of the Managed Database specified by the ManagedDatabaseId.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getExternalAsm

        Future<GetExternalAsmResponse> getExternalAsm​(GetExternalAsmRequest request,
                                              AsyncHandler<GetExternalAsmRequest,​GetExternalAsmResponse> handler)
        Gets the details for the external ASM specified by externalAsmId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getExternalAsmInstance

        Future<GetExternalAsmInstanceResponse> getExternalAsmInstance​(GetExternalAsmInstanceRequest request,
                                                              AsyncHandler<GetExternalAsmInstanceRequest,​GetExternalAsmInstanceResponse> handler)
        Gets the details for the external ASM instance specified by externalAsmInstanceId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getExternalCluster

        Future<GetExternalClusterResponse> getExternalCluster​(GetExternalClusterRequest request,
                                                      AsyncHandler<GetExternalClusterRequest,​GetExternalClusterResponse> handler)
        Gets the details for the external cluster specified by externalClusterId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getExternalClusterInstance

        Future<GetExternalClusterInstanceResponse> getExternalClusterInstance​(GetExternalClusterInstanceRequest request,
                                                                      AsyncHandler<GetExternalClusterInstanceRequest,​GetExternalClusterInstanceResponse> handler)
        Gets the details for the external cluster instance specified by externalClusterInstanceId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getExternalDbHome

        Future<GetExternalDbHomeResponse> getExternalDbHome​(GetExternalDbHomeRequest request,
                                                    AsyncHandler<GetExternalDbHomeRequest,​GetExternalDbHomeResponse> handler)
        Gets the details for the external DB home specified by externalDbHomeId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getExternalDbNode

        Future<GetExternalDbNodeResponse> getExternalDbNode​(GetExternalDbNodeRequest request,
                                                    AsyncHandler<GetExternalDbNodeRequest,​GetExternalDbNodeResponse> handler)
        Gets the details for the external DB node specified by externalDbNodeId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getExternalDbSystem

        Future<GetExternalDbSystemResponse> getExternalDbSystem​(GetExternalDbSystemRequest request,
                                                        AsyncHandler<GetExternalDbSystemRequest,​GetExternalDbSystemResponse> handler)
        Gets the details for the external DB system specified by externalDbSystemId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getExternalExadataInfrastructure

        Future<GetExternalExadataInfrastructureResponse> getExternalExadataInfrastructure​(GetExternalExadataInfrastructureRequest request,
                                                                                  AsyncHandler<GetExternalExadataInfrastructureRequest,​GetExternalExadataInfrastructureResponse> handler)
        Gets the details for the Exadata infrastructure specified by externalExadataInfrastructureId.

        It includes the DB systems and storage grid within the Exadata infrastructure.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getExternalListener

        Future<GetExternalListenerResponse> getExternalListener​(GetExternalListenerRequest request,
                                                        AsyncHandler<GetExternalListenerRequest,​GetExternalListenerResponse> handler)
        Gets the details for the external listener specified by externalListenerId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getIormPlan

        Future<GetIormPlanResponse> getIormPlan​(GetIormPlanRequest request,
                                        AsyncHandler<GetIormPlanRequest,​GetIormPlanResponse> handler)
        Get the IORM plan from the specific Exadata storage server.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getJob

        Future<GetJobResponse> getJob​(GetJobRequest request,
                              AsyncHandler<GetJobRequest,​GetJobResponse> handler)
        Gets the details of the job specified by jobId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getJobExecution

        Future<GetJobExecutionResponse> getJobExecution​(GetJobExecutionRequest request,
                                                AsyncHandler<GetJobExecutionRequest,​GetJobExecutionResponse> handler)
        Gets the details of the job execution specified by jobExecutionId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getJobRun

        Future<GetJobRunResponse> getJobRun​(GetJobRunRequest request,
                                    AsyncHandler<GetJobRunRequest,​GetJobRunResponse> handler)
        Gets the details of the job run specified by jobRunId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getManagedDatabase

        Future<GetManagedDatabaseResponse> getManagedDatabase​(GetManagedDatabaseRequest request,
                                                      AsyncHandler<GetManagedDatabaseRequest,​GetManagedDatabaseResponse> handler)
        Gets the details of the Managed Database specified by managedDatabaseId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getManagedDatabaseGroup

        Future<GetManagedDatabaseGroupResponse> getManagedDatabaseGroup​(GetManagedDatabaseGroupRequest request,
                                                                AsyncHandler<GetManagedDatabaseGroupRequest,​GetManagedDatabaseGroupResponse> handler)
        Gets the details of the Managed Database Group specified by managedDatabaseGroupId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getNamedCredential

        Future<GetNamedCredentialResponse> getNamedCredential​(GetNamedCredentialRequest request,
                                                      AsyncHandler<GetNamedCredentialRequest,​GetNamedCredentialResponse> handler)
        Gets the details for the named credential specified by namedCredentialId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getOpenAlertHistory

        Future<GetOpenAlertHistoryResponse> getOpenAlertHistory​(GetOpenAlertHistoryRequest request,
                                                        AsyncHandler<GetOpenAlertHistoryRequest,​GetOpenAlertHistoryResponse> handler)
        Gets the open alerts from the specified Exadata storage server.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getPdbMetrics

        Future<GetPdbMetricsResponse> getPdbMetrics​(GetPdbMetricsRequest request,
                                            AsyncHandler<GetPdbMetricsRequest,​GetPdbMetricsResponse> handler)
        Gets a summary of the resource usage metrics such as CPU, User I/O, and Storage for each PDB within a specific CDB.

        If comparmentId is specified, then the metrics for each PDB (within the CDB) in the specified compartment are retrieved. If compartmentId is not specified, then the metrics for all the PDBs within the CDB are retrieved.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getPeerDatabaseMetrics

        Future<GetPeerDatabaseMetricsResponse> getPeerDatabaseMetrics​(GetPeerDatabaseMetricsRequest request,
                                                              AsyncHandler<GetPeerDatabaseMetricsRequest,​GetPeerDatabaseMetricsResponse> handler)
        Gets a comparative summary of the baseline and target values of the Data Guard performance metrics for Managed Databases.

        If the peerDatabaseCompartmentId is specified, then the metrics are only retrieved from the specified compartment. If the peerDatabaseCompartmentId is not specified, then the metrics are retrieved from the compartment of the Managed Database specified by the ManagedDatabaseId.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getPreferredCredential

        Future<GetPreferredCredentialResponse> getPreferredCredential​(GetPreferredCredentialRequest request,
                                                              AsyncHandler<GetPreferredCredentialRequest,​GetPreferredCredentialResponse> handler)
        Gets the preferred credential details for a Managed Database based on credentialName.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getSqlPlanBaseline

        Future<GetSqlPlanBaselineResponse> getSqlPlanBaseline​(GetSqlPlanBaselineRequest request,
                                                      AsyncHandler<GetSqlPlanBaselineRequest,​GetSqlPlanBaselineResponse> handler)
        Gets the SQL plan baseline details for the specified planName.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getSqlPlanBaselineConfiguration

        Future<GetSqlPlanBaselineConfigurationResponse> getSqlPlanBaselineConfiguration​(GetSqlPlanBaselineConfigurationRequest request,
                                                                                AsyncHandler<GetSqlPlanBaselineConfigurationRequest,​GetSqlPlanBaselineConfigurationResponse> handler)
        Gets the configuration details of SQL plan baselines for the specified Managed Database.

        The details include the settings for the capture and use of SQL plan baselines, SPM Evolve Advisor task, and SQL Management Base.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getTablespace

        Future<GetTablespaceResponse> getTablespace​(GetTablespaceRequest request,
                                            AsyncHandler<GetTablespaceRequest,​GetTablespaceResponse> handler)
        Gets the details of the tablespace specified by tablespaceName within the Managed Database specified by managedDatabaseId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getTopSqlCpuActivity

        Future<GetTopSqlCpuActivityResponse> getTopSqlCpuActivity​(GetTopSqlCpuActivityRequest request,
                                                          AsyncHandler<GetTopSqlCpuActivityRequest,​GetTopSqlCpuActivityResponse> handler)
        Gets the SQL IDs with the top CPU activity from the Exadata storage server.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getUser

        Future<GetUserResponse> getUser​(GetUserRequest request,
                                AsyncHandler<GetUserRequest,​GetUserResponse> handler)
        Gets the details of the user specified by managedDatabaseId and userName.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • getWorkRequest

        Future<GetWorkRequestResponse> getWorkRequest​(GetWorkRequestRequest request,
                                              AsyncHandler<GetWorkRequestRequest,​GetWorkRequestResponse> handler)
        Gets the status of the work request with the given Work Request ID.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAsmProperties

        Future<ListAsmPropertiesResponse> listAsmProperties​(ListAsmPropertiesRequest request,
                                                    AsyncHandler<ListAsmPropertiesRequest,​ListAsmPropertiesResponse> handler)
        Gets the list of ASM properties for the specified managedDatabaseId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAssociatedDatabases

        Future<ListAssociatedDatabasesResponse> listAssociatedDatabases​(ListAssociatedDatabasesRequest request,
                                                                AsyncHandler<ListAssociatedDatabasesRequest,​ListAssociatedDatabasesResponse> handler)
        Gets the list of databases using a specific Database Management private endpoint.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAwrDbSnapshots

        Future<ListAwrDbSnapshotsResponse> listAwrDbSnapshots​(ListAwrDbSnapshotsRequest request,
                                                      AsyncHandler<ListAwrDbSnapshotsRequest,​ListAwrDbSnapshotsResponse> handler)
        Lists AWR snapshots for the specified database in the AWR.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listAwrDbs

        Future<ListAwrDbsResponse> listAwrDbs​(ListAwrDbsRequest request,
                                      AsyncHandler<ListAwrDbsRequest,​ListAwrDbsResponse> handler)
        Gets the list of databases and their snapshot summary details available in the AWR of the specified Managed Database.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listCloudAsmDiskGroups

        Future<ListCloudAsmDiskGroupsResponse> listCloudAsmDiskGroups​(ListCloudAsmDiskGroupsRequest request,
                                                              AsyncHandler<ListCloudAsmDiskGroupsRequest,​ListCloudAsmDiskGroupsResponse> handler)
        Lists ASM disk groups for the cloud ASM specified by cloudAsmId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listCloudAsmInstances

        Future<ListCloudAsmInstancesResponse> listCloudAsmInstances​(ListCloudAsmInstancesRequest request,
                                                            AsyncHandler<ListCloudAsmInstancesRequest,​ListCloudAsmInstancesResponse> handler)
        Lists the ASM instances in the specified cloud ASM.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listCloudAsmUsers

        Future<ListCloudAsmUsersResponse> listCloudAsmUsers​(ListCloudAsmUsersRequest request,
                                                    AsyncHandler<ListCloudAsmUsersRequest,​ListCloudAsmUsersResponse> handler)
        Lists ASM users for the cloud ASM specified by cloudAsmId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listCloudAsms

        Future<ListCloudAsmsResponse> listCloudAsms​(ListCloudAsmsRequest request,
                                            AsyncHandler<ListCloudAsmsRequest,​ListCloudAsmsResponse> handler)
        Lists the ASMs in the specified cloud DB system.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listCloudClusters

        Future<ListCloudClustersResponse> listCloudClusters​(ListCloudClustersRequest request,
                                                    AsyncHandler<ListCloudClustersRequest,​ListCloudClustersResponse> handler)
        Lists the clusters in the specified cloud DB system.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listCloudDatabases

        Future<ListCloudDatabasesResponse> listCloudDatabases​(ListCloudDatabasesRequest request,
                                                      AsyncHandler<ListCloudDatabasesRequest,​ListCloudDatabasesResponse> handler)
        Lists the cloud databases in the specified compartment or in the specified DB system.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listCloudDbHomes

        Future<ListCloudDbHomesResponse> listCloudDbHomes​(ListCloudDbHomesRequest request,
                                                  AsyncHandler<ListCloudDbHomesRequest,​ListCloudDbHomesResponse> handler)
        Lists the DB homes in the specified cloud DB system.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listCloudDbNodes

        Future<ListCloudDbNodesResponse> listCloudDbNodes​(ListCloudDbNodesRequest request,
                                                  AsyncHandler<ListCloudDbNodesRequest,​ListCloudDbNodesResponse> handler)
        Lists the cloud DB nodes in the specified cloud DB system.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listCloudDbSystems

        Future<ListCloudDbSystemsResponse> listCloudDbSystems​(ListCloudDbSystemsRequest request,
                                                      AsyncHandler<ListCloudDbSystemsRequest,​ListCloudDbSystemsResponse> handler)
        Lists the cloud DB systems in the specified compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listCloudListenerServices

        Future<ListCloudListenerServicesResponse> listCloudListenerServices​(ListCloudListenerServicesRequest request,
                                                                    AsyncHandler<ListCloudListenerServicesRequest,​ListCloudListenerServicesResponse> handler)
        Lists the database services registered with the specified cloud listener for the specified Managed Database.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listCloudListeners

        Future<ListCloudListenersResponse> listCloudListeners​(ListCloudListenersRequest request,
                                                      AsyncHandler<ListCloudListenersRequest,​ListCloudListenersResponse> handler)
        Lists the listeners in the specified cloud DB system.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listCursorCacheStatements

        Future<ListCursorCacheStatementsResponse> listCursorCacheStatements​(ListCursorCacheStatementsRequest request,
                                                                    AsyncHandler<ListCursorCacheStatementsRequest,​ListCursorCacheStatementsResponse> handler)
        Lists the SQL statements from shared SQL area, also called the cursor cache.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listDataAccessContainers

        Future<ListDataAccessContainersResponse> listDataAccessContainers​(ListDataAccessContainersRequest request,
                                                                  AsyncHandler<ListDataAccessContainersRequest,​ListDataAccessContainersResponse> handler)
        Gets the list of containers for a specific user.

        This is only applicable if ALL_CONTAINERS !=‘Y’.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listDatabaseParameters

        Future<ListDatabaseParametersResponse> listDatabaseParameters​(ListDatabaseParametersRequest request,
                                                              AsyncHandler<ListDatabaseParametersRequest,​ListDatabaseParametersResponse> handler)
        Gets the list of database parameters for the specified Managed Database.

        The parameters are listed in alphabetical order, along with their current values.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listExternalAsmUsers

        Future<ListExternalAsmUsersResponse> listExternalAsmUsers​(ListExternalAsmUsersRequest request,
                                                          AsyncHandler<ListExternalAsmUsersRequest,​ListExternalAsmUsersResponse> handler)
        Lists ASM users for the external ASM specified by externalAsmId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listExternalAsms

        Future<ListExternalAsmsResponse> listExternalAsms​(ListExternalAsmsRequest request,
                                                  AsyncHandler<ListExternalAsmsRequest,​ListExternalAsmsResponse> handler)
        Lists the ASMs in the specified external DB system.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listExternalClusters

        Future<ListExternalClustersResponse> listExternalClusters​(ListExternalClustersRequest request,
                                                          AsyncHandler<ListExternalClustersRequest,​ListExternalClustersResponse> handler)
        Lists the clusters in the specified external DB system.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listExternalDatabases

        Future<ListExternalDatabasesResponse> listExternalDatabases​(ListExternalDatabasesRequest request,
                                                            AsyncHandler<ListExternalDatabasesRequest,​ListExternalDatabasesResponse> handler)
        Lists the external databases in the specified compartment or in the specified DB system.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listExternalDbHomes

        Future<ListExternalDbHomesResponse> listExternalDbHomes​(ListExternalDbHomesRequest request,
                                                        AsyncHandler<ListExternalDbHomesRequest,​ListExternalDbHomesResponse> handler)
        Lists the DB homes in the specified external DB system.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listExternalDbNodes

        Future<ListExternalDbNodesResponse> listExternalDbNodes​(ListExternalDbNodesRequest request,
                                                        AsyncHandler<ListExternalDbNodesRequest,​ListExternalDbNodesResponse> handler)
        Lists the external DB nodes in the specified external DB system.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listExternalDbSystems

        Future<ListExternalDbSystemsResponse> listExternalDbSystems​(ListExternalDbSystemsRequest request,
                                                            AsyncHandler<ListExternalDbSystemsRequest,​ListExternalDbSystemsResponse> handler)
        Lists the external DB systems in the specified compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listExternalListeners

        Future<ListExternalListenersResponse> listExternalListeners​(ListExternalListenersRequest request,
                                                            AsyncHandler<ListExternalListenersRequest,​ListExternalListenersResponse> handler)
        Lists the listeners in the specified external DB system.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listJobExecutions

        Future<ListJobExecutionsResponse> listJobExecutions​(ListJobExecutionsRequest request,
                                                    AsyncHandler<ListJobExecutionsRequest,​ListJobExecutionsResponse> handler)
        Gets the job execution for a specific ID or the list of job executions for a job, job run, Managed Database or Managed Database Group in a specific compartment.

        Only one of the parameters, ID, jobId, jobRunId, managedDatabaseId or managedDatabaseGroupId should be provided. If none of these parameters is provided, all the job executions in the compartment are listed. Job executions can also be filtered based on the name and status parameters.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listJobRuns

        Future<ListJobRunsResponse> listJobRuns​(ListJobRunsRequest request,
                                        AsyncHandler<ListJobRunsRequest,​ListJobRunsResponse> handler)
        Gets the job run for a specific ID or the list of job runs for a job, Managed Database or Managed Database Group in a specific compartment.

        Only one of the parameters, ID, jobId, managedDatabaseId, or managedDatabaseGroupId should be provided. If none of these parameters is provided, all the job runs in the compartment are listed. Job runs can also be filtered based on name and runStatus parameters.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listJobs

        Future<ListJobsResponse> listJobs​(ListJobsRequest request,
                                  AsyncHandler<ListJobsRequest,​ListJobsResponse> handler)
        Gets the job for a specific ID or the list of jobs for a Managed Database or Managed Database Group in a specific compartment.

        Only one of the parameters, ID, managedDatabaseId or managedDatabaseGroupId, should be provided. If none of these parameters is provided, all the jobs in the compartment are listed. Jobs can also be filtered based on the name and lifecycleState parameters.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listManagedDatabaseGroups

        Future<ListManagedDatabaseGroupsResponse> listManagedDatabaseGroups​(ListManagedDatabaseGroupsRequest request,
                                                                    AsyncHandler<ListManagedDatabaseGroupsRequest,​ListManagedDatabaseGroupsResponse> handler)
        Gets the Managed Database Group for a specific ID or the list of Managed Database Groups in a specific compartment.

        Managed Database Groups can also be filtered based on the name parameter. Only one of the parameters, ID or name should be provided. If none of these parameters is provided, all the Managed Database Groups in the compartment are listed.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listManagedDatabases

        Future<ListManagedDatabasesResponse> listManagedDatabases​(ListManagedDatabasesRequest request,
                                                          AsyncHandler<ListManagedDatabasesRequest,​ListManagedDatabasesResponse> handler)
        Gets the Managed Database for a specific ID or the list of Managed Databases in a specific compartment.

        Managed Databases can be filtered based on the name parameter. Only one of the parameters, ID or name should be provided. If neither of these parameters is provided, all the Managed Databases in the compartment are listed. Managed Databases can also be filtered based on the deployment type and management option. If the deployment type is not specified or if it is ONPREMISE, then the management option is not considered and Managed Databases with ADVANCED management option are listed.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listNamedCredentials

        Future<ListNamedCredentialsResponse> listNamedCredentials​(ListNamedCredentialsRequest request,
                                                          AsyncHandler<ListNamedCredentialsRequest,​ListNamedCredentialsResponse> handler)
        Gets a single named credential specified by the name or all the named credentials in a specific compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listObjectPrivileges

        Future<ListObjectPrivilegesResponse> listObjectPrivileges​(ListObjectPrivilegesRequest request,
                                                          AsyncHandler<ListObjectPrivilegesRequest,​ListObjectPrivilegesResponse> handler)
        Gets the list of object privileges granted to a specific user.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listOptimizerStatisticsAdvisorExecutions

        Future<ListOptimizerStatisticsAdvisorExecutionsResponse> listOptimizerStatisticsAdvisorExecutions​(ListOptimizerStatisticsAdvisorExecutionsRequest request,
                                                                                                  AsyncHandler<ListOptimizerStatisticsAdvisorExecutionsRequest,​ListOptimizerStatisticsAdvisorExecutionsResponse> handler)
        Lists the details of the Optimizer Statistics Advisor task executions, such as their duration, and the number of findings, if any.

        Optionally, you can specify a date-time range (of seven days) to obtain the list of executions that fall within the specified time range. If the date-time range is not specified, then the executions in the last seven days are listed.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listOptimizerStatisticsCollectionAggregations

        Future<ListOptimizerStatisticsCollectionAggregationsResponse> listOptimizerStatisticsCollectionAggregations​(ListOptimizerStatisticsCollectionAggregationsRequest request,
                                                                                                            AsyncHandler<ListOptimizerStatisticsCollectionAggregationsRequest,​ListOptimizerStatisticsCollectionAggregationsResponse> handler)
        Gets a list of the optimizer statistics collection operations per hour, grouped by task or object status for the specified Managed Database.

        You must specify a value for GroupByQueryParam to determine whether the data should be grouped by task status or task object status. Optionally, you can specify a date-time range (of seven days) to obtain collection aggregations within the specified time range. If the date-time range is not specified, then the operations in the last seven days are listed. You can further filter the results by providing the optional type of TaskTypeQueryParam. If the task type not provided, then both Auto and Manual tasks are considered for aggregation.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listOptimizerStatisticsCollectionOperations

        Future<ListOptimizerStatisticsCollectionOperationsResponse> listOptimizerStatisticsCollectionOperations​(ListOptimizerStatisticsCollectionOperationsRequest request,
                                                                                                        AsyncHandler<ListOptimizerStatisticsCollectionOperationsRequest,​ListOptimizerStatisticsCollectionOperationsResponse> handler)
        Lists the Optimizer Statistics Collection (Auto and Manual) task operation summary for the specified Managed Database.

        The summary includes the details of each operation and the number of tasks grouped by status: Completed, In Progress, Failed, and so on. Optionally, you can specify a date-time range (of seven days) to obtain the list of operations that fall within the specified time range. If the date-time range is not specified, then the operations in the last seven days are listed. This API also enables the pagination of results and the opc-next-page response header indicates whether there is a next page. If you use the same header value in a consecutive request, the next page records are returned. To obtain the required results, you can apply the different types of filters supported by this API.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listPreferredCredentials

        Future<ListPreferredCredentialsResponse> listPreferredCredentials​(ListPreferredCredentialsRequest request,
                                                                  AsyncHandler<ListPreferredCredentialsRequest,​ListPreferredCredentialsResponse> handler)
        Gets the list of preferred credentials for a given Managed Database.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listProxiedForUsers

        Future<ListProxiedForUsersResponse> listProxiedForUsers​(ListProxiedForUsersRequest request,
                                                        AsyncHandler<ListProxiedForUsersRequest,​ListProxiedForUsersResponse> handler)
        Gets the list of users on whose behalf the current user acts as proxy.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listProxyUsers

        Future<ListProxyUsersResponse> listProxyUsers​(ListProxyUsersRequest request,
                                              AsyncHandler<ListProxyUsersRequest,​ListProxyUsersResponse> handler)
        Gets the list of proxy users for the current user.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listRoles

        Future<ListRolesResponse> listRoles​(ListRolesRequest request,
                                    AsyncHandler<ListRolesRequest,​ListRolesResponse> handler)
        Gets the list of roles granted to a specific user.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSqlPlanBaselineJobs

        Future<ListSqlPlanBaselineJobsResponse> listSqlPlanBaselineJobs​(ListSqlPlanBaselineJobsRequest request,
                                                                AsyncHandler<ListSqlPlanBaselineJobsRequest,​ListSqlPlanBaselineJobsResponse> handler)
        Lists the database jobs used for loading SQL plan baselines in the specified Managed Database.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSqlPlanBaselines

        Future<ListSqlPlanBaselinesResponse> listSqlPlanBaselines​(ListSqlPlanBaselinesRequest request,
                                                          AsyncHandler<ListSqlPlanBaselinesRequest,​ListSqlPlanBaselinesResponse> handler)
        Lists the SQL plan baselines for the specified Managed Database.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listSystemPrivileges

        Future<ListSystemPrivilegesResponse> listSystemPrivileges​(ListSystemPrivilegesRequest request,
                                                          AsyncHandler<ListSystemPrivilegesRequest,​ListSystemPrivilegesResponse> handler)
        Gets the list of system privileges granted to a specific user.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listTableStatistics

        Future<ListTableStatisticsResponse> listTableStatistics​(ListTableStatisticsRequest request,
                                                        AsyncHandler<ListTableStatisticsRequest,​ListTableStatisticsResponse> handler)
        Lists the database table statistics grouped by different statuses such as Not Stale Stats, Stale Stats, and No Stats.

        This also includes the percentage of each status.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listTablespaces

        Future<ListTablespacesResponse> listTablespaces​(ListTablespacesRequest request,
                                                AsyncHandler<ListTablespacesRequest,​ListTablespacesResponse> handler)
        Gets the list of tablespaces for the specified managedDatabaseId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listUsers

        Future<ListUsersResponse> listUsers​(ListUsersRequest request,
                                    AsyncHandler<ListUsersRequest,​ListUsersResponse> handler)
        Gets the list of users for the specified managedDatabaseId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listWorkRequestErrors

        Future<ListWorkRequestErrorsResponse> listWorkRequestErrors​(ListWorkRequestErrorsRequest request,
                                                            AsyncHandler<ListWorkRequestErrorsRequest,​ListWorkRequestErrorsResponse> handler)
        Returns a paginated list of errors for a given work request.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listWorkRequestLogs

        Future<ListWorkRequestLogsResponse> listWorkRequestLogs​(ListWorkRequestLogsRequest request,
                                                        AsyncHandler<ListWorkRequestLogsRequest,​ListWorkRequestLogsResponse> handler)
        Returns a paginated list of logs for a given work request.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • listWorkRequests

        Future<ListWorkRequestsResponse> listWorkRequests​(ListWorkRequestsRequest request,
                                                  AsyncHandler<ListWorkRequestsRequest,​ListWorkRequestsResponse> handler)
        Lists the work requests in a specific compartment.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • loadSqlPlanBaselinesFromAwr

        Future<LoadSqlPlanBaselinesFromAwrResponse> loadSqlPlanBaselinesFromAwr​(LoadSqlPlanBaselinesFromAwrRequest request,
                                                                        AsyncHandler<LoadSqlPlanBaselinesFromAwrRequest,​LoadSqlPlanBaselinesFromAwrResponse> handler)
        Loads plans from Automatic Workload Repository (AWR) snapshots.

        You must specify the beginning and ending of the snapshot range. Optionally, you can apply a filter to load only plans that meet specified criteria. By default, the optimizer uses the loaded plans the next time that the database executes the SQL statements.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • loadSqlPlanBaselinesFromCursorCache

        Future<LoadSqlPlanBaselinesFromCursorCacheResponse> loadSqlPlanBaselinesFromCursorCache​(LoadSqlPlanBaselinesFromCursorCacheRequest request,
                                                                                        AsyncHandler<LoadSqlPlanBaselinesFromCursorCacheRequest,​LoadSqlPlanBaselinesFromCursorCacheResponse> handler)
        Loads plans for statements directly from the shared SQL area, also called the cursor cache.

        By applying a filter on the module name, the schema, or the SQL ID you identify the SQL statement or set of SQL statements to load.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • removeDataFile

        Future<RemoveDataFileResponse> removeDataFile​(RemoveDataFileRequest request,
                                              AsyncHandler<RemoveDataFileRequest,​RemoveDataFileResponse> handler)
        Removes a data file or temp file from the tablespace.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • resetDatabaseParameters

        Future<ResetDatabaseParametersResponse> resetDatabaseParameters​(ResetDatabaseParametersRequest request,
                                                                AsyncHandler<ResetDatabaseParametersRequest,​ResetDatabaseParametersResponse> handler)
        Resets database parameter values to their default or startup values.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • resizeDataFile

        Future<ResizeDataFileResponse> resizeDataFile​(ResizeDataFileRequest request,
                                              AsyncHandler<ResizeDataFileRequest,​ResizeDataFileResponse> handler)
        Resizes a data file or temp file within the tablespace.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • runHistoricAddm

        Future<RunHistoricAddmResponse> runHistoricAddm​(RunHistoricAddmRequest request,
                                                AsyncHandler<RunHistoricAddmRequest,​RunHistoricAddmResponse> handler)
        Creates and executes a historic ADDM task using the specified AWR snapshot IDs.

        If an existing ADDM task uses the provided awr snapshot IDs, the existing task will be returned.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • summarizeAwrDbCpuUsages

        Future<SummarizeAwrDbCpuUsagesResponse> summarizeAwrDbCpuUsages​(SummarizeAwrDbCpuUsagesRequest request,
                                                                AsyncHandler<SummarizeAwrDbCpuUsagesRequest,​SummarizeAwrDbCpuUsagesResponse> handler)
        Summarizes the AWR CPU resource limits and metrics for the specified database in AWR.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • summarizeAwrDbMetrics

        Future<SummarizeAwrDbMetricsResponse> summarizeAwrDbMetrics​(SummarizeAwrDbMetricsRequest request,
                                                            AsyncHandler<SummarizeAwrDbMetricsRequest,​SummarizeAwrDbMetricsResponse> handler)
        Summarizes the metric samples for the specified database in the AWR.

        The metric samples are summarized based on the Time dimension for each metric.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • summarizeAwrDbParameterChanges

        Future<SummarizeAwrDbParameterChangesResponse> summarizeAwrDbParameterChanges​(SummarizeAwrDbParameterChangesRequest request,
                                                                              AsyncHandler<SummarizeAwrDbParameterChangesRequest,​SummarizeAwrDbParameterChangesResponse> handler)
        Summarizes the database parameter change history for one database parameter of the specified database in AWR.

        One change history record contains the previous value, the changed value, and the corresponding time range. If the database parameter value was changed multiple times within the time range, then multiple change history records are created for the same parameter. Note that this API only returns information on change history details for one database parameter. To get a list of all the database parameters whose values were changed during a specified time range, use the following API endpoint: /managedDatabases/{managedDatabaseId}/awrDbs/{awrDbId}/awrDbParameters

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • summarizeAwrDbParameters

        Future<SummarizeAwrDbParametersResponse> summarizeAwrDbParameters​(SummarizeAwrDbParametersRequest request,
                                                                  AsyncHandler<SummarizeAwrDbParametersRequest,​SummarizeAwrDbParametersResponse> handler)
        Summarizes the database parameter history for the specified database in AWR.

        This includes the list of database parameters, with information on whether the parameter values were modified within the query time range. Note that each database parameter is only listed once. Depending on the optional query parameters, the returned summary gets all the database parameters, which include:

        - Each parameter whose value was changed during the time range: (valueChanged =\"Y\") - Each parameter whose value was unchanged during the time range: (valueChanged =\"N\") - Each parameter whose value was changed at the system level during the time range: (valueChanged =\"Y\" and valueModified = \"SYSTEM_MOD\") - Each parameter whose value was unchanged during the time range, however, the value is not the default value: (valueChanged =\"N\" and valueDefault = \"FALSE\")

        Note that this API does not return information on the number of times each database parameter has been changed within the time range. To get the database parameter value change history for a specific parameter, use the following API endpoint: /managedDatabases/{managedDatabaseId}/awrDbs/{awrDbId}/awrDbParameterChanges

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • summarizeAwrDbSysstats

        Future<SummarizeAwrDbSysstatsResponse> summarizeAwrDbSysstats​(SummarizeAwrDbSysstatsRequest request,
                                                              AsyncHandler<SummarizeAwrDbSysstatsRequest,​SummarizeAwrDbSysstatsResponse> handler)
        Summarizes the AWR SYSSTAT sample data for the specified database in AWR.

        The statistical data is summarized based on the Time dimension for each statistic.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • summarizeAwrDbWaitEvents

        Future<SummarizeAwrDbWaitEventsResponse> summarizeAwrDbWaitEvents​(SummarizeAwrDbWaitEventsRequest request,
                                                                  AsyncHandler<SummarizeAwrDbWaitEventsRequest,​SummarizeAwrDbWaitEventsResponse> handler)
        Summarizes the AWR wait event sample data for the specified database in the AWR.

        The event data is summarized based on the Time dimension for each event.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • summarizeJobExecutionsStatuses

        Future<SummarizeJobExecutionsStatusesResponse> summarizeJobExecutionsStatuses​(SummarizeJobExecutionsStatusesRequest request,
                                                                              AsyncHandler<SummarizeJobExecutionsStatusesRequest,​SummarizeJobExecutionsStatusesResponse> handler)
        Gets the number of job executions grouped by status for a job, Managed Database, or Database Group in a specific compartment.

        Only one of the parameters, jobId, managedDatabaseId, or managedDatabaseGroupId should be provided.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • testNamedCredential

        Future<TestNamedCredentialResponse> testNamedCredential​(TestNamedCredentialRequest request,
                                                        AsyncHandler<TestNamedCredentialRequest,​TestNamedCredentialResponse> handler)
        Tests the named credential.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateCloudAsm

        Future<UpdateCloudAsmResponse> updateCloudAsm​(UpdateCloudAsmRequest request,
                                              AsyncHandler<UpdateCloudAsmRequest,​UpdateCloudAsmResponse> handler)
        Updates the cloud ASM specified by cloudAsmId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateCloudAsmInstance

        Future<UpdateCloudAsmInstanceResponse> updateCloudAsmInstance​(UpdateCloudAsmInstanceRequest request,
                                                              AsyncHandler<UpdateCloudAsmInstanceRequest,​UpdateCloudAsmInstanceResponse> handler)
        Updates the cloud ASM instance specified by cloudAsmInstanceId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateCloudCluster

        Future<UpdateCloudClusterResponse> updateCloudCluster​(UpdateCloudClusterRequest request,
                                                      AsyncHandler<UpdateCloudClusterRequest,​UpdateCloudClusterResponse> handler)
        Updates the cloud cluster specified by cloudClusterId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateCloudDbHome

        Future<UpdateCloudDbHomeResponse> updateCloudDbHome​(UpdateCloudDbHomeRequest request,
                                                    AsyncHandler<UpdateCloudDbHomeRequest,​UpdateCloudDbHomeResponse> handler)
        Updates the cloud DB home specified by cloudDbHomeId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateCloudDbNode

        Future<UpdateCloudDbNodeResponse> updateCloudDbNode​(UpdateCloudDbNodeRequest request,
                                                    AsyncHandler<UpdateCloudDbNodeRequest,​UpdateCloudDbNodeResponse> handler)
        Updates the cloud DB node specified by cloudDbNodeId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateCloudDbSystem

        Future<UpdateCloudDbSystemResponse> updateCloudDbSystem​(UpdateCloudDbSystemRequest request,
                                                        AsyncHandler<UpdateCloudDbSystemRequest,​UpdateCloudDbSystemResponse> handler)
        Updates the cloud DB system specified by cloudDbSystemId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateCloudListener

        Future<UpdateCloudListenerResponse> updateCloudListener​(UpdateCloudListenerRequest request,
                                                        AsyncHandler<UpdateCloudListenerRequest,​UpdateCloudListenerResponse> handler)
        Updates the cloud listener specified by cloudListenerId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateExternalAsm

        Future<UpdateExternalAsmResponse> updateExternalAsm​(UpdateExternalAsmRequest request,
                                                    AsyncHandler<UpdateExternalAsmRequest,​UpdateExternalAsmResponse> handler)
        Updates the external ASM specified by externalAsmId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateExternalCluster

        Future<UpdateExternalClusterResponse> updateExternalCluster​(UpdateExternalClusterRequest request,
                                                            AsyncHandler<UpdateExternalClusterRequest,​UpdateExternalClusterResponse> handler)
        Updates the external cluster specified by externalClusterId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateExternalDbHome

        Future<UpdateExternalDbHomeResponse> updateExternalDbHome​(UpdateExternalDbHomeRequest request,
                                                          AsyncHandler<UpdateExternalDbHomeRequest,​UpdateExternalDbHomeResponse> handler)
        Updates the external DB home specified by externalDbHomeId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateExternalDbNode

        Future<UpdateExternalDbNodeResponse> updateExternalDbNode​(UpdateExternalDbNodeRequest request,
                                                          AsyncHandler<UpdateExternalDbNodeRequest,​UpdateExternalDbNodeResponse> handler)
        Updates the external DB node specified by externalDbNodeId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateExternalDbSystem

        Future<UpdateExternalDbSystemResponse> updateExternalDbSystem​(UpdateExternalDbSystemRequest request,
                                                              AsyncHandler<UpdateExternalDbSystemRequest,​UpdateExternalDbSystemResponse> handler)
        Updates the external DB system specified by externalDbSystemId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateExternalListener

        Future<UpdateExternalListenerResponse> updateExternalListener​(UpdateExternalListenerRequest request,
                                                              AsyncHandler<UpdateExternalListenerRequest,​UpdateExternalListenerResponse> handler)
        Updates the external listener specified by externalListenerId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateJob

        Future<UpdateJobResponse> updateJob​(UpdateJobRequest request,
                                    AsyncHandler<UpdateJobRequest,​UpdateJobResponse> handler)
        Updates the details of the recurring scheduled job specified by jobId.

        Note that non-recurring (one time) jobs cannot be updated.

        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateManagedDatabase

        Future<UpdateManagedDatabaseResponse> updateManagedDatabase​(UpdateManagedDatabaseRequest request,
                                                            AsyncHandler<UpdateManagedDatabaseRequest,​UpdateManagedDatabaseResponse> handler)
        Updates the Managed Database specified by managedDatabaseId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateNamedCredential

        Future<UpdateNamedCredentialResponse> updateNamedCredential​(UpdateNamedCredentialRequest request,
                                                            AsyncHandler<UpdateNamedCredentialRequest,​UpdateNamedCredentialResponse> handler)
        Updates the named credential specified by namedCredentialId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.

      • updateTablespace

        Future<UpdateTablespaceResponse> updateTablespace​(UpdateTablespaceRequest request,
                                                  AsyncHandler<UpdateTablespaceRequest,​UpdateTablespaceResponse> handler)
        Updates the attributes of the tablespace specified by tablespaceName within the Managed Database specified by managedDatabaseId.
        Parameters:
        request - The request object containing the details to send
        handler - The request handler to invoke upon completion, may be null.
        Returns:
        A Future that can be used to get the response if no AsyncHandler was provided. Note, if you provide an AsyncHandler and use the Future, some types of responses (like java.io.InputStream) may not be able to be read in both places as the underlying stream may only be consumed once.