Catégories :: Fonctions de table

TO_QUERY¶

Renvoie un jeu de résultats basé sur du texte SQL et un ensemble facultatif d’arguments qui sont passés au texte SQL s’il est paramétré. La fonction compile le texte SQL comme définition d’une sous-requête dans la clause FROM. Lors de l’écriture d’une application ou d’une procédure stockée, vous pouvez appeler cette fonction pour construire une instruction SQL.

Note

Cette fonction peut inclure la saisie de l’utilisateur dans les instructions de requête, ce qui présente des risques de sécurité potentiels, tels que l’injection SQL. Si les entrées de la fonction proviennent de sources externes, assurez-vous qu’elles sont validées. Pour plus d’informations, voir injection SQL.

Voir aussi ::: Construction d’instructions SQL au moment de l’exécution

Syntaxe¶

TO_QUERY( SQL => '<string>' [ , <arg> => '<value>' [, <arg> => '<value>' ...] ] )

Arguments¶

Nécessaire

SQL => 'string': Représentation sous forme de chaîne de la sous-requête.

Facultatif

arg => 'value': Variables de liaison transmises à la string SQL.

Renvoie¶

Renvoie le jeu de résultats produit par l’exécution du texte SQL spécifié ou NULL. Si l’un des deux arguments est NULL, la fonction renvoie NULL sans signaler d’erreur.

Notes sur l’utilisation¶

Tous les arguments doivent être l’un des suivants :
- Chaînes constantes.
- Variables SQL ou Variables Snowflake Scripting qui se résolvent en chaînes.
Si vous devez convertir une chaîne passée dans un argument en un type de données différent, vous pouvez utiliser une fonction de conversion dans la string SQL pour convertir la chaîne en un autre type de données.
L’ensemble des colonnes définissant le jeu de résultats est dérivé de la liste SELECT des instructions SQL compilées.
La fonction n’est valide que dans la clause FROM d’une instruction SQL.

Exemples¶

Créez une table et insérez-y des données.

CREATE OR REPLACE TABLE to_query_example (
  deptno NUMBER(2),
  dname  VARCHAR(14),
  loc    VARCHAR(13))
AS SELECT
  column1,
  column2,
  column3
FROM
  VALUES
    (10, 'ACCOUNTING', 'NEW YORK'),
    (20, 'RESEARCH',   'DALLAS'  ),
    (30, 'SALES',      'CHICAGO' ),
    (40, 'OPERATIONS', 'BOSTON'  );

Les exemples utilisent les données de cette table.

Utilisation de TO_QUERY dans les instructions SQL¶

Tout d’abord, définissez une variable de session (variable SQL) pour le nom de la table :

SET table_name = 'to_query_example';

Les exemples utilisent la variable de session et IDENTIFIER() pour identifier la table.

Utiliser IDENTIFIER() pour identifier les objets de base de données est une bonne pratique car cela peut rendre le code plus réutilisable et aider à prévenir les risques d”injection SQL.

L’exemple suivant utilise la fonction TO_QUERY pour renvoyer toutes les données dans la table to_query_example :

SELECT * FROM TABLE(TO_QUERY('SELECT * FROM IDENTIFIER($table_name)'));

+--------+------------+----------+
| DEPTNO | DNAME      | LOC      |
|--------+------------+----------|
|     10 | ACCOUNTING | NEW YORK |
|     20 | RESEARCH   | DALLAS   |
|     30 | SALES      | CHICAGO  |
|     40 | OPERATIONS | BOSTON   |
+--------+------------+----------+

L’exemple suivant utilise la fonction TO_QUERY pour renvoyer toutes les valeurs dans la colonne deptno de la table to_query_example :

SELECT deptno FROM TABLE(TO_QUERY('SELECT * FROM IDENTIFIER($table_name)'));

+--------+
| DEPTNO |
|--------|
|     10 |
|     20 |
|     30 |
|     40 |
+--------+

L’exemple suivant utilise la fonction TO_QUERY pour passer un argument à une instruction SQL afin qu’elle renvoie la ligne où deptno est égal à 10 dans la table to_query_example :

SELECT * FROM TABLE(
  TO_QUERY(
    'SELECT * FROM IDENTIFIER($table_name)
    WHERE deptno = TO_NUMBER(:dno)', dno => '10'
    )
  );

+--------+------------+----------+
| DEPTNO | DNAME      | LOC      |
|--------+------------+----------|
|     10 | ACCOUNTING | NEW YORK |
+--------+------------+----------+

