O Amazon Redshift não permitirá mais a criação de UDFs do Python a partir do Patch 198. As UDFs do Python existentes continuarão a funcionar normalmente até 30 de junho de 2026. Para ter mais informações, consulte a [publicação de 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>

Cria uma nova tabela externa no esquema especificado. Todas as tabelas externas devem ser criadas em um esquema externo. O caminho de pesquisa não é compatível com esquemas e tabelas externos. Para obter mais informações, consulte [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md).

Além das tabelas externas criadas usando o comando de CREATE EXTERNAL TABLE, o Amazon Redshift pode fazer referência a tabelas externas definidas em um catálogo do AWS Glue ou do AWS Lake Formation ou em uma metastore do Apache Hive. Use o comando [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md) para registrar um banco de dados externo definido no catálogo externo e disponibilize as tabelas externas para uso no Amazon Redshift. Se a tabela externa existir em um catálogo do AWS Glue ou do AWS Lake Formation ou na metastore do Hive, você não precisará criar uma tabela usando CREATE EXTERNAL TABLE. Para visualizar as tabelas externas, consulte a exibição do sistema [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md). 

Ao executar o comando CREATE EXTERNAL TABLE AS, você cria uma tabela externa com base na definição da coluna de uma consulta e grava os resultados dessa consulta no Amazon S3. Os resultados estão no Apache Parquet ou no formato de texto delimitado. Se a tabela externa tiver uma chave ou chaves de partições, o Amazon Redshift particionará novos arquivos de acordo com essas chaves de partição e registrará novas partições no catálogo externo automaticamente. Para obter mais informações sobre CREATE EXTERNAL TABLE AS, consulte [Observações de uso](r_CREATE_EXTERNAL_TABLE_usage.md). 

Você pode consultar uma tabela externa usando a mesma sintaxe de SELECT que usa com outras tabelas do Amazon Redshift. Também é possível usar a sintaxe INSERT para gravar novos arquivos no local da tabela externa no Amazon S3. Para obter mais informações, consulte [INSERT (tabela externa)](r_INSERT_external_table.md).

Para criar uma exibição com uma tabela externa, inclua a cláusula WITH NO SCHEMA BINDING na instrução [CREATE VIEW](r_CREATE_VIEW.md).

Não é possível executar CREATE EXTERNAL TABLE em uma transação (BEGIN … END). Para obter mais informações sobre transações, consulte [Níveis de isolamento no Amazon Redshift](c_serial_isolation.md). 

## Privilégios obrigatórios
<a name="r_CREATE_EXTERNAL_TABLE-privileges"></a>

Para criar tabelas externas, você deve ser proprietário do esquema externo ou um superusuário. Para transferir a propriedade de um esquema externo, use ALTER SCHEMA para alterar o proprietário. O acesso a tabelas externas é controlado pelo acesso ao esquema externo. Não é possível usar o comando [GRANT](r_GRANT.md) ou [REVOKE](r_REVOKE.md) para permissões em uma tabela externa. Em vez disso, conceda ou revogue USAGE no esquema externo.

As [Observações de uso](r_CREATE_EXTERNAL_TABLE_usage.md) têm informações adicionais sobre permissões específicas para tabelas externas.

## Sintaxe
<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' [, ...] ) ]
```

Veja a seguir a sintaxe 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 }
```

## Parâmetros
<a name="r_CREATE_EXTERNAL_TABLE-parameters"></a>

 *external\$1schema.table\$1name*   
Nome da tabela a ser criada, qualificada por um nome de esquema externo. As tabelas externas devem ser criadas em um esquema externo. Para obter mais informações, consulte [CREATE EXTERNAL SCHEMA](r_CREATE_EXTERNAL_SCHEMA.md).  
O tamanho máximo de um nome de tabela é 127 bytes; nomes mais longos são truncados para ter no máximo 127 bytes. É possível usar caracteres multibyte UFT-8 até um máximo de quatro bytes. O Amazon Redshift aplica um limite de 9.900 tabelas por cluster, incluindo tabelas temporárias definidas pelo usuário e tabelas temporárias criadas pelo Amazon Redshift durante o processamento de consultas ou a manutenção do sistema. Como opção, é possível qualificar o nome da tabela com o nome do banco de dados. No exemplo a seguir, o nome do banco de dados é `spectrum_db`, o nome do esquema externo é `spectrum_schema` e o nome da tabela é `test`.  

```
create external table spectrum_db.spectrum_schema.test (c1 int)
stored as parquet
location 's3://amzn-s3-demo-bucket/myfolder/';
```
Se o banco de dados ou esquema especificado não existir, a tabela não será criada e a instrução retornará um erro. Você não pode criar tabelas ou exibições nos bancos de dados do sistema `template0`, `template1`, `padb_harvest` ou `sys:internal`.  
O nome da tabela deve ser exclusivo para o esquema especificado.   
Para obter mais informações sobre nomes válidos, consulte [Nomes e identificadores](r_names.md).

( *nome\$1coluna* *tipo\$1dados* )  
O nome e o tipo de dados de cada coluna que está sendo criada.  
O tamanho máximo de um nome de coluna é 127 bytes; nomes mais longos são truncados para ter no máximo 127 bytes. É possível usar caracteres multibyte UFT-8 até um máximo de quatro bytes. Você não pode especificar nomes de coluna `"$path"` ou `"$size"`. Para obter mais informações sobre nomes válidos, consulte [Nomes e identificadores](r_names.md).  
Por padrão, o Amazon Redshift cria tabelas externas com as pseudocolunas `$path` e `$size`. Você pode desabilitar a criação de pseudocolunas em uma sessão. Basta definir o parâmetro de configuração `spectrum_enable_pseudo_columns` como `false`. Para obter mais informações, consulte [Pseudocolunas](r_CREATE_EXTERNAL_TABLE_usage.md#r_CREATE_EXTERNAL_TABLE_usage-pseudocolumns).  
Se as pseudocolunas forem habilitadas, o número máximo de colunas que você poderá definir em uma única tabela será 1.598. Se pseudocolunas não estiverem habilitadas, o número máximo de colunas que poderá ser definido em uma única tabela será 1.600.   
Se você estiver criando uma "tabela larga", assegure que sua lista de colunas não exceda os limites de largura de linha para resultados intermediários durante cargas e processamento de consultas. Para obter mais informações, consulte [Observações de uso](r_CREATE_TABLE_NEW.md#r_CREATE_TABLE_usage).  
Para um comando CREATE EXTERNAL TABLE AS, não é necessária uma lista de colunas, pois elas são derivadas da consulta.

 *data\$1type*   
Os seguintes [Tipos de dados](c_Supported_data_types.md) são compatíveis:  
+ SMALLINT (INT2)
+ INTEGER (INT, INT4)
+ BIGINT (INT8)
+ DECIMAL (NUMERIC)
+ REAL (FLOAT4)
+ DOUBLE PRECISION (FLOAT8)
+ BOOLEAN (BOOL)
+ CHAR (CHARACTER)
+ VARCHAR (CHARACTER VARYING)
+ VARBYTE (CHARACTER VARYING): pode ser usado com arquivos de dados Parquet e ORC, e somente com tabelas não particionadas.
+ DATE: pode ser usado somente com arquivos de dados de texto, Parquet ou ORC, ou como uma coluna de partição.
+ TIMESTAMP
  
Em DATE, você pode usar os formatos conforme descrito a seguir. Para valores mensais representados usando dígitos, estes formatos são compatíveis:  
+ `mm-dd-yyyy` Por exemplo, `05-01-2017`. Esse é o padrão.
+ `yyyy-mm-dd`, onde o ano é representado por mais de 2 dígitos. Por exemplo, `2017-05-01`.
Para valores mensais representados usando abreviações de três letras, estes formatos são compatíveis:  
+ `mmm-dd-yyyy` Por exemplo, `may-01-2017`. Esse é o padrão.
+ `dd-mmm-yyyy`, onde o ano é representado por mais de 2 dígitos. Por exemplo, `01-may-2017`.
+ `yyyy-mmm-dd`, onde o ano é representado por mais de 2 dígitos. Por exemplo, `2017-may-01`.
Para valores de ano consistentemente inferiores a 100, o ano é calculado desta maneira:  
+ Se o ano for inferior a 70, o ano será calculado como o ano mais 2000. Por exemplo, a data 05-01-17 no formato `mm-dd-yyyy` é convertida para `05-01-2017`.
+ Se o ano for inferior a 100 e maior que 69, o ano será calculado como o ano mais 1900. Por exemplo, a data 05-01-89 no formato `mm-dd-yyyy` é convertida para `05-01-1989`.
+ Para valores de ano representados por dois dígitos, adicione zeros à esquerda para representar o ano em 4 dígitos.
Os valores de data e hora nos arquivos de texto devem estar no formato `yyyy-mm-dd HH:mm:ss.SSSSSS`, como mostra o seguinte valor de data e hora de exemplo: `2017-05-01 11:30:59.000000`.  
O comprimento de uma coluna VARCHAR é definido em bytes, não em caracteres. Por exemplo, uma coluna VARCHAR(12) pode conter 12 caracteres de único byte ou 6 caracteres de dois bytes. Quando você consulta uma tabela externa, os resultados são truncados para se adequar ao tamanho da coluna definido sem retornar um erro. Para obter mais informações, consulte [Armazenamento e intervalos](r_Character_types.md#r_Character_types-storage-and-ranges).   
Para obter uma melhor performance, recomendamos especificar o menor tamanho de coluna que se ajusta aos seus dados. Para encontrar o tamanho máximo em bytes dos valores em uma coluna, use a função [OCTET\$1LENGTH](r_OCTET_LENGTH.md). O exemplo a seguir retorna o tamanho máximo de valores na coluna de email.  

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

max
---
 62
```

PARTITIONED BY (*nome\$1col* *tipo\$1dados* [, … ] )  
Cláusula que define uma tabela particionada com uma ou mais colunas de partição. Um diretório de dados separado é usado para cada combinação específica, o que pode melhorar a performance da consulta em algumas condições. As colunas particionadas não existem na própria tabela de dados. Se você usar um valor para *col\$1name* que é o mesmo valor usado na coluna da tabela, obterá um erro.   
Depois de criar uma tabela particionada, altere-a usando uma instrução [ALTER TABLE](r_ALTER_TABLE.md) … ADD PARTITION para registrar novas partições no catálogo externo. Ao adicionar uma partição, você define a localização da subpasta no Amazon S3 que contém dados da partição.  
Por exemplo, se a tabela `spectrum.lineitem_part` for definida com `PARTITIONED BY (l_shipdate date)`, execute o comando ALTER TABLE a seguir para adicionar uma partição.  

```
ALTER TABLE spectrum.lineitem_part ADD PARTITION (l_shipdate='1992-01-29')
LOCATION 's3://spectrum-public/lineitem_partition/l_shipdate=1992-01-29';
```
Se você estiver usando CREATE EXTERNAL TABLE AS, não será necessário executar ALTER TABLE…ADD PARTITION. O Amazon Redshift registra novas partições no catálogo externo. O Amazon Redshift também grava automaticamente os dados correspondentes nas partições no Amazon S3 com base na chave ou nas chaves de partição definidas na tabela.  
Para visualizar partições, consulte a exibição do sistema [SVV\$1EXTERNAL\$1PARTITIONS](r_SVV_EXTERNAL_PARTITIONS.md).  
Para um comando CREATE EXTERNAL TABLE AS, não é necessário especificar o tipo de dados da coluna de partição, pois essa coluna é derivada da consulta. 

ROW FORMAT DELIMITED *formatodelinha*  
Cláusula que especifica o formato de dados subjacentes. Os valores possíveis para *rowformat* são os seguintes:  
+ LINES TERMINATED BY '*delimiter*' 
+ FIELDS TERMINATED BY '*delimiter*' 
Especifique um único caractere ASCII para '*delimiter*'. É possível especificar caracteres ASCII não imprimíveis usando o sistema octal no formato `'\`*`ddd`*`'`, em que *`d`* é um dígito octal (0-7) até “\$1177”. O exemplo a seguir especifica o caractere BEL (sino) usando o sistema octal.   

```
ROW FORMAT DELIMITED FIELDS TERMINATED BY '\007'
```
Se ROW FORMAT for omitido, o formato padrão será DELIMITED FIELDS TERMINATED BY '\$1A' (início do cabeçalho) e LINES TERMINATED BY '\$1n' (nova linha). 

ROW FORMAT SERDE '*serde\$1name*' [WITH SERDEPROPERTIES ( '*property\$1name*' = '*property\$1value*' [, ...] ) ]  
Uma cláusula que especifica o formato SERDE para os dados subjacentes.     
'*serde\$1name*'  
O nome de SerDe. Você pode especificar os seguintes formatos:  
+ org.apache.hadoop.hive.serde2.RegexSerDe 
+ com.amazonaws.glue.serde.GrokSerDe 
+ org.apache.hadoop.hive.serde2.OpenCSVSerde 

  Esse parâmetro é compatível com a seguinte propriedade SerDe para OpenCSVSerde: 

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

  Defina a propriedade `wholeFile` para `true` a fim de analisar corretamente novos caracteres de linha (\$1n) dentro de strings entre aspas para solicitações de OpenCSV. 
+ org.openx.data.jsonserde.JsonSerDe
  + O JSON SERDE também dá suporte aos arquivos Ion. 
  + O JSON bastante deve ser bem formado. 
  + Os timestamps em Ion e JSON precisam ter formato ISO8601.
  + Esse parâmetro é compatível com a seguinte propriedade SerDe para JsonSerDe: 

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

    Processa arquivos Ion/JSON contendo uma matriz muito grande entre colchetes externos ( [ … ] ) como se contivesse vários registros JSON dentro da matriz. 
+ com.amazon.ionhiveserde.IonHiveSerDe

  O formato Amazon ION fornece formatos de texto e binário, além dos tipos de dados. Para uma tabela externa que faz referência a dados no formato ION, mapeie cada coluna na tabela externa para o elemento correspondente nos dados do formato ION. Para obter mais informações, consulte [Amazon Ion](https://amzn.github.io/ion-docs/). Também é necessário especificar os formatos de entrada e saída.  
WITH SERDEPROPERTIES ( '*property\$1name*' = '*property\$1value*' [, ...] ) ]  
Opcionalmente, especifique nomes e valores de propriedade, separados por vírgulas.
Se ROW FORMAT for omitido, o formato padrão será DELIMITED FIELDS TERMINATED BY '\$1A' (início do cabeçalho) e LINES TERMINATED BY '\$1n' (nova linha). 

STORED AS *formato do arquivo*  
Formato para arquivos de dados.   
Os formatos válidos são:  
+ PARQUET
+ RCFILE (somente para dados que usem ColumnarSerDe, não LazyBinaryColumnarSerDe)
+ SEQUENCEFILE
+ TEXTFILE (para arquivos de texto, inclusive arquivos JSON).
+ ORC 
+ AVRO 
+ INPUTFORMAT '*input\$1format\$1classname*' OUTPUTFORMAT '*output\$1format\$1classname*' 
O comando CREATE EXTERNAL TABLE AS oferece suporte somente a dois formatos de arquivo, TEXTFILE e PARQUET.  
Para INPUTFORMAT e OUTPUTFORMAT, especifique um nome de classe, conforme exibido no exemplo a seguir:   

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

LOCATION \$1 's3://*bucket/folder*/' \$1 's3://*bucket/manifest\$1file*'\$1  <a name="create-external-table-location"></a>
O caminho para a pasta ou bucket do Amazon S3 que contém arquivos de dados ou um arquivo manifesto que contém uma lista de caminhos de objetos do Amazon S3. Os buckets devem estar na mesma região da AWS que o cluster do Amazon Redshift. Para obter uma lista de regiões da AWS compatíveis, consulte [Limitações do Amazon Redshift Spectrum](c-spectrum-considerations.md).  
Se o caminho especificar uma pasta ou bucket, por exemplo `'s3://amzn-s3-demo-bucket/custdata/'`, o Redshift Spectrum fará a varredura dos arquivos na pasta ou bucket especificado e em todas as subpastas. O Redshift Spectrum ignora os arquivos ocultos e os arquivos que começam com um ponto ou um sublinhado.   
Se o caminho especificar um arquivo manifesto, o argumento `'s3://bucket/manifest_file'` deverá fazer referência explícita a um único arquivo, por exemplo, `'s3://amzn-s3-demo-bucket/manifest.txt'`. Ele não pode fazer referência a um prefixo de chaves.   
O manifesto é um arquivo de texto em formato JSON que lista o URL de cada arquivo a ser carregado a partir do Amazon S3 e o tamanho do arquivo em bytes. O URL inclui o nome do bucket e o caminho de objeto completo do arquivo. Os arquivos especificados no manifesto podem estar em buckets diferentes, mas todos os buckets devem estar na mesma região da AWS que o cluster do Amazon Redshift. Se for listado duas vezes, o arquivo será carregado duas vezes. O exemplo a seguir mostra o JSON de um manifesto que carrega três arquivos.   

```
{
  "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 } }
  ]
}
```
Você pode tornar a inclusão de um arquivo específico obrigatória. Para fazer isso, inclua uma opção `mandatory` em nível de arquivo no manifesto. Ao consultar uma tabela externa com um ficheiro obrigatório faltando, a instrução SELECT falha. Certifique-se de que todos os arquivos incluídos na definição da tabela externa estejam presentes. Se nem todos estiverem presentes, um erro será exibido mostrando o primeiro arquivo obrigatório que não foi encontrado. O exemplo a seguir mostra o JSON para um manifesto com a opção `mandatory` definida como `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 fazer referência a arquivos criados usando UNLOAD, use o manifesto criado usando [UNLOAD](r_UNLOAD.md) com o parâmetro MANIFEST. O arquivo manifesto é compatível com um arquivo manifesto para [COPY do Amazon S3](copy-parameters-data-source-s3.md), mas utiliza chaves diferentes. Chaves que não são usadas são ignoradas. 

TABLE PROPERTIES ( '*property\$1name*'='*property\$1value*' [, ...] )   
Uma cláusula que estabelece a definição da tabela para propriedades da tabela.   
As propriedades de tabela fazem distinção entre maiúsculas e minúsculas.  
 'compression\$1type'='*valor*'   
 Uma propriedade que define o tipo de compactação a ser usado se o nome de arquivo não contiver uma extensão. Se você definir essa propriedade e houver uma extensão de arquivo, a extensão será ignorada e o valor definido pela propriedade será usado. Os valores válidos para o tipo de compactação são os seguintes:  
+ bzip2
+ gzip
+ nenhuma
+ snappy  
'data\$1cleansing\$1enabled'='true / false’  
Essa propriedade define se o tratamento de dados está ativado para a tabela. Quando 'data\$1cleansing\$1enabled' está definido como true, o tratamento de dados está ativado para a tabela. Quando 'data\$1cleansing\$1enabled' está definido como false, o tratamento de dados está desativado para a tabela. A seguir, há uma lista das propriedades de tratamento de dados em nível de tabela controladas por essa propriedade:  
+ column\$1count\$1mismatch\$1handling
+ invalid\$1char\$1handling
+ numeric\$1overflow\$1handling
+ replacement\$1char
+ surplus\$1char\$1handling
Para obter exemplos, consulte [Exemplos de tratamento de dados](r_CREATE_EXTERNAL_TABLE_examples.md#r_CREATE_EXTERNAL_TABLE_examples-data-handling).  
'invalid\$1char\$1handling'='*valor*'   
Especifica a ação a ser realizada quando os resultados da consulta contêm valores de caracteres UTF-8 inválidos. Você pode especificar as seguintes ações:    
DESATIVADA  
Não trata os caracteres inválidos.  
FAIL  
Cancela as consultas que retornam dados contendo valores UTF-8 inválidos.  
SET\$1TO\$1NULL   
Substitui os valores UTF-8 inválidos por null.  
DROP\$1ROW  
Substitui todos os valores da linha por null.  
REPLACE  
Substitui o caractere inválido pelo caractere de substituição especificado usando `replacement_char`.  
'replacement\$1char'='*caractere*’  
Especifica o caractere de substituição a ser usado quando você define `invalid_char_handling` como `REPLACE`.  
'numeric\$1overflow\$1handling'='valor’  
Especifica a ação a ser realizada quando os dados ORC contêm um inteiro (por exemplo, BIGINT ou int64) que é maior que a definição da coluna (por exemplo, SMALLINT ou int16). Você pode especificar as seguintes ações:    
DESATIVADA  
O tratamento de caracteres inválidos é desativado.  
FAIL  
Cancelar a consulta quando os dados incluírem caracteres inválidos.  
SET\$1TO\$1NULL  
Definir os caracteres inválidos como null.  
DROP\$1ROW  
Definir todos os valores da linha como null.  
'surplus\$1bytes\$1handling'='*value*'  
Especifica como lidar com os dados sendo carregados que excederem o comprimento do tipo de dado definido para colunas contendo dados VARBYTE. Por padrão, o Redshift Spectrum define o valor como null para dados que excedem a largura da coluna.  
Você pode especificar as seguintes ações a serem realizadas quando a consulta retorna dados que excedem o comprimento do tipo de dado:    
SET\$1TO\$1NULL  
Substitui os dados que excedem a largura da coluna por null.  
DESATIVADA  
Não lida com excesso de bytes.  
FAIL  
Cancela as consultas que retornam dados que excedem a largura da coluna.  
DROP\$1ROW  
Elimine todas as linhas que contêm dados que excedam a largura da coluna.  
TRUNCATE  
Remove os caracteres que excedem o número máximo de caracteres definido para a coluna.  
'surplus\$1char\$1handling'='*valor*'  
Especifica como lidar com os dados sendo carregados que excederem o comprimento do tipo de dados definido para colunas contendo VARCHAR, CHAR ou dados em string. Por padrão, o Redshift Spectrum define o valor como null para dados que excedem a largura da coluna.  
Você pode especificar as seguintes ações a serem realizadas quando a consulta retorna dados que excedem a largura da coluna:    
SET\$1TO\$1NULL  
Substitui os dados que excedem a largura da coluna por null.  
DESATIVADA  
Não trata de caracteres em excesso.  
FAIL  
Cancela as consultas que retornam dados que excedem a largura da coluna.  
DROP\$1ROW  
Substitui todos os valores da linha por null.  
TRUNCATE  
Remove os caracteres que excedem o número máximo de caracteres definido para a coluna.  
'column\$1count\$1mismatch\$1handling'='value’  
Identifica se o arquivo contém um número menor ou maior de valores para uma linha do que o de colunas especificado na definição da tabela externa. Essa propriedade só está disponível para um formato de arquivo de texto não compactado. Você pode especificar as seguintes ações:    
DESATIVADA  
O tratamento de incompatibilidade de contagem de colunas está desativado.  
FAIL  
Há falha na consulta se for detectada incompatibilidade na contagem de colunas.  
SET\$1TO\$1NULL  
Preencha os valores ausentes com NULL e ignore os valores adicionais em cada linha.  
DROP\$1ROW  
Elimine todas as linhas que contêm erro de incompatibilidade de contagem de colunas na verificação.  
'numRows'='*row\$1count*'   
Uma propriedade que define o valor de numRows para a definição da tabela. Para atualizar de maneira explícita as estatísticas de uma tabela externa, defina a propriedade numRows de maneira a indicar o tamanho da tabela. O Amazon Redshift não analisa as tabelas externas para gerar as estatísticas das tabelas que o otimizador de consultas utiliza para gerar um plano de consulta. Se as estatísticas de tabelas não estiverem definidas para uma tabela externa, o Amazon Redshift gera um plano de execução de consulta com base na suposição de que as tabelas externas são maiores e as tabelas locais são menores.  
'skip.header.line.count'='*line\$1count*'  
Uma propriedade que define o número de linhas a serem ignoradas no início de cada arquivo de origem.  
'serialization.null.format'=' '  
Uma propriedade que especifica o Spectrum deve retornar um valor `NULL` quando houver uma correspondência exata com o texto fornecido em um campo.  
'orc.schema.resolution'='mapping\$1type'  
Uma propriedade que define o tipo de mapeamento de coluna para tabelas que usam o formato de dados ORC. Essa propriedade é ignorada para outros formatos de dados.  
Os valores válidos para o tipo de mapeamento de coluna são os seguintes:   
+ name 
+ position 
Se a propriedade *orc.schema.resolution* for omitida, as colunas serão mapeadas por nome por padrão. Se *orc.schema.resolution* estiver definido como qualquer valor diferente de *'name'* ou *'position'*, as colunas serão mapeadas por posição. Para obter mais informações sobre o mapeamento de colunas, consulte [Mapeamento de colunas de tabela externa para colunas do ORC](c-spectrum-external-tables.md#c-spectrum-column-mapping-orc).  
O comando COPY mapeia para arquivos de dados ORC apenas por posição. A propriedade de tabela *orc.schema.resolution* não tem efeito sobre o comportamento do comando COPY.   
'write.parallel'='on / off’  
Uma propriedade que define se CREATE EXTERNAL TABLE AS deve gravar dados em paralelo. Por padrão, CREATE EXTERNAL TABLE AS grava dados em paralelo em vários arquivos, de acordo com o número de fatias no cluster. A opção padrão é ativado. Quando 'write.parallel' está definido como desativado, CREATE EXTERNAL TABLE AS grava em um ou mais arquivos de dados serialmente no Amazon S3. Essa propriedade de tabela também se aplica a qualquer instrução INSERT subsequente na mesma tabela externa.  
‘write.maxfilesize.mb’=‘size’  
Uma propriedade que define o tamanho máximo (em MB) de cada arquivo gravado no Amazon S3 por CREATE EXTERNAL TABLE AS. O tamanho deve ser um número inteiro entre 5 e 6.200. O tamanho máximo padrão do arquivo é 6.200 MB. Essa propriedade de tabela também se aplica a qualquer instrução INSERT subsequente na mesma tabela externa.  
‘write.kms.key.id’=‘*value*’  
É possível especificar uma chave AWS Key Management Service para habilitar a criptografia do lado do servidor (SSE) para objetos do Amazon S3, onde *value* é uma das seguintes ações:   
+ `auto` para usar o chave padrão do AWS KMS armazenada no bucket do Amazon S3.
+ *kms-key*que você especifica para criptografar dados.  
*select\$1statement*  
Uma instrução que insere uma ou mais linhas na tabela externa ao definir qualquer consulta. Todas as linhas que a consulta gera são gravadas no Amazon S3 no formato de texto ou Parquet com base na definição da tabela.

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

Uma coleção de exemplos está disponível em [Exemplos](r_CREATE_EXTERNAL_TABLE_examples.md).

# Observações de uso
<a name="r_CREATE_EXTERNAL_TABLE_usage"></a>

Este tópico contém notas de uso do [CREATE EXTERNAL TABLE](r_CREATE_EXTERNAL_TABLE.md). Não é possível exibir os detalhes das tabelas do Amazon Redshift Spectrum usando os mesmos recursos das tabelas padrão do Amazon Redshift, como [PG\$1TABLE\$1DEF](r_PG_TABLE_DEF.md), [STV\$1TBL\$1PERM](r_STV_TBL_PERM.md), PG\$1CLASS, ou information\$1schema. Caso sua ferramenta de business intelligence ou análise não reconheça as tabelas externas do Redshift Spectrum, configure sua aplicação para consultar [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md) e [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md).

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

Em alguns casos, é possível executar o comando CREATE EXTERNAL TABLE AS em um catálogo de dados do AWS Glue, em um catálogo externo do AWS Lake Formation ou em um metastore do Apache Hive. Nesses casos, use uma função do AWS Identity and Access Management (IAM) para criar o esquema externo. Essa função do IAM deve conter as permissões de leitura e gravação no Amazon S3. 

Se você usar um catálogo do Lake Formation, a função do IAM deve ter a permissão para criar tabelas no catálogo. Nesse caso, ela também deve ter a permissão do local do data lake no caminho de destino do Amazon S3. Essa função do IAM se torna proprietária da nova tabela do AWS Lake Formation.

Para garantir que os nomes dos arquivos sejam únicos, o Amazon Redshift usa o seguinte formato para o nome de cada arquivo carregado no Amazon S3 por padrão.

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

 Um exemplo é `20200303_004509_810669_1007_0001_part_00.parquet`.

Considere o seguinte ao executar o comando CREATE EXTERNAL TABLE AS:
+ O local do Amazon S3 deve estar vazio.
+ O Amazon Redshift oferece suporte somente aos formatos PARQUET e TEXTFILE ao usar a cláusula STORED AS.
+ Não é necessário criar uma lista de definições de coluna. Os nomes de colunas e os tipos de dados de coluna da nova tabela externa são derivados diretamente da consulta SELECT.
+ Não é necessário definir o tipo de dados da coluna de partição na cláusula PARTITIONED BY. Se você especificar uma chave de partição, o nome dessa coluna deverá existir no resultado da consulta SELECT. Ao ter várias colunas de partição, a ordem na consulta SELECT não importa. O Amazon Redshift usa a ordem definida na cláusula PARTITIONED BY para criar a tabela externa.
+ O Amazon Redshift automaticamente particiona arquivos de saída em pastas de partição com base nas chaves-valor de partição. Por padrão, o Amazon Redshift remove as colunas de partição dos arquivos de saída.
+ Não há suporte para a cláusula LINES TERMINATED BY 'delimiter'.
+ Não há suporte para a cláusula ROW FORMAT SERDE 'serde\$1name'.
+ Não há suporte para o uso de arquivos de manifesto. Dessa forma, não é possível definir a cláusula LOCATION em um arquivo manifesto no Amazon S3.
+ O Amazon Redshift automaticamente atualiza a propriedade da tabela “numRows” no final do comando.
+ A propriedade da tabela 'compression\$1type' aceita somente 'none' ou 'snappy' para o formato de arquivo PARQUET.
+ O Amazon Redshift não permite a cláusula LIMIT na consulta SELECT externa. Em vez disso, você pode usar uma cláusula LIMIT aninhada.
+ É possível usar STL\$1UNLOAD\$1LOG para rastrear os arquivos que são gravados no Amazon S3 por cada operação CREATE EXTERNAL TABLE AS.

## Permissões para criar e consultar tabelas externas
<a name="r_CREATE_EXTERNAL_TABLE_usage-permissions"></a>

Para criar tabelas externas, verifique se você é o proprietário do esquema externo ou um superusuário. Para transferir a propriedade de um esquema externo, use [ALTER SCHEMA](r_ALTER_SCHEMA.md). O exemplo a seguir altera o proprietário do esquema `spectrum_schema` para `newowner`.

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

Para executar uma consulta do Redshift Spectrum, você precisa das seguintes permissões:
+ Permissão de uso no esquema 
+ Permissão para criar tabelas temporárias no banco de dados atual 

O exemplo a seguir concede permissão de uso no esquema `spectrum_schema` para o grupo de usuários `spectrumusers`.

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

O exemplo a seguir concede permissão temporária no banco de dados `spectrumdb` para o grupo de usuários `spectrumusers`. 

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

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

Por padrão, o Amazon Redshift cria tabelas externas com as pseudocolunas *\$1path* e *\$1size*. Selecione essas colunas para exibir o caminho que levará aos arquivos de dados no Amazon S3 e o tamanho dos arquivos de dados em cada linha retornada por uma consulta. Os nomes de coluna *\$1path* e *\$1size* devem ser delimitados por aspas duplas. A cláusula *SELECT \$1* não retornará as pseudocolunas. Você deve incluir explicitamente os nomes de coluna *\$1path* e *\$1size* na consulta, como mostra o exemplo a seguir.

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

Você pode desabilitar a criação de pseudocolunas em uma sessão. Basta definir o parâmetro de configuração *spectrum\$1enable\$1pseudo\$1columns* como *false*. 

**Importante**  
A seleção de *\$1size* ou *\$1path* gera cobranças porque o Redshift Spectrum verifica os arquivos de dados no Amazon S3 para determinar o tamanho do conjunto de resultados. Para obter mais informações, consulte [Preço do Amazon Redshift](https://aws.amazon.com/redshift/pricing/).

## Definir opções de tratamento de dados
<a name="r_CREATE_EXTERNAL_TABLE_usage-data-handling"></a>

Você pode definir parâmetros de tabela para especificar o tratamento de entrada para dados que estão sendo consultados em tabelas externas, incluindo: 
+ Caracteres excedentes em colunas contendo VARCHAR, CHAR e dados em string. Para obter mais informações, consulte a propriedade de tabela externa `surplus_char_handling`.
+ Caracteres inválidos em colunas contendo VARCHAR, CHAR e dados em string. Para obter mais informações, consulte a propriedade de tabela externa `invalid_char_handling`.
+ Caractere de substituição a ser usado quando você especificar REPLACE como a propriedade de tabela externa `invalid_char_handling`.
+ Tratamento de transbordamento de conversão em colunas contendo dados inteiros e decimais. Para obter mais informações, consulte a propriedade de tabela externa `numeric_overflow_handling`.
+ Surplus\$1bytes\$1handling para especificar o tratamento de entradas para bytes excedentes em colunas que contêm dados varbyte. Para obter mais informações, consulte a propriedade de tabela externa `surplus_bytes_handling`.

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

O exemplo a seguir cria uma tabela chamada SALES no esquema externo do Amazon Redshift denominado `spectrum`. Os dados estão em arquivos de texto delimitados por tabulação. A cláusula TABLE PROPERTIES define a propriedade numRows como 170.000 linhas.

Dependendo da identidade usada para executar CREATE EXTERNAL TABLE, pode haver permissões do IAM que você precisa configurar. Como prática recomendada, anexe políticas de permissões a um perfil do IAM e, depois, atribua-as a usuários e grupos, conforme necessário. Para obter mais informações, consulte [Gerenciamento de identidade e acesso no 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');
```

O exemplo a seguir cria uma tabela que usa o JsonSerDe para fazer referência aos dados em 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';
```

O exemplo de CREATE EXTERNAL TABLE AS a seguir cria uma tabela externa não particionada. Depois, ele grava o resultado da consulta SELECT como Apache Parquet no local de destino do Amazon S3.

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

O exemplo a seguir cria uma tabela externa particionada e inclui as colunas de partição na 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 obter uma lista de bancos de dados existentes no catálogo de dados externo, consulte a exibição de 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 visualizar detalhes das tabelas externas, consulte as exibições [SVV\$1EXTERNAL\$1TABLES](r_SVV_EXTERNAL_TABLES.md) e [SVV\$1EXTERNAL\$1COLUMNS](r_SVV_EXTERNAL_COLUMNS.md) do sistema.

O exemplo a seguir consulta a exibição 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
```

O exemplo a seguir consulta a exibição 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 exibir as partições de tabela, use a consulta a seguir.

```
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
```

O exemplo a seguir retorna o tamanho total de arquivos de dados relacionados de uma tabela 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
```

## Exemplos de particionamento
<a name="r_CREATE_EXTERNAL_TABLE_examples-partitioning"></a>

Para criar uma tabela externa particionada por data, execute o seguinte 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 adicionar as partições, execute os seguintes 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 selecionar dados na tabela particionada, execute a consulta a seguir.

```
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 visualizar as partições da tabela externa, consulte a exibição do 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
```

## Exemplos de formato de linha
<a name="r_CREATE_EXTERNAL_TABLE_examples-row-format"></a>

Este é um exemplo da especificação dos parâmetros ROW FORMAT SERDE para arquivos de dados armazenados no 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' ;
```

O exemplo a seguir mostra como especificar os parâmetros ROW FORMAT SERDE usando 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';
```

O exemplo a seguir mostra como especificar os parâmetros ROW FORMAT SERDE usando 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 tabela a seguir mostra um exemplo de definição de um log de acesso ao servidor do Amazon S3 em um bucket do S3. Use o Redshift Spectrum para consultar logs de acesso do 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’;
```

Este é um exemplo da especificação dos parâmetros ROW FORMAT SERDE para dados no 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'
```

## Exemplos de tratamento de dados
<a name="r_CREATE_EXTERNAL_TABLE_examples-data-handling"></a>

Os exemplos a seguir acessam o arquivo: [spi\$1global\$1rankings.csv](https://s3.amazonaws.com/redshift-downloads/docs-downloads/spi_global_rankings.csv). Você pode carregar o arquivo `spi_global_rankings.csv` em um bucket do Amazon S3 para experimentar esses exemplos.

O exemplo a seguir cria o esquema externo `schema_spectrum_uddh` e o banco de dados externo `spectrum_db_uddh`. Para `aws-account-id`, insira o ID da conta da AWS e, para `role-name`, insira seu nome de função do 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;
```

O exemplo a seguir cria uma tabela externa `soccer_league` no 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');
```

Confira o número de linhas da tabela `soccer_league`.

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

Os números de linhas são exibidos.

```
count
645
```

A consulta a seguir exibe os 10 principais clubes. Como clube `Barcelona` tem um caractere inválido na string, um NULL é exibido para o nome.

```
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
```

O exemplo a seguir altera a tabela `soccer_league` para especificar as propriedades `invalid_char_handling`, `replacement_char` e `data_cleansing_enabled` da tabela externa e inserir um ponto de interrogação (?) como substituto de caracteres inesperados.

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

O exemplo a seguir consulta a tabela `soccer_league` para times com classificação de 1 a 10.

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

Como as propriedades da tabela foram alteradas, os resultados mostram os dez principais clubes, com o ponto de interrogação (?) como caractere substituto na oitava linha para o clube `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
```

O exemplo a seguir altera a tabela `soccer_league` para especificar que as propriedades `invalid_char_handling` da tabela externa descartem as linhas com caracteres inesperados.

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

O exemplo a seguir consulta a tabela `soccer_league` para times com classificação de 1 a 10.

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

Os resultados exibem os principais clubes, sem incluir a oitava linha para o clube `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
```