Struct rusoto_rds_data::RdsDataClient

pub struct RdsDataClient { /* fields omitted */ }

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

pub fn clone(&self) -> RdsDataClient

Returns a copy of the value.

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

Performs copy-assignment from source.

impl RdsData for RdsDataClient

pub fn batch_execute_statement<'life0, 'async_trait>(
    &'life0 self,
    input: BatchExecuteStatementRequest
) -> Pin<Box<dyn Future<Output = Result<BatchExecuteStatementResponse, RusotoError<BatchExecuteStatementError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: '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.

pub fn begin_transaction<'life0, 'async_trait>(
    &'life0 self,
    input: BeginTransactionRequest
) -> Pin<Box<dyn Future<Output = Result<BeginTransactionResponse, RusotoError<BeginTransactionError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: '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> 

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

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

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

Runs one or more SQL statements.

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

pub fn execute_statement<'life0, 'async_trait>(
    &'life0 self,
    input: ExecuteStatementRequest
) -> Pin<Box<dyn Future<Output = Result<ExecuteStatementResponse, RusotoError<ExecuteStatementError>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: '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.

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

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