Obtenir l'accès aux noms de nœud
Lorsqu'un nœud dans un composant XML a des nœuds enfants, vous pouvez obtenir le nom et la valeur de chaque nœud enfant directement dans le mappage. Cette technique est appelée "noms de nœud dynamiques". "Dynamique" se réfère au fait que le traitement a lieu "on the fly" (immédiatement), pendant l'exécution du mappage et n'est pas basé sur l'information de schéma statique qui est connu avant l'exécution du mappage. Cette rubrique présente des détails pour permettre l'accès dynamique aux noms de nœud et montre ce que vous pouvez en faire.
Lorsque vous lisez des données provenant d'une source, "noms de nœud dynamiques" signifie que vous pouvez faire les opérations suivantes :
•Obtenir une liste de tous les nœuds enfants (ou attributs) d'un nœud, en tant que séquence. Dans MapForce, "séquence" est une liste de zéro items ou plus que vous pouvez connecter à une cible et créer autant d'items dans la cible qu'il y a d'items dans la source. Ainsi, par exemple, si un nœud a cinq attributs dans la source, vous pouvez créer cinq nouveaux éléments dans la cible, chacun correspondant à un attribut.
•Lire non seulement les valeurs de nœud enfants (comme un mappage standard le fait), mais aussi leurs noms.
Lorsque vous écrivez des données dans une cible, "noms de nœud dynamiques" signifie que vous pouvez effectuer les opérations suivantes :
•Créer de nouveaux nœuds en utilisant des noms fournis par le mappage (des noms soit-disant "dynamiques"), par opposition aux noms fournis par les paramètres de composant (des noms soit-disant "static").
Afin d'illustrer les noms de nœud dynamiques, cette rubrique utilise le schéma XML suivant : <Documents>\Altova\MapForce2025\MapForceExamples\Tutorial\Products.xsd. Ce schéma est accompagné par un document d'instance échantillon, Products.xml. Pour ajouter le schéma et le fichier d'instance à la zone de mappage, choisir la commande de menu Insérer | Schéma XML /Fichier et chercher <Documents>\Altova\MapForce2025\MapForceExamples\Tutorial\Products.xml. Lorsque vous serez invité à choisir un élément racine, choisir products.
Pour activer les noms de nœud dynamiques pour le nœud product, cliquer dessus avec la touche de droite et choisir parmi une des commandes du menu contextuel suivantes :
•Afficher les attributs avec un Nom Dynamique, si vous souhaitez obtenir l'accès aux attributs du nœud
•Afficher les éléments enfants avec un Nom Dynamique, si vous souhaitez obtenir l'accès aux éléments enfants du nœud
Fig. 1 Activer des noms de nœud dynamiques (pour les éléments enfant)
| Note : | Les commandes ci-dessus sont disponibles uniquement pour les nœuds qui ont des nœuds enfants. De même, les commandes ne sont pas disponibles pour les nœuds de racine. |
Lorsque vous faites passer un nœud dans le mode dynamique, un dialogue comme celui ci-dessous apparaît. Définir les options comme indiqué ci-dessous ; ces options seront présentées plus en détail dans Accéder les nœuds de type spécifique.
Fig. 2 Dialogue "Paramètres d'Enfants nommés dynamiquement"
Fig. 3 Montre à quoi ressemble le composant lorsque les noms de nœud dynamiques sont activés pour le nœud product. Veuillez noter que l'apparence du composant a considérablement changé.
Fig.3 Noms de nœud dynamiques activés (pour les éléments)
Pour faire retourner le composant dans le mode standard, cliquer avec la touche de droite sur le nœud product, et désactiver l'option Afficher les Éléments enfants avec le nom dynamique depuis le menu contextuel.
L'image ci-dessous montre à quoi ressemble le même composant lorsque l'accès dynamique aux attributs d'un nœud est activé. Le composant a été obtenu en cliquant avec la touche de droite sur l'élément product, et en sélectionnant Afficher les attributs avec un Nom dynamique depuis le menu contextuel.
Fig. 4 Noms de nœud dynamiques activés (pour les attributs)
Pour replacer le composant dans le mode standard, cliquer avec la touche de droite dans le mode product, et désactiver l'option Afficher les attributs avec un Nom dynamique depuis le menu contextuel.
Comme illustré dans les Fig. 3 et Fig. 4, l'apparence du composant change lorsqu'un nœud (dans ce cas, product) est placé en mode "nom de nœud dynamique". La nouvelle apparence ouvre des possibilités pour les actions suivantes :
•Lire ou écrire une liste de tous les éléments ou attributs enfants d'un nœud. Ils sont fournis par l'item element() ou attribute(), respectivement.
•Lire ou écrire le nom de chaque élément ou attribut enfants. Le nom est fourni par les items node-name() et local-name().
•Dans le cas des éléments, lire ou écrire la valeur de chaque élément enfant, en tant que type de données spécifique. Cette valeur est fournie par le nœud de type cast (dans ce cas, l'item text()). Veuillez noter que seuls des éléments peuvent avoir des nœuds type cast. Les attributs sont toujours traités en tant que type "string".
•Regrouper ou filtrer les éléments enfants par nom.
Les types de nœud avec lesquels vous pouvez travailler dans le mode "nom de nœud dynamique" sont décrits ci-dessous.
element()
Ce nœud a un comportement différent dans un composant de source comparé à un composant cible. Dans un composant de source, il fournit les éléments enfant du nœud en tant que 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 depuis le XML suivant contiendra trois items (puisqu'il y a trois éléments enfant de product) :
<product> <id>1</id> <color>red</color> <size>10</size> </product> |
Veuillez noter que le nom et le type de chaque item dans la séquence est fourni par le nœud node-name() et le nœud type cast, respectivement (discuté ci-dessous). Pour comprendre cela, imaginez que vous souhaitez transformer des données depuis un XML de source dans un XML cible comme suit :
Fig. 6 Mapper des noms d'élément XML dans les valeurs d'attribut (exigence)
Le mappage qui atteindrait cet objectif comme suit :
Fig. 7 Mapper des noms d'élément XML dans les valeurs d'attribut (dans MapForce)
Le rôle d'element() ici est de fournir la séquence des éléments enfants de product, alors que node-name() et text() fournissent le nom et la valeur de chaque item dans la séquence. Ce mappage est accompagné par un échantillon de tutoriel et est discuté plus en détail dans Exemple : Mapper noms d'élément dans les valeurs d'attributs.
Dans un composant cible, element() ne crée rien par lui-même, ce qui est une exception à la règle de base du mappage "pour chaque item dans la source, créer un item cible". Les éléments sont créés par les nœuds type cast (en utilisant la valeur de node-name()) et par les nœuds de test de nom (utilisant leur propre nom).
attribute()
Comme indiqué dans la Fig. 4, cet item permet l'accès à tous les attributs du nœud, à l'exécution du mappage. Dans un composant de source, il fournit les attributs du nœud de source connecté, en tant que séquence. Par exemple, dans le XML suivant, la séquence contiendrait deux items (puisque product a deux attributs) :
<product id="1" color="red" /> |
Veuillez noter que le nœud attribute() fournit uniquement la valeur de chaque attribut dans la séquence, toujours en tant que type string. 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 item dans la séquence. Le nom d'attribut est fourni par node-name(). Par exemple, imaginer que vous souhaitez transformer des données depuis un XML de source dans un XML cible comme suit :
Fig. 8 Mapper des valeurs d'attribut pour attribuer des noms (exigence)
Le mappage qui permet d'atteindre cet objectif ressemble à ce qui suit :
Fig. 9 Mapper des valeurs d'attribut pour attribuer des noms (dans MapForce)
| Note : | Cette transformation est également possible sans activer un accès dynamique dans des attributs d'un nœud. Ici, elle illustre comment attribute() fonctionne dans un composant cible. |
Si vous souhaitez reconstruire ce mappage, il utilise les mêmes composants XML que le mappage ConvertProducts.mfd disponible dans le dossier <Documents>\Altova\MapForce2025\MapForceExamples\Tutorial\. La seule différence est que la cible est maintenant devenue la source, et que la source est devenue la cible. En guise de données d'entrée pour le composant source, vous nécessiterez une instance XML qui contient effectivement des valeurs d'attribut, par exemple :
<?xml version="1.0" encoding="UTF-8"?> |
Veuillez noter que, dans l'extrait de code, l'espace de noms et la déclaration de schéma ont été omis, pour des raisons de simplicité.
node-name()
Dans un composant source, node-name() fournit le nom de chaque élément enfant de element(), ou le nom de chaque attribut de attribute(), respectivement. Par défaut, le nom fourni est de type xs:QName. Pour obtenir le nom en tant que string, utiliser 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.
Nœud type cast
Dans un composant source, le nœud type cast 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é depuis le dialogue "Paramètres Enfants nommés dynamiquement" (Fig. 2).
Pour changer le type du nœud, cliquer sur la touche Changer sélection ( 
) et choisir un type depuis 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 de type spécifique.
Dans un composant cible, le nœud type cast écrit la valeur de chaque élément enfant contenu dans element(), en tant que type de données spécifique. De même, le type de données désiré peut être sélectionné en cliquant sur la touche Changer sélection ( ).
Nœuds de test de nom
Dans un composant de source, les nœuds de test de nom proposent un moyen pour regrouper ou filtrer les éléments enfants depuis une instance de source par nom. Vous pouvez souhaitez filtrer les éléments enfants par les noms pour vous assurer que le mappage accède aux données d'instance en utilisant le type correct (voir Accéder aux nœuds de 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 lire et écrire des valeurs et des structures sous-arborescentes. Néanmoins, étant donné que la sémantique de mappage est différente lorsque l'accès dynamique est activé, il existe des limites. 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'items dans la séquence de source connectée. Leur nom contourne la valeur mappée dans node-name().
Si nécessaire, vous pouvez dissimuler les nœuds de test de nom depuis le composant. Pour ce faire, cliquer sur la touche Changer la sélection ( ) à côté du nœud element(). Ensuite, dans le dialogue "Paramètres Enfants nommés dynamiquement" (Fig. 2), décocher la case Afficher les nœuds de test de nom....