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().

Die Verwendung von IDENTIFIER() zur Identifizierung von Datenbankobjekten ist eine bewährte Methode, da sie die Wiederverwendbarkeit des Codes erhöht und hilft, das Risiko der Einschleusung von SQL-Befehlen zu vermeiden.

Syntax¶

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

Copy

string_literal

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. 'db_name.schema_name.object_name' oder $db_name.schema_name.object_name).

session_variable

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

bind_variable

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¶

Die folgenden Beispiele verwenden IDENTIFIER().

Verwenden von IDENTIFIER() mit Zeichenfolgen-Literalen¶

Diese Beispiele zeigen, wie Sie auf ein Objekt verweisen, wenn ein Zeichenfolgenliteral den Bezeichner des Objekts enthält.

Erstellen Sie eine Datenbank:

CREATE OR REPLACE DATABASE IDENTIFIER('my_db');

Copy

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

Schema erstellen

CREATE OR REPLACE SCHEMA IDENTIFIER('my_schema');

Copy

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

Erstellen Sie eine Tabelle mit einem Tabellennamen ohne Berücksichtigung der Groß- und Kleinschreibung, der in einer Zeichenfolge angegeben ist, die den vollqualifizierten Namen enthält:

CREATE OR REPLACE TABLE IDENTIFIER('my_db.my_schema.my_table') (c1 number);

Copy

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

Erstellen Sie eine Tabelle mit einem zwischen Groß- und Kleinschreibung unterscheidenden Tabellennamen, der in einer Zeichenfolge mit doppelten Anführungszeichen angegeben ist:

CREATE OR REPLACE TABLE IDENTIFIER('"my_table"') (c1 number);

Copy

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

Zeigen Sie die Tabellen in einem Schema an:

SHOW TABLES IN SCHEMA IDENTIFIER('my_schema');

Copy

+-------------------------------+----------+---------------+-------------+-------+---------+---------+
| created_on                    | name     | database_name | schema_name | kind  | comment | ...     |
|-------------------------------+----------+---------------+-------------+-------+---------+---------|
| 2024-07-03 08:55:11.992 -0700 | MY_TABLE | MY_DB         | MY_SCHEMA   | TABLE |         | ...     |
| 2024-07-03 08:56:00.604 -0700 | my_table | MY_DB         | MY_SCHEMA   | TABLE |         | ...     |
+-------------------------------+----------+---------------+-------------+-------+---------+---------+

Verwenden von IDENTIFIER() mit Sitzungsvariablen¶

Diese Beispiele zeigen, wie Sie eine Sitzungsvariable verwenden, die einen Tabellen- oder Schemanamen hat.

Legen Sie eine Sitzungsvariable für einen Schemanamen fest:

SET schema_name = 'my_db.my_schema';

Copy

Legen Sie eine Sitzungsvariable für einen Tabellennamen fest:

SET table_name = 'my_table';

Copy

Geben Sie das Schema für die aktuelle Sitzung an:

USE SCHEMA IDENTIFIER($schema_name);

Copy

Werte in eine Tabelle einzufügen:

INSERT INTO IDENTIFIER($table_name) VALUES (1), (2), (3);

Copy

Eine Tabelle abfragen:

SELECT * FROM IDENTIFIER($table_name) ORDER BY 1;

Copy

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

Dieses Beispiel zeigt, wie Sie eine Sitzungsvariable verwenden, die einen Funktionsnamen hat.

Erstellen Sie die Funktion speed_of_light:

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

Copy

Rufen Sie die Funktion beim Namen auf:

SELECT speed_of_light();

Copy

+------------------+
| SPEED_OF_LIGHT() |
|------------------|
|        299792458 |
+------------------+

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

SET my_function_name = 'speed_of_light';

Copy

SELECT IDENTIFIER($my_function_name)();

Copy

+---------------------------------+
| IDENTIFIER($MY_FUNCTION_NAME)() |
|---------------------------------|
|                       299792458 |
+---------------------------------+

IDENTIFIER() mit gebundenen Variablen verwenden¶

In diesen Beispielen wird die Verwendung Bindungsvariablen für die Identifizierung von Objekten veranschaulicht.

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));
}

Copy

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

Copy

IDENTIFIER() mit Snowflake Scripting Variablen verwenden¶

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));
  ...

Copy