Catégories :

Fonctions de données semi-structurées et structurées (analyse)

PARSE_XML

Interprète une chaîne d’entrée comme un document XML, produisant une valeur OBJECT. Si l’entrée est NULL, la sortie est NULL.

Voir aussi :

CHECK_XML, TO_XML, XMLGET

Syntaxe

PARSE_XML( <string_containing_xml> [ , <disable_auto_convert> ] )
Copy
PARSE_XML( STR => <string_containing_xml>
  [ , DISABLE_AUTO_CONVERT => <disable_auto_convert> ] )
Copy

Arguments

Obligatoire :

string_containing_xml . OR . STR => string_containing_xml

Spécifiez une expression qui est évaluée sur une valeur VARCHAR qui contient des XML valides.

Facultatif :

disable_auto_convert . OR . DISABLE_AUTO_CONVERT => disable_auto_convert

Expression booléenne qui spécifie si la fonction doit ou non tenter de convertir les valeurs numériques et booléennes de string_containing_xml en types de données Snowflake. (Pour plus de détails sur cette conversion, voir Notes sur l’utilisation ci-dessous).

  • Si vous ne voulez pas que la fonction convertisse ces valeurs, vous devez donner à cet argument la valeur TRUE. Ce paramètre a un effet similaire à celui du paramètre DISABLE_AUTO_CONVERT dans CREATE FILE FORMAT.

  • Si vous souhaitez que la fonction convertisse ces valeurs, définissez cet argument sur FALSE ou omettez-le.

Par défaut : FALSE

Renvoie

Le type de données de la valeur renvoyée est OBJECT. L’OBJECT contient une représentation interne du XML.

Notes sur l’utilisation

  • Vous devez spécifier tous les arguments soit par leur nom, soit par leur position. Vous ne pouvez pas spécifier certains arguments par leur nom et d’autres par leur position.

    Lorsque vous spécifiez un argument par son nom, vous ne pouvez pas utiliser de guillemets doubles autour du nom de l’argument.

  • Le contenu de chaque élément des documents XML est du texte. PARSE_XML tente de convertir certaines données XML de texte en données natives (SQL Snowflake). Pour plus d’informations, voir Référence de types de données SQL.

    • NUMERIC et BOOLEAN :

      PARSE_XML tente de convertir des valeurs évidemment numériques et booléennes en représentation native de manière à ce que l’impression de ces valeurs donne des résultats textuellement identiques. Par exemple, lors de l’analyse des nombres décimaux, PARSE_XML tente de préserver l’exactitude de la représentation en considérant 123,45 comme NUMBER(5,2) et non comme DOUBLE. Cependant :

      • Les nombres en notation scientifique (c.-à-d. 1.2345e+02) ou ceux qui ne peuvent pas être stockés en tant que décimales à virgule fixe en raison de limitations de plage ou d’échelle sont stockés sous la forme DOUBLE.

      • Si le contenu d’un élément XML est un nombre avec des chiffres après la virgule, alors PARSE_XML peut tronquer les zéros de fin.

      Si vous ne voulez pas que la fonction effectue cette conversion, passez TRUE pour l’argument disable_auto_convert.

    • TIMESTAMP, DATE, TIME, BINARY:

      Comme le format XML ne représente pas des valeurs telles que TIMESTAMP, DATE, TIME ou BINARY de manière native, celles-ci doivent être représentées sous forme de chaînes au format XML. PARSE_XML ne reconnaît pas automatiquement ces valeurs. Elles sont conservées sous forme de chaînes, ce qui permet de convertir les valeurs des chaînes en types de données natifs SQL si nécessaire.

  • Les attributs XML sont un ensemble non classé de paires nom/valeur. La fonction PARSE_XML ne préserve pas nécessairement l’ordre. Par exemple, la conversion de texte en XML et de nouveau en texte peut entraîner une chaîne qui contient les informations d’origine dans un ordre différent.

  • Vous pouvez voir des changements dans les espaces entre les éléments lors de la conversion de chaîne en XML.

  • Lorsque PARSE_XML est utilisé pour insérer des valeurs numériques dans une colonne VARIANT qui sont un mélange d’entiers (par exemple, INT ou INTEGER) et de valeurs en notation décimale (par exemple, NUMBER ou FLOAT), la fonction peut ajouter des zéros de fin aux valeurs.

    L’exemple suivant utilise PARSE_XML pour insérer un mélange de valeurs entières et de valeurs décimales dans une colonne VARIANT :

    CREATE OR REPLACE TABLE test_xml_table(xmlcol VARIANT);

INSERT INTO test_xml_table (
  SELECT PARSE_XML($1) FROM VALUES
    ('<c>3.1</c>'),
    ('<e>2</e>'),
    ('<b>0.123</b>'));
    Copy

    Interrogez la table :

    SELECT * FROM test_xml_table;
    Copy
    +--------------+
| XMLCOL       |
|--------------|
| <c>3.100</c> |
| <e>2.000</e> |
| <b>0.123</b> |
+--------------+

    La sortie montre que des zéros de fin ont été ajoutés aux valeurs des deux premières lignes.

Exemples

L’exemple suivant montre comment utiliser la fonction PARSE_XML pour convertir une chaîne de XML en un OBJECT qui peut être inséré dans une colonne OBJECT :

CREATE OR REPLACE TABLE xtab (v OBJECT);

INSERT INTO xtab SELECT PARSE_XML(column1) AS v
  FROM VALUES ('<a/>'), ('<a attr="123">text</a>'), ('<a><b>X</b><b>Y</b></a>');

SELECT * FROM xtab;
Copy
+------------------------+
| V                      |
|------------------------|
| <a></a>                |
| <a attr="123">text</a> |
| <a>                    |
|   <b>X</b>             |
|   <b>Y</b>             |
| </a>                   |
+------------------------+

L’exemple suivant montre les différences entre l’utilisation et la désactivation de la conversion des valeurs numériques. Dans cet exemple, lorsque la conversion n’est pas désactivée, la fonction interprète un nombre en notation scientifique comme un DOUBLE.

SELECT PARSE_XML('<test>22257e111</test>'), PARSE_XML('<test>22257e111</test>', TRUE);
Copy
+-------------------------------------+-------------------------------------------+
| PARSE_XML('<TEST>22257E111</TEST>') | PARSE_XML('<TEST>22257E111</TEST>', TRUE) |
|-------------------------------------+-------------------------------------------|
| <test>2.225700000000000e+115</test> | <test>22257e111</test>                    |
+-------------------------------------+-------------------------------------------+

L’exemple suivant montre comment spécifier les arguments de la fonction par leur nom :

SELECT PARSE_XML(STR => '<test>22257e111</test>', DISABLE_AUTO_CONVERT => TRUE);
Copy
+--------------------------------------------------------------------------+
| PARSE_XML(STR => '<TEST>22257E111</TEST>', DISABLE_AUTO_CONVERT => TRUE) |
|--------------------------------------------------------------------------|
| <test>22257e111</test>                                                   |
+--------------------------------------------------------------------------+
Langage: Français