CREATE TABLE¶

Sintaxe¶

CREATE [ OR REPLACE ]
    [ { [ LOCAL | GLOBAL ] TEMP[ORARY] | VOLATILE } | TRANSIENT ]
    TABLE [ IF NOT EXISTS ] <table_name>
    ( <col_name> <col_type>
                             [ COLLATE '<collation_specification>' ]
                                /* COLLATE is supported only for text data types (VARCHAR and synonyms) */
                             [ COMMENT '<string_literal>' ]
                             [ { DEFAULT <expr>
                               | { AUTOINCREMENT | IDENTITY } [ { ( <start_num> , <step_num> ) | START <num> INCREMENT <num> } ] } ]
                                /* AUTOINCREMENT (or IDENTITY) is supported only for numeric data types (NUMBER, INT, FLOAT, etc.) */
                             [ NOT NULL ]
                             [ [ WITH ] MASKING POLICY <policy_name> [ USING ( <col_name> , <cond_col1> , ... ) ] ]
                             [ [ WITH ] TAG ( <tag_name> = '<tag_value>' [ , <tag_name> = '<tag_value>' , ... ] ) ]
                             [ inlineConstraint ]
      [ , <col_name> <col_type> [ ... ] ]
      [ , outoflineConstraint ]
      [ , ... ] )
  [ CLUSTER BY ( <expr> [ , <expr> , ... ] ) ]
  [ STAGE_FILE_FORMAT = ( { FORMAT_NAME = '<file_format_name>'
                           | TYPE = { CSV | JSON | AVRO | ORC | PARQUET | XML } [ formatTypeOptions ] } ) ]
  [ STAGE_COPY_OPTIONS = ( copyOptions ) ]
  [ DATA_RETENTION_TIME_IN_DAYS = <integer> ]
  [ MAX_DATA_EXTENSION_TIME_IN_DAYS = <integer> ]
  [ CHANGE_TRACKING = { TRUE | FALSE } ]
  [ DEFAULT_DDL_COLLATION = '<collation_specification>' ]
  [ COPY GRANTS ]
  [ [ WITH ] ROW ACCESS POLICY <policy_name> ON ( <col_name> [ , <col_name> ... ] ) ]
  [ [ WITH ] TAG ( <tag_name> = '<tag_value>' [ , <tag_name> = '<tag_value>' , ... ] ) ]
  [ COMMENT = '<string_literal>' ]

Onde:

inlineConstraint ::=
  [ CONSTRAINT <constraint_name> ]
  { UNIQUE | PRIMARY KEY | { [ FOREIGN KEY ] REFERENCES <ref_table_name> [ ( <ref_col_name> ) ] } }
  [ <constraint_properties> ]

Para detalhes adicionais de restrição em linha, consulte CREATE | ALTER TABLE … CONSTRAINT.

outoflineConstraint ::=
  [ CONSTRAINT <constraint_name> ]
  {
     UNIQUE [ ( <col_name> [ , <col_name> , ... ] ) ]
   | PRIMARY KEY [ ( <col_name> [ , <col_name> , ... ] ) ]
   | [ FOREIGN KEY ] [ ( <col_name> [ , <col_name> , ... ] ) ]
                     REFERENCES <ref_table_name> [ ( <ref_col_name> [ , <ref_col_name> , ... ] ) ]
  }
  [ <constraint_properties> ]

Para detalhes adicionais de restrição fora de linha, consulte CREATE | ALTER TABLE … CONSTRAINT.

formatTypeOptions ::=
-- If TYPE = CSV
     COMPRESSION = AUTO | GZIP | BZ2 | BROTLI | ZSTD | DEFLATE | RAW_DEFLATE | NONE
     RECORD_DELIMITER = '<character>' | NONE
     FIELD_DELIMITER = '<character>' | NONE
     FILE_EXTENSION = '<string>'
     SKIP_HEADER = <integer>
     SKIP_BLANK_LINES = TRUE | FALSE
     DATE_FORMAT = '<string>' | AUTO
     TIME_FORMAT = '<string>' | AUTO
     TIMESTAMP_FORMAT = '<string>' | AUTO
     BINARY_FORMAT = HEX | BASE64 | UTF8
     ESCAPE = '<character>' | NONE
     ESCAPE_UNENCLOSED_FIELD = '<character>' | NONE
     TRIM_SPACE = TRUE | FALSE
     FIELD_OPTIONALLY_ENCLOSED_BY = '<character>' | NONE
     NULL_IF = ( '<string>' [ , '<string>' ... ] )
     ERROR_ON_COLUMN_COUNT_MISMATCH = TRUE | FALSE
     REPLACE_INVALID_CHARACTERS = TRUE | FALSE
     EMPTY_FIELD_AS_NULL = TRUE | FALSE
     SKIP_BYTE_ORDER_MARK = TRUE | FALSE
     ENCODING = '<string>' | UTF8
-- If TYPE = JSON
     COMPRESSION = AUTO | GZIP | BZ2 | BROTLI | ZSTD | DEFLATE | RAW_DEFLATE | NONE
     DATE_FORMAT = '<string>' | AUTO
     TIME_FORMAT = '<string>' | AUTO
     TIMESTAMP_FORMAT = '<string>' | AUTO
     BINARY_FORMAT = HEX | BASE64 | UTF8
     TRIM_SPACE = TRUE | FALSE
     NULL_IF = ( '<string>' [ , '<string>' ... ] )
     FILE_EXTENSION = '<string>'
     ENABLE_OCTAL = TRUE | FALSE
     ALLOW_DUPLICATE = TRUE | FALSE
     STRIP_OUTER_ARRAY = TRUE | FALSE
     STRIP_NULL_VALUES = TRUE | FALSE
     REPLACE_INVALID_CHARACTERS = TRUE | FALSE
     IGNORE_UTF8_ERRORS = TRUE | FALSE
     SKIP_BYTE_ORDER_MARK = TRUE | FALSE
-- If TYPE = AVRO
     COMPRESSION = AUTO | GZIP | BROTLI | ZSTD | DEFLATE | RAW_DEFLATE | NONE
     TRIM_SPACE = TRUE | FALSE
     NULL_IF = ( '<string>' [ , '<string>' ... ] )
