Transformation d’aplatissement dans le flux de données de mappage

S’APPLIQUE À : Azure Data Factory Azure Synapse Analytics

Conseil

Essayez Data Factory dans Microsoft Fabric, une solution d’analyse tout-en-un pour les entreprises. Microsoft Fabric couvre tous les aspects, du déplacement des données à la science des données, en passant par l’analyse en temps réel, l’aide à la décision et la création de rapports. Découvrez comment démarrer un nouvel essai gratuitement !

Les flux de données sont disponibles à la fois dans les pipelines Azure Data Factory et Azure Synapse. Cet article s’applique aux flux de données de mappage. Si vous débutez dans le domaine des transformations, consultez l’article d’introduction Transformer des données avec un flux de données de mappage.

Utilisez la transformation d’aplatissement pour prendre des valeurs de tableau à l’intérieur de structures hiérarchiques, par exemple au format JSON, et les dérouler dans des lignes individuelles. Ce processus est appelé « dénormalisation ».

Configuration

La transformation d’aplatissement contient les paramètres de configuration suivants.

Dérouler par

Sélectionnez un tableau à dérouler. Les données de sortie comporteront une ligne par élément dans chaque tableau. Si le tableau « Dérouler par » sur la ligne d’entrée est null ou vide, il y aura une ligne de sortie avec des valeurs non déroulées en tant que null. Vous pouvez dérouler plusieurs tableaux par transformation aplatie. Cliquez sur le bouton plus (+) pour inclure plusieurs tableaux dans une unique transformation aplatie. Vous pouvez utiliser des méta-fonctions de flux de données ADF ici, notamment name et type, tout en utilisant les critères spéciaux pour déployer des tableaux qui correspondent à ces critères. Lorsque vous ajoutez plusieurs tableaux à une unique transformation Flatten, vos résultats sont un produit cartésien de toutes les possibles valeurs du tableau.

Racine du déroulement

Par défaut, la transformation d’aplatissement déroule un tableau au sommet de la hiérarchie dans laquelle il existe. Vous pouvez éventuellement sélectionner un tableau comme racine de déroulement. La racine de déroulement doit être un tableau d’objets complexes qui est ou contient le tableau « Dérouler par ». Si une racine de déroulement est sélectionnée, les données de sortie contiennent au moins une ligne par élément dans la racine de déroulement. Si la ligne d’entrée n’a aucun élément dans la racine de déroulement, elle est supprimée des données de sortie. Le choix d’une racine de déroulement génère toujours un nombre de lignes inférieur ou égal au comportement par défaut.

Mappage de l’aplatissement

Comme pour la transformation de sélection, choisissez la projection de la nouvelle structure à partir des champs entrants et du tableau dénormalisé. Si un tableau dénormalisé est mappé, la colonne de sortie a le même type de données que le tableau. Si le tableau « Dérouler par » est un tableau d’objets complexes qui contient des sous-tableaux, le mappage d’un élément de ce sous-tableau génère un tableau.

Pour vérifier votre sortie de mappage, reportez-vous à l’onglet Inspection et à la vue d’ensemble des données.

Mappage basé sur des règles

La transformation d’aplatissement prend en charge le mappage basé sur des règles, ce qui vous permet de créer des transformations dynamiques et flexibles qui aplatiront les tableaux en fonction des règles, et aplatiront les structures en fonction des niveaux de la hiérarchie.

Condition de correspondance

Entrez une condition de correspondance de modèle pour la ou les colonnes que vous souhaitez aplatir en fonction de correspondances exactes ou de modèles. Exemple : like(name,'cust%')

Parcours de colonne en profondeur

Paramètre facultatif qui indique au service de gérer toutes les sous-colonnes d’un objet complexe individuellement au lieu de gérer l’objet complexe comme une colonne entière.

Niveau de hiérarchie

Choisissez le niveau de hiérarchie que vous souhaitez développer.

Correspondances de nom (regex)

Si vous le souhaitez, choisissez d’exprimer votre correspondance de nom sous forme d’expression régulière dans cette zone, au lieu d’utiliser la condition de correspondance ci-dessus.

Exemples

Reportez-vous à l’objet JSON suivant pour les exemples ci-dessous de transformation d’aplatissement.

