Há mais exemplos de AWS SDK disponíveis no repositório [AWS Doc SDK Examples](https://github.com/awsdocs/aws-doc-sdk-examples) GitHub .
As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Ações para o Amazon Redshift usando AWS SDKs
Os exemplos de código a seguir demonstram como realizar ações individuais do Amazon Redshift com. AWS SDKs Cada exemplo inclui um link para GitHub, onde você pode encontrar instruções para configurar e executar o código.
Esses trechos chamam a API do Amazon Redshift e são trechos de código de programas maiores que devem ser executados no contexto. É possível ver as ações em contexto em [Cenários para o Amazon Redshift usando AWS SDKs](redshift_code_examples_scenarios.md).
Os exemplos a seguir incluem apenas as ações mais utilizadas. Para ver uma lista completa, consulte [Amazon Redshift API Reference](https://docs.aws.amazon.com/redshift/latest/APIReference/Welcome.html).
**Topics**
+ [`CreateCluster`](redshift_example_redshift_CreateCluster_section.md)
+ [`DeleteCluster`](redshift_example_redshift_DeleteCluster_section.md)
+ [`DescribeClusters`](redshift_example_redshift_DescribeClusters_section.md)
+ [`DescribeStatement`](redshift_example_redshift_DescribeStatement_section.md)
+ [`ExecuteStatement`](redshift_example_redshift_ExecuteStatement_section.md)
+ [`GetStatementResult`](redshift_example_redshift_GetStatementResult_section.md)
+ [`ListDatabases`](redshift_example_redshift_ListDatabases_section.md)
+ [`ModifyCluster`](redshift_example_redshift_ModifyCluster_section.md)
# Use `CreateCluster` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `CreateCluster`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Conheça os conceitos básicos](redshift_example_redshift_Scenario_section.md)
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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;
}
}
```
+ Para obter detalhes da API, consulte [CreateCluster](https://docs.aws.amazon.com/goto/DotNetSDKV4/redshift-2012-12-01/CreateCluster)a *Referência AWS SDK para .NET da API*.
------
#### [ CLI ]
**AWS CLI**
O ParametersThis exemplo Criar um cluster com mínimo cria um cluster com o conjunto mínimo de parâmetros. Por padrão, o formato da saída é JSON. Comando:
```
aws redshift create-cluster --node-type dw.hs1.xlarge --number-of-nodes 2 --master-username adminuser --master-user-password TopSecret1 --cluster-identifier mycluster
```
Resultado:
```
{
"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"
}
}
```
+ Para obter detalhes da API, consulte [CreateCluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/redshift/create-cluster.html)em *Referência de AWS CLI Comandos*.
------
#### [ Go ]
**SDK para Go V2**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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
}
```
+ Para obter detalhes da API, consulte [CreateCluster](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/redshift#Client.CreateCluster)a *Referência AWS SDK para Go da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/redshift#code-examples).
Crie o 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);
}
});
}
```
+ Para obter detalhes da API, consulte [CreateCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/CreateCluster)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e veja como configurar e executar no [Repositório de exemplos de código da AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/redshift#code-examples).
Crie o cliente.
```
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 };
```
Crie o 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();
```
+ Para obter detalhes da API, consulte [CreateCluster](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/redshift/command/CreateClusterCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Kotlin ]
**SDK para Kotlin**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/redshift#code-examples).
Crie o 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}")
}
}
```
+ Para obter detalhes da API, consulte a [CreateCluster](https://sdk.amazonaws.com/kotlin/api/latest/index.html)referência da API *AWS SDK for Kotlin*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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
```
O código a seguir instancia o RedshiftWrapper objeto.
```
client = boto3.client("redshift")
redhift_wrapper = RedshiftWrapper(client)
```
+ Para obter detalhes da API, consulte a [CreateCluster](https://docs.aws.amazon.com/goto/boto3/redshift-2012-12-01/CreateCluster)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rsh#code-examples).
Crie o 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.
```
+ Para obter detalhes da API, consulte a [CreateCluster](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------
# Use `DeleteCluster` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `DeleteCluster`.
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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;
}
}
```
+ Para obter detalhes da API, consulte [DeleteCluster](https://docs.aws.amazon.com/goto/DotNetSDKV4/redshift-2012-12-01/DeleteCluster)a *Referência AWS SDK para .NET da API*.
------
#### [ CLI ]
**AWS CLI**
O SnapshotThis exemplo Excluir um cluster sem cluster final exclui um cluster, forçando a exclusão de dados para que nenhum instantâneo final do cluster seja criado.Comando:
```
aws redshift delete-cluster --cluster-identifier mycluster --skip-final-cluster-snapshot
```
Excluir um cluster, permitindo um SnapshotThis exemplo de cluster final exclui um cluster, mas especifica um instantâneo final do cluster.Comando:
```
aws redshift delete-cluster --cluster-identifier mycluster --final-cluster-snapshot-identifier myfinalsnapshot
```
+ Para obter detalhes da API, consulte [DeleteCluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/redshift/delete-cluster.html)em *Referência de AWS CLI Comandos*.
------
#### [ Go ]
**SDK para Go V2**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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
}
```
+ Para obter detalhes da API, consulte [DeleteCluster](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/redshift#Client.DeleteCluster)a *Referência AWS SDK para Go da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/redshift#code-examples).
Excluir o 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());
}
});
}
```
+ Para obter detalhes da API, consulte [DeleteCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/DeleteCluster)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e veja como configurar e executar no [Repositório de exemplos de código da AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/redshift#code-examples).
Crie o cliente.
```
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 };
```
Crie o 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();
```
+ Para obter detalhes da API, consulte [DeleteCluster](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/redshift/command/DeleteClusterCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Kotlin ]
**SDK para Kotlin**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/redshift#code-examples).
Excluir o 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}")
}
}
```
+ Para obter detalhes da API, consulte a [DeleteCluster](https://sdk.amazonaws.com/kotlin/api/latest/index.html)referência da API *AWS SDK for Kotlin*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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
```
O código a seguir instancia o RedshiftWrapper objeto.
```
client = boto3.client("redshift")
redhift_wrapper = RedshiftWrapper(client)
```
+ Para obter detalhes da API, consulte a [DeleteCluster](https://docs.aws.amazon.com/goto/boto3/redshift-2012-12-01/DeleteCluster)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rsh#code-examples).
Excluir o 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.
```
+ Para obter detalhes da API, consulte a [DeleteCluster](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------
# Use `DescribeClusters` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `DescribeClusters`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Conheça os conceitos básicos](redshift_example_redshift_Scenario_section.md)
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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;
}
}
```
+ Para obter detalhes da API, consulte [DescribeClusters](https://docs.aws.amazon.com/goto/DotNetSDKV4/redshift-2012-12-01/DescribeClusters)a *Referência AWS SDK para .NET da API*.
------
#### [ CLI ]
**AWS CLI**
O ClustersThis exemplo Obter uma descrição de tudo retorna uma descrição de todos os clusters da conta. Por padrão, o formato da saída é JSON. Comando:
```
aws redshift describe-clusters
```
Resultado:
```
{
"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"
}
}
```
Você pode obter as mesmas informações em formato de texto com a opção `--output text`. Comando:
opção `--output text`. Comando:
opção. Comando:
```
aws redshift describe-clusters --output text
```
Resultado:
```
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
```
+ Para obter detalhes da API, consulte [DescribeClusters](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/redshift/describe-clusters.html)em *Referência de AWS CLI Comandos*.
------
#### [ Go ]
**SDK para Go V2**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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
}
```
+ Para obter detalhes da API, consulte [DescribeClusters](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/redshift#Client.DescribeClusters)a *Referência AWS SDK para Go da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/redshift#code-examples).
Descrever o 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);
});
}
```
+ Para obter detalhes da API, consulte [DescribeClusters](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/DescribeClusters)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e veja como configurar e executar no [Repositório de exemplos de código da AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/redshift#code-examples).
Crie o cliente.
```
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 };
```
Descreva os 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();
```
+ Para obter detalhes da API, consulte [DescribeClusters](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/redshift/command/DescribeClustersCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Kotlin ]
**SDK para Kotlin**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/redshift#code-examples).
Descrever o 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}")
}
}
}
}
```
+ Para obter detalhes da API, consulte a [DescribeClusters](https://sdk.amazonaws.com/kotlin/api/latest/index.html)referência da API *AWS SDK for Kotlin*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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
```
O código a seguir instancia o RedshiftWrapper objeto.
```
client = boto3.client("redshift")
redhift_wrapper = RedshiftWrapper(client)
```
+ Para obter detalhes da API, consulte a [DescribeClusters](https://docs.aws.amazon.com/goto/boto3/redshift-2012-12-01/DescribeClusters)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rsh#code-examples).
Descrever o 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.
```
+ Para obter detalhes da API, consulte a [DescribeClusters](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------
# Use `DescribeStatement` com um AWS SDK
Os exemplos de código a seguir mostram como usar o `DescribeStatement`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Conheça os conceitos básicos](redshift_example_redshift_Scenario_section.md)
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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;
}
}
```
+ Para obter detalhes da API, consulte [DescribeStatement](https://docs.aws.amazon.com/goto/DotNetSDKV4/redshift-2012-12-01/DescribeStatement)a *Referência AWS SDK para .NET da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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!");
}
});
}
```
+ Para obter detalhes da API, consulte [DescribeStatement](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/DescribeStatement)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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
```
O código a seguir instancia o RedshiftDataWrapper objeto.
```
client = boto3.client("redshift-data")
redshift_data_wrapper = RedshiftDataWrapper(client)
```
+ Para obter detalhes da API, consulte a [DescribeStatement](https://docs.aws.amazon.com/goto/boto3/redshift-2012-12-01/DescribeStatement)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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.
```
+ Para obter detalhes da API, consulte a [DescribeStatement](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------
# Use `ExecuteStatement` com um AWS SDK
Os exemplos de código a seguir mostram como usar o `ExecuteStatement`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Conheça os conceitos básicos](redshift_example_redshift_Scenario_section.md)
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/redshift#code-examples).
Executa uma instrução SQL para criar uma tabela de banco de dados.
```
/**
* 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");
}
});
}
```
Executa uma instrução SQL para inserir dados em uma tabela de banco de dados.
```
/**
* 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;
});
}
```
Executa uma instrução SQL para consultar uma tabela de banco de dados.
```
/**
* 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 "";
});
}
```
+ Para obter detalhes da API, consulte [ExecuteStatement](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/ExecuteStatement)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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.
```
+ Para obter detalhes da API, consulte a [ExecuteStatement](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------
# Use `GetStatementResult` com um AWS SDK
Os exemplos de código a seguir mostram como usar o `GetStatementResult`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Conheça os conceitos básicos](redshift_example_redshift_Scenario_section.md)
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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;
}
}
```
+ Para obter detalhes da API, consulte [GetStatementResult](https://docs.aws.amazon.com/goto/DotNetSDKV4/redshift-2012-12-01/GetStatementResult)a *Referência AWS SDK para .NET da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/redshift#code-examples).
Verifique o resultado da instrução
```
/**
* 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
});
}
```
+ Para obter detalhes da API, consulte [GetStatementResult](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/GetStatementResult)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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
```
O código a seguir instancia o RedshiftDataWrapper objeto.
```
client = boto3.client("redshift-data")
redshift_data_wrapper = RedshiftDataWrapper(client)
```
+ Para obter detalhes da API, consulte a [GetStatementResult](https://docs.aws.amazon.com/goto/boto3/redshift-2012-12-01/GetStatementResult)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rsd#code-examples).
Verifique o resultado da instrução
```
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.
```
+ Para obter detalhes da API, consulte a [GetStatementResult](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------
# Use `ListDatabases` com um AWS SDK
Os exemplos de código a seguir mostram como usar o `ListDatabases`.
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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;
}
}
```
+ Para obter detalhes da API, consulte [ListDatabases](https://docs.aws.amazon.com/goto/DotNetSDKV4/redshift-2012-12-01/ListDatabases)a *Referência AWS SDK para .NET da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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);
});
}
```
+ Para obter detalhes da API, consulte [ListDatabases](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/ListDatabases)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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.
```
+ Para obter detalhes da API, consulte a [ListDatabases](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------
# Use `ModifyCluster` com um AWS SDK ou CLI
Os exemplos de código a seguir mostram como usar o `ModifyCluster`.
Exemplos de ações são trechos de código de programas maiores e devem ser executados em contexto. É possível ver essa ação em contexto no seguinte exemplo de código:
+ [Conheça os conceitos básicos](redshift_example_redshift_Scenario_section.md)
------
#### [ .NET ]
**SDK para .NET (v4)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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;
}
}
```
+ Para obter detalhes da API, consulte [ModifyCluster](https://docs.aws.amazon.com/goto/DotNetSDKV4/redshift-2012-12-01/ModifyCluster)a *Referência AWS SDK para .NET da API*.
------
#### [ CLI ]
**AWS CLI**
Associar um grupo de segurança a um ClusterThis exemplo mostra como associar um grupo de segurança de cluster ao cluster especificado.Comando:
```
aws redshift modify-cluster --cluster-identifier mycluster --cluster-security-groups mysecuritygroup
```
Modificar a janela de manutenção para a ClusterThis mostra como alterar a janela de manutenção semanal preferencial de um cluster para a janela mínima de quatro horas, começando aos domingos às 23h15 e terminando às segundas-feiras às 3h15.Comando:
```
aws redshift modify-cluster --cluster-identifier mycluster --preferred-maintenance-window Sun:23:15-Mon:03:15
```
Alterar a senha mestra do ClusterThis exemplo mostra como alterar a senha mestra de um cluster.Comando:
```
aws redshift modify-cluster --cluster-identifier mycluster --master-user-password A1b2c3d4
```
+ Para obter detalhes da API, consulte [ModifyCluster](https://awscli.amazonaws.com/v2/documentation/api/latest/reference/redshift/modify-cluster.html)em *Referência de AWS CLI Comandos*.
------
#### [ Go ]
**SDK para Go V2**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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
}
```
+ Para obter detalhes da API, consulte [ModifyCluster](https://pkg.go.dev/github.com/aws/aws-sdk-go-v2/service/redshift#Client.ModifyCluster)a *Referência AWS SDK para Go da API*.
------
#### [ Java ]
**SDK para Java 2.x**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javav2/example_code/redshift#code-examples).
Modificar um 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");
}
});
}
```
+ Para obter detalhes da API, consulte [ModifyCluster](https://docs.aws.amazon.com/goto/SdkForJavaV2/redshift-2012-12-01/ModifyCluster)a *Referência AWS SDK for Java 2.x da API*.
------
#### [ JavaScript ]
**SDK para JavaScript (v3)**
Tem mais sobre GitHub. Encontre o exemplo completo e veja como configurar e executar no [Repositório de exemplos de código da AWS](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/javascriptv3/example_code/redshift#code-examples).
Crie o cliente.
```
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 };
```
Modificar um 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();
```
+ Para obter detalhes da API, consulte [ModifyCluster](https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/redshift/command/ModifyClusterCommand)a *Referência AWS SDK para JavaScript da API*.
------
#### [ Kotlin ]
**SDK para Kotlin**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/kotlin/services/redshift#code-examples).
Modificar um 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",
)
}
}
```
+ Para obter detalhes da API, consulte a [ModifyCluster](https://sdk.amazonaws.com/kotlin/api/latest/index.html)referência da API *AWS SDK for Kotlin*.
------
#### [ Python ]
**SDK para Python (Boto3)**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [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
```
O código a seguir instancia o RedshiftWrapper objeto.
```
client = boto3.client("redshift")
redhift_wrapper = RedshiftWrapper(client)
```
+ Para obter detalhes da API, consulte a [ModifyCluster](https://docs.aws.amazon.com/goto/boto3/redshift-2012-12-01/ModifyCluster)Referência da API *AWS SDK for Python (Boto3*).
------
#### [ SAP ABAP ]
**SDK para SAP ABAP**
Tem mais sobre GitHub. Encontre o exemplo completo e saiba como configurar e executar no [AWS Code Examples Repository](https://github.com/awsdocs/aws-doc-sdk-examples/tree/main/sap-abap/services/rsh#code-examples).
Modificar um 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.
```
+ Para obter detalhes da API, consulte a [ModifyCluster](https://docs.aws.amazon.com/sdk-for-sap-abap/v1/api/latest/index.html)referência da *API AWS SDK for SAP ABAP*.
------