-- If TYPE = ORC
     TRIM_SPACE = TRUE | FALSE
     NULL_IF = ( '<string>' [ , '<string>' ... ] )
-- If TYPE = PARQUET
     COMPRESSION = AUTO | LZO | SNAPPY | NONE
     SNAPPY_COMPRESSION = TRUE | FALSE
     BINARY_AS_TEXT = TRUE | FALSE
     TRIM_SPACE = TRUE | FALSE
     NULL_IF = ( '<string>' [ , '<string>' ... ] )
-- If TYPE = XML
     COMPRESSION = AUTO | GZIP | BZ2 | BROTLI | ZSTD | DEFLATE | RAW_DEFLATE | NONE
     IGNORE_UTF8_ERRORS = TRUE | FALSE
     PRESERVE_SPACE = TRUE | FALSE
     STRIP_OUTER_ELEMENT = TRUE | FALSE
     DISABLE_SNOWFLAKE_DATA = TRUE | FALSE
     DISABLE_AUTO_CONVERT = TRUE | FALSE
     SKIP_BYTE_ORDER_MARK = TRUE | FALSE

copyOptions ::=
     ON_ERROR = { CONTINUE | SKIP_FILE | SKIP_FILE_<num> | 'SKIP_FILE_<num>%' | ABORT_STATEMENT }
     SIZE_LIMIT = <num>
     PURGE = TRUE | FALSE
     RETURN_FAILED_ONLY = TRUE | FALSE
     MATCH_BY_COLUMN_NAME = CASE_SENSITIVE | CASE_INSENSITIVE | NONE
     ENFORCE_LENGTH = TRUE | FALSE
     TRUNCATECOLUMNS = TRUE | FALSE
     FORCE = TRUE | FALSE

Sintaxe da variante¶

Parâmetros obrigatórios¶

name

Especifica o identificador (ou seja, nome) da tabela; deve ser único para o esquema no qual a tabela é criada.

Além disso, o identificador deve começar com um caractere alfabético e não pode conter espaços ou caracteres especiais, a menos que toda a cadeia de caracteres do identificador esteja entre aspas duplas (por exemplo, "My object"). Os identificadores delimitados por aspas duplas também diferenciam letras maiúsculas de minúsculas.

Para obter mais detalhes, consulte Requisitos para identificadores.

col_name

Especifica o identificador da coluna (ou seja, o nome). Todos os requisitos de identificadores de tabela também se aplicam aos identificadores de coluna.

Para obter mais detalhes, consulte Requisitos para identificadores e Palavras-chave reservadas e limitadas.

Nota

Além das palavras-chave padrão reservadas, as seguintes palavras-chave não podem ser usadas como identificadores de coluna porque são reservadas para funções de contexto padrão ANSI:

• CURRENT_DATE

• CURRENT_ROLE

• CURRENT_TIME

• CURRENT_TIMESTAMP

• CURRENT_USER

Para a lista de palavras-chave reservadas, consulte Palavras-chave reservadas e limitadas.

col_type

Especifica o tipo de dados para a coluna.

Para obter mais detalhes sobre os tipos de dados que podem ser especificados para colunas de tabela, consulte Tipos de dados.

query

Necessário se estiver usando USING TEMPLATE

Subconsulta que chama a função INFER_SCHEMA e formata a saída como uma matriz.

Alternativamente, USING TEMPLATE aceita a saída INFER_SCHEMA como uma cadeia de caracteres literal ou variável.

Parâmetros opcionais¶

TEMP[ORARY] | LOCAL TEMP[ORARY] | GLOBAL TEMP[ORARY] | VOLATILE

Especifica que a tabela é temporária. Uma tabela temporária existe apenas pela duração da sessão do usuário na qual foi criada e não é visível para os outros usuários. Uma tabela temporária e todo o seu conteúdo são descartados no final da sessão.

Os sinônimos e abreviações para TEMPORARY (por exemplo, GLOBAL TEMPORARY) são fornecidos para compatibilidade com outros bancos de dados (por exemplo, para evitar erros ao migrar instruções CREATE TABLE). As tabelas criadas com qualquer uma destas palavras-chave aparecem e se comportam de forma idêntica às tabelas criadas usando TEMPORARY.

Padrão: sem valor. Se uma tabela não for declarada como TRANSIENT ou TEMPORARY, a tabela é permanente.

Nota

As tabelas temporárias têm algumas considerações de uso adicionais com relação a conflitos de nomes que podem ocorrer com outras tabelas que têm o mesmo nome no mesmo esquema.

Além disso, as tabelas temporárias têm algumas considerações de armazenamento.

Para obter mais informações sobre estas e outras considerações ao decidir sobre a criação de tabelas temporárias ou transitórias, consulte Como trabalhar com tabelas temporárias e transitórias e Custos de armazenamento para Time Travel e Fail-safe.

TRANSIENT

Especifica que a tabela é transitória.

Assim como uma tabela permanente, uma tabela transitória existe até ser descartada explicitamente e fica visível para qualquer usuário com os privilégios correspondentes. No entanto, as tabelas transitórias têm um nível de proteção de dados inferior às tabelas permanentes, o que significa que os dados em uma tabela transitória podem ser perdidos no caso de uma falha do sistema. Como tal, tabelas transitórias devem ser usadas somente para dados que possam ser recriados fora do Snowflake.

Padrão: sem valor. Se uma tabela não for declarada como TRANSIENT ou TEMPORARY, a tabela é permanente.

Nota

As tabelas transitórias têm algumas considerações de armazenamento.

Para obter mais informações sobre estas e outras considerações ao decidir sobre a criação de tabelas temporárias ou transitórias, consulte Como trabalhar com tabelas temporárias e transitórias e Custos de armazenamento para Time Travel e Fail-safe.

COLLATE 'collation_specification'

Especifica o agrupamento a ser usado para operações de coluna, tais como comparação de cadeias de caracteres. Esta opção aplica-se somente às colunas de texto (VARCHAR, STRING, TEXT etc.). Para obter mais detalhes, consulte Especificações de agrupamento.

COMMENT 'string_literal'

