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/). 

# CREATE EXTERNAL TABLE
<a name="r_CREATE_EXTERNAL_TABLE"></a>

Crea una nueva tabla externa en el esquema especificado. Todas las tablas externas deben crearse en un esquema externo. La ruta de búsqueda no es compatible con esquemas externos y tablas externas. Para obtener más información, consulte [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md).

Además de las tablas externas creadas con el comando CREATE EXTERNAL TABLE, Amazon Redshift puede referencia tablas externas definidas en un catálogo de AWS Glue o AWS Lake Formation, o bien, en un metastore de Apache Hive. Utilice el comando [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md) para registrar una base de datos externa definida en el catálogo externo y para hacer que las tablas externas estén disponibles para usarse en Amazon Redshift. Si la tabla externa ya existe en un catálogo de AWS Glue o AWS Lake Formation o en un metastore de Hive, no necesita crear la tabla con CREATE EXTERNAL TABLE. Para ver las tablas externas, consulte la vista del sistema [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md). 

Si ejecuta el comando CREATE EXTERNAL TABLE AS, puede crear una tabla externa basada en la definición de la columna de una consulta y escribir los resultados de esa consulta en Amazon S3. Los resultados están en Apache Parquet o formato de texto delimitado. Si la tabla externa tiene una clave o claves de partición, Amazon Redshift particiona los archivos nuevos según esas claves de partición y registra las particiones nuevas en el catálogo externo de forma automática. Para obtener más información acerca de CREATE EXTERNAL TABLE AS, consulte [Notas de uso](r_CREATE_EXTERNAL_TABLE_usage.md). 

Puede consultar una tabla externa mediante la misma sintaxis SELECT que utiliza con otras tablas de Amazon Redshift. También puede utilizar la sintaxis INSERT para escribir archivos nuevos en la ubicación de la tabla externa en Amazon S3. Para obtener más información, consulte [INSERT (tabla externa)](r_INSERT_external_table.md).

Para crear una vista con una tabla externa, incluya la cláusula WITH NO SCHEMA BINDING en la instrucción [CREATE VIEW](r_CREATE_VIEW.md).

No puede ejecutar CREATE EXTERNAL TABLE en una transacción (BEGIN … END). Para obtener más información acerca de las transacciones, consulte [Niveles de aislamiento en Amazon Redshift](c_serial_isolation.md). 

## Privilegios necesarios
<a name="r_CREATE_EXTERNAL_TABLE-privileges"></a>

Para crear tablas externas, debe ser el propietario del esquema externo o un superusuario. Para transferir la propiedad de un esquema externo, use ALTER SCHEMA para cambiar el propietario. El acceso a tablas externas está controlado por el acceso al esquema externo. No puede usar permisos [GRANT](r_GRANT.md) o [REVOKE](r_REVOKE.md) en una tabla externa. En su lugar, conceda o revoque USAGE en el esquema externo.

Las [Notas de uso](r_CREATE_EXTERNAL_TABLE_usage.md) tienen información adicional sobre permisos específicos para tablas externas.

## Sintaxis
<a name="r_CREATE_EXTERNAL_TABLE-synopsis"></a>

```
CREATE EXTERNAL TABLE
external_schema.table_name
(column_name data_type [, …] )
[ PARTITIONED BY (col_name data_type [, … ] )]
[ { ROW FORMAT DELIMITED row_format |
  ROW FORMAT SERDE 'serde_name'
  [ WITH SERDEPROPERTIES ( 'property_name' = 'property_value' [, ...] ) ] } ]
STORED AS file_format
LOCATION { 's3://bucket/folder/' | 's3://bucket/manifest_file' }
[ TABLE PROPERTIES ( 'property_name'='property_value' [, ...] ) ]
```

A continuación, se muestra la sintaxis de CREATE EXTERNAL TABLE AS.

```
CREATE EXTERNAL TABLE
external_schema.table_name
[ PARTITIONED BY (col_name [, … ] ) ]
[ ROW FORMAT DELIMITED row_format ]
STORED AS file_format
LOCATION { 's3://bucket/folder/' }
[ TABLE PROPERTIES ( 'property_name'='property_value' [, ...] ) ]
 AS
 { select_statement }
```

## Parameters
<a name="r_CREATE_EXTERNAL_TABLE-parameters"></a>

 *external\$1schema.table\$1name*   
El nombre de la tabla que se creará, clasificada por un nombre de esquema externo. Las tablas externas deben crearse en un esquema externo. Para obtener más información, consulte [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md).  
La longitud máxima del nombre de la tabla es de 127 bytes; los nombres más largos se truncan en 127 bytes. Puede usar caracteres multibyte UTF-8 de hasta un máximo de cuatro bytes. Amazon Redshift establece un límite de 9900 tablas por clúster, incluidas las tablas temporales definidas por el usuario y las tablas temporales creadas por Amazon Redshift durante el procesamiento de consultas o el mantenimiento del sistema. De manera opcional, puede completar el nombre de la tabla con el nombre de base de datos. En el siguiente ejemplo, el nombre de base de datos es `spectrum_db`, el nombre de esquema externo es `spectrum_schema` y el nombre de tabla es `test`.  

```
create external table spectrum_db.spectrum_schema.test (c1 int)
stored as parquet
location 's3://amzn-s3-demo-bucket/myfolder/';
```
Si no existe la base de datos o el esquema especificados, no se crea la tabla y la instrucción devuelve un error. No puede crear tablas o vistas en las bases de datos del sistema `template0`, `template1`, `padb_harvest` o `sys:internal`.  
El nombre de la tabla debe ser un nombre único para el esquema especificado.   
Para obtener más información acerca de los nombres válidos, consulte [Nombres e identificadores](r_names.md).

