Struct RdsDataClient 

pub struct RdsDataClient { /* private fields */ }

A client for the AWS RDS DataService API.

Implementations

impl RdsDataClient

pub fn new(region: Region) -> RdsDataClient

Creates a client backed by the default tokio event loop.

The client will use the default credentials provider and tls client.

pub fn new_with<P, D>( request_dispatcher: D, credentials_provider: P, region: Region, ) -> RdsDataClient

where P: ProvideAwsCredentials + Send + Sync + 'static, D: DispatchSignedRequest + Send + Sync + 'static,

pub fn new_with_client(client: Client, region: Region) -> RdsDataClient

Trait Implementations

impl Clone for RdsDataClient

fn clone(&self) -> RdsDataClient

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl RdsData for RdsDataClient

fn batch_execute_statement<'life0, 'async_trait>( &'life0 self, input: BatchExecuteStatementRequest, ) -> Pin<Box<dyn Future<Output = Result<BatchExecuteStatementResponse, RusotoError<BatchExecuteStatementError>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Runs a batch SQL statement over an array of data.

You can run bulk update and insert operations for multiple records using a DML statement with different parameter sets. Bulk operations can provide a significant performance improvement over individual insert and update operations.

If a call isn't part of a transaction because it doesn't include the transactionID parameter, changes that result from the call are committed automatically.

fn begin_transaction<'life0, 'async_trait>( &'life0 self, input: BeginTransactionRequest, ) -> Pin<Box<dyn Future<Output = Result<BeginTransactionResponse, RusotoError<BeginTransactionError>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Starts a SQL transaction.

 <important> <p>A transaction can run for a maximum of 24 hours. A transaction is terminated and rolled back automatically after 24 hours.</p> <p>A transaction times out if no calls use its transaction ID in three minutes. If a transaction times out before it's committed, it's rolled back automatically.</p> <p>DDL statements inside a transaction cause an implicit commit. We recommend that you run each DDL statement in a separate <code>ExecuteStatement</code> call with <code>continueAfterTimeout</code> enabled.</p> </important> 

fn commit_transaction<'life0, 'async_trait>( &'life0 self, input: CommitTransactionRequest, ) -> Pin<Box<dyn Future<Output = Result<CommitTransactionResponse, RusotoError<CommitTransactionError>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Ends a SQL transaction started with the BeginTransaction operation and commits the changes.

fn execute_sql<'life0, 'async_trait>( &'life0 self, input: ExecuteSqlRequest, ) -> Pin<Box<dyn Future<Output = Result<ExecuteSqlResponse, RusotoError<ExecuteSqlError>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Runs one or more SQL statements.

This operation is deprecated. Use the BatchExecuteStatement or ExecuteStatement operation.

fn execute_statement<'life0, 'async_trait>( &'life0 self, input: ExecuteStatementRequest, ) -> Pin<Box<dyn Future<Output = Result<ExecuteStatementResponse, RusotoError<ExecuteStatementError>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Runs a SQL statement against a database.

If a call isn't part of a transaction because it doesn't include the transactionID parameter, changes that result from the call are committed automatically.

The response size limit is 1 MB. If the call returns more than 1 MB of response data, the call is terminated.

fn rollback_transaction<'life0, 'async_trait>( &'life0 self, input: RollbackTransactionRequest, ) -> Pin<Box<dyn Future<Output = Result<RollbackTransactionResponse, RusotoError<RollbackTransactionError>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Performs a rollback of a transaction. Rolling back a transaction cancels its changes.