Especifica um comentário para a coluna.

(Observe que os comentários podem ser especificados no nível da coluna ou da tabela. A sintaxe de cada um é um pouco diferente).

DEFAULT ... ou . AUTOINCREMENT ...

Especifica se um valor padrão é automaticamente inserido na coluna caso um valor não seja explicitamente especificado por uma instrução INSERT ou CREATE TABLE AS SELECT:

DEFAULT expr

O valor padrão da coluna é definido pela expressão especificada que pode ser qualquer uma das opções seguintes:

• Valor constante.

• Referência de sequência (seq_name.NEXTVAL).

• Expressão simples que retorna um valor escalar.

  A expressão simples pode incluir uma UDF (função definida pelo usuário) SQL se a UDF não for uma UDF segura.

  Nota

  Se uma expressão padrão se referir a uma UDF SQL, então a função será substituída por sua definição no momento da criação da tabela. Se a função definida pelo usuário for redefinida no futuro, isso não atualizará a expressão padrão da coluna.

  A expressão simples não pode conter referências a:

  • Subconsultas.

  • Agregados.

  • Funções de janela.

  • UDFs seguras.

  • UDFs escritas em outras linguagens além de SQL (por exemplo, Java, JavaScript).

  • Funções externas.

{ AUTOINCREMENT | IDENTITY } [ { ( start_num , step_num ) | START num INCREMENT num } ]

AUTOINCREMENT e IDENTITY são sinônimos. Quando um ou outro é usado, o valor padrão para a coluna começa com um número especificado e cada valor sucessivo é incrementado automaticamente pelo valor especificado.

Cuidado

O Snowflake usa uma sequência para gerar os valores de uma coluna de incremento automático. As sequências têm limitações; consulte Semântica da sequência.

O valor padrão para o início e o passo/incremento é 1.

AUTOINCREMENT e IDENTITY podem ser usados somente para colunas com tipos de dados numéricos.

Padrão: sem valor (a coluna não tem valor padrão)

Nota

DEFAULT e AUTOINCREMENT são mutuamente exclusivos; apenas um deles pode ser especificado para uma coluna.

MASKING POLICY = policy_name

Especifica a política de mascaramento a ser definida em uma coluna.

USING ( col_name , cond_col_1 ... )

Especifica os argumentos para passar para a expressão SQL da política de mascaramento condicional.

A primeira coluna da lista especifica a coluna das condições da política para mascarar ou tokenizar os dados e deve corresponder à coluna para a qual a política de mascaramento é definida.

As colunas adicionais especificam as colunas a serem avaliadas para determinar se os dados em cada linha do resultado da consulta devem ser mascarados ou tokenizados quando uma consulta é feita na primeira coluna.

Se a cláusula USING for omitida, o Snowflake tratará a política de mascaramento condicional como uma política de mascaramento normal.

CONSTRAINT ...

Define uma restrição em linha ou fora de linha para a(s) coluna(s) especificada(s) na tabela.

Para detalhes de sintaxe, consulte CREATE | ALTER TABLE … CONSTRAINT. Para obter mais informações sobre restrições, consulte Restrições.

CLUSTER BY ( expr [ , expr , ... ] )

Especifica uma ou mais colunas ou expressões de colunas na tabela como a chave de clustering. Para obter mais detalhes, consulte Chaves de clustering e tabelas clusterizadas.

Padrão: sem valor (nenhuma chave de clustering está definida para a tabela)

Importante

As chaves de clustering não são destinadas ou recomendadas para todas as tabelas; elas normalmente são vantajosas para tabelas muito grandes (ou seja, com vários terabytes).

Antes de especificar uma chave de clustering para uma tabela, leia Explicação das estruturas de tabela do Snowflake.

STAGE_FILE_FORMAT = ( FORMAT_NAME = 'file_format_name' ) ou . STAGE_FILE_FORMAT = ( TYPE = CSV | JSON | AVRO | ORC | PARQUET | XML [ ... ] )

Especifica o formato padrão do arquivo da tabela (para carregamento e descarregamento de dados), que pode ser:

FORMAT_NAME = file_format_name

Especifica um formato de arquivo nomeado existente a ser usado para carregar/descarregar dados na tabela. O formato de arquivo nomeado determina o tipo de formato (CSV, JSON etc.), bem como quaisquer outras opções de formato, para arquivos de dados. Para obter mais detalhes, consulte CREATE FILE FORMAT.

TYPE = CSV | JSON | AVRO | ORC | PARQUET | XML [ ... ]

Especifica o tipo de arquivos a serem carregados/descarregados na tabela.

Se um tipo de formato de arquivo for especificado, opções adicionais específicas de formato podem ser determinadas. Para obter mais detalhes, consulte Opções do tipo de formato (neste tópico).

Padrão: TYPE = CSV

Nota

FORMAT_NAME e TYPE são mutuamente exclusivos; para evitar comportamentos involuntários, deve-se especificar apenas um ou outro ao criar uma tabela.

STAGE_COPY_OPTIONS = ( ... )

Especifica uma (ou mais) opções a serem usadas ao carregar dados na tabela. Para obter mais detalhes, consulte Opções de cópia (neste tópico).

DATA_RETENTION_TIME_IN_DAYS = integer

Especifica o período de retenção da tabela para que as ações do Time Travel (SELECT, CLONE, UNDROP) possam ser executadas nos dados históricos na tabela. Para obter mais detalhes, consulte Compreensão e uso do Time Travel e Como trabalhar com tabelas temporárias e transitórias.

Para uma descrição detalhada deste parâmetro de nível de objeto, bem como mais informações sobre parâmetros de objeto, consulte Parâmetros.

Valores:

• Standard Edition: 0 ou 1

• Enterprise Edition:

  • 0 a 90 para tabelas permanentes

  • 0 ou 1 para tabelas temporárias e transitórias

Padrão:

• Standard Edition: 1

• Enterprise Edition (ou superior): 1 (a menos que um valor padrão diferente tenha sido especificado no esquema, banco de dados ou nível de conta)

Nota

Um valor de 0 desabilita efetivamente o Time Travel para a tabela.

MAX_DATA_EXTENSION_TIME_IN_DAYS = integer

