/** * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved. * SPDX-License-Identifier: Apache-2.0. */ #pragma once #include #include #include #include #include #include #include namespace Aws { namespace RDS { /** * Amazon Relational Database Service

Amazon * Relational Database Service (Amazon RDS) is a web service that makes it easier * to set up, operate, and scale a relational database in the cloud. It provides * cost-efficient, resizeable capacity for an industry-standard relational database * and manages common database administration tasks, freeing up developers to focus * on what makes their applications and businesses unique.

Amazon RDS gives * you access to the capabilities of a MySQL, MariaDB, PostgreSQL, Microsoft SQL * Server, Oracle, or Amazon Aurora database server. These capabilities mean that * the code, applications, and tools you already use today with your existing * databases work with Amazon RDS without modification. Amazon RDS automatically * backs up your database and maintains the database software that powers your DB * instance. Amazon RDS is flexible: you can scale your DB instance's compute * resources and storage capacity to meet your application's demand. As with all * Amazon Web Services, there are no up-front investments, and you pay only for the * resources you use.

This interface reference for Amazon RDS contains * documentation for a programming or command line interface you can use to manage * Amazon RDS. Amazon RDS is asynchronous, which means that some interfaces might * require techniques such as polling or callback functions to determine when a * command has been applied. In this reference, the parameter descriptions indicate * whether a command is applied immediately, on the next instance reboot, or during * the maintenance window. The reference structure is as follows, and we list * following some related topics from the user guide.

Amazon RDS API * Reference

Amazon RDS User Guide