( *column\$1name* *data\$1type* )  
El nombre y el tipo de datos de cada columna que se crea.  
La longitud máxima del nombre de la columna es de 127 bytes; los nombres más largos se truncan en 127 bytes. Puede usar caracteres multibyte UTF-8 de hasta un máximo de cuatro bytes. No puede especificar nombres de columna `"$path"` o `"$size"`. Para obtener más información acerca de los nombres válidos, consulte [Nombres e identificadores](r_names.md).  
De manera predeterminada, Amazon Redshift crea tablas externas con las pseudocolumnas `$path` y `$size`. Puede deshabilitar la creación de pseudocolumnas para una sesión estableciendo el parámetro de configuración `spectrum_enable_pseudo_columns` en `false`. Para obtener más información, consulte [Pseudocolumnas](r_CREATE_EXTERNAL_TABLE_usage.md#r_CREATE_EXTERNAL_TABLE_usage-pseudocolumns).  
Si las pseudocolumnas están habilitadas, el número máximo de columnas que se pueden definir en una única tabla es 1 598. Si las pseudocolumnas no están habilitadas, el número máximo de columnas que se pueden definir en una única tabla es de 1600.   
Si va a crear una "tabla ancha", asegúrese de que la lista de columnas no supere los límites de ancho de las filas para los resultados intermedios durante la carga y el procesamiento de consultas. Para obtener más información, consulte [Notas de uso](r_CREATE_TABLE_NEW.md#r_CREATE_TABLE_usage).  
Para un comando CREATE EXTERNAL TABLE AS, no es necesaria una lista de columnas, ya que las columnas se obtienen de la consulta.

 *data\$1type*   
Se admiten los siguientes [Tipos de datos](c_Supported_data_types.md):  
+ SMALLINT (INT2)
+ INTEGER (INT, INT4)
+ BIGINT (INT8)
+ DECIMAL (NUMERIC)
+ REAL (FLOAT4)
+ DOUBLE PRECISION (FLOAT8)
+ BOOLEAN (BOOL)
+ CHAR (CHARACTER)
+ VARCHAR (CHARACTER VARYING)
+ VARBYTE (CHARACTER VARYING): se puede usar con archivos de datos Parquet y ORC, y solo con tablas que no sean de partición.
+ DATE: solo se puede utilizar con archivos de datos de texto, Parquet u ORC, o como una columna de partición.
+ TIMESTAMP
  
Para DATE, puede utilizar los formatos tal y como se describe a continuación. Para los valores de mes representados mediante dígitos, se admiten los siguientes formatos:  
+ `mm-dd-yyyy` por ejemplo, `05-01-2017`. Esta es la opción predeterminada.
+ `yyyy-mm-dd`, donde el año está representado por más de 2 dígitos. Por ejemplo, `2017-05-01`.
Para los valores de mes representados mediante abreviaturas de tres letras, se admiten los siguientes formatos:  
+ `mmm-dd-yyyy` por ejemplo, `may-01-2017`. Esta es la opción predeterminada.
+ `dd-mmm-yyyy`, donde el año está representado por más de 2 dígitos. Por ejemplo, `01-may-2017`.
+ `yyyy-mmm-dd`, donde el año está representado por más de 2 dígitos. Por ejemplo, `2017-may-01`.
En el caso de los valores de año sistemáticamente inferiores a 100, el año se calcula de la siguiente manera:  
+ Si el año es inferior a 70, el año se calcula como el año más 2000. Por ejemplo, la fecha 05-01-17 en el formato `mm-dd-yyyy` se convierte en `05-01-2017`.
+ Si el año es inferior a 100 o mayor que 69, el año se calcula como el año más 1900. Por ejemplo, la fecha 05-01-89 en el formato `mm-dd-yyyy` se convierte en `05-01-1989`.
+ Para los valores de año representados por dos dígitos, agregue ceros al principio para representar el año en 4 dígitos.
Los valores de marca temporal de los archivos de texto deben tener el formato `yyyy-mm-dd HH:mm:ss.SSSSSS`, tal y como se muestra en el siguiente valor de marca temporal: `2017-05-01 11:30:59.000000`.  
La longitud de una columna VARCHAR se expresa en bytes no en caracteres. Por ejemplo, una columna VARCHAR(12) puede contener 12 caracteres de un byte o 6 caracteres de dos bytes. Cuando se realiza una consulta a una tabla externa, los resultados se truncan para ajustar el tamaño de columna sin devolver un error. Para obtener más información, consulte [Almacenamiento y rangos](r_Character_types.md#r_Character_types-storage-and-ranges).   
Para obtener un rendimiento óptimo, le recomendamos que especifique el menor tamaño de columna que se adapte a sus datos. Para encontrar el tamaño máximo en bytes para los valores de una columna, use la función [OCTET\$1LENGTH](r_OCTET_LENGTH.md). El siguiente ejemplo devuelve el tamaño máximo de valores en la columna de correo electrónico.  

```
select max(octet_length(email)) from users;

max
---
 62
```

PARTITIONED BY (*col\$1name* *data\$1type* [, … ] )  
Una cláusula que define una tabla particionada con una o más columnas de partición. Se usa un directorio de datos separado para cada combinación especificada, lo que puede mejorar el rendimiento de la consulta en algunas circunstancias. Las columnas particionadas no existen dentro de los propios datos de la tabla. Recibirá un error si utiliza un valor para *col\$1name (nombre\$1de\$1columna)* igual al de una columna de la tabla.   
Después de crear una tabla con particiones, modifique la tabla mediante una instrucción [ALTER TABLE](r_ALTER_TABLE.md) … ADD PARTITION para registrar nuevas particiones en el catálogo externo. Cuando agrega una partición, define la ubicación de la subcarpeta en Amazon S3 que contiene los datos de partición.  
Por ejemplo, si la tabla `spectrum.lineitem_part` se define con `PARTITIONED BY (l_shipdate date)`, ejecute el siguiente comando ALTER TABLE para agregar una partición.  

```
ALTER TABLE spectrum.lineitem_part ADD PARTITION (l_shipdate='1992-01-29')
LOCATION 's3://spectrum-public/lineitem_partition/l_shipdate=1992-01-29';
```
Si utiliza CREATE EXTERNAL TABLE AS, no tendrá que ejecutar ALTER TABLE...ADD PARTITION. Amazon Redshift registra de forma automática las particiones nuevas en el catálogo externo. Amazon Redshift también escribe de forma automática los datos correspondientes en las particiones de Amazon S3 en función de la clave o las claves de partición definidas en la tabla.  
Para ver particiones, consulte la vista del sistema [SVV\$1EXTERNAL\$1PARTITIONS](r_SVV_EXTERNAL_PARTITIONS.md).  
Para un comando CREATE EXTERNAL TABLE AS, no es necesario especificar el tipo de datos de la columna de partición porque esta columna se obtiene de la consulta. 

ROW FORMAT DELIMITED *rowformat (formato\$1de\$1fila)*  
Una cláusula que especifica el formato de los datos subyacentes. Los valores posibles para *rowformat (formato\$1de\$1fila)* son los siguientes:  
+ LINES TERMINATED BY '*delimiter*' 
+ FIELDS TERMINATED BY '*delimiter*' 
Especifique un solo carácter ASCII para '*delimiter (delimitador)*'. Puede especificar caracteres ASCII no imprimibles mediante octales, con el formato `'\`*`ddd`*`'`, donde *`d`* es un dígito octal (0-7) hasta “\$1177”. El siguiente ejemplo especifica el carácter BEL (campana) usando la representación octal.   

```
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\007'
```
Si se omite ROW FORMAT DELIMITED, el formato predeterminado es DELIMITED FIELDS TERMINATED BY '\$1A' (inicio de encabezado) y LINES TERMINATED BY '\$1n' (nueva línea). 

ROW FORMAT SERDE '*serde\$1name (nombre\$1de\$1serde)*' [WITH SERDEPROPERTIES ( '*property\$1name*' = '*property\$1value*' [, ...] ) ]  
Una cláusula que especifica el formato SERDE para los datos subyacentes.     
'*serde\$1name (nombre\$1de\$1serde*'  
El nombre del SerDe. Puede especificar los siguientes formatos:  
+ org.apache.hadoop.hive.serde2.RegexSerDe 
+ com.amazonaws.glue.serde.GrokSerDe 
+ org.apache.hadoop.hive.serde2.OpenCSVSerde 

  Este parámetro admite la siguiente propiedad SerDE para OpenCSvSerde: 

  ```
  'wholeFile' = 'true' 
  ```

  Configure la propiedad `wholeFile` como `true` para analizar correctamente los nuevos caracteres de línea (\$1n) dentro de las cadenas citadas para las solicitudes OpenCSV. 
+ org.openx.data.jsonserde.JsonSerDe
  + El SERDE JSON también admite archivos Ion. 
  + El JSON debe tener un formato correcto. 
  + Las marcas temporales en Ion y JSON deben usar el formato ISO8601.
  + Este parámetro admite la siguiente propiedad SerDE para JsonSerDe: 

    ```
    'strip.outer.array'='true' 
    ```

    Procesa archivos Ion/JSON que contienen una matriz muy grande encerrada en corchetes exteriores ([ … ]) como si contiene múltiples registros JSON dentro de la matriz. 
+ com.amazon.ionhiveserde.IonHiveSerDe

  El formato Amazon ION proporciona formatos de texto y binarios, además de tipos de datos. Para una tabla externa que hace referencia a datos en formato ION, debe asignar cada columna en la tabla externa al elemento correspondiente de los datos de formato ION. Para obtener más información, consulte [Amazon Ion](https://amzn.github.io/ion-docs/). También debe especificar los formatos de entrada y salida.  
WITH SERDEPROPERTIES ( '*property\$1name*' = '*property\$1value*' [, ...] ) ]  
De manera opcional, especifique los nombres y valores de las propiedades, separados por comas.
Si se omite ROW FORMAT DELIMITED, el formato predeterminado es DELIMITED FIELDS TERMINATED BY '\$1A' (inicio de encabezado) y LINES TERMINATED BY '\$1n' (nueva línea). 

STORED AS *file\$1format*  
El formato de archivo para los archivos de datos.   
Los formatos válidos son los siguientes:  
+ PARQUET
+ RCFILE (para datos que usan ColumnarSerDe únicamente, no LazyBinaryColumnarSerDe)
+ SEQUENCEFILE
+ TEXTFILE (para archivos de texto, incluidos los archivos JSON).
+ ORC 
+ AVRO 
+ INPUTFORMAT '*input\$1format\$1classname*' OUTPUTFORMAT '*output\$1format\$1classname*' 
El comando CREATE EXTERNAL TABLE AS solo admite dos formatos de archivo, TEXTFILE y PARQUET.  
Para INPUTFORMAT y OUTPUTFORMAT, especifique un nombre de la clase, como se muestra en el siguiente ejemplo:   

```
'org.apache.hadoop.mapred.TextInputFormat'
```

LOCATION \$1 's3://*bucket/folder*/' \$1 's3://*bucket/manifest\$1file*'\$1  <a name="create-external-table-location"></a>
Se trata de la ruta a la carpeta o al bucket de Amazon S3 que contiene los archivos de datos o un archivo de manifiesto donde se incluye una lista de rutas de objetos de Amazon S3. Los buckets deben estar en la misma región de AWS que el clúster de Amazon Redshift. Para obtener una lista de las regiones de AWS admitidas, consulte [Limitaciones de Amazon Redshift Spectrum](c-spectrum-considerations.md).  
Si la ruta especifica un bucket o una carpeta, por ejemplo, `'s3://amzn-s3-demo-bucket/custdata/'`, Redshift Spectrum analiza los archivos en el bucket o la carpeta especificados, además de todas las subcarpetas. Redshift Spectrum omite los archivos ocultos y los archivos que comienzan con un carácter de subrayado.   
Si la ruta especifica un archivo de manifiesto, el argumento `'s3://bucket/manifest_file'` debe referencia de forma explícita un solo archivo; por ejemplo, `'s3://amzn-s3-demo-bucket/manifest.txt'`. No puede hacer referencia a un prefijo de clave.   
El manifiesto es un archivo de texto en formato JSON que muestra la dirección URL de cada archivo que se va a cargar desde Amazon S3 y el tamaño del archivo, en bytes. El URL incluye el nombre del bucket y la ruta de objeto completa para el archivo. Los archivos que se especifican en el manifiesto pueden estar en buckets diferentes, pero todos los buckets deben estar en la misma región de AWS que el clúster de Amazon Redshift. Si un archivo aparece dos veces, este se carga dos veces. En el siguiente ejemplo, se muestra el JSON para un manifiesto que carga tres archivos.   

```
{
  "entries": [
    {"url":"s3://amzn-s3-demo-bucket1/custdata.1", "meta": { "content_length": 5956875 } },
    {"url":"s3://amzn-s3-demo-bucket1/custdata.2", "meta": { "content_length": 5997091 } },
    {"url":"s3://amzn-s3-demo-bucket2/custdata.1", "meta": { "content_length": 5978675 } }
  ]
}
```
Puede hacer que la inclusión de un archivo en particular sea obligatoria. Para ello, incluya una opción `mandatory` en el nivel de archivo en el manifiesto. Cuando consulta una tabla externa con un archivo obligatorio faltante, se produce un error en la instrucción SELECT. Asegúrese de que todos los archivos incluidos en la definición de la tabla externa están presentes. Si no están todos presentes, aparece un error que muestra el primer archivo obligatorio que no se encuentra. En el siguiente ejemplo, se muestra el JSON de un manifiesto con la opción `mandatory` establecida en `true`.  

```
{
  "entries": [
    {"url":"s3://amzn-s3-demo-bucket1/custdata.1", "mandatory":true, "meta": { "content_length": 5956875 } },
    {"url":"s3://amzn-s3-demo-bucket1/custdata.2", "mandatory":false, "meta": { "content_length": 5997091 } },
    {"url":"s3://amzn-s3-demo-bucket2/custdata.1", "meta": { "content_length": 5978675 } }
  ]
}
```
Para hacer referencia a los archivos creados mediante UNLOAD, puede usar el manifiesto creado mediante [UNLOAD](r_UNLOAD.md) con el parámetro MANIFEST. El archivo de manifiesto es compatible con un archivo de manifiesto de [COPY de Amazon S3](copy-parameters-data-source-s3.md), pero usa claves diferentes. Las claves que no se usan se omiten. 

TABLE PROPERTIES ( '*property\$1name*'='*property\$1value*' [, ...] )   
Una cláusula que establece la definición de tabla de las propiedades de la tabla.   
Las propiedades de tabla distinguen entre mayúsculas y minúsculas.  
 'compression\$1type'='*value (valor)*'   
 Propiedad que establece el tipo de compresión que se va a utilizar si el nombre de archivo no contiene una extensión. Si establece esta propiedad y hay una extensión de archivo, la extensión se omite y se usa el valor establecido por la propiedad. Los valores válidos para el tipo de compresión son los siguientes:  
+ bzip2
+ gzip
+ none
+ snappy  
“data\$1cleansing\$1enabled”=“true/false”  
Esta propiedad establece si el control de datos está activado para la tabla. Cuando “data\$1cleansing\$1enabled” se establece en true, el control de datos está activado para la tabla. Cuando “data\$1cleansing\$1enabled” se establece en false, el control de datos está desactivado para la tabla. A continuación, se muestra una lista de las propiedades de control de datos en el nivel de la tabla que controla esta propiedad:  
+ column\$1count\$1mismatch\$1handling
+ invalid\$1char\$1handling
+ numeric\$1overflow\$1handling
+ replacement\$1char
+ surplus\$1char\$1handling
Para ver ejemplos, consulte [Ejemplos de control de datos](r_CREATE_EXTERNAL_TABLE_examples.md#r_CREATE_EXTERNAL_TABLE_examples-data-handling).  
“invalid\$1char\$1handling”=“*valor*”   
Especifica la acción que se debe realizar cuando los resultados de la consulta contienen valores de caracteres UTF-8 no válidos. Puede especificar las siguientes acciones:    
DISABLED  
No lleva a cabo un control de caracteres no válido.  
FAIL  
Cancela las consultas que devuelven datos que contienen valores UTF-8 no válidos.  
SET\$1TO\$1NULL   
Reemplaza los valores UTF-8 no válidos por valores nulos.  
DROP\$1ROW  
Reemplaza cada valor de la fila por un valor nulo.  
REPLACE  
Reemplaza el carácter no válido por el carácter de reemplazo que se especifique mediante `replacement_char`.  
“replacement\$1char”=“*carácter*”  
Especifica el carácter de reemplazo que se va a utilizar al establecer `invalid_char_handling` en `REPLACE`.  
“numeric\$1overflow\$1handling”=“valor”  
Especifica la acción que se debe realizar cuando los datos de ORC contienen un entero (por ejemplo, BIGINT o int64) que es mayor que la definición de columna (por ejemplo, SMALLINT o int16). Puede especificar las siguientes acciones:    
DISABLED  
El control de caracteres no válidos está desactivado.  
FAIL  
Cancela la consulta cuando los datos incluyen caracteres no válidos.  
SET\$1TO\$1NULL  
Establece caracteres no válidos en valores nulos.  
DROP\$1ROW  
Establece cada valor de la fila como un valor nulo.  
'surplus\$1bytes\$1handling'='*valor*'  
Especifica cómo controlar los datos que se cargan que superan la longitud del tipo de datos definido para las columnas que contienen datos VARBYTE. De manera predeterminada, Redshift Spectrum establece el valor como nulo para los datos que superan el ancho de la columna.  
Puede especificar las siguientes acciones que se realizarán cuando la consulta devuelva datos que superen la longitud del tipo de datos:    
SET\$1TO\$1NULL  
Reemplaza los datos que superan el ancho de la columna por valores nulos.  
DISABLED  
No lleva a cabo un control de bytes sobrantes.  
FAIL  
Cancela las consultas que devuelven datos que superan el ancho de la columna.  
DROP\$1ROW  
Elimina todas las filas que contienen datos que superan la anchura de columna.  
TRUNCATE  
Elimina los caracteres que superan el número máximo de caracteres definidos para la columna.  
“surplus\$1char\$1handling”=“*valor*”  
Especifica cómo controlar los datos que se cargan que superan la longitud del tipo de datos definido para las columnas que contienen datos VARCHAR, CHAR o cadenas. De manera predeterminada, Redshift Spectrum establece el valor como nulo para los datos que superan el ancho de la columna.  
Puede especificar las siguientes acciones que se deben realizar cuando la consulta devuelva datos que superan el ancho de la columna:    
SET\$1TO\$1NULL  
Reemplaza los datos que superan el ancho de la columna por valores nulos.  
DISABLED  
No lleva a cabo un control de caracteres sobrantes.  
FAIL  
Cancela las consultas que devuelven datos que superan el ancho de la columna.  
DROP\$1ROW  
Reemplaza cada valor de la fila por un valor nulo.  
TRUNCATE  
Elimina los caracteres que superan el número máximo de caracteres definidos para la columna.  
'column\$1count\$1mismatch\$1handling'='value’  
Identifica si el archivo contiene menos o más valores para una fila que el número de columnas especificado en la definición de tabla externa. Esta propiedad solo está disponible para un formato de archivo de texto sin comprimir. Puede especificar las siguientes acciones:    
DISABLED  
El control de discrepancias en el recuento de columnas está desactivado.  
FAIL  
No se puede realizar la consulta si se detecta una discrepancia en el recuento de columnas.  
SET\$1TO\$1NULL  
Rellene los valores que faltan con NULL e ignore los valores adicionales de cada fila.  
DROP\$1ROW  
Elimine del análisis todas las filas que contengan un error de discrepancia en el recuento de columnas.  
'numRows'='*row\$1count*'   
Una propiedad que establece el valor de numRows para la definición de la tabla. Para actualizar de forma explícita las estadísticas de una tabla externa, establezca la propiedad numRows de manera que indique el tamaño de la tabla. Amazon Redshift no analiza las tablas externas para generar las estadísticas de las tablas que el optimizador de consultas emplea a la hora de crear un plan de consulta. Si no se configuran las estadísticas de tabla para una tabla externa, Amazon Redshift genera un plan de ejecución de consulta basado en un supuesto de que las tablas externas son las más grandes y las tablas locales son las más pequeñas.  
'skip.header.line.count'='*line\$1count*'  
Una propiedad que establece el número de filas que se omiten al principio de cada archivo de código fuente.  
'serialization.null.format'=' '  
Una propiedad que especifica que Spectrum debe devolver un valor `NULL` cuando hay una coincidencia exacta con el texto introducido en un campo.  
'orc.schema.resolution'='mapping\$1type' (tipo\$1de\$1asignación)  
Propiedad que establece el tipo de asignación de columnas en tablas que usan el formato de datos de ORC. Esta propiedad se omite con otros formatos de datos.  
Los valores válidos para el tipo de asignación de columnas son los siguientes:   
+ name 
+ position 
Si la propiedad *orc.schema.resolution* se omite, las columnas se asignan por nombre de manera predeterminada. Si *orc.schema.resolution* se establece en un valor que no es *'name'* ni *'position'*, las columnas se asignan por posición. Para obtener más información sobre la asignación de columnas, consulte [Asignación de columnas de tablas externas a columnas ORC](c-spectrum-external-tables.md#c-spectrum-column-mapping-orc).  
El comando COPY realiza asignaciones en archivos de datos de ORC únicamente por posición. La propiedad de tabla *orc.schema.resolution* no tiene ningún efecto en el comportamiento del comando COPY.   
'write.parallel'='on / off’  
Una propiedad que establece si CREATE EXTERNAL TABLE AS debe escribir datos en paralelo. De manera predeterminada, CREATE EXTERNAL TABLE AS escribe datos en paralelo en varios archivos, según el número de sectores en el clúster. La opción predeterminada está activada. Cuando 'write.parallel' está desactivado, CREATE EXTERNAL TABLE AS escribe en uno o más archivos de datos en serie en Amazon S3. Esta propiedad de tabla también se aplica a cualquier instrucción INSERT posterior en la misma tabla externa.  
‘write.maxfilesize.mb’=‘size’  
Se trata de una propiedad que establece el tamaño máximo (en MB) de cada archivo escrito en Amazon S3 con CREATE EXTERNAL TABLE AS. El tamaño debe ser un entero válido entre 5 y 6200. El tamaño máximo de archivo predeterminado es 6200 MB. Esta propiedad de tabla también se aplica a cualquier instrucción INSERT posterior en la misma tabla externa.  
'write.kms.key.id'='*value*'  
Puede especificar una clave AWS Key Management Service para habilitar el cifrado del lado del servidor (SSE) para objetos de Amazon S3, donde *value* es una de las opciones siguientes:   
+ `auto` para utilizar la clave de AWS KMS predeterminada almacenada en el bucket de Amazon S3
+ *clave de kms* especficada para cifrar los datos  
*select\$1statement*  
Una instrucción que inserta una o más filas en la tabla externa definiendo cualquier consulta. Todas las filas que genera la consulta se escriben en Amazon S3 en formato de texto o Parquet según la definición de tabla.

## Ejemplos
<a name="r_CREATE_EXTERNAL_TABLE_examples_link"></a>

Encontrará una selección de ejemplos en [Ejemplos](r_CREATE_EXTERNAL_TABLE_examples.md).

# Notas de uso
<a name="r_CREATE_EXTERNAL_TABLE_usage"></a>

Este tema contiene notas de uso para [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). No puede ver los detalles de las tablas de Amazon Redshift Spectrum con los mismos recursos que utiliza para las tablas de Amazon Redshift estándar, como [PG\$1TABLE\$1DEF](r_PG_TABLE_DEF.md), [STV\$1TBL\$1PERM](r_STV_TBL_PERM.md), PG\$1CLASS o information\$1schema. Si su herramienta de análisis o inteligencia empresarial no reconoce las tablas externas de Redshift Spectrum, configure la aplicación para consultar [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md) y [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md).

## CREATE EXTERNAL TABLE AS
<a name="r_CETAS"></a>

En algunos casos, puede ejecutar el comando CREATE EXTERNAL TABLE AS en un catálogo de datos de AWS Glue, un catálogo externo de AWS Lake Formation o un metastore de Apache Hive. En tales casos, se utiliza un rol de AWS Identity and Access Management (IAM) para crear el esquema externo. Este rol de IAM debe tener permisos de lectura y escritura en Amazon S3. 

Si utiliza un catálogo de Lake Formation, el rol de IAM debe tener permiso para crear tablas en el catálogo. En este caso, también debe tener el permiso de ubicación del lago de datos en la ruta de destino de Amazon S3. Este rol de IAM se convierte en el propietario de la nueva tabla AWS Lake Formation.

Para asegurarse de que los nombres de los archivos son únicos, Amazon Redshift utiliza el siguiente formato para el nombre de cada archivo cargado en Amazon S3 de manera predeterminada.

`<date>_<time>_<microseconds>_<query_id>_<slice-number>_part_<part-number>.<format>`.

 Un ejemplo es `20200303_004509_810669_1007_0001_part_00.parquet`.

Tenga en cuenta lo siguiente al ejecutar el comando CREATE EXTERNAL TABLE AS:
+ La ubicación de Amazon S3 debe estar vacía.
+ Amazon Redshift solo admite los formatos PARQUET y TEXTFILE cuando se utiliza la cláusula STORED AS.
+ No es necesario definir una lista de definición de columna. Los nombres de columna y los tipos de datos de columna de la nueva tabla externa se obtienen directamente de la consulta SELECT.
+ No es necesario definir el tipo de datos de la columna de partición en la cláusula PARTITIONED BY. Si especifica una clave de partición, el nombre de esta columna debe existir en el resultado de la consulta SELECT. Cuando tiene varias columnas de partición, no importa el orden en la consulta SELECT. Amazon Redshift utiliza el orden definido en la cláusula PARTITIONED BY para crear la tabla externa.
+ Amazon Redshift particiona de forma automática los archivos de salida en carpetas de partición en función de los valores de la clave de partición. De manera predeterminada, Amazon Redshift quita las columnas de partición de los archivos de salida.
+ No se admite la cláusula LINES TERMINATED BY 'delimitador'.
+ No se admite la cláusula ROW FORMAT SERDE 'serde\$1name'.
+ No se admite el uso de archivos de manifiesto. Por lo tanto, no se puede definir la cláusula LOCATION en un archivo de manifiesto en Amazon S3.
+ Amazon Redshift actualiza de forma automática la propiedad de la tabla 'numRows' al final del comando.
+ La propiedad de tabla 'compression\$1type' sólo acepta 'none' o 'snappy' para el formato de archivo PARQUET.
+ Amazon Redshift no admite la cláusula LIMIT en la consulta SELECT externa. En su lugar, puede utilizar una cláusula LIMIT anidada.
+ Puede utilizar STL\$1UNLOAD\$1LOG para realizar un seguimiento de los archivos que cada operación CREATE EXTERNAL TABLE AS escribe en Amazon S3.

## Permisos necesarios para crear y consultar tablas externas
<a name="r_CREATE_EXTERNAL_TABLE_usage-permissions"></a>

Para crear tablas externas, asegúrese de que es el propietario del esquema externo o un superusuario. Para transferir la propiedad de un esquema externo, utilice [ALTER SCHEMA](r_ALTER_SCHEMA.md). En el siguiente ejemplo, se modifica el propietario del esquema `spectrum_schema` a `newowner`.

```
alter schema spectrum_schema owner to newowner;
```

Para ejecutar una consulta de Redshift Spectrum, necesita los siguientes permisos:
+ Permiso de uso para el esquema 
+ Permiso para crear tablas temporales en la base de datos actual 

En el siguiente ejemplo, se concede permiso de uso para el esquema `spectrum_schema` al grupo de usuarios `spectrumusers`.

```
grant usage on schema spectrum_schema to group spectrumusers;
```

En el siguiente ejemplo, se concede un permiso temporal para la base de datos `spectrumdb` al grupo de usuarios `spectrumusers`. 

```
grant temp on database spectrumdb to group spectrumusers;
```

## Pseudocolumnas
<a name="r_CREATE_EXTERNAL_TABLE_usage-pseudocolumns"></a>

De manera predeterminada, Amazon Redshift crea tablas externas con las pseudocolumnas *\$1path* y *\$1size*. Seleccione estas columnas para ver la ruta a los archivos de datos en Amazon S3 y el tamaño de los archivos de datos de cada fila devuelta por una consulta. Los nombres de las columnas *\$1path* y *\$1size* deben estar delimitados con comillas dobles. Las cláusulas *SELECT \$1* no devuelven las pseudocolumnas. Debe incluir explícitamente los nombres de columna *\$1path* y *\$1size* en la consulta, tal y como se muestra en el siguiente ejemplo.

```
select "$path", "$size"
from spectrum.sales_part
where saledate = '2008-12-01';
```

Puede deshabilitar la creación de pseudocolumnas en una sesión estableciendo el parámetro de configuración *spectrum\$1enable\$1pseudo\$1columns* en *false*. 

**importante**  
La selección de *\$1size* o *\$1path* genera cargos, ya que Redshift Spectrum analiza los archivos de datos en Amazon S3 para determinar el tamaño del conjunto de resultados. Para obtener más información, consulte [Precios de Amazon Redshift](https://aws.amazon.com/redshift/pricing/).

## Configuración de opciones de control de datos
<a name="r_CREATE_EXTERNAL_TABLE_usage-data-handling"></a>

Puede establecer parámetros de tabla para especificar el control de entrada de los datos que se consultan en tablas externas, incluidos los siguientes: 
+ Caracteres sobrantes en columnas que contengan datos de VARCHAR, CHAR y cadenas. Para obtener más información, consulte la propiedad de tabla externa `surplus_char_handling`.
+ Caracteres no válidos en columnas que contengan datos de VARCHAR, CHAR y cadenas. Para obtener más información, consulte la propiedad de tabla externa `invalid_char_handling`.
+ Carácter de reemplazo que se utilizará al especificar REPLACE para la propiedad de tabla externa `invalid_char_handling`.
+ Control de desbordamiento de conversión en columnas que contengan datos enteros y decimales. Para obtener más información, consulte la propiedad de tabla externa `numeric_overflow_handling`.
+ Surplus\$1bytes\$1handling para especificar la gestión de entrada de los bytes sobrantes en las columnas que contienen datos varbyte. Para obtener más información, consulte la propiedad de tabla externa `surplus_bytes_handling`.

# Ejemplos
<a name="r_CREATE_EXTERNAL_TABLE_examples"></a>

En el siguiente ejemplo, se crea una tabla denominada SALES en el esquema externo de Amazon Redshift `spectrum`. Los datos están en archivos de texto delimitados por tabulaciones. La cláusula TABLE PROPERTIES configura la propiedad numRows con 170 000 filas.

Según la identidad que utilice para ejecutar CREATE EXTERNAL TABLE, es posible que deba configurar permisos de IAM. Como práctica recomendada, aconsejamos asociar las políticas de permisos a un rol de IAM y luego asignarlo a los usuarios y grupos según sea necesario. Para obtener más información, consulte [Administración de identidades y accesos en Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/mgmt/redshift-iam-authentication-access-control.html).

```
create external table spectrum.sales(
salesid integer,
listid integer,
sellerid integer,
buyerid integer,
eventid integer,
saledate date,
qtysold smallint,
pricepaid decimal(8,2),
commission decimal(8,2),
saletime timestamp)
row format delimited
fields terminated by '\t'
stored as textfile
location 's3://redshift-downloads/tickit/spectrum/sales/'
table properties ('numRows'='170000');
```

En el siguiente ejemplo, se crea una tabla que utiliza JsonSerDe para hacer referencia a datos con formato JSON.

```
create external table spectrum.cloudtrail_json (
event_version int,
event_id bigint,
event_time timestamp,
event_type varchar(10),
awsregion varchar(20),
event_name varchar(max),
event_source varchar(max),
requesttime timestamp,
useragent varchar(max),
recipientaccountid bigint)
row format serde 'org.openx.data.jsonserde.JsonSerDe'
with serdeproperties (
'dots.in.keys' = 'true',
'mapping.requesttime' = 'requesttimestamp'
) location 's3://amzn-s3-demo-bucket/json/cloudtrail';
```

En el siguiente ejemplo CREATE EXTERNAL TABLE AS se crea una tabla externa no particionada. Luego, escribe el resultado de la consulta SELECT con Apache Parquet en la ubicación de destino de Amazon S3.

```
CREATE EXTERNAL TABLE spectrum.lineitem
STORED AS parquet
LOCATION 'S3://amzn-s3-demo-bucket/cetas/lineitem/'
AS SELECT * FROM local_lineitem;
```

En el siguiente ejemplo, se crea una tabla externa particionada y se incluyen las columnas de partición en la consulta SELECT. 

```
CREATE EXTERNAL TABLE spectrum.partitioned_lineitem
PARTITIONED BY (l_shipdate, l_shipmode)
STORED AS parquet
LOCATION 'S3://amzn-s3-demo-bucket/cetas/partitioned_lineitem/'
AS SELECT l_orderkey, l_shipmode, l_shipdate, l_partkey FROM local_table;
```

Para obtener una lista de bases de datos existentes en el catálogo de datos externos, consulte la vista del sistema [SVV\$1EXTERNAL\$1DATABASES](r_SVV_EXTERNAL_DATABASES.md). 

```
select eskind,databasename,esoptions from svv_external_databases order by databasename;
```

```
eskind | databasename | esoptions
-------+--------------+----------------------------------------------------------------------------------
     1 | default      | {"REGION":"us-west-2","IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"}
     1 | sampledb     | {"REGION":"us-west-2","IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"}
     1 | spectrumdb   | {"REGION":"us-west-2","IAM_ROLE":"arn:aws:iam::123456789012:role/mySpectrumRole"}
```

Para ver detalles de tablas externas, consulte las vistas del sistema [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md) y [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md).

En el siguiente ejemplo, se consulta la vista SVV\$1EXTERNAL\$1TABLES.

```
select schemaname, tablename, location from svv_external_tables;
```

```
schemaname | tablename            | location
-----------+----------------------+--------------------------------------------------------
spectrum   | sales                | s3://redshift-downloads/tickit/spectrum/sales
spectrum   | sales_part           | s3://redshift-downloads/tickit/spectrum/sales_partition
```

En el siguiente ejemplo, se consulta la vista SVV\$1EXTERNAL\$1COLUMNS. 

```
select * from svv_external_columns where schemaname like 'spectrum%' and tablename ='sales';
```

```
schemaname | tablename | columnname | external_type | columnnum | part_key
-----------+-----------+------------+---------------+-----------+---------
spectrum   | sales     | salesid    | int           |         1 |        0
spectrum   | sales     | listid     | int           |         2 |        0
spectrum   | sales     | sellerid   | int           |         3 |        0
spectrum   | sales     | buyerid    | int           |         4 |        0
spectrum   | sales     | eventid    | int           |         5 |        0
spectrum   | sales     | saledate   | date          |         6 |        0
spectrum   | sales     | qtysold    | smallint      |         7 |        0
spectrum   | sales     | pricepaid  | decimal(8,2)  |         8 |        0
spectrum   | sales     | commission | decimal(8,2)  |         9 |        0
spectrum   | sales     | saletime   | timestamp     |        10 |        0
```

Para ver las particiones de la tabla, use la siguiente consulta.

```
select schemaname, tablename, values, location
from svv_external_partitions
where tablename = 'sales_part';
```

```
schemaname | tablename  | values         | location
-----------+------------+----------------+-------------------------------------------------------------------------
spectrum   | sales_part | ["2008-01-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01
spectrum   | sales_part | ["2008-02-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-02
spectrum   | sales_part | ["2008-03-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03
spectrum   | sales_part | ["2008-04-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-04
spectrum   | sales_part | ["2008-05-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-05
spectrum   | sales_part | ["2008-06-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-06
spectrum   | sales_part | ["2008-07-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-07
spectrum   | sales_part | ["2008-08-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-08
spectrum   | sales_part | ["2008-09-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-09
spectrum   | sales_part | ["2008-10-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-10
spectrum   | sales_part | ["2008-11-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-11
spectrum   | sales_part | ["2008-12-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-12
```

El siguiente ejemplo devuelve el tamaño total de los archivos de datos relacionados de una tabla externa.

```
select distinct "$path", "$size"
   from spectrum.sales_part;

 $path                                                                    | $size
--------------------------------------------------------------------------+-------
s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/ |  1616
s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-02/ |  1444
s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-02/ |  1444
```

## Ejemplos de partición
<a name="r_CREATE_EXTERNAL_TABLE_examples-partitioning"></a>

Para crear una tabla externa particionada por fecha, ejecute el siguiente comando.

```
create external table spectrum.sales_part(
salesid integer,
listid integer,
sellerid integer,
buyerid integer,
eventid integer,
dateid smallint,
qtysold smallint,
pricepaid decimal(8,2),
commission decimal(8,2),
saletime timestamp)
partitioned by (saledate date)
row format delimited
fields terminated by '|'
stored as textfile
location 's3://redshift-downloads/tickit/spectrum/sales_partition/'
table properties ('numRows'='170000');
```

Para agregar las particiones, ejecute los siguientes comandos ALTER TABLE.

```
alter table spectrum.sales_part
add if not exists partition (saledate='2008-01-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01/';
alter table spectrum.sales_part
add if not exists partition (saledate='2008-02-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-02/';
alter table spectrum.sales_part
add if not exists partition (saledate='2008-03-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03/';
alter table spectrum.sales_part
add if not exists partition (saledate='2008-04-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-04/';
alter table spectrum.sales_part
add if not exists partition (saledate='2008-05-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-05/';
alter table spectrum.sales_part
add if not exists partition (saledate='2008-06-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-06/';
alter table spectrum.sales_part
add if not exists partition (saledate='2008-07-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-07/';
alter table spectrum.sales_part
add if not exists partition (saledate='2008-08-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-08/';
alter table spectrum.sales_part
add if not exists partition (saledate='2008-09-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-09/';
alter table spectrum.sales_part
add if not exists partition (saledate='2008-10-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-10/';
alter table spectrum.sales_part
add if not exists partition (saledate='2008-11-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-11/';
alter table spectrum.sales_part
add if not exists partition (saledate='2008-12-01')
location 's3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-12/';
```

Para seleccionar los datos de la tabla particionada, ejecute la siguiente consulta.

```
select top 10 spectrum.sales_part.eventid, sum(spectrum.sales_part.pricepaid)
from spectrum.sales_part, event
where spectrum.sales_part.eventid = event.eventid
  and spectrum.sales_part.pricepaid > 30
  and saledate = '2008-12-01'
group by spectrum.sales_part.eventid
order by 2 desc;
```

```
eventid | sum
--------+---------
    914 | 36173.00
   5478 | 27303.00
   5061 | 26383.00
   4406 | 26252.00
   5324 | 24015.00
   1829 | 23911.00
   3601 | 23616.00
   3665 | 23214.00
   6069 | 22869.00
   5638 | 22551.00
```

Para ver particiones de la tabla externa, consulte la vista del sistema [SVV\$1EXTERNAL\$1PARTITIONS](r_SVV_EXTERNAL_PARTITIONS.md).

```
select schemaname, tablename, values, location from svv_external_partitions
where tablename = 'sales_part';
```

```
schemaname | tablename  | values         | location
-----------+------------+----------------+--------------------------------------------------
spectrum   | sales_part | ["2008-01-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-01
spectrum   | sales_part | ["2008-02-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-02
spectrum   | sales_part | ["2008-03-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-03
spectrum   | sales_part | ["2008-04-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-04
spectrum   | sales_part | ["2008-05-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-05
spectrum   | sales_part | ["2008-06-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-06
spectrum   | sales_part | ["2008-07-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-07
spectrum   | sales_part | ["2008-08-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-08
spectrum   | sales_part | ["2008-09-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-09
spectrum   | sales_part | ["2008-10-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-10
spectrum   | sales_part | ["2008-11-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-11
spectrum   | sales_part | ["2008-12-01"] | s3://redshift-downloads/tickit/spectrum/sales_partition/saledate=2008-12
```

## Ejemplos de formato de fila
<a name="r_CREATE_EXTERNAL_TABLE_examples-row-format"></a>

A continuación, se muestra un ejemplo de cómo especificar los parámetros ROW FORMAT SERDE para archivos de datos almacenados con formato AVRO.

```
create external table spectrum.sales(salesid int, listid int, sellerid int, buyerid int, eventid int, dateid int, qtysold int, pricepaid decimal(8,2), comment VARCHAR(255))
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.avro.AvroSerDe'
WITH SERDEPROPERTIES ('avro.schema.literal'='{\"namespace\": \"dory.sample\",\"name\": \"dory_avro\",\"type\": \"record\", \"fields\": [{\"name\":\"salesid\", \"type\":\"int\"},
{\"name\":\"listid\", \"type\":\"int\"},
{\"name\":\"sellerid\", \"type\":\"int\"},
{\"name\":\"buyerid\", \"type\":\"int\"},
{\"name\":\"eventid\",\"type\":\"int\"},
{\"name\":\"dateid\",\"type\":\"int\"},
{\"name\":\"qtysold\",\"type\":\"int\"},
{\"name\":\"pricepaid\", \"type\": {\"type\": \"bytes\", \"logicalType\": \"decimal\", \"precision\": 8, \"scale\": 2}}, {\"name\":\"comment\",\"type\":\"string\"}]}')
STORED AS AVRO
location 's3://amzn-s3-demo-bucket/avro/sales' ;
```

A continuación se muestra un ejemplo de especificación de los parámetros ROW FORMAT SERDE mediante RegEx.

```
create external table spectrum.types(
cbigint bigint,
cbigint_null bigint,
cint int,
cint_null int)
row format serde 'org.apache.hadoop.hive.serde2.RegexSerDe'
with serdeproperties ('input.regex'='([^\\x01]+)\\x01([^\\x01]+)\\x01([^\\x01]+)\\x01([^\\x01]+)')
stored as textfile
location 's3://amzn-s3-demo-bucket/regex/types';
```

A continuación se muestra un ejemplo de especificación de los parámetros ROW FORMAT SERDE mediante Grok.

```
create external table spectrum.grok_log(
timestamp varchar(255),
pid varchar(255),
loglevel varchar(255),
progname varchar(255),
message varchar(255))
row format serde 'com.amazonaws.glue.serde.GrokSerDe'
with serdeproperties ('input.format'='[DFEWI], \\[%{TIMESTAMP_ISO8601:timestamp} #%{POSINT:pid:int}\\] *(?<loglevel>:DEBUG|FATAL|ERROR|WARN|INFO) -- +%{DATA:progname}: %{GREEDYDATA:message}')
stored as textfile
location 's3://DOC-EXAMPLE-BUCKET/grok/logs';
```

A continuación, se muestra un ejemplo en el que se define un registro de acceso al servidor de Amazon S3 en un bucket de S3. Puede utilizar Redshift Spectrum para consultar los registros de acceso de Amazon S3.

```
CREATE EXTERNAL TABLE spectrum.mybucket_s3_logs(
bucketowner varchar(255),
bucket varchar(255),
requestdatetime varchar(2000),
remoteip varchar(255),
requester varchar(255),
requested varchar(255),
operation varchar(255),
key varchar(255),
requesturi_operation varchar(255),
requesturi_key varchar(255),
requesturi_httpprotoversion varchar(255),
httpstatus varchar(255),
errorcode varchar(255),
bytessent bigint,
objectsize bigint,
totaltime varchar(255),
turnaroundtime varchar(255),
referrer varchar(255),
useragent varchar(255),
versionid varchar(255)
)
ROW FORMAT SERDE 'org.apache.hadoop.hive.serde2.RegexSerDe'
WITH SERDEPROPERTIES (
'input.regex' = '([^ ]*) ([^ ]*) \\[(.*?)\\] ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) \"([^ ]*)\\s*([^ ]*)\\s*([^ ]*)\" (- |[^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) ([^ ]*) (\"[^\"]*\") ([^ ]*).*$')
LOCATION 's3://amzn-s3-demo-bucket/s3logs’;
```

A continuación, se muestra un ejemplo de cómo especificar los parámetros ROW FORMAT SERDE para datos con formato ION.

```
CREATE EXTERNAL TABLE tbl_name (columns)
ROW FORMAT SERDE 'com.amazon.ionhiveserde.IonHiveSerDe'
STORED AS
INPUTFORMAT 'com.amazon.ionhiveserde.formats.IonInputFormat'
OUTPUTFORMAT 'com.amazon.ionhiveserde.formats.IonOutputFormat'
LOCATION 's3://amzn-s3-demo-bucket/prefix'
```

## Ejemplos de control de datos
<a name="r_CREATE_EXTERNAL_TABLE_examples-data-handling"></a>

Los ejemplos siguientes acceden al archivo [spi\$1global\$1rankings.csv](https://s3.amazonaws.com/redshift-downloads/docs-downloads/spi_global_rankings.csv). Puede cargar el archivo `spi_global_rankings.csv` en un bucket de Amazon S3 para probar estos ejemplos.

En el siguiente ejemplo, se crea el esquema externo `schema_spectrum_uddh` y la base de datos `spectrum_db_uddh`. En el caso de `aws-account-id`, ingrese su ID de cuenta de AWS y, para `role-name`, ingrese el nombre de rol de Redshift Spectrum.

```
create external schema schema_spectrum_uddh
from data catalog
database 'spectrum_db_uddh'
iam_role 'arn:aws:iam::aws-account-id:role/role-name'
create external database if not exists;
```

En el siguiente ejemplo, se crea una tabla externa `soccer_league` en el esquema externo `schema_spectrum_uddh`.

```
CREATE EXTERNAL TABLE schema_spectrum_uddh.soccer_league
(
  league_rank smallint,
  prev_rank   smallint,
  club_name   varchar(15),
  league_name varchar(20),
  league_off  decimal(6,2),
  league_def  decimal(6,2),
  league_spi  decimal(6,2),
  league_nspi integer
)
ROW FORMAT DELIMITED
    FIELDS TERMINATED BY ','
    LINES TERMINATED BY '\n\l'
stored as textfile
LOCATION 's3://spectrum-uddh/league/'
table properties ('skip.header.line.count'='1');
```

Verifique el número de filas en la tabla `soccer_league`.

```
select count(*) from schema_spectrum_uddh.soccer_league;
```

Se muestra el número de filas.

```
count
645
```

En la siguiente consulta, se muestran los 10 clubes principales. Dado que el club `Barcelona` tiene un carácter no válido en la cadena, se muestra un NULL en el nombre.

```
select league_rank,club_name,league_name,league_nspi
from schema_spectrum_uddh.soccer_league
where league_rank between 1 and 10;
```

```
league_rank	club_name	league_name			league_nspi
1		Manchester City	Barclays Premier Lea		34595
2		Bayern Munich	German Bundesliga		34151
3		Liverpool	Barclays Premier Lea		33223
4		Chelsea		Barclays Premier Lea		32808
5		Ajax		Dutch Eredivisie		32790
6		Atletico 	Madrid	Spanish Primera Divi	31517
7		Real Madrid	Spanish Primera Divi		31469
8		NULL	        Spanish Primera Divi            31321
9		RB Leipzig	German Bundesliga		31014
10		Paris Saint-Ger	French Ligue 1			30929
```

En el siguiente ejemplo, se modifica la tabla `soccer_league` para especificar las propiedades de tabla externa `invalid_char_handling`, `replacement_char` y `data_cleansing_enabled` con objeto de insertar un signo de interrogación (?) como reemplazo de caracteres no previstos.

```
alter  table schema_spectrum_uddh.soccer_league
set table properties ('invalid_char_handling'='REPLACE','replacement_char'='?','data_cleansing_enabled'='true');
```

En el siguiente ejemplo, se consulta la tabla `soccer_league` para equipos con una clasificación del 1 al 10.

```
select league_rank,club_name,league_name,league_nspi
from schema_spectrum_uddh.soccer_league
where league_rank between 1 and 10;
```

Dado que las propiedades de la tabla se han modificado, los resultados muestran los 10 principales clubes, con el carácter de sustitución del signo de interrogación (?) en la octava fila para el club `Barcelona`.

```
league_rank	club_name	league_name		league_nspi
1		Manchester City	Barclays Premier Lea	34595
2		Bayern Munich	German Bundesliga	34151
3		Liverpool	Barclays Premier Lea	33223
4		Chelsea		Barclays Premier Lea	32808
5		Ajax		Dutch Eredivisie	32790
6		Atletico Madrid	Spanish Primera Divi	31517
7		Real Madrid	Spanish Primera Divi	31469
8		Barcel?na	Spanish Primera Divi	31321
9		RB Leipzig	German Bundesliga	31014
10		Paris Saint-Ger	French Ligue 1		30929
```

En el siguiente ejemplo, se modifica la tabla `soccer_league` para especificar las propiedades de tabla externa `invalid_char_handling` con objeto de eliminar filas con caracteres no previstos.

```
alter table schema_spectrum_uddh.soccer_league
set table properties ('invalid_char_handling'='DROP_ROW','data_cleansing_enabled'='true');
```

En el siguiente ejemplo, se consulta la tabla `soccer_league` para equipos con una clasificación del 1 al 10.

```
select league_rank,club_name,league_name,league_nspi
from schema_spectrum_uddh.soccer_league
where league_rank between 1 and 10;
```

En los resultados se muestran los clubes principales, pero no se incluye la octava fila, que correspondería al club `Barcelona`.

```
league_rank   club_name         league_name            league_nspi
1             Manchester City   Barclays Premier Lea   34595
2             Bayern Munich     German Bundesliga      34151
3             Liverpool         Barclays Premier Lea   33223
4             Chelsea           Barclays Premier Lea   32808
5             Ajax              Dutch Eredivisie       32790
6             Atletico Madrid   Spanish Primera Divi   31517
7             Real Madrid       Spanish Primera Divi   31469
9             RB Leipzig        German Bundesliga      31014
10            Paris Saint-Ger   French Ligue 1         30929
```