Catégories :: Fonctions de données semi-structurées et structurées (Ordre supérieur)

TRANSFORM¶

Transforme un tableau en fonction de la logique d’une expression lambda.

Voir aussi :: Utilisation de fonctions Lambda sur les données avec les fonctions d’ordre supérieur de Snowflake

Syntaxe¶

TRANSFORM( <array> , <lambda_expression> )

Arguments¶

array

Tableau contenant les éléments à transformer. Le tableau peut être semi-structuré ou structuré.

lambda_expression

Une expression Lambda qui définit la logique de transformation sur chaque élément du tableau.

L’expression lambda ne doit avoir qu’un seul argument spécifié dans la syntaxe suivante :

<arg> [ <datatype> ] -> <expr>

Renvoie¶

Le type de renvoi de cette fonction est une table semi-structurée ou structurée du résultat de l’expression lambda.

Si l’un des deux arguments est NULL, la fonction renvoie NULL sans signaler d’erreur.

Notes sur l’utilisation¶

Lorsque le type de données de l’argument lambda est explicitement spécifié, l’élément du tableau est contraint de se convertir dans le type spécifié avant l’invocation de lambda. Pour des informations sur la coercition ou contrainte de conversion, voir Conversion de type de données.
Si aucun type de données n’est spécifié pour l’argument lambda, son type de données est dérivé du tableau d’entrée comme suit :
- Si le tableau d’entrée est semi-structuré, le type de données de l’argument lambda est VARIANT.
- Si le tableau d’entrée est structuré, le type de données de l’argument lambda est le type de données de l’élément du tableau.
Pour une entrée de tableau semi-structuré, un tableau semi-structuré est renvoyé. Pour une entrée de tableau structuré, un tableau structuré du type de résultat de l’expression lambda est renvoyé.

Exemples¶

Les exemples suivants utilisent la fonction TRANSFORM.

Multiplier chaque élément d’un tableau par une valeur¶

Utilisez la fonction TRANSFORM pour multiplier chaque élément d’un tableau par deux :

SELECT TRANSFORM([1, 2, 3], a INT -> a * 2) AS "Multiply by Two";

+-----------------+
| Multiply by Two |
|-----------------|
| [               |
|   2,            |
|   4,            |
|   6             |
| ]               |
+-----------------+

Cet exemple est le même que l’exemple précédent, mais il spécifie un tableau structuré de type INT :

SELECT TRANSFORM([1, 2, 3]::ARRAY(INT), a INT -> a * 2) AS "Multiply by Two (Structured)";

+------------------------------+
| Multiply by Two (Structured) |
|------------------------------|
| [                            |
|   2,                         |
|   4,                         |
|   6                          |
| ]                            |
+------------------------------+

Renvoyer des valeurs dans un tableau avec un texte ajouté¶

Utilisez la fonction TRANSFORM pour renvoyer la valeur de chaque objet d’un tableau et ajouter un texte à chacun d’entre eux :

SELECT TRANSFORM(
    [
      {'name':'Pat', 'value': 50},
      {'name':'Terry', 'value': 75},
      {'name':'Dana', 'value': 25}
    ],
    c -> c:value || ' is the number'
  ) AS "Return Values";

+-----------------------+
| Return Values         |
|-----------------------|
| [                     |
|   "50 is the number", |
|   "75 is the number", |
|   "25 is the number"  |
| ]                     |
+-----------------------+

Transformer des éléments de tableau en données de table¶

Supposons que vous disposiez d’une table nommée orders avec les colonnes order_id, order_date et order_detail. La colonne order_detail est un tableau contenant les articles, la quantité achetée et le sous-total. La table contient deux lignes de données. L’instruction SQL suivante crée cette table et insère les lignes :

CREATE OR REPLACE TABLE orders AS
  SELECT 1 AS order_id, '2024-01-01' AS order_date, [
    {'item':'UHD Monitor', 'quantity':3, 'subtotal':1500},
    {'item':'Business Printer', 'quantity':1, 'subtotal':1200}
  ] AS order_detail
  UNION
  SELECT 2 AS order_id, '2024-01-02' AS order_date, [
    {'item':'Laptop', 'quantity':5, 'subtotal':7500},
    {'item':'Noise-canceling Headphones', 'quantity':5, 'subtotal':1000}
  ] AS order_detail;

SELECT * FROM orders;

+----------+------------+-------------------------------------------+
| ORDER_ID | ORDER_DATE | ORDER_DETAIL                              |
|----------+------------+-------------------------------------------|
|        1 | 2024-01-01 | [                                         |
|          |            |   {                                       |
|          |            |     "item": "UHD Monitor",                |
|          |            |     "quantity": 3,                        |
|          |            |     "subtotal": 1500                      |
|          |            |   },                                      |
|          |            |   {                                       |
|          |            |     "item": "Business Printer",           |
|          |            |     "quantity": 1,                        |
|          |            |     "subtotal": 1200                      |
|          |            |   }                                       |
|          |            | ]                                         |
|        2 | 2024-01-02 | [                                         |
|          |            |   {                                       |
|          |            |     "item": "Laptop",                     |
|          |            |     "quantity": 5,                        |
|          |            |     "subtotal": 7500                      |
|          |            |   },                                      |
|          |            |   {                                       |
|          |            |     "item": "Noise-canceling Headphones", |
|          |            |     "quantity": 5,                        |
|          |            |     "subtotal": 1000                      |
|          |            |   }                                       |
|          |            | ]                                         |
+----------+------------+-------------------------------------------+

