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

À l'aide d'un ensemble d'options de menu, les paramètres du Transformer peuvent être attribués en faisant référence à d'autres éléments de traitement. Des fonctions plus avancées, telles qu'un éditeur avancé et un éditeur arithmétique, sont également disponibles dans certains Transformers. Pour accéder à un menu de ces options, cliquez sur à côté du paramètre applicable. Pour plus d'informations, voir Options de menus et paramètres de Transformer.

Définir les valeurs

Il existe plusieurs façons de définir une valeur à utiliser dans un Transformer. La plus simple est de simplement taper une valeur ou une chaîne de caractères, qui peut inclure des fonctions de différents types comme des références d'attributs, des fonctions mathématiques et de chaînes de caractères, et des paramètres de traitement. Il existe un certain nombre d'outils et de raccourcis qui peuvent aider à construire des valeurs, généralement disponibles dans le menu contextuel déroulant adjacent au champ de valeur.

Options - Tables

Les Transformers avec des paramètres de style table possèdent des outils additionnels pour remplir et manipuler des valeurs.

FME Community

FME Community est l'endroit où trouver des démos, des tutoriaux, des articles, des FAQ et bien plus encore. Obtenez des réponses à vos questions, apprenez des autres utilisateurs et suggérez, votez et commentez de nouvelles entités.

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