CREATE TABLE

Cria uma nova tabela no esquema atual/especificado, substitui uma tabela existente ou altera uma tabela existente. Uma tabela pode ter várias colunas, com cada definição de coluna consistindo de um nome, tipo de dados e, opcionalmente, se a coluna:

  • Exige um valor (NOT NULL).

  • Tem um valor padrão.

  • Tem qualquer restrição de integridade referencial (chave primária, chave estrangeira etc.).

Além disso, este comando oferece suporte às seguintes variantes:

  • CREATE OR ALTER TABLE (cria uma tabela se ela não existir ou a altera de acordo com a definição da tabela)

  • CREATE TABLE … AS SELECT (cria uma tabela preenchida; também referida como CTAS)

  • CREATE TABLE … USING TEMPLATE (cria uma tabela com as definições das colunas derivadas de um conjunto de arquivos preparados)

  • CREATE TABLE … LIKE (cria uma cópia vazia de uma tabela existente)

  • CREATE TABLE … CLONE (cria um clone de uma tabela existente)

Consulte também:

ALTER TABLE , DROP TABLE , SHOW TABLES , DESCRIBE TABLE

Sintaxe

CREATE [ OR REPLACE ]
    [ { [ { LOCAL | GLOBAL } ] TEMP | TEMPORARY | VOLATILE | TRANSIENT } ]
  TABLE [ IF NOT EXISTS ] <table_name> (
    -- Column definition
    <col_name> <col_type>
      [ inlineConstraint ]
      [ NOT NULL ]
      [ COLLATE '<collation_specification>' ]
      [
        {
          DEFAULT <expr>
          | { AUTOINCREMENT | IDENTITY }
            [
              {
                ( <start_num> , <step_num> )
                | START <num> INCREMENT <num>
              }
            ]
            [ { ORDER | NOORDER } ]
        }
      ]
      [ [ WITH ] MASKING POLICY <policy_name> [ USING ( <col_name> , <cond_col1> , ... ) ] ]
      [ [ WITH ] PROJECTION POLICY <policy_name> ]
      [ [ WITH ] TAG ( <tag_name> = '<tag_value>' [ , <tag_name> = '<tag_value>' , ... ] ) ]
      [ COMMENT '<string_literal>' ]

    -- Additional column definitions
    [ , <col_name> <col_type> [ ... ] ]

    -- Out-of-line constraints
    [ , outoflineConstraint [ ... ] ]
  )
  [ CLUSTER BY ( <expr> [ , <expr> , ... ] ) ]
  [ ENABLE_SCHEMA_EVOLUTION = { TRUE | FALSE } ]
  [ DATA_RETENTION_TIME_IN_DAYS = <integer> ]
  [ MAX_DATA_EXTENSION_TIME_IN_DAYS = <integer> ]
  [ CHANGE_TRACKING = { TRUE | FALSE } ]
  [ DEFAULT_DDL_COLLATION = '<collation_specification>' ]
  [ COPY GRANTS ]
  [ COMMENT = '<string_literal>' ]
  [ [ WITH ] ROW ACCESS POLICY <policy_name> ON ( <col_name> [ , <col_name> ... ] ) ]
  [ [ WITH ] AGGREGATION POLICY <policy_name> [ ENTITY KEY ( <col_name> [ , <col_name> ... ] ) ] ]
  [ [ WITH ] TAG ( <tag_name> = '<tag_value>' [ , <tag_name> = '<tag_value>' , ... ] ) ]
Copy

Onde:

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

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> ]
  [ COMMENT '<string_literal>' ]
Copy

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

Nota

Não especifique as opções de cópia usando os comandos CREATE STAGE, ALTER STAGE, CREATE TABLE ou ALTER TABLE. Recomendamos que você use o comando COPY INTO <tabela> para especificar as opções de cópia.

Sintaxe da variante

CREATE OR ALTER TABLE