Parâmetro de objeto que especifica o número máximo de dias para os quais o Snowflake pode estender o período de retenção de dados da tabela para evitar que os fluxos na tabela se tornem obsoletos.

Para uma descrição detalhada deste parâmetro, consulte MAX_DATA_EXTENSION_TIME_IN_DAYS.

CHANGE_TRACKING = TRUE | FALSE

Especifica se deve permitir o rastreamento de alterações na tabela.

• TRUE habilita o rastreamento de alterações na tabela. Esta configuração adiciona um par de colunas ocultas à tabela de origem e começa a armazenar os metadados de rastreamento de alterações nas colunas. Estas colunas consomem uma pequena quantidade de armazenamento.

  Os metadados de rastreamento de alterações podem ser consultados usando a cláusula CHANGES para instruções SELECT ou criando e consultando um ou mais fluxos na tabela.

• FALSE não permite o rastreamento de alterações na tabela.

Padrão: FALSE

DEFAULT_DDL_COLLATION = 'collation_specification'

Determina uma especificação de agrupamento padrão para as colunas da tabela, incluindo colunas adicionadas à tabela no futuro.

Para obter mais detalhes sobre o parâmetro, consulte DEFAULT_DDL_COLLATION.

COPY GRANTS

Especifica manter os privilégios de acesso da tabela original quando uma nova tabela é criada usando qualquer uma das seguintes variantes CREATE TABLE:

• CREATE OR REPLACE TABLE

• CREATE TABLE … LIKE

• CREATE TABLE … CLONE

O parâmetro copia todos os privilégios, exceto OWNERSHIP, da tabela existente para a nova tabela. A nova tabela não herda as concessões futuras definidas para o tipo de objeto no esquema. Por padrão, a função que executa a instrução CREATE TABLE é a proprietária da nova tabela.

Se o parâmetro não estiver incluído na instrução CREATE TABLE, então a nova tabela não herda qualquer privilégio de acesso explícito concedido na tabela original, mas herda qualquer concessão futura definida para o tipo de objeto no esquema.

Nota:

• Se a instrução CREATE TABLE fizer referência a mais de uma tabela (por exemplo, create or replace table TABLE1 clone TABLE2;), a cláusula COPY GRANTS copia as concessões da tabela que está sendo substituída (por exemplo, TABLE1 neste exemplo).

• Com compartilhamento de dados:

  • Se a tabela existente foi compartilhada com outra conta, a tabela de substituição também será compartilhada.

  • Se a tabela existente foi compartilhada com sua conta como consumidor de dados, e o acesso foi ainda concedido a outras funções na conta (usando GRANT IMPORTED PRIVILEGES no banco de dados pai), o acesso também é concedido à tabela de substituição.

• A saída SHOW GRANTS para a tabela de substituição relaciona o cessionário para os privilégios copiados como a função que executou a instruçãoCREATE TABLE, com o carimbo de data/hora atual quando a instrução foi executada.

• A operação de cópia de concessões ocorre atomicamente no comando CREATE TABLE (ou seja, dentro da mesma transação).

ROW ACCESS POLICY policy_name ON ( col_name [ , col_name ... ] )

Especifica a política de acesso a linhas a ser definida em uma tabela.

TAG tag_name = 'tag_value' [ , tag_name = 'tag_value' , ... ]

Especifica o nome da tag e o valor da cadeia de caracteres dela.

O valor de tag é sempre uma cadeia de caracteres, e o número máximo de caracteres do valor da tag é 256.

Para obter detalhes sobre como especificar tags em uma instrução, consulte Cotas de tags para objetos e colunas.

COMMENT = 'string_literal'

Especifica um comentário para a tabela.

Padrão: sem valor

(Observe que os comentários podem ser especificados no nível da coluna ou da tabela. A sintaxe de cada um é um pouco diferente).

Opções de tipo de formato (formatTypeOptions)¶

As opções de tipo de formato são usadas para carregar dados e descarregar dados das tabelas.

Dependendo do tipo de formato de arquivo especificado (STAGE_FILE_FORMAT = ( TYPE = ... )), você pode incluir uma ou mais das seguintes opções de formato específicas (separadas por espaços em branco, vírgulas ou novas linhas):

Opções de cópia (copyOptions)¶

As opções de cópia são usadas para carregar dados para e descarregar dados de tabelas.

Você pode especificar uma ou mais das seguintes opções de cópia (separadas por espaços em branco, vírgulas ou novas linhas):

STAGE_COPY_OPTIONS = ( ... )

ON_ERROR = CONTINUE | SKIP_FILE | SKIP_FILE_num | 'SKIP_FILE_num%' | ABORT_STATEMENT

Uso

Somente carregamento de dados

Definição

Cadeia de caracteres (constante) que especifica o tratamento do erro para a operação de carga.

Importante

Considere cuidadosamente o valor da opção de cópia ON_ERROR. O valor padrão é adequado em cenários comuns, mas nem sempre é a melhor opção.

Valores

Valores suportados	Notas
CONTINUE	Continuar a carregar o arquivo se forem encontrados erros. A instrução COPY retorna uma mensagem de erro para um máximo de um erro encontrado por arquivo de dados. Observe que a diferença entre os valores das colunas ROWS_PARSED e ROWS_LOADED representa o número de linhas que incluem os erros detectados. No entanto, cada uma dessas linhas poderia incluir vários erros. Para visualizar todos os erros nos arquivos de dados, use o parâmetro VALIDATION_MODE ou consulte a função VALIDATE.
SKIP_FILE	Ignorar um arquivo quando for encontrado um erro. Observe que a ação SKIP_FILE armazena em buffer o arquivo inteiro, quer sejam ou não encontrados erros. Por este motivo, SKIP_FILE é mais lento que CONTINUE ou ABORT_STATEMENT. Ignorar arquivos grandes devido a um pequeno número de erros pode resultar em atrasos e desperdício de créditos. Ao carregar um grande número de registros de arquivos que não têm delimitação lógica (por exemplo, os arquivos foram gerados automaticamente em intervalos aproximados), considere especificar CONTINUE em vez disso. Padrões adicionais: SKIP_FILE_num (por exemplo, SKIP_FILE_10) Ignorar um arquivo quando o número de linhas de erro encontrado no arquivo for igual ou maior que o número especificado. 'SKIP_FILE_num%' (por exemplo, 'SKIP_FILE_10%') Pular um arquivo quando a porcentagem de linhas de erro encontradas no arquivo exceder a porcentagem especificada.
ABORT_STATEMENT	Abortar a operação de carregamento se algum erro for encontrado em um arquivo de dados. Observe que a operação de carregamento não é abortada se o arquivo de dados não puder ser encontrado (por exemplo, porque ele não existe ou não pode ser acessado), exceto quando arquivos de dados explicitamente especificados no parâmetro FILES não puderem ser encontrados.

