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à.
# Esempi
I seguenti esempi dimostrano vari attributi di colonna e tabella nelle istruzioni CREATE TABLE di Amazon Redshift. Per ulteriori informazioni su CREATE TABLE, incluse le definizioni dei parametri, consulta [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Molti esempi utilizzano tabelle e dati del set di dati di esempio *TICKIT*. Per ulteriori informazioni, consulta [Database di esempio](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html).
È possibile aggiungere un prefisso al nome della tabella con il nome del database e il nome dello schema in un comando CREATE TABLE. Ad esempio, `dev_database.public.sales`. Il nome del database deve essere il database a cui si è connessi. Qualsiasi tentativo di creare oggetti di database in un altro database restituisce un errore di operazione non valida.
## Creazione di una tabella con una chiave di distribuzione, una chiave di ordinamento composta e una compressione
L'esempio seguente crea una tabella SALES nel database TICKIT con compressione definita per più colonne. LISTID è dichiarato come chiave di distribuzione e LISTID e SELLERID sono dichiarati come una chiave di ordinamento composto a più colonne. Anche i vincoli della chiave primaria e della chiave esterna sono definiti per la tabella. Prima di creare la tabella nell'esempio, potrebbe essere necessario aggiungere un vincolo UNIQUE a ogni colonna a cui fa riferimento una chiave esterna, se i vincoli non esistono.
```
create table sales(
salesid integer not null,
listid integer not null,
sellerid integer not null,
buyerid integer not null,
eventid integer not null encode mostly16,
dateid smallint not null,
qtysold smallint not null encode mostly8,
pricepaid decimal(8,2) encode delta32k,
commission decimal(8,2) encode delta32k,
saletime timestamp,
primary key(salesid),
foreign key(listid) references listing(listid),
foreign key(sellerid) references users(userid),
foreign key(buyerid) references users(userid),
foreign key(dateid) references date(dateid))
distkey(listid)
compound sortkey(listid,sellerid);
```
I risultati sono i seguenti:
```
schemaname | tablename | column | type | encoding | distkey | sortkey | notnull
-----------+-----------+------------+-----------------------------+----------+---------+---------+--------
public | sales | salesid | integer | lzo | false | 0 | true
public | sales | listid | integer | none | true | 1 | true
public | sales | sellerid | integer | none | false | 2 | true
public | sales | buyerid | integer | lzo | false | 0 | true
public | sales | eventid | integer | mostly16 | false | 0 | true
public | sales | dateid | smallint | lzo | false | 0 | true
public | sales | qtysold | smallint | mostly8 | false | 0 | true
public | sales | pricepaid | numeric(8,2) | delta32k | false | 0 | false
public | sales | commission | numeric(8,2) | delta32k | false | 0 | false
public | sales | saletime | timestamp without time zone | lzo | false | 0 | false
```
Nell'esempio seguente viene creata la tabella t1 con una colonna col1 senza distinzione tra maiuscole e minuscole.
```
create table T1 (
col1 Varchar(20) collate case_insensitive
);
insert into T1 values ('bob'), ('john'), ('Tom'), ('JOHN'), ('Bob');
```
Esecuzione di query sulla tabella:
```
select * from T1 where col1 = 'John';
col1
------
john
JOHN
(2 rows)
```
## Creazione di una tabella usando una chiave di ordinamento interlacciato
L'esempio seguente crea la tabella CUSTOMER con una chiave di ordinamento "interlacciato".
```
create table customer_interleaved (
c_custkey integer not null,
c_name varchar(25) not null,
c_address varchar(25) not null,
c_city varchar(10) not null,
c_nation varchar(15) not null,
c_region varchar(12) not null,
c_phone varchar(15) not null,
c_mktsegment varchar(10) not null)
diststyle all
interleaved sortkey (c_custkey, c_city, c_mktsegment);
```
## Creazione di una tabella utilizzando IF NOT EXISTS
L'esempio seguente crea la tabella CITIES oppure non esegue nulla e restituisce un messaggio se lo schema esiste già:
```
create table if not exists cities(
cityid integer not null,
city varchar(100) not null,
state char(2) not null);
```
## Creazione di una tabella con distribuzione ALL
L'esempio seguente crea la tabella VENUE con la distribuzione ALL.
```
create table venue(
venueid smallint not null,
venuename varchar(100),
venuecity varchar(30),
venuestate char(2),
venueseats integer,
primary key(venueid))
diststyle all;
```
## Creazione di una tabella con distribuzione EVEN
Il seguente esempio crea una tabella chiamata MYEVENT con tre colonne.
```
create table myevent(
eventid int,
eventname varchar(200),
eventcity varchar(30))
diststyle even;
```
La tabella è distribuita in modo uniforme e non è ordinata. La tabella non ha colonne DISTKEY o SORTKEY dichiarate.
```
select "column", type, encoding, distkey, sortkey
from pg_table_def where tablename = 'myevent';
column | type | encoding | distkey | sortkey
-----------+------------------------+----------+---------+---------
eventid | integer | lzo | f | 0
eventname | character varying(200) | lzo | f | 0
eventcity | character varying(30) | lzo | f | 0
(3 rows)
```
## Creazione di una tabella temporanea simile a un'altra tabella
Nell'esempio seguente viene creata una tabella temporanea denominata TEMPEVENT che eredita le colonne dalla tabella EVENT.
```
create temp table tempevent(like event);
```
Questa tabella eredita anche gli attributi DISTKEY e SORTKEY della tabella padre:
```
select "column", type, encoding, distkey, sortkey
from pg_table_def where tablename = 'tempevent';
column | type | encoding | distkey | sortkey
-----------+-----------------------------+----------+---------+---------
eventid | integer | none | t | 1
venueid | smallint | none | f | 0
catid | smallint | none | f | 0
dateid | smallint | none | f | 0
eventname | character varying(200) | lzo | f | 0
starttime | timestamp without time zone | bytedict | f | 0
(6 rows)
```
## Creazione di una tabella con una colonna IDENTITY
Nell'esempio seguente viene creata una tabella denominata VENUE\$1IDENT che ha una colonna IDENTITY denominata VENUEID. Questa colonna inizia con 0 e incrementa di 1 per ogni record. VENUEID è anche dichiarato come chiave primaria della tabella.
```
create table venue_ident(venueid bigint identity(0, 1),
venuename varchar(100),
venuecity varchar(30),
venuestate char(2),
venueseats integer,
primary key(venueid));
```
## Creazione di una tabella con una colonna IDENTITY predefinita
L'esempio seguente crea una tabella denominata `t1`. Questa tabella contiene una colonna IDENTITY denominata `hist_id` e una colonna IDENTITY predefinita denominata `base_id`.
```
CREATE TABLE t1(
hist_id BIGINT IDENTITY NOT NULL, /* Cannot be overridden */
base_id BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL, /* Can be overridden */
business_key varchar(10) ,
some_field varchar(10)
);
```
L'inserimento di una riga nella tabella mostra che entrambi i valori `hist_id` e `base_id` vengono generati.
```
INSERT INTO T1 (business_key, some_field) values ('A','MM');
```
```
SELECT * FROM t1;
hist_id | base_id | business_key | some_field
---------+---------+--------------+------------
1 | 1 | A | MM
```
L'inserimento di una seconda riga mostra che viene generato il valore predefinito per `base_id`.
```
INSERT INTO T1 (base_id, business_key, some_field) values (DEFAULT, 'B','MNOP');
```
```
SELECT * FROM t1;
hist_id | base_id | business_key | some_field
---------+---------+--------------+------------
1 | 1 | A | MM
2 | 2 | B | MNOP
```
L'inserimento di una terza riga mostra che il valore per `base_id` non deve essere univoco.
```
INSERT INTO T1 (base_id, business_key, some_field) values (2,'B','MNNN');
```
```
SELECT * FROM t1;
hist_id | base_id | business_key | some_field
---------+---------+--------------+------------
1 | 1 | A | MM
2 | 2 | B | MNOP
3 | 2 | B | MNNN
```
## Creazione di una tabella con valori di colonna DEFAULT
L'esempio seguente crea una tabella CATEGORYDEF che dichiara i valori predefiniti per ogni colonna:
```
create table categorydef(
catid smallint not null default 0,
catgroup varchar(10) default 'Special',
catname varchar(10) default 'Other',
catdesc varchar(50) default 'Special events',
primary key(catid));
insert into categorydef values(default,default,default,default);
```
```
select * from categorydef;
catid | catgroup | catname | catdesc
-------+----------+---------+----------------
0 | Special | Other | Special events
(1 row)
```
## Opzioni DISTSTYLE, DISTKEY e SORTKEY
L'esempio seguente mostra come funzionano le opzioni DISTKEY, SORTKEY e DISTSTYLE. In questo esempio, COL1 è la chiave di distribuzione; pertanto, lo stile di distribuzione deve essere impostato su KEY o non impostato. Per impostazione predefinita, la tabella non dispone della chiave di ordinamento e quindi non è ordinata:
```
create table t1(col1 int distkey, col2 int) diststyle key;
```
```
select "column", type, encoding, distkey, sortkey
from pg_table_def where tablename = 't1';
column | type | encoding | distkey | sortkey
-------+---------+----------+---------+---------
col1 | integer | az64 | t | 0
col2 | integer | az64 | f | 0
```
Nell'esempio seguente, la stessa colonna è definita come la chiave di distribuzione e la chiave di ordinamento. Di nuovo, lo stile di distribuzione deve essere impostato su KEY o non impostato.
```
create table t2(col1 int distkey sortkey, col2 int);
```
```
select "column", type, encoding, distkey, sortkey
from pg_table_def where tablename = 't2';
column | type | encoding | distkey | sortkey
-------+---------+----------+---------+---------
col1 | integer | none | t | 1
col2 | integer | az64 | f | 0
```
Nell'esempio seguente, nessuna colonna è impostata come chiave di distribuzione, COL2 è impostata come chiave di ordinamento e lo stile di distribuzione è impostato su ALL:
```
create table t3(col1 int, col2 int sortkey) diststyle all;
```
```
select "column", type, encoding, distkey, sortkey
from pg_table_def where tablename = 't3';
Column | Type | Encoding | DistKey | SortKey
-------+---------+----------+---------+--------
col1 | integer | az64 | f | 0
col2 | integer | none | f | 1
```
Nell'esempio seguente, lo stile di distribuzione è impostato su EVEN e nessuna chiave di ordinamento è definita esplicitamente, quindi la tabella è distribuita in modo uniforme ma non è ordinata.
```
create table t4(col1 int, col2 int) diststyle even;
```
```
select "column", type, encoding, distkey, sortkey
from pg_table_def where tablename = 't4';
column | type |encoding | distkey | sortkey
--------+---------+---------+---------+--------
col1 | integer | az64 | f | 0
col2 | integer | az64 | f | 0
```
## Creazione di una tabella con l'opzione ENCODE AUTO
L'esempio seguente crea la tabella `t1` con codifica di compressione automatica. ENCODE AUTO è l'impostazione di default per le tabelle quando non si specifica un tipo di codifica in nessuna colonna.
```
create table t1(c0 int, c1 varchar);
```
L'esempio seguente crea la tabella `t2` con codifica di compressione automatica specificando ENCODE AUTO.
```
create table t2(c0 int, c1 varchar) encode auto;
```
L'esempio seguente crea la tabella `t3` con codifica di compressione automatica specificando ENCODE AUTO. La colonna `c0` è definita con un tipo di codifica iniziale di DELTA. Amazon Redshift può modificare la codifica se un'altra codifica fornisce migliori prestazioni delle query.
```
create table t3(c0 int encode delta, c1 varchar) encode auto;
```
L'esempio seguente crea la tabella `t4` con codifica di compressione automatica specificando ENCODE AUTO. La colonna `c0` è definita con una codifica iniziale di DELTA e la colonna `c1` è definita con una codifica iniziale di LZO. Amazon Redshift può modificare queste codifiche se altre codifiche forniscono prestazioni di query migliori.
```
create table t4(c0 int encode delta, c1 varchar encode lzo) encode auto;
```