Nœud Do-while - DataWorks - Centre de documentation Alibaba Cloud

Cas d'utilisation

Dans le développement de données, le nœud do-while simplifie la conception des workflows qui doivent exécuter des tâches de manière répétée en fonction d'une condition. Parmi les cas d'utilisation courants, on retrouve :

Interrogation d'API (Polling) : Appelez une API de façon répétée jusqu'à ce qu'elle renvoie un statut spécifique, tel que SUCCESS, ou jusqu'à ce que les données de réponse correspondent à vos attentes.
Vérifications de disponibilité des données : Attendez la génération d'un fichier en amont ou d'une partition de données. La boucle vérifie la présence des données à chaque itération et se termine dès qu'elles sont disponibles, déclenchant ainsi les tâches en aval.
Traitement des données par lots : Traitez une liste d'éléments, tels que des noms de table ou des partitions de date, fournie par un nœud en amont comme un nœud d'assignation. Le nœud do-while parcourt la liste en traitant un élément à la fois jusqu'à épuisement de celle-ci.
Synchronisation des statuts : Vérifiez régulièrement le statut d'un service externe. Dès que le statut du service passe à l'état souhaité, par exemple « Available » ou « Complete », la boucle se termine et déclenche le workflow de synchronisation ou de traitement des données suivant.

Remarques importantes

Exigences de version : Disponible uniquement dans DataWorks Standard Edition et versions ultérieures.
Autorisations : Votre compte RAM doit être ajouté à l'espace de travail cible et recevoir le rôle developer ou workspace administrator. Pour plus d'informations, consultez Ajouter des membres à un espace de travail.

Fonctionnement

Le nœud do-while agit comme un conteneur de boucle basé sur un mécanisme « exécuter d'abord, vérifier ensuite ».

Nœud Start → corps de la boucle (exécuter les tâches) → Nœud End (évaluer la condition)

Démarrage et exécution : La boucle démarre au niveau du Nœud Start → corps de la boucle (exécuter les tâches) → Nœud End (évaluer la condition)
Évaluation de la condition : Une fois le corps de la boucle terminé, le Nœud End (évaluer la condition) s'exécute.
Décision de boucle :
- Si le Nœud End (évaluer la condition) renvoie True, la boucle continue.
- Si le Nœud End (évaluer la condition) renvoie False, la boucle se termine.

Fonctionnalité clé : Le corps de la boucle s'exécute toujours au moins une fois, quelle que soit la condition initiale.

Composants du nœud

Double-cliquez sur un nœud do-while pour ouvrir son canevas interne, qui se compose de trois parties principales :

Nœud Start → corps de la boucle (exécuter les tâches) → Nœud End (évaluer la condition)
Corps de la boucle : Un canevas personnalisable pour vos tâches. Cliquez sur Create Internal Node pour ajouter divers types de nœuds internes, tels que Shell, SQL et Python, afin de former le processus métier répétable.
Nœud End (évaluer la condition)

Variables intégrées

Dans le corps de la boucle et le nœud End d'un nœud do-while, vous pouvez utiliser les variables intégrées suivantes pour obtenir l'état actuel de la boucle et les données d'entrée :

Variable intégrée

Description

Variables système intégrées

${dag.loopTimes}

Le numéro d'itération actuel, commençant à 1.

${dag.offset}

Le décalage de l'itération actuelle, commençant à 0. Équivalent à ${dag.loopTimes} - 1.

Utilisé avec un nœud d'assignation (En supposant que le paramètre d'entrée input est lié à la sortie d'un nœud d'assignation en amont)

${dag.input}

Récupère l'ensemble de résultats complet transmis depuis l'amont (généralement un tableau bidimensionnel).

${dag.input.length}

Récupère le nombre de lignes dans l'ensemble de résultats (le nombre total d'éléments).

${dag.input[${dag.offset}]}

Récupère la ligne de données traitée lors de l'itération actuelle. Le format de retour est une chaîne séparée par des virgules (par exemple, "user_A,beijing").

${dag.input[i][j]}

(Uniquement pour les tableaux bidimensionnels) Récupère la valeur exacte à la ligne i, colonne j (les index commencent à 0).

Exemple : ${dag.input[0][1]} extrait la valeur "beijing" de la première ligne et de la deuxième colonne.

Remarques

Exigence d'édition : Cette fonctionnalité est disponible uniquement dans DataWorks Standard Edition et versions supérieures.
Limite de boucle : Le nombre maximal d'itérations par défaut est de 128. Le maximum configurable est de 1024. Le dépassement de cette limite entraîne l'échec de la tâche.
Mécanisme d'exécution : Le nœud do-while utilise un mode d'exécution sériel et ne prend pas en charge le traitement concurrent. Chaque itération doit se terminer avant que la suivante ne commence.
Limitation de débogage : Vous ne pouvez pas exécuter directement un test sur la page Data Studio. Vous devez d'abord déployer le workflow, puis utiliser la fonctionnalité backfill data dans Operation Center pour vérifier la tâche.
Propagation des dépendances : Si le nœud do-while dépend d'un nœud d'assignation en amont, assurez-vous de démarrer le backfill depuis le nœud en amont pour garantir l'intégrité du pipeline de données.
Contrôle de flux : Si vous utilisez un nœud Branch à l'intérieur du corps de la boucle, assurez-vous que tous les chemins de branche convergent finalement vers un nœud Merge afin d'éviter de rompre le workflow.

