Les littéraux et les variables comme identificateurs

Dans les instructions SQL Snowflake, en plus de faire référence aux objets par leur nom (voir Exigences relatives à l’identificateur), vous pouvez également utiliser un littéral de chaîne, une variable de session, une variable de liaison ou une variable Exécution de scripts Snowflake pour faire référence à un objet. Par exemple, vous pouvez utiliser une variable de session définie comme le nom d’une table dans la clause FROM d’une instruction SELECT.

Pour utiliser un nom d’objet spécifié dans un littéral ou une variable, utilisez IDENTIFIER().

Syntaxe

IDENTIFIER( { string_literal | session_variable | bind_variable | snowflake_scripting_variable } )
litéral_chaine

Chaîne identifiant le nom de l’objet :

  • La chaîne doit être délimitée par des guillemets simples ('nom') ou commencer par un signe dollar ($nom).

  • Le littéral de chaîne peut être un nom d’objet complet (par exemple 'nom_bd.nom_schéma.nom_objet' ou $nom_bd.nom_schéma.nom_objet).

variable_session

Une variable SQL qui a été définie pour la session.

variable_liaison

Variable de liaison, sous la forme de ? ou :variable, qui peut être utilisée par des interfaces client/programme qui prennent en charge la liaison (JDBC, ODBC, Python, etc.).

variable_exécution_de_scripts_snowflake

Variable Exécution de scripts Snowflake qui a été définie.

Notes sur l’utilisation

  • Vous pouvez utiliser des littéraux et des variables (session ou liaison) dans certains cas lorsque vous devez identifier un objet par son nom (requêtes, DML, DDL, etc.).

  • Vous pouvez utiliser des variables de liaison pour des identificateurs d’objets et des variables de liaison pour les valeurs dans la même requête.

  • Dans une clause FROM vous pouvez utiliser TABLE( { string_literal | session_variable | bind_variable | snowflake_scripting_variable } ) comme synonyme de IDENTIFIER( { string_literal | session_variable | bind_variable | snowflake_scripting_variable } ).

  • Bien que IDENTIFIER(...) utilise la syntaxe d’une fonction, il ne s’agit pas d’une vraie fonction. Des commandes telles que SHOW FUNCTIONS ne le renvoie pas.

Exemples

Littéraux de chaînes :

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

Variables de session :

Cela montre comment utiliser une variable de session qui a un nom de table ou un nom de schéma :

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

Cela montre comment utiliser une variable de session qui a un nom de fonction. La fonction s’appelle speed_of_light.

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

Appelez la fonction par son nom :

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

Appelez la fonction en utilisant la syntaxe IDENTIFIER() :

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

Variables de liaison :

Cet exemple montre comment lier un nom de fonction dans JDBC. La fonction s’appelle 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));
}

Les exemples suivants présentent une variété d’instructions SQL qui peuvent utiliser la liaison et une variété d’objets de base de données qui peuvent être liés (y compris les noms de schéma et de table) :

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(?);

Variables Exécution de scripts Snowflake :

Cet exemple montre comment utiliser une variable Exécution de scripts Snowflake pour un nom de table dans une instruction SELECT :

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