JSONTemplater

Remplit un document JSON avec les valeurs des attributs des entités FME. Le document est fourni en tant que modèle, et le Transformer utilisera XQuery pour insérer les valeurs des attributs et les informations géométriques dans le modèle.

Le document peut être chargé à partir d'un attribut, d'un fichier ou saisi directement dans les paramètres du Transformer.

Pour chaque entité qui entre dans le port d'entrée Root, le modèle JSON Root sera évalué, et le résultat sera placé dans l'attribut nommé par le paramètre Attribut résultat. L'entité sera ensuite sortie du Transformer.

Un modèle JSON est simplement un document JSON qui contient des fonctions XQuery. Essentiellement, ces fonctions sont des espaces réservés aux valeurs de données. Lorsque le modèle est traité, les fonctions sont évaluées et les résultats sont insérés dans le document. Le plus souvent, cette fonction est utilisée pour insérer des valeurs d'attributs d'entités dans le document. Les noms des attributs à insérer sont spécifiés à l'aide des mêmes fonctions XQuery que celles utilisées dans plusieurs autres Transformers : XMLTemplater, XMLUpdater, XMLXQueryExtractor, XMLXQueryExploder, etc.

Dans le JSONTemplater, les fonctions fme:get-attribute, fme:get-list-attribute et fme:get-json-attribute sont particulièrement utiles. Seules les fonctions qui ne modifient pas l'entité sont autorisées. Consultez la documentation sur les fonctions XQuery pour plus d'informations sur les fonctions disponibles.

Le modèle JSON suivant remplit un élément JSON avec la valeur d'attribut "id".

{

"id" : fme:get-attribute("id")

}

Si l'attribut n'existe pas dans l'entité, la valeur clé JSON aura une valeur nulle.

Pour remplir un tableau JSON avec le contenu d'un attribut de liste fme:get-list-attribute peut être utilisé, comme dans cet exemple :

{

"ids" : [ fme:get-list-attribute("ids{}") ]

}

Si l'appel de fonction n'est pas contenu dans les accolades carrées, un tableau sera automatiquement créé si la fonction renvoie plus d'une valeur. Un tableau ne sera pas créé si la fonction renvoie une ou zéro valeur.

Sous-modèles

Lorsqu'un modèle est évalué, il ne peut accéder qu'aux attributs de l'entité en cours de traitement. Afin de permettre à un modèle d'accéder aux attributs de plusieurs entités, le concept de sous-modèles a été introduit. En utilisant la fonction fme:process-features, le Transformer peut évaluer un sous-modèle sur un ensemble d'entités, puis insérer les résultats dans le premier modèle. Dans l'interface du Transformer, un nom est attribué à chaque sous-modèle. Ce nom sera ensuite utilisé dans l'appel fme:process-features pour identifier le sous-modèle à évaluer. En outre, un port d'entrée de Transformer sera créé pour chaque sous-modèle. Le sous-modèle sera traité sur les entités qui entrent dans l'entrée du Transformer correspondant. Les entités qui entrent dans l'un de ces ports d'entrée seront appelées des sous-modèles.

Dans l'exemple suivant, le modèle Root construit un objet JSON représentant un village, avec des informations provenant d'une seule entité. Il remplit ensuite la valeur "maisons", en utilisant les valeurs d'attribut des entités qui sont entrées dans le port d'entrée HOUSE.

{

"name" : fme:get-attribute("village_name"),

"populate" : fme:get-attribute("population"),

"houses" : [

fme:process-features("HOUSE")

]

}

Le modèle associé au port d'entrée HOUSE crée un élément <house>.

{

"address" : fme:get-attribute("address"),

"owner" : fme:get-attribute("owner"),

"num_floors" : fme:get-attribute("num_floors")

}

Si une unique entité entre par le port Root et deux entités entrent par le port HOUSE, le document JSON généré pourrait ressembler à cela :

{

"name" : "Anytown, USA",

"populate" : 2568,

"houses" : [

{

"address" : "123 Main Street",

"owner" : "John Doe",

"num_floors" : 2

},

{

"address" : "324 Main Street",

"owner" : "Jane Doe",

"num_floors" : 3

}

]

}