• Os seguintes comportamentos se aplicam a esta opção de cópia:

  • Todos os valores ON_ERROR funcionam como esperado ao carregar arquivos de dados estruturados (CSV, TSV etc.) com erros de análise ou de transformação.

    No entanto, os arquivos de dados semiestruturados (JSON, Avro, ORC, Parquet ou XML) não oferecem suporte à mesma semântica de comportamento que os arquivos de dados estruturados para os seguintes valores ON_ERROR: CONTINUE, SKIP_FILE_num ou 'SKIP_FILE_num%' devido ao projeto desses tipos de formato.

  • Somente dados Parquet e ORC. Quando ON_ERROR está definido como CONTINUE, SKIP_FILE_num ou 'SKIP_FILE_num%', qualquer erro de análise faz com que o arquivo de dados seja ignorado. Qualquer erro de conversão ou transformação segue o comportamento padrão de ABORT_STATEMENT (instruções COPY INTO <tabela>) ou SKIP_FILE (Snowpipe), independentemente do valor da opção selecionada.

  • Somente dados JSON, XML e Avro. Quando ON_ERROR está definido como CONTINUE, SKIP_FILE_num ou 'SKIP_FILE_num%', todos os registros até o registro que contém o erro de análise são carregados, mas o restante dos registros no arquivo de dados são ignorados. Qualquer erro de conversão ou transformação segue o comportamento padrão de COPY (ABORT_STATEMENT) ou Snowpipe (SKIP_FILE), independentemente do valor da opção selecionada.

Padrão

Carregamento em massa utilizando COPY

ABORT_STATEMENT

Snowpipe

SKIP_FILE

SIZE_LIMIT = num

Uso

Somente carregamento de dados

Definição

Número (> 0) que especifica o tamanho máximo (em bytes) dos dados a serem carregados para uma determinada instrução COPY. Quando o limite é excedido, a operação COPY interrompe o carregamento dos arquivos. Esta opção é comumente usada para carregar um grupo comum de arquivos usando múltiplas instruções COPY. Para cada instrução, o carregamento de dados continua até que o SIZE_LIMIT especificado seja excedido, antes de passar para a instrução seguinte.

Por exemplo, suponha que um conjunto de arquivos em um caminho do estágio tivesse um tamanho de 10 MB cada. Se múltiplas instruções COPY definissem SIZE_LIMIT como 25000000 (25 MB), cada uma carregaria 3 arquivos. Ou seja, cada operação COPY seria interrompida após o limite SIZE_LIMIT ter sido excedido.

Observe que pelo menos um arquivo é carregado independentemente do valor especificado para SIZE_LIMIT, a menos que não haja nenhum arquivo a ser carregado.

Padrão

nulo (sem limite de tamanho)

PURGE = TRUE | FALSE

Uso

Somente carregamento de dados

Definição

Booleano que especifica se os arquivos de dados devem ser removidos automaticamente do estágio depois que os dados forem carregados com sucesso.

Se esta opção for definida como TRUE, observe que é feito o melhor possível para remover arquivos de dados carregados com sucesso. Se a operação de limpeza falhar por qualquer motivo, nenhum erro é devolvido no momento. Recomendamos que você liste arquivos preparados periodicamente (usando LIST) e remova manualmente os arquivos carregados com sucesso, se houver algum.

Padrão

FALSE

RETURN_FAILED_ONLY = TRUE | FALSE

Uso

Somente carregamento de dados

Definição

Booleano que especifica se devem ser devolvidos apenas os arquivos que não tenham sido carregados no resultado da instrução.

Padrão

FALSE

MATCH_BY_COLUMN_NAME = CASE_SENSITIVE | CASE_INSENSITIVE | NONE

Uso

Somente carregamento de dados

Definição

Cadeia de caracteres que especifica se dados semiestruturados devem ser carregados em colunas na tabela de destino que correspondem às colunas representadas nos dados.

Esta opção de cópia é suportada para os seguintes formatos de dados:

• JSON

• Avro

• ORC

• Parquet

Para que uma coluna seja correspondente, os seguintes critérios devem ser verdadeiros:

• A coluna representada nos dados deve ter exatamente o mesmo nome que a coluna da tabela. A opção de cópia oferece suporte à diferenciação de letras maiúsculas e minúsculas em nomes de colunas. A ordem das colunas não importa.

• A coluna na tabela deve ter um tipo de dados compatível com os valores na coluna representada nos dados. Por exemplo, os valores da cadeia de caracteres, número e booleano podem ser todos carregados em uma coluna variante.

Valores

CASE_SENSITIVE | CASE_INSENSITIVE

Carregar dados semiestruturados em colunas da tabela de destino que correspondam às colunas representadas nos dados. Os nomes das colunas distinguem letras maiúsculas de minúsculas (CASE_SENSITIVE) ou não (CASE_INSENSITIVE).

A operação COPY verifica se pelo menos uma coluna na tabela de destino corresponde a uma coluna representada nos arquivos de dados. Se for encontrada uma correspondência, os valores nos arquivos de dados são carregados na coluna ou colunas. Se nenhuma correspondência for encontrada, um conjunto de valores NULL para cada registro nos arquivos é carregado na tabela.

Nota

• Se colunas adicionais não correspondentes estiverem presentes nos arquivos de dados, os valores nestas colunas não serão carregados.

• Se colunas adicionais não correspondentes estiverem presentes na tabela de destino, a operação COPY insere valores NULL nestas colunas. Estas colunas devem oferecer suporte a valores NULL.

