Literale und Variablen als Bezeichner mit IDENTIFIER()-Syntax

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 die Syntax IDENTIFIER().

Die Verwendung von IDENTIFIER() zur Identifizierung von Datenbankobjekten ist eine bewährte Methode, da sie die Wiederverwendbarkeit des Codes erhöht und dazu beiträgt, das Risiko einer SQL-Injektion zu vermeiden.

Syntax

IDENTIFIER( { string_literal | session_variable | bind_variable | snowflake_scripting_variable } )
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 die Syntax IDENTIFIER().

Verwendung der IDENTIFIER()-Syntax mit Zeichenfolgenliteralen

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

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

Schema erstellen

CREATE OR REPLACE SCHEMA IDENTIFIER('my_schema');

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

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

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

Zeigen Sie die Tabellen in einem Schema an:

SHOW TABLES IN SCHEMA IDENTIFIER('my_schema');

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

Verwendung der IDENTIFIER()-Syntax 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';

Legen Sie eine Sitzungsvariable für einen Tabellennamen fest:

SET table_name = 'my_table';

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

USE SCHEMA IDENTIFIER($schema_name);

Werte in eine Tabelle einzufügen:

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

Eine Tabelle abfragen:

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

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

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

  1. Erstellen Sie die Funktion speed_of_light:

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

  2. Rufen Sie die Funktion beim Namen auf:

    SELECT speed_of_light();

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

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

Verwendung der IDENTIFIER()-Syntax mit Bindungsvariablen

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

Dieses Beispiel zeigt Ihnen, wie Sie einen Funktionsnamen in JDBC binden. 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(?);

Verwendung der IDENTIFIER()-Syntax mit 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));
  ...