Cria uma tabela se ela não existir ou a altera de acordo com a definição da tabela. A sintaxe CREATE OR ALTER TABLE segue as regras de uma instrução CREATE TABLE e tem as mesmas limitações de uma instrução ALTER TABLE. Se a tabela for transformada, os dados existentes na tabela serão preservados sempre que possível. Se uma coluna precisar ser descartada, poderá ocorrer perda de dados.

As seguintes alterações são suportadas ao alterar uma tabela:

  • Alterar propriedades e parâmetros da tabela. Por exemplo, ENABLE_SCHEMA_EVOLUTION, DATA_RETENTION_TIME_IN_DAYS ou CLUSTER BY.

  • Alterar tipo de dados da coluna, valor padrão, nulidade, comentário ou incremento automático.

  • Adicionar novas colunas ao final da lista de colunas.

  • Descartar colunas.

  • Adicionar, remover ou modificar restrições em linha ou fora de linha.

  • Adicionar, remover ou modificar chaves de clustering.

Para obter mais informações, consulte Notas de uso de CREATE OR ALTER TABLE.

CREATE OR ALTER
    [ { [ { LOCAL | GLOBAL } ] TEMP | TEMPORARY | TRANSIENT } ]
  TABLE <table_name> (
    -- Column definition
    <col_name> <col_type>
      [ inlineConstraint ]
      [ NOT NULL ]
      [ COLLATE '<collation_specification>' ]
      [
        {
          DEFAULT <expr>
          | { AUTOINCREMENT | IDENTITY }
            [
              {
                ( <start_num> , <step_num> )
                | START <num> INCREMENT <num>
              }
            ]
            [ { ORDER | NOORDER } ]
        }
      ]
      [ COMMENT '<string_literal>' ]

    -- Additional column definitions
    [ , <col_name> <col_type> [ ... ] ]

    -- Out-of-line constraints
    [ , outoflineConstraint [ ... ] ]
  )
  [ CLUSTER BY ( <expr> [ , <expr> , ... ] ) ]
  [ ENABLE_SCHEMA_EVOLUTION = { TRUE | FALSE } ]
  [ DATA_RETENTION_TIME_IN_DAYS = <integer> ]
  [ MAX_DATA_EXTENSION_TIME_IN_DAYS = <integer> ]
  [ CHANGE_TRACKING = { TRUE | FALSE } ]
  [ DEFAULT_DDL_COLLATION = '<collation_specification>' ]
  [ COMMENT = '<string_literal>' ]
Copy

CREATE TABLE … AS SELECT (também chamado de CTAS)

Cria uma nova tabela preenchida com os dados devolvidos por uma consulta:

CREATE [ OR REPLACE ] TABLE <table_name> [ ( <col_name> [ <col_type> ] , <col_name> [ <col_type> ] , ... ) ]
  [ CLUSTER BY ( <expr> [ , <expr> , ... ] ) ]
  [ COPY GRANTS ]
  AS <query>
  [ ... ]
Copy

Uma política de mascaramento pode ser aplicada a uma coluna em uma instrução CTAS. Especifique a política de mascaramento após o tipo de dados da coluna. Da mesma forma, uma política de acesso a linhas pode ser aplicada à tabela. Por exemplo:

CREATE TABLE <table_name> ( <col1> <data_type> [ WITH ] MASKING POLICY <policy_name> [ , ... ] )
  ...
  [ WITH ] ROW ACCESS POLICY <policy_name> ON ( <col1> [ , ... ] )
  AS <query>
  [ ... ]
Copy

Nota

Em um CTAS, a cláusula COPY GRANTS é válida somente quando combinada com a cláusula OR REPLACE. COPY GRANTS copia as permissões da tabela sendo substituída por CREATE OR REPLACE (se já existir), e não da(s) tabela(s) de origem sendo consultada(s) na instrução SELECT. CTAS com COPY GRANTS permite que você substitua uma tabela por um novo conjunto de dados enquanto mantém as concessões existentes nesta tabela.

Para obter mais detalhes sobre COPY GRANTS, consulte COPY GRANTS neste documento.

