Amazon Redshift non supporterà più la creazione di nuovi Python UDFs a partire dalla Patch 198. Python esistente UDFs continuerà a funzionare fino al 30 giugno 2026. Per ulteriori informazioni, consulta il [post del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.
# Chiamata dell'API dati
Puoi chiamare l'API Data o AWS CLI eseguire istruzioni SQL sul tuo cluster o gruppo di lavoro serverless. Le operazioni principali per eseguire le istruzioni SQL sono [https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_ExecuteStatement.html](https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_ExecuteStatement.html) e[https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_BatchExecuteStatement.html](https://docs.aws.amazon.com/redshift-data/latest/APIReference/API_BatchExecuteStatement.html) nel *Riferimento all'API dati di Amazon Redshift*. L'API Data supporta i linguaggi di programmazione supportati dall' AWS SDK. Per ulteriori informazioni, consultare [Strumenti per creare in AWS](https://aws.amazon.com/tools/).
Per vedere esempi di codice di chiamata all'API Data, consulta [Getting Started with Redshift Data API](https://github.com/aws-samples/getting-started-with-amazon-redshift-data-api#getting-started-with-redshift-data-api) in. *GitHub* Questo repository contiene esempi di utilizzo AWS Lambda per accedere ai dati di Amazon Redshift da Amazon EC2 e Amazon Runtime AWS Glue Data Catalog. SageMaker Esempi di linguaggi di programmazione includono Python, Go, Java e Javascript.
Puoi chiamare l'API dati utilizzando AWS CLI.
Gli esempi seguenti utilizzano AWS CLI per chiamare l'API Data. Per eseguire gli esempi, modificare i valori dei parametri in modo che corrispondano all'ambiente in uso. In molti esempi viene fornito un `cluster-identifier` per l'esecuzione in un cluster. Quando l'esecuzione avviene in un gruppo di lavoro serverless, viene fornito invece un `workgroup-name`. In questi esempi sono illustrate alcune delle operazioni dell'API dati. Per ulteriori informazioni, consultare la sezione relativa alle *informazioni di riferimento ai comandi della AWS CLI *.
I comandi nei seguenti esempi sono stati divisi e formattati per una maggiore leggibilità. Non tutti i parametri e le risposte vengono mostrati in tutti gli esempi. Per la definizione API della sintassi completa della richiesta, dei parametri di richiesta, della sintassi di risposta e degli elementi di risposta, consulta la [documentazione di riferimento dell’API dati Amazon Redshift](https://docs.aws.amazon.com/redshift-data/latest/APIReference/).
# Passaggio delle istruzioni SQL a un data warehouse Amazon Redshift
Gli esempi in questa pagina illustrano diversi modi per passare un’istruzione SQL al data warehouse
## Eseguire un’istruzione SQL
Per eseguire un'istruzione SQL, utilizzare il `aws redshift-data execute-statement` AWS CLI comando.
Il AWS CLI comando seguente esegue un'istruzione SQL su un cluster e restituisce un identificatore per recuperare i risultati. In questo esempio viene utilizzato il metodo di autenticazione Gestione dei segreti AWS .
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "select * from stl_query limit 1"
--database dev
```
Di seguito è riportato un esempio della risposta.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598323175.823,
"Database": "dev",
"Id": "c016234e-5c6c-4bc5-bb16-2c5b8ff61814",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn"
}
```
Il AWS CLI comando seguente esegue un'istruzione SQL su un cluster e restituisce un identificatore per recuperare i risultati. In questo esempio viene utilizzato il metodo di autenticazione con le credenziali temporanee.
```
aws redshift-data execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sql "select * from stl_query limit 1"
```
Di seguito è riportato un esempio della risposta.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Database": "dev",
"DbUser": "myuser",
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766"
}
```
Il AWS CLI comando seguente esegue un'istruzione SQL su un gruppo di lavoro senza server e restituisce un identificatore per recuperare i risultati. In questo esempio viene utilizzato il metodo di autenticazione con le credenziali temporanee.
```
aws redshift-data execute-statement
--database dev
--workgroup-name myworkgroup
--sql "select 1;"
```
Di seguito è riportato un esempio della risposta.
```
{
"CreatedAt": "2022-02-11T06:25:28.748000+00:00",
"Database": "dev",
"DbUser": "IAMR:RoleName",
"Id": "89dd91f5-2d43-43d3-8461-f33aa093c41e",
"WorkgroupName": "myworkgroup"
}
```
Il AWS CLI comando seguente esegue un'istruzione SQL su un cluster e restituisce un identificatore per recuperare i risultati. In questo esempio viene utilizzato il metodo di autenticazione Gestione dei segreti AWS e un token di idempotenza.
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "select * from stl_query limit 1"
--database dev
--client-token b855dced-259b-444c-bc7b-d3e8e33f94g1
```
Di seguito è riportato un esempio della risposta.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598323175.823,
"Database": "dev",
"Id": "c016234e-5c6c-4bc5-bb16-2c5b8ff61814",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn"
}
```
## Eseguire un’istruzione SQL con i parametri
Per eseguire un'istruzione SQL, utilizzare il `aws redshift-data execute-statement` AWS CLI comando.
Il AWS CLI comando seguente esegue un'istruzione SQL su un cluster e restituisce un identificatore per recuperare i risultati. In questo esempio viene utilizzato il metodo di autenticazione Gestione dei segreti AWS . Il testo SQL ha un parametro denominato `distance`. In questo caso, la distanza utilizzata nel predicato è `5`. In un'istruzione SELECT, i parametri denominati per i nomi delle colonne possono essere utilizzati solo nel predicato. I valori per i parametri specificati per l'istruzione SQL vengono specificati nell'opzione `parameters`.
```
aws redshift-data execute-statement
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--sql "SELECT ratecode FROM demo_table WHERE trip_distance > :distance"
--parameters "[{\"name\": \"distance\", \"value\": \"5\"}]"
--database dev
```
Di seguito è riportato un esempio della risposta.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598323175.823,
"Database": "dev",
"Id": "c016234e-5c6c-4bc5-bb16-2c5b8ff61814",
"SecretArn": "arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn"
}
```
La query seguente utilizza la tabella `EVENT` dal database di esempio. Per ulteriori informazioni, consultare [Tabella EVENT](https://docs.aws.amazon.com/redshift/latest/dg/r_eventtable.html) nella *Guida per gli sviluppatori di database di Amazon Redshift*.
Se non si dispone già della tabella `EVENT` nel database, è possibile crearne una utilizzando l'API dati come segue:
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "create table event( eventid integer not null distkey,
venueid smallint not null,
catid smallint not null,
dateid smallint not null sortkey,
eventname varchar(200),
starttime timestamp)"
```
Il comando seguente inserisce una riga nella tabella `EVENT`.
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "insert into event values(:eventid, :venueid::smallint, :catid, :dateid, :eventname, :starttime)"
--parameters "[{\"name\": \"eventid\", \"value\": \"1\"}, {\"name\": \"venueid\", \"value\": \"1\"},
{\"name\": \"catid\", \"value\": \"1\"},
{\"name\": \"dateid\", \"value\": \"1\"},
{\"name\": \"eventname\", \"value\": \"event 1\"},
{\"name\": \"starttime\", \"value\": \"2022-02-22\"}]"
```
Il comando seguente inserisce una seconda riga nella tabella `EVENT`. Questo esempio esegue le operazioni seguenti:
+ Il parametro denominato `id` viene utilizzato quattro volte nel testo SQL.
+ Il tipo di conversione implicita viene applicato automaticamente quando si inserisce il parametro `starttime`.
+ La colonna `venueid` è tipo cast per il tipo di dati SMALLINT.
+ Le stringhe di caratteri che rappresentano il tipo di dati DATE vengono convertite implicitamente nel tipo di dati TIMESTAMP.
+ All'interno del testo SQL è possibile utilizzare i commenti.
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "insert into event values(:id, :id::smallint, :id, :id, :eventname, :starttime) /*this is comment, and it won't apply parameterization for :id, :eventname or :starttime here*/"
--parameters "[{\"name\": \"eventname\", \"value\": \"event 2\"},
{\"name\": \"starttime\", \"value\": \"2022-02-22\"},
{\"name\": \"id\", \"value\": \"2\"}]"
```
Di seguito sono riportate le due righe inserite:
```
eventid | venueid | catid | dateid | eventname | starttime
---------+---------+-------+--------+-----------+---------------------
1 | 1 | 1 | 1 | event 1 | 2022-02-22 00:00:00
2 | 2 | 2 | 2 | event 2 | 2022-02-22 00:00:00
```
Il comando seguente utilizza un parametro denominato in una clausola WHERE per recuperare la riga in cui `eventid` è `1`.
```
aws redshift-data execute-statement
--database dev
--cluster-id mycluster-test
--db-user awsuser
--sql "select * from event where eventid=:id"
--parameters "[{\"name\": \"id\", \"value\": \"1\"}]"
```
Eseguire il comando seguente per ottenere i risultati SQL dell'istruzione SQL precedente:
```
aws redshift-data get-statement-result --id 7529ad05-b905-4d71-9ec6-8b333836eb5a
```
Vengono restituiti i risultati seguenti:
```
{
"Records": [
[
{
"longValue": 1
},
{
"longValue": 1
},
{
"longValue": 1
},
{
"longValue": 1
},
{
"stringValue": "event 1"
},
{
"stringValue": "2022-02-22 00:00:00.0"
}
]
],
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "eventid",
"length": 0,
"name": "eventid",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "venueid",
"length": 0,
"name": "venueid",
"nullable": 0,
"precision": 5,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int2"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "catid",
"length": 0,
"name": "catid",
"nullable": 0,
"precision": 5,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int2"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "dateid",
"length": 0,
"name": "dateid",
"nullable": 0,
"precision": 5,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "int2"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "eventname",
"length": 0,
"name": "eventname",
"nullable": 1,
"precision": 200,
"scale": 0,
"schemaName": "public",
"tableName": "event",
"typeName": "varchar"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"label": "starttime",
"length": 0,
"name": "starttime",
"nullable": 1,
"precision": 29,
"scale": 6,
"schemaName": "public",
"tableName": "event",
"typeName": "timestamp"
}
],
"TotalNumRows": 1
}
```
## Eseguire più istruzioni SQL
Per eseguire più istruzioni SQL con un solo comando, utilizzare il `aws redshift-data batch-execute-statement` AWS CLI comando.
Il AWS CLI comando seguente esegue tre istruzioni SQL su un cluster e restituisce un identificatore per recuperare i risultati. In questo esempio viene utilizzato il metodo di autenticazione con le credenziali temporanee.
```
aws redshift-data batch-execute-statement
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--sqls "set timezone to BST" "select * from mytable" "select * from another_table"
```
Di seguito è riportato un esempio della risposta.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Database": "dev",
"DbUser": "myuser",
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766"
}
```
# Elencare i metadati sulle istruzioni SQL
Per elencare i metadati relativi alle istruzioni SQL, utilizzate il comando. `aws redshift-data list-statements` AWS CLI L'autorizzazione per eseguire questo comando si basa sulle autorizzazioni IAM del chiamante.
Il AWS CLI comando seguente elenca le istruzioni SQL eseguite.
```
aws redshift-data list-statements
--status ALL
```
Di seguito è riportato un esempio della risposta.
```
{
"Statements": [
{
"CreatedAt": 1598306924.632,
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766",
"QueryString": "select * from stl_query limit 1",
"Status": "FINISHED",
"UpdatedAt": 1598306926.667
},
{
"CreatedAt": 1598311717.437,
"Id": "e0ebd578-58b3-46cc-8e52-8163fd7e01aa",
"QueryString": "select * from stl_query limit 1",
"Status": "FAILED",
"UpdatedAt": 1598311719.008
},
{
"CreatedAt": 1598313683.65,
"Id": "c361d4f7-8c53-4343-8c45-6b2b1166330c",
"QueryString": "select * from stl_query limit 1",
"Status": "ABORTED",
"UpdatedAt": 1598313685.495
},
{
"CreatedAt": 1598306653.333,
"Id": "a512b7bd-98c7-45d5-985b-a715f3cfde7f",
"QueryString": "select 1",
"Status": "FINISHED",
"UpdatedAt": 1598306653.992
}
]
}
```
# Descrivere i metadati relativi a un’istruzione SQL
Per ottenere le descrizioni dei metadati per un'istruzione SQL, utilizzate il `aws redshift-data describe-statement` AWS CLI comando. L'autorizzazione per eseguire questo comando si basa sulle autorizzazioni IAM del chiamante.
Il AWS CLI comando seguente descrive un'istruzione SQL.
```
aws redshift-data describe-statement
--id d9b6c0c9-0747-4bf4-b142-e8883122f766
```
Di seguito è riportato un esempio della risposta.
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": 1598306924.632,
"Duration": 1095981511,
"Id": "d9b6c0c9-0747-4bf4-b142-e8883122f766",
"QueryString": "select * from stl_query limit 1",
"RedshiftPid": 20859,
"RedshiftQueryId": 48879,
"ResultRows": 1,
"ResultSize": 4489,
"Status": "FINISHED",
"UpdatedAt": 1598306926.667
}
```
Di seguito è riportato un esempio di una risposta `describe-statement` dopo aver eseguito un comando `batch-execute-statement` con più istruzioni SQL.
```
{
"ClusterIdentifier": "mayo",
"CreatedAt": 1623979777.126,
"Duration": 6591877,
"HasResultSet": true,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652",
"RedshiftPid": 31459,
"RedshiftQueryId": 0,
"ResultRows": 2,
"ResultSize": 22,
"Status": "FINISHED",
"SubStatements": [
{
"CreatedAt": 1623979777.274,
"Duration": 3396637,
"HasResultSet": true,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:1",
"QueryString": "select 1;",
"RedshiftQueryId": -1,
"ResultRows": 1,
"ResultSize": 11,
"Status": "FINISHED",
"UpdatedAt": 1623979777.903
},
{
"CreatedAt": 1623979777.274,
"Duration": 3195240,
"HasResultSet": true,
"Id": "b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2",
"QueryString": "select 2;",
"RedshiftQueryId": -1,
"ResultRows": 1,
"ResultSize": 11,
"Status": "FINISHED",
"UpdatedAt": 1623979778.076
}
],
"UpdatedAt": 1623979778.183
}
```
# Recuperare i risultati di un’istruzione SQL
Per recuperare il risultato da un'istruzione SQL eseguita, utilizzare il `redshift-data get-statement-result-v2` AWS CLI comando `redshift-data get-statement-result` or. I risultati di `get-statement-result` sono in formato JSON. I risultati di `get-statement-result-v2` sono in formato CSV. È possibile fornire un `Id` che viene ricevuto nella risposta a `execute-statement` o `batch-execute-statement`. Il valore `Id` per un'istruzione SQL eseguita da `batch-execute-statement` può essere recuperato nel risultato di `describe-statement` ed ha un suffisso formato da due punti e un numero di sequenza, ad esempio `b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2`. Se con `batch-execute-statement` vengono eseguite più istruzioni SQL, ogni istruzione SQL avrà un valore `Id` come mostrato nella`describe-statement`. L'autorizzazione per eseguire questo comando si basa sulle autorizzazioni IAM del chiamante.
L’istruzione seguente restituisce il risultato di un’istruzione SQL eseguita da `execute-statement` che ha lasciato il valore predefinito di `ResultFormat` su `JSON`. Per recuperare i risultati, chiama l’operazione `get-statement-result`.
```
aws redshift-data get-statement-result
--id d9b6c0c9-0747-4bf4-b142-e8883122f766
```
L'istruzione seguente restituisce il risultato della seconda istruzione SQL eseguita da `batch-execute-statement`.
```
aws redshift-data get-statement-result
--id b2906c76-fa6e-4cdf-8c5f-4de1ff9b7652:2
```
Di seguito è riportato un esempio della risposta a una chiamata a `get-statement-result` in cui il risultato SQL viene restituito in formato JSON nella chiave `Records` della risposta.
```
{
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "userid",
"length": 0,
"name": "userid",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "query",
"length": 0,
"name": "query",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "label",
"length": 0,
"name": "label",
"nullable": 0,
"precision": 320,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "bpchar"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "xid",
"length": 0,
"name": "xid",
"nullable": 0,
"precision": 19,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int8"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "pid",
"length": 0,
"name": "pid",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "database",
"length": 0,
"name": "database",
"nullable": 0,
"precision": 32,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "bpchar"
},
{
"isCaseSensitive": true,
"isCurrency": false,
"isSigned": false,
"label": "querytxt",
"length": 0,
"name": "querytxt",
"nullable": 0,
"precision": 4000,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "bpchar"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"label": "starttime",
"length": 0,
"name": "starttime",
"nullable": 0,
"precision": 29,
"scale": 6,
"schemaName": "",
"tableName": "stll_query",
"typeName": "timestamp"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"label": "endtime",
"length": 0,
"name": "endtime",
"nullable": 0,
"precision": 29,
"scale": 6,
"schemaName": "",
"tableName": "stll_query",
"type": 93,
"typeName": "timestamp"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "aborted",
"length": 0,
"name": "aborted",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "insert_pristine",
"length": 0,
"name": "insert_pristine",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "concurrency_scaling_status",
"length": 0,
"name": "concurrency_scaling_status",
"nullable": 0,
"precision": 10,
"scale": 0,
"schemaName": "",
"tableName": "stll_query",
"typeName": "int4"
}
],
"Records": [
[
{
"longValue": 1
},
{
"longValue": 3
},
{
"stringValue": "health"
},
{
"longValue": 1023
},
{
"longValue": 15279
},
{
"stringValue": "dev"
},
{
"stringValue": "select system_status from stv_gui_status;"
},
{
"stringValue": "2020-08-21 17:33:51.88712"
},
{
"stringValue": "2020-08-21 17:33:52.974306"
},
{
"longValue": 0
},
{
"longValue": 0
},
{
"longValue": 6
}
]
],
"TotalNumRows": 1
}
```
L’esempio seguente mostra un’istruzione SQL eseguita da `execute-statement` per restituire risultati come JSON. La tabella `testingtable` ha tre colonne di numeri interi (col1, col2, col3) e tre righe con valori (1, 2, 3), (4, 5, 6) e (7, 8, 9).
```
aws redshift-data execute-statement
--database dev
--sql "SELECT col1, col2, col3 FROM testingtable"
--cluster-id mycluster-test
--result-format JSON
```
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": "2024-04-02T16:45:25.144000+00:00",
"Database": "dev",
"DbUser": "IAMR:Administrator",
"Id": "d468d942-6df9-4f85-8ae3-bac01a61aec3"
}
```
Di seguito è riportato un esempio della risposta a una chiamata a `get-statement-result` in cui il risultato SQL viene restituito in formato JSON nella chiave `Records` della risposta.
```
aws redshift-data get-statement-result
--id d468d942-6df9-4f85-8ae3-bac01a61aec3
```
```
{
"Records": [
[
{
"longValue": 1
},
{
"longValue": 2
},
{
"longValue": 3
}
],
[
{
"longValue": 4
},
{
"longValue": 5
},
{
"longValue": 6
}
],
[
{
"longValue": 7
},
{
"longValue": 8
},
{
"longValue": 9
}
]
],
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col1",
"name": "col1",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col2",
"name": "col2",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col3",
"name": "col3",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
}
],
"TotalNumRows": 3
}
```
L’esempio seguente mostra un’istruzione SQL eseguita da `execute-statement` per restituire i risultati in formato CSV. La tabella `testingtable` ha tre colonne di numeri interi (col1, col2, col3) e tre righe con valori (1, 2, 3), (4, 5, 6) e (7, 8, 9).
```
aws redshift-data execute-statement
--database dev
--sql "SELECT col1, col2, col3 FROM testingtable"
--cluster-id mycluster-test
--result-format CSV
```
```
{
"ClusterIdentifier": "mycluster-test",
"CreatedAt": "2024-04-02T16:45:25.144000+00:00",
"Database": "dev",
"DbUser": "IAMR:Administrator",
"Id": "d468d942-6df9-4f85-8ae3-bac01a61aec3"
}
```
Di seguito è riportato un esempio della risposta a una chiamata a `get-statement-result-v2` in cui il risultato SQL viene restituito in formato CSV nella chiave `Records` della risposta. Le righe sono separate da un ritorno a capo e una nuova riga (\$1r\$1n). La prima riga restituita in `Records` sono le intestazioni delle colonne. I risultati restituiti in formato CSV vengono restituiti in 1 MB, dove ogni blocco può memorizzare un numero qualsiasi di righe fino a 1 MB.
```
aws redshift-data get-statement-result-v2
--id d468d942-6df9-4f85-8ae3-bac01a61aec3
```
```
{
"Records": [
{
"CSVRecords": "col1,col2,col3\r\n1,2,3\r\n4,5,6\r\n7,8,9\r\n"
}
],
"ColumnMetadata": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col1",
"name": "col1",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col2",
"name": "col2",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": true,
"label": "col3",
"name": "col3",
"nullable": 1,
"precision": 10,
"scale": 0,
"schemaName": "public",
"tableName": "testingtable",
"typeName": "int4",
"length": 0
}
],
"TotalNumRows": 3,
"ResultFormat": "csv"
}
```
# Descrivere una tabella
Per ottenere i metadati che descrivono una tabella, utilizzate il `aws redshift-data describe-table` AWS CLI comando.
Il AWS CLI comando seguente esegue un'istruzione SQL su un cluster e restituisce i metadati che descrivono una tabella. In questo esempio viene utilizzato il metodo Gestione dei segreti AWS di autenticazione.
```
aws redshift-data describe-table
--cluster-identifier mycluster-test
--database dev
--schema information_schema
--table sql_features
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
```
Di seguito è riportato un esempio della risposta.
```
{
"ColumnList": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_id",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_name",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
}
]
}
```
Il AWS CLI comando seguente esegue un'istruzione SQL su un cluster che descrive una tabella. In questo esempio viene utilizzato il metodo di autenticazione con le credenziali temporanee.
```
aws redshift-data describe-table
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--schema information_schema
--table sql_features
```
Di seguito è riportato un esempio della risposta.
```
{
"ColumnList": [
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_id",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "feature_name",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "sub_feature_id",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "sub_feature_name",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "is_supported",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "is_verified_by",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
},
{
"isCaseSensitive": false,
"isCurrency": false,
"isSigned": false,
"length": 2147483647,
"name": "comments",
"nullable": 1,
"precision": 2147483647,
"scale": 0,
"schemaName": "information_schema",
"tableName": "sql_features",
"typeName": "character_data"
}
]
}
```
# Elencare i database in un cluster
Per elencare i database in un cluster, utilizzare il `aws redshift-data list-databases` AWS CLI comando.
Il AWS CLI comando seguente esegue un'istruzione SQL su un cluster per elencare i database. In questo esempio viene utilizzato il metodo di Gestione dei segreti AWS autenticazione.
```
aws redshift-data list-databases
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
```
Di seguito è riportato un esempio della risposta.
```
{
"Databases": [
"dev"
]
}
```
Il AWS CLI comando seguente esegue un'istruzione SQL su un cluster per elencare i database. In questo esempio viene utilizzato il metodo di autenticazione con le credenziali temporanee.
```
aws redshift-data list-databases
--db-user myuser
--cluster-identifier mycluster-test
--database dev
```
Di seguito è riportato un esempio della risposta.
```
{
"Databases": [
"dev"
]
}
```
# Elencare gli schemi in un database
Per elencare gli schemi in un database, utilizzare il `aws redshift-data list-schemas` AWS CLI comando.
Il AWS CLI comando seguente esegue un'istruzione SQL su un cluster per elencare gli schemi in un database. In questo esempio viene utilizzato il metodo Gestione dei segreti AWS di autenticazione.
```
aws redshift-data list-schemas
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
```
Di seguito è riportato un esempio della risposta.
```
{
"Schemas": [
"information_schema",
"pg_catalog",
"pg_internal",
"public"
]
}
```
Il AWS CLI comando seguente esegue un'istruzione SQL su un cluster per elencare gli schemi in un database. In questo esempio viene utilizzato il metodo di autenticazione con le credenziali temporanee.
```
aws redshift-data list-schemas
--db-user mysuser
--cluster-identifier mycluster-test
--database dev
```
Di seguito è riportato un esempio della risposta.
```
{
"Schemas": [
"information_schema",
"pg_catalog",
"pg_internal",
"public"
]
}
```
# Elencare le tabelle in un database
Per elencare le tabelle in un database, utilizzare il `aws redshift-data list-tables` AWS CLI comando.
Il AWS CLI comando seguente esegue un'istruzione SQL su un cluster per elencare le tabelle in un database. In questo esempio viene utilizzato il metodo di Gestione dei segreti AWS autenticazione.
```
aws redshift-data list-tables
--secret-arn arn:aws:secretsmanager:us-west-2:123456789012:secret:myuser-secret-hKgPWn
--cluster-identifier mycluster-test
--database dev
--schema information_schema
```
Di seguito è riportato un esempio della risposta.
```
{
"Tables": [
{
"name": "sql_features",
"schema": "information_schema",
"type": "SYSTEM TABLE"
},
{
"name": "sql_implementation_info",
"schema": "information_schema",
"type": "SYSTEM TABLE"
}
}
```
Il AWS CLI comando seguente esegue un'istruzione SQL su un cluster per elencare le tabelle in un database. In questo esempio viene utilizzato il metodo di autenticazione con le credenziali temporanee.
```
aws redshift-data list-tables
--db-user myuser
--cluster-identifier mycluster-test
--database dev
--schema information_schema
```
Di seguito è riportato un esempio della risposta.
```
{
"Tables": [
{
"name": "sql_features",
"schema": "information_schema",
"type": "SYSTEM TABLE"
},
{
"name": "sql_implementation_info",
"schema": "information_schema",
"type": "SYSTEM TABLE"
}
]
}
```