Un modèle peut appeler plusieurs sous-modèles. Par exemple, dans l'exemple ci-dessus, nous pourrions ajouter un autre sous-modèle nommé BUSINESS, puis utiliser la fonction process-features pour exécuter ce sous-modèle à partir du modèle Root. En outre, un sous-modèle peut exécuter un autre sous-modèle, avec la restriction qu'un sous-modèle ne peut pas directement ou indirectement s'exécuter lui-même.

Sélection des sous-entités à traiter

Il existe souvent une structure hiérarchique des entités qui entrent dans le JSONTemplater. Par exemple, chaque village aura un certain nombre de maisons, et chaque maison aura plusieurs pièces, etc. Si la fonction fme:process-features est utilisée comme décrit ci-dessus, le document résultant ne sera probablement pas correct. Supposons qu'il y ait deux villages, chacun avec cinq maisons. Chaque village et chaque maison sont représentés par une entité FME distincte. Les entités du village sont acheminées vers le port d'entrée Root, tandis que les entités de la maison sont acheminées vers le port d'entrée HOUSE.

Si le Transformer est exécuté avec les modèles ci-dessus, il y aura deux entités de sortie, comme prévu. Cependant, les deux objets village comprendront les dix objets maison. Le comportement correct consiste à évaluer le sous-modèle uniquement sur les entités MAISON qui correspondent à l'entité village actuelle.

La fonction fme:process-features permet de le faire. Des paramètres de fonction supplémentaires peuvent être utilisés pour filtrer les entités à traiter. Le deuxième paramètre est une liste de noms d'attributs, et le troisième est une liste de valeurs d'attributs. Seules les entités dont les attributs correspondent à la liste donnée de noms et de valeurs d'attributs seront traitées.

Cette fonction évaluera le sous-modèle HOUSE sur toutes les entités HOUSE dont l'attribut village_id correspondra à l'id de l'entité en cours.

fme:process-features("HOUSE", "village_id", fme:get-attribute("id"))

Il est possible de spécifier plus d'une paire attribut/valeur. Dans ce cas, les noms et les valeurs des attributs doivent être contenus entre parenthèses. L'appel de fonction suivant évalue le sous-modèle HOUSE sur toutes les entités HOUSE dont l'attribut village_id correspond à l'attribut id de l'entité actuelle et dont l'attribut num_floors est égal à 2.

fme:process-features("HOUSE", ("village_id","num_floors"), (fme:get-attribute("id"), 2) )

Regroupement de sous-entités

Le paramètre Regrouper les sous-entités par permet un filtrage plus grossier des sous-éléments que les paramètres de la fonction fme:process-features. Lorsque ce paramètre est défini comme une liste de noms d'attributs, la fonction fme:process-features ne traitera que les sous-entités qui ont les mêmes valeurs pour ces attributs que l'entité en cours de traitement. Notez que ce paramètre n'a aucun effet sur les entités Root. Chaque entité Root sera traitée et produite par le Transformer.

Lors du regroupement de sous-entités, si toutes les entités de chaque groupe sont consécutives, les performances du Transformer peuvent être améliorées en réglant le paramètre Les sous-entités groupées sont consécutives sur Oui. Lorsque cette valeur est définie, les entités Root seront traitées dès que toutes les sous-entités applicables seront arrivées au Transformer. Cela signifie que le Transformer fonctionnera de manière non-bloquante, plutôt que d'attendre que toutes les entités arrivent avant de commencer à traiter les modèles. Le comportement du Transformer est indéfini si les entités d'un groupe n'arrivent pas toutes consécutivement. Il est probable que certaines entités secondaires ne seront pas traitées si cela se produit.

Exécuter plusieurs sous-modèles avec un unique appel de fonction

Il est possible d'évaluer plusieurs sous-modèles en utilisant un seul appel de fonction. Il suffit de passer une liste de noms de modèles à la fonction fme:process-features. Les sous-modèles seront évalués sur chacune des entités nommées dans la liste. Les entités seront traitées dans l'ordre dans lequel elles sont entrées dans le Transformer. L'appel de fonction suivant traite les sous-modèles HOUSE et BUSINESS :

