You are viewing documentation for version 2 of the AWS SDK for Ruby. Version 3 documentation can be found here.
Class: Aws::RDSDataService::Client
- Inherits:
-
Seahorse::Client::Base
- Object
- Seahorse::Client::Base
- Aws::RDSDataService::Client
- Defined in:
- (unknown)
Overview
An API client for AWS RDS DataService. To construct a client, you need to configure a :region
and :credentials
.
rdsdataservice = Aws::RDSDataService::Client.new(
region: region_name,
credentials: credentials,
# ...
)
See #initialize for a full list of supported configuration options.
Region
You can configure a default region in the following locations:
ENV['AWS_REGION']
Aws.config[:region]
Go here for a list of supported regions.
Credentials
Default credentials are loaded automatically from the following locations:
ENV['AWS_ACCESS_KEY_ID']
andENV['AWS_SECRET_ACCESS_KEY']
Aws.config[:credentials]
- The shared credentials ini file at
~/.aws/credentials
(more information) - From an instance profile when running on EC2
You can also construct a credentials object from one of the following classes:
Alternatively, you configure credentials with :access_key_id
and
:secret_access_key
:
# load credentials from disk
creds = YAML.load(File.read('/path/to/secrets'))
Aws::RDSDataService::Client.new(
access_key_id: creds['access_key_id'],
secret_access_key: creds['secret_access_key']
)
Always load your credentials from outside your application. Avoid configuring credentials statically and never commit them to source control.
Instance Attribute Summary
Attributes inherited from Seahorse::Client::Base
Constructor collapse
-
#initialize(options = {}) ⇒ Aws::RDSDataService::Client
constructor
Constructs an API client.
API Operations collapse
-
#batch_execute_statement(options = {}) ⇒ Types::BatchExecuteStatementResponse
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.
-
#begin_transaction(options = {}) ⇒ Types::BeginTransactionResponse
Starts a SQL transaction.
<important> <p>A transaction can run for a maximum of 24 hours.
-
#commit_transaction(options = {}) ⇒ Types::CommitTransactionResponse
Ends a SQL transaction started with the
BeginTransaction
operation and commits the changes..
-
#execute_sql(options = {}) ⇒ Types::ExecuteSqlResponse
Runs one or more SQL statements.
This operation is deprecated.
-
#execute_statement(options = {}) ⇒ Types::ExecuteStatementResponse
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.
-
#rollback_transaction(options = {}) ⇒ Types::RollbackTransactionResponse
Performs a rollback of a transaction.
Instance Method Summary collapse
-
#wait_until(waiter_name, params = {}) {|waiter| ... } ⇒ Boolean
Waiters polls an API operation until a resource enters a desired state.
-
#waiter_names ⇒ Array<Symbol>
Returns the list of supported waiters.
Methods inherited from Seahorse::Client::Base
add_plugin, api, #build_request, clear_plugins, define, new, #operation, #operation_names, plugins, remove_plugin, set_api, set_plugins
Methods included from Seahorse::Client::HandlerBuilder
#handle, #handle_request, #handle_response
Constructor Details
#initialize(options = {}) ⇒ Aws::RDSDataService::Client
Constructs an API client.
Instance Method Details
#batch_execute_statement(options = {}) ⇒ Types::BatchExecuteStatementResponse
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.
#begin_transaction(options = {}) ⇒ Types::BeginTransactionResponse
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>
#commit_transaction(options = {}) ⇒ Types::CommitTransactionResponse
Ends a SQL transaction started with the BeginTransaction
operation and commits the changes.
#execute_sql(options = {}) ⇒ Types::ExecuteSqlResponse
Runs one or more SQL statements.
This operation is deprecated. Use the BatchExecuteStatement
or ExecuteStatement
operation.
#execute_statement(options = {}) ⇒ Types::ExecuteStatementResponse
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.
#rollback_transaction(options = {}) ⇒ Types::RollbackTransactionResponse
Performs a rollback of a transaction. Rolling back a transaction cancels its changes.
#wait_until(waiter_name, params = {}) {|waiter| ... } ⇒ Boolean
Waiters polls an API operation until a resource enters a desired state.
Basic Usage
Waiters will poll until they are succesful, they fail by entering a terminal state, or until a maximum number of attempts are made.
# polls in a loop, sleeping between attempts client.waiter_until(waiter_name, params)
Configuration
You can configure the maximum number of polling attempts, and the delay (in seconds) between each polling attempt. You configure waiters by passing a block to #wait_until:
# poll for ~25 seconds
client.wait_until(...) do |w|
w.max_attempts = 5
w.delay = 5
end
Callbacks
You can be notified before each polling attempt and before each
delay. If you throw :success
or :failure
from these callbacks,
it will terminate the waiter.
started_at = Time.now
client.wait_until(...) do |w|
# disable max attempts
w.max_attempts = nil
# poll for 1 hour, instead of a number of attempts
w.before_wait do |attempts, response|
throw :failure if Time.now - started_at > 3600
end
end
Handling Errors
When a waiter is successful, it returns true
. When a waiter
fails, it raises an error. All errors raised extend from
Waiters::Errors::WaiterFailed.
begin
client.wait_until(...)
rescue Aws::Waiters::Errors::WaiterFailed
# resource did not enter the desired state in time
end
#waiter_names ⇒ Array<Symbol>
Returns the list of supported waiters. The following table lists the supported waiters and the client method they call:
Waiter Name | Client Method | Default Delay: | Default Max Attempts: |
---|