DataWorks:Configurer un nœud do-while

Prérequis

• Vous maîtrisez la personnalisation du flux de travail au sein d'un nœud do-while. Pour plus d'informations, consultez Composants de nœud et orchestration de flux de travail.

• Vous savez utiliser les variables intégrées pour obtenir les paramètres liés à la boucle au sein du nœud. Pour plus d'informations, consultez Variables intégrées.

• Vous comprenez que, dans un nœud do-while, le nœud Start marque le début d'une boucle et que le nœud End définit la logique de sortie de la boucle. Pour plus d'informations, consultez Exemple de sortie de boucle : échantillons de code du nœud End.

• Vous connaissez les précautions à prendre pour tester un nœud do-while et consulter ses journaux. Pour plus d'informations, consultez Remarques d'utilisation.

Limitations

• Le nœud do-while est disponible uniquement dans DataWorks Édition Standard et versions ultérieures. Pour plus d'informations, consultez Éditions et fonctionnalités de DataWorks.

• Un nœud do-while peut effectuer un maximum de 1 024 itérations.

• L'exécution parallèle n'est pas prise en charge. Une nouvelle itération ne peut démarrer qu'après l'achèvement de la précédente.

Créer un nœud do-while

1. Connectez-vous à la console DataWorks. Dans la région cible, cliquez sur Data Development and O&M > Data Development dans le volet de navigation de gauche. Sélectionnez un espace de travail dans la liste déroulante et cliquez sur Go to Data Development.

2. Créez un nœud do-while.

   1. Sur la page Data Studio , placez le pointeur sur l'icône et choisissez Create Node > General > do-while.

      Vous pouvez également ouvrir un flux de travail, cliquer avec le bouton droit sur General , puis sélectionner Create Node > do-while.

   2. Dans la boîte de dialogue Create Node , spécifiez le nom et le chemin d'accès du nœud.

   3. Cliquez sur OK .

Exemples

Modifier le code du nœud

Un nœud do-while contient par défaut trois nœuds : Start , Shell et End :

• Le nœud Start marque le début d'une boucle et ne remplit aucune fonction métier. Il ne peut pas être supprimé.

• Le nœud Shell est un exemple de nœud de traitement métier fourni par DataWorks.

• Le nœud End marque la fin d'une boucle et détermine s'il faut lancer l'itération suivante. Il sert à définir la condition de sortie du nœud do-while et ne peut pas être supprimé.

Vous pouvez également personnaliser le flux de travail à l'intérieur du nœud do-while en fonction de vos besoins métier en remplaçant le nœud Shell par d'autres nœuds.

1. Double-cliquez sur le nœud Shell pour ouvrir sa page d'édition.

2. Saisissez le code suivant.

   echo ${dag.loopTimes} ----Print the loop count.

   • La variable ${dag.loopTimes} est une variable réservée par le système qui représente le nombre d'itérations actuel, en commençant par 1. Les nœuds internes d'un nœud do-while peuvent référencer directement cette variable. Pour plus d'informations sur les variables intégrées, consultez Variables intégrées et Variables dépendantes du contexte .

   • Veillez à enregistrer le code après l'avoir modifié dans le nœud Shell. Aucun message ne s'affiche lorsque vous soumettez le nœud. Si vous n'enregistrez pas le code, les dernières modifications ne seront pas appliquées.

Définir la condition de sortie de la boucle

Définissez la condition de sortie afin que la boucle s'arrête après 5 itérations.

1. Double-cliquez sur le nœud End pour ouvrir sa page d'édition.

2. Dans la liste déroulante Select Language , sélectionnez Python .

3. Saisissez le code suivant pour définir la condition de sortie du nœud do-while.

   if ${dag.loopTimes}<5: 
    print True; 
   else: 
    print False;

   • La variable ${dag.loopTimes} est une variable réservée par le système qui représente le nombre d'itérations actuel, en commençant par 1. Les nœuds internes d'un nœud do-while peuvent référencer directement cette variable. Pour plus d'informations sur les variables intégrées, consultez Variables intégrées et Variables dépendantes du contexte .

   • Le code compare dag.loopTimes à 5 pour limiter le nombre total d'itérations de la boucle. Lors de la première itération, dag.loopTimes vaut 1, lors de la deuxième il vaut 2, et ainsi de suite jusqu'à la cinquième itération où il vaut 5. À ce stade, l'expression ${dag.loopTimes}<5 est évaluée à False et la boucle se termine.

Soumettre le nœud do-while

1. Cliquez sur l'icône dans la barre d'outils pour enregistrer le nœud.

2. Cliquez sur l'icône dans la barre d'outils pour soumettre le nœud.

   Lorsque vous soumettez le nœud, saisissez une Change Description dans la boîte de dialogue Submission et indiquez si vous souhaitez initier une revue de code après la soumission du nœud.

   Important

   • Vous devez configurer l'attribut Rerun attribute et les Parent Nodes avant de pouvoir soumettre le nœud.

   • La revue de code permet de garantir la qualité du code des tâches et d'éviter les erreurs causées par le déploiement direct de code non revu dans l'environnement de production. Si la revue de code est activée, le code du nœud soumis doit être approuvé par les réviseurs avant son déploiement. Pour plus d'informations, consultez Revue de code .

   Si vous utilisez un espace de travail en mode standard, vous devez cliquer sur Deploy dans le coin supérieur droit de la page d'édition du nœud pour déployer la tâche dans l'environnement de production après sa soumission. Pour plus d'informations, consultez Déployer des nœuds .

