CREATE VIEW¶

Sintaxe¶

CREATE [ OR REPLACE ] [ SECURE ] [ { [ { LOCAL | GLOBAL } ] TEMP | TEMPORARY | VOLATILE } ] [ RECURSIVE ] VIEW [ IF NOT EXISTS ] <name>
  [ ( <column_list> ) ]
  [ <col1> [ WITH ] MASKING POLICY <policy_name> [ USING ( <col1> , <cond_col1> , ... ) ]
           [ WITH ] PROJECTION POLICY <policy_name>
           [ WITH ] TAG ( <tag_name> = '<tag_value>' [ , <tag_name> = '<tag_value>' , ... ] ) ]
  [ , <col2> [ ... ] ]
  [ [ WITH ] ROW ACCESS POLICY <policy_name> ON ( <col_name> [ , <col_name> ... ] ) ]
  [ [ WITH ] TAG ( <tag_name> = '<tag_value>' [ , <tag_name> = '<tag_value>' , ... ] ) ]
  [ COPY GRANTS ]
  [ COMMENT = '<string_literal>' ]
  [ [ WITH ] ROW ACCESS POLICY <policy_name> ON ( <col_name> [ , <col_name> ... ] ) ]
  [ [ WITH ] AGGREGATION POLICY <policy_name> ]
  [ [ WITH ] TAG ( <tag_name> = '<tag_value>' [ , <tag_name> = '<tag_value>' , ... ] ) ]
  AS <select_statement>

Parâmetros obrigatórios¶

name

Especifica o identificador da visualização; deve ser único para o esquema no qual a visualização é 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.

select_statement

Especifica a consulta utilizada para criar a visualização. Pode estar em uma ou mais tabelas de origem ou qualquer outra instrução SELECT válida. Esta consulta serve como texto/definição para a exibição e é exibida na saída SHOW VIEWS e na exibição VIEWS do Information Schema.

Parâmetros opcionais¶

SECURE

Especifica que a visualização é segura. Para obter mais informações sobre exibições seguras, consulte Como trabalhar com exibições seguras.

Padrão: sem valor (a visualização não é segura)

{ [ { LOCAL | GLOBAL } ] TEMP | TEMPORARY | VOLATILE }

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

Padrão: sem valor. Se uma exibição não for declarada como TEMPORARY, ela será permanente.

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

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

RECURSIVE

Especifica que a exibição pode fazer referência a si mesma usando uma sintaxe recursiva sem necessariamente usar um CTE (expressão de tabela comum). Para obter mais informações sobre exibições recursivas em geral, e a palavra-chave RECURSIVE em particular, consulte Exibições recursivas (apenas exibições não-materializadas) e os exemplos de exibições recursivas abaixo.

Padrão: sem valor (a exibição não é recursiva, ou é recursiva apenas por meio de um CTE)

column_list

Se você quiser mudar o nome de uma coluna ou adicionar um comentário a uma coluna na nova exibição, inclua uma lista de colunas que especifique os nomes das colunas e (se necessário) comentários sobre as colunas. (Você não precisa especificar os tipos de dados das colunas).

Se qualquer uma das colunas na exibição for baseada em expressões (não apenas em nomes simples de colunas), então você deverá fornecer um nome de coluna para cada coluna na exibição. Por exemplo, os nomes das colunas são necessários no caso a seguir:

CREATE VIEW v1 (pre_tax_profit, taxes, after_tax_profit) AS
    SELECT revenue - cost, (revenue - cost) * tax_rate, (revenue - cost) * (1.0 - tax_rate)
    FROM table1;

Copy

Você pode especificar um comentário opcional para cada coluna. Por exemplo:

CREATE VIEW v1 (pre_tax_profit COMMENT 'revenue minus cost',
                taxes COMMENT 'assumes taxes are a fixed percentage of profit',
                after_tax_profit)
    AS
    SELECT revenue - cost, (revenue - cost) * tax_rate, (revenue - cost) * (1.0 - tax_rate)
    FROM table1;

Copy

Os comentários são particularmente úteis quando os nomes das colunas são enigmáticos.