CREATE TABLE … USING TEMPLATE

Cria uma nova tabela com as definições das colunas derivadas de um conjunto de arquivos preparados usando a função INFER_SCHEMA. Este recurso oferece suporte aos arquivos Apache Parquet, Apache Avro, ORC, JSON e CSV.

CREATE [ OR REPLACE ] TABLE <table_name>
  [ COPY GRANTS ]
  USING TEMPLATE <query>
  [ ... ]
Copy

Nota

Se a instrução estiver substituindo uma tabela existente com o mesmo nome, então as concessões são copiadas da tabela que está sendo substituída. Se não existir uma tabela com esse nome, então as concessões são copiadas da tabela de origem que está sendo clonada.

Para obter mais detalhes sobre COPY GRANTS, consulte COPY GRANTS neste documento.

CREATE TABLE … LIKE

Cria uma nova tabela com as mesmas definições de coluna que uma tabela existente, mas sem copiar os dados da tabela existente. Os nomes das colunas, tipos, padrões e restrições são copiados para a nova tabela:

CREATE [ OR REPLACE ] TABLE <table_name> LIKE <source_table>
  [ CLUSTER BY ( <expr> [ , <expr> , ... ] ) ]
  [ COPY GRANTS ]
  [ ... ]
Copy

Para obter mais detalhes sobre COPY GRANTS, consulte COPY GRANTS neste documento.

Nota

CREATE TABLE … LIKE para uma tabela com uma sequência de incremento automático acessada por meio de um compartilhamento de dados não é suportada no momento.

CREATE TABLE … CLONE

Cria uma nova tabela com as mesmas definições de coluna e contendo todos os dados existentes da tabela de origem, sem realmente copiar os dados. Esta variante também pode ser usada para clonar uma tabela em um momento/ponto específico no passado (usando Time Travel):

CREATE [ OR REPLACE ]
    [ {
          [ { LOCAL | GLOBAL } ] TEMP [ READ ONLY ] |
          TEMPORARY [ READ ONLY ] |
          VOLATILE |
          TRANSIENT
    } ]
  TABLE <name> CLONE <source_table>
    [ { AT | BEFORE } ( { TIMESTAMP => <timestamp> | OFFSET => <time_difference> | STATEMENT => <id> } ) ]
    [ COPY GRANTS ]
    [ ... ]
Copy

Nota

Se a instrução estiver substituindo uma tabela existente com o mesmo nome, então as concessões são copiadas da tabela que está sendo substituída. Se não existir uma tabela com esse nome, então as concessões são copiadas da tabela de origem que está sendo clonada.

Para obter mais detalhes sobre COPY GRANTS, consulte COPY GRANTS neste documento.

Para obter mais detalhes sobre clonagem, consulte CREATE <objeto> … CLONE.

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 Referência dos tipos de dados SQL.

query

Necessário para CTAS e USING TEMPLATE.

  • Para CTAS, especifica a instrução SELECT que preenche a tabela.

  • Para CREATE TABLE … USING TEMPLATE, especifica a 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.

source_table

Necessário para LIKE e CLONE.

  • Para CREATE TABLE. .. LIKE, especifica a tabela da qual as propriedades e definições de coluna são copiadas.

  • Para CREATE TABLE. .. CLONE, especifica a tabela a ser usada como origem para o clone.

Parâmetros opcionais

{ [ { LOCAL | GLOBAL } ] TEMP [ READ ONLY] | ` :newline:.` TEMPORARY [ READ ONLY] | . VOLATILE | ` :newline:.` TRANSIENT }

Especifica que a tabela persiste apenas pela duração da sessão em que você o criou. 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 dessas palavras-chave aparecem e se comportam de forma idêntica a uma tabela criada com a palavra-chave TEMPORARY.

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

Se você deseja evitar conflitos inesperados, evite nomear tabelas temporárias como tabelas que já existem no esquema.