Tester et consulter les journaux d'exécution

La soumission et le déploiement d'un nœud do-while suivent le même processus que pour un nœud classique. Cependant, les tests depuis l'interface Data Studio ne sont pas pris en charge.

Lorsque DataWorks est en mode standard, vous ne pouvez pas tester directement un nœud do-while depuis l'interface Data Studio.

Pour tester et vérifier les résultats d'exécution d'un nœud do-while, vous devez soumettre et déployer la tâche contenant le nœud do-while vers Operation Center, puis exécuter la tâche du nœud do-while depuis la page Operation Center. Si vous utilisez des valeurs transmises par un nœud d'assignation à l'intérieur du nœud do-while, exécutez à la fois le nœud d'assignation et le nœud do-while ensemble lors des tests dans Operation Center.

1. Cliquez sur O&M Personnel dans le coin supérieur droit de la page pour accéder à Operation Center .

2. Dans le volet de navigation de gauche, cliquez sur Auto Triggered Task O&M > Periodic tasks .

3. Sélectionnez le nœud souhaité. Dans le DAG situé à droite, cliquez avec le bouton droit sur le nœud d'assignation et sélectionnez Retroactive Instance > Current and Descendant Nodes Retroactively .

4. Actualisez la page Data Backfill Instance . Une fois l'instance de backfill exécutée avec succès, cliquez sur DAG à côté de l'instance.

5. Consultez les journaux d'exécution du nœud do-while.

   1. Cliquez avec le bouton droit sur le nœud do-while et sélectionnez View Inner Nodes .

      Pour les nœuds composites tels que les nœuds do-while, consultez les nœuds internes pour voir les journaux d'exécution détaillés. Dans cet exemple, la boucle a été exécutée 5 fois et toutes les itérations se sont terminées avec succès.

      L'affichage de la boucle interne d'un nœud do-while comporte trois parties :

      • Le panneau de gauche affiche l'historique des réexécutions. Chaque exécution complète de l'instance do-while ajoute un enregistrement ici.

      • Le panneau central affiche la liste des enregistrements de boucle avec le nombre total d'itérations et l'état de chaque itération.

      • Le panneau de droite affiche les détails de l'itération. Cliquez sur une itération dans la liste des enregistrements de boucle pour afficher l'état d'exécution de chaque nœud dans cette itération.

   2. Sur la page des nœuds internes, cliquez sur un numéro d'itération à gauche, cliquez avec le bouton droit sur le nœud souhaité et sélectionnez View Runtime Log .

   3. Consultez les journaux d'exécution détaillés de la Nième itération.

      Sur la page des nœuds internes, cliquez sur Iteration 5 à gauche pour afficher les journaux du nœud Shell dans la 5e itération.

      Le journal d'exécution montre que, lors de la 5e itération, le nœud End a exécuté le code d'évaluation if 5 < 5: print True else: print False , et la sortie était False (Output Result: False ). La boucle s'est terminée et la tâche s'est achevée normalement.

      Le flux de travail d'un nœud do-while est le suivant :

      1. L'exécution commence à partir du nœud Start.

      2. Les tâches sont exécutées séquentiellement en fonction des relations de dépendance définies.

      3. La condition de sortie est définie dans le nœud End.

      4. Une fois qu'un ensemble de tâches est terminé, l'instruction de condition de sortie dans le nœud End est exécutée.

      5. Si l'instruction d'évaluation dans le nœud End affiche True dans les journaux, la boucle continue à partir de l'étape 1.

      6. Si l'instruction d'évaluation dans le nœud End affiche False dans les journaux, la boucle entière se termine et le nœud do-while est achevé.

Résumé

• Comparaison du nœud do-while avec les types de boucles standards :

  • Prend en charge le modèle do...while (exécuter d'abord, puis évaluer). Peut également implémenter indirectement le modèle foreach en utilisant la variable système dag.offset avec le contexte du nœud.

  • Ne prend pas en charge le modèle while, qui évalue la condition avant d'exécuter le corps de la boucle.

• Flux d'exécution d'un nœud do-while :

  1. À partir du nœud Start, les tâches du corps de la boucle sont exécutées séquentiellement en fonction des relations de dépendance définies.

  2. Le code défini par l'utilisateur dans le nœud End est exécuté.

     • Si le nœud End renvoie True, l'itération suivante commence.

     • Si le nœud End renvoie False, la boucle se termine.

• Les nœuds internes d'un nœud do-while peuvent référencer le contexte du nœud en utilisant ${dag.context variable name} .

• DataWorks fournit automatiquement deux variables système pour les nœuds internes d'un nœud do-while :

  • dag.loopTimes : Le nombre d'itérations, en commençant par 1.

  • dag.offset : Le décalage de l'itération actuelle par rapport à la première itération, en commençant par 0.