Amazon Redshift will no longer support the creation of new Python UDFs starting Patch 198. Existing Python UDFs will continue to function until June 30, 2026. For more information, see the [ blog post ](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
# Actions for Amazon Redshift using AWS SDKs
The following code examples demonstrate how to perform individual Amazon Redshift actions with AWS SDKs. Each example includes a link to GitHub, where you can find instructions for setting up and running the code.
These excerpts call the Amazon Redshift API and are code excerpts from larger programs that must be run in context. You can see actions in context in [Scenarios for Amazon Redshift using AWS SDKs](service_code_examples_scenarios.md).
The following examples include only the most commonly used actions. For a complete list, see the [Amazon Redshift API Reference](https://docs.aws.amazon.com/redshift/latest/APIReference/Welcome.html).
**Topics**
+ [`CreateCluster`](example_redshift_CreateCluster_section.md)
+ [`DeleteCluster`](example_redshift_DeleteCluster_section.md)
+ [`DescribeClusters`](example_redshift_DescribeClusters_section.md)
+ [`DescribeStatement`](example_redshift_DescribeStatement_section.md)
+ [`ExecuteStatement`](example_redshift_ExecuteStatement_section.md)
+ [`GetStatementResult`](example_redshift_GetStatementResult_section.md)
+ [`ListDatabases`](example_redshift_ListDatabases_section.md)
+ [`ModifyCluster`](example_redshift_ModifyCluster_section.md)
# Use `CreateCluster` with an AWS SDK or CLI
The following code examples show how to use `CreateCluster`.
Action examples are code excerpts from larger programs and must be run in context. You can see this action in context in the following code examples:
+ [Learn the basics](example_redshift_Scenario_section.md)
+ [Getting started with Amazon Redshift provisioned clusters](example_redshift_GettingStarted_039_section.md)
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Redshift#code-examples).
```
///
/// Create a new Amazon Redshift cluster.
///
/// The identifier for the cluster.
/// The name of the database.
/// The master username.
/// The master user password.
/// The node type for the cluster.
/// The cluster that was created.
public async Task CreateClusterAsync(string clusterIdentifier, string databaseName,
string masterUsername, string masterUserPassword, string nodeType = "ra3.large")
{
try
{
var request = new CreateClusterRequest
{
ClusterIdentifier = clusterIdentifier,
DBName = databaseName,
MasterUsername = masterUsername,
MasterUserPassword = masterUserPassword,
NodeType = nodeType,
NumberOfNodes = 1,
ClusterType = "single-node"
};
var response = await _redshiftClient.CreateClusterAsync(request);
Console.WriteLine($"Created cluster {clusterIdentifier}");
return response.Cluster;
}
catch (ClusterAlreadyExistsException ex)
{
Console.WriteLine($"Cluster already exists: {ex.Message}");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"Couldn't create cluster. Here's why: {ex.Message}");
throw;
}
}
```
+ For API details, see [CreateCluster](https://docs.aws.amazon.com/goto/DotNetSDKV4/redshift-2012-12-01/CreateCluster) in *AWS SDK for .NET API Reference*.
------
#### [ CLI ]
**AWS CLI**
Create a Cluster with Minimal ParametersThis example creates a cluster with the minimal set of parameters. By default, the output is in JSON format.Command:
```
aws redshift create-cluster --node-type dw.hs1.xlarge --number-of-nodes 2 --master-username adminuser --master-user-password TopSecret1 --cluster-identifier mycluster
```
Result:
```
{
"Cluster": {
"NodeType": "dw.hs1.xlarge",
"ClusterVersion": "1.0",
"PubliclyAccessible": "true",
"MasterUsername": "adminuser",
"ClusterParameterGroups": [
{
"ParameterApplyStatus": "in-sync",
"ParameterGroupName": "default.redshift-1.0"
} ],
"ClusterSecurityGroups": [
{
"Status": "active",
"ClusterSecurityGroupName": "default"
} ],
"AllowVersionUpgrade": true,
"VpcSecurityGroups": \[],
"PreferredMaintenanceWindow": "sat:03:30-sat:04:00",
"AutomatedSnapshotRetentionPeriod": 1,
"ClusterStatus": "creating",
"ClusterIdentifier": "mycluster",
"DBName": "dev",
"NumberOfNodes": 2,
"PendingModifiedValues": {
"MasterUserPassword": "\****"
}
},
"ResponseMetadata": {
"RequestId": "7cf4bcfc-64dd-11e2-bea9-49e0ce183f07"
}
}
```
+ For API details, see [CreateCluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/redshift/create-cluster.html) in *AWS CLI Command Reference*.
------
#### [ Go ]
**SDK for Go V2**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/redshift#code-examples).
```
import (
"context"
"errors"
"log"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/redshift"
"github.com/aws/aws-sdk-go-v2/service/redshift/types"
)
// RedshiftActions wraps Redshift service actions.
type RedshiftActions struct {
RedshiftClient *redshift.Client
}
// CreateCluster sends a request to create a cluster with the given clusterId using the provided credentials.
func (actor RedshiftActions) CreateCluster(ctx context.Context, clusterId string, userName string, userPassword string, nodeType string, clusterType string, publiclyAccessible bool) (*redshift.CreateClusterOutput, error) {
// Create a new Redshift cluster
input := &redshift.CreateClusterInput{
ClusterIdentifier: aws.String(clusterId),
MasterUserPassword: aws.String(userPassword),
MasterUsername: aws.String(userName),
NodeType: aws.String(nodeType),
ClusterType: aws.String(clusterType),
PubliclyAccessible: aws.Bool(publiclyAccessible),
}
var opErr *types.ClusterAlreadyExistsFault
output, err := actor.RedshiftClient.CreateCluster(ctx, input)
if err != nil && errors.As(err, &opErr) {
log.Println("Cluster already exists")
return nil, nil
} else if err != nil {
log.Printf("Failed to create Redshift cluster: %v\n", err)
return nil, err
}
log.Printf("Created cluster %s\n", *output.Cluster.ClusterIdentifier)
return output, nil
}
```
+ For API details, see [CreateCluster](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/redshift#Client.CreateCluster) in *AWS SDK for Go API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/redshift#code-examples).
Create the cluster.
```
/**
* Creates a new Amazon Redshift cluster asynchronously.
* @param clusterId the unique identifier for the cluster
* @param username the username for the administrative user
* @param userPassword the password for the administrative user
* @return a CompletableFuture that represents the asynchronous operation of creating the cluster
* @throws RuntimeException if the cluster creation fails
*/
public CompletableFuture createClusterAsync(String clusterId, String username, String userPassword) {
CreateClusterRequest clusterRequest = CreateClusterRequest.builder()
.clusterIdentifier(clusterId)
.masterUsername(username)
.masterUserPassword(userPassword)
.nodeType("ra3.4xlarge")
.publiclyAccessible(true)
.numberOfNodes(2)
.build();
return getAsyncClient().createCluster(clusterRequest)
.whenComplete((response, exception) -> {
if (response != null) {
logger.info("Created cluster ");
} else {
throw new RuntimeException("Failed to create cluster: " + exception.getMessage(), exception);
}
});
}
```
+ For API details, see [CreateCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/CreateCluster) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/redshift#code-examples).
Create the client.
```
import { RedshiftClient } from "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION";
//Set the Redshift Service Object
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```
Create the cluster.
```
// Import required AWS SDK clients and commands for Node.js
import { CreateClusterCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";
const params = {
ClusterIdentifier: "CLUSTER_NAME", // Required
NodeType: "NODE_TYPE", //Required
MasterUsername: "MASTER_USER_NAME", // Required - must be lowercase
MasterUserPassword: "MASTER_USER_PASSWORD", // Required - must contain at least one uppercase letter, and one number
ClusterType: "CLUSTER_TYPE", // Required
IAMRoleARN: "IAM_ROLE_ARN", // Optional - the ARN of an IAM role with permissions your cluster needs to access other AWS services on your behalf, such as Amazon S3.
ClusterSubnetGroupName: "CLUSTER_SUBNET_GROUPNAME", //Optional - the name of a cluster subnet group to be associated with this cluster. Defaults to 'default' if not specified.
DBName: "DATABASE_NAME", // Optional - defaults to 'dev' if not specified
Port: "PORT_NUMBER", // Optional - defaults to '5439' if not specified
};
const run = async () => {
try {
const data = await redshiftClient.send(new CreateClusterCommand(params));
console.log(
`Cluster ${data.Cluster.ClusterIdentifier} successfully created`,
);
return data; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
+ For API details, see [CreateCluster](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/redshift/command/CreateClusterCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Kotlin ]
**SDK for Kotlin**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/redshift#code-examples).
Create the cluster.
```
suspend fun createCluster(
clusterId: String?,
masterUsernameVal: String?,
masterUserPasswordVal: String?,
) {
val clusterRequest =
CreateClusterRequest {
clusterIdentifier = clusterId
availabilityZone = "us-east-1a"
masterUsername = masterUsernameVal
masterUserPassword = masterUserPasswordVal
nodeType = "ra3.4xlarge"
publiclyAccessible = true
numberOfNodes = 2
}
RedshiftClient.fromEnvironment { region = "us-east-1" }.use { redshiftClient ->
val clusterResponse = redshiftClient.createCluster(clusterRequest)
println("Created cluster ${clusterResponse.cluster?.clusterIdentifier}")
}
}
```
+ For API details, see [CreateCluster](https://sdk.amazonaws.com/kotlin/api/latest/index.html) in *AWS SDK for Kotlin API reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/redshift#code-examples).
```
class RedshiftWrapper:
"""
Encapsulates Amazon Redshift cluster operations.
"""
def __init__(self, redshift_client):
"""
:param redshift_client: A Boto3 Redshift client.
"""
self.client = redshift_client
def create_cluster(
self,
cluster_identifier,
node_type,
master_username,
master_user_password,
publicly_accessible,
number_of_nodes,
):
"""
Creates a cluster.
:param cluster_identifier: The name of the cluster.
:param node_type: The type of node in the cluster.
:param master_username: The master username.
:param master_user_password: The master user password.
:param publicly_accessible: Whether the cluster is publicly accessible.
:param number_of_nodes: The number of nodes in the cluster.
:return: The cluster.
"""
try:
cluster = self.client.create_cluster(
ClusterIdentifier=cluster_identifier,
NodeType=node_type,
MasterUsername=master_username,
MasterUserPassword=master_user_password,
PubliclyAccessible=publicly_accessible,
NumberOfNodes=number_of_nodes,
)
return cluster
except ClientError as err:
logging.error(
"Couldn't create a cluster. Here's why: %s: %s",
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
```
The following code instantiates the RedshiftWrapper object.
```
client = boto3.client("redshift")
redhift_wrapper = RedshiftWrapper(client)
```
+ For API details, see [CreateCluster](https://docs.aws.amazon.com/goto/boto3/redshift-2012-12-01/CreateCluster) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rsh#code-examples).
Create the cluster.
```
TRY.
" Example values: iv_cluster_identifier = 'my-redshift-cluster'
" Example values: iv_node_type = 'ra3.4xlarge'
" Example values: iv_master_username = 'awsuser'
" Example values: iv_master_password = 'AwsUser1000'
" Example values: iv_publicly_accessible = abap_true
" Example values: iv_number_of_nodes = 2
oo_result = lo_rsh->createcluster(
iv_clusteridentifier = iv_cluster_identifier
iv_nodetype = iv_node_type
iv_masterusername = iv_master_username
iv_masteruserpassword = iv_master_password
iv_publiclyaccessible = iv_publicly_accessible
iv_numberofnodes = iv_number_of_nodes
).
MESSAGE 'Redshift cluster created successfully.' TYPE 'I'.
CATCH /aws1/cx_rshclustalrdyexfault.
MESSAGE 'Cluster already exists.' TYPE 'I'.
CATCH /aws1/cx_rshclstquotaexcdfault.
MESSAGE 'Cluster quota exceeded.' TYPE 'I'.
ENDTRY.
```
+ For API details, see [CreateCluster](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) in *AWS SDK for SAP ABAP API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using this service with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Use `DeleteCluster` with an AWS SDK or CLI
The following code examples show how to use `DeleteCluster`.
Action examples are code excerpts from larger programs and must be run in context. You can see this action in context in the following code example:
+ [Getting started with Amazon Redshift provisioned clusters](example_redshift_GettingStarted_039_section.md)
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Redshift#code-examples).
```
///
/// Delete an Amazon Redshift cluster without a final snapshot.
///
/// The identifier for the cluster.
/// True if successful.
public async Task DeleteClusterWithoutSnapshotAsync(string clusterIdentifier)
{
try
{
var request = new DeleteClusterRequest
{
ClusterIdentifier = clusterIdentifier,
SkipFinalClusterSnapshot = true
};
var response = await _redshiftClient.DeleteClusterAsync(request);
Console.WriteLine($"The {clusterIdentifier} was deleted");
return true;
}
catch (ClusterNotFoundException ex)
{
Console.WriteLine($"Cluster not found: {ex.Message}");
return false;
}
catch (Exception ex)
{
Console.WriteLine($"Couldn't delete cluster. Here's why: {ex.Message}");
return false;
}
}
```
+ For API details, see [DeleteCluster](https://docs.aws.amazon.com/goto/DotNetSDKV4/redshift-2012-12-01/DeleteCluster) in *AWS SDK for .NET API Reference*.
------
#### [ CLI ]
**AWS CLI**
Delete a Cluster with No Final Cluster SnapshotThis example deletes a cluster, forcing data deletion so no final cluster snapshot is created.Command:
```
aws redshift delete-cluster --cluster-identifier mycluster --skip-final-cluster-snapshot
```
Delete a Cluster, Allowing a Final Cluster SnapshotThis example deletes a cluster, but specifies a final cluster snapshot.Command:
```
aws redshift delete-cluster --cluster-identifier mycluster --final-cluster-snapshot-identifier myfinalsnapshot
```
+ For API details, see [DeleteCluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/redshift/delete-cluster.html) in *AWS CLI Command Reference*.
------
#### [ Go ]
**SDK for Go V2**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/redshift#code-examples).
```
import (
"context"
"errors"
"log"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/redshift"
"github.com/aws/aws-sdk-go-v2/service/redshift/types"
)
// RedshiftActions wraps Redshift service actions.
type RedshiftActions struct {
RedshiftClient *redshift.Client
}
// DeleteCluster deletes the given cluster.
func (actor RedshiftActions) DeleteCluster(ctx context.Context, clusterId string) (bool, error) {
input := redshift.DeleteClusterInput{
ClusterIdentifier: aws.String(clusterId),
SkipFinalClusterSnapshot: aws.Bool(true),
}
_, err := actor.RedshiftClient.DeleteCluster(ctx, &input)
var opErr *types.ClusterNotFoundFault
if err != nil && errors.As(err, &opErr) {
log.Println("Cluster was not found. Where could it be?")
return false, err
} else if err != nil {
log.Printf("Failed to delete Redshift cluster: %v\n", err)
return false, err
}
waiter := redshift.NewClusterDeletedWaiter(actor.RedshiftClient)
err = waiter.Wait(ctx, &redshift.DescribeClustersInput{
ClusterIdentifier: aws.String(clusterId),
}, 5*time.Minute)
if err != nil {
log.Printf("Wait time exceeded for deleting cluster, continuing: %v\n", err)
}
log.Printf("The cluster %s was deleted\n", clusterId)
return true, nil
}
```
+ For API details, see [DeleteCluster](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/redshift#Client.DeleteCluster) in *AWS SDK for Go API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/redshift#code-examples).
Delete the cluster.
```
/**
* Deletes a Redshift cluster asynchronously.
*
* @param clusterId the identifier of the Redshift cluster to be deleted
* @return a {@link CompletableFuture} that represents the asynchronous operation of deleting the Redshift cluster
*/
public CompletableFuture deleteRedshiftClusterAsync(String clusterId) {
DeleteClusterRequest deleteClusterRequest = DeleteClusterRequest.builder()
.clusterIdentifier(clusterId)
.skipFinalClusterSnapshot(true)
.build();
return getAsyncClient().deleteCluster(deleteClusterRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
// Handle exceptions
if (exception.getCause() instanceof RedshiftException) {
logger.info("Error: {}", exception.getMessage());
} else {
logger.info("Unexpected error: {}", exception.getMessage());
}
} else {
// Handle successful response
logger.info("The status is {}", response.cluster().clusterStatus());
}
});
}
```
+ For API details, see [DeleteCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/DeleteCluster) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/redshift#code-examples).
Create the client.
```
import { RedshiftClient } from "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION";
//Set the Redshift Service Object
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```
Create the cluster.
```
// Import required AWS SDK clients and commands for Node.js
import { DeleteClusterCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";
const params = {
ClusterIdentifier: "CLUSTER_NAME",
SkipFinalClusterSnapshot: false,
FinalClusterSnapshotIdentifier: "CLUSTER_SNAPSHOT_ID",
};
const run = async () => {
try {
const data = await redshiftClient.send(new DeleteClusterCommand(params));
console.log("Success, cluster deleted. ", data);
return data; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
+ For API details, see [DeleteCluster](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/redshift/command/DeleteClusterCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Kotlin ]
**SDK for Kotlin**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/redshift#code-examples).
Delete the cluster.
```
suspend fun deleteRedshiftCluster(clusterId: String?) {
val request =
DeleteClusterRequest {
clusterIdentifier = clusterId
skipFinalClusterSnapshot = true
}
RedshiftClient.fromEnvironment { region = "us-west-2" }.use { redshiftClient ->
val response = redshiftClient.deleteCluster(request)
println("The status is ${response.cluster?.clusterStatus}")
}
}
```
+ For API details, see [DeleteCluster](https://sdk.amazonaws.com/kotlin/api/latest/index.html) in *AWS SDK for Kotlin API reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/redshift#code-examples).
```
class RedshiftWrapper:
"""
Encapsulates Amazon Redshift cluster operations.
"""
def __init__(self, redshift_client):
"""
:param redshift_client: A Boto3 Redshift client.
"""
self.client = redshift_client
def delete_cluster(self, cluster_identifier):
"""
Deletes a cluster.
:param cluster_identifier: The cluster identifier.
"""
try:
self.client.delete_cluster(
ClusterIdentifier=cluster_identifier, SkipFinalClusterSnapshot=True
)
except ClientError as err:
logging.error(
"Couldn't delete a cluster. Here's why: %s: %s",
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
```
The following code instantiates the RedshiftWrapper object.
```
client = boto3.client("redshift")
redhift_wrapper = RedshiftWrapper(client)
```
+ For API details, see [DeleteCluster](https://docs.aws.amazon.com/goto/boto3/redshift-2012-12-01/DeleteCluster) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rsh#code-examples).
Delete the cluster.
```
TRY.
" Example values: iv_cluster_identifier = 'my-redshift-cluster'
lo_rsh->deletecluster(
iv_clusteridentifier = iv_cluster_identifier
iv_skipfinalclustersnapshot = abap_true
).
MESSAGE 'Redshift cluster deleted successfully.' TYPE 'I'.
CATCH /aws1/cx_rshclustnotfoundfault.
MESSAGE 'Cluster not found.' TYPE 'I'.
CATCH /aws1/cx_rshinvcluststatefault.
MESSAGE 'Invalid cluster state for deletion.' TYPE 'I'.
ENDTRY.
```
+ For API details, see [DeleteCluster](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) in *AWS SDK for SAP ABAP API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using this service with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Use `DescribeClusters` with an AWS SDK or CLI
The following code examples show how to use `DescribeClusters`.
Action examples are code excerpts from larger programs and must be run in context. You can see this action in context in the following code examples:
+ [Learn the basics](example_redshift_Scenario_section.md)
+ [Getting started with Amazon Redshift provisioned clusters](example_redshift_GettingStarted_039_section.md)
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Redshift#code-examples).
```
///
/// Describe Amazon Redshift clusters.
///
/// Optional cluster identifier to describe a specific cluster.
/// A list of clusters.
public async Task> DescribeClustersAsync(string? clusterIdentifier = null)
{
try
{
var clusters = new List();
var request = new DescribeClustersRequest();
if (!string.IsNullOrEmpty(clusterIdentifier))
{
request.ClusterIdentifier = clusterIdentifier;
}
var clustersPaginator = _redshiftClient.Paginators.DescribeClusters(request);
await foreach (var response in clustersPaginator.Responses)
{
if (response.Clusters != null)
clusters.AddRange(response.Clusters);
}
Console.WriteLine($"{clusters.Count} cluster(s) retrieved.");
foreach (var cluster in clusters)
{
Console.WriteLine($"\t{cluster.ClusterIdentifier} (Status: {cluster.ClusterStatus})");
}
return clusters;
}
catch (ClusterNotFoundException ex)
{
Console.WriteLine($"Cluster {clusterIdentifier} not found: {ex.Message}");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"Couldn't describe clusters. Here's why: {ex.Message}");
throw;
}
}
```
+ For API details, see [DescribeClusters](https://docs.aws.amazon.com/goto/DotNetSDKV4/redshift-2012-12-01/DescribeClusters) in *AWS SDK for .NET API Reference*.
------
#### [ CLI ]
**AWS CLI**
Get a Description of All ClustersThis example returns a description of all clusters for the account. By default, the output is in JSON format.Command:
```
aws redshift describe-clusters
```
Result:
```
{
"Clusters": [
{
"NodeType": "dw.hs1.xlarge",
"Endpoint": {
"Port": 5439,
"Address": "mycluster.coqoarplqhsn.us-east-1.redshift.amazonaws.com"
},
"ClusterVersion": "1.0",
"PubliclyAccessible": "true",
"MasterUsername": "adminuser",
"ClusterParameterGroups": [
{
"ParameterApplyStatus": "in-sync",
"ParameterGroupName": "default.redshift-1.0"
} ],
"ClusterSecurityGroups": [
{
"Status": "active",
"ClusterSecurityGroupName": "default"
} ],
"AllowVersionUpgrade": true,
"VpcSecurityGroups": \[],
"AvailabilityZone": "us-east-1a",
"ClusterCreateTime": "2013-01-22T21:59:29.559Z",
"PreferredMaintenanceWindow": "sat:03:30-sat:04:00",
"AutomatedSnapshotRetentionPeriod": 1,
"ClusterStatus": "available",
"ClusterIdentifier": "mycluster",
"DBName": "dev",
"NumberOfNodes": 2,
"PendingModifiedValues": {}
} ],
"ResponseMetadata": {
"RequestId": "65b71cac-64df-11e2-8f5b-e90bd6c77476"
}
}
```
You can also obtain the same information in text format using the `--output text` option.Command:
`--output text` option.Command:
option.Command:
```
aws redshift describe-clusters --output text
```
Result:
```
dw.hs1.xlarge 1.0 true adminuser True us-east-1a 2013-01-22T21:59:29.559Z sat:03:30-sat:04:00 1 available mycluster dev 2
ENDPOINT 5439 mycluster.coqoarplqhsn.us-east-1.redshift.amazonaws.com
in-sync default.redshift-1.0
active default
PENDINGMODIFIEDVALUES
RESPONSEMETADATA 934281a8-64df-11e2-b07c-f7fbdd006c67
```
+ For API details, see [DescribeClusters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/redshift/describe-clusters.html) in *AWS CLI Command Reference*.
------
#### [ Go ]
**SDK for Go V2**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/redshift#code-examples).
```
import (
"context"
"errors"
"log"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/redshift"
"github.com/aws/aws-sdk-go-v2/service/redshift/types"
)
// RedshiftActions wraps Redshift service actions.
type RedshiftActions struct {
RedshiftClient *redshift.Client
}
// DescribeClusters returns information about the given cluster.
func (actor RedshiftActions) DescribeClusters(ctx context.Context, clusterId string) (*redshift.DescribeClustersOutput, error) {
input, err := actor.RedshiftClient.DescribeClusters(ctx, &redshift.DescribeClustersInput{
ClusterIdentifier: aws.String(clusterId),
})
var opErr *types.AccessToClusterDeniedFault
if errors.As(err, &opErr) {
println("Access to cluster denied.")
panic(err)
} else if err != nil {
println("Failed to describe Redshift clusters.")
return nil, err
}
return input, nil
}
```
+ For API details, see [DescribeClusters](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/redshift#Client.DescribeClusters) in *AWS SDK for Go API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/redshift#code-examples).
Describe the cluster.
```
/**
* Waits asynchronously for the specified cluster to become available.
* @param clusterId the identifier of the cluster to wait for
* @return a {@link CompletableFuture} that completes when the cluster is ready
*/
public CompletableFuture waitForClusterReadyAsync(String clusterId) {
DescribeClustersRequest clustersRequest = DescribeClustersRequest.builder()
.clusterIdentifier(clusterId)
.build();
logger.info("Waiting for cluster to become available. This may take a few minutes.");
long startTime = System.currentTimeMillis();
// Recursive method to poll the cluster status.
return checkClusterStatusAsync(clustersRequest, startTime);
}
private CompletableFuture checkClusterStatusAsync(DescribeClustersRequest clustersRequest, long startTime) {
return getAsyncClient().describeClusters(clustersRequest)
.thenCompose(clusterResponse -> {
List clusterList = clusterResponse.clusters();
boolean clusterReady = false;
for (Cluster cluster : clusterList) {
if ("available".equals(cluster.clusterStatus())) {
clusterReady = true;
break;
}
}
if (clusterReady) {
logger.info(String.format("Cluster is available!"));
return CompletableFuture.completedFuture(null);
} else {
long elapsedTimeMillis = System.currentTimeMillis() - startTime;
long elapsedSeconds = elapsedTimeMillis / 1000;
long minutes = elapsedSeconds / 60;
long seconds = elapsedSeconds % 60;
System.out.printf("\rElapsed Time: %02d:%02d - Waiting for cluster...", minutes, seconds);
System.out.flush();
// Wait 1 second before the next status check
return CompletableFuture.runAsync(() -> {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException("Error during sleep: " + e.getMessage(), e);
}
}).thenCompose(ignored -> checkClusterStatusAsync(clustersRequest, startTime));
}
}).exceptionally(exception -> {
throw new RuntimeException("Failed to get cluster status: " + exception.getMessage(), exception);
});
}
```
+ For API details, see [DescribeClusters](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/DescribeClusters) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/redshift#code-examples).
Create the client.
```
import { RedshiftClient } from "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION";
//Set the Redshift Service Object
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```
Describe your clusters.
```
// Import required AWS SDK clients and commands for Node.js
import { DescribeClustersCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";
const params = {
ClusterIdentifier: "CLUSTER_NAME",
};
const run = async () => {
try {
const data = await redshiftClient.send(new DescribeClustersCommand(params));
console.log("Success", data);
return data; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
+ For API details, see [DescribeClusters](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/redshift/command/DescribeClustersCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Kotlin ]
**SDK for Kotlin**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/redshift#code-examples).
Describe the cluster.
```
suspend fun describeRedshiftClusters() {
RedshiftClient.fromEnvironment { region = "us-west-2" }.use { redshiftClient ->
val clusterResponse = redshiftClient.describeClusters(DescribeClustersRequest {})
val clusterList = clusterResponse.clusters
if (clusterList != null) {
for (cluster in clusterList) {
println("Cluster database name is ${cluster.dbName}")
println("Cluster status is ${cluster.clusterStatus}")
}
}
}
}
```
+ For API details, see [DescribeClusters](https://sdk.amazonaws.com/kotlin/api/latest/index.html) in *AWS SDK for Kotlin API reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/redshift#code-examples).
```
class RedshiftWrapper:
"""
Encapsulates Amazon Redshift cluster operations.
"""
def __init__(self, redshift_client):
"""
:param redshift_client: A Boto3 Redshift client.
"""
self.client = redshift_client
def describe_clusters(self, cluster_identifier):
"""
Describes a cluster.
:param cluster_identifier: The cluster identifier.
:return: A list of clusters.
"""
try:
kwargs = {}
if cluster_identifier:
kwargs["ClusterIdentifier"] = cluster_identifier
paginator = self.client.get_paginator("describe_clusters")
clusters = []
for page in paginator.paginate(**kwargs):
clusters.extend(page["Clusters"])
return clusters
except ClientError as err:
logging.error(
"Couldn't describe a cluster. Here's why: %s: %s",
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
```
The following code instantiates the RedshiftWrapper object.
```
client = boto3.client("redshift")
redhift_wrapper = RedshiftWrapper(client)
```
+ For API details, see [DescribeClusters](https://docs.aws.amazon.com/goto/boto3/redshift-2012-12-01/DescribeClusters) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rsh#code-examples).
Describe the cluster.
```
TRY.
" Example values: iv_cluster_identifier = 'my-redshift-cluster' (optional)
oo_result = lo_rsh->describeclusters(
iv_clusteridentifier = iv_cluster_identifier
).
lt_clusters = oo_result->get_clusters( ).
lv_cluster_count = lines( lt_clusters ).
MESSAGE |Retrieved { lv_cluster_count } cluster(s).| TYPE 'I'.
CATCH /aws1/cx_rshclustnotfoundfault.
MESSAGE 'Cluster not found.' TYPE 'I'.
ENDTRY.
```
+ For API details, see [DescribeClusters](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) in *AWS SDK for SAP ABAP API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using this service with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Use `DescribeStatement` with an AWS SDK
The following code examples show how to use `DescribeStatement`.
Action examples are code excerpts from larger programs and must be run in context. You can see this action in context in the following code example:
+ [Learn the basics](example_redshift_Scenario_section.md)
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Redshift#code-examples).
```
///
/// Describe a statement execution.
///
/// The statement ID.
/// The statement description.
public async Task DescribeStatementAsync(string statementId)
{
try
{
var request = new DescribeStatementRequest
{
Id = statementId
};
var response = await _redshiftDataClient.DescribeStatementAsync(request);
return response;
}
catch (Amazon.RedshiftDataAPIService.Model.ResourceNotFoundException ex)
{
Console.WriteLine($"Statement not found: {ex.Message}");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"Couldn't describe statement. Here's why: {ex.Message}");
throw;
}
}
```
+ For API details, see [DescribeStatement](https://docs.aws.amazon.com/goto/DotNetSDKV4/redshift-2012-12-01/DescribeStatement) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/redshift#code-examples).
```
/**
* Checks the status of an SQL statement asynchronously and handles the completion of the statement.
*
* @param sqlId the ID of the SQL statement to check
* @return a {@link CompletableFuture} that completes when the SQL statement's status is either "FINISHED" or "FAILED"
*/
public CompletableFuture checkStatementAsync(String sqlId) {
DescribeStatementRequest statementRequest = DescribeStatementRequest.builder()
.id(sqlId)
.build();
return getAsyncDataClient().describeStatement(statementRequest)
.thenCompose(response -> {
String status = response.statusAsString();
logger.info("... Status: {} ", status);
if ("FAILED".equals(status)) {
throw new RuntimeException("The Query Failed. Ending program");
} else if ("FINISHED".equals(status)) {
return CompletableFuture.completedFuture(null);
} else {
// Sleep for 1 second and recheck status
return CompletableFuture.runAsync(() -> {
try {
TimeUnit.SECONDS.sleep(1);
} catch (InterruptedException e) {
throw new RuntimeException("Error during sleep: " + e.getMessage(), e);
}
}).thenCompose(ignore -> checkStatementAsync(sqlId)); // Recursively call until status is FINISHED or FAILED
}
}).whenComplete((result, exception) -> {
if (exception != null) {
// Handle exceptions
logger.info("Error: {} ", exception.getMessage());
} else {
logger.info("The statement is finished!");
}
});
}
```
+ For API details, see [DescribeStatement](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/DescribeStatement) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/redshift#code-examples).
```
class RedshiftDataWrapper:
"""Encapsulates Amazon Redshift data."""
def __init__(self, client):
"""
:param client: A Boto3 RedshiftDataWrapper client.
"""
self.client = client
def describe_statement(self, statement_id):
"""
Describes a SQL statement.
:param statement_id: The SQL statement identifier.
:return: The SQL statement result.
"""
try:
response = self.client.describe_statement(Id=statement_id)
return response
except ClientError as err:
logging.error(
"Couldn't describe statement. Here's why: %s: %s",
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
```
The following code instantiates the RedshiftDataWrapper object.
```
client = boto3.client("redshift-data")
redshift_data_wrapper = RedshiftDataWrapper(client)
```
+ For API details, see [DescribeStatement](https://docs.aws.amazon.com/goto/boto3/redshift-2012-12-01/DescribeStatement) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rsd#code-examples).
```
TRY.
" Example values: iv_statement_id = 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
oo_result = lo_rsd->describestatement(
iv_id = iv_statement_id
).
lv_status = oo_result->get_status( ).
MESSAGE |Statement status: { lv_status }| TYPE 'I'.
CATCH /aws1/cx_rsdresourcenotfoundex.
MESSAGE 'Statement not found.' TYPE 'I'.
CATCH /aws1/cx_rsdinternalserverex.
MESSAGE 'Internal server error.' TYPE 'I'.
ENDTRY.
```
+ For API details, see [DescribeStatement](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) in *AWS SDK for SAP ABAP API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using this service with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Use `ExecuteStatement` with an AWS SDK
The following code examples show how to use `ExecuteStatement`.
Action examples are code excerpts from larger programs and must be run in context. You can see this action in context in the following code example:
+ [Learn the basics](example_redshift_Scenario_section.md)
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/redshift#code-examples).
Executes a SQL statement to create a database table.
```
/**
* Creates an asynchronous task to execute a SQL statement for creating a new table.
*
* @param clusterId the identifier of the Amazon Redshift cluster
* @param databaseName the name of the database to create the table in
* @param userName the username to use for the database connection
* @return a {@link CompletableFuture} that completes with the result of the SQL statement execution
* @throws RuntimeException if there is an error creating the table
*/
public CompletableFuture createTableAsync(String clusterId, String databaseName, String userName) {
ExecuteStatementRequest createTableRequest = ExecuteStatementRequest.builder()
.clusterIdentifier(clusterId)
.dbUser(userName)
.database(databaseName)
.sql("CREATE TABLE Movies (" +
"id INT PRIMARY KEY, " +
"title VARCHAR(100), " +
"year INT)")
.build();
return getAsyncDataClient().executeStatement(createTableRequest)
.whenComplete((response, exception) -> {
if (exception != null) {
throw new RuntimeException("Error creating table: " + exception.getMessage(), exception);
} else {
logger.info("Table created: Movies");
}
});
}
```
Executes a SQL statement to insert data into a database table.
```
/**
* Asynchronously pops a table from a JSON file.
*
* @param clusterId the ID of the cluster
* @param databaseName the name of the database
* @param userName the username
* @param fileName the name of the JSON file
* @param number the number of records to process
* @return a CompletableFuture that completes with the number of records added to the Movies table
*/
public CompletableFuture popTableAsync(String clusterId, String databaseName, String userName, String fileName, int number) {
return CompletableFuture.supplyAsync(() -> {
try {
JsonParser parser = new JsonFactory().createParser(new File(fileName));
JsonNode rootNode = new ObjectMapper().readTree(parser);
Iterator iter = rootNode.iterator();
return iter;
} catch (IOException e) {
throw new RuntimeException("Failed to read or parse JSON file: " + e.getMessage(), e);
}
}).thenCompose(iter -> processNodesAsync(clusterId, databaseName, userName, iter, number))
.whenComplete((result, exception) -> {
if (exception != null) {
logger.info("Error {} ", exception.getMessage());
} else {
logger.info("{} records were added to the Movies table." , result);
}
});
}
private CompletableFuture processNodesAsync(String clusterId, String databaseName, String userName, Iterator iter, int number) {
return CompletableFuture.supplyAsync(() -> {
int t = 0;
try {
while (iter.hasNext()) {
if (t == number)
break;
JsonNode currentNode = iter.next();
int year = currentNode.get("year").asInt();
String title = currentNode.get("title").asText();
// Use SqlParameter to avoid SQL injection.
List parameterList = new ArrayList<>();
String sqlStatement = "INSERT INTO Movies VALUES( :id , :title, :year);";
SqlParameter idParam = SqlParameter.builder()
.name("id")
.value(String.valueOf(t))
.build();
SqlParameter titleParam = SqlParameter.builder()
.name("title")
.value(title)
.build();
SqlParameter yearParam = SqlParameter.builder()
.name("year")
.value(String.valueOf(year))
.build();
parameterList.add(idParam);
parameterList.add(titleParam);
parameterList.add(yearParam);
ExecuteStatementRequest insertStatementRequest = ExecuteStatementRequest.builder()
.clusterIdentifier(clusterId)
.sql(sqlStatement)
.database(databaseName)
.dbUser(userName)
.parameters(parameterList)
.build();
getAsyncDataClient().executeStatement(insertStatementRequest);
logger.info("Inserted: " + title + " (" + year + ")");
t++;
}
} catch (RedshiftDataException e) {
throw new RuntimeException("Error inserting data: " + e.getMessage(), e);
}
return t;
});
}
```
Executes a SQL statement to query a database table.
```
/**
* Asynchronously queries movies by a given year from a Redshift database.
*
* @param database the name of the database to query
* @param dbUser the user to connect to the database with
* @param year the year to filter the movies by
* @param clusterId the identifier of the Redshift cluster to connect to
* @return a {@link CompletableFuture} containing the response ID of the executed SQL statement
*/
public CompletableFuture queryMoviesByYearAsync(String database,
String dbUser,
int year,
String clusterId) {
String sqlStatement = "SELECT * FROM Movies WHERE year = :year";
SqlParameter yearParam = SqlParameter.builder()
.name("year")
.value(String.valueOf(year))
.build();
ExecuteStatementRequest statementRequest = ExecuteStatementRequest.builder()
.clusterIdentifier(clusterId)
.database(database)
.dbUser(dbUser)
.parameters(yearParam)
.sql(sqlStatement)
.build();
return CompletableFuture.supplyAsync(() -> {
try {
ExecuteStatementResponse response = getAsyncDataClient().executeStatement(statementRequest).join(); // Use join() to wait for the result
return response.id();
} catch (RedshiftDataException e) {
throw new RuntimeException("Error executing statement: " + e.getMessage(), e);
}
}).exceptionally(exception -> {
logger.info("Error: {}", exception.getMessage());
return "";
});
}
```
+ For API details, see [ExecuteStatement](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/ExecuteStatement) in *AWS SDK for Java 2.x API Reference*.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rsd#code-examples).
```
TRY.
" Example values: iv_cluster_identifier = 'redshift-cluster-movies'
" Example values: iv_database_name = 'dev'
" Example values: iv_user_name = 'awsuser'
" Example values: iv_sql = 'SELECT * FROM movies WHERE year = :year'
" Example values: it_parameter_list - SQL parameters for parameterized queries
" Only pass parameters if the list is not empty
IF it_parameter_list IS NOT INITIAL.
oo_result = lo_rsd->executestatement(
iv_clusteridentifier = iv_cluster_identifier
iv_database = iv_database_name
iv_dbuser = iv_user_name
iv_sql = iv_sql
it_parameters = it_parameter_list
).
ELSE.
oo_result = lo_rsd->executestatement(
iv_clusteridentifier = iv_cluster_identifier
iv_database = iv_database_name
iv_dbuser = iv_user_name
iv_sql = iv_sql
).
ENDIF.
lv_statement_id = oo_result->get_id( ).
MESSAGE |Statement executed. ID: { lv_statement_id }| TYPE 'I'.
CATCH /aws1/cx_rsdexecutestatementex.
MESSAGE 'Statement execution error.' TYPE 'I'.
CATCH /aws1/cx_rsdresourcenotfoundex.
MESSAGE 'Resource not found.' TYPE 'I'.
ENDTRY.
```
+ For API details, see [ExecuteStatement](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) in *AWS SDK for SAP ABAP API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using this service with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Use `GetStatementResult` with an AWS SDK
The following code examples show how to use `GetStatementResult`.
Action examples are code excerpts from larger programs and must be run in context. You can see this action in context in the following code example:
+ [Learn the basics](example_redshift_Scenario_section.md)
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Redshift#code-examples).
```
///
/// Get the results of a statement execution.
///
/// The statement ID.
/// A list of result rows.
public async Task>> GetStatementResultAsync(string statementId)
{
try
{
var request = new GetStatementResultRequest
{
Id = statementId
};
var response = await _redshiftDataClient.GetStatementResultAsync(request);
return response.Records;
}
catch (Amazon.RedshiftDataAPIService.Model.ResourceNotFoundException ex)
{
Console.WriteLine($"Statement not found: {ex.Message}");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"Couldn't get statement result. Here's why: {ex.Message}");
throw;
}
}
```
+ For API details, see [GetStatementResult](https://docs.aws.amazon.com/goto/DotNetSDKV4/redshift-2012-12-01/GetStatementResult) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/redshift#code-examples).
Check the statement result.
```
/**
* Asynchronously retrieves the results of a statement execution.
*
* @param statementId the ID of the statement for which to retrieve the results
* @return a {@link CompletableFuture} that completes when the statement result has been processed
*/
public CompletableFuture getResultsAsync(String statementId) {
GetStatementResultRequest resultRequest = GetStatementResultRequest.builder()
.id(statementId)
.build();
return getAsyncDataClient().getStatementResult(resultRequest)
.handle((response, exception) -> {
if (exception != null) {
logger.info("Error getting statement result {} ", exception.getMessage());
throw new RuntimeException("Error getting statement result: " + exception.getMessage(), exception);
}
// Extract and print the field values using streams if the response is valid.
response.records().stream()
.flatMap(List::stream)
.map(Field::stringValue)
.filter(value -> value != null)
.forEach(value -> System.out.println("The Movie title field is " + value));
return response;
}).thenAccept(response -> {
// Optionally add more logic here if needed after handling the response
});
}
```
+ For API details, see [GetStatementResult](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/GetStatementResult) in *AWS SDK for Java 2.x API Reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/redshift#code-examples).
```
class RedshiftDataWrapper:
"""Encapsulates Amazon Redshift data."""
def __init__(self, client):
"""
:param client: A Boto3 RedshiftDataWrapper client.
"""
self.client = client
def get_statement_result(self, statement_id):
"""
Gets the result of a SQL statement.
:param statement_id: The SQL statement identifier.
:return: The SQL statement result.
"""
try:
result = {
"Records": [],
}
paginator = self.client.get_paginator("get_statement_result")
for page in paginator.paginate(Id=statement_id):
if "ColumnMetadata" not in result:
result["ColumnMetadata"] = page["ColumnMetadata"]
result["Records"].extend(page["Records"])
return result
except ClientError as err:
logging.error(
"Couldn't get statement result. Here's why: %s: %s",
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
```
The following code instantiates the RedshiftDataWrapper object.
```
client = boto3.client("redshift-data")
redshift_data_wrapper = RedshiftDataWrapper(client)
```
+ For API details, see [GetStatementResult](https://docs.aws.amazon.com/goto/boto3/redshift-2012-12-01/GetStatementResult) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rsd#code-examples).
Check the statement result.
```
TRY.
" Example values: iv_statement_id = 'xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx'
" Handle pagination for large result sets
DO.
lo_result_page = lo_rsd->getstatementresult(
iv_id = iv_statement_id
iv_nexttoken = lv_next_token
).
" Collect records from this page
lt_page_records = lo_result_page->get_records( ).
APPEND LINES OF lt_page_records TO lt_all_records.
" Check if there are more pages
lv_next_token = lo_result_page->get_nexttoken( ).
IF lv_next_token IS INITIAL.
EXIT. " No more pages
ENDIF.
ENDDO.
" For the last call, set oo_result for return value
oo_result = lo_result_page.
lv_record_count = lines( lt_all_records ).
MESSAGE |Retrieved { lv_record_count } record(s).| TYPE 'I'.
CATCH /aws1/cx_rsdresourcenotfoundex.
MESSAGE 'Statement not found or results not available.' TYPE 'I'.
CATCH /aws1/cx_rsdinternalserverex.
MESSAGE 'Internal server error.' TYPE 'I'.
ENDTRY.
```
+ For API details, see [GetStatementResult](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) in *AWS SDK for SAP ABAP API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using this service with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Use `ListDatabases` with an AWS SDK
The following code examples show how to use `ListDatabases`.
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Redshift#code-examples).
```
///
/// List databases in a Redshift cluster.
///
/// The cluster identifier.
/// The database user.
/// The database name for authentication.
/// A list of database names.
public async Task> ListDatabasesAsync(string clusterIdentifier, string dbUser, string databaseName)
{
try
{
var request = new ListDatabasesRequest
{
ClusterIdentifier = clusterIdentifier,
DbUser = dbUser,
Database = databaseName
};
var response = await _redshiftDataClient.ListDatabasesAsync(request);
var databases = new List();
foreach (var database in response.Databases)
{
Console.WriteLine($"The database name is : {database}");
databases.Add(database);
}
return databases;
}
catch (Amazon.RedshiftDataAPIService.Model.ValidationException ex)
{
Console.WriteLine($"Validation error: {ex.Message}");
throw;
}
catch (Exception ex)
{
Console.WriteLine($"Couldn't list databases. Here's why: {ex.Message}");
throw;
}
}
```
+ For API details, see [ListDatabases](https://docs.aws.amazon.com/goto/DotNetSDKV4/redshift-2012-12-01/ListDatabases) in *AWS SDK for .NET API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/redshift#code-examples).
```
/**
* Lists all databases asynchronously for the specified cluster, database user, and database.
* @param clusterId the identifier of the cluster to list databases for
* @param dbUser the database user to use for the list databases request
* @param database the database to list databases for
* @return a {@link CompletableFuture} that completes when the database listing is complete, or throws a {@link RuntimeException} if there was an error
*/
public CompletableFuture listAllDatabasesAsync(String clusterId, String dbUser, String database) {
ListDatabasesRequest databasesRequest = ListDatabasesRequest.builder()
.clusterIdentifier(clusterId)
.dbUser(dbUser)
.database(database)
.build();
// Asynchronous paginator for listing databases.
ListDatabasesPublisher databasesPaginator = getAsyncDataClient().listDatabasesPaginator(databasesRequest);
CompletableFuture future = databasesPaginator.subscribe(response -> {
response.databases().forEach(db -> {
logger.info("The database name is {} ", db);
});
});
// Return the future for asynchronous handling.
return future.exceptionally(exception -> {
throw new RuntimeException("Failed to list databases: " + exception.getMessage(), exception);
});
}
```
+ For API details, see [ListDatabases](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/ListDatabases) in *AWS SDK for Java 2.x API Reference*.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rsd#code-examples).
```
TRY.
" Example values: iv_cluster_identifier = 'redshift-cluster-movies'
" Example values: iv_database_name = 'dev'
" Example values: iv_database_user = 'awsuser'
oo_result = lo_rsd->listdatabases(
iv_clusteridentifier = iv_cluster_identifier
iv_database = iv_database_name
iv_dbuser = iv_database_user
).
lt_databases = oo_result->get_databases( ).
lv_db_count = lines( lt_databases ).
MESSAGE |Retrieved { lv_db_count } database(s).| TYPE 'I'.
CATCH /aws1/cx_rsddatabaseconnex.
MESSAGE 'Database connection error.' TYPE 'I'.
CATCH /aws1/cx_rsdresourcenotfoundex.
MESSAGE 'Cluster not found.' TYPE 'I'.
ENDTRY.
```
+ For API details, see [ListDatabases](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) in *AWS SDK for SAP ABAP API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using this service with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.
# Use `ModifyCluster` with an AWS SDK or CLI
The following code examples show how to use `ModifyCluster`.
Action examples are code excerpts from larger programs and must be run in context. You can see this action in context in the following code example:
+ [Learn the basics](example_redshift_Scenario_section.md)
------
#### [ .NET ]
**SDK for .NET (v4)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/dotnetv4/Redshift#code-examples).
```
///
/// Modify an Amazon Redshift cluster.
///
/// The identifier for the cluster.
/// The preferred maintenance window.
/// True if successful.
public async Task ModifyClusterAsync(string clusterIdentifier, string preferredMaintenanceWindow)
{
try
{
var request = new ModifyClusterRequest
{
ClusterIdentifier = clusterIdentifier,
PreferredMaintenanceWindow = preferredMaintenanceWindow
};
var response = await _redshiftClient.ModifyClusterAsync(request);
Console.WriteLine($"The modified cluster was successfully modified and has {response.Cluster.PreferredMaintenanceWindow} as the maintenance window");
return true;
}
catch (ClusterNotFoundException ex)
{
Console.WriteLine($"Cluster {clusterIdentifier} not found: {ex.Message}");
return false;
}
catch (Exception ex)
{
Console.WriteLine($"Couldn't modify cluster. Here's why: {ex.Message}");
return false;
}
}
```
+ For API details, see [ModifyCluster](https://docs.aws.amazon.com/goto/DotNetSDKV4/redshift-2012-12-01/ModifyCluster) in *AWS SDK for .NET API Reference*.
------
#### [ CLI ]
**AWS CLI**
Associate a Security Group with a ClusterThis example shows how to associate a cluster security group with the specified cluster.Command:
```
aws redshift modify-cluster --cluster-identifier mycluster --cluster-security-groups mysecuritygroup
```
Modify the Maintenance Window for a ClusterThis shows how to change the weekly preferred maintenance window for a cluster to be the minimum four hour window starting Sundays at 11:15 PM, and ending Mondays at 3:15 AM.Command:
```
aws redshift modify-cluster --cluster-identifier mycluster --preferred-maintenance-window Sun:23:15-Mon:03:15
```
Change the Master Password for the ClusterThis example shows how to change the master password for a cluster.Command:
```
aws redshift modify-cluster --cluster-identifier mycluster --master-user-password A1b2c3d4
```
+ For API details, see [ModifyCluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/redshift/modify-cluster.html) in *AWS CLI Command Reference*.
------
#### [ Go ]
**SDK for Go V2**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/gov2/redshift#code-examples).
```
import (
"context"
"errors"
"log"
"time"
"github.com/aws/aws-sdk-go-v2/aws"
"github.com/aws/aws-sdk-go-v2/service/redshift"
"github.com/aws/aws-sdk-go-v2/service/redshift/types"
)
// RedshiftActions wraps Redshift service actions.
type RedshiftActions struct {
RedshiftClient *redshift.Client
}
// ModifyCluster sets the preferred maintenance window for the given cluster.
func (actor RedshiftActions) ModifyCluster(ctx context.Context, clusterId string, maintenanceWindow string) *redshift.ModifyClusterOutput {
// Modify the cluster's maintenance window
input := &redshift.ModifyClusterInput{
ClusterIdentifier: aws.String(clusterId),
PreferredMaintenanceWindow: aws.String(maintenanceWindow),
}
var opErr *types.InvalidClusterStateFault
output, err := actor.RedshiftClient.ModifyCluster(ctx, input)
if err != nil && errors.As(err, &opErr) {
log.Println("Cluster is in an invalid state.")
panic(err)
} else if err != nil {
log.Printf("Failed to modify Redshift cluster: %v\n", err)
panic(err)
}
log.Printf("The cluster was successfully modified and now has %s as the maintenance window\n", *output.Cluster.PreferredMaintenanceWindow)
return output
}
```
+ For API details, see [ModifyCluster](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/redshift#Client.ModifyCluster) in *AWS SDK for Go API Reference*.
------
#### [ Java ]
**SDK for Java 2.x**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/redshift#code-examples).
Modify a cluster.
```
/**
* Modifies an Amazon Redshift cluster asynchronously.
*
* @param clusterId the identifier of the cluster to be modified
* @return a {@link CompletableFuture} that completes when the cluster modification is complete
*/
public CompletableFuture modifyClusterAsync(String clusterId) {
ModifyClusterRequest modifyClusterRequest = ModifyClusterRequest.builder()
.clusterIdentifier(clusterId)
.preferredMaintenanceWindow("wed:07:30-wed:08:00")
.build();
return getAsyncClient().modifyCluster(modifyClusterRequest)
.whenComplete((clusterResponse, exception) -> {
if (exception != null) {
if (exception.getCause() instanceof RedshiftException) {
logger.info("Error: {} ", exception.getMessage());
} else {
logger.info("Unexpected error: {} ", exception.getMessage());
}
} else {
logger.info("The modified cluster was successfully modified and has "
+ clusterResponse.cluster().preferredMaintenanceWindow() + " as the maintenance window");
}
});
}
```
+ For API details, see [ModifyCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/ModifyCluster) in *AWS SDK for Java 2.x API Reference*.
------
#### [ JavaScript ]
**SDK for JavaScript (v3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/redshift#code-examples).
Create the client.
```
import { RedshiftClient } from "@aws-sdk/client-redshift";
// Set the AWS Region.
const REGION = "REGION";
//Set the Redshift Service Object
const redshiftClient = new RedshiftClient({ region: REGION });
export { redshiftClient };
```
Modify a cluster.
```
// Import required AWS SDK clients and commands for Node.js
import { ModifyClusterCommand } from "@aws-sdk/client-redshift";
import { redshiftClient } from "./libs/redshiftClient.js";
// Set the parameters
const params = {
ClusterIdentifier: "CLUSTER_NAME",
MasterUserPassword: "NEW_MASTER_USER_PASSWORD",
};
const run = async () => {
try {
const data = await redshiftClient.send(new ModifyClusterCommand(params));
console.log("Success was modified.", data);
return data; // For unit tests.
} catch (err) {
console.log("Error", err);
}
};
run();
```
+ For API details, see [ModifyCluster](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/redshift/command/ModifyClusterCommand) in *AWS SDK for JavaScript API Reference*.
------
#### [ Kotlin ]
**SDK for Kotlin**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/redshift#code-examples).
Modify a cluster.
```
suspend fun modifyCluster(clusterId: String?) {
val modifyClusterRequest =
ModifyClusterRequest {
clusterIdentifier = clusterId
preferredMaintenanceWindow = "wed:07:30-wed:08:00"
}
RedshiftClient { region = "us-west-2" }.use { redshiftClient ->
val clusterResponse = redshiftClient.modifyCluster(modifyClusterRequest)
println(
"The modified cluster was successfully modified and has ${clusterResponse.cluster?.preferredMaintenanceWindow} as the maintenance window",
)
}
}
```
+ For API details, see [ModifyCluster](https://sdk.amazonaws.com/kotlin/api/latest/index.html) in *AWS SDK for Kotlin API reference*.
------
#### [ Python ]
**SDK for Python (Boto3)**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/python/example_code/redshift#code-examples).
```
class RedshiftWrapper:
"""
Encapsulates Amazon Redshift cluster operations.
"""
def __init__(self, redshift_client):
"""
:param redshift_client: A Boto3 Redshift client.
"""
self.client = redshift_client
def modify_cluster(self, cluster_identifier, preferred_maintenance_window):
"""
Modifies a cluster.
:param cluster_identifier: The cluster identifier.
:param preferred_maintenance_window: The preferred maintenance window.
"""
try:
self.client.modify_cluster(
ClusterIdentifier=cluster_identifier,
PreferredMaintenanceWindow=preferred_maintenance_window,
)
except ClientError as err:
logging.error(
"Couldn't modify a cluster. Here's why: %s: %s",
err.response["Error"]["Code"],
err.response["Error"]["Message"],
)
raise
```
The following code instantiates the RedshiftWrapper object.
```
client = boto3.client("redshift")
redhift_wrapper = RedshiftWrapper(client)
```
+ For API details, see [ModifyCluster](https://docs.aws.amazon.com/goto/boto3/redshift-2012-12-01/ModifyCluster) in *AWS SDK for Python (Boto3) API Reference*.
------
#### [ SAP ABAP ]
**SDK for SAP ABAP**
There's more on GitHub. Find the complete example and learn how to set up and run in the [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rsh#code-examples).
Modify a cluster.
```
TRY.
" Example values: iv_cluster_identifier = 'my-redshift-cluster'
" Example values: iv_pref_maintenance_wn = 'wed:07:30-wed:08:00'
lo_rsh->modifycluster(
iv_clusteridentifier = iv_cluster_identifier
iv_preferredmaintenancewin00 = iv_pref_maintenance_wn
).
MESSAGE 'Redshift cluster modified successfully.' TYPE 'I'.
CATCH /aws1/cx_rshclustnotfoundfault.
MESSAGE 'Cluster not found.' TYPE 'I'.
CATCH /aws1/cx_rshinvcluststatefault.
MESSAGE 'Invalid cluster state for modification.' TYPE 'I'.
ENDTRY.
```
+ For API details, see [ModifyCluster](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html) in *AWS SDK for SAP ABAP API reference*.
------
For a complete list of AWS SDK developer guides and code examples, see [Using this service with an AWS SDK](sdk-general-information-section.md). This topic also includes information about getting started and details about previous SDK versions.