Se você criou uma tabela temporária com o mesmo nome de outra tabela no esquema, todas as consultas e operações usadas na tabela afetarão apenas a tabela temporária na sessão, até que você elimine a tabela temporária. Se você descartar a tabela, descartará a tabela temporária e não a tabela que já existe no esquema.

Para obter mais informações sobre tabelas temporárias ou transitórias e como elas podem afetar o armazenamento e o custo, consulte os seguintes recursos:

READ ONLY

Especifica que a tabela é somente leitura. READ ONLY é válido apenas para uma tabela temporária que está sendo criada com a variante CREATE TABLE … CLONE do comando CREATE TABLE.

Uma tabela somente leitura não permite operações de DML e permite apenas o seguinte subconjunto de operações de DDL:

  • ALTER TABLE … { ALTER | MODIFY } COLUMN … { SET | UNSET } COMMENT

  • ALTER TABLE … { ALTER | MODIFY } COLUMN … { SET | UNSET } MASKING POLICY

  • ALTER TABLE … { ALTER | MODIFY } COLUMN … { SET | UNSET } TAG

  • ALTER TABLE … RENAME COLUMN … TO

  • ALTER TABLE … RENAME TO

  • ALTER TABLE … { SET | UNSET } COMMENT

  • ALTER TABLE … { SET | UNSET } TAG

  • COMMENT

  • DESCRIBE

  • DROP

  • SHOW

  • UNDROP

As tabelas somente leitura têm uma coluna METADATA$ROW_POSITION. Esta coluna de metadados atribui um número de linha a cada linha na tabela que é contínua e começa em 0. O número de linha atribuído a cada linha permanece inalterado até que a tabela somente leitura seja descartada.

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.

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.

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.

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 } ] . [ { ORDER | NOORDER } ]

Quando você especifica AUTOINCREMENT ou IDENTITY, o valor padrão para a coluna começa com um número especificado e cada valor sucessivo é incrementado automaticamente pelo valor especificado.

AUTOINCREMENT e IDENTITY são sinônimos e podem ser usados somente para colunas com tipos de dados numéricos, como NUMBER, INT, FLOAT.

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 valor inicial e o valor da etapa/incremento é 1.

Nota

Inserir valores manualmente em uma coluna AUTOINCREMENT ou IDENTITY pode resultar em valores duplicados. Se você inserir manualmente o valor 5 em uma coluna AUTOINCREMENT ou IDENTITY, uma linha inserida posteriormente pode usar o mesmo valor 5 como o valor padrão para a coluna.

Use ORDER ou NOORDER para especificar se os valores serão gerados ou não para a coluna incrementada automaticamente em ordem crescente ou decrescente.

  • ORDER especifica que os valores gerados para uma sequência ou coluna incrementada automaticamente estão em ordem crescente (ou, se o intervalor for um valor negativo, em ordem decrescente).

    Por exemplo, se uma sequência ou coluna incrementada automaticamente tiver START 1 INCREMENT 2, os valores gerados podem ser 1, 3, 5, 7, 9 etc.

  • NOORDER especifica que não é garantido que os valores estejam em ordem crescente.

    Por exemplo, se uma sequência tiver START 1 INCREMENT 2, os valores gerados podem ser 1, 3, 101, 5, 103 etc.

    NOORDER pode melhorar o desempenho quando várias operações INSERT são executadas simultaneamente (por exemplo, quando vários clientes estão executando várias instruções INSERT).

Se você não especificar ORDER ou NOORDER, o parâmetro NOORDER_SEQUENCE_AS_DEFAULT determinará qual propriedade será configurada.

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.

Este parâmetro não é suportado pela sintaxe da variante CREATE OR ALTER.

PROJECTION POLICY policy_name

Especifica a política de projeção a ser definida em uma coluna.

Este parâmetro não é suportado pela sintaxe da variante CREATE OR ALTER.

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

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.

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, você deve entender as micropartições. Para obter mais informações, consulte Explicação das estruturas de tabela do Snowflake.