• A instrução COPY não permite especificar uma consulta para transformar ainda mais os dados durante a carga (ou seja, transformação de COPY).

NONE

A operação COPY carrega os dados semiestruturados em uma coluna variante ou, se uma consulta for incluída na instrução COPY, transforma os dados.

Nota

As seguintes limitações se aplicam atualmente:

• MATCH_BY_COLUMN_NAME não pode ser usado com o parâmetro VALIDATION_MODE em uma instrução COPY para validar os dados preparados em vez de carregá-los na tabela de destino.

• Somente dados Parquet. Quando MATCH_BY_COLUMN_NAME está definido como CASE_SENSITIVE ou CASE_INSENSITIVE, um valor de coluna vazio (por exemplo, "col1": "") produz um erro.

Padrão

NONE

ENFORCE_LENGTH = TRUE | FALSE

Uso

Somente carregamento de dados

Definição

Sintaxe alternativa para TRUNCATECOLUMNS com lógica reversa (para compatibilidade com outros sistemas)

Booleano que especifica se deve truncar cadeias de caracteres de texto que excedam o comprimento da coluna de destino:

• Se TRUE, a instrução COPY produz um erro se uma cadeia de caracteres carregada exceder o comprimento da coluna alvo.

• Se FALSE, as cadeias de caracteres são automaticamente truncadas para o comprimento da coluna de destino.

Esta opção de cópia oferece suporte a dados CSV, bem como valores de cadeia de caracteres em dados semiestruturados quando carregados em colunas separadas em tabelas relacionais.

Nota

• Se o comprimento da coluna da cadeia de caracteres de destino for definido como o máximo (por exemplo, VARCHAR (16777216)), uma cadeia de caracteres de entrada não pode exceder este comprimento; caso contrário, o comando COPY produz um erro.

• Este parâmetro é funcionalmente equivalente a TRUNCATECOLUMNS, mas tem o comportamento oposto. É fornecido para compatibilidade com outros bancos de dados. É necessário apenas incluir um destes dois parâmetros em uma instrução COPY para produzir a saída desejada.

Padrão

TRUE

TRUNCATECOLUMNS = TRUE | FALSE

Uso

Somente carregamento de dados

Definição

Sintaxe alternativa para ENFORCE_LENGTH com lógica reversa (para compatibilidade com outros sistemas)

Booleano que especifica se deve truncar cadeias de caracteres de texto que excedam o comprimento da coluna de destino:

• Se TRUE, as cadeias de caracteres são automaticamente truncadas para o comprimento da coluna de destino.

• Se FALSE, a instrução COPY produz um erro se uma cadeia de caracteres carregada exceder o comprimento da coluna alvo.

Esta opção de cópia oferece suporte a dados CSV, bem como valores de cadeia de caracteres em dados semiestruturados quando carregados em colunas separadas em tabelas relacionais.

Nota

• Se o comprimento da coluna da cadeia de caracteres de destino for definido como o máximo (por exemplo, VARCHAR (16777216)), uma cadeia de caracteres de entrada não pode exceder este comprimento; caso contrário, o comando COPY produz um erro.

• Este parâmetro é funcionalmente equivalente a ENFORCE_LENGTH, mas tem o comportamento oposto. É fornecido para compatibilidade com outros bancos de dados. É necessário apenas incluir um destes dois parâmetros em uma instrução COPY para produzir a saída desejada.

Padrão

FALSE

FORCE = TRUE | FALSE

Uso

Somente carregamento de dados

Definição

Booleano que especifica o carregamento de todos os arquivos, independentemente de terem sido carregados anteriormente e não terem mudado desde que foram carregados. Note que esta opção recarrega os arquivos, potencialmente duplicando dados em uma tabela.

Padrão

FALSE

Requisitos de controle de acesso¶

Uma função usada para executar este comando SQL deve ter os seguintes privilégios no mínimo:

Observe que operar em qualquer objeto de um esquema também requer o privilégio USAGE no banco de dados e esquema principais.

Para instruções sobre como criar uma função personalizada com um conjunto específico de privilégios, consulte Criação de funções personalizadas.

Para informações gerais sobre concessões de funções e privilégios para executar ações de SQL em objetos protegíveis, consulte Controle de acesso no Snowflake.

Notas de uso¶

• Um esquema não pode conter tabelas e/ou visualizações com o mesmo nome. Ao criar uma tabela:

  • Se já existir uma visualização com o mesmo nome no esquema, um erro é emitido e a tabela não é criada.

  • Se uma tabela com o mesmo nome já existir no esquema, um erro é emitido e a tabela não é criada, a menos que a palavra-chave opcional OR REPLACE esteja incluída no comando.

  Importante

  Usar OR REPLACE é o equivalente a usar DROP TABLE na tabela existente e depois criar uma nova tabela com o mesmo nome; no entanto, a tabela descartada não é permanentemente removida do sistema. Em vez disso, ela fica retida no Time Travel. Isto é importante notar porque as tabelas descartadas no Time Travel podem ser recuperadas, mas elas também contribuem para o armazenamento de dados de sua conta. Para obter mais informações, consulte Custos de armazenamento para Time Travel e Fail-safe.

  Instruções CREATE OR REPLACE <object> são atômicas. Ou seja, quando o objeto é substituído, a exclusão do objeto antigo e a criação do novo objeto são processadas em uma única transação.

  Isso significa que qualquer consulta concorrente com a operação CREATE OR REPLACE TABLE utiliza a versão da tabela antiga ou nova.

  A recriação ou troca de uma tabela descarta seus dados de alteração. Qualquer fluxo na tabela se torna obsoleto. Além disso, qualquer fluxo em uma visualização que tenha esta tabela como uma tabela subjacente, torna-se obsoleto. Um fluxo obsoleto é ilegível.

• Assim como as palavras-chave reservadas, nomes de funções reservadas ANSI (CURRENT_DATE, CURRENT_TIMESTAMP etc.) não podem ser usados como nomes de colunas.