*/ class AWS_RDS_API RDSClient : public Aws::Client::AWSXMLClient, public Aws::Client::ClientWithAsyncTemplateMethods { public: typedef Aws::Client::AWSXMLClient BASECLASS; static const char* SERVICE_NAME; static const char* ALLOCATION_TAG; typedef RDSClientConfiguration ClientConfigurationType; typedef RDSEndpointProvider EndpointProviderType; /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ RDSClient(const Aws::RDS::RDSClientConfiguration& clientConfiguration = Aws::RDS::RDSClientConfiguration(), std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG)); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ RDSClient(const Aws::Auth::AWSCredentials& credentials, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::RDS::RDSClientConfiguration& clientConfiguration = Aws::RDS::RDSClientConfiguration()); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ RDSClient(const std::shared_ptr& credentialsProvider, std::shared_ptr endpointProvider = Aws::MakeShared(ALLOCATION_TAG), const Aws::RDS::RDSClientConfiguration& clientConfiguration = Aws::RDS::RDSClientConfiguration()); /* Legacy constructors due deprecation */ /** * Initializes client to use DefaultCredentialProviderChain, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ RDSClient(const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use SimpleAWSCredentialsProvider, with default http client factory, and optional client config. If client config * is not specified, it will be initialized to default values. */ RDSClient(const Aws::Auth::AWSCredentials& credentials, const Aws::Client::ClientConfiguration& clientConfiguration); /** * Initializes client to use specified credentials provider with specified client config. If http client factory is not supplied, * the default http client factory will be used */ RDSClient(const std::shared_ptr& credentialsProvider, const Aws::Client::ClientConfiguration& clientConfiguration); /* End of legacy constructors due deprecation */ virtual ~RDSClient(); /** * Converts any request object to a presigned URL with the GET method, using region for the signer and a timeout of 15 minutes. */ Aws::String ConvertRequestToPresignedUrl(const Aws::AmazonSerializableWebServiceRequest& requestToConvert, const char* region) const; /** * Generates an auth token for connecting to an rds instance. */ Aws::String GenerateConnectAuthToken(const char* dbHostName, const char* dbRegion, unsigned port, const char* dbUserName) const; /** *

Associates an Identity and Access Management (IAM) role with a DB * cluster.

See Also:

AWS * API Reference

*/ virtual Model::AddRoleToDBClusterOutcome AddRoleToDBCluster(const Model::AddRoleToDBClusterRequest& request) const; /** * A Callable wrapper for AddRoleToDBCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddRoleToDBClusterOutcomeCallable AddRoleToDBClusterCallable(const AddRoleToDBClusterRequestT& request) const { return SubmitCallable(&RDSClient::AddRoleToDBCluster, request); } /** * An Async wrapper for AddRoleToDBCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddRoleToDBClusterAsync(const AddRoleToDBClusterRequestT& request, const AddRoleToDBClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::AddRoleToDBCluster, request, handler, context); } /** *

Associates an Amazon Web Services Identity and Access Management (IAM) role * with a DB instance.

To add a role to a DB instance, the status of * the DB instance must be available.

This command * doesn't apply to RDS Custom.

See Also:

AWS * API Reference

*/ virtual Model::AddRoleToDBInstanceOutcome AddRoleToDBInstance(const Model::AddRoleToDBInstanceRequest& request) const; /** * A Callable wrapper for AddRoleToDBInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddRoleToDBInstanceOutcomeCallable AddRoleToDBInstanceCallable(const AddRoleToDBInstanceRequestT& request) const { return SubmitCallable(&RDSClient::AddRoleToDBInstance, request); } /** * An Async wrapper for AddRoleToDBInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddRoleToDBInstanceAsync(const AddRoleToDBInstanceRequestT& request, const AddRoleToDBInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::AddRoleToDBInstance, request, handler, context); } /** *

Adds a source identifier to an existing RDS event notification * subscription.

See Also:

AWS * API Reference

*/ virtual Model::AddSourceIdentifierToSubscriptionOutcome AddSourceIdentifierToSubscription(const Model::AddSourceIdentifierToSubscriptionRequest& request) const; /** * A Callable wrapper for AddSourceIdentifierToSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddSourceIdentifierToSubscriptionOutcomeCallable AddSourceIdentifierToSubscriptionCallable(const AddSourceIdentifierToSubscriptionRequestT& request) const { return SubmitCallable(&RDSClient::AddSourceIdentifierToSubscription, request); } /** * An Async wrapper for AddSourceIdentifierToSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddSourceIdentifierToSubscriptionAsync(const AddSourceIdentifierToSubscriptionRequestT& request, const AddSourceIdentifierToSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::AddSourceIdentifierToSubscription, request, handler, context); } /** *

Adds metadata tags to an Amazon RDS resource. These tags can also be used * with cost allocation reporting to track cost associated with Amazon RDS * resources, or used in a Condition statement in an IAM policy for Amazon RDS.

*

For an overview on tagging Amazon RDS resources, see Tagging * Amazon RDS Resources.

See Also:

AWS * API Reference

*/ virtual Model::AddTagsToResourceOutcome AddTagsToResource(const Model::AddTagsToResourceRequest& request) const; /** * A Callable wrapper for AddTagsToResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AddTagsToResourceOutcomeCallable AddTagsToResourceCallable(const AddTagsToResourceRequestT& request) const { return SubmitCallable(&RDSClient::AddTagsToResource, request); } /** * An Async wrapper for AddTagsToResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AddTagsToResourceAsync(const AddTagsToResourceRequestT& request, const AddTagsToResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::AddTagsToResource, request, handler, context); } /** *

Applies a pending maintenance action to a resource (for example, to a DB * instance).

See Also:

AWS * API Reference

*/ virtual Model::ApplyPendingMaintenanceActionOutcome ApplyPendingMaintenanceAction(const Model::ApplyPendingMaintenanceActionRequest& request) const; /** * A Callable wrapper for ApplyPendingMaintenanceAction that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ApplyPendingMaintenanceActionOutcomeCallable ApplyPendingMaintenanceActionCallable(const ApplyPendingMaintenanceActionRequestT& request) const { return SubmitCallable(&RDSClient::ApplyPendingMaintenanceAction, request); } /** * An Async wrapper for ApplyPendingMaintenanceAction that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ApplyPendingMaintenanceActionAsync(const ApplyPendingMaintenanceActionRequestT& request, const ApplyPendingMaintenanceActionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ApplyPendingMaintenanceAction, request, handler, context); } /** *

Enables ingress to a DBSecurityGroup using one of two forms of authorization. * First, EC2 or VPC security groups can be added to the DBSecurityGroup if the * application using the database is running on EC2 or VPC instances. Second, IP * ranges are available if the application accessing your database is running on * the internet. Required parameters for this API are one of CIDR range, * EC2SecurityGroupId for VPC, or (EC2SecurityGroupOwnerId and either * EC2SecurityGroupName or EC2SecurityGroupId for non-VPC).

You can't * authorize ingress from an EC2 security group in one Amazon Web Services Region * to an Amazon RDS DB instance in another. You can't authorize ingress from a VPC * security group in one VPC to an Amazon RDS DB instance in another.

For an * overview of CIDR ranges, go to the Wikipedia * Tutorial.

EC2-Classic was retired on August 15, 2022. If you * haven't migrated from EC2-Classic to a VPC, we recommend that you migrate as * soon as possible. For more information, see Migrate * from EC2-Classic to a VPC in the Amazon EC2 User Guide, the blog EC2-Classic * Networking is Retiring – Here’s How to Prepare, and Moving * a DB instance not in a VPC into a VPC in the Amazon RDS User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::AuthorizeDBSecurityGroupIngressOutcome AuthorizeDBSecurityGroupIngress(const Model::AuthorizeDBSecurityGroupIngressRequest& request) const; /** * A Callable wrapper for AuthorizeDBSecurityGroupIngress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::AuthorizeDBSecurityGroupIngressOutcomeCallable AuthorizeDBSecurityGroupIngressCallable(const AuthorizeDBSecurityGroupIngressRequestT& request) const { return SubmitCallable(&RDSClient::AuthorizeDBSecurityGroupIngress, request); } /** * An Async wrapper for AuthorizeDBSecurityGroupIngress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void AuthorizeDBSecurityGroupIngressAsync(const AuthorizeDBSecurityGroupIngressRequestT& request, const AuthorizeDBSecurityGroupIngressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::AuthorizeDBSecurityGroupIngress, request, handler, context); } /** *

Backtracks a DB cluster to a specific time, without creating a new DB * cluster.

For more information on backtracking, see * Backtracking an Aurora DB Cluster in the Amazon Aurora User * Guide.

This action applies only to Aurora MySQL DB * clusters.

See Also:

AWS * API Reference

*/ virtual Model::BacktrackDBClusterOutcome BacktrackDBCluster(const Model::BacktrackDBClusterRequest& request) const; /** * A Callable wrapper for BacktrackDBCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::BacktrackDBClusterOutcomeCallable BacktrackDBClusterCallable(const BacktrackDBClusterRequestT& request) const { return SubmitCallable(&RDSClient::BacktrackDBCluster, request); } /** * An Async wrapper for BacktrackDBCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void BacktrackDBClusterAsync(const BacktrackDBClusterRequestT& request, const BacktrackDBClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::BacktrackDBCluster, request, handler, context); } /** *

Cancels an export task in progress that is exporting a snapshot or cluster to * Amazon S3. Any data that has already been written to the S3 bucket isn't * removed.

See Also:

AWS * API Reference

*/ virtual Model::CancelExportTaskOutcome CancelExportTask(const Model::CancelExportTaskRequest& request) const; /** * A Callable wrapper for CancelExportTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CancelExportTaskOutcomeCallable CancelExportTaskCallable(const CancelExportTaskRequestT& request) const { return SubmitCallable(&RDSClient::CancelExportTask, request); } /** * An Async wrapper for CancelExportTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CancelExportTaskAsync(const CancelExportTaskRequestT& request, const CancelExportTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CancelExportTask, request, handler, context); } /** *

Copies the specified DB cluster parameter group.

See Also:

* AWS * API Reference

*/ virtual Model::CopyDBClusterParameterGroupOutcome CopyDBClusterParameterGroup(const Model::CopyDBClusterParameterGroupRequest& request) const; /** * A Callable wrapper for CopyDBClusterParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CopyDBClusterParameterGroupOutcomeCallable CopyDBClusterParameterGroupCallable(const CopyDBClusterParameterGroupRequestT& request) const { return SubmitCallable(&RDSClient::CopyDBClusterParameterGroup, request); } /** * An Async wrapper for CopyDBClusterParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CopyDBClusterParameterGroupAsync(const CopyDBClusterParameterGroupRequestT& request, const CopyDBClusterParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CopyDBClusterParameterGroup, request, handler, context); } /** *

Copies a snapshot of a DB cluster.

To copy a DB cluster snapshot from * a shared manual DB cluster snapshot, * SourceDBClusterSnapshotIdentifier must be the Amazon Resource Name * (ARN) of the shared DB cluster snapshot.

You can copy an encrypted DB * cluster snapshot from another Amazon Web Services Region. In that case, the * Amazon Web Services Region where you call the CopyDBClusterSnapshot * operation is the destination Amazon Web Services Region for the encrypted DB * cluster snapshot to be copied to. To copy an encrypted DB cluster snapshot from * another Amazon Web Services Region, you must provide the following values:

*

  • KmsKeyId - The Amazon Web Services Key Management * System (Amazon Web Services KMS) key identifier for the key to use to encrypt * the copy of the DB cluster snapshot in the destination Amazon Web Services * Region.

  • TargetDBClusterSnapshotIdentifier - The * identifier for the new copy of the DB cluster snapshot in the destination Amazon * Web Services Region.

  • * SourceDBClusterSnapshotIdentifier - The DB cluster snapshot * identifier for the encrypted DB cluster snapshot to be copied. This identifier * must be in the ARN format for the source Amazon Web Services Region and is the * same value as the SourceDBClusterSnapshotIdentifier in the * presigned URL.

To cancel the copy operation once it is in * progress, delete the target DB cluster snapshot identified by * TargetDBClusterSnapshotIdentifier while that DB cluster snapshot is * in "copying" status.

For more information on copying encrypted Amazon * Aurora DB cluster snapshots from one Amazon Web Services Region to another, see * * Copying a Snapshot in the Amazon Aurora User Guide.

For more * information on Amazon Aurora DB clusters, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CopyDBClusterSnapshotOutcome CopyDBClusterSnapshot(const Model::CopyDBClusterSnapshotRequest& request) const; /** * A Callable wrapper for CopyDBClusterSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CopyDBClusterSnapshotOutcomeCallable CopyDBClusterSnapshotCallable(const CopyDBClusterSnapshotRequestT& request) const { return SubmitCallable(&RDSClient::CopyDBClusterSnapshot, request); } /** * An Async wrapper for CopyDBClusterSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CopyDBClusterSnapshotAsync(const CopyDBClusterSnapshotRequestT& request, const CopyDBClusterSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CopyDBClusterSnapshot, request, handler, context); } /** *

Copies the specified DB parameter group.

See Also:

AWS * API Reference

*/ virtual Model::CopyDBParameterGroupOutcome CopyDBParameterGroup(const Model::CopyDBParameterGroupRequest& request) const; /** * A Callable wrapper for CopyDBParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CopyDBParameterGroupOutcomeCallable CopyDBParameterGroupCallable(const CopyDBParameterGroupRequestT& request) const { return SubmitCallable(&RDSClient::CopyDBParameterGroup, request); } /** * An Async wrapper for CopyDBParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CopyDBParameterGroupAsync(const CopyDBParameterGroupRequestT& request, const CopyDBParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CopyDBParameterGroup, request, handler, context); } /** *

Copies the specified DB snapshot. The source DB snapshot must be in the * available state.

You can copy a snapshot from one Amazon Web * Services Region to another. In that case, the Amazon Web Services Region where * you call the CopyDBSnapshot operation is the destination Amazon Web * Services Region for the DB snapshot copy.

This command doesn't apply to * RDS Custom.

For more information about copying snapshots, see Copying * a DB Snapshot in the Amazon RDS User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::CopyDBSnapshotOutcome CopyDBSnapshot(const Model::CopyDBSnapshotRequest& request) const; /** * A Callable wrapper for CopyDBSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CopyDBSnapshotOutcomeCallable CopyDBSnapshotCallable(const CopyDBSnapshotRequestT& request) const { return SubmitCallable(&RDSClient::CopyDBSnapshot, request); } /** * An Async wrapper for CopyDBSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CopyDBSnapshotAsync(const CopyDBSnapshotRequestT& request, const CopyDBSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CopyDBSnapshot, request, handler, context); } /** *

Copies the specified option group.

See Also:

AWS * API Reference

*/ virtual Model::CopyOptionGroupOutcome CopyOptionGroup(const Model::CopyOptionGroupRequest& request) const; /** * A Callable wrapper for CopyOptionGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CopyOptionGroupOutcomeCallable CopyOptionGroupCallable(const CopyOptionGroupRequestT& request) const { return SubmitCallable(&RDSClient::CopyOptionGroup, request); } /** * An Async wrapper for CopyOptionGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CopyOptionGroupAsync(const CopyOptionGroupRequestT& request, const CopyOptionGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CopyOptionGroup, request, handler, context); } /** *

Creates a blue/green deployment.

A blue/green deployment creates a * staging environment that copies the production environment. In a blue/green * deployment, the blue environment is the current production environment. The * green environment is the staging environment. The staging environment stays in * sync with the current production environment using logical replication.

*

You can make changes to the databases in the green environment without * affecting production workloads. For example, you can upgrade the major or minor * DB engine version, change database parameters, or make schema changes in the * staging environment. You can thoroughly test changes in the green environment. * When ready, you can switch over the environments to promote the green * environment to be the new production environment. The switchover typically takes * under a minute.

For more information, see Using * Amazon RDS Blue/Green Deployments for database updates in the Amazon RDS * User Guide and * Using Amazon RDS Blue/Green Deployments for database updates in the * Amazon Aurora User Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateBlueGreenDeploymentOutcome CreateBlueGreenDeployment(const Model::CreateBlueGreenDeploymentRequest& request) const; /** * A Callable wrapper for CreateBlueGreenDeployment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateBlueGreenDeploymentOutcomeCallable CreateBlueGreenDeploymentCallable(const CreateBlueGreenDeploymentRequestT& request) const { return SubmitCallable(&RDSClient::CreateBlueGreenDeployment, request); } /** * An Async wrapper for CreateBlueGreenDeployment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateBlueGreenDeploymentAsync(const CreateBlueGreenDeploymentRequestT& request, const CreateBlueGreenDeploymentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateBlueGreenDeployment, request, handler, context); } /** *

Creates a custom DB engine version (CEV).

See Also:

AWS * API Reference

*/ virtual Model::CreateCustomDBEngineVersionOutcome CreateCustomDBEngineVersion(const Model::CreateCustomDBEngineVersionRequest& request) const; /** * A Callable wrapper for CreateCustomDBEngineVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateCustomDBEngineVersionOutcomeCallable CreateCustomDBEngineVersionCallable(const CreateCustomDBEngineVersionRequestT& request) const { return SubmitCallable(&RDSClient::CreateCustomDBEngineVersion, request); } /** * An Async wrapper for CreateCustomDBEngineVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateCustomDBEngineVersionAsync(const CreateCustomDBEngineVersionRequestT& request, const CreateCustomDBEngineVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateCustomDBEngineVersion, request, handler, context); } /** *

Creates a new Amazon Aurora DB cluster or Multi-AZ DB cluster.

If you * create an Aurora DB cluster, the request creates an empty cluster. You must * explicitly create the writer instance for your DB cluster using the CreateDBInstance * operation. If you create a Multi-AZ DB cluster, the request creates a writer and * two reader DB instances for you, each in a different Availability Zone.

*

You can use the ReplicationSourceIdentifier parameter to create * an Amazon Aurora DB cluster as a read replica of another DB cluster or Amazon * RDS for MySQL or PostgreSQL DB instance. For more information about Amazon * Aurora, see What * is Amazon Aurora? in the Amazon Aurora User Guide.

You can * also use the ReplicationSourceIdentifier parameter to create a * Multi-AZ DB cluster read replica with an RDS for MySQL or PostgreSQL DB instance * as the source. For more information about Multi-AZ DB clusters, see Multi-AZ * DB cluster deployments in the Amazon RDS User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::CreateDBClusterOutcome CreateDBCluster(const Model::CreateDBClusterRequest& request) const; /** * A Callable wrapper for CreateDBCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDBClusterOutcomeCallable CreateDBClusterCallable(const CreateDBClusterRequestT& request) const { return SubmitCallable(&RDSClient::CreateDBCluster, request); } /** * An Async wrapper for CreateDBCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDBClusterAsync(const CreateDBClusterRequestT& request, const CreateDBClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateDBCluster, request, handler, context); } /** *

Creates a new custom endpoint and associates it with an Amazon Aurora DB * cluster.

This action applies only to Aurora DB clusters.

*

See Also:

AWS * API Reference

*/ virtual Model::CreateDBClusterEndpointOutcome CreateDBClusterEndpoint(const Model::CreateDBClusterEndpointRequest& request) const; /** * A Callable wrapper for CreateDBClusterEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDBClusterEndpointOutcomeCallable CreateDBClusterEndpointCallable(const CreateDBClusterEndpointRequestT& request) const { return SubmitCallable(&RDSClient::CreateDBClusterEndpoint, request); } /** * An Async wrapper for CreateDBClusterEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDBClusterEndpointAsync(const CreateDBClusterEndpointRequestT& request, const CreateDBClusterEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateDBClusterEndpoint, request, handler, context); } /** *

Creates a new DB cluster parameter group.

Parameters in a DB cluster * parameter group apply to all of the instances in a DB cluster.

A DB * cluster parameter group is initially created with the default parameters for the * database engine used by instances in the DB cluster. To provide custom values * for any of the parameters, you must modify the group after creating it using * ModifyDBClusterParameterGroup. Once you've created a DB cluster * parameter group, you need to associate it with your DB cluster using * ModifyDBCluster.

When you associate a new DB cluster * parameter group with a running Aurora DB cluster, reboot the DB instances in the * DB cluster without failover for the new DB cluster parameter group and * associated settings to take effect.

When you associate a new DB cluster * parameter group with a running Multi-AZ DB cluster, reboot the DB cluster * without failover for the new DB cluster parameter group and associated settings * to take effect.

After you create a DB cluster parameter * group, you should wait at least 5 minutes before creating your first DB cluster * that uses that DB cluster parameter group as the default parameter group. This * allows Amazon RDS to fully complete the create action before the DB cluster * parameter group is used as the default for a new DB cluster. This is especially * important for parameters that are critical when creating the default database * for a DB cluster, such as the character set for the default database defined by * the character_set_database parameter. You can use the Parameter * Groups option of the Amazon * RDS console or the DescribeDBClusterParameters operation to * verify that your DB cluster parameter group has been created or modified.

*

For more information on Amazon Aurora, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateDBClusterParameterGroupOutcome CreateDBClusterParameterGroup(const Model::CreateDBClusterParameterGroupRequest& request) const; /** * A Callable wrapper for CreateDBClusterParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDBClusterParameterGroupOutcomeCallable CreateDBClusterParameterGroupCallable(const CreateDBClusterParameterGroupRequestT& request) const { return SubmitCallable(&RDSClient::CreateDBClusterParameterGroup, request); } /** * An Async wrapper for CreateDBClusterParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDBClusterParameterGroupAsync(const CreateDBClusterParameterGroupRequestT& request, const CreateDBClusterParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateDBClusterParameterGroup, request, handler, context); } /** *

Creates a snapshot of a DB cluster.

For more information on Amazon * Aurora, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateDBClusterSnapshotOutcome CreateDBClusterSnapshot(const Model::CreateDBClusterSnapshotRequest& request) const; /** * A Callable wrapper for CreateDBClusterSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDBClusterSnapshotOutcomeCallable CreateDBClusterSnapshotCallable(const CreateDBClusterSnapshotRequestT& request) const { return SubmitCallable(&RDSClient::CreateDBClusterSnapshot, request); } /** * An Async wrapper for CreateDBClusterSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDBClusterSnapshotAsync(const CreateDBClusterSnapshotRequestT& request, const CreateDBClusterSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateDBClusterSnapshot, request, handler, context); } /** *

Creates a new DB instance.

The new DB instance can be an RDS DB * instance, or it can be a DB instance in an Aurora DB cluster. For an Aurora DB * cluster, you can call this operation multiple times to add more than one DB * instance to the cluster.

For more information about creating an RDS DB * instance, see * Creating an Amazon RDS DB instance in the Amazon RDS User Guide.

*

For more information about creating a DB instance in an Aurora DB cluster, * see * Creating an Amazon Aurora DB cluster in the Amazon Aurora User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateDBInstanceOutcome CreateDBInstance(const Model::CreateDBInstanceRequest& request) const; /** * A Callable wrapper for CreateDBInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDBInstanceOutcomeCallable CreateDBInstanceCallable(const CreateDBInstanceRequestT& request) const { return SubmitCallable(&RDSClient::CreateDBInstance, request); } /** * An Async wrapper for CreateDBInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDBInstanceAsync(const CreateDBInstanceRequestT& request, const CreateDBInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateDBInstance, request, handler, context); } /** *

Creates a new DB instance that acts as a read replica for an existing source * DB instance or Multi-AZ DB cluster. You can create a read replica for a DB * instance running MySQL, MariaDB, Oracle, PostgreSQL, or SQL Server. You can * create a read replica for a Multi-AZ DB cluster running MySQL or PostgreSQL. For * more information, see Working * with read replicas and Migrating * from a Multi-AZ DB cluster to a DB instance using a read replica in the * Amazon RDS User Guide.

Amazon Aurora doesn't support this * operation. Call the CreateDBInstance operation to create a DB * instance for an Aurora DB cluster.

All read replica DB instances are * created with backups disabled. All other attributes (including DB security * groups and DB parameter groups) are inherited from the source DB instance or * cluster, except as specified.

Your source DB instance or * cluster must have backup retention enabled.

See * Also:

AWS * API Reference

*/ virtual Model::CreateDBInstanceReadReplicaOutcome CreateDBInstanceReadReplica(const Model::CreateDBInstanceReadReplicaRequest& request) const; /** * A Callable wrapper for CreateDBInstanceReadReplica that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDBInstanceReadReplicaOutcomeCallable CreateDBInstanceReadReplicaCallable(const CreateDBInstanceReadReplicaRequestT& request) const { return SubmitCallable(&RDSClient::CreateDBInstanceReadReplica, request); } /** * An Async wrapper for CreateDBInstanceReadReplica that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDBInstanceReadReplicaAsync(const CreateDBInstanceReadReplicaRequestT& request, const CreateDBInstanceReadReplicaResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateDBInstanceReadReplica, request, handler, context); } /** *

Creates a new DB parameter group.

A DB parameter group is initially * created with the default parameters for the database engine used by the DB * instance. To provide custom values for any of the parameters, you must modify * the group after creating it using ModifyDBParameterGroup. Once * you've created a DB parameter group, you need to associate it with your DB * instance using ModifyDBInstance. When you associate a new DB * parameter group with a running DB instance, you need to reboot the DB instance * without failover for the new DB parameter group and associated settings to take * effect.

This command doesn't apply to RDS Custom.

*

After you create a DB parameter group, you should wait at least 5 minutes * before creating your first DB instance that uses that DB parameter group as the * default parameter group. This allows Amazon RDS to fully complete the create * action before the parameter group is used as the default for a new DB instance. * This is especially important for parameters that are critical when creating the * default database for a DB instance, such as the character set for the default * database defined by the character_set_database parameter. You can * use the Parameter Groups option of the Amazon RDS console or the * DescribeDBParameters command to verify that your DB parameter group has * been created or modified.

See Also:

AWS * API Reference

*/ virtual Model::CreateDBParameterGroupOutcome CreateDBParameterGroup(const Model::CreateDBParameterGroupRequest& request) const; /** * A Callable wrapper for CreateDBParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDBParameterGroupOutcomeCallable CreateDBParameterGroupCallable(const CreateDBParameterGroupRequestT& request) const { return SubmitCallable(&RDSClient::CreateDBParameterGroup, request); } /** * An Async wrapper for CreateDBParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDBParameterGroupAsync(const CreateDBParameterGroupRequestT& request, const CreateDBParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateDBParameterGroup, request, handler, context); } /** *

Creates a new DB proxy.

See Also:

AWS * API Reference

*/ virtual Model::CreateDBProxyOutcome CreateDBProxy(const Model::CreateDBProxyRequest& request) const; /** * A Callable wrapper for CreateDBProxy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDBProxyOutcomeCallable CreateDBProxyCallable(const CreateDBProxyRequestT& request) const { return SubmitCallable(&RDSClient::CreateDBProxy, request); } /** * An Async wrapper for CreateDBProxy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDBProxyAsync(const CreateDBProxyRequestT& request, const CreateDBProxyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateDBProxy, request, handler, context); } /** *

Creates a DBProxyEndpoint. Only applies to proxies that are * associated with Aurora DB clusters. You can use DB proxy endpoints to specify * read/write or read-only access to the DB cluster. You can also use DB proxy * endpoints to access a DB proxy through a different VPC than the proxy's default * VPC.

See Also:

AWS * API Reference

*/ virtual Model::CreateDBProxyEndpointOutcome CreateDBProxyEndpoint(const Model::CreateDBProxyEndpointRequest& request) const; /** * A Callable wrapper for CreateDBProxyEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDBProxyEndpointOutcomeCallable CreateDBProxyEndpointCallable(const CreateDBProxyEndpointRequestT& request) const { return SubmitCallable(&RDSClient::CreateDBProxyEndpoint, request); } /** * An Async wrapper for CreateDBProxyEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDBProxyEndpointAsync(const CreateDBProxyEndpointRequestT& request, const CreateDBProxyEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateDBProxyEndpoint, request, handler, context); } /** *

Creates a new DB security group. DB security groups control access to a DB * instance.

A DB security group controls access to EC2-Classic DB instances * that are not in a VPC.

EC2-Classic was retired on August 15, 2022. * If you haven't migrated from EC2-Classic to a VPC, we recommend that you migrate * as soon as possible. For more information, see Migrate * from EC2-Classic to a VPC in the Amazon EC2 User Guide, the blog EC2-Classic * Networking is Retiring – Here’s How to Prepare, and Moving * a DB instance not in a VPC into a VPC in the Amazon RDS User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateDBSecurityGroupOutcome CreateDBSecurityGroup(const Model::CreateDBSecurityGroupRequest& request) const; /** * A Callable wrapper for CreateDBSecurityGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDBSecurityGroupOutcomeCallable CreateDBSecurityGroupCallable(const CreateDBSecurityGroupRequestT& request) const { return SubmitCallable(&RDSClient::CreateDBSecurityGroup, request); } /** * An Async wrapper for CreateDBSecurityGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDBSecurityGroupAsync(const CreateDBSecurityGroupRequestT& request, const CreateDBSecurityGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateDBSecurityGroup, request, handler, context); } /** *

Creates a snapshot of a DB instance. The source DB instance must be in the * available or storage-optimization state.

See * Also:

AWS * API Reference

*/ virtual Model::CreateDBSnapshotOutcome CreateDBSnapshot(const Model::CreateDBSnapshotRequest& request) const; /** * A Callable wrapper for CreateDBSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDBSnapshotOutcomeCallable CreateDBSnapshotCallable(const CreateDBSnapshotRequestT& request) const { return SubmitCallable(&RDSClient::CreateDBSnapshot, request); } /** * An Async wrapper for CreateDBSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDBSnapshotAsync(const CreateDBSnapshotRequestT& request, const CreateDBSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateDBSnapshot, request, handler, context); } /** *

Creates a new DB subnet group. DB subnet groups must contain at least one * subnet in at least two AZs in the Amazon Web Services Region.

See * Also:

AWS * API Reference

*/ virtual Model::CreateDBSubnetGroupOutcome CreateDBSubnetGroup(const Model::CreateDBSubnetGroupRequest& request) const; /** * A Callable wrapper for CreateDBSubnetGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateDBSubnetGroupOutcomeCallable CreateDBSubnetGroupCallable(const CreateDBSubnetGroupRequestT& request) const { return SubmitCallable(&RDSClient::CreateDBSubnetGroup, request); } /** * An Async wrapper for CreateDBSubnetGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateDBSubnetGroupAsync(const CreateDBSubnetGroupRequestT& request, const CreateDBSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateDBSubnetGroup, request, handler, context); } /** *

Creates an RDS event notification subscription. This operation requires a * topic Amazon Resource Name (ARN) created by either the RDS console, the SNS * console, or the SNS API. To obtain an ARN with SNS, you must create a topic in * Amazon SNS and subscribe to the topic. The ARN is displayed in the SNS * console.

You can specify the type of source (SourceType) * that you want to be notified of and provide a list of RDS sources * (SourceIds) that triggers the events. You can also provide a list * of event categories (EventCategories) for events that you want to * be notified of. For example, you can specify SourceType = * db-instance, SourceIds = mydbinstance1, * mydbinstance2 and EventCategories = * Availability, Backup.

If you specify both the * SourceType and SourceIds, such as * SourceType = db-instance and SourceIds = * myDBInstance1, you are notified of all the db-instance * events for the specified source. If you specify a SourceType but do * not specify SourceIds, you receive notice of the events for that * source type for all your RDS sources. If you don't specify either the SourceType * or the SourceIds, you are notified of events generated from all RDS * sources belonging to your customer account.

For more information about * subscribing to an event for RDS DB engines, see * Subscribing to Amazon RDS event notification in the Amazon RDS User * Guide.

For more information about subscribing to an event for Aurora * DB engines, see * Subscribing to Amazon RDS event notification in the Amazon Aurora User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::CreateEventSubscriptionOutcome CreateEventSubscription(const Model::CreateEventSubscriptionRequest& request) const; /** * A Callable wrapper for CreateEventSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateEventSubscriptionOutcomeCallable CreateEventSubscriptionCallable(const CreateEventSubscriptionRequestT& request) const { return SubmitCallable(&RDSClient::CreateEventSubscription, request); } /** * An Async wrapper for CreateEventSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateEventSubscriptionAsync(const CreateEventSubscriptionRequestT& request, const CreateEventSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateEventSubscription, request, handler, context); } /** *

Creates an Aurora global database spread across multiple Amazon Web Services * Regions. The global database contains a single primary cluster with read-write * capability, and a read-only secondary cluster that receives data from the * primary cluster through high-speed replication performed by the Aurora storage * subsystem.

You can create a global database that is initially empty, and * then create the primary and secondary DB clusters in the global database. Or you * can specify an existing Aurora cluster during the create operation, and this * cluster becomes the primary cluster of the global database.

This * operation applies only to Aurora DB clusters.

See Also:

* AWS * API Reference

*/ virtual Model::CreateGlobalClusterOutcome CreateGlobalCluster(const Model::CreateGlobalClusterRequest& request) const; /** * A Callable wrapper for CreateGlobalCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateGlobalClusterOutcomeCallable CreateGlobalClusterCallable(const CreateGlobalClusterRequestT& request) const { return SubmitCallable(&RDSClient::CreateGlobalCluster, request); } /** * An Async wrapper for CreateGlobalCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateGlobalClusterAsync(const CreateGlobalClusterRequestT& request, const CreateGlobalClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateGlobalCluster, request, handler, context); } /** *

Creates a new option group. You can create up to 20 option groups.

*

This command doesn't apply to RDS Custom.

See Also:

AWS * API Reference

*/ virtual Model::CreateOptionGroupOutcome CreateOptionGroup(const Model::CreateOptionGroupRequest& request) const; /** * A Callable wrapper for CreateOptionGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::CreateOptionGroupOutcomeCallable CreateOptionGroupCallable(const CreateOptionGroupRequestT& request) const { return SubmitCallable(&RDSClient::CreateOptionGroup, request); } /** * An Async wrapper for CreateOptionGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void CreateOptionGroupAsync(const CreateOptionGroupRequestT& request, const CreateOptionGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::CreateOptionGroup, request, handler, context); } /** *

Deletes a blue/green deployment.

For more information, see Using * Amazon RDS Blue/Green Deployments for database updates in the Amazon RDS * User Guide and Using * Amazon RDS Blue/Green Deployments for database updates in the Amazon * Aurora User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteBlueGreenDeploymentOutcome DeleteBlueGreenDeployment(const Model::DeleteBlueGreenDeploymentRequest& request) const; /** * A Callable wrapper for DeleteBlueGreenDeployment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteBlueGreenDeploymentOutcomeCallable DeleteBlueGreenDeploymentCallable(const DeleteBlueGreenDeploymentRequestT& request) const { return SubmitCallable(&RDSClient::DeleteBlueGreenDeployment, request); } /** * An Async wrapper for DeleteBlueGreenDeployment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteBlueGreenDeploymentAsync(const DeleteBlueGreenDeploymentRequestT& request, const DeleteBlueGreenDeploymentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteBlueGreenDeployment, request, handler, context); } /** *

Deletes a custom engine version. To run this command, make sure you meet the * following prerequisites:

  • The CEV must not be the default for * RDS Custom. If it is, change the default before running this command.

    • *

  • The CEV must not be associated with an RDS Custom DB instance, RDS * Custom instance snapshot, or automated backup of your RDS Custom instance.

    *

Typically, deletion takes a few minutes.

The * MediaImport service that imports files from Amazon S3 to create CEVs isn't * integrated with Amazon Web Services CloudTrail. If you turn on data logging for * Amazon RDS in CloudTrail, calls to the DeleteCustomDbEngineVersion * event aren't logged. However, you might see calls from the API gateway that * accesses your Amazon S3 bucket. These calls originate from the MediaImport * service for the DeleteCustomDbEngineVersion event.

*

For more information, see Deleting * a CEV in the Amazon RDS User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteCustomDBEngineVersionOutcome DeleteCustomDBEngineVersion(const Model::DeleteCustomDBEngineVersionRequest& request) const; /** * A Callable wrapper for DeleteCustomDBEngineVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteCustomDBEngineVersionOutcomeCallable DeleteCustomDBEngineVersionCallable(const DeleteCustomDBEngineVersionRequestT& request) const { return SubmitCallable(&RDSClient::DeleteCustomDBEngineVersion, request); } /** * An Async wrapper for DeleteCustomDBEngineVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteCustomDBEngineVersionAsync(const DeleteCustomDBEngineVersionRequestT& request, const DeleteCustomDBEngineVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteCustomDBEngineVersion, request, handler, context); } /** *

The DeleteDBCluster action deletes a previously provisioned DB cluster. When * you delete a DB cluster, all automated backups for that DB cluster are deleted * and can't be recovered. Manual DB cluster snapshots of the specified DB cluster * are not deleted.

If you're deleting a Multi-AZ DB cluster with read * replicas, all cluster members are terminated and read replicas are promoted to * standalone instances.

For more information on Amazon Aurora, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDBClusterOutcome DeleteDBCluster(const Model::DeleteDBClusterRequest& request) const; /** * A Callable wrapper for DeleteDBCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDBClusterOutcomeCallable DeleteDBClusterCallable(const DeleteDBClusterRequestT& request) const { return SubmitCallable(&RDSClient::DeleteDBCluster, request); } /** * An Async wrapper for DeleteDBCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDBClusterAsync(const DeleteDBClusterRequestT& request, const DeleteDBClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteDBCluster, request, handler, context); } /** *

Deletes a custom endpoint and removes it from an Amazon Aurora DB * cluster.

This action only applies to Aurora DB clusters.

*

See Also:

AWS * API Reference

*/ virtual Model::DeleteDBClusterEndpointOutcome DeleteDBClusterEndpoint(const Model::DeleteDBClusterEndpointRequest& request) const; /** * A Callable wrapper for DeleteDBClusterEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDBClusterEndpointOutcomeCallable DeleteDBClusterEndpointCallable(const DeleteDBClusterEndpointRequestT& request) const { return SubmitCallable(&RDSClient::DeleteDBClusterEndpoint, request); } /** * An Async wrapper for DeleteDBClusterEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDBClusterEndpointAsync(const DeleteDBClusterEndpointRequestT& request, const DeleteDBClusterEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteDBClusterEndpoint, request, handler, context); } /** *

Deletes a specified DB cluster parameter group. The DB cluster parameter * group to be deleted can't be associated with any DB clusters.

For more * information on Amazon Aurora, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDBClusterParameterGroupOutcome DeleteDBClusterParameterGroup(const Model::DeleteDBClusterParameterGroupRequest& request) const; /** * A Callable wrapper for DeleteDBClusterParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDBClusterParameterGroupOutcomeCallable DeleteDBClusterParameterGroupCallable(const DeleteDBClusterParameterGroupRequestT& request) const { return SubmitCallable(&RDSClient::DeleteDBClusterParameterGroup, request); } /** * An Async wrapper for DeleteDBClusterParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDBClusterParameterGroupAsync(const DeleteDBClusterParameterGroupRequestT& request, const DeleteDBClusterParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteDBClusterParameterGroup, request, handler, context); } /** *

Deletes a DB cluster snapshot. If the snapshot is being copied, the copy * operation is terminated.

The DB cluster snapshot must be in the * available state to be deleted.

For more information * on Amazon Aurora, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDBClusterSnapshotOutcome DeleteDBClusterSnapshot(const Model::DeleteDBClusterSnapshotRequest& request) const; /** * A Callable wrapper for DeleteDBClusterSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDBClusterSnapshotOutcomeCallable DeleteDBClusterSnapshotCallable(const DeleteDBClusterSnapshotRequestT& request) const { return SubmitCallable(&RDSClient::DeleteDBClusterSnapshot, request); } /** * An Async wrapper for DeleteDBClusterSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDBClusterSnapshotAsync(const DeleteDBClusterSnapshotRequestT& request, const DeleteDBClusterSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteDBClusterSnapshot, request, handler, context); } /** *

The DeleteDBInstance action deletes a previously provisioned DB instance. * When you delete a DB instance, all automated backups for that instance are * deleted and can't be recovered. Manual DB snapshots of the DB instance to be * deleted by DeleteDBInstance are not deleted.

If you request * a final DB snapshot the status of the Amazon RDS DB instance is * deleting until the DB snapshot is created. The API action * DescribeDBInstance is used to monitor the status of this operation. * The action can't be canceled or reverted once submitted.

When a DB * instance is in a failure state and has a status of failed, * incompatible-restore, or incompatible-network, you can * only delete it when you skip creation of the final snapshot with the * SkipFinalSnapshot parameter.

If the specified DB instance is * part of an Amazon Aurora DB cluster, you can't delete the DB instance if both of * the following conditions are true:

  • The DB cluster is a read * replica of another Amazon Aurora DB cluster.

  • The DB instance * is the only instance in the DB cluster.

To delete a DB * instance in this case, first call the PromoteReadReplicaDBCluster * API action to promote the DB cluster so it's no longer a read replica. After the * promotion completes, then call the DeleteDBInstance API action to * delete the final instance in the DB cluster.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDBInstanceOutcome DeleteDBInstance(const Model::DeleteDBInstanceRequest& request) const; /** * A Callable wrapper for DeleteDBInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDBInstanceOutcomeCallable DeleteDBInstanceCallable(const DeleteDBInstanceRequestT& request) const { return SubmitCallable(&RDSClient::DeleteDBInstance, request); } /** * An Async wrapper for DeleteDBInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDBInstanceAsync(const DeleteDBInstanceRequestT& request, const DeleteDBInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteDBInstance, request, handler, context); } /** *

Deletes automated backups using the DbiResourceId value of the * source DB instance or the Amazon Resource Name (ARN) of the automated * backups.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDBInstanceAutomatedBackupOutcome DeleteDBInstanceAutomatedBackup(const Model::DeleteDBInstanceAutomatedBackupRequest& request) const; /** * A Callable wrapper for DeleteDBInstanceAutomatedBackup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDBInstanceAutomatedBackupOutcomeCallable DeleteDBInstanceAutomatedBackupCallable(const DeleteDBInstanceAutomatedBackupRequestT& request) const { return SubmitCallable(&RDSClient::DeleteDBInstanceAutomatedBackup, request); } /** * An Async wrapper for DeleteDBInstanceAutomatedBackup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDBInstanceAutomatedBackupAsync(const DeleteDBInstanceAutomatedBackupRequestT& request, const DeleteDBInstanceAutomatedBackupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteDBInstanceAutomatedBackup, request, handler, context); } /** *

Deletes a specified DB parameter group. The DB parameter group to be deleted * can't be associated with any DB instances.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDBParameterGroupOutcome DeleteDBParameterGroup(const Model::DeleteDBParameterGroupRequest& request) const; /** * A Callable wrapper for DeleteDBParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDBParameterGroupOutcomeCallable DeleteDBParameterGroupCallable(const DeleteDBParameterGroupRequestT& request) const { return SubmitCallable(&RDSClient::DeleteDBParameterGroup, request); } /** * An Async wrapper for DeleteDBParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDBParameterGroupAsync(const DeleteDBParameterGroupRequestT& request, const DeleteDBParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteDBParameterGroup, request, handler, context); } /** *

Deletes an existing DB proxy.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDBProxyOutcome DeleteDBProxy(const Model::DeleteDBProxyRequest& request) const; /** * A Callable wrapper for DeleteDBProxy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDBProxyOutcomeCallable DeleteDBProxyCallable(const DeleteDBProxyRequestT& request) const { return SubmitCallable(&RDSClient::DeleteDBProxy, request); } /** * An Async wrapper for DeleteDBProxy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDBProxyAsync(const DeleteDBProxyRequestT& request, const DeleteDBProxyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteDBProxy, request, handler, context); } /** *

Deletes a DBProxyEndpoint. Doing so removes the ability to * access the DB proxy using the endpoint that you defined. The endpoint that you * delete might have provided capabilities such as read/write or read-only * operations, or using a different VPC than the DB proxy's default * VPC.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDBProxyEndpointOutcome DeleteDBProxyEndpoint(const Model::DeleteDBProxyEndpointRequest& request) const; /** * A Callable wrapper for DeleteDBProxyEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDBProxyEndpointOutcomeCallable DeleteDBProxyEndpointCallable(const DeleteDBProxyEndpointRequestT& request) const { return SubmitCallable(&RDSClient::DeleteDBProxyEndpoint, request); } /** * An Async wrapper for DeleteDBProxyEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDBProxyEndpointAsync(const DeleteDBProxyEndpointRequestT& request, const DeleteDBProxyEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteDBProxyEndpoint, request, handler, context); } /** *

Deletes a DB security group.

The specified DB security group must not * be associated with any DB instances.

EC2-Classic was retired on * August 15, 2022. If you haven't migrated from EC2-Classic to a VPC, we recommend * that you migrate as soon as possible. For more information, see Migrate * from EC2-Classic to a VPC in the Amazon EC2 User Guide, the blog EC2-Classic * Networking is Retiring – Here’s How to Prepare, and Moving * a DB instance not in a VPC into a VPC in the Amazon RDS User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDBSecurityGroupOutcome DeleteDBSecurityGroup(const Model::DeleteDBSecurityGroupRequest& request) const; /** * A Callable wrapper for DeleteDBSecurityGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDBSecurityGroupOutcomeCallable DeleteDBSecurityGroupCallable(const DeleteDBSecurityGroupRequestT& request) const { return SubmitCallable(&RDSClient::DeleteDBSecurityGroup, request); } /** * An Async wrapper for DeleteDBSecurityGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDBSecurityGroupAsync(const DeleteDBSecurityGroupRequestT& request, const DeleteDBSecurityGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteDBSecurityGroup, request, handler, context); } /** *

Deletes a DB snapshot. If the snapshot is being copied, the copy operation is * terminated.

The DB snapshot must be in the available * state to be deleted.

See Also:

AWS * API Reference

*/ virtual Model::DeleteDBSnapshotOutcome DeleteDBSnapshot(const Model::DeleteDBSnapshotRequest& request) const; /** * A Callable wrapper for DeleteDBSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDBSnapshotOutcomeCallable DeleteDBSnapshotCallable(const DeleteDBSnapshotRequestT& request) const { return SubmitCallable(&RDSClient::DeleteDBSnapshot, request); } /** * An Async wrapper for DeleteDBSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDBSnapshotAsync(const DeleteDBSnapshotRequestT& request, const DeleteDBSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteDBSnapshot, request, handler, context); } /** *

Deletes a DB subnet group.

The specified database subnet group * must not be associated with any DB instances.

See Also:

* AWS * API Reference

*/ virtual Model::DeleteDBSubnetGroupOutcome DeleteDBSubnetGroup(const Model::DeleteDBSubnetGroupRequest& request) const; /** * A Callable wrapper for DeleteDBSubnetGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteDBSubnetGroupOutcomeCallable DeleteDBSubnetGroupCallable(const DeleteDBSubnetGroupRequestT& request) const { return SubmitCallable(&RDSClient::DeleteDBSubnetGroup, request); } /** * An Async wrapper for DeleteDBSubnetGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteDBSubnetGroupAsync(const DeleteDBSubnetGroupRequestT& request, const DeleteDBSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteDBSubnetGroup, request, handler, context); } /** *

Deletes an RDS event notification subscription.

See Also:

AWS * API Reference

*/ virtual Model::DeleteEventSubscriptionOutcome DeleteEventSubscription(const Model::DeleteEventSubscriptionRequest& request) const; /** * A Callable wrapper for DeleteEventSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteEventSubscriptionOutcomeCallable DeleteEventSubscriptionCallable(const DeleteEventSubscriptionRequestT& request) const { return SubmitCallable(&RDSClient::DeleteEventSubscription, request); } /** * An Async wrapper for DeleteEventSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteEventSubscriptionAsync(const DeleteEventSubscriptionRequestT& request, const DeleteEventSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteEventSubscription, request, handler, context); } /** *

Deletes a global database cluster. The primary and secondary clusters must * already be detached or destroyed first.

This action only applies * to Aurora DB clusters.

See Also:

AWS * API Reference

*/ virtual Model::DeleteGlobalClusterOutcome DeleteGlobalCluster(const Model::DeleteGlobalClusterRequest& request) const; /** * A Callable wrapper for DeleteGlobalCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteGlobalClusterOutcomeCallable DeleteGlobalClusterCallable(const DeleteGlobalClusterRequestT& request) const { return SubmitCallable(&RDSClient::DeleteGlobalCluster, request); } /** * An Async wrapper for DeleteGlobalCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteGlobalClusterAsync(const DeleteGlobalClusterRequestT& request, const DeleteGlobalClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteGlobalCluster, request, handler, context); } /** *

Deletes an existing option group.

See Also:

AWS * API Reference

*/ virtual Model::DeleteOptionGroupOutcome DeleteOptionGroup(const Model::DeleteOptionGroupRequest& request) const; /** * A Callable wrapper for DeleteOptionGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeleteOptionGroupOutcomeCallable DeleteOptionGroupCallable(const DeleteOptionGroupRequestT& request) const { return SubmitCallable(&RDSClient::DeleteOptionGroup, request); } /** * An Async wrapper for DeleteOptionGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeleteOptionGroupAsync(const DeleteOptionGroupRequestT& request, const DeleteOptionGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeleteOptionGroup, request, handler, context); } /** *

Remove the association between one or more DBProxyTarget data * structures and a DBProxyTargetGroup.

See Also:

AWS * API Reference

*/ virtual Model::DeregisterDBProxyTargetsOutcome DeregisterDBProxyTargets(const Model::DeregisterDBProxyTargetsRequest& request) const; /** * A Callable wrapper for DeregisterDBProxyTargets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DeregisterDBProxyTargetsOutcomeCallable DeregisterDBProxyTargetsCallable(const DeregisterDBProxyTargetsRequestT& request) const { return SubmitCallable(&RDSClient::DeregisterDBProxyTargets, request); } /** * An Async wrapper for DeregisterDBProxyTargets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DeregisterDBProxyTargetsAsync(const DeregisterDBProxyTargetsRequestT& request, const DeregisterDBProxyTargetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DeregisterDBProxyTargets, request, handler, context); } /** *

Lists all of the attributes for a customer account. The attributes include * Amazon RDS quotas for the account, such as the number of DB instances allowed. * The description for a quota includes the quota name, current usage toward that * quota, and the quota's maximum value.

This command doesn't take any * parameters.

See Also:

AWS * API Reference

*/ virtual Model::DescribeAccountAttributesOutcome DescribeAccountAttributes(const Model::DescribeAccountAttributesRequest& request) const; /** * A Callable wrapper for DescribeAccountAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeAccountAttributesOutcomeCallable DescribeAccountAttributesCallable(const DescribeAccountAttributesRequestT& request) const { return SubmitCallable(&RDSClient::DescribeAccountAttributes, request); } /** * An Async wrapper for DescribeAccountAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeAccountAttributesAsync(const DescribeAccountAttributesRequestT& request, const DescribeAccountAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeAccountAttributes, request, handler, context); } /** *

Describes one or more blue/green deployments.

For more information, * see Using * Amazon RDS Blue/Green Deployments for database updates in the Amazon RDS * User Guide and * Using Amazon RDS Blue/Green Deployments for database updates in the * Amazon Aurora User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeBlueGreenDeploymentsOutcome DescribeBlueGreenDeployments(const Model::DescribeBlueGreenDeploymentsRequest& request) const; /** * A Callable wrapper for DescribeBlueGreenDeployments that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeBlueGreenDeploymentsOutcomeCallable DescribeBlueGreenDeploymentsCallable(const DescribeBlueGreenDeploymentsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeBlueGreenDeployments, request); } /** * An Async wrapper for DescribeBlueGreenDeployments that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeBlueGreenDeploymentsAsync(const DescribeBlueGreenDeploymentsRequestT& request, const DescribeBlueGreenDeploymentsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeBlueGreenDeployments, request, handler, context); } /** *

Lists the set of CA certificates provided by Amazon RDS for this Amazon Web * Services account.

For more information, see Using * SSL/TLS to encrypt a connection to a DB instance in the Amazon RDS User * Guide and * Using SSL/TLS to encrypt a connection to a DB cluster in the Amazon * Aurora User Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeCertificatesOutcome DescribeCertificates(const Model::DescribeCertificatesRequest& request) const; /** * A Callable wrapper for DescribeCertificates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeCertificatesOutcomeCallable DescribeCertificatesCallable(const DescribeCertificatesRequestT& request) const { return SubmitCallable(&RDSClient::DescribeCertificates, request); } /** * An Async wrapper for DescribeCertificates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeCertificatesAsync(const DescribeCertificatesRequestT& request, const DescribeCertificatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeCertificates, request, handler, context); } /** *

Returns information about backtracks for a DB cluster.

For more * information on Amazon Aurora, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

*

This action only applies to Aurora MySQL DB clusters.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeDBClusterBacktracksOutcome DescribeDBClusterBacktracks(const Model::DescribeDBClusterBacktracksRequest& request) const; /** * A Callable wrapper for DescribeDBClusterBacktracks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBClusterBacktracksOutcomeCallable DescribeDBClusterBacktracksCallable(const DescribeDBClusterBacktracksRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBClusterBacktracks, request); } /** * An Async wrapper for DescribeDBClusterBacktracks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBClusterBacktracksAsync(const DescribeDBClusterBacktracksRequestT& request, const DescribeDBClusterBacktracksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBClusterBacktracks, request, handler, context); } /** *

Returns information about endpoints for an Amazon Aurora DB cluster.

*

This action only applies to Aurora DB clusters.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeDBClusterEndpointsOutcome DescribeDBClusterEndpoints(const Model::DescribeDBClusterEndpointsRequest& request) const; /** * A Callable wrapper for DescribeDBClusterEndpoints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBClusterEndpointsOutcomeCallable DescribeDBClusterEndpointsCallable(const DescribeDBClusterEndpointsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBClusterEndpoints, request); } /** * An Async wrapper for DescribeDBClusterEndpoints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBClusterEndpointsAsync(const DescribeDBClusterEndpointsRequestT& request, const DescribeDBClusterEndpointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBClusterEndpoints, request, handler, context); } /** *

Returns a list of DBClusterParameterGroup descriptions. If a * DBClusterParameterGroupName parameter is specified, the list will * contain only the description of the specified DB cluster parameter group.

*

For more information on Amazon Aurora, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBClusterParameterGroupsOutcome DescribeDBClusterParameterGroups(const Model::DescribeDBClusterParameterGroupsRequest& request) const; /** * A Callable wrapper for DescribeDBClusterParameterGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBClusterParameterGroupsOutcomeCallable DescribeDBClusterParameterGroupsCallable(const DescribeDBClusterParameterGroupsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBClusterParameterGroups, request); } /** * An Async wrapper for DescribeDBClusterParameterGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBClusterParameterGroupsAsync(const DescribeDBClusterParameterGroupsRequestT& request, const DescribeDBClusterParameterGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBClusterParameterGroups, request, handler, context); } /** *

Returns the detailed parameter list for a particular DB cluster parameter * group.

For more information on Amazon Aurora, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBClusterParametersOutcome DescribeDBClusterParameters(const Model::DescribeDBClusterParametersRequest& request) const; /** * A Callable wrapper for DescribeDBClusterParameters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBClusterParametersOutcomeCallable DescribeDBClusterParametersCallable(const DescribeDBClusterParametersRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBClusterParameters, request); } /** * An Async wrapper for DescribeDBClusterParameters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBClusterParametersAsync(const DescribeDBClusterParametersRequestT& request, const DescribeDBClusterParametersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBClusterParameters, request, handler, context); } /** *

Returns a list of DB cluster snapshot attribute names and values for a manual * DB cluster snapshot.

When sharing snapshots with other Amazon Web * Services accounts, DescribeDBClusterSnapshotAttributes returns the * restore attribute and a list of IDs for the Amazon Web Services * accounts that are authorized to copy or restore the manual DB cluster snapshot. * If all is included in the list of values for the * restore attribute, then the manual DB cluster snapshot is public * and can be copied or restored by all Amazon Web Services accounts.

To add * or remove access for an Amazon Web Services account to copy or restore a manual * DB cluster snapshot, or to make the manual DB cluster snapshot public or * private, use the ModifyDBClusterSnapshotAttribute API * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBClusterSnapshotAttributesOutcome DescribeDBClusterSnapshotAttributes(const Model::DescribeDBClusterSnapshotAttributesRequest& request) const; /** * A Callable wrapper for DescribeDBClusterSnapshotAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBClusterSnapshotAttributesOutcomeCallable DescribeDBClusterSnapshotAttributesCallable(const DescribeDBClusterSnapshotAttributesRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBClusterSnapshotAttributes, request); } /** * An Async wrapper for DescribeDBClusterSnapshotAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBClusterSnapshotAttributesAsync(const DescribeDBClusterSnapshotAttributesRequestT& request, const DescribeDBClusterSnapshotAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBClusterSnapshotAttributes, request, handler, context); } /** *

Returns information about DB cluster snapshots. This API action supports * pagination.

For more information on Amazon Aurora DB clusters, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBClusterSnapshotsOutcome DescribeDBClusterSnapshots(const Model::DescribeDBClusterSnapshotsRequest& request) const; /** * A Callable wrapper for DescribeDBClusterSnapshots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBClusterSnapshotsOutcomeCallable DescribeDBClusterSnapshotsCallable(const DescribeDBClusterSnapshotsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBClusterSnapshots, request); } /** * An Async wrapper for DescribeDBClusterSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBClusterSnapshotsAsync(const DescribeDBClusterSnapshotsRequestT& request, const DescribeDBClusterSnapshotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBClusterSnapshots, request, handler, context); } /** *

Describes existing Amazon Aurora DB clusters and Multi-AZ DB clusters. This * API supports pagination.

For more information on Amazon Aurora DB * clusters, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User Guide.

*

This operation can also return information for Amazon Neptune DB instances * and Amazon DocumentDB instances.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBClustersOutcome DescribeDBClusters(const Model::DescribeDBClustersRequest& request) const; /** * A Callable wrapper for DescribeDBClusters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBClustersOutcomeCallable DescribeDBClustersCallable(const DescribeDBClustersRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBClusters, request); } /** * An Async wrapper for DescribeDBClusters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBClustersAsync(const DescribeDBClustersRequestT& request, const DescribeDBClustersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBClusters, request, handler, context); } /** *

Returns a list of the available DB engines.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBEngineVersionsOutcome DescribeDBEngineVersions(const Model::DescribeDBEngineVersionsRequest& request) const; /** * A Callable wrapper for DescribeDBEngineVersions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBEngineVersionsOutcomeCallable DescribeDBEngineVersionsCallable(const DescribeDBEngineVersionsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBEngineVersions, request); } /** * An Async wrapper for DescribeDBEngineVersions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBEngineVersionsAsync(const DescribeDBEngineVersionsRequestT& request, const DescribeDBEngineVersionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBEngineVersions, request, handler, context); } /** *

Displays backups for both current and deleted instances. For example, use * this operation to find details about automated backups for previously deleted * instances. Current instances with retention periods greater than zero (0) are * returned for both the DescribeDBInstanceAutomatedBackups and * DescribeDBInstances operations.

All parameters are * optional.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBInstanceAutomatedBackupsOutcome DescribeDBInstanceAutomatedBackups(const Model::DescribeDBInstanceAutomatedBackupsRequest& request) const; /** * A Callable wrapper for DescribeDBInstanceAutomatedBackups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBInstanceAutomatedBackupsOutcomeCallable DescribeDBInstanceAutomatedBackupsCallable(const DescribeDBInstanceAutomatedBackupsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBInstanceAutomatedBackups, request); } /** * An Async wrapper for DescribeDBInstanceAutomatedBackups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBInstanceAutomatedBackupsAsync(const DescribeDBInstanceAutomatedBackupsRequestT& request, const DescribeDBInstanceAutomatedBackupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBInstanceAutomatedBackups, request, handler, context); } /** *

Describes provisioned RDS instances. This API supports pagination.

*

This operation can also return information for Amazon Neptune DB instances * and Amazon DocumentDB instances.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBInstancesOutcome DescribeDBInstances(const Model::DescribeDBInstancesRequest& request) const; /** * A Callable wrapper for DescribeDBInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBInstancesOutcomeCallable DescribeDBInstancesCallable(const DescribeDBInstancesRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBInstances, request); } /** * An Async wrapper for DescribeDBInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBInstancesAsync(const DescribeDBInstancesRequestT& request, const DescribeDBInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBInstances, request, handler, context); } /** *

Returns a list of DB log files for the DB instance.

This command * doesn't apply to RDS Custom.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBLogFilesOutcome DescribeDBLogFiles(const Model::DescribeDBLogFilesRequest& request) const; /** * A Callable wrapper for DescribeDBLogFiles that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBLogFilesOutcomeCallable DescribeDBLogFilesCallable(const DescribeDBLogFilesRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBLogFiles, request); } /** * An Async wrapper for DescribeDBLogFiles that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBLogFilesAsync(const DescribeDBLogFilesRequestT& request, const DescribeDBLogFilesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBLogFiles, request, handler, context); } /** *

Returns a list of DBParameterGroup descriptions. If a * DBParameterGroupName is specified, the list will contain only the * description of the specified DB parameter group.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBParameterGroupsOutcome DescribeDBParameterGroups(const Model::DescribeDBParameterGroupsRequest& request) const; /** * A Callable wrapper for DescribeDBParameterGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBParameterGroupsOutcomeCallable DescribeDBParameterGroupsCallable(const DescribeDBParameterGroupsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBParameterGroups, request); } /** * An Async wrapper for DescribeDBParameterGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBParameterGroupsAsync(const DescribeDBParameterGroupsRequestT& request, const DescribeDBParameterGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBParameterGroups, request, handler, context); } /** *

Returns the detailed parameter list for a particular DB parameter * group.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBParametersOutcome DescribeDBParameters(const Model::DescribeDBParametersRequest& request) const; /** * A Callable wrapper for DescribeDBParameters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBParametersOutcomeCallable DescribeDBParametersCallable(const DescribeDBParametersRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBParameters, request); } /** * An Async wrapper for DescribeDBParameters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBParametersAsync(const DescribeDBParametersRequestT& request, const DescribeDBParametersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBParameters, request, handler, context); } /** *

Returns information about DB proxies.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBProxiesOutcome DescribeDBProxies(const Model::DescribeDBProxiesRequest& request) const; /** * A Callable wrapper for DescribeDBProxies that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBProxiesOutcomeCallable DescribeDBProxiesCallable(const DescribeDBProxiesRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBProxies, request); } /** * An Async wrapper for DescribeDBProxies that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBProxiesAsync(const DescribeDBProxiesRequestT& request, const DescribeDBProxiesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBProxies, request, handler, context); } /** *

Returns information about DB proxy endpoints.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBProxyEndpointsOutcome DescribeDBProxyEndpoints(const Model::DescribeDBProxyEndpointsRequest& request) const; /** * A Callable wrapper for DescribeDBProxyEndpoints that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBProxyEndpointsOutcomeCallable DescribeDBProxyEndpointsCallable(const DescribeDBProxyEndpointsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBProxyEndpoints, request); } /** * An Async wrapper for DescribeDBProxyEndpoints that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBProxyEndpointsAsync(const DescribeDBProxyEndpointsRequestT& request, const DescribeDBProxyEndpointsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBProxyEndpoints, request, handler, context); } /** *

Returns information about DB proxy target groups, represented by * DBProxyTargetGroup data structures.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBProxyTargetGroupsOutcome DescribeDBProxyTargetGroups(const Model::DescribeDBProxyTargetGroupsRequest& request) const; /** * A Callable wrapper for DescribeDBProxyTargetGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBProxyTargetGroupsOutcomeCallable DescribeDBProxyTargetGroupsCallable(const DescribeDBProxyTargetGroupsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBProxyTargetGroups, request); } /** * An Async wrapper for DescribeDBProxyTargetGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBProxyTargetGroupsAsync(const DescribeDBProxyTargetGroupsRequestT& request, const DescribeDBProxyTargetGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBProxyTargetGroups, request, handler, context); } /** *

Returns information about DBProxyTarget objects. This API * supports pagination.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBProxyTargetsOutcome DescribeDBProxyTargets(const Model::DescribeDBProxyTargetsRequest& request) const; /** * A Callable wrapper for DescribeDBProxyTargets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBProxyTargetsOutcomeCallable DescribeDBProxyTargetsCallable(const DescribeDBProxyTargetsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBProxyTargets, request); } /** * An Async wrapper for DescribeDBProxyTargets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBProxyTargetsAsync(const DescribeDBProxyTargetsRequestT& request, const DescribeDBProxyTargetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBProxyTargets, request, handler, context); } /** *

Returns a list of DBSecurityGroup descriptions. If a * DBSecurityGroupName is specified, the list will contain only the * descriptions of the specified DB security group.

EC2-Classic was * retired on August 15, 2022. If you haven't migrated from EC2-Classic to a VPC, * we recommend that you migrate as soon as possible. For more information, see Migrate * from EC2-Classic to a VPC in the Amazon EC2 User Guide, the blog EC2-Classic * Networking is Retiring – Here’s How to Prepare, and Moving * a DB instance not in a VPC into a VPC in the Amazon RDS User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBSecurityGroupsOutcome DescribeDBSecurityGroups(const Model::DescribeDBSecurityGroupsRequest& request) const; /** * A Callable wrapper for DescribeDBSecurityGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBSecurityGroupsOutcomeCallable DescribeDBSecurityGroupsCallable(const DescribeDBSecurityGroupsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBSecurityGroups, request); } /** * An Async wrapper for DescribeDBSecurityGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBSecurityGroupsAsync(const DescribeDBSecurityGroupsRequestT& request, const DescribeDBSecurityGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBSecurityGroups, request, handler, context); } /** *

Returns a list of DB snapshot attribute names and values for a manual DB * snapshot.

When sharing snapshots with other Amazon Web Services accounts, * DescribeDBSnapshotAttributes returns the restore * attribute and a list of IDs for the Amazon Web Services accounts that are * authorized to copy or restore the manual DB snapshot. If all is * included in the list of values for the restore attribute, then the * manual DB snapshot is public and can be copied or restored by all Amazon Web * Services accounts.

To add or remove access for an Amazon Web Services * account to copy or restore a manual DB snapshot, or to make the manual DB * snapshot public or private, use the ModifyDBSnapshotAttribute API * action.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBSnapshotAttributesOutcome DescribeDBSnapshotAttributes(const Model::DescribeDBSnapshotAttributesRequest& request) const; /** * A Callable wrapper for DescribeDBSnapshotAttributes that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBSnapshotAttributesOutcomeCallable DescribeDBSnapshotAttributesCallable(const DescribeDBSnapshotAttributesRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBSnapshotAttributes, request); } /** * An Async wrapper for DescribeDBSnapshotAttributes that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBSnapshotAttributesAsync(const DescribeDBSnapshotAttributesRequestT& request, const DescribeDBSnapshotAttributesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBSnapshotAttributes, request, handler, context); } /** *

Returns information about DB snapshots. This API action supports * pagination.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBSnapshotsOutcome DescribeDBSnapshots(const Model::DescribeDBSnapshotsRequest& request) const; /** * A Callable wrapper for DescribeDBSnapshots that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBSnapshotsOutcomeCallable DescribeDBSnapshotsCallable(const DescribeDBSnapshotsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBSnapshots, request); } /** * An Async wrapper for DescribeDBSnapshots that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBSnapshotsAsync(const DescribeDBSnapshotsRequestT& request, const DescribeDBSnapshotsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBSnapshots, request, handler, context); } /** *

Returns a list of DBSubnetGroup descriptions. If a DBSubnetGroupName is * specified, the list will contain only the descriptions of the specified * DBSubnetGroup.

For an overview of CIDR ranges, go to the Wikipedia * Tutorial.

See Also:

AWS * API Reference

*/ virtual Model::DescribeDBSubnetGroupsOutcome DescribeDBSubnetGroups(const Model::DescribeDBSubnetGroupsRequest& request) const; /** * A Callable wrapper for DescribeDBSubnetGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeDBSubnetGroupsOutcomeCallable DescribeDBSubnetGroupsCallable(const DescribeDBSubnetGroupsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeDBSubnetGroups, request); } /** * An Async wrapper for DescribeDBSubnetGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeDBSubnetGroupsAsync(const DescribeDBSubnetGroupsRequestT& request, const DescribeDBSubnetGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeDBSubnetGroups, request, handler, context); } /** *

Returns the default engine and system parameter information for the cluster * database engine.

For more information on Amazon Aurora, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeEngineDefaultClusterParametersOutcome DescribeEngineDefaultClusterParameters(const Model::DescribeEngineDefaultClusterParametersRequest& request) const; /** * A Callable wrapper for DescribeEngineDefaultClusterParameters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEngineDefaultClusterParametersOutcomeCallable DescribeEngineDefaultClusterParametersCallable(const DescribeEngineDefaultClusterParametersRequestT& request) const { return SubmitCallable(&RDSClient::DescribeEngineDefaultClusterParameters, request); } /** * An Async wrapper for DescribeEngineDefaultClusterParameters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEngineDefaultClusterParametersAsync(const DescribeEngineDefaultClusterParametersRequestT& request, const DescribeEngineDefaultClusterParametersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeEngineDefaultClusterParameters, request, handler, context); } /** *

Returns the default engine and system parameter information for the specified * database engine.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEngineDefaultParametersOutcome DescribeEngineDefaultParameters(const Model::DescribeEngineDefaultParametersRequest& request) const; /** * A Callable wrapper for DescribeEngineDefaultParameters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEngineDefaultParametersOutcomeCallable DescribeEngineDefaultParametersCallable(const DescribeEngineDefaultParametersRequestT& request) const { return SubmitCallable(&RDSClient::DescribeEngineDefaultParameters, request); } /** * An Async wrapper for DescribeEngineDefaultParameters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEngineDefaultParametersAsync(const DescribeEngineDefaultParametersRequestT& request, const DescribeEngineDefaultParametersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeEngineDefaultParameters, request, handler, context); } /** *

Displays a list of categories for all event source types, or, if specified, * for a specified source type. You can also see this list in the "Amazon RDS event * categories and event messages" section of the * Amazon RDS User Guide or the * Amazon Aurora User Guide .

See Also:

AWS * API Reference

*/ virtual Model::DescribeEventCategoriesOutcome DescribeEventCategories(const Model::DescribeEventCategoriesRequest& request) const; /** * A Callable wrapper for DescribeEventCategories that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEventCategoriesOutcomeCallable DescribeEventCategoriesCallable(const DescribeEventCategoriesRequestT& request) const { return SubmitCallable(&RDSClient::DescribeEventCategories, request); } /** * An Async wrapper for DescribeEventCategories that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEventCategoriesAsync(const DescribeEventCategoriesRequestT& request, const DescribeEventCategoriesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeEventCategories, request, handler, context); } /** *

Lists all the subscription descriptions for a customer account. The * description for a subscription includes SubscriptionName, * SNSTopicARN, CustomerID, SourceType, * SourceID, CreationTime, and Status.

*

If you specify a SubscriptionName, lists the description for * that subscription.

See Also:

AWS * API Reference

*/ virtual Model::DescribeEventSubscriptionsOutcome DescribeEventSubscriptions(const Model::DescribeEventSubscriptionsRequest& request) const; /** * A Callable wrapper for DescribeEventSubscriptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEventSubscriptionsOutcomeCallable DescribeEventSubscriptionsCallable(const DescribeEventSubscriptionsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeEventSubscriptions, request); } /** * An Async wrapper for DescribeEventSubscriptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEventSubscriptionsAsync(const DescribeEventSubscriptionsRequestT& request, const DescribeEventSubscriptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeEventSubscriptions, request, handler, context); } /** *

Returns events related to DB instances, DB clusters, DB parameter groups, DB * security groups, DB snapshots, DB cluster snapshots, and RDS Proxies for the * past 14 days. Events specific to a particular DB instance, DB cluster, DB * parameter group, DB security group, DB snapshot, DB cluster snapshot group, or * RDS Proxy can be obtained by providing the name as a parameter.

For more * information on working with events, see Monitoring * Amazon RDS events in the Amazon RDS User Guide and Monitoring * Amazon Aurora events in the Amazon Aurora User Guide.

*

By default, RDS returns events that were generated in the past hour.

*

See Also:

AWS * API Reference

*/ virtual Model::DescribeEventsOutcome DescribeEvents(const Model::DescribeEventsRequest& request) const; /** * A Callable wrapper for DescribeEvents that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeEventsOutcomeCallable DescribeEventsCallable(const DescribeEventsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeEvents, request); } /** * An Async wrapper for DescribeEvents that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeEventsAsync(const DescribeEventsRequestT& request, const DescribeEventsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeEvents, request, handler, context); } /** *

Returns information about a snapshot or cluster export to Amazon S3. This API * operation supports pagination.

See Also:

AWS * API Reference

*/ virtual Model::DescribeExportTasksOutcome DescribeExportTasks(const Model::DescribeExportTasksRequest& request) const; /** * A Callable wrapper for DescribeExportTasks that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeExportTasksOutcomeCallable DescribeExportTasksCallable(const DescribeExportTasksRequestT& request) const { return SubmitCallable(&RDSClient::DescribeExportTasks, request); } /** * An Async wrapper for DescribeExportTasks that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeExportTasksAsync(const DescribeExportTasksRequestT& request, const DescribeExportTasksResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeExportTasks, request, handler, context); } /** *

Returns information about Aurora global database clusters. This API supports * pagination.

For more information on Amazon Aurora, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

*

This action only applies to Aurora DB clusters.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeGlobalClustersOutcome DescribeGlobalClusters(const Model::DescribeGlobalClustersRequest& request) const; /** * A Callable wrapper for DescribeGlobalClusters that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeGlobalClustersOutcomeCallable DescribeGlobalClustersCallable(const DescribeGlobalClustersRequestT& request) const { return SubmitCallable(&RDSClient::DescribeGlobalClusters, request); } /** * An Async wrapper for DescribeGlobalClusters that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeGlobalClustersAsync(const DescribeGlobalClustersRequestT& request, const DescribeGlobalClustersResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeGlobalClusters, request, handler, context); } /** *

Describes all available options.

See Also:

AWS * API Reference

*/ virtual Model::DescribeOptionGroupOptionsOutcome DescribeOptionGroupOptions(const Model::DescribeOptionGroupOptionsRequest& request) const; /** * A Callable wrapper for DescribeOptionGroupOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeOptionGroupOptionsOutcomeCallable DescribeOptionGroupOptionsCallable(const DescribeOptionGroupOptionsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeOptionGroupOptions, request); } /** * An Async wrapper for DescribeOptionGroupOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeOptionGroupOptionsAsync(const DescribeOptionGroupOptionsRequestT& request, const DescribeOptionGroupOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeOptionGroupOptions, request, handler, context); } /** *

Describes the available option groups.

See Also:

AWS * API Reference

*/ virtual Model::DescribeOptionGroupsOutcome DescribeOptionGroups(const Model::DescribeOptionGroupsRequest& request) const; /** * A Callable wrapper for DescribeOptionGroups that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeOptionGroupsOutcomeCallable DescribeOptionGroupsCallable(const DescribeOptionGroupsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeOptionGroups, request); } /** * An Async wrapper for DescribeOptionGroups that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeOptionGroupsAsync(const DescribeOptionGroupsRequestT& request, const DescribeOptionGroupsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeOptionGroups, request, handler, context); } /** *

Returns a list of orderable DB instance options for the specified DB engine, * DB engine version, and DB instance class.

See Also:

AWS * API Reference

*/ virtual Model::DescribeOrderableDBInstanceOptionsOutcome DescribeOrderableDBInstanceOptions(const Model::DescribeOrderableDBInstanceOptionsRequest& request) const; /** * A Callable wrapper for DescribeOrderableDBInstanceOptions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeOrderableDBInstanceOptionsOutcomeCallable DescribeOrderableDBInstanceOptionsCallable(const DescribeOrderableDBInstanceOptionsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeOrderableDBInstanceOptions, request); } /** * An Async wrapper for DescribeOrderableDBInstanceOptions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeOrderableDBInstanceOptionsAsync(const DescribeOrderableDBInstanceOptionsRequestT& request, const DescribeOrderableDBInstanceOptionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeOrderableDBInstanceOptions, request, handler, context); } /** *

Returns a list of resources (for example, DB instances) that have at least * one pending maintenance action.

See Also:

AWS * API Reference

*/ virtual Model::DescribePendingMaintenanceActionsOutcome DescribePendingMaintenanceActions(const Model::DescribePendingMaintenanceActionsRequest& request) const; /** * A Callable wrapper for DescribePendingMaintenanceActions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribePendingMaintenanceActionsOutcomeCallable DescribePendingMaintenanceActionsCallable(const DescribePendingMaintenanceActionsRequestT& request) const { return SubmitCallable(&RDSClient::DescribePendingMaintenanceActions, request); } /** * An Async wrapper for DescribePendingMaintenanceActions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribePendingMaintenanceActionsAsync(const DescribePendingMaintenanceActionsRequestT& request, const DescribePendingMaintenanceActionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribePendingMaintenanceActions, request, handler, context); } /** *

Returns information about reserved DB instances for this account, or about a * specified reserved DB instance.

See Also:

AWS * API Reference

*/ virtual Model::DescribeReservedDBInstancesOutcome DescribeReservedDBInstances(const Model::DescribeReservedDBInstancesRequest& request) const; /** * A Callable wrapper for DescribeReservedDBInstances that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeReservedDBInstancesOutcomeCallable DescribeReservedDBInstancesCallable(const DescribeReservedDBInstancesRequestT& request) const { return SubmitCallable(&RDSClient::DescribeReservedDBInstances, request); } /** * An Async wrapper for DescribeReservedDBInstances that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeReservedDBInstancesAsync(const DescribeReservedDBInstancesRequestT& request, const DescribeReservedDBInstancesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeReservedDBInstances, request, handler, context); } /** *

Lists available reserved DB instance offerings.

See Also:

AWS * API Reference

*/ virtual Model::DescribeReservedDBInstancesOfferingsOutcome DescribeReservedDBInstancesOfferings(const Model::DescribeReservedDBInstancesOfferingsRequest& request) const; /** * A Callable wrapper for DescribeReservedDBInstancesOfferings that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeReservedDBInstancesOfferingsOutcomeCallable DescribeReservedDBInstancesOfferingsCallable(const DescribeReservedDBInstancesOfferingsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeReservedDBInstancesOfferings, request); } /** * An Async wrapper for DescribeReservedDBInstancesOfferings that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeReservedDBInstancesOfferingsAsync(const DescribeReservedDBInstancesOfferingsRequestT& request, const DescribeReservedDBInstancesOfferingsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeReservedDBInstancesOfferings, request, handler, context); } /** *

Returns a list of the source Amazon Web Services Regions where the current * Amazon Web Services Region can create a read replica, copy a DB snapshot from, * or replicate automated backups from.

Use this operation to determine * whether cross-Region features are supported between other Regions and your * current Region. This operation supports pagination.

To return information * about the Regions that are enabled for your account, or all Regions, use the EC2 * operation DescribeRegions. For more information, see * DescribeRegions in the Amazon EC2 API Reference.

See * Also:

AWS * API Reference

*/ virtual Model::DescribeSourceRegionsOutcome DescribeSourceRegions(const Model::DescribeSourceRegionsRequest& request) const; /** * A Callable wrapper for DescribeSourceRegions that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeSourceRegionsOutcomeCallable DescribeSourceRegionsCallable(const DescribeSourceRegionsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeSourceRegions, request); } /** * An Async wrapper for DescribeSourceRegions that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeSourceRegionsAsync(const DescribeSourceRegionsRequestT& request, const DescribeSourceRegionsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeSourceRegions, request, handler, context); } /** *

You can call DescribeValidDBInstanceModifications to learn what * modifications you can make to your DB instance. You can use this information * when you call ModifyDBInstance.

This command doesn't apply * to RDS Custom.

See Also:

AWS * API Reference

*/ virtual Model::DescribeValidDBInstanceModificationsOutcome DescribeValidDBInstanceModifications(const Model::DescribeValidDBInstanceModificationsRequest& request) const; /** * A Callable wrapper for DescribeValidDBInstanceModifications that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DescribeValidDBInstanceModificationsOutcomeCallable DescribeValidDBInstanceModificationsCallable(const DescribeValidDBInstanceModificationsRequestT& request) const { return SubmitCallable(&RDSClient::DescribeValidDBInstanceModifications, request); } /** * An Async wrapper for DescribeValidDBInstanceModifications that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DescribeValidDBInstanceModificationsAsync(const DescribeValidDBInstanceModificationsRequestT& request, const DescribeValidDBInstanceModificationsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DescribeValidDBInstanceModifications, request, handler, context); } /** *

Downloads all or a portion of the specified log file, up to 1 MB in size.

*

This command doesn't apply to RDS Custom.

See Also:

AWS * API Reference

*/ virtual Model::DownloadDBLogFilePortionOutcome DownloadDBLogFilePortion(const Model::DownloadDBLogFilePortionRequest& request) const; /** * A Callable wrapper for DownloadDBLogFilePortion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::DownloadDBLogFilePortionOutcomeCallable DownloadDBLogFilePortionCallable(const DownloadDBLogFilePortionRequestT& request) const { return SubmitCallable(&RDSClient::DownloadDBLogFilePortion, request); } /** * An Async wrapper for DownloadDBLogFilePortion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void DownloadDBLogFilePortionAsync(const DownloadDBLogFilePortionRequestT& request, const DownloadDBLogFilePortionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::DownloadDBLogFilePortion, request, handler, context); } /** *

Forces a failover for a DB cluster.

For an Aurora DB cluster, failover * for a DB cluster promotes one of the Aurora Replicas (read-only instances) in * the DB cluster to be the primary DB instance (the cluster writer).

For a * Multi-AZ DB cluster, failover for a DB cluster promotes one of the readable * standby DB instances (read-only instances) in the DB cluster to be the primary * DB instance (the cluster writer).

An Amazon Aurora DB cluster * automatically fails over to an Aurora Replica, if one exists, when the primary * DB instance fails. A Multi-AZ DB cluster automatically fails over to a readable * standby DB instance when the primary DB instance fails.

To simulate a * failure of a primary instance for testing, you can force a failover. Because * each instance in a DB cluster has its own endpoint address, make sure to clean * up and re-establish any existing connections that use those endpoint addresses * when the failover is complete.

For more information on Amazon Aurora DB * clusters, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::FailoverDBClusterOutcome FailoverDBCluster(const Model::FailoverDBClusterRequest& request) const; /** * A Callable wrapper for FailoverDBCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::FailoverDBClusterOutcomeCallable FailoverDBClusterCallable(const FailoverDBClusterRequestT& request) const { return SubmitCallable(&RDSClient::FailoverDBCluster, request); } /** * An Async wrapper for FailoverDBCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void FailoverDBClusterAsync(const FailoverDBClusterRequestT& request, const FailoverDBClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::FailoverDBCluster, request, handler, context); } /** *

Initiates the failover process for an Aurora global database * (GlobalCluster).

A failover for an Aurora global database promotes * one of secondary read-only DB clusters to be the primary DB cluster and demotes * the primary DB cluster to being a secondary (read-only) DB cluster. In other * words, the role of the current primary DB cluster and the selected (target) DB * cluster are switched. The selected secondary DB cluster assumes full read/write * capabilities for the Aurora global database.

For more information about * failing over an Amazon Aurora global database, see Managed * planned failover for Amazon Aurora global databases in the Amazon Aurora * User Guide.

This action applies to GlobalCluster * (Aurora global databases) only. Use this action only on healthy Aurora global * databases with running Aurora DB clusters and no Region-wide outages, to test * disaster recovery scenarios or to reconfigure your Aurora global database * topology.

See Also:

AWS * API Reference

*/ virtual Model::FailoverGlobalClusterOutcome FailoverGlobalCluster(const Model::FailoverGlobalClusterRequest& request) const; /** * A Callable wrapper for FailoverGlobalCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::FailoverGlobalClusterOutcomeCallable FailoverGlobalClusterCallable(const FailoverGlobalClusterRequestT& request) const { return SubmitCallable(&RDSClient::FailoverGlobalCluster, request); } /** * An Async wrapper for FailoverGlobalCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void FailoverGlobalClusterAsync(const FailoverGlobalClusterRequestT& request, const FailoverGlobalClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::FailoverGlobalCluster, request, handler, context); } /** *

Lists all tags on an Amazon RDS resource.

For an overview on tagging * an Amazon RDS resource, see Tagging * Amazon RDS Resources in the Amazon RDS User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::ListTagsForResourceOutcome ListTagsForResource(const Model::ListTagsForResourceRequest& request) const; /** * A Callable wrapper for ListTagsForResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ListTagsForResourceOutcomeCallable ListTagsForResourceCallable(const ListTagsForResourceRequestT& request) const { return SubmitCallable(&RDSClient::ListTagsForResource, request); } /** * An Async wrapper for ListTagsForResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ListTagsForResourceAsync(const ListTagsForResourceRequestT& request, const ListTagsForResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ListTagsForResource, request, handler, context); } /** *

Changes the audit policy state of a database activity stream to either locked * (default) or unlocked. A locked policy is read-only, whereas an unlocked policy * is read/write. If your activity stream is started and locked, you can unlock it, * customize your audit policy, and then lock your activity stream. Restarting the * activity stream isn't required. For more information, see * Modifying a database activity stream in the Amazon RDS User Guide. *

This operation is supported for RDS for Oracle and Microsoft SQL * Server.

See Also:

AWS * API Reference

*/ virtual Model::ModifyActivityStreamOutcome ModifyActivityStream(const Model::ModifyActivityStreamRequest& request) const; /** * A Callable wrapper for ModifyActivityStream that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyActivityStreamOutcomeCallable ModifyActivityStreamCallable(const ModifyActivityStreamRequestT& request) const { return SubmitCallable(&RDSClient::ModifyActivityStream, request); } /** * An Async wrapper for ModifyActivityStream that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyActivityStreamAsync(const ModifyActivityStreamRequestT& request, const ModifyActivityStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyActivityStream, request, handler, context); } /** *

Override the system-default Secure Sockets Layer/Transport Layer Security * (SSL/TLS) certificate for Amazon RDS for new DB instances, or remove the * override.

By using this operation, you can specify an RDS-approved * SSL/TLS certificate for new DB instances that is different from the default * certificate provided by RDS. You can also use this operation to remove the * override, so that new DB instances use the default certificate provided by * RDS.

You might need to override the default certificate in the following * situations:

  • You already migrated your applications to support * the latest certificate authority (CA) certificate, but the new CA certificate is * not yet the RDS default CA certificate for the specified Amazon Web Services * Region.

  • RDS has already moved to a new default CA certificate * for the specified Amazon Web Services Region, but you are still in the process * of supporting the new CA certificate. In this case, you temporarily need * additional time to finish your application changes.

For more * information about rotating your SSL/TLS certificate for RDS DB engines, see * Rotating Your SSL/TLS Certificate in the Amazon RDS User Guide.

*

For more information about rotating your SSL/TLS certificate for Aurora DB * engines, see * Rotating Your SSL/TLS Certificate in the Amazon Aurora User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ModifyCertificatesOutcome ModifyCertificates(const Model::ModifyCertificatesRequest& request) const; /** * A Callable wrapper for ModifyCertificates that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyCertificatesOutcomeCallable ModifyCertificatesCallable(const ModifyCertificatesRequestT& request) const { return SubmitCallable(&RDSClient::ModifyCertificates, request); } /** * An Async wrapper for ModifyCertificates that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyCertificatesAsync(const ModifyCertificatesRequestT& request, const ModifyCertificatesResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyCertificates, request, handler, context); } /** *

Set the capacity of an Aurora Serverless v1 DB cluster to a specific * value.

Aurora Serverless v1 scales seamlessly based on the workload on * the DB cluster. In some cases, the capacity might not scale fast enough to meet * a sudden change in workload, such as a large number of new transactions. Call * ModifyCurrentDBClusterCapacity to set the capacity explicitly.

*

After this call sets the DB cluster capacity, Aurora Serverless v1 can * automatically scale the DB cluster based on the cooldown period for scaling up * and the cooldown period for scaling down.

For more information about * Aurora Serverless v1, see Using * Amazon Aurora Serverless v1 in the Amazon Aurora User Guide.

*

If you call ModifyCurrentDBClusterCapacity with the * default TimeoutAction, connections that prevent Aurora Serverless * v1 from finding a scaling point might be dropped. For more information about * scaling points, see * Autoscaling for Aurora Serverless v1 in the Amazon Aurora User * Guide.

This action only applies to Aurora * Serverless v1 DB clusters.

See Also:

AWS * API Reference

*/ virtual Model::ModifyCurrentDBClusterCapacityOutcome ModifyCurrentDBClusterCapacity(const Model::ModifyCurrentDBClusterCapacityRequest& request) const; /** * A Callable wrapper for ModifyCurrentDBClusterCapacity that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyCurrentDBClusterCapacityOutcomeCallable ModifyCurrentDBClusterCapacityCallable(const ModifyCurrentDBClusterCapacityRequestT& request) const { return SubmitCallable(&RDSClient::ModifyCurrentDBClusterCapacity, request); } /** * An Async wrapper for ModifyCurrentDBClusterCapacity that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyCurrentDBClusterCapacityAsync(const ModifyCurrentDBClusterCapacityRequestT& request, const ModifyCurrentDBClusterCapacityResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyCurrentDBClusterCapacity, request, handler, context); } /** *

Modifies the status of a custom engine version (CEV). You can find CEVs to * modify by calling DescribeDBEngineVersions.

The * MediaImport service that imports files from Amazon S3 to create CEVs isn't * integrated with Amazon Web Services CloudTrail. If you turn on data logging for * Amazon RDS in CloudTrail, calls to the ModifyCustomDbEngineVersion * event aren't logged. However, you might see calls from the API gateway that * accesses your Amazon S3 bucket. These calls originate from the MediaImport * service for the ModifyCustomDbEngineVersion event.

*

For more information, see Modifying * CEV status in the Amazon RDS User Guide.

See Also:

* AWS * API Reference

*/ virtual Model::ModifyCustomDBEngineVersionOutcome ModifyCustomDBEngineVersion(const Model::ModifyCustomDBEngineVersionRequest& request) const; /** * A Callable wrapper for ModifyCustomDBEngineVersion that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyCustomDBEngineVersionOutcomeCallable ModifyCustomDBEngineVersionCallable(const ModifyCustomDBEngineVersionRequestT& request) const { return SubmitCallable(&RDSClient::ModifyCustomDBEngineVersion, request); } /** * An Async wrapper for ModifyCustomDBEngineVersion that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyCustomDBEngineVersionAsync(const ModifyCustomDBEngineVersionRequestT& request, const ModifyCustomDBEngineVersionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyCustomDBEngineVersion, request, handler, context); } /** *

Modifies the settings of an Amazon Aurora DB cluster or a Multi-AZ DB * cluster. You can change one or more settings by specifying these parameters and * the new values in the request.

For more information on Amazon Aurora DB * clusters, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::ModifyDBClusterOutcome ModifyDBCluster(const Model::ModifyDBClusterRequest& request) const; /** * A Callable wrapper for ModifyDBCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyDBClusterOutcomeCallable ModifyDBClusterCallable(const ModifyDBClusterRequestT& request) const { return SubmitCallable(&RDSClient::ModifyDBCluster, request); } /** * An Async wrapper for ModifyDBCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyDBClusterAsync(const ModifyDBClusterRequestT& request, const ModifyDBClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyDBCluster, request, handler, context); } /** *

Modifies the properties of an endpoint in an Amazon Aurora DB cluster.

*

This action only applies to Aurora DB clusters.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyDBClusterEndpointOutcome ModifyDBClusterEndpoint(const Model::ModifyDBClusterEndpointRequest& request) const; /** * A Callable wrapper for ModifyDBClusterEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyDBClusterEndpointOutcomeCallable ModifyDBClusterEndpointCallable(const ModifyDBClusterEndpointRequestT& request) const { return SubmitCallable(&RDSClient::ModifyDBClusterEndpoint, request); } /** * An Async wrapper for ModifyDBClusterEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyDBClusterEndpointAsync(const ModifyDBClusterEndpointRequestT& request, const ModifyDBClusterEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyDBClusterEndpoint, request, handler, context); } /** *

Modifies the parameters of a DB cluster parameter group. To modify more than * one parameter, submit a list of the following: ParameterName, * ParameterValue, and ApplyMethod. A maximum of 20 * parameters can be modified in a single request.

After you * create a DB cluster parameter group, you should wait at least 5 minutes before * creating your first DB cluster that uses that DB cluster parameter group as the * default parameter group. This allows Amazon RDS to fully complete the create * action before the parameter group is used as the default for a new DB cluster. * This is especially important for parameters that are critical when creating the * default database for a DB cluster, such as the character set for the default * database defined by the character_set_database parameter. You can * use the Parameter Groups option of the Amazon RDS console or the * DescribeDBClusterParameters operation to verify that your DB * cluster parameter group has been created or modified.

If the modified DB * cluster parameter group is used by an Aurora Serverless v1 cluster, Aurora * applies the update immediately. The cluster restart might interrupt your * workload. In that case, your application must reopen any connections and retry * any transactions that were active when the parameter changes took effect.

*

For more information on Amazon Aurora DB clusters, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User Guide. *

See Also:

AWS * API Reference

*/ virtual Model::ModifyDBClusterParameterGroupOutcome ModifyDBClusterParameterGroup(const Model::ModifyDBClusterParameterGroupRequest& request) const; /** * A Callable wrapper for ModifyDBClusterParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyDBClusterParameterGroupOutcomeCallable ModifyDBClusterParameterGroupCallable(const ModifyDBClusterParameterGroupRequestT& request) const { return SubmitCallable(&RDSClient::ModifyDBClusterParameterGroup, request); } /** * An Async wrapper for ModifyDBClusterParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyDBClusterParameterGroupAsync(const ModifyDBClusterParameterGroupRequestT& request, const ModifyDBClusterParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyDBClusterParameterGroup, request, handler, context); } /** *

Adds an attribute and values to, or removes an attribute and values from, a * manual DB cluster snapshot.

To share a manual DB cluster snapshot with * other Amazon Web Services accounts, specify restore as the * AttributeName and use the ValuesToAdd parameter to add * a list of IDs of the Amazon Web Services accounts that are authorized to restore * the manual DB cluster snapshot. Use the value all to make the * manual DB cluster snapshot public, which means that it can be copied or restored * by all Amazon Web Services accounts.

Don't add the * all value for any manual DB cluster snapshots that contain private * information that you don't want available to all Amazon Web Services * accounts.

If a manual DB cluster snapshot is encrypted, it can be * shared, but only by specifying a list of authorized Amazon Web Services account * IDs for the ValuesToAdd parameter. You can't use all * as a value for that parameter in this case.

To view which Amazon Web * Services accounts have access to copy or restore a manual DB cluster snapshot, * or whether a manual DB cluster snapshot is public or private, use the * DescribeDBClusterSnapshotAttributes API operation. The accounts are * returned as values for the restore attribute.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyDBClusterSnapshotAttributeOutcome ModifyDBClusterSnapshotAttribute(const Model::ModifyDBClusterSnapshotAttributeRequest& request) const; /** * A Callable wrapper for ModifyDBClusterSnapshotAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyDBClusterSnapshotAttributeOutcomeCallable ModifyDBClusterSnapshotAttributeCallable(const ModifyDBClusterSnapshotAttributeRequestT& request) const { return SubmitCallable(&RDSClient::ModifyDBClusterSnapshotAttribute, request); } /** * An Async wrapper for ModifyDBClusterSnapshotAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyDBClusterSnapshotAttributeAsync(const ModifyDBClusterSnapshotAttributeRequestT& request, const ModifyDBClusterSnapshotAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyDBClusterSnapshotAttribute, request, handler, context); } /** *

Modifies settings for a DB instance. You can change one or more database * configuration parameters by specifying these parameters and the new values in * the request. To learn what modifications you can make to your DB instance, call * DescribeValidDBInstanceModifications before you call * ModifyDBInstance.

See Also:

AWS * API Reference

*/ virtual Model::ModifyDBInstanceOutcome ModifyDBInstance(const Model::ModifyDBInstanceRequest& request) const; /** * A Callable wrapper for ModifyDBInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyDBInstanceOutcomeCallable ModifyDBInstanceCallable(const ModifyDBInstanceRequestT& request) const { return SubmitCallable(&RDSClient::ModifyDBInstance, request); } /** * An Async wrapper for ModifyDBInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyDBInstanceAsync(const ModifyDBInstanceRequestT& request, const ModifyDBInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyDBInstance, request, handler, context); } /** *

Modifies the parameters of a DB parameter group. To modify more than one * parameter, submit a list of the following: ParameterName, * ParameterValue, and ApplyMethod. A maximum of 20 * parameters can be modified in a single request.

After you * modify a DB parameter group, you should wait at least 5 minutes before creating * your first DB instance that uses that DB parameter group as the default * parameter group. This allows Amazon RDS to fully complete the modify action * before the parameter group is used as the default for a new DB instance. This is * especially important for parameters that are critical when creating the default * database for a DB instance, such as the character set for the default database * defined by the character_set_database parameter. You can use the * Parameter Groups option of the Amazon RDS console or the * DescribeDBParameters command to verify that your DB parameter group has * been created or modified.

See Also:

AWS * API Reference

*/ virtual Model::ModifyDBParameterGroupOutcome ModifyDBParameterGroup(const Model::ModifyDBParameterGroupRequest& request) const; /** * A Callable wrapper for ModifyDBParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyDBParameterGroupOutcomeCallable ModifyDBParameterGroupCallable(const ModifyDBParameterGroupRequestT& request) const { return SubmitCallable(&RDSClient::ModifyDBParameterGroup, request); } /** * An Async wrapper for ModifyDBParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyDBParameterGroupAsync(const ModifyDBParameterGroupRequestT& request, const ModifyDBParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyDBParameterGroup, request, handler, context); } /** *

Changes the settings for an existing DB proxy.

See Also:

AWS * API Reference

*/ virtual Model::ModifyDBProxyOutcome ModifyDBProxy(const Model::ModifyDBProxyRequest& request) const; /** * A Callable wrapper for ModifyDBProxy that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyDBProxyOutcomeCallable ModifyDBProxyCallable(const ModifyDBProxyRequestT& request) const { return SubmitCallable(&RDSClient::ModifyDBProxy, request); } /** * An Async wrapper for ModifyDBProxy that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyDBProxyAsync(const ModifyDBProxyRequestT& request, const ModifyDBProxyResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyDBProxy, request, handler, context); } /** *

Changes the settings for an existing DB proxy endpoint.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyDBProxyEndpointOutcome ModifyDBProxyEndpoint(const Model::ModifyDBProxyEndpointRequest& request) const; /** * A Callable wrapper for ModifyDBProxyEndpoint that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyDBProxyEndpointOutcomeCallable ModifyDBProxyEndpointCallable(const ModifyDBProxyEndpointRequestT& request) const { return SubmitCallable(&RDSClient::ModifyDBProxyEndpoint, request); } /** * An Async wrapper for ModifyDBProxyEndpoint that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyDBProxyEndpointAsync(const ModifyDBProxyEndpointRequestT& request, const ModifyDBProxyEndpointResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyDBProxyEndpoint, request, handler, context); } /** *

Modifies the properties of a DBProxyTargetGroup.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyDBProxyTargetGroupOutcome ModifyDBProxyTargetGroup(const Model::ModifyDBProxyTargetGroupRequest& request) const; /** * A Callable wrapper for ModifyDBProxyTargetGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyDBProxyTargetGroupOutcomeCallable ModifyDBProxyTargetGroupCallable(const ModifyDBProxyTargetGroupRequestT& request) const { return SubmitCallable(&RDSClient::ModifyDBProxyTargetGroup, request); } /** * An Async wrapper for ModifyDBProxyTargetGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyDBProxyTargetGroupAsync(const ModifyDBProxyTargetGroupRequestT& request, const ModifyDBProxyTargetGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyDBProxyTargetGroup, request, handler, context); } /** *

Updates a manual DB snapshot with a new engine version. The snapshot can be * encrypted or unencrypted, but not shared or public.

Amazon RDS supports * upgrading DB snapshots for MySQL, PostgreSQL, and Oracle. This command doesn't * apply to RDS Custom.

See Also:

AWS * API Reference

*/ virtual Model::ModifyDBSnapshotOutcome ModifyDBSnapshot(const Model::ModifyDBSnapshotRequest& request) const; /** * A Callable wrapper for ModifyDBSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyDBSnapshotOutcomeCallable ModifyDBSnapshotCallable(const ModifyDBSnapshotRequestT& request) const { return SubmitCallable(&RDSClient::ModifyDBSnapshot, request); } /** * An Async wrapper for ModifyDBSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyDBSnapshotAsync(const ModifyDBSnapshotRequestT& request, const ModifyDBSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyDBSnapshot, request, handler, context); } /** *

Adds an attribute and values to, or removes an attribute and values from, a * manual DB snapshot.

To share a manual DB snapshot with other Amazon Web * Services accounts, specify restore as the * AttributeName and use the ValuesToAdd parameter to add * a list of IDs of the Amazon Web Services accounts that are authorized to restore * the manual DB snapshot. Uses the value all to make the manual DB * snapshot public, which means it can be copied or restored by all Amazon Web * Services accounts.

Don't add the all value for any * manual DB snapshots that contain private information that you don't want * available to all Amazon Web Services accounts.

If the manual DB * snapshot is encrypted, it can be shared, but only by specifying a list of * authorized Amazon Web Services account IDs for the ValuesToAdd * parameter. You can't use all as a value for that parameter in this * case.

To view which Amazon Web Services accounts have access to copy or * restore a manual DB snapshot, or whether a manual DB snapshot public or private, * use the DescribeDBSnapshotAttributes API operation. The accounts are * returned as values for the restore attribute.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyDBSnapshotAttributeOutcome ModifyDBSnapshotAttribute(const Model::ModifyDBSnapshotAttributeRequest& request) const; /** * A Callable wrapper for ModifyDBSnapshotAttribute that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyDBSnapshotAttributeOutcomeCallable ModifyDBSnapshotAttributeCallable(const ModifyDBSnapshotAttributeRequestT& request) const { return SubmitCallable(&RDSClient::ModifyDBSnapshotAttribute, request); } /** * An Async wrapper for ModifyDBSnapshotAttribute that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyDBSnapshotAttributeAsync(const ModifyDBSnapshotAttributeRequestT& request, const ModifyDBSnapshotAttributeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyDBSnapshotAttribute, request, handler, context); } /** *

Modifies an existing DB subnet group. DB subnet groups must contain at least * one subnet in at least two AZs in the Amazon Web Services Region.

See * Also:

AWS * API Reference

*/ virtual Model::ModifyDBSubnetGroupOutcome ModifyDBSubnetGroup(const Model::ModifyDBSubnetGroupRequest& request) const; /** * A Callable wrapper for ModifyDBSubnetGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyDBSubnetGroupOutcomeCallable ModifyDBSubnetGroupCallable(const ModifyDBSubnetGroupRequestT& request) const { return SubmitCallable(&RDSClient::ModifyDBSubnetGroup, request); } /** * An Async wrapper for ModifyDBSubnetGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyDBSubnetGroupAsync(const ModifyDBSubnetGroupRequestT& request, const ModifyDBSubnetGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyDBSubnetGroup, request, handler, context); } /** *

Modifies an existing RDS event notification subscription. You can't modify * the source identifiers using this call. To change source identifiers for a * subscription, use the AddSourceIdentifierToSubscription and * RemoveSourceIdentifierFromSubscription calls.

You can see a * list of the event categories for a given source type (SourceType) * in Events * in the Amazon RDS User Guide or by using the * DescribeEventCategories operation.

See Also:

AWS * API Reference

*/ virtual Model::ModifyEventSubscriptionOutcome ModifyEventSubscription(const Model::ModifyEventSubscriptionRequest& request) const; /** * A Callable wrapper for ModifyEventSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyEventSubscriptionOutcomeCallable ModifyEventSubscriptionCallable(const ModifyEventSubscriptionRequestT& request) const { return SubmitCallable(&RDSClient::ModifyEventSubscription, request); } /** * An Async wrapper for ModifyEventSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyEventSubscriptionAsync(const ModifyEventSubscriptionRequestT& request, const ModifyEventSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyEventSubscription, request, handler, context); } /** *

Modifies a setting for an Amazon Aurora global cluster. You can change one or * more database configuration parameters by specifying these parameters and the * new values in the request. For more information on Amazon Aurora, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

*

This operation only applies to Aurora global database clusters.

*

See Also:

AWS * API Reference

*/ virtual Model::ModifyGlobalClusterOutcome ModifyGlobalCluster(const Model::ModifyGlobalClusterRequest& request) const; /** * A Callable wrapper for ModifyGlobalCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyGlobalClusterOutcomeCallable ModifyGlobalClusterCallable(const ModifyGlobalClusterRequestT& request) const { return SubmitCallable(&RDSClient::ModifyGlobalCluster, request); } /** * An Async wrapper for ModifyGlobalCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyGlobalClusterAsync(const ModifyGlobalClusterRequestT& request, const ModifyGlobalClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyGlobalCluster, request, handler, context); } /** *

Modifies an existing option group.

See Also:

AWS * API Reference

*/ virtual Model::ModifyOptionGroupOutcome ModifyOptionGroup(const Model::ModifyOptionGroupRequest& request) const; /** * A Callable wrapper for ModifyOptionGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ModifyOptionGroupOutcomeCallable ModifyOptionGroupCallable(const ModifyOptionGroupRequestT& request) const { return SubmitCallable(&RDSClient::ModifyOptionGroup, request); } /** * An Async wrapper for ModifyOptionGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ModifyOptionGroupAsync(const ModifyOptionGroupRequestT& request, const ModifyOptionGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ModifyOptionGroup, request, handler, context); } /** *

Promotes a read replica DB instance to a standalone DB instance.

*

  • Backup duration is a function of the amount of changes to the * database since the previous backup. If you plan to promote a read replica to a * standalone instance, we recommend that you enable backups and complete at least * one backup prior to promotion. In addition, a read replica cannot be promoted to * a standalone instance when it is in the backing-up status. If you * have enabled backups on your read replica, configure the automated backup window * so that daily backups do not interfere with read replica promotion.

    • *

  • This command doesn't apply to Aurora MySQL, Aurora PostgreSQL, or RDS * Custom.

See Also:

AWS * API Reference

*/ virtual Model::PromoteReadReplicaOutcome PromoteReadReplica(const Model::PromoteReadReplicaRequest& request) const; /** * A Callable wrapper for PromoteReadReplica that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PromoteReadReplicaOutcomeCallable PromoteReadReplicaCallable(const PromoteReadReplicaRequestT& request) const { return SubmitCallable(&RDSClient::PromoteReadReplica, request); } /** * An Async wrapper for PromoteReadReplica that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PromoteReadReplicaAsync(const PromoteReadReplicaRequestT& request, const PromoteReadReplicaResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::PromoteReadReplica, request, handler, context); } /** *

Promotes a read replica DB cluster to a standalone DB cluster.

See * Also:

AWS * API Reference

*/ virtual Model::PromoteReadReplicaDBClusterOutcome PromoteReadReplicaDBCluster(const Model::PromoteReadReplicaDBClusterRequest& request) const; /** * A Callable wrapper for PromoteReadReplicaDBCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PromoteReadReplicaDBClusterOutcomeCallable PromoteReadReplicaDBClusterCallable(const PromoteReadReplicaDBClusterRequestT& request) const { return SubmitCallable(&RDSClient::PromoteReadReplicaDBCluster, request); } /** * An Async wrapper for PromoteReadReplicaDBCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PromoteReadReplicaDBClusterAsync(const PromoteReadReplicaDBClusterRequestT& request, const PromoteReadReplicaDBClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::PromoteReadReplicaDBCluster, request, handler, context); } /** *

Purchases a reserved DB instance offering.

See Also:

AWS * API Reference

*/ virtual Model::PurchaseReservedDBInstancesOfferingOutcome PurchaseReservedDBInstancesOffering(const Model::PurchaseReservedDBInstancesOfferingRequest& request) const; /** * A Callable wrapper for PurchaseReservedDBInstancesOffering that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::PurchaseReservedDBInstancesOfferingOutcomeCallable PurchaseReservedDBInstancesOfferingCallable(const PurchaseReservedDBInstancesOfferingRequestT& request) const { return SubmitCallable(&RDSClient::PurchaseReservedDBInstancesOffering, request); } /** * An Async wrapper for PurchaseReservedDBInstancesOffering that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void PurchaseReservedDBInstancesOfferingAsync(const PurchaseReservedDBInstancesOfferingRequestT& request, const PurchaseReservedDBInstancesOfferingResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::PurchaseReservedDBInstancesOffering, request, handler, context); } /** *

You might need to reboot your DB cluster, usually for maintenance reasons. * For example, if you make certain modifications, or if you change the DB cluster * parameter group associated with the DB cluster, reboot the DB cluster for the * changes to take effect.

Rebooting a DB cluster restarts the database * engine service. Rebooting a DB cluster results in a momentary outage, during * which the DB cluster status is set to rebooting.

Use this operation only * for a non-Aurora Multi-AZ DB cluster.

For more information on Multi-AZ DB * clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User Guide. *

See Also:

AWS * API Reference

*/ virtual Model::RebootDBClusterOutcome RebootDBCluster(const Model::RebootDBClusterRequest& request) const; /** * A Callable wrapper for RebootDBCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RebootDBClusterOutcomeCallable RebootDBClusterCallable(const RebootDBClusterRequestT& request) const { return SubmitCallable(&RDSClient::RebootDBCluster, request); } /** * An Async wrapper for RebootDBCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RebootDBClusterAsync(const RebootDBClusterRequestT& request, const RebootDBClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::RebootDBCluster, request, handler, context); } /** *

You might need to reboot your DB instance, usually for maintenance reasons. * For example, if you make certain modifications, or if you change the DB * parameter group associated with the DB instance, you must reboot the instance * for the changes to take effect.

Rebooting a DB instance restarts the * database engine service. Rebooting a DB instance results in a momentary outage, * during which the DB instance status is set to rebooting.

For more * information about rebooting, see Rebooting * a DB Instance in the Amazon RDS User Guide.

This command * doesn't apply to RDS Custom.

If your DB instance is part of a Multi-AZ DB * cluster, you can reboot the DB cluster with the RebootDBCluster * operation.

See Also:

AWS * API Reference

*/ virtual Model::RebootDBInstanceOutcome RebootDBInstance(const Model::RebootDBInstanceRequest& request) const; /** * A Callable wrapper for RebootDBInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RebootDBInstanceOutcomeCallable RebootDBInstanceCallable(const RebootDBInstanceRequestT& request) const { return SubmitCallable(&RDSClient::RebootDBInstance, request); } /** * An Async wrapper for RebootDBInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RebootDBInstanceAsync(const RebootDBInstanceRequestT& request, const RebootDBInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::RebootDBInstance, request, handler, context); } /** *

Associate one or more DBProxyTarget data structures with a * DBProxyTargetGroup.

See Also:

AWS * API Reference

*/ virtual Model::RegisterDBProxyTargetsOutcome RegisterDBProxyTargets(const Model::RegisterDBProxyTargetsRequest& request) const; /** * A Callable wrapper for RegisterDBProxyTargets that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RegisterDBProxyTargetsOutcomeCallable RegisterDBProxyTargetsCallable(const RegisterDBProxyTargetsRequestT& request) const { return SubmitCallable(&RDSClient::RegisterDBProxyTargets, request); } /** * An Async wrapper for RegisterDBProxyTargets that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RegisterDBProxyTargetsAsync(const RegisterDBProxyTargetsRequestT& request, const RegisterDBProxyTargetsResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::RegisterDBProxyTargets, request, handler, context); } /** *

Detaches an Aurora secondary cluster from an Aurora global database cluster. * The cluster becomes a standalone cluster with read-write capability instead of * being read-only and receiving data from a primary cluster in a different * Region.

This action only applies to Aurora DB clusters.

*

See Also:

AWS * API Reference

*/ virtual Model::RemoveFromGlobalClusterOutcome RemoveFromGlobalCluster(const Model::RemoveFromGlobalClusterRequest& request) const; /** * A Callable wrapper for RemoveFromGlobalCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveFromGlobalClusterOutcomeCallable RemoveFromGlobalClusterCallable(const RemoveFromGlobalClusterRequestT& request) const { return SubmitCallable(&RDSClient::RemoveFromGlobalCluster, request); } /** * An Async wrapper for RemoveFromGlobalCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveFromGlobalClusterAsync(const RemoveFromGlobalClusterRequestT& request, const RemoveFromGlobalClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::RemoveFromGlobalCluster, request, handler, context); } /** *

Removes the asssociation of an Amazon Web Services Identity and Access * Management (IAM) role from a DB cluster.

For more information on Amazon * Aurora DB clusters, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User Guide. *

See Also:

AWS * API Reference

*/ virtual Model::RemoveRoleFromDBClusterOutcome RemoveRoleFromDBCluster(const Model::RemoveRoleFromDBClusterRequest& request) const; /** * A Callable wrapper for RemoveRoleFromDBCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveRoleFromDBClusterOutcomeCallable RemoveRoleFromDBClusterCallable(const RemoveRoleFromDBClusterRequestT& request) const { return SubmitCallable(&RDSClient::RemoveRoleFromDBCluster, request); } /** * An Async wrapper for RemoveRoleFromDBCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveRoleFromDBClusterAsync(const RemoveRoleFromDBClusterRequestT& request, const RemoveRoleFromDBClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::RemoveRoleFromDBCluster, request, handler, context); } /** *

Disassociates an Amazon Web Services Identity and Access Management (IAM) * role from a DB instance.

See Also:

AWS * API Reference

*/ virtual Model::RemoveRoleFromDBInstanceOutcome RemoveRoleFromDBInstance(const Model::RemoveRoleFromDBInstanceRequest& request) const; /** * A Callable wrapper for RemoveRoleFromDBInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveRoleFromDBInstanceOutcomeCallable RemoveRoleFromDBInstanceCallable(const RemoveRoleFromDBInstanceRequestT& request) const { return SubmitCallable(&RDSClient::RemoveRoleFromDBInstance, request); } /** * An Async wrapper for RemoveRoleFromDBInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveRoleFromDBInstanceAsync(const RemoveRoleFromDBInstanceRequestT& request, const RemoveRoleFromDBInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::RemoveRoleFromDBInstance, request, handler, context); } /** *

Removes a source identifier from an existing RDS event notification * subscription.

See Also:

AWS * API Reference

*/ virtual Model::RemoveSourceIdentifierFromSubscriptionOutcome RemoveSourceIdentifierFromSubscription(const Model::RemoveSourceIdentifierFromSubscriptionRequest& request) const; /** * A Callable wrapper for RemoveSourceIdentifierFromSubscription that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveSourceIdentifierFromSubscriptionOutcomeCallable RemoveSourceIdentifierFromSubscriptionCallable(const RemoveSourceIdentifierFromSubscriptionRequestT& request) const { return SubmitCallable(&RDSClient::RemoveSourceIdentifierFromSubscription, request); } /** * An Async wrapper for RemoveSourceIdentifierFromSubscription that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveSourceIdentifierFromSubscriptionAsync(const RemoveSourceIdentifierFromSubscriptionRequestT& request, const RemoveSourceIdentifierFromSubscriptionResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::RemoveSourceIdentifierFromSubscription, request, handler, context); } /** *

Removes metadata tags from an Amazon RDS resource.

For an overview on * tagging an Amazon RDS resource, see Tagging * Amazon RDS Resources in the Amazon RDS User Guide.

See * Also:

AWS * API Reference

*/ virtual Model::RemoveTagsFromResourceOutcome RemoveTagsFromResource(const Model::RemoveTagsFromResourceRequest& request) const; /** * A Callable wrapper for RemoveTagsFromResource that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RemoveTagsFromResourceOutcomeCallable RemoveTagsFromResourceCallable(const RemoveTagsFromResourceRequestT& request) const { return SubmitCallable(&RDSClient::RemoveTagsFromResource, request); } /** * An Async wrapper for RemoveTagsFromResource that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RemoveTagsFromResourceAsync(const RemoveTagsFromResourceRequestT& request, const RemoveTagsFromResourceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::RemoveTagsFromResource, request, handler, context); } /** *

Modifies the parameters of a DB cluster parameter group to the default value. * To reset specific parameters submit a list of the following: * ParameterName and ApplyMethod. To reset the entire DB * cluster parameter group, specify the DBClusterParameterGroupName * and ResetAllParameters parameters.

When resetting the entire * group, dynamic parameters are updated immediately and static parameters are set * to pending-reboot to take effect on the next DB instance restart or * RebootDBInstance request. You must call * RebootDBInstance for every DB instance in your DB cluster that you * want the updated static parameter to apply to.

For more information on * Amazon Aurora DB clusters, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User Guide. *

See Also:

AWS * API Reference

*/ virtual Model::ResetDBClusterParameterGroupOutcome ResetDBClusterParameterGroup(const Model::ResetDBClusterParameterGroupRequest& request) const; /** * A Callable wrapper for ResetDBClusterParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResetDBClusterParameterGroupOutcomeCallable ResetDBClusterParameterGroupCallable(const ResetDBClusterParameterGroupRequestT& request) const { return SubmitCallable(&RDSClient::ResetDBClusterParameterGroup, request); } /** * An Async wrapper for ResetDBClusterParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResetDBClusterParameterGroupAsync(const ResetDBClusterParameterGroupRequestT& request, const ResetDBClusterParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ResetDBClusterParameterGroup, request, handler, context); } /** *

Modifies the parameters of a DB parameter group to the engine/system default * value. To reset specific parameters, provide a list of the following: * ParameterName and ApplyMethod. To reset the entire DB * parameter group, specify the DBParameterGroup name and * ResetAllParameters parameters. When resetting the entire group, * dynamic parameters are updated immediately and static parameters are set to * pending-reboot to take effect on the next DB instance restart or * RebootDBInstance request.

See Also:

AWS * API Reference

*/ virtual Model::ResetDBParameterGroupOutcome ResetDBParameterGroup(const Model::ResetDBParameterGroupRequest& request) const; /** * A Callable wrapper for ResetDBParameterGroup that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::ResetDBParameterGroupOutcomeCallable ResetDBParameterGroupCallable(const ResetDBParameterGroupRequestT& request) const { return SubmitCallable(&RDSClient::ResetDBParameterGroup, request); } /** * An Async wrapper for ResetDBParameterGroup that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void ResetDBParameterGroupAsync(const ResetDBParameterGroupRequestT& request, const ResetDBParameterGroupResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::ResetDBParameterGroup, request, handler, context); } /** *

Creates an Amazon Aurora DB cluster from MySQL data stored in an Amazon S3 * bucket. Amazon RDS must be authorized to access the Amazon S3 bucket and the * data must be created using the Percona XtraBackup utility as described in * Migrating Data from MySQL by Using an Amazon S3 Bucket in the Amazon * Aurora User Guide.

This action only restores the DB cluster, * not the DB instances for that DB cluster. You must invoke the * CreateDBInstance action to create DB instances for the restored DB * cluster, specifying the identifier of the restored DB cluster in * DBClusterIdentifier. You can create DB instances only after the * RestoreDBClusterFromS3 action has completed and the DB cluster is * available.

For more information on Amazon Aurora, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

*

This action only applies to Aurora DB clusters. The source DB engine must be * MySQL.

See Also:

AWS * API Reference

*/ virtual Model::RestoreDBClusterFromS3Outcome RestoreDBClusterFromS3(const Model::RestoreDBClusterFromS3Request& request) const; /** * A Callable wrapper for RestoreDBClusterFromS3 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreDBClusterFromS3OutcomeCallable RestoreDBClusterFromS3Callable(const RestoreDBClusterFromS3RequestT& request) const { return SubmitCallable(&RDSClient::RestoreDBClusterFromS3, request); } /** * An Async wrapper for RestoreDBClusterFromS3 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreDBClusterFromS3Async(const RestoreDBClusterFromS3RequestT& request, const RestoreDBClusterFromS3ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::RestoreDBClusterFromS3, request, handler, context); } /** *

Creates a new DB cluster from a DB snapshot or DB cluster snapshot.

*

The target DB cluster is created from the source snapshot with a default * configuration. If you don't specify a security group, the new DB cluster is * associated with the default security group.

This action only * restores the DB cluster, not the DB instances for that DB cluster. You must * invoke the CreateDBInstance action to create DB instances for the * restored DB cluster, specifying the identifier of the restored DB cluster in * DBClusterIdentifier. You can create DB instances only after the * RestoreDBClusterFromSnapshot action has completed and the DB * cluster is available.

For more information on Amazon Aurora DB * clusters, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User Guide. *

See Also:

AWS * API Reference

*/ virtual Model::RestoreDBClusterFromSnapshotOutcome RestoreDBClusterFromSnapshot(const Model::RestoreDBClusterFromSnapshotRequest& request) const; /** * A Callable wrapper for RestoreDBClusterFromSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreDBClusterFromSnapshotOutcomeCallable RestoreDBClusterFromSnapshotCallable(const RestoreDBClusterFromSnapshotRequestT& request) const { return SubmitCallable(&RDSClient::RestoreDBClusterFromSnapshot, request); } /** * An Async wrapper for RestoreDBClusterFromSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreDBClusterFromSnapshotAsync(const RestoreDBClusterFromSnapshotRequestT& request, const RestoreDBClusterFromSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::RestoreDBClusterFromSnapshot, request, handler, context); } /** *

Restores a DB cluster to an arbitrary point in time. Users can restore to any * point in time before LatestRestorableTime for up to * BackupRetentionPeriod days. The target DB cluster is created from * the source DB cluster with the same configuration as the original DB cluster, * except that the new DB cluster is created with the default DB security * group.

For Aurora, this action only restores the DB cluster, not * the DB instances for that DB cluster. You must invoke the * CreateDBInstance action to create DB instances for the restored DB * cluster, specifying the identifier of the restored DB cluster in * DBClusterIdentifier. You can create DB instances only after the * RestoreDBClusterToPointInTime action has completed and the DB * cluster is available.

For more information on Amazon Aurora DB * clusters, see * What is Amazon Aurora? in the Amazon Aurora User Guide.

For * more information on Multi-AZ DB clusters, see * Multi-AZ DB cluster deployments in the Amazon RDS User Guide. *

See Also:

AWS * API Reference

*/ virtual Model::RestoreDBClusterToPointInTimeOutcome RestoreDBClusterToPointInTime(const Model::RestoreDBClusterToPointInTimeRequest& request) const; /** * A Callable wrapper for RestoreDBClusterToPointInTime that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreDBClusterToPointInTimeOutcomeCallable RestoreDBClusterToPointInTimeCallable(const RestoreDBClusterToPointInTimeRequestT& request) const { return SubmitCallable(&RDSClient::RestoreDBClusterToPointInTime, request); } /** * An Async wrapper for RestoreDBClusterToPointInTime that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreDBClusterToPointInTimeAsync(const RestoreDBClusterToPointInTimeRequestT& request, const RestoreDBClusterToPointInTimeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::RestoreDBClusterToPointInTime, request, handler, context); } /** *

Creates a new DB instance from a DB snapshot. The target database is created * from the source database restore point with most of the source's original * configuration, including the default security group and DB parameter group. By * default, the new DB instance is created as a Single-AZ deployment, except when * the instance is a SQL Server instance that has an option group associated with * mirroring. In this case, the instance becomes a Multi-AZ deployment, not a * Single-AZ deployment.

If you want to replace your original DB instance * with the new, restored DB instance, then rename your original DB instance before * you call the RestoreDBInstanceFromDBSnapshot action. RDS doesn't allow two DB * instances with the same name. After you have renamed your original DB instance * with a different identifier, then you can pass the original name of the DB * instance as the DBInstanceIdentifier in the call to the * RestoreDBInstanceFromDBSnapshot action. The result is that you replace the * original DB instance with the DB instance created from the snapshot.

If * you are restoring from a shared manual DB snapshot, the * DBSnapshotIdentifier must be the ARN of the shared DB snapshot.

*

This command doesn't apply to Aurora MySQL and Aurora PostgreSQL. For * Aurora, use RestoreDBClusterFromSnapshot.

See * Also:

AWS * API Reference

*/ virtual Model::RestoreDBInstanceFromDBSnapshotOutcome RestoreDBInstanceFromDBSnapshot(const Model::RestoreDBInstanceFromDBSnapshotRequest& request) const; /** * A Callable wrapper for RestoreDBInstanceFromDBSnapshot that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreDBInstanceFromDBSnapshotOutcomeCallable RestoreDBInstanceFromDBSnapshotCallable(const RestoreDBInstanceFromDBSnapshotRequestT& request) const { return SubmitCallable(&RDSClient::RestoreDBInstanceFromDBSnapshot, request); } /** * An Async wrapper for RestoreDBInstanceFromDBSnapshot that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreDBInstanceFromDBSnapshotAsync(const RestoreDBInstanceFromDBSnapshotRequestT& request, const RestoreDBInstanceFromDBSnapshotResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::RestoreDBInstanceFromDBSnapshot, request, handler, context); } /** *

Amazon Relational Database Service (Amazon RDS) supports importing MySQL * databases by using backup files. You can create a backup of your on-premises * database, store it on Amazon Simple Storage Service (Amazon S3), and then * restore the backup file onto a new Amazon RDS DB instance running MySQL. For * more information, see Importing * Data into an Amazon RDS MySQL DB Instance in the Amazon RDS User * Guide.

This command doesn't apply to RDS Custom.

See * Also:

AWS * API Reference

*/ virtual Model::RestoreDBInstanceFromS3Outcome RestoreDBInstanceFromS3(const Model::RestoreDBInstanceFromS3Request& request) const; /** * A Callable wrapper for RestoreDBInstanceFromS3 that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreDBInstanceFromS3OutcomeCallable RestoreDBInstanceFromS3Callable(const RestoreDBInstanceFromS3RequestT& request) const { return SubmitCallable(&RDSClient::RestoreDBInstanceFromS3, request); } /** * An Async wrapper for RestoreDBInstanceFromS3 that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreDBInstanceFromS3Async(const RestoreDBInstanceFromS3RequestT& request, const RestoreDBInstanceFromS3ResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::RestoreDBInstanceFromS3, request, handler, context); } /** *

Restores a DB instance to an arbitrary point in time. You can restore to any * point in time before the time identified by the LatestRestorableTime property. * You can restore to a point up to the number of days specified by the * BackupRetentionPeriod property.

The target database is created with most * of the original configuration, but in a system-selected Availability Zone, with * the default security group, the default subnet group, and the default DB * parameter group. By default, the new DB instance is created as a single-AZ * deployment except when the instance is a SQL Server instance that has an option * group that is associated with mirroring; in this case, the instance becomes a * mirrored deployment and not a single-AZ deployment.

This command * doesn't apply to Aurora MySQL and Aurora PostgreSQL. For Aurora, use * RestoreDBClusterToPointInTime.

See Also:

* AWS * API Reference

*/ virtual Model::RestoreDBInstanceToPointInTimeOutcome RestoreDBInstanceToPointInTime(const Model::RestoreDBInstanceToPointInTimeRequest& request) const; /** * A Callable wrapper for RestoreDBInstanceToPointInTime that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RestoreDBInstanceToPointInTimeOutcomeCallable RestoreDBInstanceToPointInTimeCallable(const RestoreDBInstanceToPointInTimeRequestT& request) const { return SubmitCallable(&RDSClient::RestoreDBInstanceToPointInTime, request); } /** * An Async wrapper for RestoreDBInstanceToPointInTime that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RestoreDBInstanceToPointInTimeAsync(const RestoreDBInstanceToPointInTimeRequestT& request, const RestoreDBInstanceToPointInTimeResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::RestoreDBInstanceToPointInTime, request, handler, context); } /** *

Revokes ingress from a DBSecurityGroup for previously authorized IP ranges or * EC2 or VPC security groups. Required parameters for this API are one of CIDRIP, * EC2SecurityGroupId for VPC, or (EC2SecurityGroupOwnerId and either * EC2SecurityGroupName or EC2SecurityGroupId).

EC2-Classic was * retired on August 15, 2022. If you haven't migrated from EC2-Classic to a VPC, * we recommend that you migrate as soon as possible. For more information, see Migrate * from EC2-Classic to a VPC in the Amazon EC2 User Guide, the blog EC2-Classic * Networking is Retiring – Here’s How to Prepare, and Moving * a DB instance not in a VPC into a VPC in the Amazon RDS User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::RevokeDBSecurityGroupIngressOutcome RevokeDBSecurityGroupIngress(const Model::RevokeDBSecurityGroupIngressRequest& request) const; /** * A Callable wrapper for RevokeDBSecurityGroupIngress that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::RevokeDBSecurityGroupIngressOutcomeCallable RevokeDBSecurityGroupIngressCallable(const RevokeDBSecurityGroupIngressRequestT& request) const { return SubmitCallable(&RDSClient::RevokeDBSecurityGroupIngress, request); } /** * An Async wrapper for RevokeDBSecurityGroupIngress that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void RevokeDBSecurityGroupIngressAsync(const RevokeDBSecurityGroupIngressRequestT& request, const RevokeDBSecurityGroupIngressResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::RevokeDBSecurityGroupIngress, request, handler, context); } /** *

Starts a database activity stream to monitor activity on the database. For * more information, see * Monitoring Amazon Aurora with Database Activity Streams in the Amazon * Aurora User Guide or * Monitoring Amazon RDS with Database Activity Streams in the Amazon RDS * User Guide.

See Also:

AWS * API Reference

*/ virtual Model::StartActivityStreamOutcome StartActivityStream(const Model::StartActivityStreamRequest& request) const; /** * A Callable wrapper for StartActivityStream that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartActivityStreamOutcomeCallable StartActivityStreamCallable(const StartActivityStreamRequestT& request) const { return SubmitCallable(&RDSClient::StartActivityStream, request); } /** * An Async wrapper for StartActivityStream that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartActivityStreamAsync(const StartActivityStreamRequestT& request, const StartActivityStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::StartActivityStream, request, handler, context); } /** *

Starts an Amazon Aurora DB cluster that was stopped using the Amazon Web * Services console, the stop-db-cluster CLI command, or the StopDBCluster * action.

For more information, see * Stopping and Starting an Aurora Cluster in the Amazon Aurora User * Guide.

This action only applies to Aurora DB clusters.

*

See Also:

AWS * API Reference

*/ virtual Model::StartDBClusterOutcome StartDBCluster(const Model::StartDBClusterRequest& request) const; /** * A Callable wrapper for StartDBCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartDBClusterOutcomeCallable StartDBClusterCallable(const StartDBClusterRequestT& request) const { return SubmitCallable(&RDSClient::StartDBCluster, request); } /** * An Async wrapper for StartDBCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartDBClusterAsync(const StartDBClusterRequestT& request, const StartDBClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::StartDBCluster, request, handler, context); } /** *

Starts an Amazon RDS DB instance that was stopped using the Amazon Web * Services console, the stop-db-instance CLI command, or the StopDBInstance * action.

For more information, see * Starting an Amazon RDS DB instance That Was Previously Stopped in the * Amazon RDS User Guide.

This command doesn't apply to RDS * Custom, Aurora MySQL, and Aurora PostgreSQL. For Aurora DB clusters, use * StartDBCluster instead.

See Also:

AWS * API Reference

*/ virtual Model::StartDBInstanceOutcome StartDBInstance(const Model::StartDBInstanceRequest& request) const; /** * A Callable wrapper for StartDBInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartDBInstanceOutcomeCallable StartDBInstanceCallable(const StartDBInstanceRequestT& request) const { return SubmitCallable(&RDSClient::StartDBInstance, request); } /** * An Async wrapper for StartDBInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartDBInstanceAsync(const StartDBInstanceRequestT& request, const StartDBInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::StartDBInstance, request, handler, context); } /** *

Enables replication of automated backups to a different Amazon Web Services * Region.

This command doesn't apply to RDS Custom.

For more * information, see * Replicating Automated Backups to Another Amazon Web Services Region in the * Amazon RDS User Guide.

See Also:

AWS * API Reference

*/ virtual Model::StartDBInstanceAutomatedBackupsReplicationOutcome StartDBInstanceAutomatedBackupsReplication(const Model::StartDBInstanceAutomatedBackupsReplicationRequest& request) const; /** * A Callable wrapper for StartDBInstanceAutomatedBackupsReplication that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartDBInstanceAutomatedBackupsReplicationOutcomeCallable StartDBInstanceAutomatedBackupsReplicationCallable(const StartDBInstanceAutomatedBackupsReplicationRequestT& request) const { return SubmitCallable(&RDSClient::StartDBInstanceAutomatedBackupsReplication, request); } /** * An Async wrapper for StartDBInstanceAutomatedBackupsReplication that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartDBInstanceAutomatedBackupsReplicationAsync(const StartDBInstanceAutomatedBackupsReplicationRequestT& request, const StartDBInstanceAutomatedBackupsReplicationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::StartDBInstanceAutomatedBackupsReplication, request, handler, context); } /** *

Starts an export of DB snapshot or DB cluster data to Amazon S3. The provided * IAM role must have access to the S3 bucket.

You can't export snapshot * data from RDS Custom DB instances.

You can't export cluster data from * Multi-AZ DB clusters.

For more information on exporting DB snapshot data, * see Exporting * DB snapshot data to Amazon S3 in the Amazon RDS User Guide or Exporting * DB cluster snapshot data to Amazon S3 in the Amazon Aurora User * Guide.

For more information on exporting DB cluster data, see Exporting * DB cluster data to Amazon S3 in the Amazon Aurora User * Guide.

See Also:

AWS * API Reference

*/ virtual Model::StartExportTaskOutcome StartExportTask(const Model::StartExportTaskRequest& request) const; /** * A Callable wrapper for StartExportTask that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StartExportTaskOutcomeCallable StartExportTaskCallable(const StartExportTaskRequestT& request) const { return SubmitCallable(&RDSClient::StartExportTask, request); } /** * An Async wrapper for StartExportTask that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StartExportTaskAsync(const StartExportTaskRequestT& request, const StartExportTaskResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::StartExportTask, request, handler, context); } /** *

Stops a database activity stream that was started using the Amazon Web * Services console, the start-activity-stream CLI command, or the * StartActivityStream action.

For more information, see * Monitoring Amazon Aurora with Database Activity Streams in the Amazon * Aurora User Guide or * Monitoring Amazon RDS with Database Activity Streams in the Amazon RDS * User Guide.

See Also:

AWS * API Reference

*/ virtual Model::StopActivityStreamOutcome StopActivityStream(const Model::StopActivityStreamRequest& request) const; /** * A Callable wrapper for StopActivityStream that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopActivityStreamOutcomeCallable StopActivityStreamCallable(const StopActivityStreamRequestT& request) const { return SubmitCallable(&RDSClient::StopActivityStream, request); } /** * An Async wrapper for StopActivityStream that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopActivityStreamAsync(const StopActivityStreamRequestT& request, const StopActivityStreamResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::StopActivityStream, request, handler, context); } /** *

Stops an Amazon Aurora DB cluster. When you stop a DB cluster, Aurora retains * the DB cluster's metadata, including its endpoints and DB parameter groups. * Aurora also retains the transaction logs so you can do a point-in-time restore * if necessary.

For more information, see * Stopping and Starting an Aurora Cluster in the Amazon Aurora User * Guide.

This action only applies to Aurora DB clusters.

*

See Also:

AWS * API Reference

*/ virtual Model::StopDBClusterOutcome StopDBCluster(const Model::StopDBClusterRequest& request) const; /** * A Callable wrapper for StopDBCluster that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopDBClusterOutcomeCallable StopDBClusterCallable(const StopDBClusterRequestT& request) const { return SubmitCallable(&RDSClient::StopDBCluster, request); } /** * An Async wrapper for StopDBCluster that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopDBClusterAsync(const StopDBClusterRequestT& request, const StopDBClusterResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::StopDBCluster, request, handler, context); } /** *

Stops an Amazon RDS DB instance. When you stop a DB instance, Amazon RDS * retains the DB instance's metadata, including its endpoint, DB parameter group, * and option group membership. Amazon RDS also retains the transaction logs so you * can do a point-in-time restore if necessary.

For more information, see * Stopping an Amazon RDS DB Instance Temporarily in the Amazon RDS User * Guide.

This command doesn't apply to RDS Custom, Aurora * MySQL, and Aurora PostgreSQL. For Aurora clusters, use * StopDBCluster instead.

See Also:

AWS * API Reference

*/ virtual Model::StopDBInstanceOutcome StopDBInstance(const Model::StopDBInstanceRequest& request) const; /** * A Callable wrapper for StopDBInstance that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopDBInstanceOutcomeCallable StopDBInstanceCallable(const StopDBInstanceRequestT& request) const { return SubmitCallable(&RDSClient::StopDBInstance, request); } /** * An Async wrapper for StopDBInstance that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopDBInstanceAsync(const StopDBInstanceRequestT& request, const StopDBInstanceResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::StopDBInstance, request, handler, context); } /** *

Stops automated backup replication for a DB instance.

This command * doesn't apply to RDS Custom, Aurora MySQL, and Aurora PostgreSQL.

For * more information, see * Replicating Automated Backups to Another Amazon Web Services Region in the * Amazon RDS User Guide.

See Also:

AWS * API Reference

*/ virtual Model::StopDBInstanceAutomatedBackupsReplicationOutcome StopDBInstanceAutomatedBackupsReplication(const Model::StopDBInstanceAutomatedBackupsReplicationRequest& request) const; /** * A Callable wrapper for StopDBInstanceAutomatedBackupsReplication that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::StopDBInstanceAutomatedBackupsReplicationOutcomeCallable StopDBInstanceAutomatedBackupsReplicationCallable(const StopDBInstanceAutomatedBackupsReplicationRequestT& request) const { return SubmitCallable(&RDSClient::StopDBInstanceAutomatedBackupsReplication, request); } /** * An Async wrapper for StopDBInstanceAutomatedBackupsReplication that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void StopDBInstanceAutomatedBackupsReplicationAsync(const StopDBInstanceAutomatedBackupsReplicationRequestT& request, const StopDBInstanceAutomatedBackupsReplicationResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::StopDBInstanceAutomatedBackupsReplication, request, handler, context); } /** *

Switches over a blue/green deployment.

Before you switch over, * production traffic is routed to the databases in the blue environment. After you * switch over, production traffic is routed to the databases in the green * environment.

For more information, see Using * Amazon RDS Blue/Green Deployments for database updates in the Amazon RDS * User Guide and Using * Amazon RDS Blue/Green Deployments for database updates in the Amazon * Aurora User Guide.

See Also:

AWS * API Reference

*/ virtual Model::SwitchoverBlueGreenDeploymentOutcome SwitchoverBlueGreenDeployment(const Model::SwitchoverBlueGreenDeploymentRequest& request) const; /** * A Callable wrapper for SwitchoverBlueGreenDeployment that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SwitchoverBlueGreenDeploymentOutcomeCallable SwitchoverBlueGreenDeploymentCallable(const SwitchoverBlueGreenDeploymentRequestT& request) const { return SubmitCallable(&RDSClient::SwitchoverBlueGreenDeployment, request); } /** * An Async wrapper for SwitchoverBlueGreenDeployment that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SwitchoverBlueGreenDeploymentAsync(const SwitchoverBlueGreenDeploymentRequestT& request, const SwitchoverBlueGreenDeploymentResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::SwitchoverBlueGreenDeployment, request, handler, context); } /** *

Switches over an Oracle standby database in an Oracle Data Guard environment, * making it the new primary database. Issue this command in the Region that hosts * the current standby database.

See Also:

AWS * API Reference

*/ virtual Model::SwitchoverReadReplicaOutcome SwitchoverReadReplica(const Model::SwitchoverReadReplicaRequest& request) const; /** * A Callable wrapper for SwitchoverReadReplica that returns a future to the operation so that it can be executed in parallel to other requests. */ template Model::SwitchoverReadReplicaOutcomeCallable SwitchoverReadReplicaCallable(const SwitchoverReadReplicaRequestT& request) const { return SubmitCallable(&RDSClient::SwitchoverReadReplica, request); } /** * An Async wrapper for SwitchoverReadReplica that queues the request into a thread executor and triggers associated callback when operation has finished. */ template void SwitchoverReadReplicaAsync(const SwitchoverReadReplicaRequestT& request, const SwitchoverReadReplicaResponseReceivedHandler& handler, const std::shared_ptr& context = nullptr) const { return SubmitAsync(&RDSClient::SwitchoverReadReplica, request, handler, context); } void OverrideEndpoint(const Aws::String& endpoint); std::shared_ptr& accessEndpointProvider(); private: friend class Aws::Client::ClientWithAsyncTemplateMethods; void init(const RDSClientConfiguration& clientConfiguration); RDSClientConfiguration m_clientConfiguration; std::shared_ptr m_executor; std::shared_ptr m_endpointProvider; }; } // namespace RDS } // namespace Aws