Para ver os comentários, use DESCRIBE VIEW.

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.

PROJECTION POLICY policy_name

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

COPY GRANTS

Mantém as permissões de acesso da exibição original quando uma nova exibição é criada usando a cláusula OR REPLACE.

O parâmetro copia todos os privilégios, exceto OWNERSHIP, da exibição existente para a nova exibição. A nova visualização 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 VIEW é a proprietária da nova exibição.

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

Observe que a operação de cópia de concessões ocorre atomicamente com a instrução CREATE VIEW (isto é, dentro da mesma transação).

Padrão: sem valor (as concessões não são copiadas)

COMMENT = 'string_literal'

Especifica um comentário para a visualização.

Padrão: sem valor

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

Especifica a política de acesso a linhas a ser definida em uma visualização.

AGGREGATION POLICY policy_name

Especifica a política de acesso a linhas a ser definida em uma exibição.

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.

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

Notas de uso¶

• Uma definição de exibição pode incluir uma cláusula ORDER BY (por exemplo, create view v1 as select * from t1 ORDER BY column1). Entretanto, o Snowflake recomenda excluir a cláusula ORDER BY da maioria das definições de exibição. Se a exibição for utilizada em contextos que não se beneficiam da classificação, então a cláusula ORDER BY acrescentará custos desnecessários. Por exemplo, quando a exibição é usada em uma junção, e a coluna de junção não é a mesma que a coluna ORDER BY, o custo extra para ordenar os resultados da exibição é normalmente desperdiçado. Se você precisar ordenar os resultados da consulta, geralmente é mais eficiente especificar ORDER BY na consulta que usa a exibição, em vez de na própria exibição.

• A definição de uma exibição é limitada a 95KB.

• Os níveis de aninhamento são limitados a um máximo de 20. Uma tentativa de criar uma exibição aninhada mais de 20 vezes falhará.

• As definições de visualização não são dinâmicas. Uma exibição não é atualizada automaticamente se as fontes subjacentes forem modificadas de forma que não correspondam mais à definição da exibição, especialmente quando as colunas são descartadas. Por exemplo:

  • É criada uma exibição referenciando uma coluna específica em uma tabela de origem e a coluna é posteriormente descartada da tabela.

  • Uma exibição é criada usando SELECT * de uma tabela, e alterações são feitas nas colunas da tabela, como quando:

    • Uma coluna é descartada.

    • Uma coluna é adicionada.

    • A ordem das colunas muda.

  Nestes cenários, consultar a exibição retorna um erro relacionado à coluna.

• Se uma tabela de origem de uma exibição for descartada, a consulta da exibição retornará um erro object does not exist.

• Um esquema não pode conter uma tabela e uma exibição com o mesmo nome. Uma instrução CREATE VIEW produz um erro se uma tabela com o mesmo nome já existir no esquema.

• Quando uma exibição é criada, referências não qualificadas a tabelas e outros objetos de bancos de dados são resolvidas no esquema da exibição, não no esquema atual da exibição. Da mesma forma, objetos que são parcialmente qualificados (isto é, esquema.objeto) são resolvidos no banco de dados da exibição, não no banco de dados atual da sessão.

  O parâmetro da sessão SEARCH_PATH (se presente) é ignorado.

• Usar OR REPLACE é o equivalente a usar DROP VIEW na exibição existente e depois criar uma nova exibição com o mesmo nome.

  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 VIEW utiliza a versão da exibição antiga ou nova.

  Recriar ou trocar uma exibição descarta seus dados de mudança, o que torna qualquer fluxo na exibição obsoleto. Um fluxo obsoleto é ilegível.

• Usando COPY GRANTS:

  • Compartilhamento de dados:

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

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

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

• Quando você cria uma exibição e então concede privilégios nessa exibição a uma função, a função pode usar a exibição mesmo que a função não tenha privilégios na(s) tabela(s) subjacente(s) que a exibição acessa. Isto significa que você pode criar uma exibição para conceder a uma função acesso a apenas um subconjunto de uma tabela. Por exemplo, você pode criar uma exibição que acesse informações de faturamento médico, mas não informações de diagnóstico médico na mesma tabela. Então você pode conceder privilégios nessa exibição à função de “contador” para que os contadores possam olhar as informações de faturamento sem ver o diagnóstico do paciente.