L’exemple suivant est le même que l’exemple précédent, mais il utilise une variable de session pour passer la valeur deptno à la fonction TO_QUERY :

SET dept = '10';

SELECT * FROM TABLE(
  TO_QUERY(
    'SELECT * FROM IDENTIFIER($table_name)
    WHERE deptno = TO_NUMBER(:dno)', dno => $dept
    )
  );

+--------+------------+----------+
| DEPTNO | DNAME      | LOC      |
|--------+------------+----------|
|     10 | ACCOUNTING | NEW YORK |
+--------+------------+----------+

L’exemple suivant utilise la fonction TO_QUERY pour passer deux arguments à une instruction SQL afin qu’elle renvoie les lignes où deptno est égal à 10 ou dname est égal à SALES dans la table to_query_example :

SELECT * FROM TABLE(
  TO_QUERY(
    'SELECT * FROM IDENTIFIER($table_name)
    WHERE deptno = TO_NUMBER(:dno) OR dname = :dnm',
    dno => '10', dnm => 'SALES'
    )
  );

+--------+------------+----------+
| DEPTNO | DNAME      | LOC      |
|--------+------------+----------|
|     10 | ACCOUNTING | NEW YORK |
|     30 | SALES      | CHICAGO  |
+--------+------------+----------+

Utilisation de TO_QUERY dans les procédures stockées¶

L’exemple suivant utilise la fonction TO_QUERY dans une procédure stockée :

CREATE OR REPLACE PROCEDURE get_num_results_tq(query VARCHAR)
RETURNS TABLE ()
LANGUAGE SQL
AS
DECLARE
  res RESULTSET DEFAULT (SELECT COUNT(*) FROM TABLE(TO_QUERY(:query)));
BEGIN
  RETURN TABLE(res);
END;

Note: If you use Snowflake CLI, SnowSQL, the Classic Console, or the execute_stream or execute_string method in Python Connector code, use this example instead (see Using Snowflake Scripting in Snowflake CLI, SnowSQL, and Python Connector):

CREATE OR REPLACE PROCEDURE get_num_results_tq(query VARCHAR)
RETURNS TABLE ()
LANGUAGE SQL
AS
$$
DECLARE
  res RESULTSET DEFAULT (SELECT COUNT(*) FROM TABLE(TO_QUERY(:query)));
BEGIN
  RETURN TABLE(res);
END;
$$
;

Appelez la procédure stockée :

CALL get_num_results_tq('SELECT * FROM to_query_example');

+----------+
| COUNT(*) |
|----------|
|        4 |
+----------+

CALL get_num_results_tq('SELECT * FROM to_query_example WHERE deptno = 20');

+----------+
| COUNT(*) |
|----------|
|        1 |
+----------+

L’exemple suivant utilise la fonction TO_QUERY dans une procédure stockée avec une variable de liaison :

CREATE OR REPLACE PROCEDURE get_results_tqbnd(dno VARCHAR)
RETURNS TABLE ()
LANGUAGE SQL
AS
DECLARE
  res RESULTSET DEFAULT (SELECT * FROM TABLE(
    TO_QUERY(
      'SELECT * FROM to_query_example
      WHERE deptno = TO_NUMBER(:dnoval)', dnoval => :dno
    )
  ));
BEGIN
  RETURN TABLE(res);
END;

CREATE OR REPLACE PROCEDURE get_results_tqbnd(dno VARCHAR)
RETURNS TABLE ()
LANGUAGE SQL
AS
$$
DECLARE
  res RESULTSET DEFAULT (SELECT * FROM TABLE(
    TO_QUERY(
      'SELECT * FROM to_query_example
      WHERE deptno = TO_NUMBER(:dnoval)', dnoval => :dno
    )
  ));
BEGIN
  RETURN TABLE(res);
END;
$$
;

Appelez la procédure stockée :

CALL get_results_tqbnd('40');

+--------+------------+--------+
| DEPTNO | DNAME      | LOC    |
|--------+------------+--------|
|     40 | OPERATIONS | BOSTON |
+--------+------------+--------+

Appelez la procédure stockée à l’aide d’une variable de session :

SET dept = '20';

CALL get_results_tqbnd($dept);

+--------+----------+--------+
| DEPTNO | DNAME    | LOC    |
|--------+----------+--------|
|     20 | RESEARCH | DALLAS |
+--------+----------+--------+