ENABLE_SCHEMA_EVOLUTION = { TRUE | FALSE }

Ativa ou desativa as alterações automáticas no esquema da tabela a partir dos dados carregados na tabela dos arquivos de origem, incluindo:

  • Colunas adicionadas.

    Por padrão, a evolução do esquema é limitada a um máximo de 10 colunas adicionadas por operação de carregamento. Para solicitar mais de 10 colunas adicionadas por operação de carga, entre em contato com o suporte Snowflake.

  • A restrição NOT NULL pode ser descartada de qualquer número de colunas ausentes em novos arquivos de dados.

Configurando como TRUE permite a evolução automática do esquema da tabela. O padrão FALSE desativa a evolução automática do esquema da tabela.

Nota

O carregamento de dados de arquivos evolui as colunas da tabela quando todas as condições a seguir forem verdadeiras:

  • A instrução COPY INTO <tabela> inclui a opção MATCH_BY_COLUMN_NAME.

  • A função usada para carregar os dados tem o privilégio EVOLVE SCHEMA ou OWNERSHIP na tabela.

Além disso, para a evolução do esquema com CSV, quando usado com MATCH_BY_COLUMN_NAME e PARSE_HEADER, ERROR_ON_COLUMN_COUNT_MISMATCH deve ser definido como falso.

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 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 par 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:

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

  • Este parâmetro não é suportado pela sintaxe da variante CREATE OR ALTER.

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, no nível da restrição ou no nível da tabela. A sintaxe de cada um é um pouco diferente).

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

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

Este parâmetro não é suportado pela sintaxe da variante CREATE OR ALTER.

AGGREGATION POLICY policy_name [ ENTITY KEY ( col_name [ , col_name ... ] ) ]

Especifica a política de agregação a ser definida em uma tabela.

Use o parâmetro opcional ENTITY KEY para definir quais colunas identificam exclusivamente uma entidade dentro da tabela. Para obter mais informações, consulte Implementação de privacidade ao nível de entidade com políticas de agregação.

Este parâmetro não é suportado pela sintaxe da variante CREATE OR ALTER.

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 informações sobre como especificar tags em uma instrução, consulte Cotas de tags para objetos e colunas.

Este parâmetro não é suportado pela sintaxe da variante CREATE OR ALTER.

Requisitos de controle de acesso

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

Privilégio

Objeto

Notas

CREATE TABLE

Esquema

Note que a criação de uma tabela temporária não requer o privilégio CREATE TABLE.

SELECT

Tabela, tabela externa, exibição

Necessário em tabelas e/ou exibições consultadas somente ao clonar uma tabela ou executar instruções CTAS.

APPLY

Política de mascaramento, política de acesso a linhas, tag

Necessário somente ao aplicar uma política de mascaramento, política de acesso a linhas, tags de objetos ou qualquer combinação dessas recursos de governança ao criar tabelas.

USAGE (estágio externo) ou READ (estágio interno)

Estágio

Necessário para derivar definições de colunas da tabela a partir de arquivos preparados usando instruções CREATE TABLE … USING TEMPLATE.

OWNERSHIP

Tabela

  • Uma função deve ser concedida ou herdar o privilégio OWNERSHIP no objeto para criar um objeto temporário com o mesmo nome do objeto que já existe no esquema.

  • Necessário para executar uma instrução CREATE OR ALTER TABLE para uma tabela existente.

OWNERSHIP is a special privilege on an object that is automatically granted to the role that created the object, but can also be transferred using the GRANT OWNERSHIP command to a different role by the owning role (or any role with the MANAGE GRANTS privilege).

Note that in a managed access schema, only the schema owner (i.e. the role with the OWNERSHIP privilege on the schema) or a role with the MANAGE GRANTS privilege can grant or revoke privileges on objects in the schema, including future grants.

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 Visão geral do controle de acesso.

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 um objeto é substituído, o objeto antigo é excluído e o novo objeto é criado 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 OR ALTER TABLE:

    Para obter mais informações, consulte Notas de uso de CREATE OR ALTER TABLE.

  • 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 … CHANGE_TRACKING = TRUE:

    Quando o rastreamento da alterações é ativado, a tabela é bloqueada durante toda a operação. Os bloqueios podem causar latência com algumas operações associadas DDL/DML. Para obter mais informações, consulte Bloqueio de recursos.

  • 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 ...
      
      Copy

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

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

      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.

