# Mapper des boucles imbriquées dans une map DSQL

Mappez des éléments à partir d'une entrée contenant plusieurs boucles imbriquées.

## Avant de commencer

## Pourquoi et quand exécuter cette tâche

Dans cet exemple, vous allez créer une map DSQL pour extraire des données relatives à un magasin, à partir d'un fichier plat JSON contenant plusieurs niveaux imbriqués et écrire ces données dans une structure plate JSON.

```
{
    "name": "plusstore",
    "location": "saint louis",
    "departments": [
        {
            "name": "sports",
            "salesperson_id": 25,
            "items": [
                {
                    "name": "MBIKE",
                    "description": "27.5 inch electric mountain bike"
                },
                {
                    "name": "ESCOOT",
                    "description": "Camou electric scooter"
                }
            ]
        },
        {
            "name": "electronics",
            "salesperson_id": 32,
            "items": [
                {
                    "name": "Portable SSD T5",
                    "description": "1 TB SSD USB-C"
                },
                {
                    "name": "Extreme Portable SSD",
                    "description": "500 GB SSD USB-C"
                }
            ]
        }
    ],
    "salespersons": [
        {
            "name": "Antonio Guttierez",
            "id": 25
        },
        {
            "name": "Gina Monsanto",
            "id": 32
        }
    ]
}
```

```
{
    "items": [
        {
            "store_name": "",
            "store_location": "",
            "department_name": "",
            "salesperson_id": "",
            "salesperson_name": "",
            "item_name": ""
        }
    ]
}
```

## Procédure

1. ![Mapping des éléments.](https://help.qlik.com/talend/fr-FR/data-mapper-user-guide/Resources/images/tdm-dsql-map-editor-nested-loops-map.png)
2. Cliquez sur l'élément de sortie items et saisissez l'expression suivante pour configurer le contexte d'itération :
   ```
   FROM departments
   UNNEST items
   ```

   Cela signifie que la sortie va contenir une occurrence de items pour chaque élément items de chaque élément departments de l'entrée.
3. Mappez les éléments suivants à l'aide du glisser-déposer :
   * plusstore.name à plusstoreitems.items.store\_name
   * plusstore.location à plusstoreitems.items.store\_location
   * plusstore.departments.name à plusstoreitems.items.department\_name
   * plusstore.departments.salesperson\_id à plusstoreitems.items.salesperson\_id
   * plusstore.departments.items.name à plusstoreitems.items.item\_name

   Vous pouvez voir que, dans quasiment tous les éléments, l'expression générée est un chemin relatif simple. Cela n'est pas possible pour store\_name et department\_name car le chemin relatif name ne peut faire référence qu'à plusstore.departments.items.name à cause du contexte d'itération. Pour plus d'informations, consultez [Chemin d'élément DSQL](https://help.qlik.com/talend/fr-FR/data-mapper-user-guide/8.0/dsql-element-path).
4. Cliquez sur l'élément de sortie items et ajoutez les lignes suivantes sous l'expression existante :
   ```
   JOIN salespersons ON id = salesperson_id
   ```

   Cette clause JOIN est nécessaire pour mapper plusstore.salespersons.name à plusstoreitems.items.salesperson\_name, car l'élément d'entrée n'est pas dans le contexte d'itération courant. Cette clause modifie le contexte de boucle et si vous cliquez sur la sortie item\_name, vous pouvez voir que l'expression n'est plus un chemin relatif, elle a été remplacée par un chemin absolu.
5. Glissez-déposez plusstore.salespersons.name sur plusstoreitems.items.salesperson\_name.

   Puisque le contexte d'itération est à présent la boucle d'entrée salespersons, l'expression dans salesperson\_name est le chemin relatif name.

## Résultats

```
{
   "items":[
      {
         "store_name":"plusstore",
         "store_location":"saint louis",
         "department_name":"sports",
         "salesperson_id":"25",
         "salesperson_name":"Antonio Guttierez",
         "item_name":"MBIKE"
      },
      {
         "store_name":"plusstore",
         "store_location":"saint louis",
         "department_name":"sports",
         "salesperson_id":"25",
         "salesperson_name":"Antonio Guttierez",
         "item_name":"ESCOOT"
      },
      {
         "store_name":"plusstore",
         "store_location":"saint louis",
         "department_name":"electronics",
         "salesperson_id":"32",
         "salesperson_name":"Gina Monsanto",
         "item_name":"Portable SSD T5"
      },
      {
         "store_name":"plusstore",
         "store_location":"saint louis",
         "department_name":"electronics",
         "salesperson_id":"32",
         "salesperson_name":"Gina Monsanto",
         "item_name":"Extreme Portable SSD"
      }
   ]
}
```

Vous pouvez également consulter la vue DSQL Script (Script DSQL) pour voir à quoi ressemble le script complet. Vous pouvez voir que certains éléments utilisent des chemins relatifs et d'autres des chemins absolus :

```
FROM plusstore
SELECT {
   items = (
      FROM plusstore.departments
      UNNEST items
      JOIN salespersons ON id = salesperson_id
      SELECT {
         store_name = plusstore.name,
         store_location = location,
         department_name = plusstore.departments.name,
         salesperson_id = salesperson_id,
         salesperson_name = name,
         item_name = plusstore.departments.items.name
      }
   )
}
```