• CREATE TABLE … CLONE:

  • Se a tabela de origem tiver chaves de clustering, então a nova tabela terá chaves de clustering. Por padrão, o Clustering automático é suspenso para a nova tabela – mesmo que o Clustering automático não tenha sido suspenso para a tabela de origem.

• CREATE TABLE … LIKE:

  • Se a tabela de origem tiver chaves de clustering, então a nova tabela terá chaves de clustering. Por padrão, o Clustering automático não é suspenso para a nova tabela – mesmo que o Clustering automático tenha sido suspenso para a tabela de origem.

• CREATE TABLE … AS SELECT (CTAS):

  • Se os aliases para os nomes das colunas na lista SELECT forem colunas válidas, então as definições das colunas não são exigidas na instrução CTAS; se omitidos, os nomes e tipos das colunas são inferidos a partir da consulta subjacente:

    CREATE TABLE <table_name> AS SELECT ...
    

    Alternativamente, os nomes podem ser explicitamente especificados usando a seguinte sintaxe:

    CREATE TABLE <table_name> ( <col1_name> , <col2_name> , ... ) AS SELECT ...
    

    O número de nomes de colunas especificados deve corresponder ao número de itens da lista SELECT na consulta; os tipos das colunas são inferidos a partir dos tipos produzidos pela consulta.

  • Quando as chaves de clustering são especificadas em uma instrução CTAS:

    • As definições das colunas são necessárias e devem ser explicitamente especificadas na instrução.

    • Por padrão, o Clustering automático não é suspenso para a nova tabela – mesmo que o Clustering automático seja suspenso para a tabela de origem.

  • Se você quiser que a tabela seja criada com linhas em uma ordem específica, então use uma subcláusula ORDER BY na cláusula SELECT do CTAS. Especificar CLUSTER BY não agrupa os dados no momento em que a tabela é criada; em vez disso, CLUSTER BY depende do clustering automático para reter os dados ao longo do tempo.

    A subcláusula ORDER BY em uma instrução CREATE TABLE não afeta a ordem das linhas devolvidas por futuras instruções SELECT naquela tabela. Para especificar a ordem das linhas nas futuras instruções SELECT, use uma subcláusula ORDER BY nessas instruções.

• Dentro de uma transação, qualquer instrução DDL (incluindo CREATE TEMPORARY/TRANSIENT TABLE) executa a transação antes de executar a própria instrução DDL. A instrução DDL é então executada em sua própria transação. A próxima instrução após a instrução DDL inicia uma nova transação. Portanto, você não pode criar, usar e descartar uma tabela temporária ou transitória dentro de uma única transação. Se você quiser usar uma tabela temporária ou transitória dentro de uma transação, então crie a tabela antes da transação, e descarte a tabela após a transação.

• Recriar uma tabela (usando a palavra-chave opcional OR REPLACE) diminui seu histórico, o que torna qualquer fluxo na tabela obsoleto. Um fluxo obsoleto é ilegível.

• Uma única política de mascaramento que utilize colunas condicionais pode ser aplicada a várias tabelas, desde que a estrutura de colunas da tabela corresponda às colunas especificadas na política.

• Ao criar uma tabela com uma política de mascaramento em uma ou mais colunas da tabela, ou uma política de acesso a linhas adicionada à tabela, use a função POLICY_CONTEXT para simular uma consulta na(s) coluna(s) protegida(s) por uma política de mascaramento e a tabela protegida por uma política de acesso a linhas.

• Em relação aos metadados:

  Atenção

  Os clientes devem garantir que nenhum dado pessoal (exceto para um objeto do usuário), dados sensíveis, dados controlados por exportação ou outros dados regulamentados sejam inseridos como metadados ao usar o serviço Snowflake. Para obter mais informações, consulte Campos de metadados no Snowflake.

Exemplos¶

Criar uma tabela simples no banco de dados atual e inserir uma linha na tabela:

CREATE TABLE mytable (amount NUMBER);

+-------------------------------------+
| status                              |
|-------------------------------------|
| Table MYTABLE successfully created. |
+-------------------------------------+

INSERT INTO mytable VALUES(1);

SHOW TABLES like 'mytable';

+---------------------------------+---------+---------------+-------------+-------+---------+------------+------+-------+--------------+----------------+
| created_on                      | name    | database_name | schema_name | kind  | comment | cluster_by | rows | bytes | owner        | retention_time |
|---------------------------------+---------+---------------+-------------+-------+---------+------------+------+-------+--------------+----------------|
| Mon, 11 Sep 2017 16:32:28 -0700 | MYTABLE | TESTDB        | PUBLIC      | TABLE |         |            |    1 |  1024 | ACCOUNTADMIN | 1              |
+---------------------------------+---------+---------------+-------------+-------+---------+------------+------+-------+--------------+----------------+

DESC TABLE mytable;

+--------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+
| name   | type         | kind   | null? | default | primary key | unique key | check | expression | comment |
|--------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------|
| AMOUNT | NUMBER(38,0) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
+--------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+

Criar uma tabela simples e especificar comentários tanto para a tabela quanto para a coluna na tabela:

CREATE TABLE example (col1 number comment 'a column comment') COMMENT='a table comment';

+-------------------------------------+
| status                              |
|-------------------------------------|
| Table EXAMPLE successfully created. |
+-------------------------------------+

SHOW TABLES like 'example';

+---------------------------------+---------+---------------+-------------+-------+-----------------+------------+------+-------+--------------+----------------+
| created_on                      | name    | database_name | schema_name | kind  | comment         | cluster_by | rows | bytes | owner        | retention_time |
|---------------------------------+---------+---------------+-------------+-------+-----------------+------------+------+-------+--------------+----------------|
| Mon, 11 Sep 2017 16:35:59 -0700 | EXAMPLE | TESTDB        | PUBLIC      | TABLE | a table comment |            |    0 |     0 | ACCOUNTADMIN | 1              |
+---------------------------------+---------+---------------+-------------+-------+-----------------+------------+------+-------+--------------+----------------+

DESC TABLE example;

+------+--------------+--------+-------+---------+-------------+------------+-------+------------+------------------+
| name | type         | kind   | null? | default | primary key | unique key | check | expression | comment          |
|------+--------------+--------+-------+---------+-------------+------------+-------+------------+------------------|
| COL1 | NUMBER(38,0) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | a column comment |
+------+--------------+--------+-------+---------+-------------+------------+-------+------------+------------------+