Notas de uso de CREATE OR ALTER TABLE

  • Limitações

    • Atualmente, oferece suporte apenas a tabelas permanentes, temporárias e transitórias. Tabelas somente leitura, externas, dinâmicas, Apache Iceberg™ e híbridas não são compatíveis.

    • Todas as limitações do comando ALTER TABLE se aplicam.

    • Atualmente não oferece suporte ao seguinte:

      • Sintaxe da variante CREATE TABLE … AS SELECT (CTAS).

      • Sintaxe da variante CREATE TABLE … USING TEMPLATE.

      • Sintaxe da variante CREATE TABLE … LIKE.

      • Sintaxe da variante CREATE TABLE … CLONE.

  • Parâmetros e propriedades da tabela

    • A ausência de uma propriedade ou parâmetro que foi previamente definido na definição da tabela modificada resulta no cancelamento de sua definição.

    • O cancelamento da definição de um valor de parâmetro explícito resulta na configuração do valor do parâmetro padrão. Se o parâmetro for definido no esquema ou banco de dados que contém a tabela, a tabela herdará o valor do parâmetro definido no esquema ou banco de dados.

  • Governança de dados

    • Definir ou desmarcar uma tag ou política em uma tabela ou coluna usando uma instrução CREATE OR ALTER TABLE não é suportado.

      As políticas ou tags existentes não são alteradas por uma instrução CREATE OR ALTER e permanecem inalteradas.

  • Restrições

    Definir ou cancelar a definição de uma chave primária inline altera a nulidade da coluna de acordo. Isso está alinhado com o comportamento do comando CREATE TABLE, mas é diferente do comportamento do comando ALTER TABLE.

  • Colunas

    • Novas colunas só podem ser adicionadas ao final da lista de colunas.

    • As colunas não podem ser renomeadas. Se você tentar renomear uma coluna, ela será descartada e uma nova coluna será adicionada.

    • O valor padrão de uma coluna só pode ser modificado para usar uma sequência.

    • A sequência padrão para uma coluna (por exemplo, SET DEFAULT seq_name.NEXTVAL) só pode ser alterado se a coluna já tiver uma sequência.

    • Para obter mais informações sobre como modificar colunas, consulte ALTER TABLE … ALTER COLUMN.

  • Agrupamento

    • As especificações de agrupamento não podem ser alteradas.

    • A definição do parâmetro DEFAULT_DDL_COLLATION no comando CREATE OR ALTER TABLE define a especificação de agrupamento padrão para colunas existentes, o que garante o comando CREATE OR ALTER TABLE produza os mesmos resultados que o comando CREATE TABLE. Portanto, você não pode usar o comando CREATE OR ALTER TABLE para definir o parâmetro DEFAULT_DDL_COLLATION em uma tabela que possui colunas de texto existentes. No entanto, você pode tornar as comparações explícitas para colunas existentes ao alterar o parâmetro DEFAULT_DDL_COLLATION para uma tabela.

      Por exemplo, crie uma nova tabela my_table e defina a especificação de ordenação padrão para a tabela como “fr”:

      CREATE OR ALTER TABLE my_table (
        a INT PRIMARY KEY,
        b VARCHAR(20)
      )
      DEFAULT_DDL_COLLATION = 'fr';
      
      Copy

      A especificação de ordenação para coluna b é “fr” e não pode ser alterado. Para alterar a especificação de ordenação padrão para tabela my_table, você deve definir explicitamente a ordenação para a coluna de texto b na instrução CREATE OR ALTER:

      CREATE OR ALTER TABLE my_table (
        a INT PRIMARY KEY,
        b VARCHAR(200) COLLATE 'fr'
      )
      DEFAULT_DDL_COLLATION = 'de';
      
      Copy
  • Atomicidade

    O comando CREATE OR ALTER TABLE atualmente não garante atomicidade. Isto significa que se uma instrução CREATE OR ALTER TABLE falhar durante a execução, é possível que um subconjunto de alterações tenha sido aplicado à tabela. Se houver possibilidade de alterações parciais, a mensagem de erro, na maioria dos casos, inclui o seguinte texto:

    CREATE OR ALTER execution failed. Partial updates may have been applied.
    

    Por exemplo, se a instrução estiver tentando remover a coluna A e adicionar uma nova coluna B em uma tabela e a instrução for abortada, é possível que a coluna A tenha sido descartado mas a coluna B não foi adicionada.

    Nota

    Se as alterações forem aplicadas parcialmente, a tabela resultante ainda estará em um estado válido e você poderá usar instruções ALTER TABLE para completar o conjunto original de alterações.

    Para se recuperar de atualizações parciais, a Snowflake recomenda os seguintes mecanismos de recuperação:

    • Reparo adiantado

      • Execute a instrução CREATE OR ALTER TABLE novamente. Se as instruções forem bem-sucedidas na segunda tentativa, o estado alvo será alcançado.

      • Investigue a mensagem de erro. Se possível, corrija o erro e execute novamente a instrução CREATE OR ALTER TABLE.

    • Reversão

      Se não for possível fazer o reparo aidantado, a Snowflake recomenda reverter manualmente as alterações parciais:

      • Investigue o estado da tabela usando os comandos DESCRIBE TABLE e SHOW TABLES. Determine quais alterações parciais foram aplicadas, se houver.

      • Se alguma alteração parcial foi aplicada, execute as instrução ALTER TABLE apropriadas para transformar a tabela de volta ao seu estado original.

        Nota

        Em alguns casos, talvez não seja possível desfazer alterações parciais. Para obter mais informações, consulte as ações com e sem suporte para modificar as propriedades da coluna no tópico ALTER TABLE … ALTER COLUMN.

    • Se precisar de ajuda para se recuperar de uma atualização parcial, entre em contato com o suporte Snowflake.

