Literale und Variablen als Bezeichner

In Snowflake-SQL-Anweisungen können Sie nicht nur über den Namen auf Objekte verweisen (siehe Anforderungen an Bezeichner), sondern auch ein Zeichenfolgenliteral, eine Sitzungsvariable, eine Bindungsvariable oder eine Snowflake Scripting-Variable verwenden, um auf ein Objekt zu verweisen. Sie können zum Beispiel eine Sitzungsvariable verwenden, die in der FROM-Klausel einer SELECT-Anweisung auf den Namen einer Tabelle gesetzt wird.

Um einen in einem Literal oder einer Variablen angegebenen Objektnamen zu verwenden, verwenden Sie IDENTIFIER().

Syntax

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

Zeichenfolge, die den Namen des Objekts identifiziert:

  • Die Zeichenfolge muss entweder in einfache Anführungszeichen ('Name') eingeschlossen sein oder mit einem Dollarzeichen ($Name) beginnen.

  • Das Zeichenfolgenliteral kann ein vollständig qualifizierter Objektname sein (z. B. 'Datenbankname.Schemaname.Objektname' oder $Datenbankname.Schemaname.Objektname).

Sitzungsvariable

Eine SQL-Variable, die für die Sitzung festgelegt wurde.

Bindungsvariable

Eine Bindungsvariable in Form von ? oder :Variable, die von Clients oder Programmierschnittstellen verwendet werden kann, die Bindungen unterstützen (JDBC, ODBC, Python usw.).

Snowflake_Scripting-Variable

Eine Snowflake Scripting-Variable, die festgelegt wurde.

Nutzungshinweise

  • Sie können Literale und Variablen (Sitzung oder Bindung) in einigen Fällen verwenden, wenn Sie ein Objekt durch einen Namen identifizieren müssen (Abfragen, DML, DDL, usw.).

  • Sie können Bindungsvariablen für Objektbezeichner und Bindungsvariablen für Werte in derselben Abfrage verwenden.

  • In einer FROM-Klausel können Sie TABLE( { string_literal | session_variable | bind_variable | snowflake_scripting_variable } ) als Synonym für IDENTIFIER( { string_literal | session_variable | bind_variable | snowflake_scripting_variable } ) verwenden.

  • Obwohl IDENTIFIER(...) die Syntax einer Funktion verwendet, handelt es sich nicht um eine echte Funktion und wird nicht von Befehlen wie SHOW FUNCTIONS zurückgegeben.

Beispiele

Zeichenfolgenliterale:

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

Sitzungsvariablen:

Hier wird gezeigt, wie eine Sitzungsvariable mit einem Tabellennamen oder Schemanamen verwendet wird:

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

Hier wird gezeigt, wie eine Sitzungsvariable mit einem Funktionsnamen verwendet wird. Die Funktion heißt speed_of_light.

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

Rufen Sie die Funktion beim Namen auf:

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

Rufen Sie die Funktion mit der IDENTIFIER()-Syntax auf:

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

Bindungsvariablen:

Dieses Beispiel zeigt, wie ein Funktionsname in JDBC gebunden wird. Die Funktion heißt 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));
}

Die folgenden Beispiele zeigen eine Vielzahl von SQL-Anweisungen, die eine Bindung verwenden können, und eine Vielzahl von Datenbankobjekten, die gebunden werden können (einschließlich Schemanamen und Tabellennamen):

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

Snowflake Scripting-Variablen:

Das folgende Beispiel zeigt, wie Sie eine Snowflake Scripting-Variable für einen Tabellennamen in einer SELECT-Anweisung verwenden:

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