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à.
# Comandi meta di Amazon Redshift RSQL
I comandi meta di Amazon Redshift RSQL restituiscono registri informativi su database o oggetti di database specifici. I risultati possono includere varie colonne e metadati. Altri comandi eseguono azioni specifiche. Questi comandi sono preceduti da una barra rovesciata.
## \$1d[S\$1]
Elenca le tabelle create dall'utente locale, le viste regolari, le viste di associazione tardiva e le viste materializzate. `\dS ` elenca anche tabelle e viste, come `\d`, ma gli oggetti di sistema sono inclusi nei registri restituiti. Il `+` ha come risultato la colonna aggiuntiva dei metadati `description` per tutti gli oggetti elencati. Di seguito sono riportati i registri di esempio restituiti come risultato del comando.
```
List of relations
schema | name | type | owner
--------+-----------+-------+---------
public | category | table | awsuser
public | date | table | awsuser
public | event | table | awsuser
public | listing | table | awsuser
public | sales | table | awsuser
public | users | table | awsuser
public | venue | table | awsuser
(7 rows)
```
## \$1d[S\$1] NOME
Descrive una tabella, una vista o un indice. Include i nomi e i tipi di colonna. Fornisce inoltre diststyle, configurazione di backup, data di creazione (tabelle create dopo ottobre 2018) e vincoli. Ad esempio, `\dS+ sample` restituisce le proprietà dell'oggetto. L'aggiunta di `S+` ha come risultato colonne aggiuntive incluse nei registri restituiti.
```
Table "public.sample"
Column | Type | Collation | Nullable | Default Value | Encoding | DistKey | SortKey
--------+-----------------------------+----------------+----------+---------------+-----------+---------+---------
col1 | smallint | | NO | | none | t | 1
col2 | character(100) | case_sensitive | YES | | none | f | 2
col3 | character varying(100) | case_sensitive | YES | | text32k | f | 3
col4 | timestamp without time zone | | YES | | runlength | f | 0
col5 | super | | YES | | zstd | f | 0
col6 | bigint | | YES | | az64 | f | 0
Diststyle: KEY
Backup: YES
Created: 2021-07-20 19:47:27.997045
Unique Constraints:
"sample_pkey" PRIMARY KEY (col1)
"sample_col2_key" UNIQUE (col2)
Foreign-key constraints:
"sample_col2_fkey" FOREIGN KEY (col2) REFERENCES lineitem(l_orderkey)
```
Lo stile di distribuzione o *Diststyle*, della tabella può essere KEY, AUTO, EVEN o ALL.
*Backup* indica se la tabella viene sottoposta a backup quando viene scattato uno snapshot. I valori validi sono `YES` e `NO`.
*Creato* la data e l'ora di quando viene creata la tabella. La data di creazione non è disponibile per le tabelle Amazon Redshift create prima di novembre 2018. Le tabelle create prima di questa data vengono visualizzate (non disponibile). n/a
*Vincoli unici* elenca i vincoli di chiave primaria e univoca nella tabella.
*Vincoli di chiave straniera* elenca i vincoli di chiave straniera nella tabella.
## \$1dC [\$1] [MODELLO]
Elenca i cast. Include il tipo di origine, il tipo di destinazione e se il cast è implicito.
Di seguito viene mostrato un sottoinsieme di risultati da `\dC+`.
```
List of casts
source type | target type | function | implicit? | description
-----------------------------+-----------------------------+---------------------+---------------+-------------
"char" | character | bpchar | in assignment |
"char" | character varying | text | in assignment |
"char" | integer | int4 | no |
"char" | text | text | yes |
"path" | point | point | no |
"path" | polygon | polygon | in assignment |
abstime | date | date | in assignment |
abstime | integer | (binary coercible) | no |
abstime | time without time zone | time | in assignment |
abstime | timestamp with time zone | timestamptz | yes |
abstime | timestamp without time zone | timestamp | yes |
bigint | bit | bit | no |
bigint | boolean | bool | yes |
bigint | character | bpchar | in assignment |
bigint | character varying | text | in assignment |
bigint | double precision | float8 | yes |
bigint | integer | int4 | in assignment |
bigint | numeric | numeric | yes |
bigint | oid | oid | yes |
bigint | real | float4 | yes |
bigint | regclass | oid | yes |
bigint | regoper | oid | yes |
bigint | regoperator | oid | yes |
bigint | regproc | oid | yes |
bigint | regprocedure | oid | yes |
bigint | regtype | oid | yes |
bigint | smallint | int2 | in assignment |
bigint | super | int8_partiql | in assignment |
```
## \$1dd[S] [MODELLO]
Mostra le descrizioni degli oggetti non visualizzate altrove.
## \$1de
Elenca le tabelle esterne. Sono incluse le AWS Glue Data Catalog tabelle in Hive Metastore e le tabelle federate di Amazon MySQL, Amazon PostgreSQL e RDS/Aurora Amazon Redshift. RDS/Aurora
## \$1de NOME
Descrive una tabella esterna.
L' AWS Glue esempio seguente mostra una tabella esterna.
```
# \de spectrum.lineitem
Glue External table "spectrum.lineitem"
Column | External Type | Redshift Type | Position | Partition Key | Nullable
-----------------+---------------+---------------+----------+---------------+----------
l_orderkey | bigint | bigint | 1 | 0 |
l_partkey | bigint | bigint | 2 | 0 |
l_suppkey | int | int | 3 | 0 |
l_linenumber | int | int | 4 | 0 |
l_quantity | decimal(12,2) | decimal(12,2) | 5 | 0 |
l_extendedprice | decimal(12,2) | decimal(12,2) | 6 | 0 |
l_discount | decimal(12,2) | decimal(12,2) | 7 | 0 |
l_tax | decimal(12,2) | decimal(12,2) | 8 | 0 |
l_returnflag | char(1) | char(1) | 9 | 0 |
l_linestatus | char(1) | char(1) | 10 | 0 |
l_shipdate | date | date | 11 | 0 |
l_commitdate | date | date | 12 | 0 |
l_receiptdate | date | date | 13 | 0 |
l_shipinstruct | char(25) | char(25) | 14 | 0 |
l_shipmode | char(10) | char(10) | 15 | 0 |
l_comment | varchar(44) | varchar(44) | 16 | 0 |
Location: s3://redshiftbucket/kfhose2019/12/31
Input_format: org.apache.hadoop.mapred.TextInputFormat
Output_format: org.apache.hadoop.hive.ql.io.HiveIgnoreKeyTextOutputFormat
Serialization_lib: org.apache.hadoop.hive.serde2.lazy.LazySimpleSerDe
Serde_parameters: {"field.delim":"|","serialization.format":"|"}
Parameters: {"EXTERNAL":"TRUE","numRows":"178196721475","transient_lastDdlTime":"1577771873"}
```
Un tavolo Hive Metastore.
```
# \de emr.lineitem
Hive Metastore External Table "emr.lineitem"
Column | External Type | Redshift Type | Position | Partition Key | Nullable
-----------------+---------------+---------------+----------+---------------+----------
l_orderkey | bigint | bigint | 1 | 0 |
l_partkey | bigint | bigint | 2 | 0 |
l_suppkey | int | int | 3 | 0 |
l_linenumber | int | int | 4 | 0 |
l_quantity | decimal(12,2) | decimal(12,2) | 5 | 0 |
l_extendedprice | decimal(12,2) | decimal(12,2) | 6 | 0 |
l_discount | decimal(12,2) | decimal(12,2) | 7 | 0 |
l_tax | decimal(12,2) | decimal(12,2) | 8 | 0 |
l_returnflag | char(1) | char(1) | 9 | 0 |
l_linestatus | char(1) | char(1) | 10 | 0 |
l_commitdate | date | date | 11 | 0 |
l_receiptdate | date | date | 12 | 0 |
l_shipinstruct | char(25) | char(25) | 13 | 0 |
l_shipmode | char(10) | char(10) | 14 | 0 |
l_comment | varchar(44) | varchar(44) | 15 | 0 |
l_shipdate | date | date | 16 | 1 |
Location: s3://redshiftbucket/cetas
Input_format: org.apache.hadoop.hive.ql.io.parquet.MapredParquetInputFormat
Output_format: org.apache.hadoop.hive.ql.io.parquet.MapredParquetOutputFormat
Serialization_lib: org.apache.hadoop.hive.ql.io.parquet.serde.ParquetHiveSerDe
Serde_parameters: {"serialization.format":"1"}
Parameters: {"EXTERNAL":"TRUE", "numRows":"4307207", "transient_lastDdlTime":"1626990007"}
```
Tabella esterna PostgreSQL.
```
# \de pgrsql.alltypes
Postgres Federated Table "pgrsql.alltypes"
Column | External Type | Redshift Type | Position | Partition Key | Nullable
--------+-----------------------------+-----------------------------+----------+---------------+----------
col1 | bigint | bigint | 1 | 0 |
col2 | bigint | bigint | 2 | 0 |
col5 | boolean | boolean | 3 | 0 |
col6 | box | varchar(65535) | 4 | 0 |
col7 | bytea | varchar(65535) | 5 | 0 |
col8 | character(10) | character(10) | 6 | 0 |
col9 | character varying(10) | character varying(10) | 7 | 0 |
col10 | cidr | varchar(65535) | 8 | 0 |
col11 | circle | varchar(65535) | 9 | 0 |
col12 | date | date | 10 | 0 |
col13 | double precision | double precision | 11 | 0 |
col14 | inet | varchar(65535) | 12 | 0 |
col15 | integer | integer | 13 | 0 |
col16 | interval | varchar(65535) | 14 | 0 |
col17 | json | varchar(65535) | 15 | 0 |
col18 | jsonb | varchar(65535) | 16 | 0 |
col19 | line | varchar(65535) | 17 | 0 |
col20 | lseg | varchar(65535) | 18 | 0 |
col21 | macaddr | varchar(65535) | 19 | 0 |
col22 | macaddr8 | varchar(65535) | 20 | 0 |
col23 | money | varchar(65535) | 21 | 0 |
col24 | numeric | numeric(38,20) | 22 | 0 |
col25 | path | varchar(65535) | 23 | 0 |
col26 | pg_lsn | varchar(65535) | 24 | 0 |
col28 | point | varchar(65535) | 25 | 0 |
col29 | polygon | varchar(65535) | 26 | 0 |
col30 | real | real | 27 | 0 |
col31 | smallint | smallint | 28 | 0 |
col32 | smallint | smallint | 29 | 0 |
col33 | integer | integer | 30 | 0 |
col34 | text | varchar(65535) | 31 | 0 |
col35 | time without time zone | varchar(65535) | 32 | 0 |
col36 | time with time zone | varchar(65535) | 33 | 0 |
col37 | timestamp without time zone | timestamp without time zone | 34 | 0 |
col38 | timestamp with time zone | timestamp with time zone | 35 | 0 |
col39 | tsquery | varchar(65535) | 36 | 0 |
col40 | tsvector | varchar(65535) | 37 | 0 |
col41 | txid_snapshot | varchar(65535) | 38 | 0 |
col42 | uuid | varchar(65535) | 39 | 0 |
col43 | xml | varchar(65535) | 40 | 0 |
```
## \$1df[anptw][S\$1] [MODELLO]
Elenca funzioni di vario tipo. Il comando `\df`, ad esempio, restituisce un elenco di funzioni. I risultati includono proprietà come nome, tipo di dati restituito, privilegi di accesso e metadati aggiuntivi. I tipi di funzioni possono includere trigger, procedure archiviate, funzioni di finestra e altri tipi. Quando si aggiunge `S+` al comando, ad esempio `\dfantS+`, sono incluse colonne di metadati aggiuntive, ad esempio `owner`, `security`, e `access privileges`.
## \$1dL[S\$1] [MODELLO]
Elenca i dati sui linguaggi procedurali associati al database. Le informazioni includono il nome, come plpgsql, e altri metadati, che includono se sono attendibili, privilegi di accesso e descrizione. La chiamata di esempio è, ad esempio, `\dLS+`, che elenca le lingue e le loro proprietà. Quando si aggiunge `S+` al comando, sono incluse colonne di metadati aggiuntive, ad esempio `call handler`, e `access privileges`.
Risultati di esempio:
```
List of languages
name | trusted | internal language | call handler | validator | access privileges | description
-----------+---------+-------------------+-------------------------+------------------------------------------------------------+-------------------+--------------------------------
c | f | t | - | fmgr_c_validator(oid) | | Dynamically-loaded C functions
exfunc | f | f | exfunc_call_handler() | - | rdsdb=U/rdsdb |
internal | f | t | - | fmgr_internal_validator(oid) | | Built-in functions
mlfunc | f | f | mlfunc_call_handler() | - | rdsdb=U/rdsdb |
plpgsql | t | f | plpgsql_call_handler() | plpgsql_validator(oid) | |
plpythonu | f | f | plpython_call_handler() | plpython_compiler(cstring,cstring,cstring,cstring,cstring) | rdsdb=U/rdsdb |
sql | t | t | - | fmgr_sql_validator(oid) | =U/rdsdb | SQL-language functions
```
## \$1dm[S\$1] [MODELLO]
Elenca le viste materializzate. Ad esempio, `\dmS+` elenca le viste materializzate e le relative proprietà. Quando si aggiunge `S+` al comando, sono incluse colonne di metadati aggiuntive.
## \$1dn[S\$1] [MODELLO]
Elenca schemi. Quando si aggiunge `S+` al comando, ad esempio`\dnS+`, sono incluse colonne di metadati aggiuntive, ad esempio `description` e `access privileges`.
## \$1dp [MODELLO]
Elenca i privilegi di accesso a tabella, vista e sequenza.
## \$1dt[S\$1] [MODELLO]
Elencare tabelle. Quando si aggiunge `S+` al comando, ad esempio `\dtS+`, sono incluse colonne di metadati aggiuntive, ad esempio `description` in questo caso.
## \$1du
Elenca gli utenti per il database. Include il nome e i ruoli, come utente con privilegi avanzati, e gli attributi.
## \$1dv[S\$1] [MODELLO]
Elenca le viste. Include schema, tipo e dati del proprietario. Quando si aggiunge `S+` al comando, ad esempio `\dvS+`, sono incluse colonne di metadati aggiuntive.
## \$1H
Attiva l'output HTML. Ciò è utile per restituire rapidamente risultati formattati. Ad esempio, `select * from sales; \H` restituisce i risultati della tabella di vendita, in HTML. Per tornare ai risultati tabulari, utilizzare `\q`, o silenzioso.
## \$1i
Esegue comandi da un file. Ad esempio, supponendo di avere rsql\$1steps.sql nella directory di lavoro, il seguente esegue i comandi nel file: `\i rsql_steps.sql`.
## \$1l[\$1] [MODELLO]
Elenca i database. Include proprietario, codifica e informazioni aggiuntive.
## \$1q
L'uscita, o il comando `\q`, disconnette le sessioni del database ed esce da RSQL.
## \$1sv[\$1] VISUALIZZAZIONE NOME
Mostra la definizione di una vista.
## \$1tempo
Mostra il tempo di esecuzione, ad esempio per una query.
## \$1z [MODELLO]
Lo stesso output di \$1dp.
## \$1?
Mostra le informazioni di aiuto. Il parametro facoltativo specifica l'elemento da spiegare.
## \$1USCITA
Disconnette tutte le sessioni del database ed esce da Amazon Redshift RSQL. Inoltre, puoi specificare un codice di uscita opzionale. Ad esempio, `\EXIT 15` uscirà dal terminale Amazon Redshift RSQL e restituirà il codice di uscita 15.
L'esempio seguente mostra l'output da una connessione e l'uscita da RSQL.
```
% rsql -D testuser
DSN Connected
DBMS Name: Amazon Redshift
Driver Name: Amazon Redshift ODBC Driver
Driver Version: 1.4.34.1000
Rsql Version: 1.0.1
Redshift Version: 1.0.29306
Type "help" for help.
(testcluster) user1@dev=# \exit 15
% echo $?
15
```
## \$1EXPORT
Specifica il nome di un file di esportazione utilizzato da RSQL per memorizzare le informazioni del database restituite da una istruzione SQL SELECT successiva.
export\$101.sql
```
\export report file='E:\\accounts.out'
\rset rformat off
\rset width 1500
\rset heading "General Title"
\rset titledashes on
select * from td_dwh.accounts;
\export reset
```
Output della console:
```
Rformat is off.
Target width is 1500.
Heading is set to: General Title
Titledashes is on.
(exported 40 rows)
```
## \$1 CONNESSIONE
Si connette a un database. È possibile specificare i parametri di connessione utilizzando la sintassi posizionale o come stringa di connessione.
La sintassi dei comandi è la seguente: `\logon {[DBNAME|- USERNAME|- HOST|- PORT|- [PASSWORD]] | conninfo}`
La `DBNAME` è il nome del database a cui connettersi. Il `USERNAME` è il nome utente con cui connettersi. Il `HOST` predefinito è `localhost`. Il `PORT` predefinito è `5439`.
Quando viene specificato un nome host in un comando `\LOGON`, diventa il nome host predefinito per ulteriori comandi `\LOGON`. Per modificare il nome host predefinito, specifica un nuovo `HOST` in un ulteriore comando `\LOGON`.
Output di esempio dal comando `\LOGON` per `user1`.
```
(testcluster) user1@redshiftdb=# \logon dev
DBMS Name: Amazon Redshift
Driver Name: Amazon Redshift ODBC Driver
Driver Version: 1.4.27.1000
Rsql Version: 1.0.1
You are now connected to database "dev" as user "user1".
(testcluster) user1@dev=#
```
Output di esempio per *user2*.
```
(testcluster) user1@dev=# \logon dev user2 testcluster2.example.com
Password for user user2:
DBMS Name: Amazon Redshift
Driver Name: Amazon Redshift ODBC Driver
Driver Version: 1.4.27.1000
Rsql Version: 1.0.1
You are now connected to database "dev" as user "user2" on host "testcluster2.example.com" at port "5439".
(testcluster2) user2@dev=#
```
## \$1NOTA
Un'estensione del comando `\echo`. `\REMARK` stampa la stringa specificata sul flusso di output. `\REMARK ` estende `\echo` aggiungendo la possibilità di rompere l'output su linee separate.
L'esempio seguente mostra l'output del comando.
```
(testcluster) user1@dev=# \remark 'hello//world'
hello
world
```
## \$1RSET
Il comando `\rset` imposta i parametri di comando e le variabili. `\rset` ha sia una modalità interattiva che una modalità batch. Non supporta le opzioni come opzioni bash, come *-x*, o argomenti, ad esempio *--*.
Imposta le variabili, come le seguenti:
+ ERRORLEVEL
+ HEADING e RTITLE
+ RFORMAT
+ MAXERROR
+ TITLEDASHES
+ WIDTH
Nell'esempio seguente viene specificata un'intestazione.
```
\rset heading "Winter Sales Report"
```
Per ulteriori esempi su come utilizzare `\rset`, consultare gli argomenti [Variabili di Amazon Redshift RSQL](rsql-query-tool-variables.md).
## \$1ESEGUI
Esegue lo script Amazon Redshift RSQL contenuto nel file specificato. `\RUN`estende il comando `\i` aggiungendo un'opzione per saltare le righe di intestazione in un file.
Se il nome del file include una virgola, un punto e virgola o uno spazio, racchiuderlo tra virgolette singole. Inoltre, se il testo segue il nome del file, racchiuderlo tra virgolette. In UNIX i nomi dei file rispettano la distinzione tra lettere maiuscole e minuscole. In Windows, i nomi di file non distinguono tra maiuscole e minuscole.
L'esempio seguente mostra l'output del comando.
```
(testcluster) user1@dev=# \! cat test.sql
select count(*) as lineitem_cnt from lineitem;
select count(*) as customer_cnt from customer;
select count(*) as orders_cnt from orders;
(testcluster) user1@dev=# \run file=test.sql
lineitem_cnt
--------------
4307207
(1 row)
customer_cnt
--------------
37796166
(1 row)
orders_cnt
------------
0
(1 row)
(testcluster) user1@dev=# \run file=test.sql skip=2
2 records skipped in RUN file.
orders_cnt
------------
0
(1 row)
```
## \$1SISTEMA OPERATIVO
Un alias per il comando`\!`. `\OS` esegue il comando del sistema operativo passato come parametro. Il controllo ritorna ad Amazon Redshift RSQL dopo l'esecuzione del comando. Ad esempio, è possibile eseguire il comando seguente per stampare l'ora corrente del sistema e tornare al terminale RSQL: `\os date`.
```
(testcluster) user1@dev=# \os date
Tue Sep 7 20:47:54 UTC 2021
```
## \$1VAI A
Un nuovo comando per Amazon Redshift RSQL. `\GOTO` salta tutti i comandi intervenuti e riprende l'elaborazione in base alle `\LABEL` specificate. La `\LABEL` deve essere un riferimento in avanti. Non puoi saltare a un `\LABEL` che precede lessicamente il `\GOTO`.
Di seguito viene mostrato l'output di esempio.
```
(testcluster) user1@dev=# \! cat test.sql
select count(*) as cnt from lineitem \gset
select :cnt as cnt;
\if :cnt > 100
\goto LABELB
\endif
\label LABELA
\remark 'this is label LABELA'
\label LABELB
\remark 'this is label LABELB'
(testcluster) user1@dev=# \i test.sql
cnt
---------
4307207
(1 row)
\label LABELA ignored
\label LABELB processed
this is label LABELB
```
## \$1ETICHETTA
Un nuovo comando per Amazon Redshift RSQL. `\LABEL` stabilisce un punto di ingresso per l'esecuzione del programma, come obiettivo per un comando `\GOTO`.
L'esempio seguente mostra l'output del comando.
```
(testcluster) user1@dev=# \! cat test.sql
select count(*) from lineitem limit 5;
\goto LABELB
\remark "this step was skipped by goto label";
\label LABELA
\remark 'this is label LABELA'
\label LABELB
\remark 'this is label LABELB'
(testcluster) user1@dev=# \i testgoto.sql
count
4307193
(1 row)
\label LABELA ignored
\label LABELB processed
this is label LABELB
```
## \$1SE (\$1ELSEIF, \$1ELSE, \$1ENDIF)
`\IF` e i comandi correlati eseguono in modo condizionale porzioni dello script di input. Un'estensione del comando PSQL `\if` (`\elif`, `\else`, `\endif`). `\IF` e `\ELSEIF` supportano espressioni booleane tra cui le condizioni `AND`, `OR` e `NOT`.
L'esempio seguente mostra un esempio di output dei comandi.
```
(testcluster) user1@dev=# \! cat test.sql
SELECT query FROM stv_inflight LIMIT 1 \gset
select :query as query;
\if :query > 1000000
\remark 'Query id is greater than 1000000'
\elseif :query = 1000000
\remark 'Query id is equal than 1000000'
\else
\remark 'Query id is less than 1000000'
\endif
(testcluster) user1@dev=# \i test.sql
query
--------
994803
(1 row)
Query id is less than 1000000
```
Utilizza `ERRORCODE` nella tua logica di ramificazione.
```
\if :'ERRORCODE' = '00000'
\remark 'The statement was executed without error'
\else
\remark :LAST_ERROR_MESSAGE
\endif
```
Utilizza `\GOTO` all'interno di un blocco `\IF` per controllare come viene eseguito il codice.