Exemplos

Exemplos básicos

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    |
+--------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+
Copy

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 |
+------+--------------+--------+-------+---------+-------------+------------+-------+------------+------------------+
Copy

Exemplos CTAS

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 |
+---+
Copy

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;
Copy

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    |
+-------------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+
Copy

Exemplos de CREATE TABLE … LIKE

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 |
|--------|
+--------+
Copy

Exemplos de CREATE TABLE que definem parâmetros e propriedades

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              |
+---------------------------------+---------+---------------+-------------+-------+---------+------------------+------+-------+--------------+----------------+
Copy

Especificar o agrupamento para colunas em uma tabela:

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

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

Exemplos de CREATE TABLE … USINGTEMPLATE

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'
        )
      ));
Copy

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.

Nota

Usar * para ARRAY_AGG(OBJECT_CONSTRUCT()) pode resultar em erro se o resultado retornado for maior que 16MB. Recomenda-se evitar o uso de * para conjuntos de resultados maiores e usar apenas as colunas obrigatórias, COLUMN NAME, TYPE e NULLABLE, para a consulta. A coluna opcional ORDER_ID pode ser incluída ao usar WITHIN GROUP (ORDER BY order_id).

Exemplos de tabelas temporárias

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);
Copy

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);
Copy

Exemplos de CREATE OR ALTER TABLE

Crie uma tabela my_table usando o comando CREATE OR ALTER TABLE:

CREATE OR ALTER TABLE my_table(a INT);
Copy

Nota

As instruções CREATE OR ALTER TABLE para tabelas existentes só podem ser executadas por uma função com o privilégio OWNERSHIP na tabela my_table.