• Por projeto, o comando SHOW VIEWS não fornece informações sobre exibições seguras. Para visualizar informações sobre uma exibição segura, você deve usar a exibição VIEWS no Information Schema e deve usar a função proprietária da exibição.

• Uma exibição recursiva deve fornecer uma lista de nomes de coluna.

• Ao definir exibições recursivas, evite a recorrência infinita. A cláusula WHERE na definição da exibição recursiva deve permitir que a recursividade pare eventualmente, normalmente ficando sem dados após o processamento do último nível de uma hierarquia de dados.

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

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

• Não crie exibições com fluxos como objetos de origem, a menos que a mesma função seja proprietária tanto da exibição quanto dos fluxos de origem (ou seja, a mesma função, ou uma função inferior em uma hierarquia de funções, com o privilégio OWNERSHIP na exibição e os fluxos de origem). Em vez disso, criar exibições que tenham os objetos a serem rastreados como os objetos de origem. Em seguida, criar fluxos nessas exibições. Para obter mais informações, consulte Streams on Views.

Notas sobre portabilidade¶

• Alguns fornecedores oferecem suporte à palavra-chave FORCE:

  CREATE OR REPLACE FORCE VIEW ...
  

  Copy

  O Snowflake aceita a palavra-chave FORCE, mas não oferece suporte para ela. Em outras palavras, você não recebe um erro de sintaxe se usar esta palavra-chave, mas usar FORCE não força a criação de uma exibição se os objetos subjacentes de banco de dados (tabela(s) ou exibição(ões)) ainda não existirem. A tentativa de criar uma exibição de uma tabela ou exibição inexistente resulta em uma mensagem de erro mesmo que a palavra-chave FORCE seja usada.

• Ao procurar as tabelas em uma exibição, alguns fornecedores procuram por nomes de tabelas não qualificados no esquema ativo; o Snowflake procura por nomes de tabelas não qualificados no mesmo esquema da exibição. Ao portar para o Snowflake, considere a atualização de exibições para usar nomes de tabelas totalmente qualificadas.

Exemplos¶

Criar uma exibição no esquema atual, com um comentário, que selecione todas as linhas de uma tabela:

CREATE VIEW myview COMMENT='Test view' AS SELECT col1, col2 FROM mytable;

SHOW VIEWS;

+---------------------------------+-------------------+----------+---------------+-------------+----------+-----------+--------------------------------------------------------------------------+
| created_on                      | name              | reserved | database_name | schema_name | owner    | comment   | text                                                                     |
|---------------------------------+-------------------+----------+---------------+-------------+----------+-----------+--------------------------------------------------------------------------|
| Thu, 19 Jan 2017 15:00:37 -0800 | MYVIEW            |          | MYTEST1       | PUBLIC      | SYSADMIN | Test view | CREATE VIEW myview COMMENT='Test view' AS SELECT col1, col2 FROM mytable |
+---------------------------------+-------------------+----------+---------------+-------------+----------+-----------+--------------------------------------------------------------------------+

Copy

O exemplo seguinte é o mesmo que o exemplo anterior, exceto que a exibição em questão é segura:

CREATE OR REPLACE SECURE VIEW myview COMMENT='Test secure view' AS SELECT col1, col2 FROM mytable;

SELECT is_secure FROM information_schema.views WHERE table_name = 'MYVIEW';

Copy

O seguinte mostra duas maneiras de criar exibições recorrentes:

Primeiro, criar e carregar a tabela:

CREATE OR REPLACE TABLE employees (title VARCHAR, employee_ID INTEGER, manager_ID INTEGER);

Copy

INSERT INTO employees (title, employee_ID, manager_ID) VALUES
    ('President', 1, NULL),  -- The President has no manager.
        ('Vice President Engineering', 10, 1),
            ('Programmer', 100, 10),
            ('QA Engineer', 101, 10),
        ('Vice President HR', 20, 1),
            ('Health Insurance Analyst', 200, 20);

Copy