fme:process-features( ("HOUSE","BUSINESS") )

Les paramètres de sélection de sous-entités peuvent encore être utilisés lorsque la fonction fme:process-features est utilisée pour évaluer plusieurs sous-modèles.

Exécuter un sous-modèle sur la même entité

Il est possible d'évaluer un sous-modèle en utilisant la même entité que celle qui est utilisée pour évaluer le modèle actuel. La fonction fme:process-template prend un nom, ou une liste de noms, de sous-modèles qui doivent être évalués. Ces modèles seront évalués et les résultats seront insérés dans le modèle actuel. Pour évaluer un modèle, il suffit d'entrer le nom du sous-modèle comme paramètre de la fonction. Par exemple, pendant le traitement d'une entité HOUSE, nous pouvons évaluer le modèle OWNER en utilisant l'appel de fonction suivant. Le modèle OWNER sera évalué en utilisant l'entité qui est entrée dans le port d'entrée HOUSE.

fme:process-template("OWNER")

Pour évaluer plusieurs modèles, insérer une liste de noms :

fme:process-template( ("OWNER","ADDRESS") )

Cette technique peut être utilisée pour modulariser les modèles XML, en déplaçant les structures de modèles répétées en un seul endroit. Par exemple, si les maisons et les entreprises ont une adresse, l'adresse pourrait être extraite dans un modèle ADDRESS, et les modèles HOUSE et BUSINESS pourraient alors utiliser la fonction fme:process-template pour insérer les valeurs d'adresse. De cette façon, il n'est pas nécessaire de dupliquer le modèle d'adresse dans les modèles de MAISON et de COMMERCE.

Modèles de géométrie

Les modèles de géométrie peuvent être utilisés pour écrire une géométrie XML personnalisée. Il existe un grand nombre de fonctions permettant l'extraction de données géométriques et le traitement de sous-modèles sur des géométries. Pour plus d'informations, consultez la documentation sur les fonctions XQuery pour obtenir une liste de toutes les fonctions de géométrie et savoir comment écrire des données géométriques à l'aide de sous-modèles.

Les sous-modèles géométriques opèrent de la même manière que les sous-modèles classiques à l'exception qu'un sous-modèle géométrique ne crée pas un port d'entrée sur le Transformer.

Lorsqu'un modèle géométrique est traité, les fonctions qui accèdent aux attributs de l'entité (fme:get-attribute etc) restent toujours utilisables.

Valider les noms des attributs/modèles

Lors de la spécification d'un modèle XML via le paramètre Expression du modèle ou le paramètre Fichier du modèle, le Transformer vérifiera que tous les attributs des entités référencées sont présents dans une entité entrante. Si des attributs sont manquants (non exposés) dans les entités d'entrée, le Transformer sera surligné en rouge comme étant incomplet. Dans ce cas, l'annotation de résumé du Transformer indiquera les attributs manquants auxquels le modèle XML fait référence.

De plus, quand des noms de sous-modèles sont passés aux fonctions fme:process-features et fme:process-template, les noms seront validés pour s'assurer qu'ils correspondent aux noms donnés dans l'interface du Transformer.

Ce comportement de validation additionnel peut être surclassé en définissant le paramètre Valider les noms des attributs/modèles à Non.

Éditer les paramètres des Transformers

Les paramètres du Transformer peuvent être définis en saisissant directement des valeurs, en utilisant des expressions ou en faisant référence à d'autres éléments de l'espace de travail tels que des valeurs d'attributs ou des paramètres utilisateur. Divers éditeurs et menus contextuels sont disponibles pour vous aider. Pour voir ce qui est disponible, cliquez sur à côté du paramètre concerné.

Pour plus d'information, consulter la section Options des Transformers.

FME Community

FME Community dispose d'une mine de connaissances sur FME, avec plus de 20 000 membres actifs dans le monde entier. Obtenez de l'aide sur FME, partagez vos connaissances et entrez en contact avec des utilisateurs du monde entier.

Voir tous les résultats à propos de ce Transformer sur FME Community.