Procédure : Créer une tâche de boucle simple

Cet exemple vous guide dans la création d'une tâche qui effectue 5 boucles et affiche le numéro d'itération actuel à chaque tour.

Étape 1 : Configurer le corps de la boucle (ajouter un nœud Shell)

Créez un nœud do-while dans votre workflow.
Double-cliquez sur le nœud pour accéder à son canevas interne. Dans la zone du corps de la boucle, cliquez sur Create Internal Node, sélectionnez Shell et nommez-le print_loop_times.
Cliquez avec le bouton droit sur le nœud et sélectionnez Open Node.

Saisissez la commande suivante dans l'éditeur de code :

# Use the built-in variable ${dag.loopTimes} to get the current loop count
echo "This is loop number: ${dag.loopTimes}"

Cliquez sur l'icône d'enregistrement pour sauvegarder le nœud.

Étape 2 : Définir la condition de sortie

Revenez au canevas interne du do-while, cliquez avec le bouton droit sur le Nœud End (évaluer la condition).
Basculez la langue vers Python.

Saisissez le code Python suivant :

# When the loop count is less than 5, output True and continue looping
# When the loop count reaches 5, output False and exit the loop
if ${dag.loopTimes} < 5:
    print True
else:
    print False

Enregistrez le nœud End.

Étape 3 : Déployer, exécuter et vérifier

Revenez au canevas principal du workflow et cliquez sur Deploy dans la barre d'outils pour déployer l'ensemble du workflow.
Accédez à Operation Center et localisez le nœud do-while.
Cliquez avec le bouton droit sur le nœud et choisissez Backfill Data > Current Node pour démarrer un test.
Une fois l'instance exécutée avec succès, cliquez à nouveau avec le bouton droit sur le nœud et sélectionnez View Internal Nodes.
Consultez les cinq itérations de la boucle. Développez n'importe quelle itération (par exemple, la 5e), cliquez avec le bouton droit sur l'instance print_loop_times à l'intérieur, et sélectionnez View Runtime Log. Vous devriez voir la sortie suivante :
```
This is loop number: 5
```

Utilisation avancée : Traiter une liste de données avec un nœud d'assignation

Il s'agit d'un scénario courant et pratique : utiliser un nœud do-while pour itérer et traiter un jeu de données produit par un nœud d'assignation en amont. Dans cet exemple, un nœud d'assignation ODPS SQL en amont interroge deux lignes d'informations utilisateur, et le nœud do-while traite chaque ligne.

Étape 1 : Configurer le nœud d'assignation en amont

Créez un nœud d'assignation (par exemple, nommé assign_sql_data) et définissez-le comme prédécesseur du nœud do-while.

Utilisez ODPS SQL pour interroger les données dans le nœud :

SELECT 'user_A', 'beijing'
UNION ALL
SELECT 'user_B', 'shanghai';

Enregistrez le nœud. Son paramètre outputs générera un tableau bidimensionnel contenant deux lignes de données.

Étape 2 : Configurer le nœud do-while pour consommer les données

Dans le panneau Schedule Settings situé à droite du nœud do-while, recherchez Input Parameters of This Node.
Cliquez sur Add et configurez le paramètre suivant :
- Parameter Name : input (personnalisable)
- Value Source : Sélectionnez assign_sql_data.outputs
Dans le corps de la boucle du nœud do-while, créez un nœud Shell et saisissez le script suivant pour traiter la ligne actuelle :
```
# Get the data row being processed in the current loop iteration
echo "Processing data row: ${dag.input[${dag.offset}]}"
```

Ouvrez le Nœud End (évaluer la condition) et configurez la logique de sortie :

# If the number of times executed is less than the total number of data rows, continue looping
if ${dag.loopTimes} < ${dag.input.length}:
    print True
else:
    print False

Déployez le workflow et, dans Operation Center, démarrez le backfill depuis le nœud assign_sql_data pour garantir que les données circulent correctement dans la boucle.

Après une exécution réussie, vous pouvez constater dans les journaux que les deux itérations ont traité respectivement "user_A,beijing" et "user_B,shanghai".

Annexe : Comparaison entre les nœuds do-while et for-each

Fonctionnalité

Nœud Do-while

Nœud For-each

Logique principale

Piloté par condition : Répète l'exécution jusqu'à ce qu'une condition ne soit plus satisfaite.

Piloté par les données : S'exécute une fois pour chaque élément de la liste d'entrée.

Nombre d'itérations

Indéterminé ; dépend du moment où la condition est satisfaite.

Déterminé ; égal au nombre d'éléments dans la liste d'entrée.

Garantie d'exécution

S'exécute au moins une fois (même si la condition initiale n'est déjà pas satisfaite).

Si l'entrée est vide, aucune exécution n'a lieu.

Cas d'utilisation

Polling, attente, vérifications de statut et traitement par lots jusqu'à épuisement de la source.

Traitement par lots d'une liste connue (comme la synchronisation d'un ensemble de tables ou le traitement de plusieurs partitions).

Méthode de contrôle

Contrôlé par la sortie du nœud End renvoyant True / False pour déterminer si la boucle continue.

Se termine automatiquement après le parcours de tous les éléments.