Crie uma exibição usando um CTE recursivo, e depois consulte a exibição.

CREATE VIEW employee_hierarchy (title, employee_ID, manager_ID, "MGR_EMP_ID (SHOULD BE SAME)", "MGR TITLE") AS (
   WITH RECURSIVE employee_hierarchy_cte (title, employee_ID, manager_ID, "MGR_EMP_ID (SHOULD BE SAME)", "MGR TITLE") AS (
      -- Start at the top of the hierarchy ...
      SELECT title, employee_ID, manager_ID, NULL AS "MGR_EMP_ID (SHOULD BE SAME)", 'President' AS "MGR TITLE"
        FROM employees
        WHERE title = 'President'
      UNION ALL
      -- ... and work our way down one level at a time.
      SELECT employees.title, 
             employees.employee_ID, 
             employees.manager_ID, 
             employee_hierarchy_cte.employee_id AS "MGR_EMP_ID (SHOULD BE SAME)", 
             employee_hierarchy_cte.title AS "MGR TITLE"
        FROM employees INNER JOIN employee_hierarchy_cte
       WHERE employee_hierarchy_cte.employee_ID = employees.manager_ID
   )
   SELECT * 
      FROM employee_hierarchy_cte
);

Copy

SELECT * 
    FROM employee_hierarchy 
    ORDER BY employee_ID;
+----------------------------+-------------+------------+-----------------------------+----------------------------+
| TITLE                      | EMPLOYEE_ID | MANAGER_ID | MGR_EMP_ID (SHOULD BE SAME) | MGR TITLE                  |
|----------------------------+-------------+------------+-----------------------------+----------------------------|
| President                  |           1 |       NULL |                        NULL | President                  |
| Vice President Engineering |          10 |          1 |                           1 | President                  |
| Vice President HR          |          20 |          1 |                           1 | President                  |
| Programmer                 |         100 |         10 |                          10 | Vice President Engineering |
| QA Engineer                |         101 |         10 |                          10 | Vice President Engineering |
| Health Insurance Analyst   |         200 |         20 |                          20 | Vice President HR          |
+----------------------------+-------------+------------+-----------------------------+----------------------------+

Copy

Crie uma exibição usando a palavra-chave RECURSIVE, e depois consulte a exibição.

CREATE RECURSIVE VIEW employee_hierarchy_02 (title, employee_ID, manager_ID, "MGR_EMP_ID (SHOULD BE SAME)", "MGR TITLE") AS (
      -- Start at the top of the hierarchy ...
      SELECT title, employee_ID, manager_ID, NULL AS "MGR_EMP_ID (SHOULD BE SAME)", 'President' AS "MGR TITLE"
        FROM employees
        WHERE title = 'President'
      UNION ALL
      -- ... and work our way down one level at a time.
      SELECT employees.title, 
             employees.employee_ID, 
             employees.manager_ID, 
             employee_hierarchy_02.employee_id AS "MGR_EMP_ID (SHOULD BE SAME)", 
             employee_hierarchy_02.title AS "MGR TITLE"
        FROM employees INNER JOIN employee_hierarchy_02
        WHERE employee_hierarchy_02.employee_ID = employees.manager_ID
);

Copy

SELECT * 
    FROM employee_hierarchy_02 
    ORDER BY employee_ID;
+----------------------------+-------------+------------+-----------------------------+----------------------------+
| TITLE                      | EMPLOYEE_ID | MANAGER_ID | MGR_EMP_ID (SHOULD BE SAME) | MGR TITLE                  |
|----------------------------+-------------+------------+-----------------------------+----------------------------|
| President                  |           1 |       NULL |                        NULL | President                  |
| Vice President Engineering |          10 |          1 |                           1 | President                  |
| Vice President HR          |          20 |          1 |                           1 | President                  |
| Programmer                 |         100 |         10 |                          10 | Vice President Engineering |
| QA Engineer                |         101 |         10 |                          10 | Vice President Engineering |
| Health Insurance Analyst   |         200 |         20 |                          20 | Vice President HR          |
+----------------------------+-------------+------------+-----------------------------+----------------------------+

Copy