Interface DatabaseAsync

    • 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
      • cancelBackup

        Future<CancelBackupResponse> cancelBackup​(CancelBackupRequest request,
                                                  AsyncHandler<CancelBackupRequest,​CancelBackupResponse> handler)
        Cancel automatic/standalone full/incremental create backup workrequests specified by the backup 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.
      • cancelExecutionWindow

        Future<CancelExecutionWindowResponse> cancelExecutionWindow​(CancelExecutionWindowRequest request,
                                                                    AsyncHandler<CancelExecutionWindowRequest,​CancelExecutionWindowResponse> handler)
        Cancels the in progress maintenance activity under this execution window.
        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.
      • changeCloudVmClusterCompartment

        Future<ChangeCloudVmClusterCompartmentResponse> changeCloudVmClusterCompartment​(ChangeCloudVmClusterCompartmentRequest request,
                                                                                        AsyncHandler<ChangeCloudVmClusterCompartmentRequest,​ChangeCloudVmClusterCompartmentResponse> handler)
        Moves a cloud VM cluster and its dependent resources to another compartment.

        Applies to Exadata Cloud Service instances and Autonomous Database on dedicated Exadata infrastructure only.

        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.
      • changeExadataInfrastructureCompartment

        Future<ChangeExadataInfrastructureCompartmentResponse> changeExadataInfrastructureCompartment​(ChangeExadataInfrastructureCompartmentRequest request,
                                                                                                      AsyncHandler<ChangeExadataInfrastructureCompartmentRequest,​ChangeExadataInfrastructureCompartmentResponse> handler)
        Moves an Exadata infrastructure resource and its dependent resources to another compartment.

        Applies to Exadata Cloud@Customer instances only. To move an Exadata Cloud Service infrastructure resource to another compartment, use the changeCloudExadataInfrastructureCompartment operation.

        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.
      • changeExadbVmClusterCompartment

        Future<ChangeExadbVmClusterCompartmentResponse> changeExadbVmClusterCompartment​(ChangeExadbVmClusterCompartmentRequest request,
                                                                                        AsyncHandler<ChangeExadbVmClusterCompartmentRequest,​ChangeExadbVmClusterCompartmentResponse> handler)
        Moves a Exadata VM cluster on Exascale Infrastructure and its dependent resources to another compartment.

        Applies to Exadata Database Service on Exascale Infrastructure only.

        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.
      • changeKeyStoreType

        Future<ChangeKeyStoreTypeResponse> changeKeyStoreType​(ChangeKeyStoreTypeRequest request,
                                                              AsyncHandler<ChangeKeyStoreTypeRequest,​ChangeKeyStoreTypeResponse> handler)
        Changes encryption key management type
        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.
      • changeVmClusterCompartment

        Future<ChangeVmClusterCompartmentResponse> changeVmClusterCompartment​(ChangeVmClusterCompartmentRequest request,
                                                                              AsyncHandler<ChangeVmClusterCompartmentRequest,​ChangeVmClusterCompartmentResponse> handler)
        Moves a VM cluster and its dependent resources to another compartment.

        Applies to Exadata Cloud@Customer instances only. To move a cloud VM cluster in an Exadata Cloud Service instance to another compartment, use the changeCloudVmClusterCompartment operation.

        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.
      • completeExternalBackupJob

        Future<CompleteExternalBackupJobResponse> completeExternalBackupJob​(CompleteExternalBackupJobRequest request,
                                                                            AsyncHandler<CompleteExternalBackupJobRequest,​CompleteExternalBackupJobResponse> handler)
        Changes the status of the standalone backup resource to ACTIVE after the backup is created from the on-premises database and placed in Oracle Cloud Infrastructure Object Storage.

        *Note:** This API is used by an Oracle Cloud Infrastructure Python script that is packaged with the Oracle Cloud Infrastructure CLI. Oracle recommends that you use the script instead using the API directly. See [Migrating an On-Premises Database to Oracle Cloud Infrastructure by Creating a Backup in the Cloud](https://docs.oracle.com/iaas/Content/Database/Tasks/mig-onprembackup.htm) for more information.

        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.
      • configureSaasAdminUser

        Future<ConfigureSaasAdminUserResponse> configureSaasAdminUser​(ConfigureSaasAdminUserRequest request,
                                                                      AsyncHandler<ConfigureSaasAdminUserRequest,​ConfigureSaasAdminUserResponse> handler)
        This operation updates SaaS administrative user configuration of the Autonomous 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.
      • confirmKeyStoreDetailsAreCorrect

        Future<ConfirmKeyStoreDetailsAreCorrectResponse> confirmKeyStoreDetailsAreCorrect​(ConfirmKeyStoreDetailsAreCorrectRequest request,
                                                                                          AsyncHandler<ConfirmKeyStoreDetailsAreCorrectRequest,​ConfirmKeyStoreDetailsAreCorrectResponse> handler)
        This is for user to confirm to DBaaS that the Oracle Key Valut (OKV) connection IPs, username and password are all correct.

        This operation will put the Key Store back into Active state. If details are incorrect, your OKV account may get locked after some unsuccessful attempts to connect.

        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.
      • convertToPdb

        Future<ConvertToPdbResponse> convertToPdb​(ConvertToPdbRequest request,
                                                  AsyncHandler<ConvertToPdbRequest,​ConvertToPdbResponse> handler)
        Converts a non-container database to a pluggable 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.
      • convertToStandalone

        Future<ConvertToStandaloneResponse> convertToStandalone​(ConvertToStandaloneRequest request,
                                                                AsyncHandler<ConvertToStandaloneRequest,​ConvertToStandaloneResponse> handler)
        Disassociate the standby database identified by the databaseId parameter from existing Data Guard group.

        Convert the standby to a standalone database.

        This operation should be performed on respective standby 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.
      • createApplicationVip

        Future<CreateApplicationVipResponse> createApplicationVip​(CreateApplicationVipRequest request,
                                                                  AsyncHandler<CreateApplicationVipRequest,​CreateApplicationVipResponse> handler)
        Creates a new application virtual IP (VIP) address in the specified cloud VM cluster based on the request parameters you provide.
        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.
      • createAutonomousContainerDatabaseDataguardAssociation

        Future<CreateAutonomousContainerDatabaseDataguardAssociationResponse> createAutonomousContainerDatabaseDataguardAssociation​(CreateAutonomousContainerDatabaseDataguardAssociationRequest request,
                                                                                                                                    AsyncHandler<CreateAutonomousContainerDatabaseDataguardAssociationRequest,​CreateAutonomousContainerDatabaseDataguardAssociationResponse> handler)
        Create a new Autonomous Data Guard association.

        An Autonomous Data Guard association represents the replication relationship between the specified Autonomous Container database and a peer Autonomous Container database. For more information, see Using Oracle Data Guard.

        All Oracle Cloud Infrastructure resources, including Data Guard associations, get an Oracle-assigned, unique ID called an Oracle Cloud Identifier (OCID). When you create a resource, you can find its OCID in the response. You can also retrieve a resource's OCID by using a List API operation on that resource type, or by viewing the resource in the Console. For more information, see [Resource Identifiers](https://docs.oracle.com/iaas/Content/General/Concepts/identifiers.htm).

        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.
      • createAutonomousVmCluster

        Future<CreateAutonomousVmClusterResponse> createAutonomousVmCluster​(CreateAutonomousVmClusterRequest request,
                                                                            AsyncHandler<CreateAutonomousVmClusterRequest,​CreateAutonomousVmClusterResponse> handler)
        Creates an Autonomous VM cluster for Exadata Cloud@Customer.

        To create an Autonomous VM Cluster in the Oracle cloud, see createCloudAutonomousVmCluster.

        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.
      • createBackup

        Future<CreateBackupResponse> createBackup​(CreateBackupRequest request,
                                                  AsyncHandler<CreateBackupRequest,​CreateBackupResponse> handler)
        Creates a new backup in the specified database based on the request parameters you provide.

        If you previously used RMAN or dbcli to configure backups and then you switch to using the Console or the API for backups, a new backup configuration is created and associated with your database. This means that you can no longer rely on your previously configured unmanaged backups to work.

        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.
      • createBackupDestination

        Future<CreateBackupDestinationResponse> createBackupDestination​(CreateBackupDestinationRequest request,
                                                                        AsyncHandler<CreateBackupDestinationRequest,​CreateBackupDestinationResponse> handler)
        Creates a backup destination in an Exadata Cloud@Customer 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.
      • createCloudVmCluster

        Future<CreateCloudVmClusterResponse> createCloudVmCluster​(CreateCloudVmClusterRequest request,
                                                                  AsyncHandler<CreateCloudVmClusterRequest,​CreateCloudVmClusterResponse> handler)
        Creates a cloud VM cluster.
        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.
      • createConsoleConnection

        Future<CreateConsoleConnectionResponse> createConsoleConnection​(CreateConsoleConnectionRequest request,
                                                                        AsyncHandler<CreateConsoleConnectionRequest,​CreateConsoleConnectionResponse> handler)
        Creates a new console connection to the specified database node.

        After the console connection has been created and is available, you connect to the console using SSH.

        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.
      • createConsoleHistory

        Future<CreateConsoleHistoryResponse> createConsoleHistory​(CreateConsoleHistoryRequest request,
                                                                  AsyncHandler<CreateConsoleHistoryRequest,​CreateConsoleHistoryResponse> handler)
        Captures the most recent serial console data (up to a megabyte) for the specified database node.
        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.
      • createDataGuardAssociation

        Future<CreateDataGuardAssociationResponse> createDataGuardAssociation​(CreateDataGuardAssociationRequest request,
                                                                              AsyncHandler<CreateDataGuardAssociationRequest,​CreateDataGuardAssociationResponse> handler)
        Creates a new Data Guard association.

        A Data Guard association represents the replication relationship between the specified database and a peer database. For more information, see Using Oracle Data Guard.

        All Oracle Cloud Infrastructure resources, including Data Guard associations, get an Oracle-assigned, unique ID called an Oracle Cloud Identifier (OCID). When you create a resource, you can find its OCID in the response. You can also retrieve a resource's OCID by using a List API operation on that resource type, or by viewing the resource in the Console. For more information, see [Resource Identifiers](https://docs.oracle.com/iaas/Content/General/Concepts/identifiers.htm).

        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.
      • createDatabase

        Future<CreateDatabaseResponse> createDatabase​(CreateDatabaseRequest request,
                                                      AsyncHandler<CreateDatabaseRequest,​CreateDatabaseResponse> handler)
        Creates a new database in the specified Database Home.

        If the database version is provided, it must match the version of the Database Home. Applies to Exadata and Exadata Cloud@Customer systems.

        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.
      • createDbHome

        Future<CreateDbHomeResponse> createDbHome​(CreateDbHomeRequest request,
                                                  AsyncHandler<CreateDbHomeRequest,​CreateDbHomeResponse> handler)
        Creates a new Database Home in the specified database system based on the request parameters you provide.

        Applies to bare metal DB systems, Exadata systems, and Exadata Cloud@Customer systems.

        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.
      • createExadataInfrastructure

        Future<CreateExadataInfrastructureResponse> createExadataInfrastructure​(CreateExadataInfrastructureRequest request,
                                                                                AsyncHandler<CreateExadataInfrastructureRequest,​CreateExadataInfrastructureResponse> handler)
        Creates an Exadata infrastructure resource.

        Applies to Exadata Cloud@Customer instances only. To create an Exadata Cloud Service infrastructure resource, use the createCloudExadataInfrastructure operation.

        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.
      • createExadbVmCluster

        Future<CreateExadbVmClusterResponse> createExadbVmCluster​(CreateExadbVmClusterRequest request,
                                                                  AsyncHandler<CreateExadbVmClusterRequest,​CreateExadbVmClusterResponse> handler)
        Creates an Exadata VM cluster on Exascale 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.
      • createExecutionAction

        Future<CreateExecutionActionResponse> createExecutionAction​(CreateExecutionActionRequest request,
                                                                    AsyncHandler<CreateExecutionActionRequest,​CreateExecutionActionResponse> handler)
        Creates an execution action 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.
      • createExecutionWindow

        Future<CreateExecutionWindowResponse> createExecutionWindow​(CreateExecutionWindowRequest request,
                                                                    AsyncHandler<CreateExecutionWindowRequest,​CreateExecutionWindowResponse> handler)
        Creates an execution window 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.
      • createExternalBackupJob

        Future<CreateExternalBackupJobResponse> createExternalBackupJob​(CreateExternalBackupJobRequest request,
                                                                        AsyncHandler<CreateExternalBackupJobRequest,​CreateExternalBackupJobResponse> handler)
        Creates a new backup resource and returns the information the caller needs to back up an on-premises Oracle Database to Oracle Cloud Infrastructure.

        *Note:** This API is used by an Oracle Cloud Infrastructure Python script that is packaged with the Oracle Cloud Infrastructure CLI. Oracle recommends that you use the script instead using the API directly. See [Migrating an On-Premises Database to Oracle Cloud Infrastructure by Creating a Backup in the Cloud](https://docs.oracle.com/iaas/Content/Database/Tasks/mig-onprembackup.htm) for more information.

        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.
      • createKeyStore

        Future<CreateKeyStoreResponse> createKeyStore​(CreateKeyStoreRequest request,
                                                      AsyncHandler<CreateKeyStoreRequest,​CreateKeyStoreResponse> handler)
        Creates a Key Store.
        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.
      • createMaintenanceRun

        Future<CreateMaintenanceRunResponse> createMaintenanceRun​(CreateMaintenanceRunRequest request,
                                                                  AsyncHandler<CreateMaintenanceRunRequest,​CreateMaintenanceRunResponse> handler)
        Creates a maintenance run with one of the following: 1.

        The latest available release update patch (RUP) for the Autonomous Container Database. 2. The latest available RUP and DST time-zone (TZ) file updates for the Autonomous Container Database. 3. The DST TZ file updates for the Autonomous Container 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.
      • createOneoffPatch

        Future<CreateOneoffPatchResponse> createOneoffPatch​(CreateOneoffPatchRequest request,
                                                            AsyncHandler<CreateOneoffPatchRequest,​CreateOneoffPatchResponse> handler)
        Creates one-off patch for specified database version to download.
        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.
      • createPluggableDatabase

        Future<CreatePluggableDatabaseResponse> createPluggableDatabase​(CreatePluggableDatabaseRequest request,
                                                                        AsyncHandler<CreatePluggableDatabaseRequest,​CreatePluggableDatabaseResponse> handler)
        Creates and starts a pluggable database in the specified container database.

        Pluggable Database can be created using different operations (e.g. LocalClone, RemoteClone, Relocate ) with this API. Use the startPluggableDatabase and stopPluggableDatabase APIs to start and stop the pluggable 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.
      • createScheduledAction

        Future<CreateScheduledActionResponse> createScheduledAction​(CreateScheduledActionRequest request,
                                                                    AsyncHandler<CreateScheduledActionRequest,​CreateScheduledActionResponse> handler)
        Creates a Scheduled Action 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.
      • createSchedulingPlan

        Future<CreateSchedulingPlanResponse> createSchedulingPlan​(CreateSchedulingPlanRequest request,
                                                                  AsyncHandler<CreateSchedulingPlanRequest,​CreateSchedulingPlanResponse> handler)
        Creates a Scheduling Plan 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.
      • createSchedulingPolicy

        Future<CreateSchedulingPolicyResponse> createSchedulingPolicy​(CreateSchedulingPolicyRequest request,
                                                                      AsyncHandler<CreateSchedulingPolicyRequest,​CreateSchedulingPolicyResponse> handler)
        Creates a Scheduling Policy 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.
      • createSchedulingWindow

        Future<CreateSchedulingWindowResponse> createSchedulingWindow​(CreateSchedulingWindowRequest request,
                                                                      AsyncHandler<CreateSchedulingWindowRequest,​CreateSchedulingWindowResponse> handler)
        Creates a Scheduling Window 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.
      • createVmCluster

        Future<CreateVmClusterResponse> createVmCluster​(CreateVmClusterRequest request,
                                                        AsyncHandler<CreateVmClusterRequest,​CreateVmClusterResponse> handler)
        Creates an Exadata Cloud@Customer VM cluster.
        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.
      • createVmClusterNetwork

        Future<CreateVmClusterNetworkResponse> createVmClusterNetwork​(CreateVmClusterNetworkRequest request,
                                                                      AsyncHandler<CreateVmClusterNetworkRequest,​CreateVmClusterNetworkResponse> handler)
        Creates the VM cluster network.

        Applies to Exadata Cloud@Customer instances only. To create a cloud VM cluster in an Exadata Cloud Service instance, use the createCloudVmCluster operation.

        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.
      • dbNodeAction

        Future<DbNodeActionResponse> dbNodeAction​(DbNodeActionRequest request,
                                                  AsyncHandler<DbNodeActionRequest,​DbNodeActionResponse> handler)
        Performs one of the following power actions on the specified DB node: - start - power on - stop - power off - softreset - ACPI shutdown and power on - reset - power off and power on

        *Note:** Stopping a node affects billing differently, depending on the type of DB system: *Bare metal and Exadata systems* - The _stop_ state has no effect on the resources you consume. Billing continues for DB nodes that you stop, and related resources continue to apply against any relevant quotas. You must terminate the DB system (terminateDbSystem) to remove its resources from billing and quotas. *Virtual machine DB systems* - Stopping a node stops billing for all OCPUs associated with that node, and billing resumes when you restart the node.

        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.
      • deleteApplicationVip

        Future<DeleteApplicationVipResponse> deleteApplicationVip​(DeleteApplicationVipRequest request,
                                                                  AsyncHandler<DeleteApplicationVipRequest,​DeleteApplicationVipResponse> handler)
        Deletes and deregisters the specified application virtual IP (VIP) address.
        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.
      • deleteAutonomousVmCluster

        Future<DeleteAutonomousVmClusterResponse> deleteAutonomousVmCluster​(DeleteAutonomousVmClusterRequest request,
                                                                            AsyncHandler<DeleteAutonomousVmClusterRequest,​DeleteAutonomousVmClusterResponse> handler)
        Deletes the specified Autonomous VM cluster in an Exadata Cloud@Customer system.

        To delete an Autonomous VM Cluster in the Oracle cloud, see deleteCloudAutonomousVmCluster.

        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.
      • deleteBackup

        Future<DeleteBackupResponse> deleteBackup​(DeleteBackupRequest request,
                                                  AsyncHandler<DeleteBackupRequest,​DeleteBackupResponse> handler)
        Deletes a full backup.

        You cannot delete automatic backups using 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.
      • deleteBackupDestination

        Future<DeleteBackupDestinationResponse> deleteBackupDestination​(DeleteBackupDestinationRequest request,
                                                                        AsyncHandler<DeleteBackupDestinationRequest,​DeleteBackupDestinationResponse> handler)
        Deletes a backup destination in an Exadata Cloud@Customer 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.
      • deleteCloudVmCluster

        Future<DeleteCloudVmClusterResponse> deleteCloudVmCluster​(DeleteCloudVmClusterRequest request,
                                                                  AsyncHandler<DeleteCloudVmClusterRequest,​DeleteCloudVmClusterResponse> handler)
        Deletes the specified cloud VM cluster.

        Applies to Exadata Cloud Service instances and Autonomous Database on dedicated Exadata infrastructure only.

        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.
      • deleteConsoleConnection

        Future<DeleteConsoleConnectionResponse> deleteConsoleConnection​(DeleteConsoleConnectionRequest request,
                                                                        AsyncHandler<DeleteConsoleConnectionRequest,​DeleteConsoleConnectionResponse> handler)
        Deletes the specified database node console connection.
        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.
      • deleteConsoleHistory

        Future<DeleteConsoleHistoryResponse> deleteConsoleHistory​(DeleteConsoleHistoryRequest request,
                                                                  AsyncHandler<DeleteConsoleHistoryRequest,​DeleteConsoleHistoryResponse> handler)
        Deletes the specified database node console history.
        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.
      • deleteDatabase

        Future<DeleteDatabaseResponse> deleteDatabase​(DeleteDatabaseRequest request,
                                                      AsyncHandler<DeleteDatabaseRequest,​DeleteDatabaseResponse> handler)
        Deletes the specified database.

        Applies only to Exadata systems.

        The data in this database is local to the Exadata system and will be lost when the database is deleted. Oracle recommends that you back up any data in the Exadata system prior to deleting it. You can use the `performFinalBackup` parameter to have the Exadata system database backed up before it is 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.
      • deleteDbHome

        Future<DeleteDbHomeResponse> deleteDbHome​(DeleteDbHomeRequest request,
                                                  AsyncHandler<DeleteDbHomeRequest,​DeleteDbHomeResponse> handler)
        Deletes a Database Home.

        Applies to bare metal DB systems, Exadata Cloud Service, and Exadata Cloud@Customer systems.

        Oracle recommends that you use the `performFinalBackup` parameter to back up any data on a bare metal DB system before you delete a Database Home. On an Exadata Cloud@Customer system or an Exadata Cloud Service system, you can delete a Database Home only when there are no databases in it and therefore you cannot use the `performFinalBackup` parameter to back up data.

        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.
      • deleteExadbVmCluster

        Future<DeleteExadbVmClusterResponse> deleteExadbVmCluster​(DeleteExadbVmClusterRequest request,
                                                                  AsyncHandler<DeleteExadbVmClusterRequest,​DeleteExadbVmClusterResponse> handler)
        Deletes the specified Exadata VM cluster on Exascale Infrastructure.

        Applies to Exadata Database Service on Exascale Infrastructure only.

        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.
      • deleteExecutionAction

        Future<DeleteExecutionActionResponse> deleteExecutionAction​(DeleteExecutionActionRequest request,
                                                                    AsyncHandler<DeleteExecutionActionRequest,​DeleteExecutionActionResponse> handler)
        Deletes the execution action.
        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.
      • deleteExecutionWindow

        Future<DeleteExecutionWindowResponse> deleteExecutionWindow​(DeleteExecutionWindowRequest request,
                                                                    AsyncHandler<DeleteExecutionWindowRequest,​DeleteExecutionWindowResponse> handler)
        Deletes the execution window.
        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.
      • deleteExternalContainerDatabase

        Future<DeleteExternalContainerDatabaseResponse> deleteExternalContainerDatabase​(DeleteExternalContainerDatabaseRequest request,
                                                                                        AsyncHandler<DeleteExternalContainerDatabaseRequest,​DeleteExternalContainerDatabaseResponse> handler)
        Deletes the createExternalContainerDatabaseDetails resource.

        Any external pluggable databases registered under this container database must be deleted in your Oracle Cloud Infrastructure tenancy prior to this operation.

        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.
      • deleteKeyStore

        Future<DeleteKeyStoreResponse> deleteKeyStore​(DeleteKeyStoreRequest request,
                                                      AsyncHandler<DeleteKeyStoreRequest,​DeleteKeyStoreResponse> handler)
        Deletes a key store.
        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.
      • deleteOneoffPatch

        Future<DeleteOneoffPatchResponse> deleteOneoffPatch​(DeleteOneoffPatchRequest request,
                                                            AsyncHandler<DeleteOneoffPatchRequest,​DeleteOneoffPatchResponse> handler)
        Deletes a one-off patch.
        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.
      • deleteScheduledAction

        Future<DeleteScheduledActionResponse> deleteScheduledAction​(DeleteScheduledActionRequest request,
                                                                    AsyncHandler<DeleteScheduledActionRequest,​DeleteScheduledActionResponse> handler)
        Deletes the scheduled action.
        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.
      • deleteSchedulingPlan

        Future<DeleteSchedulingPlanResponse> deleteSchedulingPlan​(DeleteSchedulingPlanRequest request,
                                                                  AsyncHandler<DeleteSchedulingPlanRequest,​DeleteSchedulingPlanResponse> handler)
        Deletes the scheduling plan.
        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.
      • deleteSchedulingPolicy

        Future<DeleteSchedulingPolicyResponse> deleteSchedulingPolicy​(DeleteSchedulingPolicyRequest request,
                                                                      AsyncHandler<DeleteSchedulingPolicyRequest,​DeleteSchedulingPolicyResponse> handler)
        Deletes the scheduling policy.
        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.
      • deleteSchedulingWindow

        Future<DeleteSchedulingWindowResponse> deleteSchedulingWindow​(DeleteSchedulingWindowRequest request,
                                                                      AsyncHandler<DeleteSchedulingWindowRequest,​DeleteSchedulingWindowResponse> handler)
        Deletes the scheduling window.
        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.
      • deleteVmCluster

        Future<DeleteVmClusterResponse> deleteVmCluster​(DeleteVmClusterRequest request,
                                                        AsyncHandler<DeleteVmClusterRequest,​DeleteVmClusterResponse> handler)
        Deletes the specified VM cluster.

        Applies to Exadata Cloud@Customer instances only.

        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.
      • deleteVmClusterNetwork

        Future<DeleteVmClusterNetworkResponse> deleteVmClusterNetwork​(DeleteVmClusterNetworkRequest request,
                                                                      AsyncHandler<DeleteVmClusterNetworkRequest,​DeleteVmClusterNetworkResponse> handler)
        Deletes the specified VM cluster network.

        Applies to Exadata Cloud@Customer instances only. To delete a cloud VM cluster in an Exadata Cloud Service instance, use the deleteCloudVmCluster operation.

        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.
      • downloadOneoffPatch

        Future<DownloadOneoffPatchResponse> downloadOneoffPatch​(DownloadOneoffPatchRequest request,
                                                                AsyncHandler<DownloadOneoffPatchRequest,​DownloadOneoffPatchResponse> handler)
        Download one-off patch.
        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.
      • downloadValidationReport

        Future<DownloadValidationReportResponse> downloadValidationReport​(DownloadValidationReportRequest request,
                                                                          AsyncHandler<DownloadValidationReportRequest,​DownloadValidationReportResponse> handler)
        Downloads the network validation report file for the specified VM cluster network.

        Applies to Exadata Cloud@Customer instances only.

        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.
      • enableDatabaseManagement

        Future<EnableDatabaseManagementResponse> enableDatabaseManagement​(EnableDatabaseManagementRequest request,
                                                                          AsyncHandler<EnableDatabaseManagementRequest,​EnableDatabaseManagementResponse> handler)
        Enables the Database Management service for an Oracle Database located in Oracle Cloud Infrastructure.

        This service allows the database to access tools including Metrics and Performance hub. Database Management is enabled at the container database (CDB) level.

        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.
      • enablePluggableDatabaseManagement

        Future<EnablePluggableDatabaseManagementResponse> enablePluggableDatabaseManagement​(EnablePluggableDatabaseManagementRequest request,
                                                                                            AsyncHandler<EnablePluggableDatabaseManagementRequest,​EnablePluggableDatabaseManagementResponse> handler)
        Enables the Database Management service for an Oracle Pluggable Database located in Oracle Cloud Infrastructure.

        This service allows the pluggable database to access tools including Metrics and Performance hub. Database Management is enabled at the pluggable database (PDB) level.

        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.
      • failOverAutonomousDatabase

        Future<FailOverAutonomousDatabaseResponse> failOverAutonomousDatabase​(FailOverAutonomousDatabaseRequest request,
                                                                              AsyncHandler<FailOverAutonomousDatabaseRequest,​FailOverAutonomousDatabaseResponse> handler)
        Initiates a failover of the specified Autonomous Database to the associated peer database.

        Applicable only to databases with Disaster Recovery enabled. This API should be called in the remote region where the peer database resides. Below parameter is optional: - peerDbId Use this parameter to specify the database OCID of the Disaster Recovery peer, which is located in a different (remote) region from the current peer database. If this parameter is not provided, the failover will happen in the same region.

        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.
      • failoverDataGuard

        Future<FailoverDataGuardResponse> failoverDataGuard​(FailoverDataGuardRequest request,
                                                            AsyncHandler<FailoverDataGuardRequest,​FailoverDataGuardResponse> handler)
        Performs a failover to transition the standby database identified by the databaseId path parameter into the primary role after the existing primary database fails or becomes unreachable.

        A failover might result in data loss depending on the protection mode in effect at the time of the primary database failure.

        This operation should be performed on respective standby 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.
      • failoverDataGuardAssociation

        Future<FailoverDataGuardAssociationResponse> failoverDataGuardAssociation​(FailoverDataGuardAssociationRequest request,
                                                                                  AsyncHandler<FailoverDataGuardAssociationRequest,​FailoverDataGuardAssociationResponse> handler)
        Performs a failover to transition the standby database identified by the databaseId parameter into the specified Data Guard association’s primary role after the existing primary database fails or becomes unreachable.

        A failover might result in data loss depending on the protection mode in effect at the time of the primary database failure.

        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.
      • getApplicationVip

        Future<GetApplicationVipResponse> getApplicationVip​(GetApplicationVipRequest request,
                                                            AsyncHandler<GetApplicationVipRequest,​GetApplicationVipResponse> handler)
        Gets information about a specified application virtual IP (VIP) address.
        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.
      • getAutonomousDatabase

        Future<GetAutonomousDatabaseResponse> getAutonomousDatabase​(GetAutonomousDatabaseRequest request,
                                                                    AsyncHandler<GetAutonomousDatabaseRequest,​GetAutonomousDatabaseResponse> handler)
        Gets the details of the specified Autonomous 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.
      • getAutonomousExadataInfrastructure

        Future<GetAutonomousExadataInfrastructureResponse> getAutonomousExadataInfrastructure​(GetAutonomousExadataInfrastructureRequest request,
                                                                                              AsyncHandler<GetAutonomousExadataInfrastructureRequest,​GetAutonomousExadataInfrastructureResponse> handler)
        Deprecated. Use the getCloudExadataInfrastructure operation to get details of an Exadata Infrastructure resource and the getCloudAutonomousVmCluster operation to get details of an Autonomous Exadata VM cluster.
        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.
      • getAutonomousPatch

        Future<GetAutonomousPatchResponse> getAutonomousPatch​(GetAutonomousPatchRequest request,
                                                              AsyncHandler<GetAutonomousPatchRequest,​GetAutonomousPatchResponse> handler)
        Gets information about a specific autonomous patch.
        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.
      • getAutonomousVmCluster

        Future<GetAutonomousVmClusterResponse> getAutonomousVmCluster​(GetAutonomousVmClusterRequest request,
                                                                      AsyncHandler<GetAutonomousVmClusterRequest,​GetAutonomousVmClusterResponse> handler)
        Gets information about the specified Autonomous VM cluster for an Exadata Cloud@Customer system.

        To get information about an Autonomous VM Cluster in the Oracle cloud, see getCloudAutonomousVmCluster.

        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.
      • getBackup

        Future<GetBackupResponse> getBackup​(GetBackupRequest request,
                                            AsyncHandler<GetBackupRequest,​GetBackupResponse> handler)
        Gets information about the specified backup.
        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.
      • getBackupDestination

        Future<GetBackupDestinationResponse> getBackupDestination​(GetBackupDestinationRequest request,
                                                                  AsyncHandler<GetBackupDestinationRequest,​GetBackupDestinationResponse> handler)
        Gets information about the specified backup destination in an Exadata Cloud@Customer 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.
      • getCloudAutonomousVmCluster

        Future<GetCloudAutonomousVmClusterResponse> getCloudAutonomousVmCluster​(GetCloudAutonomousVmClusterRequest request,
                                                                                AsyncHandler<GetCloudAutonomousVmClusterRequest,​GetCloudAutonomousVmClusterResponse> handler)
        Gets information about the specified Autonomous Exadata VM cluster in the Oracle cloud.

        For Exadata Cloud@Custustomer systems, see getAutonomousVmCluster.

        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.
      • getCloudExadataInfrastructure

        Future<GetCloudExadataInfrastructureResponse> getCloudExadataInfrastructure​(GetCloudExadataInfrastructureRequest request,
                                                                                    AsyncHandler<GetCloudExadataInfrastructureRequest,​GetCloudExadataInfrastructureResponse> handler)
        Gets information about the specified cloud Exadata infrastructure resource.

        Applies to Exadata Cloud Service instances and Autonomous Database on dedicated Exadata infrastructure only.

        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.
      • getCloudVmCluster

        Future<GetCloudVmClusterResponse> getCloudVmCluster​(GetCloudVmClusterRequest request,
                                                            AsyncHandler<GetCloudVmClusterRequest,​GetCloudVmClusterResponse> handler)
        Gets information about the specified cloud VM cluster.

        Applies to Exadata Cloud Service instances and Autonomous Database on dedicated Exadata infrastructure only.

        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.
      • getCloudVmClusterIormConfig

        Future<GetCloudVmClusterIormConfigResponse> getCloudVmClusterIormConfig​(GetCloudVmClusterIormConfigRequest request,
                                                                                AsyncHandler<GetCloudVmClusterIormConfigRequest,​GetCloudVmClusterIormConfigResponse> handler)
        Gets the IORM configuration for the specified cloud VM cluster in an Exadata Cloud Service instance.

        If you have not specified an IORM configuration, the default configuration is 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.
      • getCloudVmClusterUpdate

        Future<GetCloudVmClusterUpdateResponse> getCloudVmClusterUpdate​(GetCloudVmClusterUpdateRequest request,
                                                                        AsyncHandler<GetCloudVmClusterUpdateRequest,​GetCloudVmClusterUpdateResponse> handler)
        Gets information about a specified maintenance update package for a cloud VM cluster.

        Applies to Exadata Cloud Service instances only.

        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.
      • getConsoleConnection

        Future<GetConsoleConnectionResponse> getConsoleConnection​(GetConsoleConnectionRequest request,
                                                                  AsyncHandler<GetConsoleConnectionRequest,​GetConsoleConnectionResponse> handler)
        Gets the specified database node console connection’s information.
        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.
      • getConsoleHistory

        Future<GetConsoleHistoryResponse> getConsoleHistory​(GetConsoleHistoryRequest request,
                                                            AsyncHandler<GetConsoleHistoryRequest,​GetConsoleHistoryResponse> handler)
        Gets information about the specified database node console history.
        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.
      • getConsoleHistoryContent

        Future<GetConsoleHistoryContentResponse> getConsoleHistoryContent​(GetConsoleHistoryContentRequest request,
                                                                          AsyncHandler<GetConsoleHistoryContentRequest,​GetConsoleHistoryContentResponse> handler)
        Retrieves the specified database node console history contents upto a megabyte.
        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.
      • getDataGuardAssociation

        Future<GetDataGuardAssociationResponse> getDataGuardAssociation​(GetDataGuardAssociationRequest request,
                                                                        AsyncHandler<GetDataGuardAssociationRequest,​GetDataGuardAssociationResponse> handler)
        Gets the specified Data Guard association’s configuration information.
        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.
      • getDatabase

        Future<GetDatabaseResponse> getDatabase​(GetDatabaseRequest request,
                                                AsyncHandler<GetDatabaseRequest,​GetDatabaseResponse> handler)
        Gets information about 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.
      • getDatabaseSoftwareImage

        Future<GetDatabaseSoftwareImageResponse> getDatabaseSoftwareImage​(GetDatabaseSoftwareImageRequest request,
                                                                          AsyncHandler<GetDatabaseSoftwareImageRequest,​GetDatabaseSoftwareImageResponse> handler)
        Gets information about the specified database software image.
        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.
      • getDbHome

        Future<GetDbHomeResponse> getDbHome​(GetDbHomeRequest request,
                                            AsyncHandler<GetDbHomeRequest,​GetDbHomeResponse> handler)
        Gets information about the specified Database Home.
        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.
      • getDbHomePatch

        Future<GetDbHomePatchResponse> getDbHomePatch​(GetDbHomePatchRequest request,
                                                      AsyncHandler<GetDbHomePatchRequest,​GetDbHomePatchResponse> handler)
        Gets information about a specified patch package.
        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.
      • getDbNode

        Future<GetDbNodeResponse> getDbNode​(GetDbNodeRequest request,
                                            AsyncHandler<GetDbNodeRequest,​GetDbNodeResponse> handler)
        Gets information about the specified database node.
        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.
      • getDbServer

        Future<GetDbServerResponse> getDbServer​(GetDbServerRequest request,
                                                AsyncHandler<GetDbServerRequest,​GetDbServerResponse> handler)
        Gets information about the Exadata Db 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.
      • getDbSystem

        Future<GetDbSystemResponse> getDbSystem​(GetDbSystemRequest request,
                                                AsyncHandler<GetDbSystemRequest,​GetDbSystemResponse> handler)
        Gets information about the specified DB system.

        *Note:** Deprecated for Exadata Cloud Service systems. Use the [new resource model APIs](https://docs.oracle.com/iaas/Content/Database/Concepts/exaflexsystem.htm#exaflexsystem_topic-resource_model) instead.

        For Exadata Cloud Service instances, support for this API will end on May 15th, 2021. See [Switching an Exadata DB System to the New Resource Model and APIs](https://docs.oracle.com/iaas/Content/Database/Concepts/exaflexsystem_topic-resource_model_conversion.htm) for details on converting existing Exadata DB systems to the new resource model.

        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.
      • getDbSystemPatch

        Future<GetDbSystemPatchResponse> getDbSystemPatch​(GetDbSystemPatchRequest request,
                                                          AsyncHandler<GetDbSystemPatchRequest,​GetDbSystemPatchResponse> handler)
        Gets information the specified patch.
        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.
      • getExadataInfrastructure

        Future<GetExadataInfrastructureResponse> getExadataInfrastructure​(GetExadataInfrastructureRequest request,
                                                                          AsyncHandler<GetExadataInfrastructureRequest,​GetExadataInfrastructureResponse> handler)
        Gets information about the specified Exadata infrastructure.

        Applies to Exadata Cloud@Customer instances only. To get information on an Exadata Cloud Service infrastructure resource, use the getCloudExadataInfrastructure operation.

        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.
      • getExadataIormConfig

        Future<GetExadataIormConfigResponse> getExadataIormConfig​(GetExadataIormConfigRequest request,
                                                                  AsyncHandler<GetExadataIormConfigRequest,​GetExadataIormConfigResponse> handler)
        Gets the IORM configuration settings for the specified cloud Exadata DB system.

        All Exadata service instances have default IORM settings.

        *Note:** Deprecated for Exadata Cloud Service systems. Use the [new resource model APIs](https://docs.oracle.com/iaas/Content/Database/Concepts/exaflexsystem.htm#exaflexsystem_topic-resource_model) instead.

        For Exadata Cloud Service instances, support for this API will end on May 15th, 2021. See [Switching an Exadata DB System to the New Resource Model and APIs](https://docs.oracle.com/iaas/Content/Database/Concepts/exaflexsystem_topic-resource_model_conversion.htm) for details on converting existing Exadata DB systems to the new resource model.

        The getCloudVmClusterIormConfig API is used for this operation with Exadata systems using the new resource model.

        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.
      • getExadbVmCluster

        Future<GetExadbVmClusterResponse> getExadbVmCluster​(GetExadbVmClusterRequest request,
                                                            AsyncHandler<GetExadbVmClusterRequest,​GetExadbVmClusterResponse> handler)
        Gets information about the specified Exadata VM cluster on Exascale Infrastructure.

        Applies to Exadata Database Service on Exascale Infrastructure only.

        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.
      • getExadbVmClusterUpdate

        Future<GetExadbVmClusterUpdateResponse> getExadbVmClusterUpdate​(GetExadbVmClusterUpdateRequest request,
                                                                        AsyncHandler<GetExadbVmClusterUpdateRequest,​GetExadbVmClusterUpdateResponse> handler)
        Gets information about a specified maintenance update package for a Exadata VM cluster on Exascale 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.
      • getExascaleDbStorageVault

        Future<GetExascaleDbStorageVaultResponse> getExascaleDbStorageVault​(GetExascaleDbStorageVaultRequest request,
                                                                            AsyncHandler<GetExascaleDbStorageVaultRequest,​GetExascaleDbStorageVaultResponse> handler)
        Gets information about the specified Exadata Database Storage Vaults 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.
      • getExecutionAction

        Future<GetExecutionActionResponse> getExecutionAction​(GetExecutionActionRequest request,
                                                              AsyncHandler<GetExecutionActionRequest,​GetExecutionActionResponse> handler)
        Gets information about the specified execution action.
        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.
      • getExecutionWindow

        Future<GetExecutionWindowResponse> getExecutionWindow​(GetExecutionWindowRequest request,
                                                              AsyncHandler<GetExecutionWindowRequest,​GetExecutionWindowResponse> handler)
        Gets information about the specified execution window.
        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.
      • getExternalBackupJob

        Future<GetExternalBackupJobResponse> getExternalBackupJob​(GetExternalBackupJobRequest request,
                                                                  AsyncHandler<GetExternalBackupJobRequest,​GetExternalBackupJobResponse> handler)
        Gets information about the specified external backup job.

        *Note:** This API is used by an Oracle Cloud Infrastructure Python script that is packaged with the Oracle Cloud Infrastructure CLI. Oracle recommends that you use the script instead using the API directly. See [Migrating an On-Premises Database to Oracle Cloud Infrastructure by Creating a Backup in the Cloud](https://docs.oracle.com/iaas/Content/Database/Tasks/mig-onprembackup.htm) for more information.

        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.
      • getInfrastructureTargetVersions

        Future<GetInfrastructureTargetVersionsResponse> getInfrastructureTargetVersions​(GetInfrastructureTargetVersionsRequest request,
                                                                                        AsyncHandler<GetInfrastructureTargetVersionsRequest,​GetInfrastructureTargetVersionsResponse> handler)
        Gets details of the Exadata Infrastructure target system software versions that can be applied to the specified infrastructure resource for maintenance updates.

        Applies to Exadata Cloud@Customer and Exadata Cloud instances only.

        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.
      • getKeyStore

        Future<GetKeyStoreResponse> getKeyStore​(GetKeyStoreRequest request,
                                                AsyncHandler<GetKeyStoreRequest,​GetKeyStoreResponse> handler)
        Gets information about the specified key store.
        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.
      • getMaintenanceRun

        Future<GetMaintenanceRunResponse> getMaintenanceRun​(GetMaintenanceRunRequest request,
                                                            AsyncHandler<GetMaintenanceRunRequest,​GetMaintenanceRunResponse> handler)
        Gets information about the specified maintenance run.
        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.
      • getMaintenanceRunHistory

        Future<GetMaintenanceRunHistoryResponse> getMaintenanceRunHistory​(GetMaintenanceRunHistoryRequest request,
                                                                          AsyncHandler<GetMaintenanceRunHistoryRequest,​GetMaintenanceRunHistoryResponse> handler)
        Gets information about the specified maintenance run history.
        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.
      • getOneoffPatch

        Future<GetOneoffPatchResponse> getOneoffPatch​(GetOneoffPatchRequest request,
                                                      AsyncHandler<GetOneoffPatchRequest,​GetOneoffPatchResponse> handler)
        Gets information about the specified one-off patch.
        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.
      • getPdbConversionHistoryEntry

        Future<GetPdbConversionHistoryEntryResponse> getPdbConversionHistoryEntry​(GetPdbConversionHistoryEntryRequest request,
                                                                                  AsyncHandler<GetPdbConversionHistoryEntryRequest,​GetPdbConversionHistoryEntryResponse> handler)
        Gets the details of operations performed to convert the specified database from non-container (non-CDB) to pluggable (PDB).
        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.
      • getPluggableDatabase

        Future<GetPluggableDatabaseResponse> getPluggableDatabase​(GetPluggableDatabaseRequest request,
                                                                  AsyncHandler<GetPluggableDatabaseRequest,​GetPluggableDatabaseResponse> handler)
        Gets information about the specified pluggable 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.
      • getScheduledAction

        Future<GetScheduledActionResponse> getScheduledAction​(GetScheduledActionRequest request,
                                                              AsyncHandler<GetScheduledActionRequest,​GetScheduledActionResponse> handler)
        Gets information about the specified Scheduled Action.
        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.
      • getSchedulingPlan

        Future<GetSchedulingPlanResponse> getSchedulingPlan​(GetSchedulingPlanRequest request,
                                                            AsyncHandler<GetSchedulingPlanRequest,​GetSchedulingPlanResponse> handler)
        Gets information about the specified Scheduling Plan.
        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.
      • getSchedulingPolicy

        Future<GetSchedulingPolicyResponse> getSchedulingPolicy​(GetSchedulingPolicyRequest request,
                                                                AsyncHandler<GetSchedulingPolicyRequest,​GetSchedulingPolicyResponse> handler)
        Gets information about the specified Scheduling Policy.
        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.
      • getSchedulingWindow

        Future<GetSchedulingWindowResponse> getSchedulingWindow​(GetSchedulingWindowRequest request,
                                                                AsyncHandler<GetSchedulingWindowRequest,​GetSchedulingWindowResponse> handler)
        Gets information about the specified Scheduling Window.
        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.
      • getVmCluster

        Future<GetVmClusterResponse> getVmCluster​(GetVmClusterRequest request,
                                                  AsyncHandler<GetVmClusterRequest,​GetVmClusterResponse> handler)
        Gets information about the VM cluster.

        Applies to Exadata Cloud@Customer instances only.

        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.
      • getVmClusterNetwork

        Future<GetVmClusterNetworkResponse> getVmClusterNetwork​(GetVmClusterNetworkRequest request,
                                                                AsyncHandler<GetVmClusterNetworkRequest,​GetVmClusterNetworkResponse> handler)
        Gets information about the specified VM cluster network.

        Applies to Exadata Cloud@Customer instances only. To get information about a cloud VM cluster in an Exadata Cloud Service instance, use the getCloudVmCluster operation.

        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.
      • getVmClusterPatch

        Future<GetVmClusterPatchResponse> getVmClusterPatch​(GetVmClusterPatchRequest request,
                                                            AsyncHandler<GetVmClusterPatchRequest,​GetVmClusterPatchResponse> handler)
        Gets information about a specified patch package.
        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.
      • getVmClusterUpdate

        Future<GetVmClusterUpdateResponse> getVmClusterUpdate​(GetVmClusterUpdateRequest request,
                                                              AsyncHandler<GetVmClusterUpdateRequest,​GetVmClusterUpdateResponse> handler)
        Gets information about a specified maintenance update package for a VM cluster.

        Applies to Exadata Cloud@Customer instances only.

        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.
      • launchAutonomousExadataInfrastructure

        Future<LaunchAutonomousExadataInfrastructureResponse> launchAutonomousExadataInfrastructure​(LaunchAutonomousExadataInfrastructureRequest request,
                                                                                                    AsyncHandler<LaunchAutonomousExadataInfrastructureRequest,​LaunchAutonomousExadataInfrastructureResponse> handler)
        Deprecated To create a new Autonomous Database system on dedicated Exadata Infrastructure, use the createCloudExadataInfrastructure and createCloudAutonomousVmCluster operations instead.

        Note that to create an Autonomous VM cluster, you must have an existing Exadata Infrastructure resource to contain the VM cluster.

        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.
      • launchDbSystem

        Future<LaunchDbSystemResponse> launchDbSystem​(LaunchDbSystemRequest request,
                                                      AsyncHandler<LaunchDbSystemRequest,​LaunchDbSystemResponse> handler)
        Creates a new DB system in the specified compartment and availability domain.

        The Oracle Database edition that you specify applies to all the databases on that DB system. The selected edition cannot be changed.

        An initial database is created on the DB system based on the request parameters you provide and some default options. For detailed information about default options, see [Bare metal and virtual machine DB system default options.](https://docs.oracle.com/iaas/Content/Database/Tasks/creatingDBsystem.htm#Default)

        *Note:** Deprecated for Exadata Cloud Service systems. Use the [new resource model APIs](https://docs.oracle.com/iaas/Content/Database/Concepts/exaflexsystem.htm#exaflexsystem_topic-resource_model) instead.

        For Exadata Cloud Service instances, support for this API will end on May 15th, 2021. See [Switching an Exadata DB System to the New Resource Model and APIs](https://docs.oracle.com/iaas/Content/Database/Concepts/exaflexsystem_topic-resource_model_conversion.htm) for details on converting existing Exadata DB systems to the new resource model.

        Use the createCloudExadataInfrastructure and createCloudVmCluster APIs to provision a new Exadata Cloud Service 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.
      • listApplicationVips

        Future<ListApplicationVipsResponse> listApplicationVips​(ListApplicationVipsRequest request,
                                                                AsyncHandler<ListApplicationVipsRequest,​ListApplicationVipsResponse> handler)
        Gets a list of application virtual IP (VIP) addresses on a cloud VM cluster.
        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.
      • listAutonomousDatabaseBackups

        Future<ListAutonomousDatabaseBackupsResponse> listAutonomousDatabaseBackups​(ListAutonomousDatabaseBackupsRequest request,
                                                                                    AsyncHandler<ListAutonomousDatabaseBackupsRequest,​ListAutonomousDatabaseBackupsResponse> handler)
        Gets a list of Autonomous Database backups based on either the autonomousDatabaseId or compartmentId specified as a query parameter.
        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.
      • listAutonomousDatabases

        Future<ListAutonomousDatabasesResponse> listAutonomousDatabases​(ListAutonomousDatabasesRequest request,
                                                                        AsyncHandler<ListAutonomousDatabasesRequest,​ListAutonomousDatabasesResponse> handler)
        Gets a list of Autonomous Databases based on the query parameters specified.
        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.
      • listAutonomousDbPreviewVersions

        Future<ListAutonomousDbPreviewVersionsResponse> listAutonomousDbPreviewVersions​(ListAutonomousDbPreviewVersionsRequest request,
                                                                                        AsyncHandler<ListAutonomousDbPreviewVersionsRequest,​ListAutonomousDbPreviewVersionsResponse> handler)
        Gets a list of supported Autonomous Database versions.

        Note that preview version software is only available for Autonomous Database Serverless (https://docs.oracle.com/en/cloud/paas/autonomous-database/index.html) databases.

        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.
      • listAutonomousVmClusters

        Future<ListAutonomousVmClustersResponse> listAutonomousVmClusters​(ListAutonomousVmClustersRequest request,
                                                                          AsyncHandler<ListAutonomousVmClustersRequest,​ListAutonomousVmClustersResponse> handler)
        Gets a list of Exadata Cloud@Customer Autonomous VM clusters in the specified compartment.

        To list Autonomous VM Clusters in the Oracle Cloud, see listCloudAutonomousVmClusters.

        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.
      • listBackupDestination

        Future<ListBackupDestinationResponse> listBackupDestination​(ListBackupDestinationRequest request,
                                                                    AsyncHandler<ListBackupDestinationRequest,​ListBackupDestinationResponse> handler)
        Gets a list of backup destinations 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.
      • listBackups

        Future<ListBackupsResponse> listBackups​(ListBackupsRequest request,
                                                AsyncHandler<ListBackupsRequest,​ListBackupsResponse> handler)
        Gets a list of backups based on the databaseId or compartmentId specified.

        Either one of these query parameters must 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.
      • listCloudExadataInfrastructures

        Future<ListCloudExadataInfrastructuresResponse> listCloudExadataInfrastructures​(ListCloudExadataInfrastructuresRequest request,
                                                                                        AsyncHandler<ListCloudExadataInfrastructuresRequest,​ListCloudExadataInfrastructuresResponse> handler)
        Gets a list of the cloud Exadata infrastructure resources in the specified compartment.

        Applies to Exadata Cloud Service instances and Autonomous Database on dedicated Exadata infrastructure only.

        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.
      • listCloudVmClusterUpdates

        Future<ListCloudVmClusterUpdatesResponse> listCloudVmClusterUpdates​(ListCloudVmClusterUpdatesRequest request,
                                                                            AsyncHandler<ListCloudVmClusterUpdatesRequest,​ListCloudVmClusterUpdatesResponse> handler)
        Lists the maintenance updates that can be applied to the specified cloud VM cluster.

        Applies to Exadata Cloud Service instances only.

        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.
      • listCloudVmClusters

        Future<ListCloudVmClustersResponse> listCloudVmClusters​(ListCloudVmClustersRequest request,
                                                                AsyncHandler<ListCloudVmClustersRequest,​ListCloudVmClustersResponse> handler)
        Gets a list of the cloud VM clusters in the specified compartment.

        Applies to Exadata Cloud Service instances and Autonomous Database on dedicated Exadata infrastructure only.

        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.
      • listConsoleConnections

        Future<ListConsoleConnectionsResponse> listConsoleConnections​(ListConsoleConnectionsRequest request,
                                                                      AsyncHandler<ListConsoleConnectionsRequest,​ListConsoleConnectionsResponse> handler)
        Lists the console connections for the specified database node.
        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.
      • listConsoleHistories

        Future<ListConsoleHistoriesResponse> listConsoleHistories​(ListConsoleHistoriesRequest request,
                                                                  AsyncHandler<ListConsoleHistoriesRequest,​ListConsoleHistoriesResponse> handler)
        Lists the console histories for the specified database node.
        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.
      • listDatabases

        Future<ListDatabasesResponse> listDatabases​(ListDatabasesRequest request,
                                                    AsyncHandler<ListDatabasesRequest,​ListDatabasesResponse> handler)
        Gets a list of the databases in the specified Database Home.
        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.
      • listDbHomePatches

        Future<ListDbHomePatchesResponse> listDbHomePatches​(ListDbHomePatchesRequest request,
                                                            AsyncHandler<ListDbHomePatchesRequest,​ListDbHomePatchesResponse> handler)
        Lists patches applicable to the requested Database Home.
        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.
      • listDbHomes

        Future<ListDbHomesResponse> listDbHomes​(ListDbHomesRequest request,
                                                AsyncHandler<ListDbHomesRequest,​ListDbHomesResponse> handler)
        Lists the Database Homes in the specified DB system and compartment.

        A Database Home is a directory where Oracle Database software is installed.

        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.
      • listDbNodes

        Future<ListDbNodesResponse> listDbNodes​(ListDbNodesRequest request,
                                                AsyncHandler<ListDbNodesRequest,​ListDbNodesResponse> handler)
        Lists the database nodes in the specified DB system and compartment.

        A database node is a server running database software.

        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.
      • listDbServers

        Future<ListDbServersResponse> listDbServers​(ListDbServersRequest request,
                                                    AsyncHandler<ListDbServersRequest,​ListDbServersResponse> handler)
        Lists the Exadata DB servers in the ExadataInfrastructureId and 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.
      • listDbSystemPatches

        Future<ListDbSystemPatchesResponse> listDbSystemPatches​(ListDbSystemPatchesRequest request,
                                                                AsyncHandler<ListDbSystemPatchesRequest,​ListDbSystemPatchesResponse> handler)
        Lists the patches applicable to 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.
      • listDbSystemShapes

        Future<ListDbSystemShapesResponse> listDbSystemShapes​(ListDbSystemShapesRequest request,
                                                              AsyncHandler<ListDbSystemShapesRequest,​ListDbSystemShapesResponse> handler)
        Gets a list of the shapes that can be used to launch a new DB system.

        The shape determines resources to allocate to the DB system - CPU cores and memory for VM shapes; CPU cores, memory and storage for non-VM (or bare metal) shapes.

        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.
      • listDbSystems

        Future<ListDbSystemsResponse> listDbSystems​(ListDbSystemsRequest request,
                                                    AsyncHandler<ListDbSystemsRequest,​ListDbSystemsResponse> handler)
        Lists the DB systems in the specified compartment.

        You can specify a backupId to list only the DB systems that support creating a database using this backup in this compartment.

        *Note:** Deprecated for Exadata Cloud Service systems. Use the [new resource model APIs](https://docs.oracle.com/iaas/Content/Database/Concepts/exaflexsystem.htm#exaflexsystem_topic-resource_model) instead.

        For Exadata Cloud Service instances, support for this API will end on May 15th, 2021. See [Switching an Exadata DB System to the New Resource Model and APIs](https://docs.oracle.com/iaas/Content/Database/Concepts/exaflexsystem_topic-resource_model_conversion.htm) for details on converting existing Exadata DB systems to the new resource model.

        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.
      • listDbVersions

        Future<ListDbVersionsResponse> listDbVersions​(ListDbVersionsRequest request,
                                                      AsyncHandler<ListDbVersionsRequest,​ListDbVersionsResponse> handler)
        Gets a list of supported Oracle Database versions.
        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.
      • listExadataInfrastructures

        Future<ListExadataInfrastructuresResponse> listExadataInfrastructures​(ListExadataInfrastructuresRequest request,
                                                                              AsyncHandler<ListExadataInfrastructuresRequest,​ListExadataInfrastructuresResponse> handler)
        Lists the Exadata infrastructure resources in the specified compartment.

        Applies to Exadata Cloud@Customer instances only. To list the Exadata Cloud Service infrastructure resources in a compartment, use the listCloudExadataInfrastructures operation.

        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.
      • listExadbVmClusterUpdates

        Future<ListExadbVmClusterUpdatesResponse> listExadbVmClusterUpdates​(ListExadbVmClusterUpdatesRequest request,
                                                                            AsyncHandler<ListExadbVmClusterUpdatesRequest,​ListExadbVmClusterUpdatesResponse> handler)
        Lists the maintenance updates that can be applied to the specified Exadata VM cluster on Exascale 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.
      • listExadbVmClusters

        Future<ListExadbVmClustersResponse> listExadbVmClusters​(ListExadbVmClustersRequest request,
                                                                AsyncHandler<ListExadbVmClustersRequest,​ListExadbVmClustersResponse> handler)
        Gets a list of the Exadata VM clusters on Exascale Infrastructure in the specified compartment.

        Applies to Exadata Database Service on Exascale Infrastructure only.

        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.
      • listExecutionActions

        Future<ListExecutionActionsResponse> listExecutionActions​(ListExecutionActionsRequest request,
                                                                  AsyncHandler<ListExecutionActionsRequest,​ListExecutionActionsResponse> handler)
        Lists the execution action resources 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.
      • listExecutionWindows

        Future<ListExecutionWindowsResponse> listExecutionWindows​(ListExecutionWindowsRequest request,
                                                                  AsyncHandler<ListExecutionWindowsRequest,​ListExecutionWindowsResponse> handler)
        Lists the execution window resources 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.
      • listFlexComponents

        Future<ListFlexComponentsResponse> listFlexComponents​(ListFlexComponentsRequest request,
                                                              AsyncHandler<ListFlexComponentsRequest,​ListFlexComponentsResponse> handler)
        Gets a list of the flex components that can be used to launch a new DB system.

        The flex component determines resources to allocate to the DB system - Database Servers and Storage Servers.

        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.
      • listGiVersionMinorVersions

        Future<ListGiVersionMinorVersionsResponse> listGiVersionMinorVersions​(ListGiVersionMinorVersionsRequest request,
                                                                              AsyncHandler<ListGiVersionMinorVersionsRequest,​ListGiVersionMinorVersionsResponse> handler)
        Gets a list of supported Oracle Grid Infrastructure minor versions for the given major version and shape family.
        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.
      • listGiVersions

        Future<ListGiVersionsResponse> listGiVersions​(ListGiVersionsRequest request,
                                                      AsyncHandler<ListGiVersionsRequest,​ListGiVersionsResponse> handler)
        Gets a list of supported GI versions.
        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.
      • listKeyStores

        Future<ListKeyStoresResponse> listKeyStores​(ListKeyStoresRequest request,
                                                    AsyncHandler<ListKeyStoresRequest,​ListKeyStoresResponse> handler)
        Gets a list of key stores 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.
      • listMaintenanceRunHistory

        Future<ListMaintenanceRunHistoryResponse> listMaintenanceRunHistory​(ListMaintenanceRunHistoryRequest request,
                                                                            AsyncHandler<ListMaintenanceRunHistoryRequest,​ListMaintenanceRunHistoryResponse> handler)
        Gets a list of the maintenance run histories 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.
      • listMaintenanceRuns

        Future<ListMaintenanceRunsResponse> listMaintenanceRuns​(ListMaintenanceRunsRequest request,
                                                                AsyncHandler<ListMaintenanceRunsRequest,​ListMaintenanceRunsResponse> handler)
        Gets a list of the maintenance runs 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.
      • listOneoffPatches

        Future<ListOneoffPatchesResponse> listOneoffPatches​(ListOneoffPatchesRequest request,
                                                            AsyncHandler<ListOneoffPatchesRequest,​ListOneoffPatchesResponse> handler)
        Lists one-off patches 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.
      • listParamsForActionType

        Future<ListParamsForActionTypeResponse> listParamsForActionType​(ListParamsForActionTypeRequest request,
                                                                        AsyncHandler<ListParamsForActionTypeRequest,​ListParamsForActionTypeResponse> handler)
        List all the action params and their possible values for a given action type
        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.
      • listPluggableDatabases

        Future<ListPluggableDatabasesResponse> listPluggableDatabases​(ListPluggableDatabasesRequest request,
                                                                      AsyncHandler<ListPluggableDatabasesRequest,​ListPluggableDatabasesResponse> handler)
        Gets a list of the pluggable databases in a database or compartment.

        You must provide either a databaseId or compartmentId value.

        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.
      • listScheduledActions

        Future<ListScheduledActionsResponse> listScheduledActions​(ListScheduledActionsRequest request,
                                                                  AsyncHandler<ListScheduledActionsRequest,​ListScheduledActionsResponse> handler)
        Lists the Scheduled Action resources 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.
      • listSchedulingPlans

        Future<ListSchedulingPlansResponse> listSchedulingPlans​(ListSchedulingPlansRequest request,
                                                                AsyncHandler<ListSchedulingPlansRequest,​ListSchedulingPlansResponse> handler)
        Lists the Scheduling Plan resources 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.
      • listSchedulingPolicies

        Future<ListSchedulingPoliciesResponse> listSchedulingPolicies​(ListSchedulingPoliciesRequest request,
                                                                      AsyncHandler<ListSchedulingPoliciesRequest,​ListSchedulingPoliciesResponse> handler)
        Lists the Scheduling Policy resources 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.
      • listSchedulingWindows

        Future<ListSchedulingWindowsResponse> listSchedulingWindows​(ListSchedulingWindowsRequest request,
                                                                    AsyncHandler<ListSchedulingWindowsRequest,​ListSchedulingWindowsResponse> handler)
        Lists the Scheduling Window resources 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.
      • listSystemVersions

        Future<ListSystemVersionsResponse> listSystemVersions​(ListSystemVersionsRequest request,
                                                              AsyncHandler<ListSystemVersionsRequest,​ListSystemVersionsResponse> handler)
        Gets a list of supported Exadata system versions for a given shape and GI version.
        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.
      • listVmClusterNetworks

        Future<ListVmClusterNetworksResponse> listVmClusterNetworks​(ListVmClusterNetworksRequest request,
                                                                    AsyncHandler<ListVmClusterNetworksRequest,​ListVmClusterNetworksResponse> handler)
        Gets a list of the VM cluster networks in the specified compartment.

        Applies to Exadata Cloud@Customer instances only.

        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.
      • listVmClusterPatches

        Future<ListVmClusterPatchesResponse> listVmClusterPatches​(ListVmClusterPatchesRequest request,
                                                                  AsyncHandler<ListVmClusterPatchesRequest,​ListVmClusterPatchesResponse> handler)
        Lists the patches applicable to the specified VM cluster in an Exadata Cloud@Customer 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.
      • listVmClusterUpdates

        Future<ListVmClusterUpdatesResponse> listVmClusterUpdates​(ListVmClusterUpdatesRequest request,
                                                                  AsyncHandler<ListVmClusterUpdatesRequest,​ListVmClusterUpdatesResponse> handler)
        Lists the maintenance updates that can be applied to the specified VM cluster.

        Applies to Exadata Cloud@Customer instances only.

        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.
      • listVmClusters

        Future<ListVmClustersResponse> listVmClusters​(ListVmClustersRequest request,
                                                      AsyncHandler<ListVmClustersRequest,​ListVmClustersResponse> handler)
        Lists the VM clusters in the specified compartment.

        Applies to Exadata Cloud@Customer instances only. To list the cloud VM clusters in an Exadata Cloud Service instance, use the listCloudVmClusters operation.

        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.
      • localClonePluggableDatabase

        Future<LocalClonePluggableDatabaseResponse> localClonePluggableDatabase​(LocalClonePluggableDatabaseRequest request,
                                                                                AsyncHandler<LocalClonePluggableDatabaseRequest,​LocalClonePluggableDatabaseResponse> handler)
        Deprecated. Use createPluggableDatabase for Pluggable Database LocalClone Operation.

        Clones and starts a pluggable database (PDB) in the same database (CDB) as the source PDB. The source PDB must be in the READ_WRITE openMode to perform the clone operation.

        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.
      • migrateVaultKey

        Future<MigrateVaultKeyResponse> migrateVaultKey​(MigrateVaultKeyRequest request,
                                                        AsyncHandler<MigrateVaultKeyRequest,​MigrateVaultKeyResponse> handler)
        Changes encryption key management from customer-managed, using the Vault service, to Oracle-managed.
        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.
      • modifyDatabaseManagement

        Future<ModifyDatabaseManagementResponse> modifyDatabaseManagement​(ModifyDatabaseManagementRequest request,
                                                                          AsyncHandler<ModifyDatabaseManagementRequest,​ModifyDatabaseManagementResponse> handler)
        Updates one or more attributes of the Database Management service for the 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.
      • moveExecutionActionMember

        Future<MoveExecutionActionMemberResponse> moveExecutionActionMember​(MoveExecutionActionMemberRequest request,
                                                                            AsyncHandler<MoveExecutionActionMemberRequest,​MoveExecutionActionMemberResponse> handler)
        Moves an execution action member to this execution action resource from another.
        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.
      • reinstateDataGuard

        Future<ReinstateDataGuardResponse> reinstateDataGuard​(ReinstateDataGuardRequest request,
                                                              AsyncHandler<ReinstateDataGuardRequest,​ReinstateDataGuardResponse> handler)
        Reinstates the database identified by the databaseId parameter into the standby role in a Data Guard association.

        This operation should be performed on disabled standby 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.
      • remoteClonePluggableDatabase

        Future<RemoteClonePluggableDatabaseResponse> remoteClonePluggableDatabase​(RemoteClonePluggableDatabaseRequest request,
                                                                                  AsyncHandler<RemoteClonePluggableDatabaseRequest,​RemoteClonePluggableDatabaseResponse> handler)
        Deprecated. Use createPluggableDatabase for Pluggable Database RemoteClone Operation.

        Clones a pluggable database (PDB) to a different database from the source PDB. The cloned PDB will be started upon completion of the clone operation. The source PDB must be in the READ_WRITE openMode when performing the clone. For Exadata Cloud@Customer instances, the source pluggable database (PDB) must be on the same Exadata Infrastructure as the target container database (CDB) to create a remote clone.

        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.
      • reorderExecutionActions

        Future<ReorderExecutionActionsResponse> reorderExecutionActions​(ReorderExecutionActionsRequest request,
                                                                        AsyncHandler<ReorderExecutionActionsRequest,​ReorderExecutionActionsResponse> handler)
        Reorders the execution actions under this execution window 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.
      • reorderScheduledActions

        Future<ReorderScheduledActionsResponse> reorderScheduledActions​(ReorderScheduledActionsRequest request,
                                                                        AsyncHandler<ReorderScheduledActionsRequest,​ReorderScheduledActionsResponse> handler)
        Re-order the scheduled actions under this scheduling plan 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.
      • resizeVmClusterNetwork

        Future<ResizeVmClusterNetworkResponse> resizeVmClusterNetwork​(ResizeVmClusterNetworkRequest request,
                                                                      AsyncHandler<ResizeVmClusterNetworkRequest,​ResizeVmClusterNetworkResponse> handler)
        Adds or removes Db server network nodes to extend or shrink the existing VM cluster network.

        Applies to Exadata Cloud@Customer instances only.

        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.
      • resourcePoolShapes

        Future<ResourcePoolShapesResponse> resourcePoolShapes​(ResourcePoolShapesRequest request,
                                                              AsyncHandler<ResourcePoolShapesRequest,​ResourcePoolShapesResponse> handler)
        Lists available resource pools shapes.
        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.
      • restoreAutonomousDatabase

        Future<RestoreAutonomousDatabaseResponse> restoreAutonomousDatabase​(RestoreAutonomousDatabaseRequest request,
                                                                            AsyncHandler<RestoreAutonomousDatabaseRequest,​RestoreAutonomousDatabaseResponse> handler)
        Restores an Autonomous Database based on the provided request 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.
      • restoreDatabase

        Future<RestoreDatabaseResponse> restoreDatabase​(RestoreDatabaseRequest request,
                                                        AsyncHandler<RestoreDatabaseRequest,​RestoreDatabaseResponse> handler)
        Restore a Database based on the request parameters you provide.
        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.
      • rotateOrdsCerts

        Future<RotateOrdsCertsResponse> rotateOrdsCerts​(RotateOrdsCertsRequest request,
                                                        AsyncHandler<RotateOrdsCertsRequest,​RotateOrdsCertsResponse> handler)
        Deprecated. Use the rotateCloudAutonomousVmClusterOrdsCerts to rotate Oracle REST Data Services (ORDS) certs for an Autonomous Exadata VM cluster instead.
        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.
      • rotateSslCerts

        Future<RotateSslCertsResponse> rotateSslCerts​(RotateSslCertsRequest request,
                                                      AsyncHandler<RotateSslCertsRequest,​RotateSslCertsResponse> handler)
        Deprecated. Use the rotateCloudAutonomousVmClusterSslCerts to rotate SSL certs for an Autonomous Exadata VM cluster instead.
        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.
      • rotateVaultKey

        Future<RotateVaultKeyResponse> rotateVaultKey​(RotateVaultKeyRequest request,
                                                      AsyncHandler<RotateVaultKeyRequest,​RotateVaultKeyResponse> handler)
        Creates a new version of an existing Vault service key.
        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.
      • saasAdminUserStatus

        Future<SaasAdminUserStatusResponse> saasAdminUserStatus​(SaasAdminUserStatusRequest request,
                                                                AsyncHandler<SaasAdminUserStatusRequest,​SaasAdminUserStatusResponse> handler)
        This operation gets SaaS administrative user status of the Autonomous 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.
      • setDbKeyVersion

        Future<SetDbKeyVersionResponse> setDbKeyVersion​(SetDbKeyVersionRequest request,
                                                        AsyncHandler<SetDbKeyVersionRequest,​SetDbKeyVersionResponse> handler)
        Sets a new version of an existing Vault service key.
        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.
      • setPdbKeyVersion

        Future<SetPdbKeyVersionResponse> setPdbKeyVersion​(SetPdbKeyVersionRequest request,
                                                          AsyncHandler<SetPdbKeyVersionRequest,​SetPdbKeyVersionResponse> handler)
        Sets a new version of an existing Vault service key.
        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.
      • shrinkAutonomousDatabase

        Future<ShrinkAutonomousDatabaseResponse> shrinkAutonomousDatabase​(ShrinkAutonomousDatabaseRequest request,
                                                                          AsyncHandler<ShrinkAutonomousDatabaseRequest,​ShrinkAutonomousDatabaseResponse> handler)
        This operation shrinks the current allocated storage down to the current actual used data storage (actualUsedDataStorageSizeInTBs).

        The if the base storage value for the database (dataStorageSizeInTBs) is larger than the actualUsedDataStorageSizeInTBs value, you are billed for the base storage value.

        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.
      • startPluggableDatabase

        Future<StartPluggableDatabaseResponse> startPluggableDatabase​(StartPluggableDatabaseRequest request,
                                                                      AsyncHandler<StartPluggableDatabaseRequest,​StartPluggableDatabaseResponse> handler)
        Starts a stopped pluggable database.

        The openMode value of the pluggable database will be READ_WRITE upon completion.

        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.
      • stopAutonomousDatabase

        Future<StopAutonomousDatabaseResponse> stopAutonomousDatabase​(StopAutonomousDatabaseRequest request,
                                                                      AsyncHandler<StopAutonomousDatabaseRequest,​StopAutonomousDatabaseResponse> handler)
        Stops the specified Autonomous 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.
      • stopPluggableDatabase

        Future<StopPluggableDatabaseResponse> stopPluggableDatabase​(StopPluggableDatabaseRequest request,
                                                                    AsyncHandler<StopPluggableDatabaseRequest,​StopPluggableDatabaseResponse> handler)
        Stops a pluggable database.

        The openMode value of the pluggable database will be MOUNTED upon completion.

        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.
      • switchOverDataGuard

        Future<SwitchOverDataGuardResponse> switchOverDataGuard​(SwitchOverDataGuardRequest request,
                                                                AsyncHandler<SwitchOverDataGuardRequest,​SwitchOverDataGuardResponse> handler)
        Performs a switchover to transition primary database of this Data Guard association into a standby role.

        The standby database associated with the dataGuardAssociationId assumes the primary database role.

        A switchover guarantees no data loss.

        This operation should be performed on respective standby 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.
      • switchoverAutonomousDatabase

        Future<SwitchoverAutonomousDatabaseResponse> switchoverAutonomousDatabase​(SwitchoverAutonomousDatabaseRequest request,
                                                                                  AsyncHandler<SwitchoverAutonomousDatabaseRequest,​SwitchoverAutonomousDatabaseResponse> handler)
        Initiates a switchover of the specified Autonomous Database to the associated peer database.

        Applicable only to databases with Disaster Recovery enabled. This API should be called in the remote region where the peer database resides. Below parameter is optional: - peerDbId Use this parameter to specify the database OCID of the Disaster Recovery peer, which is located in a different (remote) region from the current peer database. If this parameter is not provided, the switchover will happen in the same region.

        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.
      • switchoverDataGuardAssociation

        Future<SwitchoverDataGuardAssociationResponse> switchoverDataGuardAssociation​(SwitchoverDataGuardAssociationRequest request,
                                                                                      AsyncHandler<SwitchoverDataGuardAssociationRequest,​SwitchoverDataGuardAssociationResponse> handler)
        Performs a switchover to transition the primary database of a Data Guard association into a standby role.

        The standby database associated with the dataGuardAssociationId assumes the primary database role.

        A switchover guarantees no data loss.

        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.
      • terminateAutonomousContainerDatabase

        Future<TerminateAutonomousContainerDatabaseResponse> terminateAutonomousContainerDatabase​(TerminateAutonomousContainerDatabaseRequest request,
                                                                                                  AsyncHandler<TerminateAutonomousContainerDatabaseRequest,​TerminateAutonomousContainerDatabaseResponse> handler)
        Terminates an Autonomous Container Database, which permanently deletes the container database and any databases within the container database.

        The database data is local to the Autonomous Exadata Infrastructure and will be lost when the container database is terminated. Oracle recommends that you back up any data in the Autonomous Container Database prior to terminating it.

        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.
      • terminateDbSystem

        Future<TerminateDbSystemResponse> terminateDbSystem​(TerminateDbSystemRequest request,
                                                            AsyncHandler<TerminateDbSystemRequest,​TerminateDbSystemResponse> handler)
        Terminates a DB system and permanently deletes it and any databases running on it, and any storage volumes attached to it.

        The database data is local to the DB system and will be lost when the system is terminated. Oracle recommends that you back up any data in the DB system prior to terminating it.

        *Note:** Deprecated for Exadata Cloud Service systems. Use the [new resource model APIs](https://docs.oracle.com/iaas/Content/Database/Concepts/exaflexsystem.htm#exaflexsystem_topic-resource_model) instead.

        For Exadata Cloud Service instances, support for this API will end on May 15th, 2021. See [Switching an Exadata DB System to the New Resource Model and APIs](https://docs.oracle.com/iaas/Content/Database/Concepts/exaflexsystem_topic-resource_model_conversion.htm) for details on converting existing Exadata DB systems to the new resource model.

        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.
      • updateAutonomousDatabase

        Future<UpdateAutonomousDatabaseResponse> updateAutonomousDatabase​(UpdateAutonomousDatabaseRequest request,
                                                                          AsyncHandler<UpdateAutonomousDatabaseRequest,​UpdateAutonomousDatabaseResponse> handler)
        Updates one or more attributes of the specified Autonomous Database.

        See the UpdateAutonomousDatabaseDetails resource for a full list of attributes that can 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.
      • updateAutonomousVmCluster

        Future<UpdateAutonomousVmClusterResponse> updateAutonomousVmCluster​(UpdateAutonomousVmClusterRequest request,
                                                                            AsyncHandler<UpdateAutonomousVmClusterRequest,​UpdateAutonomousVmClusterResponse> handler)
        Updates the specified Autonomous VM cluster for the Exadata Cloud@Customer system.To update an Autonomous VM Cluster in the Oracle cloud, see updateCloudAutonomousVmCluster.
        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.
      • updateBackup

        Future<UpdateBackupResponse> updateBackup​(UpdateBackupRequest request,
                                                  AsyncHandler<UpdateBackupRequest,​UpdateBackupResponse> handler)
        Updates database backup details.
        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.
      • updateBackupDestination

        Future<UpdateBackupDestinationResponse> updateBackupDestination​(UpdateBackupDestinationRequest request,
                                                                        AsyncHandler<UpdateBackupDestinationRequest,​UpdateBackupDestinationResponse> handler)
        If no database is associated with the backup destination: - For a RECOVERY_APPLIANCE backup destination, updates the connection string and/or the list of VPC users.
        • For an NFS backup destination, updates the NFS location.
        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.
      • updateCloudVmCluster

        Future<UpdateCloudVmClusterResponse> updateCloudVmCluster​(UpdateCloudVmClusterRequest request,
                                                                  AsyncHandler<UpdateCloudVmClusterRequest,​UpdateCloudVmClusterResponse> handler)
        Updates the specified cloud VM cluster.

        Applies to Exadata Cloud Service instances and Autonomous Database on dedicated Exadata infrastructure only.

        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.
      • updateConsoleConnection

        Future<UpdateConsoleConnectionResponse> updateConsoleConnection​(UpdateConsoleConnectionRequest request,
                                                                        AsyncHandler<UpdateConsoleConnectionRequest,​UpdateConsoleConnectionResponse> handler)
        Updates the specified database node console connection.
        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.
      • updateConsoleHistory

        Future<UpdateConsoleHistoryResponse> updateConsoleHistory​(UpdateConsoleHistoryRequest request,
                                                                  AsyncHandler<UpdateConsoleHistoryRequest,​UpdateConsoleHistoryResponse> handler)
        Updates the specified database node console history.
        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.
      • updateDataGuard

        Future<UpdateDataGuardResponse> updateDataGuard​(UpdateDataGuardRequest request,
                                                        AsyncHandler<UpdateDataGuardRequest,​UpdateDataGuardResponse> handler)
        Update an existing Data Guard member.

        A Data Guard member represents the replication relationship between the specified database and a standby database. For more information, see Using Oracle Data Guard.

        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.
      • updateDataGuardAssociation

        Future<UpdateDataGuardAssociationResponse> updateDataGuardAssociation​(UpdateDataGuardAssociationRequest request,
                                                                              AsyncHandler<UpdateDataGuardAssociationRequest,​UpdateDataGuardAssociationResponse> handler)
        Updates the Data Guard association the specified database.

        This API can be used to change the protectionMode and transportType of the Data Guard association.

        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.
      • updateDatabase

        Future<UpdateDatabaseResponse> updateDatabase​(UpdateDatabaseRequest request,
                                                      AsyncHandler<UpdateDatabaseRequest,​UpdateDatabaseResponse> handler)
        Update the specified database based on the request parameters 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.
      • updateDbHome

        Future<UpdateDbHomeResponse> updateDbHome​(UpdateDbHomeRequest request,
                                                  AsyncHandler<UpdateDbHomeRequest,​UpdateDbHomeResponse> handler)
        Patches the specified Database Home.
        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.
      • updateDbNode

        Future<UpdateDbNodeResponse> updateDbNode​(UpdateDbNodeRequest request,
                                                  AsyncHandler<UpdateDbNodeRequest,​UpdateDbNodeResponse> handler)
        Updates the specified database node.
        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.
      • updateDbSystem

        Future<UpdateDbSystemResponse> updateDbSystem​(UpdateDbSystemRequest request,
                                                      AsyncHandler<UpdateDbSystemRequest,​UpdateDbSystemResponse> handler)
        Updates the properties of the specified DB system.

        *Note:** Deprecated for Exadata Cloud Service systems. Use the [new resource model APIs](https://docs.oracle.com/iaas/Content/Database/Concepts/exaflexsystem.htm#exaflexsystem_topic-resource_model) instead.

        For Exadata Cloud Service instances, support for this API will end on May 15th, 2021. See [Switching an Exadata DB System to the New Resource Model and APIs](https://docs.oracle.com/iaas/Content/Database/Concepts/exaflexsystem_topic-resource_model_conversion.htm) for details on converting existing Exadata DB systems to the new resource model.

        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.
      • updateExadataInfrastructure

        Future<UpdateExadataInfrastructureResponse> updateExadataInfrastructure​(UpdateExadataInfrastructureRequest request,
                                                                                AsyncHandler<UpdateExadataInfrastructureRequest,​UpdateExadataInfrastructureResponse> handler)
        Updates the Exadata infrastructure resource.

        Applies to Exadata Cloud@Customer instances only. To update an Exadata Cloud Service infrastructure resource, use the updateCloudExadataInfrastructure operation.

        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.
      • updateExadataIormConfig

        Future<UpdateExadataIormConfigResponse> updateExadataIormConfig​(UpdateExadataIormConfigRequest request,
                                                                        AsyncHandler<UpdateExadataIormConfigRequest,​UpdateExadataIormConfigResponse> handler)
        Updates IORM settings for the specified Exadata DB system.

        *Note:** Deprecated for Exadata Cloud Service systems. Use the [new resource model APIs](https://docs.oracle.com/iaas/Content/Database/Concepts/exaflexsystem.htm#exaflexsystem_topic-resource_model) instead.

        For Exadata Cloud Service instances, support for this API will end on May 15th, 2021. See [Switching an Exadata DB System to the New Resource Model and APIs](https://docs.oracle.com/iaas/Content/Database/Concepts/exaflexsystem_topic-resource_model_conversion.htm) for details on converting existing Exadata DB systems to the new resource model.

        The updateCloudVmClusterIormConfig API is used for Exadata systems using the new resource model.

        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.
      • updateExadbVmCluster

        Future<UpdateExadbVmClusterResponse> updateExadbVmCluster​(UpdateExadbVmClusterRequest request,
                                                                  AsyncHandler<UpdateExadbVmClusterRequest,​UpdateExadbVmClusterResponse> handler)
        Updates the specified Exadata VM cluster on Exascale Infrastructure.

        Applies to Exadata Database Service on Exascale Infrastructure only.

        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.
      • updateExecutionAction

        Future<UpdateExecutionActionResponse> updateExecutionAction​(UpdateExecutionActionRequest request,
                                                                    AsyncHandler<UpdateExecutionActionRequest,​UpdateExecutionActionResponse> handler)
        Updates the execution action 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.
      • updateExecutionWindow

        Future<UpdateExecutionWindowResponse> updateExecutionWindow​(UpdateExecutionWindowRequest request,
                                                                    AsyncHandler<UpdateExecutionWindowRequest,​UpdateExecutionWindowResponse> handler)
        Updates the execution window 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.
      • updateKeyStore

        Future<UpdateKeyStoreResponse> updateKeyStore​(UpdateKeyStoreRequest request,
                                                      AsyncHandler<UpdateKeyStoreRequest,​UpdateKeyStoreResponse> handler)
        Edit the key store.
        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.
      • updateMaintenanceRun

        Future<UpdateMaintenanceRunResponse> updateMaintenanceRun​(UpdateMaintenanceRunRequest request,
                                                                  AsyncHandler<UpdateMaintenanceRunRequest,​UpdateMaintenanceRunResponse> handler)
        Updates the properties of a maintenance run, such as the state of a maintenance run.
        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.
      • updateOneoffPatch

        Future<UpdateOneoffPatchResponse> updateOneoffPatch​(UpdateOneoffPatchRequest request,
                                                            AsyncHandler<UpdateOneoffPatchRequest,​UpdateOneoffPatchResponse> handler)
        Updates the properties of the specified one-off patch.
        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.
      • updateScheduledAction

        Future<UpdateScheduledActionResponse> updateScheduledAction​(UpdateScheduledActionRequest request,
                                                                    AsyncHandler<UpdateScheduledActionRequest,​UpdateScheduledActionResponse> handler)
        Updates the Scheduled Action 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.
      • updateSchedulingPolicy

        Future<UpdateSchedulingPolicyResponse> updateSchedulingPolicy​(UpdateSchedulingPolicyRequest request,
                                                                      AsyncHandler<UpdateSchedulingPolicyRequest,​UpdateSchedulingPolicyResponse> handler)
        Updates the Scheduling Policy 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.
      • updateSchedulingWindow

        Future<UpdateSchedulingWindowResponse> updateSchedulingWindow​(UpdateSchedulingWindowRequest request,
                                                                      AsyncHandler<UpdateSchedulingWindowRequest,​UpdateSchedulingWindowResponse> handler)
        Updates the Scheduling Window 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.
      • updateVmCluster

        Future<UpdateVmClusterResponse> updateVmCluster​(UpdateVmClusterRequest request,
                                                        AsyncHandler<UpdateVmClusterRequest,​UpdateVmClusterResponse> handler)
        Updates the specified VM cluster.

        Applies to Exadata Cloud@Customer instances only.

        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.
      • updateVmClusterNetwork

        Future<UpdateVmClusterNetworkResponse> updateVmClusterNetwork​(UpdateVmClusterNetworkRequest request,
                                                                      AsyncHandler<UpdateVmClusterNetworkRequest,​UpdateVmClusterNetworkResponse> handler)
        Updates the specified VM cluster network.

        Applies to Exadata Cloud@Customer instances only. To update a cloud VM cluster in an Exadata Cloud Service instance, use the updateCloudVmCluster operation.

        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.
      • upgradeDatabase

        Future<UpgradeDatabaseResponse> upgradeDatabase​(UpgradeDatabaseRequest request,
                                                        AsyncHandler<UpgradeDatabaseRequest,​UpgradeDatabaseResponse> handler)
        Upgrades the specified Oracle Database 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.
      • upgradeDbSystem

        Future<UpgradeDbSystemResponse> upgradeDbSystem​(UpgradeDbSystemRequest request,
                                                        AsyncHandler<UpgradeDbSystemRequest,​UpgradeDbSystemResponse> handler)
        Upgrades the operating system and grid infrastructure of the 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.
      • validateVmClusterNetwork

        Future<ValidateVmClusterNetworkResponse> validateVmClusterNetwork​(ValidateVmClusterNetworkRequest request,
                                                                          AsyncHandler<ValidateVmClusterNetworkRequest,​ValidateVmClusterNetworkResponse> handler)
        Validates the specified VM cluster network.

        Applies to Exadata Cloud@Customer instances only.

        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.