Utilisez la fonction TRANSFORM pour ajouter un élément unit_price à chaque tableau de la table orders :

SELECT order_id,
       order_date,
       TRANSFORM(o.order_detail, i -> OBJECT_INSERT(
         i,
         'unit_price',
         (i:subtotal / i:quantity)::NUMERIC(10,2)
         )
       ) AS order_detail_with_unit_price
  FROM orders o;

+----------+------------+-------------------------------------------+
| ORDER_ID | ORDER_DATE | ORDER_DETAIL_WITH_UNIT_PRICE              |
|----------+------------+-------------------------------------------|
|        1 | 2024-01-01 | [                                         |
|          |            |   {                                       |
|          |            |     "item": "UHD Monitor",                |
|          |            |     "quantity": 3,                        |
|          |            |     "subtotal": 1500,                     |
|          |            |     "unit_price": 500                     |
|          |            |   },                                      |
|          |            |   {                                       |
|          |            |     "item": "Business Printer",           |
|          |            |     "quantity": 1,                        |
|          |            |     "subtotal": 1200,                     |
|          |            |     "unit_price": 1200                    |
|          |            |   }                                       |
|          |            | ]                                         |
|        2 | 2024-01-02 | [                                         |
|          |            |   {                                       |
|          |            |     "item": "Laptop",                     |
|          |            |     "quantity": 5,                        |
|          |            |     "subtotal": 7500,                     |
|          |            |     "unit_price": 1500                    |
|          |            |   },                                      |
|          |            |   {                                       |
|          |            |     "item": "Noise-canceling Headphones", |
|          |            |     "quantity": 5,                        |
|          |            |     "subtotal": 1000,                     |
|          |            |     "unit_price": 200                     |
|          |            |   }                                       |
|          |            | ]                                         |
+----------+------------+-------------------------------------------+

Utilisez la fonction TRANSFORM avec la fonction OBJECT_DELETE dans la logique de l’expression lambda pour supprimer l’élément quantity dans chaque tableau à partir du tableau orders :

SELECT order_id,
       order_date,
       TRANSFORM(o.order_detail, i -> OBJECT_DELETE(
         i,
         'quantity'
         )
       ) AS order_detail_without_quantity
  FROM orders o;

+----------+------------+-------------------------------------------+
| ORDER_ID | ORDER_DATE | ORDER_DETAIL_WITHOUT_QUANTITY             |
|----------+------------+-------------------------------------------|
|        1 | 2024-01-01 | [                                         |
|          |            |   {                                       |
|          |            |     "item": "UHD Monitor",                |
|          |            |     "subtotal": 1500                      |
|          |            |   },                                      |
|          |            |   {                                       |
|          |            |     "item": "Business Printer",           |
|          |            |     "subtotal": 1200                      |
|          |            |   }                                       |
|          |            | ]                                         |
|        2 | 2024-01-02 | [                                         |
|          |            |   {                                       |
|          |            |     "item": "Laptop",                     |
|          |            |     "subtotal": 7500                      |
|          |            |   },                                      |
|          |            |   {                                       |
|          |            |     "item": "Noise-canceling Headphones", |
|          |            |     "subtotal": 1000                      |
|          |            |   }                                       |
|          |            | ]                                         |
+----------+------------+-------------------------------------------+

Référencer une colonne de table dans une expression lambda pour transformer des éléments de tableau en données de table¶

Créez une table avec une colonne de type ARRAY et une autre colonne de type INT :

CREATE OR REPLACE TABLE transform_column_ref_demo AS
  SELECT [ 1, 2, 3 ] AS col1, 10 AS col2
  UNION
  SELECT [ 4, 5, 6 ] AS col1, -1 AS col2
  UNION
  SELECT [ 7, 8, 9 ] AS col1, NULL AS col2;

SELECT * FROM transform_column_ref_demo;

+------+------+
| COL1 | COL2 |
|------+------|
| [    |   10 |
|   1, |      |
|   2, |      |
|   3  |      |
| ]    |      |
| [    |   -1 |
|   4, |      |
|   5, |      |
|   6  |      |
| ]    |      |
| [    | NULL |
|   7, |      |
|   8, |      |
|   9  |      |
| ]    |      |
+------+------+

Utilisez la fonction TRANSFORM pour ajouter la valeur de col2 à la valeur de chaque élément du tableau dans chaque ligne :

SELECT TRANSFORM(col1, v INT -> v + col2) AS transform_col_ref
  FROM transform_column_ref_demo;

+-------------------+
| TRANSFORM_COL_REF |
|-------------------|
| [                 |
|   11,             |
|   12,             |
|   13              |
| ]                 |
| [                 |
|   3,              |
|   4,              |
|   5               |
| ]                 |
| [                 |
|   undefined,      |
|   undefined,      |
|   undefined       |
| ]                 |
+-------------------+