Resolução de nome de objeto¶
Um objeto de esquema totalmente qualificado (tabela, exibição, formato de arquivo etc.) tem a forma:
<database_name>.<schema_name>.<object_name>
Entretanto, como pode ser tedioso escrever isso, o usuário pode omitir qualificações, da esquerda para a direita. Este tópico descreve como os nomes dos objetos de esquema são resolvidos.
Resolução quando o banco de dados é omitido¶
(''<schema_name>.<object_name>'')
O nome do objeto é aumentado com o banco de dados atual. O banco de dados atual é definido para um valor padrão, dependendo das configurações da conta, quando uma sessão é iniciada. Em seguida, pode ser alterado usando o comando USE DATABASE. O comando CREATE DATABASE também altera implicitamente o banco de dados atual para o recém-criado. O nome do banco de dados atual é retornado pela função CURRENT_DATABASE.
Por exemplo:
SELECT CURRENT_DATABASE();
+--------------------+
| CURRENT_DATABASE() |
+--------------------+
| TESTDB |
+--------------------+
CREATE DATABASE db1;
+------------------------------------+
| status |
+------------------------------------+
| Database DB1 successfully created. |
+------------------------------------+
SELECT CURRENT_DATABASE();
+--------------------+
| CURRENT_DATABASE() |
+--------------------+
| DB1 |
+--------------------+
USE DATABASE testdb;
+----------------------------------+
| status |
+----------------------------------+
| Statement executed successfully. |
+----------------------------------+
SELECT CURRENT_DATABASE();
+--------------------+
| CURRENT_DATABASE() |
+--------------------+
| TESTDB |
+--------------------+
Resolução em caso de omissão de esquema (notação de ponto duplo)¶
(''<database_name>..<object_name>'')
Os dois pontos indicam que o nome do esquema não está especificado. O esquema padrão PUBLIC é sempre referenciado.
Note que esse formato notacional é fornecido principalmente para compatibilidade com outros sistemas, como Microsoft SQL Server e IBM Netezza. O uso desta notação em novas consultas não é recomendável.
Objetos não qualificados¶
Objetos não qualificados (identificadores únicos) são resolvidos de duas maneiras diferentes, dependendo do caso: se aparecem em uma instrução DDL ou DML, ou em uma consulta.
Instruções DDL e DML¶
Nas instruções DDL e DML, os objetos não qualificados são aumentados com o banco de dados e esquema atual. O esquema atual é mantido de forma similar ao atual banco de dados. O esquema atual pertence sempre ao banco de dados atual.
Quando uma sessão é iniciada, o esquema atual é inicializado com base nas configurações da conexão. Quando o banco de dados atual é alterado, o esquema atual usa o padrão de valor de uma propriedade interna (normalmente definido como PUBLIC). O esquema atual pode ser alterado (sempre dentro do banco de dados atual) usando o comando USE SCHEMA. Também é implicitamente alterado pelo comando CREATE SCHEMA. O nome do esquema atual é retornado pela função CURRENT_SCHEMA.
Por exemplo:
SELECT CURRENT_SCHEMA();
+------------------+
| CURRENT_SCHEMA() |
+------------------+
| TESTSCHEMA |
+------------------+
CREATE DATABASE db1;
+------------------------------------+
| status |
+------------------------------------+
| Database DB1 successfully created. |
+------------------------------------+
SELECT CURRENT_SCHEMA();
+------------------+
| CURRENT_SCHEMA() |
+------------------+
| PUBLIC |
+------------------+
CREATE SCHEMA sch1;
+-----------------------------------+
| status |
+-----------------------------------+
| Schema SCH1 successfully created. |
+-----------------------------------+
SELECT current_schema();
+------------------+
| CURRENT_SCHEMA() |
|------------------+
| SCH1 |
|------------------+
Resolução de nomes em consultas¶
Nas consultas, nomes de objetos não qualificados são resolvidos por meio de um caminho de pesquisa.
O caminho de pesquisa geralmente contém o esquema atual, mas também pode conter outros esquemas.
O caminho de pesquisa é armazenado no parâmetro de nível de sessão SEARCH_PATH. Similar a qualquer outro parâmetro, ele pode ser alterado usando o comando ALTER SESSION.
O valor do caminho de pesquisa é uma lista de identificadores separados por vírgulas. A lista pode conter nomes de esquemas total ou parcialmente qualificados. Cada nome de esquema pode ser um Identificadores entre aspas duplas.
O caminho de pesquisa também pode conter as seguintes pseudovariáveis:
- $current
Especifica o esquema atual (veja acima).
- $public
Especifica o esquema público do banco de dados atual. O nome do esquema público é determinado por uma propriedade interna, mantida pelo Snowflake, que normalmente é definida como PUBLIC (para o esquema PUBLIC criado automaticamente para cada banco de dados).
Esses nomes pseudovariáveis na diferenciam maiúsculas e minúsculas.
O valor padrão do caminho de pesquisa é $current, $public.
Se o usuário especificar um novo valor para o caminho de pesquisa, o novo valor será validado. Cada identificador de esquema especificado no novo valor deve corresponder a um esquema existente. (Em especial, todo esquema não qualificado deve corresponder a um esquema existente no banco de dados atual). Caso contrário, um erro será levantado e search_path manterá seu valor anterior. Entretanto, as pseudovariáveis podem ser usadas livremente. Por exemplo, $public pode ser usado mesmo que o banco de dados atual não tenha um esquema público.
O valor do parâmetro SEARCH_PATH é reinterpretado toda vez que ele é utilizado. Portanto, alterar o esquema atual muda o significado de $current, e alterar o banco de dados atual muda o significado de $public, assim como o significado de quaisquer esquemas não qualificados.
Se um esquema no caminho de pesquisa for descartado, ou se o banco de dados atual for alterado e alguns esquemas não qualificados no caminho de pesquisa não existirem no novo banco de dados, nenhum erro será levantado.
O SEARCH_PATH não é usado dentro das exibições ou UDFs. Todos os objetos não qualificados em uma definição de exibição ou UDF serão resolvidos somente no esquema da exibição ou UDF.
O valor do literal do caminho de pesquisa pode ser examinado com o comando SHOW PARAMETERS.
Para ver os esquemas que serão pesquisados para objetos não qualificados nas consultas, use a função CURRENT_SCHEMAS. O valor de retorno para a função contém uma série de esquemas totalmente qualificados no caminho de pesquisa, separados por vírgulas.
Por exemplo:
SELECT CURRENT_SCHEMAS();
+-------------------+
| CURRENT_SCHEMAS() |
+-------------------+
| [] |
+-------------------+
USE DATABASE mytestdb;
SELECT current_schemas();
+---------------------+
| CURRENT_SCHEMAS() |
+---------------------+
| ["MYTESTDB.PUBLIC"] |
+---------------------+
CREATE SCHEMA private;
SELECT current_schemas();
+-----------------------------------------+
| CURRENT_SCHEMAS() |
+-----------------------------------------+
| ["MYTESTDB.PRIVATE", "MYTESTDB.PUBLIC"] |
+-----------------------------------------+
As pseudovariáveis são expandidas para seu valor atual, os esquemas não qualificados são totalmente qualificados, e os esquemas que não existem ou não são visíveis são omitidos.
SHOW PARAMETERS LIKE 'search_path';
+-------------+--------------------+--------------------+------------------------------------------------+
| key | value | default | description |
+-------------+--------------------+--------------------+------------------------------------------------+
| SEARCH_PATH | $current, $public, | $current, $public, | Search path for unqualified object references. |
+-------------+--------------------+--------------------+------------------------------------------------+
SELECT current_schemas();
+---------------------------------------------------------------------------+
| CURRENT_SCHEMAS() |
+---------------------------------------------------------------------------+
| [XY12345.TESTDB.TESTSCHEMA, XY12345.TESTDB.PUBLIC, SAMPLES.COMMON.PUBLIC] |
+---------------------------------------------------------------------------+
CREATE DATABASE db1;
+------------------------------------+
| status |
+------------------------------------+
| Database DB1 successfully created. |
+------------------------------------+
USE SCHEMA public;
+----------------------------------+
| status |
+----------------------------------+
| Statement executed successfully. |
+----------------------------------+
SELECT current_schemas();
+---------------------------------------------+
| CURRENT_SCHEMAS() |
+---------------------------------------------+
| [XY12345.DB1.PUBLIC, SAMPLES.COMMON.PUBLIC] |
+---------------------------------------------+
ALTER SESSION SET search_path='$current, $public, testdb.public';
+----------------------------------+
| status |
+----------------------------------+
| Statement executed successfully. |
+----------------------------------+
SHOW PARAMETERS LIKE 'search_path';
+-------------+----------------------------------+--------------------+------------------------------------------------+
| key | value | default | description |
+-------------+----------------------------------+--------------------+------------------------------------------------+
| SEARCH_PATH | $current, $public, testdb.public | $current, $public, | Search path for unqualified object references. |
+-------------+----------------------------------+--------------------+------------------------------------------------+
SELECT current_schemas();
+---------------------------------------------+
| CURRENT_SCHEMAS() |
+---------------------------------------------+
| [XY12345.DB1.PUBLIC, XY12345.TESTDB.PUBLIC] |
+---------------------------------------------+
Precedência quando um nome de coluna e um alias são iguais¶
É possível (mas, geralmente, não recomendado) criar uma consulta que contenha um alias igual a um nome de coluna:
SELECT x, some_expression AS x
FROM ...
Se uma cláusula contém um nome que corresponde ao nome de uma coluna e a um alias, a cláusula usa o nome da coluna. O exemplo a seguir demonstra esse comportamento usando uma cláusula GROUP BY:
Criar uma tabela e inserir linhas:
CREATE TABLE employees (salary FLOAT, state VARCHAR, employment_state VARCHAR);
INSERT INTO employees (salary, state, employment_state) VALUES
(60000, 'California', 'Active'),
(70000, 'California', 'On leave'),
(80000, 'Oregon', 'Active');
A consulta abaixo retorna a soma dos salários dos funcionários que estão ativos e a soma dos salários dos funcionários que estão de licença:
SELECT SUM(salary), ANY_VALUE(employment_state)
FROM employees
GROUP BY employment_state;
+-------------+-----------------------------+
| SUM(SALARY) | ANY_VALUE(EMPLOYMENT_STATE) |
|-------------+-----------------------------|
| 140000 | Active |
| 70000 | On leave |
+-------------+-----------------------------+
A consulta seguinte usa o alias state, que corresponde ao nome de uma coluna da tabela na consulta. Quando state é usado na cláusula GROUP BY, o Snowflake o interpreta como uma referência ao nome da coluna, e não ao alias. Portanto, a consulta retorna a soma dos salários dos funcionários no estado da Califórnia e a soma dos salários dos funcionários no estado de Oregon, mas exibe as informações de employment_state (isto é, Active) em vez dos nomes dos estados ou províncias.
SELECT SUM(salary), ANY_VALUE(employment_state) AS state
FROM employees
GROUP BY state;
+-------------+--------+
| SUM(SALARY) | STATE |
|-------------+--------|
| 130000 | Active |
| 80000 | Active |
+-------------+--------+