Criar uma tabela selecionando de uma tabela existente:

CREATE TABLE mytable_copy (b) AS SELECT * from mytable;

DESC TABLE mytable_copy;

+------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+
| name | type         | kind   | null? | default | primary key | unique key | check | expression | comment |
|------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------|
| B    | NUMBER(38,0) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
+------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+

CREATE TABLE mytable_copy2 AS SELECT b+1 AS c FROM mytable_copy;

DESC TABLE mytable_copy2;

+------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+
| name | type         | kind   | null? | default | primary key | unique key | check | expression | comment |
|------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------|
| C    | NUMBER(39,0) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
+------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+

SELECT * FROM mytable_copy2;

+---+
| C |
|---|
| 2 |
+---+

Exemplo mais avançado de criação de uma tabela selecionando de uma tabela existente; neste exemplo, os valores na coluna summary_amount da nova tabela são derivados de duas colunas na tabela de origem:

CREATE TABLE testtable_summary (name, summary_amount) AS SELECT name, amount1 + amount2 FROM testtable;

Criar uma tabela selecionando colunas de um arquivo de dados preparado do Parquet:

CREATE OR REPLACE TABLE parquet_col (
  custKey number default NULL,
  orderDate date default NULL,
  orderStatus varchar(100) default NULL,
  price varchar(255)
)
AS SELECT
  $1:o_custkey::number,
  $1:o_orderdate::date,
  $1:o_orderstatus::text,
  $1:o_totalprice::text
FROM @my_stage;

+-----------------------------------------+
| status                                  |
|-----------------------------------------|
| Table PARQUET_COL successfully created. |
+-----------------------------------------+

DESC TABLE parquet_col;

+-------------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+
| name        | type         | kind   | null? | default | primary key | unique key | check | expression | comment |
|-------------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------|
| CUSTKEY     | NUMBER(38,0) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| ORDERDATE   | DATE         | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| ORDERSTATUS | VARCHAR(100) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
| PRICE       | VARCHAR(255) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
+-------------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+

Criar uma tabela com as mesmas definições de coluna que outra tabela, mas sem linhas:

CREATE TABLE mytable (amount NUMBER);

INSERT INTO mytable VALUES(1);

SELECT * FROM mytable;

+--------+
| AMOUNT |
|--------|
|      1 |
+--------+

CREATE TABLE mytable_2 LIKE mytable;

DESC TABLE mytable_2;

+--------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+
| name   | type         | kind   | null? | default | primary key | unique key | check | expression | comment |
|--------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------|
| AMOUNT | NUMBER(38,0) | COLUMN | Y     | NULL    | N           | N          | NULL  | NULL       | NULL    |
+--------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+

SELECT * FROM mytable_2;

+--------+
| AMOUNT |
|--------|
+--------+

Criar uma tabela com uma chave de clustering de várias colunas:

CREATE TABLE mytable (date timestamp_ntz, id number, content variant) CLUSTER BY (date, id);

SHOW TABLES LIKE 'mytable';

+---------------------------------+---------+---------------+-------------+-------+---------+------------------+------+-------+--------------+----------------+
| created_on                      | name    | database_name | schema_name | kind  | comment | cluster_by       | rows | bytes | owner        | retention_time |
|---------------------------------+---------+---------------+-------------+-------+---------+------------------+------+-------+--------------+----------------|
| Mon, 11 Sep 2017 16:20:41 -0700 | MYTABLE | TESTDB        | PUBLIC      | TABLE |         | LINEAR(DATE, ID) |    0 |     0 | ACCOUNTADMIN | 1              |
+---------------------------------+---------+---------------+-------------+-------+---------+------------------+------+-------+--------------+----------------+

Especificar o agrupamento para colunas em uma tabela:

CREATE TABLE collation_demo (
  uncollated_phrase VARCHAR, 
  utf8_phrase VARCHAR COLLATE 'utf8',
  english_phrase VARCHAR COLLATE 'en',
  spanish_phrase VARCHAR COLLATE 'sp'
  );

INSERT INTO collation_demo (uncollated_phrase, utf8_phrase, english_phrase, spanish_phrase) 
   VALUES ('pinata', 'pinata', 'pinata', 'piñata');

Criar uma tabela onde as definições das colunas sejam derivadas de um conjunto de arquivos preparados que contenham dados Avro, Parquet ou ORC.

Observe que o estágio mystage e o formato de arquivo my_parquet_format mencionados na instrução já devem existir. Um conjunto de arquivos já deve ser preparado no local de armazenamento em nuvem referenciado na definição do estágio.

O exemplo a seguir cria uma tabela usando o esquema detectado a partir de arquivos preparados e ordena as colunas por ORDER_ID. Isso se baseia em um exemplo no tópico INFER_SCHEMA.

CREATE TABLE mytable
  USING TEMPLATE (
    SELECT ARRAY_AGG(OBJECT_CONSTRUCT(*))
    WITHIN GROUP (ORDER BY ORDER_ID)
      FROM TABLE(
        INFER_SCHEMA(
          LOCATION=>'@mystage',
          FILE_FORMAT=>'my_parquet_format'
        )
      ));

Observe que a ordenação das colunas por ORDER_ID só se aplica se todos os arquivos preparados compartilharem um único esquema. Se o conjunto de arquivos de dados preparados incluir vários esquemas com nomes de colunas compartilhadas, a ordem representada na coluna ORDER_ID pode não corresponder a nenhum arquivo único.

Criar uma tabela temporária que é automaticamente descartada no fim da sessão:

create temporary table demo_temporary (i integer);
create temp      table demo_temp      (i integer);

Para compatibilidade com outros fornecedores, o Snowflake também oferece suporte ao uso das palavras-chave abaixo como sinônimos para TEMPORARY:

create local temporary table demo_local_temporary (i integer);
create local temp      table demo_local_temp      (i integer);

create global temporary table demo_global_temporary (i integer);
create global temp      table demo_global_temp      (i integer);

create volatile table demo_volatile (i integer);