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 |
+-------------+-----------------------------+
The next query uses the alias state, which matches the name of a column of the table in the query. When state is used in
the GROUP BY clause, Snowflake interprets it as a reference to the column name, not the alias. This query therefore returns the sum of
the salaries of the employees in the state of California and the sum of the salaries of the employees in the state of Oregon,
yet displays employment_state information, such as Active, rather than the names of states or provinces:
SELECT SUM(salary), ANY_VALUE(employment_state) AS state
FROM employees
GROUP BY state;
+-------------+--------+
| SUM(SALARY) | STATE |
|-------------+--------|
| 130000 | Active |
| 80000 | Active |
+-------------+--------+