Literais e variáveis como identificadores

Nas instruções SQL do Snowflake, além de se referir a objetos pelo nome (consulte Requisitos para identificadores), você também pode usar um literal de cadeia de caracteres, variável de sessão, variável de vinculação ou variável de Script Snowflake para se referir a um objeto. Por exemplo, você pode usar uma variável de sessão que está definida para o nome de uma tabela na cláusula FROM de uma instrução SELECT.

Para usar um nome de objeto especificado em um literal ou variável, use IDENTIFIER().

Sintaxe

IDENTIFIER( { string_literal | session_variable | bind_variable | snowflake_scripting_variable } )
Copy
string_literal

Cadeia de caracteres que identifica o nome do objeto:

  • A cadeia de caracteres deve ser delimitada por aspas simples ('name') ou deve começar com um cifrão ($name).

  • O literal de cadeia de caracteres pode ser um nome de objeto totalmente qualificado (por exemplo, 'db_name.schema_name.object_name' ou $db_name.schema_name.object_name).

session_variable

A variável SQL que foi definida para a sessão.

bind_variable

Uma variável de vinculação, na forma de ? ou :variable, que pode ser usada por clientes/interfaces programáticas que aceitam vinculação (JDBC, ODBC, Python etc.).

snowflake_scripting_variable

Uma variável Script Snowflake que foi definida.

Notas de uso

  • Você pode usar literais e variáveis (sessão ou vinculação) em alguns casos quando for necessário identificar um objeto pelo nome (consultas, DML, DDL etc.).

  • Você pode usar variáveis de vinculação para identificadores de objeto e variáveis de vinculação para valores na mesma consulta.

  • Em uma cláusula FROM, você pode usar TABLE( { string_literal | session_variable | bind_variable | snowflake_scripting_variable } ) como sinônimo de IDENTIFIER( { string_literal | session_variable | bind_variable | snowflake_scripting_variable } ).

  • Embora IDENTIFIER(...) utilize a sintaxe de uma função, ela não é uma função verdadeira e não é retornada por comandos como SHOW FUNCTIONS.

Exemplos

Literais de cadeia de caracteres:

create or replace database identifier('my_db');

+--------------------------------------+
|                status                |
+--------------------------------------+
| Database MY_DB successfully created. |
+--------------------------------------+

create or replace schema identifier('my_schema');

+----------------------------------------+
|                 status                 |
+----------------------------------------+
| Schema MY_SCHEMA successfully created. |
+----------------------------------------+

-- case-insensitive table name specified in a string containing the fully-qualified name
create or replace table identifier('my_db.my_schema.my_table') (c1 number);

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

-- case-sensitive table name specified in a double-quoted string
create or replace table identifier('"my_table"') (c1 number);

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

show tables in schema identifier('my_schema');

+---------------------------------+----------+---------------+-------------+-------+---------+------------+------+-------+----------+----------------+
|           created_on            |   name   | database_name | schema_name | kind  | comment | cluster_by | rows | bytes |  owner   | retention_time |
+---------------------------------+----------+---------------+-------------+-------+---------+------------+------+-------+----------+----------------+
| Tue, 05 Dec 2017 12:16:18 -0800 | MY_TABLE | MY_DB         | MY_SCHEMA   | TABLE |         |            | 0    | 0     | SYSADMIN | 1              |
| Tue, 05 Dec 2017 12:16:59 -0800 | my_table | MY_DB         | MY_SCHEMA   | TABLE |         |            | 0    | 0     | SYSADMIN | 1              |
+---------------------------------+----------+---------------+-------------+-------+---------+------------+------+-------+----------+----------------+
Copy

Variáveis de sessão:

Isto mostra como usar uma variável de sessão que tem um nome de tabela ou nome de esquema:

set schema_name = 'my_db.my_schema';

set table_name = 'my_table';

use schema identifier($schema_name);

insert into identifier($table_name) values (1), (2), (3);

select * from identifier($table_name) order by 1;

+----+
| C1 |
+----+
| 1  |
| 2  |
| 3  |
+----+
Copy

Isto mostra como usar uma variável de sessão que tem um nome de função. A função é denominada speed_of_light.

CREATE FUNCTION speed_of_light() 
RETURNS INTEGER
AS
    $$
    299792458
    $$;
Copy

Chame a função pelo nome:

SELECT SPEED_OF_LIGHT();
+------------------+
| SPEED_OF_LIGHT() |
|------------------|
|        299792458 |
+------------------+
Copy

Chame a função usando a sintaxe IDENTIFIER():

SET MY_FUNCTION_NAME = 'speed_of_light';
Copy
SELECT IDENTIFIER($MY_FUNCTION_NAME)();
+---------------------------------+
| IDENTIFIER($MY_FUNCTION_NAME)() |
|---------------------------------|
|                       299792458 |
+---------------------------------+
Copy

Variáveis de vinculação:

Este exemplo mostra como vincular um nome de função em JDBC. A função é denominada speed_of_light.

String sql_command;

// Create a Statement object to use later.
System.out.println("Create JDBC statement.");
Statement statement = connection.createStatement();
System.out.println("Create function.");
sql_command = "CREATE FUNCTION speed_of_light() RETURNS INTEGER AS $$ 299792458 $$";
statement.execute(sql_command);

System.out.println("Create prepared statement.");
sql_command = "SELECT IDENTIFIER(?)()";
PreparedStatement ps = connection.prepareStatement(sql_command);
// Bind
ps.setString(1, "speed_of_light");
ResultSet rs = ps.executeQuery();
if (rs.next()) {
  System.out.println("Speed of light (m/s) = " + rs.getInt(1));
}
Copy

Os exemplos a seguir mostram uma variedade de instruções SQL que podem usar vinculação, e uma variedade de objetos de banco de dados que podem ser vinculados (incluindo nomes de esquemas e nomes de tabelas):

use schema identifier(?);

create or replace table identifier(?) (c1 number);

insert into identifier(?) values (?), (?), (?);

select t2.c1 from identifier(?) as t1, identifier(?) as t2 where t1.c1 = t2.c1 and t1.c1 > (?);

drop table identifier(?);
Copy

Variáveis Script Snowflake:

Este exemplo mostra como usar uma variável Script Snowflake para um nome de tabela em uma instrução SELECT:

BEGIN
  LET res RESULTSET := (SELECT COUNT(*) AS COUNT FROM IDENTIFIER(:table_name));
  ...
Copy