{
  "name":"MSFT","location":"Redmond", "satellites": ["Bay Area", "Shanghai"],
  "goods": {
    "trade":true, "customers":["government", "distributer", "retail"],
    "orders":[
        {"orderId":1,"orderTotal":123.34,"shipped":{"orderItems":[{"itemName":"Laptop","itemQty":20},{"itemName":"Charger","itemQty":2}]}},
        {"orderId":2,"orderTotal":323.34,"shipped":{"orderItems":[{"itemName":"Mice","itemQty":2},{"itemName":"Keyboard","itemQty":1}]}}
    ]}}
{"name":"Company1","location":"Seattle", "satellites": ["New York"],
  "goods":{"trade":false, "customers":["store1", "store2"],
  "orders":[
      {"orderId":4,"orderTotal":123.34,"shipped":{"orderItems":[{"itemName":"Laptop","itemQty":20},{"itemName":"Charger","itemQty":3}]}},
      {"orderId":5,"orderTotal":343.24,"shipped":{"orderItems":[{"itemName":"Chair","itemQty":4},{"itemName":"Lamp","itemQty":2}]}}
    ]}}
{"name": "Company2", "location": "Bellevue",
  "goods": {"trade": true, "customers":["Bank"], "orders": [{"orderId": 4, "orderTotal": 123.34}]}}
{"name": "Company3", "location": "Kirkland"}

Aucune racine de déroulement avec tableau de chaînes

Dérouler par	Racine du déroulement	Projection
goods.customers	Aucun(e)	name customer = goods.customer

Sortie

{ 'MSFT', 'government'}
{ 'MSFT', 'distributer'}
{ 'MSFT', 'retail'}
{ 'Company1', 'store'}
{ 'Company1', 'store2'}
{ 'Company2', 'Bank'}
{ 'Company3', null}

Aucune racine de déroulement avec tableau complexe

Dérouler par	Racine du déroulement	Projection
goods.orders.shipped.orderItems	Aucun(e)	name orderId = goods.orders.orderId itemName = goods.orders.shipped.orderItems.itemName itemQty = goods.orders.shipped.orderItems.itemQty location = location

Sortie

{ 'MSFT', 1, 'Laptop', 20, 'Redmond'}
{ 'MSFT', 1, 'Charger', 2, 'Redmond'}
{ 'MSFT', 2, 'Mice', 2, 'Redmond'}
{ 'MSFT', 2, 'Keyboard', 1, 'Redmond'}
{ 'Company1', 4, 'Laptop', 20, 'Seattle'}
{ 'Company1', 4, 'Charger', 3, 'Seattle'}
{ 'Company1', 5, 'Chair', 4, 'Seattle'}
{ 'Company1', 5, 'Lamp', 2, 'Seattle'}
{ 'Company2', 4, null, null, 'Bellevue'}
{ 'Company3', null, null, null, 'Kirkland'}

Même racine que le tableau de déroulement

Dérouler par	Racine du déroulement	Projection
goods.orders	goods.orders	name goods.orders.shipped.orderItems.itemName goods.customers location

Sortie

{ 'MSFT', ['Laptop','Charger'], ['government','distributer','retail'], 'Redmond'}
{ 'MSFT', ['Mice', 'Keyboard'], ['government','distributer','retail'], 'Redmond'}
{ 'Company1', ['Laptop','Charger'], ['store', 'store2'], 'Seattle'}
{ 'Company1', ['Chair', 'Lamp'], ['store', 'store2'], 'Seattle'}
{ 'Company2', null, ['Bank'], 'Bellevue'}

Racine de déroulement avec tableau complexe

Dérouler par	Racine du déroulement	Projection
goods.orders.shipped.orderItem	goods.orders	name orderId = goods.orders.orderId itemName = goods.orders.shipped.orderItems.itemName itemQty = goods.orders.shipped.orderItems.itemQty location = location

Sortie

{ 'MSFT', 1, 'Laptop', 20, 'Redmond'}
{ 'MSFT', 1, 'Charger', 2, 'Redmond'}
{ 'MSFT', 2, 'Mice', 2, 'Redmond'}
{ 'MSFT', 2, 'Keyboard', 1, 'Redmond'}
{ 'Company1', 4, 'Laptop', 20, 'Seattle'}
{ 'Company1', 4, 'Charger', 3, 'Seattle'}
{ 'Company1', 5, 'Chair', 4, 'Seattle'}
{ 'Company1', 5, 'Lamp', 2, 'Seattle'}
{ 'Company2', 4, null, null, 'Bellevue'}

Script de flux de données

Syntaxe

<incomingStream>
foldDown(unroll(<unroll cols>),
    mapColumn(
        name,
        each(<array>(type == '<arrayDataType>')),
        each(<array>, match(true())),
        location
    )) ~> <transformationName>

Exemple

source foldDown(unroll(goods.orders.shipped.orderItems, goods.orders),
    mapColumn(
        name,
        orderId = goods.orders.orderId,
        itemName = goods.orders.shipped.orderItems.itemName,
        itemQty = goods.orders.shipped.orderItems.itemQty,
        location = location
    ),
    skipDuplicateMapInputs: false,
    skipDuplicateMapOutputs: false) 

Contenu connexe

• Utilisez la transformation Tableau croisé dynamique pour convertir des lignes en colonnes.
• Utilisez la transformation de suppression de tableau croisé dynamique pour convertir des colonnes en lignes.