Accéder aux noms des nœuds
Lorsqu'un nœud d'un composant XML possède des nœuds enfants, vous pouvez récupérer à la fois le nom et la valeur de chaque nœud enfant directement dans le mappage. Cette technique est appelée « noms de nœuds dynamiques ». Le terme « dynamique » fait référence au fait que le traitement s'effectue « à la volée », pendant l'exécution du mappage, et ne repose pas sur les informations statiques du schéma connues avant le lancement du mappage. Cette rubrique fournit des détails sur la manière d’activer l’accès dynamique aux noms de nœuds et sur ce que vous pouvez en faire.
Lorsque vous lisez des données à partir d’une source, les « noms de nœuds dynamiques » vous permettent d’effectuer les opérations suivantes :
•Obtenir une liste de tous les nœuds enfants (ou attributs) d’un nœud, sous forme de séquence. Dans MapForce, une « séquence » est une liste contenant zéro ou plusieurs éléments que vous pouvez connecter à une cible et créer autant d’éléments dans la cible qu’il y en a dans la source. Ainsi, par exemple, si un nœud comporte cinq attributs dans la source, vous pouvez créer cinq nouveaux éléments dans la cible, chacun correspondant à un attribut.
•Vous pouvez lire non seulement les valeurs des nœuds enfants (comme le fait un mappage standard), mais également leurs noms.
Lorsque vous écrivez des données dans une cible, les « noms de nœuds dynamiques » vous permettent d’effectuer les opérations suivantes :
•Créer de nouveaux nœuds à l’aide de noms fournis par le mappage (appelés noms « dynamiques »), par opposition aux noms fournis par les paramètres du composant (appelés noms « statiques »).
Pour illustrer les noms de nœuds dynamiques, cette rubrique utilise le schéma XML suivant : <Documents>\Altova\MapForce2027\MapForceExamples\DocExamples\Products.xsd. Ce schéma est accompagné d’un exemple de document d’instance, Products.xml. Pour ajouter à la fois le schéma et le fichier d’instance à la zone de mappage, sélectionnez la commande de menu Insérer | Fichier/schéma XML, puis recherchez <Documents>\Altova\MapForce2027\MapForceExamples\DocExamples\Products.xml. Lorsque vous êtes invité à sélectionner un élément racine, choisissez products.
Pour activer les noms de nœuds dynamiques pour le nœud product, cliquez dessus avec le bouton droit de la souris et sélectionnez l’une des commandes suivantes du menu contextuel :
•Afficher attributs avec nom dynamique, si vous souhaitez accéder aux attributs du nœud
•Afficher éléments enfant générique avec nom dynamique, si vous souhaitez accéder aux éléments enfants du nœud
Fig. 1 Activation des noms de nœuds dynamiques (pour les éléments enfants)
Note : les commandes ci-dessus ne sont disponibles que pour les nœuds comportant des nœuds enfants. De plus, ces commandes ne sont pas disponibles pour les nœuds racines.
Lorsque vous passez un nœud en mode dynamique, un dialogue similaire à celui ci-dessous s’affiche. Dans le cadre de cette rubrique, configurez les options comme indiqué ci-dessous ; ces options sont abordées plus en détail dans la section Accéder aux nœuds d’un type spécifique.
Fig. 2 Dialogue « Paramètres enfants nommés dynamiquement »
La fig. 3 illustre l’apparence du composant lorsque les noms de nœuds dynamiques sont activés pour le nœud product. Remarquez à quel point l’apparence du composant a désormais considérablement changé.
Fig.3 Noms de nœuds dynamiques activés (pour les éléments)
Pour ramener le composant en mode standard, cliquez avec le bouton droit sur le nœud product et désactivez l’option Afficher éléments enfant générique avec nom dynamique dans le menu contextuel.
L’image ci-dessous montre l’apparence du même composant lorsque l’accès dynamique aux attributs d’un nœud est activé. Ce composant a été obtenu en cliquant avec le bouton droit sur l’élément product, puis en sélectionnant Afficher attributs avec nom dynamique dans le menu contextuel.
Fig. 4 Noms de nœuds dynamiques activés (pour les attributs)
Pour ramener le composant en mode standard, cliquez avec le bouton droit sur le nœud product et désactivez l’option Afficher attributs avec nom dynamique dans le menu contextuel.
Comme l’illustrent les fig. 3 et 4, le composant change d’apparence lorsqu’un nœud quelconque (dans ce cas, product) passe en mode « nom de nœud dynamique ». Cette nouvelle apparence ouvre la voie aux actions suivantes :
•Lire ou écrire la liste de tous les éléments enfants ou attributs d’un nœud. Ces opérations sont respectivement fournies par les éléments element() et attribute().
•Lire ou écrire le nom de chaque élément ou attribut enfant. Ce nom est fourni par les éléments node-name() et local-name().
•Dans le cas des éléments, lire ou écrire la valeur de chaque élément enfant, sous la forme d’un type de données spécifique. Cette valeur est fournie par le nœud de conversion de type (dans ce cas, l’élément text()). Notez que seuls les éléments peuvent comporter des nœuds de conversion de type. Les attributs sont toujours traités comme étant de type « chaîne ».
•Regrouper ou filtrer les éléments enfants par nom.
Les types de nœuds avec lesquels vous pouvez travailler en mode « nom de nœud dynamique » sont décrits ci-dessous.
element()
Ce nœud présente un comportement différent dans un composant source par rapport à un composant cible. Dans un composant source, il fournit les éléments enfants du nœud sous forme de séquence. Dans la fig. 3, element() fournit une liste (séquence) de tous les éléments enfants de product. Par exemple, la séquence créée à partir du code XML suivant contiendrait trois éléments (puisqu’il y a trois éléments enfants de product) :
<product> <id>1</id> <color>red</color> <size>10</size> </product> |
Notez que le nom et le type réels de chaque élément de la séquence sont fournis respectivement par le nœud node-name() et le nœud type cast (voir ci-dessous). Pour mieux comprendre cela, imaginez que vous deviez transformer les données d’un XML source en un XML cible comme suit :
Fig. 6 Mappage des noms d’éléments XML aux valeurs d’attributs (exigence)
Le mappage permettant d’atteindre cet objectif se présente comme suit :
Fig. 7 Mappage des noms d’éléments XML aux valeurs d’attributs (dans MapForce)
Le rôle du nœud element() ici est de fournir la séquence des éléments enfants de product, tandis que les nœuds node-name() et text() fournissent respectivement le nom et la valeur réels de chaque élément de la séquence. Ce mappage est accompagné d’un exemple de tutoriel et est abordé plus en détail dans Exemple : Mapper les noms d'éléments aux valeurs d'attribut.
Dans un composant cible, la fonction element() ne crée rien en soi, ce qui constitue une exception à la règle de base du mappage : « pour chaque élément de la source, créer un élément cible ». Les éléments proprement dits sont créés par les nœuds de conversion de type (à l’aide de la valeur de node-name()) et par les nœuds de test de nom (à l’aide de leur propre nom).
attribute()
Comme le montre la fig. 4, cet élément permet d’accéder à tous les attributs du nœud, au moment de l’exécution du mappage. Dans un composant source, il fournit les attributs du nœud source connecté, sous forme de séquence. Par exemple, dans le code XML suivant, la séquence contiendrait deux éléments (puisque product possède deux attributs) :
<product id="1" color="red" /> |
Notez que le nœud attribute() ne fournit que la valeur de chaque attribut de la séquence, toujours sous forme de chaîne de caractères. Le nom de chaque attribut est fourni par le nœud node-name().
Dans un composant cible, ce nœud traite une séquence connectée et crée une valeur d’attribut pour chaque élément de la séquence. Le nom de l’attribut est fourni par le nœud node-name(). Par exemple, imaginez que vous deviez transformer les données d’un XML source en un XML cible comme suit :
Fig. 8 Mappage des valeurs d’attribut aux noms d’attribut (exigence)
Le mappage permettant d’atteindre cet objectif se présente comme suit :
Fig. 9 Mappage des valeurs d’attribut aux noms d’attribut (dans MapForce)
Note : cette transformation est également possible sans activer l’accès dynamique aux attributs d’un nœud. Ici, cela illustre simplement le fonctionnement de la fonction attribute() dans un composant cible.
Si vous souhaitez reconstituer ce mappage, sachez qu’il utilise les mêmes composants XML que le mappage ConvertProducts.mfd disponible dans le dossier DocExamples. La seule différence est que la cible est désormais devenue la source, et que la source est devenue la cible. En tant que données d’entrée pour le composant source, vous aurez besoin d’une instance XML contenant effectivement des valeurs d’attributs, par exemple :
<?xml version="1.0" encoding="UTF-8"?> |
Notez que, dans le listing de code ci-dessus, la déclaration d’espace de noms et de schéma a été omise, par souci de simplicité.
node-name()
Dans un composant source, node-name() fournit respectivement le nom de chaque élément enfant de element(), ou le nom de chaque attribut de attribute(). Par défaut, le nom fourni est de type xs:QName. Pour obtenir le nom sous forme de chaîne de caractères, utilisez le nœud local-name() (voir fig. 3).
Dans un composant cible, node-name() écrit le nom de chaque élément ou attribut contenu dans element() ou attribute().
local-name()
Ce nœud fonctionne de la même manière que node-name(), à la différence que le type est xs:string au lieu de xs:QName.
Type cast node
Dans un composant source, le nœud de conversion de type fournit la valeur de chaque élément enfant contenu dans element(). Le nom et la structure de ce nœud dépendent du type sélectionné dans le dialogue « Paramètres enfants nommés dynamiquement » (fig. 2).
Pour modifier le type du nœud, cliquez sur le bouton Modifier la sélection ( 
) et sélectionnez un type dans la liste des types disponibles, y compris un caractère générique de schéma (xs:any). Pour plus d’informations, voir Accéder aux nœuds d’un type spécifique.
Dans un composant cible, le nœud de conversion de type écrit la valeur de chaque élément enfant contenu dans element(), sous la forme d’un type de données spécifique. Là encore, le type de données souhaité peut être sélectionné en cliquant sur le bouton Modifier la sélection ( ).
Nœuds de test de nom
Dans un composant source, les nœuds de test de nom permettent de regrouper ou de filtrer les éléments enfants d’une instance source par nom. Vous pouvez être amené à filtrer les éléments enfants par nom afin de vous assurer que le mappage accède aux données de l’instance en utilisant le type correct (voir Accéder aux nœuds d’un type spécifique).
En général, les nœuds de test de nom fonctionnent presque comme des nœuds d’élément normaux pour la lecture et l’écriture de valeurs et de structures de sous-arborescence. Cependant, la sémantique du mappage étant différente lorsque l’accès dynamique est activé, certaines limitations s’appliquent. Par exemple, vous ne pouvez pas concaténer la valeur de deux nœuds de test de nom.
Du côté cible, les nœuds de test de nom créent autant d’éléments dans la sortie qu’il y a d’éléments dans la séquence source connectée. Leur nom remplace la valeur mappée à node-name().
Si nécessaire, vous pouvez masquer les nœuds de test de nom dans le composant. Pour ce faire, cliquez sur le bouton Modifier la sélection ( ) situé à côté du nœud element(). Ensuite, dans le dialogue Paramètres enfants nommés dynamiquement (Fig. 2), décochez la case Afficher les nœuds de test...