Amazon Redshift dejará de admitir la creación de nuevas UDF de Python a partir del parche 198. Las UDF de Python existentes seguirán funcionando hasta el 30 de junio de 2026. Para obtener más información, consulte la [publicación del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/).
# Ejemplos
Los siguientes ejemplos muestran distintos atributos de tabla y columna en instrucciones CREATE TABLE de Amazon Redshift. Para obtener más información acerca de CREATE TABLE, incluidas las definiciones de parámetros, consulte [CREATE TABLE](r_CREATE_TABLE_NEW.md).
Muchos de los ejemplos utilizan tablas y datos del conjunto de datos de muestra *TICKIT*. Para obtener más información, consulte [Base de datos de muestra](https://docs.aws.amazon.com/redshift/latest/dg/c_sampledb.html).
En un comando CREATE TABLE puede anteponer el nombre de base de datos y el nombre de esquema al nombre de tabla. Por ejemplo, `dev_database.public.sales`. El nombre de base de datos debe ser la base de datos a la que está conectado. Cualquier intento de crear objetos de base de datos en otra base de datos produce un error de operación no válida.
## Crear una tabla con una clave de distribución, una clave de ordenación compuesta y compresión
En el siguiente ejemplo, se crea una tabla SALES en la base de datos TICKIT con compresión definida para varias columnas. LISTID está declarada como la clave de distribución, y LISTID y SELLERID están declaradas como una clave de ordenación compuesta de varias columnas. También se definen las restricciones de clave principal y clave externa para la tabla. Antes de crear la tabla del ejemplo, puede que necesite agregar una restricción UNIQUE a cada columna a la que haga referencia una clave externa, si no existen restricciones.
```
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);
```
Los resultados son los siguientes:
```
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
```
En el siguiente ejemplo, se crea la tabla t1 con una columna col1 que no distingue entre mayúsculas y minúsculas.
```
create table T1 (
col1 Varchar(20) collate case_insensitive
);
insert into T1 values ('bob'), ('john'), ('Tom'), ('JOHN'), ('Bob');
```
Consultar la tabla:
```
select * from T1 where col1 = 'John';
col1
------
john
JOHN
(2 rows)
```
## Crear una tabla con una clave de ordenación intercalada
En el siguiente ejemplo, se crea una tabla CUSTOMER con una clave de ordenación intercalada.
```
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);
```
## Crear una tabla con IF NOT EXISTS
En el siguiente ejemplo, se crea la tabla CITIES o no se realiza una acción y se devuelve un mensaje si ya existe:
```
create table if not exists cities(
cityid integer not null,
city varchar(100) not null,
state char(2) not null);
```
## Crear una tabla con la distribución ALL
En el siguiente ejemplo, se crea la tabla VENUE con la distribución ALL.
```
create table venue(
venueid smallint not null,
venuename varchar(100),
venuecity varchar(30),
venuestate char(2),
venueseats integer,
primary key(venueid))
diststyle all;
```
## Crear una tabla con la distribución EVEN
En el siguiente ejemplo, se crea una tabla denominada MYEVENT con tres columnas.
```
create table myevent(
eventid int,
eventname varchar(200),
eventcity varchar(30))
diststyle even;
```
La tabla se distribuye de manera uniforme y no se ordena. La tabla no tiene columnas DISTKEY o SORTKEY declaradas.
```
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)
```
## Crear una tabla temporal con el comando LIKE que sea como otra tabla
En el siguiente ejemplo, se crea una tabla temporal denominada TEMPEVENT, que hereda sus columnas de la tabla EVENT.
```
create temp table tempevent(like event);
```
Esta tabla también hereda los atributos DISTKEY y SORTKEY de su tabla principal:
```
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)
```
## Crear una tabla con una columna IDENTITY
En el siguiente ejemplo, se crea una tabla denominada VENUE\$1IDENT, que tiene una columna IDENTITY denominada VENUEID. Esta columna comienza con 0 y crece en incrementos de 1 para cada registro. VENUEID también se declara como la clave principal de la tabla.
```
create table venue_ident(venueid bigint identity(0, 1),
venuename varchar(100),
venuecity varchar(30),
venuestate char(2),
venueseats integer,
primary key(venueid));
```
## Crear una tabla con una columna IDENTITY predeterminada
En el siguiente ejemplo, se crea una tabla llamada `t1`. Esta tabla tiene una columna IDENTITY llamada `hist_id` y una columna IDENTITY predeterminada llamada `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)
);
```
Si se inserta una fila en la tabla, se generan los dos valores: `hist_id` y `base_id`.
```
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
```
Si se inserta una segunda fila, se genera el valor predeterminado de `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
```
Si se inserta una tercera fila, no es necesario que el valor de `base_id` sea único.
```
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
```
## Crear una tabla con valores de la columna DEFAULT
En el siguiente ejemplo, se crea una tabla CATEGORYDEF que declara valores predeterminados para cada columna:
```
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)
```
## Opciones DISTSTYLE, DISTKEY y SORTKEY
En el siguiente ejemplo, se muestra cómo funcionan las opciones DISTKEY, SORTKEY y DISTSTYLE. En este ejemplo, COL1 es la clave de distribución: por lo tanto, el estilo de distribución debe configurarse en KEY o no configurarse. De manera predeterminada, la tabla no tiene ninguna clave de ordenación y, por lo tanto, no se ordena:
```
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
```
En el siguiente ejemplo, se define la misma columna como la clave de distribución y la clave de ordenación. El estilo de distribución debe configurarse en KEY o no configurarse.
```
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
```
En el siguiente ejemplo, no se configura una columna como la clave de distribución, se configura COL2 como la clave de ordenación, y se configura el estilo de distribución en 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
```
En el siguiente ejemplo, el estilo de distribución está establecido en EVEN y no se define explícitamente una clave de ordenación. Por lo tanto, la tabla se distribuye de manera uniforme, pero no se ordena.
```
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
```
## Crear una tabla con la opción ENCODE AUTO
En el siguiente ejemplo, se crea la tabla `t1` con codificación de compresión automática. ENCODE AUTO es la opción predeterminada para las tablas cuando no se especifica un tipo de codificación para ninguna columna.
```
create table t1(c0 int, c1 varchar);
```
En el siguiente ejemplo, se crea la tabla `t2` con codificación de compresión automática mediante la especificación de ENCODE AUTO.
```
create table t2(c0 int, c1 varchar) encode auto;
```
En el siguiente ejemplo, se crea la tabla `t3` con codificación de compresión automática mediante la especificación de ENCODE AUTO. La columna `c0` se define con un tipo de codificación inicial de DELTA. Amazon Redshift puede cambiar la codificación si otra codificación proporciona un mejor rendimiento en las consultas.
```
create table t3(c0 int encode delta, c1 varchar) encode auto;
```
En el siguiente ejemplo, se crea la tabla `t4` con codificación de compresión automática mediante la especificación de ENCODE AUTO. La columna `c0` se define con una codificación inicial de DELTA, y la columna `c1` se define con una codificación inicial de LZO. Amazon Redshift puede cambiar estas codificaciones si otras codificaciones proporcionan un mejor rendimiento en las consultas.
```
create table t4(c0 int encode delta, c1 varchar encode lzo) encode auto;
```