Altere a tabela my_table para adicionar e modificar colunas e definir os parâmetros DATA_RETENTION_TIME_IN_DAYS e DEFAULT_DDL_COLLATION:

CREATE OR ALTER TABLE my_table(
    a INT PRIMARY KEY,
    b VARCHAR(200)
  )
  DATA_RETENTION_TIME_IN_DAYS = 5
  DEFAULT_DDL_COLLATION = 'de';
Copy

Desative o parâmetro DATA_RETENTION_TIME_IN_DAYS. A ausência de um parâmetro na definição da tabela modificada resulta no cancelamento de sua definição. Nesse caso, a desinstalação do parâmetro DATA_RETENTION_TIME_IN_DAYS da tabela o redefine para o valor padrão de 1:

CREATE OR ALTER TABLE my_table(
    a INT PRIMARY KEY,
    c VARCHAR(200)
  )
  DEFAULT_DDL_COLLATION = 'de';
Copy

O comando CREATE OR ALTER TABLE oferece suporte à adição de colunas no fim da lista de colunas. Se você tentar renomear uma coluna existente, a coluna existente será descartada e uma nova coluna com o novo nome será adicionada. Isso pode resultar em perda de dados se houver dados na coluna original.

O exemplo a seguir ilustra esse comportamento.

  1. Crie uma tabela:

    CREATE OR ALTER TABLE my_table(
        a INT PRIMARY KEY,
        b INT
      );
    
    Copy
  2. Inserir dados na tabela my_table:

    INSERT INTO my_table VALUES (1, 2), (2, 3);
    
    SELECT * FROM my_table;
    
    Copy

    Retorna:

    +---+---+
    | A | B |
    |---+---|
    | 1 | 2 |
    | 2 | 3 |
    +---+---+
    
  3. Tentar renomear coluna b:

    CREATE OR ALTER TABLE my_table(
        a INT PRIMARY KEY,
        c INT
      );
    
    Copy

    A coluna b é descartada e a coluna c é adicionada:

    SELECT * FROM my_table;
    
    Copy

    Retorna:

    +---+------+
    | A | C    |
    |---+------|
    | 1 | NULL |
    | 2 | NULL |
    +---+------+
    

    Nota

    Você pode recuperar colunas descartadas usando o Time Travel.

Definir ou cancelar a definição de uma chave primária inline altera a nulidade da coluna de uma forma que se alinha com o comportamento do comando CREATE TABLE, mas é diferente do comportamento do comando ALTER TABLE. Por exemplo, adicionar uma restrição de chave primária em uma coluna usando uma instrução ALTER TABLE não altera a nulidade da coluna.

O exemplo a seguir ilustra esse comportamento.

  1. Crie uma tabela:

    CREATE TABLE t(a INT);
    
    Copy
  2. Altere a tabela para adicionar uma restrição PRIMARY KEY:

    CREATE OR ALTER TABLE t(a INT PRIMARY KEY);
    
    Copy

    A coluna a agora é a chave primária e está definida como NOT NULL:

    DESC TABLE t;
    
    Copy

    Retorna:

    +------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------+
    | name | type         | kind   | null? | default | primary key | unique key | check | expression | comment | policy name | privacy domain |
    |------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------|
    | A    | NUMBER(38,0) | COLUMN | N     | NULL    | Y           | N          | NULL  | NULL       | NULL    | NULL        | NULL           |
    +------+--------------+--------+-------+---------+-------------+------------+-------+------------+---------+-------------+----------------+
    
  3. Substitua a tabela t:

    CREATE OR REPLACE TABLE t(a INT);
    
    Copy
  4. Insira um valor NULL:

    INSERT INTO t VALUES (null);
    
    Copy
  5. Adicione a restrição de chave primária à coluna a.

    O valor NULL na coluna a faz com que a seguinte instrução falhe:

    CREATE OR ALTER TABLE t(a INT PRIMARY KEY);
    
    Copy

    Retorna:

    001471 (42601): SQL compilation error:
    Column 'A' contains null values. Not null constraint cannot be added.