Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

# AWS IoT TwinMaker graphe de connaissances
<a name="tm-knowledge-graph"></a>

Le graphe de AWS IoT TwinMaker connaissances organise toutes les informations contenues dans vos AWS IoT TwinMaker espaces de travail et les présente sous forme de graphique visuel. Vous pouvez exécuter des requêtes sur vos entités, composants et types de composants afin de générer des graphiques visuels illustrant les relations entre vos AWS IoT TwinMaker ressources.

Les rubriques suivantes expliquent comment utiliser et intégrer le graphe de connaissances.

**Topics**
+ [

## AWS IoT TwinMaker concepts de base du graphe de connaissances
](#tm-knowledge-graph-concepts)
+ [

# Comment exécuter des requêtes AWS IoT TwinMaker Knowledge Graph
](tm-knowledge-graph-use.md)
+ [

# Intégration de scènes de graphes de connaissances
](tm-knowledge-graph-scene.md)
+ [

# Comment utiliser le AWS IoT TwinMaker Knowledge Graph avec Grafana
](tm-knowledge-Grafana-panel.md)
+ [

# AWS IoT TwinMaker Knowledge Graph (ressources supplémentaires)
](tm-knowledge-graph-resources.md)

## AWS IoT TwinMaker concepts de base du graphe de connaissances
<a name="tm-knowledge-graph-concepts"></a>

Cette rubrique couvre les concepts clés et le vocabulaire de la fonctionnalité Knowledge Graph.

**Comment fonctionne le Knowledge Graph** :  
Le graphe de connaissances crée des relations entre les entités et leurs composants avec le [CreateEntity](https://docs.aws.amazon.com//iot-twinmaker/latest/apireference/API_CreateEntity.html)ou existant [ UpdateEntity](https://docs.aws.amazon.com//iot-twinmaker/latest/apireference/API_UpdateEntity.html) APIs. Une relation est simplement une propriété d'un type de données spécial [RELATIONSHIP](https://docs.aws.amazon.com//iot-twinmaker/latest/apireference/API_DataType.html#:~:text=Valid%20Values%3A-,RELATIONSHIP,-%7C%20STRING%20%7C%20LONG%20%7C%20BOOLEAN) défini sur un composant d'une entité. AWS IoT TwinMaker Knowledge Graph appelle l'[ExecuteQuery](https://docs.aws.amazon.com/iot-twinmaker/latest/apireference/API_ExecuteQuery.html)API pour effectuer une requête basée sur les données des entités ou sur les relations entre elles. Knowledge Graph utilise le langage de requête flexible partiQL (utilisé par de nombreux AWS services) qui a récemment été ajouté à la prise en charge de la syntaxe des correspondances de graphes pour vous aider à rédiger vos requêtes. Une fois les appels effectués, vous pouvez afficher les résultats sous forme de tableau ou les visualiser sous forme de graphique des nœuds et des arêtes connectés.

**Termes clés du Knowledge Graph** :  
+ **Graphe d'entités** : ensemble de nœuds et d'arêtes dans un espace de travail.
+ **Nœud** : chaque entité de votre espace de travail devient un nœud dans le graphe d'entités.
+ **Arête** : chaque propriété de relation définie sur un composant d'une entité devient une arête dans le graphe d'entités. En outre, une relation parent-enfant hiérarchique définie à l'aide du parentEntityId champ d'une entité devient également une arête dans le graphe d'entités avec un nom de relation « isChildOf ». Toutes les arêtes sont des arêtes directionnelles.
+ **Relation** : une AWS IoT TwinMaker relation est un type spécial de propriété du composant d'une entité. Vous pouvez utiliser l'[UpdateEntity](https://docs.aws.amazon.com//iot-twinmaker/latest/apireference/API_UpdateEntity.html)API AWS IoT TwinMaker [ CreateEntity](https://docs.aws.amazon.com//iot-twinmaker/latest/apireference/API_CreateEntity.html)or pour définir et modifier une relation. Dans AWS IoT TwinMaker, une relation doit être définie dans un composant d'une entité. Une relation ne peut pas être définie comme une ressource isolée. Une relation doit être directionnelle d'une entité à l'autre.

# Comment exécuter des requêtes AWS IoT TwinMaker Knowledge Graph
<a name="tm-knowledge-graph-use"></a>

Avant d'utiliser le AWS IoT TwinMaker Knowledge Graph, assurez-vous d'avoir rempli les conditions préalables suivantes :
+ Créez un AWS IoT TwinMaker espace de travail. Vous pouvez créer un espace de travail dans la [AWS IoT TwinMaker console](https://console.aws.amazon.com/iottwinmaker/).
+ Familiarisez-vous avec AWS IoT TwinMaker le système de composants d'entités et apprenez à créer des entités. Pour de plus amples informations, veuillez consulter [Créez votre première entité](twinmaker-gs-entity.md).
+ Familiarisez-vous avec AWS IoT TwinMaker les connecteurs de données. Pour de plus amples informations, veuillez consulter [AWS IoT TwinMaker connecteurs de données](data-connector-interface.md).

**Note**  
Pour utiliser le AWS IoT TwinMaker Knowledge Graph, vous devez utiliser le mode de tarification des offres **groupées **standard** ou échelonné**. Pour de plus amples informations, veuillez consulter [Changer de mode de AWS IoT TwinMaker tarification](tm-pricing-mode.md).

Les procédures suivantes vous montrent comment écrire, exécuter, enregistrer et modifier des requêtes.

 **Ouvrez l'éditeur de requêtes**   

**Pour accéder à l'éditeur de requêtes Knowledge Graph**

1. Ouvrez la [AWS IoT TwinMaker console](https://console.aws.amazon.com/iottwinmaker/).

1. Ouvrez l'espace de travail dans lequel vous souhaitez utiliser le Knowledge Graph.

1. Dans le menu de navigation de gauche, choisissez l'**éditeur de requêtes**.

1. L'éditeur de requêtes s'ouvre. Vous êtes maintenant prêt à exécuter des requêtes sur les ressources de votre espace de travail.

 **Exécuter une requête**   

**Pour exécuter une requête et générer un graphique**

1. Dans l'éditeur de requêtes, choisissez l'onglet **Éditeur** pour ouvrir l'éditeur de syntaxe.

1. Dans l'espace éditeur, écrivez la requête que vous souhaitez exécuter sur les ressources de votre espace de travail.  
![\[L'espace de l'éditeur dans lequel une requête a été saisie.\]](http://docs.aws.amazon.com/fr_fr/iot-twinmaker/latest/guide/images/kg-query-updated.png)

   Dans l'exemple illustré, la demande recherche les entités dont le nom est indiqué, puis organise ces entités `vav_%` en fonction de la `feed` relation entre elles, à l'aide du code suivant.

   ```
   SELECT ahu, vav, r FROM EntityGraph
   MATCH (vav)<-[r:feed]-(ahu)
   WHERE vav.entityName LIKE 'vav_%'
   ```
**Note**  
La syntaxe du graphe de connaissances utilise [partiQL](https://partiql.org/). Pour plus d'informations sur cette syntaxe, consultez[AWS IoT TwinMaker Knowledge Graph (ressources supplémentaires)](tm-knowledge-graph-resources.md).

1. Choisissez **Exécuter la requête** pour exécuter la demande que vous avez créée.

   Un graphique est généré en fonction de votre demande.  
![\[Un graphique présentant les résultats de la requête détaillée dans les étapes précédentes.\]](http://docs.aws.amazon.com/fr_fr/iot-twinmaker/latest/guide/images/tm-kg-graph-output.png)

   L'exemple de graphique présenté ci-dessus est basé sur l'exemple de requête de l'étape 2.

1. Les résultats de la requête sont également présentés dans une liste. Choisissez **les résultats** pour afficher les résultats de la requête sous forme de liste.

1. Choisissez éventuellement **Exporter sous** pour exporter les résultats de la requête au format JSON ou CSV.

Cela couvre l'utilisation de base du Knowledge Graph dans la console. Pour plus d'informations et des exemples illustrant la syntaxe du Knowledge Graph, consultez[AWS IoT TwinMaker Knowledge Graph (ressources supplémentaires)](tm-knowledge-graph-resources.md).

# Intégration de scènes de graphes de connaissances
<a name="tm-knowledge-graph-scene"></a>

Vous pouvez utiliser les composants du kit d' AWS IoT applications pour créer une application Web qui intègre le Knowledge Graph dans vos AWS IoT TwinMaker scènes. Cela vous permet de générer des graphiques basés sur les nœuds 3D (les modèles 3D qui représentent votre équipement ou vos systèmes) présents dans votre scène. Pour créer une application qui représente graphiquement des nœuds 3D à partir de votre scène, liez d'abord les nœuds 3D aux entités de votre espace de travail. Ce mappage permet de AWS IoT TwinMaker représenter graphiquement les relations entre les modèles 3D présents dans votre scène et les entités de votre espace de travail. Vous pouvez ensuite créer une application Web, sélectionner des modèles 3D avec votre scène et explorer leurs relations avec d'autres entités sous forme de graphique.

![\[TwinMaker Scène avec un graphe de connaissances illustrant les relations entre les modèles 3D.\]](http://docs.aws.amazon.com/fr_fr/iot-twinmaker/latest/guide/images/intro_kg_scene.png)


Pour un exemple d'application Web fonctionnelle qui utilise les composants du kit d' AWS IoT applications pour générer des graphiques dans une AWS IoT TwinMaker scène, consultez l'[AWS IoT TwinMaker exemple d'application React](https://github.com/awslabs/iot-app-kit/blob/3DKG_Demo/examples/react-app/src/components/index.tsx) sur github.

## AWS IoT TwinMaker prérequis pour les graphes de scène
<a name="tm-knowledge-graph-prereqs"></a>

Avant de créer une application Web qui utilise le AWS IoT TwinMaker Knowledge Graph dans vos scènes, remplissez les conditions préalables suivantes :
+ Créez un AWS IoT TwinMaker espace de travail. Vous pouvez créer un espace de travail dans la [AWS IoT TwinMaker console](https://console.aws.amazon.com/iottwinmaker/).
+ Familiarisez-vous avec AWS IoT TwinMaker le système de composants d'entités et apprenez à créer des entités. Pour de plus amples informations, veuillez consulter [Créez votre première entité](twinmaker-gs-entity.md).
+ Créez une AWS IoT TwinMaker scène remplie de modèles 3D.
+ Familiarisez-vous avec AWS IoT TwinMaker les composants du kit d' AWS IoT applications. Pour plus d'informations sur les AWS IoT TwinMaker composants, consultez[Création d'une application Web personnalisée à l'aide des composants de l' AWS IoT TwinMaker interface utilisateur](tm-app-kit.md).
+ Familiarisez-vous avec les concepts du graphe de connaissances et la terminologie clé. Consultez [AWS IoT TwinMaker concepts de base du graphe de connaissances](tm-knowledge-graph.md#tm-knowledge-graph-concepts).

**Note**  
Pour utiliser le AWS IoT TwinMaker Knowledge Graph et les fonctionnalités associées, vous devez utiliser le mode de tarification des offres **groupées **standard** ou échelonné**. Pour plus d'informations sur AWS IoT TwinMaker les tarifs, consultez[Changer de mode de AWS IoT TwinMaker tarification](tm-pricing-mode.md).

## Liez des nœuds 3D dans votre scène
<a name="tm-knowledge-graph-scene-data-binidng"></a>

Avant de créer une application Web qui intègre le graphe de connaissances à votre scène, liez les modèles 3D, appelés nœuds 3D, présents dans votre scène à l'entité d'espace de travail associée. Par exemple, si vous avez un modèle d'équipement de mixage dans une scène et qu'une entité correspondante est appelée`mixer_0`, créez une **liaison de données** entre le modèle du mélangeur et l'entité représentant le mélangeur, afin que le modèle et l'entité puissent être représentés graphiquement.

**Pour effectuer une action de liaison de données**

1. Connectez-vous à la [console AWS IoT TwinMaker](https://console.aws.amazon.com/iottwinmaker/).

1. Ouvrez votre espace de travail et sélectionnez une scène contenant les nœuds 3D que vous souhaitez lier.

1. Sélectionnez un nœud (modèle 3D) dans le compositeur de scène. Lorsque vous sélectionnez un nœud, il ouvre un panneau d'inspection sur le côté droit de l'écran.

1. Dans le panneau de l'inspecteur, naviguez vers le haut du panneau et sélectionnez le bouton **\$1**. Choisissez ensuite l'option **Ajouter une liaison d'entité**. Cela ouvrira une liste déroulante dans laquelle vous pourrez sélectionner une entité à lier au nœud actuellement sélectionné.  
![\[Scène avec le signe plus sélectionné dans le panneau Inspector et la liaison Ajouter une entité surlignée.\]](http://docs.aws.amazon.com/fr_fr/iot-twinmaker/latest/guide/images/binding-step-4.png)

1. Dans le menu déroulant de liaison de données, sélectionnez l'identifiant d'entité que vous souhaitez associer au modèle 3D. Dans les champs **Nom du composant** et **Nom de la propriété**, sélectionnez les composants et les propriétés que vous souhaitez lier.  
![\[Scène dont les noms des composants et des propriétés sont sélectionnés dans le panneau Inspector.\]](http://docs.aws.amazon.com/fr_fr/iot-twinmaker/latest/guide/images/binding-step-6.png)

   Une fois que vous avez sélectionné les champs **Identifiant de l'entité**, **Nom du composant** et **Nom de propriété**, la liaison est terminée.

1. Répétez ce processus pour tous les modèles et entités que vous souhaitez représenter graphiquement.
**Note**  
La même opération de liaison de données peut être effectuée sur les balises de votre scène. Il suffit de sélectionner une balise au lieu d'une entité et de suivre le même processus pour lier la balise à un nœud.

## Création d'une application Web
<a name="tm-knowledge-graph-scene-application"></a>

Après avoir lié vos entités, utilisez la bibliothèque du kit d' AWS IoT applications pour créer une application Web avec un widget de graphe de connaissances qui vous permet de visualiser votre scène et d'explorer les relations entre les nœuds de scène et les entités.

Utilisez les ressources suivantes pour créer votre propre application :
+  AWS IoT TwinMaker Exemple de documentation [Readme de l'application React](https://github.com/awslabs/iot-app-kit/blob/3DKG_Demo/examples/react-app/README.md) sur github.
+ L' AWS IoT TwinMaker exemple de [source](https://github.com/awslabs/iot-app-kit/blob/3DKG_Demo/examples/react-app/src/components/index.tsx) de l'application React sur github.
+ Le kit d' AWS IoT applications : documentation de [démarrage](https://awslabs.github.io/iot-app-kit/?path=/docs/overview-getting-started--docs).
+ La documentation des [composants du lecteur vidéo du](https://awslabs.github.io/iot-app-kit/?path=/docs/components-videoplayer--docs) kit d' AWS IoT applications.
+ La documentation des [composants du kit d' AWS IoT applications Scene Viewer](https://awslabs.github.io/iot-app-kit/?path=/docs/components-sceneviewer--docs).

La procédure suivante illustre les fonctionnalités du composant Scene Viewer dans une application Web.

**Note**  
Cette procédure est basée sur l'implémentation du composant AWS IoT App Kit Scene Viewer dans l' AWS IoT TwinMaker exemple d'application React.

1. Ouvrez le composant Scene Viewer de l' AWS IoT TwinMaker exemple d'application React. Dans le champ de recherche, saisissez un nom d'entité ou un nom d'entité partiel (recherche distinguant majuscules et minuscules), puis sélectionnez le bouton **Rechercher**. Si un modèle est lié à l'identifiant de l'entité, le modèle de la scène sera mis en surbrillance et un nœud de l'entité sera affiché dans le panneau de visualisation de scène.  
![\[Scène dans laquelle le panneau de visualisation de scènes Knowledge Graph est affiché.\]](http://docs.aws.amazon.com/fr_fr/iot-twinmaker/latest/guide/images/search_select_kg_event.png)

1. Pour générer un graphique de toutes les relations, sélectionnez un nœud dans le widget Scene Viewer et cliquez sur le bouton **Explorer**.  
![\[Scène dont le panneau de visualisation de scènes Knowledge Graph affiche un graphique des relations.\]](http://docs.aws.amazon.com/fr_fr/iot-twinmaker/latest/guide/images/explore_select_kg.png)

1. Appuyez sur le bouton **Effacer** pour effacer votre sélection de graphes actuelle et recommencer.

# Comment utiliser le AWS IoT TwinMaker Knowledge Graph avec Grafana
<a name="tm-knowledge-Grafana-panel"></a>

Cette section vous montre comment ajouter un panneau d'éditeur de requêtes à votre tableau de bord AWS IoT TwinMaker Grafana pour exécuter et afficher des requêtes.

## AWS IoT TwinMaker prérequis pour l'éditeur de requêtes
<a name="tm-knowledge-graph-Grafana-prereqs"></a>

Avant d'utiliser le graphe de AWS IoT TwinMaker connaissances dans Grafana, remplissez les conditions préalables suivantes :
+ Créez un AWS IoT TwinMaker espace de travail. Vous pouvez créer un espace de travail dans la [AWS IoT TwinMaker console](https://console.aws.amazon.com/iottwinmaker/).
+ Configurez AWS IoT TwinMaker pour une utilisation avec Grafana. Pour obtenir des instructions, veuillez consulter [AWS IoT TwinMaker Intégration au tableau de bord Grafana](grafana-integration.md).

**Note**  
Pour utiliser le AWS IoT TwinMaker Knowledge Graph, vous devez utiliser le mode de tarification des offres **groupées **standard** ou échelonné**. Pour de plus amples informations, veuillez consulter [Changer de mode de AWS IoT TwinMaker tarification](tm-pricing-mode.md).

## AWS IoT TwinMaker autorisations de l'éditeur de requêtes
<a name="tm-knowledge-graph-Grafana-config"></a>

Pour utiliser l'éditeur de AWS IoT TwinMaker requêtes dans Grafana, vous devez avoir un rôle IAM autorisé à effectuer l'action. `iottwinmaker:ExecuteQuery` Ajoutez cette autorisation à votre rôle de tableau de bord de l'espace de travail, comme illustré dans cet exemple :

------
#### [ JSON ]

****  

```
{
    "Version":"2012-10-17",		 	 	 
    "Statement": [
        {
            "Effect": "Allow",
            "Action": [
                "s3:GetObject"
            ],
            "Resource": [
                "arn:aws:s3:::amzn-s3-demo-bucket",
                "arn:aws:s3:::amzn-s3-demo-bucket/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": [
                "iottwinmaker:GetEntity",
                "iottwinmaker:ListEntities",
                "iottwinmaker:ExecuteQuery"
            ],
            "Resource": [
                "arn:aws:iottwinmaker:us-east-2:111122223333:workspace/workspaceId",
                "arn:aws:iottwinmaker:us-east-2:111122223333:workspace/workspaceId/*"
            ]
        },
        {
            "Effect": "Allow",
            "Action": "iottwinmaker:ListWorkspaces",
            "Resource": "*"
        }
    ]
}
```

------

**Note**  
Lorsque vous configurez votre source de données AWS IoT TwinMaker Grafana, assurez-vous d'utiliser le rôle avec cette autorisation pour le champ **ARN Assumer** le rôle. Après l'avoir ajouté, vous pouvez sélectionner votre espace de travail dans le menu déroulant situé à côté de **Workspace**.

Pour de plus amples informations, veuillez consulter [Création d'un rôle IAM dans le tableau de bord](dashboard-IAM-role.md#dashboard-IAM-role.title).

### Configuration du panneau de l'éditeur de AWS IoT TwinMaker requêtes
<a name="tm-knowledge-graph-Grafana-panel"></a>

**Pour configurer un nouveau panneau de tableau de bord Grafana pour Knowledge Graph**

1. Ouvrez votre tableau de AWS IoT TwinMaker bord Grafana.

1. Créez un nouveau **panneau de tableau de bord**. Pour connaître les étapes détaillées de création d'un panneau, voir [Création d'un tableau de bord](https://grafana.com/docs/grafana/latest/dashboards/build-dashboards/create-dashboard/) dans la documentation de Grafana.

1. Dans la liste des visualisations, sélectionnez **Éditeur de AWS IoT TwinMaker requêtes**.  
![\[La liste déroulante du AWS IoT TwinMaker tableau de bord contient l'option pour l'éditeur de AWS IoT TwinMaker requêtes.\]](http://docs.aws.amazon.com/fr_fr/iot-twinmaker/latest/guide/images/tw-query-editor-dropdown.png)

1. Sélectionnez la source de données sur laquelle exécuter les requêtes.

1. **(Facultatif)** Ajoutez un nom pour le nouveau panneau dans le champ prévu à cet effet.

1. Sélectionnez **Appliquer** pour enregistrer et confirmer votre nouveau panneau.

Le panneau Knowledge Graph fonctionne de la même manière que l'éditeur de requêtes fourni dans la AWS IoT TwinMaker console. Vous pouvez exécuter, écrire et effacer les requêtes que vous effectuez dans le panneau. Pour plus d'informations sur la façon d'écrire des requêtes, consultez[AWS IoT TwinMaker Knowledge Graph (ressources supplémentaires)](tm-knowledge-graph-resources.md).

#### Comment utiliser l'éditeur AWS IoT TwinMaker de requêtes
<a name="tm-knowledge-graph-Grafana-use"></a>

Les résultats de vos requêtes sont affichés de trois manières, comme le montrent les images suivantes : visualisés sous forme de graphique, répertoriés dans un tableau ou présentés sous forme de résumé d'exécution.
+ **Visualisation graphique :**  
![\[AWS IoT TwinMaker les résultats de l'éditeur de requêtes sont affichés sous forme de graphique visuel.\]](http://docs.aws.amazon.com/fr_fr/iot-twinmaker/latest/guide/images/kg-vis-graph.png)

  Le graphique visuel affiche uniquement les données des requêtes dont le résultat contient au moins une relation. Le graphique affiche les entités sous forme de nœuds et les relations sous forme d'arêtes orientées dans le graphe.
+ **Données tabulaires :**  
![\[AWS IoT TwinMaker les résultats de l'éditeur de requêtes sont affichés sous forme de données tabulaires.\]](http://docs.aws.amazon.com/fr_fr/iot-twinmaker/latest/guide/images/kg-table-data.png)

  Le format de données tabulaire affiche les données de toutes les requêtes. Vous pouvez rechercher dans le tableau des résultats spécifiques ou des sous-ensembles de résultats. Les données peuvent être exportées au format JSON ou CSV.
+ **Résumé de l'exécution**  
![\[AWS IoT TwinMaker les résultats de l'éditeur de requêtes sont affichés sous forme de résumé d'exécution.\]](http://docs.aws.amazon.com/fr_fr/iot-twinmaker/latest/guide/images/kg-run-sum.png)

  Le résumé de l'exécution affiche la requête et les métadonnées relatives à l'état de la requête.

# AWS IoT TwinMaker Knowledge Graph (ressources supplémentaires)
<a name="tm-knowledge-graph-resources"></a>

Cette section fournit des exemples de base de la syntaxe partiQL utilisée pour écrire des requêtes dans le graphe de connaissances, ainsi que des liens vers la documentation partiQL qui fournit des informations sur le modèle de données du graphe de connaissances.
+ [ Documentation sur les modèles de données graphiques PartiQL](https://partiql.org/gpml/graph_model.html)
+ [ Documentation sur les requêtes graphiques PartiQL](https://partiql.org/gpml/graph_query.html)

Cet ensemble d'exemples montre les requêtes de base avec leurs réponses. Utilisez-le comme référence pour rédiger vos propres requêtes.

**Requêtes de base**  
+ **Obtenir toutes les entités à l'aide d'un filtre**

  ```
  SELECT entity
  FROM EntityGraph MATCH (entity)
  WHERE entity.entityName = 'room_0'
  ```

   Cette requête renvoie toutes les entités d'un espace de travail portant le nom`room_0`.

  `FROM`clause : `EntityGraph` est la collection de graphes qui contient toutes les entités et leurs relations dans un espace de travail. Cette collection est automatiquement créée et gérée en AWS IoT TwinMaker fonction des entités de votre espace de travail.

  `MATCH`clause : spécifie un modèle qui correspond à une partie du graphique. Dans ce cas, le modèle `(entity)` correspond à chaque nœud du graphe et est lié à la variable d'entité. La `FROM` clause doit être suivie de la `MATCH` clause.

  `WHERE`clause : spécifie un filtre sur le `entityName` champ du nœud, où la valeur doit correspondre`room_0`.

  `SELECT`clause : spécifie la `entity` variable afin que l'ensemble du nœud de l'entité soit renvoyé.

  **Réponse :**

  ```
  {
    "columnDescriptions": [
      {
        "name": "entity",
        "type": "NODE"
      }
    ],
    "rows": [
      {
        "rowData": [
          {
            "arn": "arn:aws:iottwinmaker:us-east-1: 577476956029: workspace / SmartBuilding8292022 / entity / room_18f3ef90 - 7197 - 53 d1 - abab - db9c9ad02781 ",
            "creationDate": 1661811123914,
            "entityId": "room_18f3ef90-7197-53d1-abab-db9c9ad02781",
            "entityName": "room_0",
            "lastUpdateDate": 1661811125072,
            "workspaceId": "SmartBuilding8292022",
            "description": "",
            "components": [
              {
                "componentName": "RoomComponent",
                "componentTypeId": "com.example.query.construction.room",
                "properties": [
                  {
                    "propertyName": "roomFunction",
                    "propertyValue": "meeting"
                  },
                  {
                    "propertyName": "roomNumber",
                    "propertyValue": 0
                  }
                ]
              }
            ]
          }
        ]
      }
    ]
  }
  ```

  `columnDescriptions`Renvoie les métadonnées relatives à la colonne, telles que le nom et le type. Le type renvoyé est`NODE`. Cela indique que le nœud entier a été renvoyé. Les autres valeurs du type peuvent `EDGE` indiquer une relation ou `VALUE` une valeur scalaire telle qu'un entier ou une chaîne.

  `rows`Renvoie une liste de lignes. Comme une seule entité a été mise en correspondance, `rowData` une entité contenant tous les champs d'une entité est renvoyée.
**Note**  
Contrairement au SQL où vous ne pouvez renvoyer que des valeurs scalaires, vous pouvez renvoyer un objet (au format JSON) en utilisant partiQL.

  Chaque nœud contient tous les champs au niveau de l'entité tels que`entityId`, `arn` et les champs au niveau des composants tels que`components`, et, ainsi que les champs au niveau de la propriété tels que `componentTypeId` et `componentName``properties`, le tout sous forme de JSON `propertyName` `propertyValue` imbriqué.
+ **Obtenez toutes les relations à l'aide d'un filtre** :

  ```
  SELECT relationship
  FROM EntityGraph MATCH (e1)-[relationship]->(e2)
  WHERE relationship.relationshipName = 'isLocationOf'
  ```

  Cette requête renvoie toutes les relations d'un espace de travail avec le nom de la relation`isLocationOf`.

   La `MATCH` clause : spécifie un modèle qui correspond à deux nœuds (indiqués par`()`) connectés par une arête dirigée (indiquée par`-[]->`) et liés à une variable appelée`relationship`.

  La `WHERE` clause : spécifie un filtre sur le `relationshipName` champ de l'arête, où se trouve la valeur`isLocationOf`.

  La `SELECT` clause : spécifie la variable de relation afin que l'ensemble du nœud périphérique soit renvoyé.

  **Réponse**

  ```
  {
      "columnDescriptions": [{
          "name": "relationship",
          "type": "EDGE"
      }],
      "rows": [{
          "rowData": [{
              "relationshipName": "isLocationOf",
              "sourceEntityId": "floor_83faea7a-ea3b-56b7-8e22-562f0cf90c5a",
              "targetEntityId": "building_4ec7f9e9-e67e-543f-9d1b- 235df7e3f6a8",
              "sourceComponentName": "FloorComponent",
              "sourceComponentTypeId": "com.example.query.construction.floor"
          }]
      },
          ... //rest of the rows are omitted
      ]
  }
  ```

  Le type de colonne dans `columnDescriptions` est un`EDGE`.

  Chacun `rowData` représente une arête avec des champs tels que`relationshipName`. Il est identique au nom de propriété de relation défini sur l'entité. Les`sourceEntityId`, `sourceComponentName` et `sourceComponentTypeId` fournissent des informations sur l'entité et le composant sur lesquels la propriété de relation a été définie. `targetEntityId`Spécifie l'entité vers laquelle cette relation pointe.
+ **Obtenez toutes les entités ayant une relation spécifique avec une entité spécifique**

  ```
  SELECT e2.entityName
        FROM EntityGraph MATCH (e1)-[r]->(e2)
        WHERE relationship.relationshipName = 'isLocationOf'
        AND e1.entityName = 'room_0'
  ```

  Cette requête renvoie tous les noms d'entité de toutes les entités ayant une `isLocationOf` relation avec l'`room_0`entité.

  La `MATCH` clause : spécifie un modèle qui correspond à deux nœuds (`e1`,`e2`) ayant une arête dirigée (`r`).

  La `WHERE` clause : spécifie un filtre sur le nom de la relation et le nom de l'entité source.

  La `SELECT` clause : renvoie le `entityName` champ dans le `e2` nœud.

  **Réponse**

  ```
  {
    "columnDescriptions": [
      {
         "name": "entityName",
         "type": "VALUE"
      }
    ],
     "rows": [
      {
         "rowData": [
           "floor_0"
        ]
      }
    ]
  }
  ```

  Dans les ColumnDescriptions, le type de la colonne est `VALUE` puisque c'`entityName`est une chaîne.

  Une entité est renvoyée. `floor_0`

**CORRESPONDRE**  
Les modèles suivants sont pris en charge dans une `MATCH` clause :  
+ Faites correspondre le nœud « b » pointant vers le nœud « a » :

  ```
  FROM EntityGraph MATCH (a)-[rel]-(b)
  ```
+ Faites correspondre le nœud « a » pointant vers le nœud « b » :

  ```
  FROM EntityGraph MATCH (a)-[]->(b)
  ```

  Aucune variable n'est liée à une relation en supposant qu'il n'est pas nécessaire de spécifier un filtre sur la relation.
+ Faites correspondre le nœud « a » pointant vers le nœud « b » et le nœud « b » pointant vers le nœud « a » :

  ```
  FROM EntityGraph MATCH (a)-[rel]-(b)
  ```

  Cela renverra deux correspondances : une de « a » à « b » et une autre de « b » à « a ». Il est donc recommandé d'utiliser des arêtes orientées dans la mesure du possible.
+ Le nom de la relation est également une étiquette du graphe `EntityGraph` de propriétés. Vous pouvez donc simplement spécifier le nom de la relation après deux points (:) au lieu de spécifier un filtre `rel.relationshipName` dans la `WHERE` clause.

  ```
  FROM EntityGraph MATCH (a)-[:isLocationOf]-(b)
  ```
+ Enchaînement : les modèles peuvent être enchaînés pour correspondre à plusieurs relations.

  ```
  FROM EntityGraph MATCH (a)-[rel1]->(b)-[rel2]-(c)
  ```
+ Les modèles de sauts variables peuvent également s'étendre sur plusieurs nœuds et arêtes :

  ```
  FROM EntityGraph MATCH (a)-[]->{1,5}(b)
  ```

  Cette requête correspond à n'importe quel modèle avec des arêtes sortantes du nœud « a » entre 1 et 5 sauts. Les quantificateurs autorisés sont les suivants :

  `{m,n}`- entre m et n répétitions

  `{m,}`- 5 répétitions ou plus.

**À PARTIR DE** :  
Un nœud d'entité peut contenir des données imbriquées, telles que des composants qui contiennent eux-mêmes d'autres données imbriquées telles que des propriétés. Vous pouvez y accéder en démêlant le résultat du modèle MATCH.  

```
SELECT e
FROM EntityGraph MATCH (e), e.components AS c, c.properties AS p
WHERE c.componentTypeId = 'com.example.query.construction.room',
AND p.propertyName = 'roomFunction'
AND p.propertyValue = 'meeting'
```
Accédez aux champs imbriqués en pointant des points `.` dans une variable. Une virgule (,) est utilisée pour désimbriquer (ou joindre) des entités contenant les composants, puis les propriétés contenues dans ces composants. `AS`est utilisé pour lier une variable aux variables non imbriquées afin qu'elles puissent être utilisées dans les clauses `WHERE` or`SELECT`. Cette requête renvoie toutes les entités qui contiennent une propriété nommée `roomFunction` avec une valeur `meeting` dans un composant avec un identifiant de type de composant `com.example.query.construction.room`   
Pour accéder à plusieurs champs imbriqués d'un champ, tels que plusieurs composants d'une entité, utilisez la notation par virgule pour effectuer une jointure.  

```
SELECT e
FROM EntityGraph MATCH (e), e.components AS c1, e.components AS c2
```

**SÉLECTIONNEZ** :  
+ Renvoie un nœud :

  ```
  SELECT e
  FROM EntityGraph MATCH (e)
  ```
+ Renvoie une arête :

  ```
  SELECT r
  FROM EntityGraph MATCH (e1)-[r]->(e2)
  ```
+ Renvoie une valeur scalaire :

  ```
  SELECT floor.entityName, room.description, p.propertyValue AS roomfunction
  FROM EntityGraph MATCH (floor)-[:isLocationOf]-(room),
  room.components AS c, c.properties AS p
  ```

  Formatez le nom du champ de sortie en lui attribuant un alias en utilisant`AS`. Ici, au lieu d'`propertyValue`un nom de colonne dans la réponse, `roomfunction` il est renvoyé.
+ Alias de retour :

  ```
  SELECT floor.entityName AS floorName, luminaire.entityName as luminaireName
  FROM EntityGraph MATCH (floor)-[:isLocationOf]-(room)-[:hasPart]-
  (lightingZone)-[:feed]-(luminaire)
  WHERE floor.entityName = 'floor_0'
  AND luminaire.entityName like 'lumin%'
  ```

  Il est fortement recommandé d'utiliser des alias pour être explicite, améliorer la lisibilité et éviter toute ambiguïté dans vos requêtes.

**OÙ** :  
+ Les opérateurs logiques pris en charge sont `AND``NOT`, et`OR`.
+ Les opérateurs de comparaison pris en charge sont `<` `<=``>`,`=>`,`=`, et`!=`.
+ Utilisez le `IN` mot clé si vous souhaitez spécifier plusieurs `OR` conditions dans le même champ.
+ Filtrez sur un champ d'entité, de composant ou de propriété :

  ```
  FROM EntityGraph MATCH (e), e.components AS c, c.properties AS p
  WHERE e.entityName = 'room_0'
  AND c.componentTypeId = 'com.example.query.construction.room',
  AND p.propertyName = 'roomFunction'
  AND NOT p.propertyValue = 'meeting'
  OR p.propertyValue = 'office'
  ```
+ Filtrez sur la `configuration` propriété. `unit`Voici la clé de la carte de configuration et `Celsius` la valeur.

  ```
  WHERE p.definition.configuration.unit = 'Celsius'
  ```
+ Vérifiez si une propriété de carte contient une clé et une valeur données :

  ```
  WHERE p.propertyValue.length = 20.0
  ```
+ Vérifiez si une propriété de carte contient une clé donnée :

  ```
  WHERE NOT p.propertyValue.length IS MISSING
  ```
+ Vérifiez si une propriété de liste contient une valeur donnée :

  ```
  WHERE 10.0 IN p.propertyValue
  ```
+ Utilisez cette `lower()` fonction pour les comparaisons sans distinction majuscules/majuscules. Par défaut, toutes les comparaisons font la distinction majuscules/minuscules.

  ```
  WHERE lower(p.propertyValue) = 'meeting'
  ```

**COMME** :  
Utile si vous ne connaissez pas la valeur exacte d'un champ et que vous pouvez effectuer une recherche en texte intégral sur le champ spécifié. `%`représente zéro ou plus.  

```
WHERE e.entityName LIKE '%room%'
```
+ Recherche d'infixes : `%room%`
+ Recherche par préfixe : `room%`
+ Recherche de suffixes : `%room`
+ Si vous avez « % » dans vos valeurs, insérez un caractère d'échappement dans `LIKE` et spécifiez le caractère d'échappement avec`ESCAPE`.

```
WHERE e.entityName LIKE 'room\%' ESCAPE '\'
```

**DISTINCT** :  

```
SELECT DISTINCT c.componentTypeId
FROM EntityGraph MATCH (e), e.components AS c
```
+ Le `DISTINCT` mot clé élimine les doublons du résultat final.

  `DISTINCT`n'est pas pris en charge sur les types de données complexes.

**COMPTER**  

```
SELECT COUNT(e), COUNT(c.componentTypeId)
FROM EntityGraph MATCH (e), e.components AS c
```
+ Le `COUNT` mot clé calcule le nombre d'éléments dans le résultat d'une requête.
+ `COUNT`n'est pas pris en charge sur les champs complexes imbriqués et les champs de modèle graphique.
+ `COUNT`l'agrégation n'est pas prise en charge par `DISTINCT` les requêtes imbriquées.

  Par exemple, `COUNT(DISTINCT e.entityId)` n’est pas pris en charge.

**CHEMIN**  
Les projections de modèles suivantes sont prises en charge lors des requêtes utilisant la projection de trajectoire :  
+ Requêtes à sauts variables

  ```
  SELECT p FROM EntityGraph MATCH p = (a)-[]->{1, 3}(b)
  ```

  Cette requête fait correspondre et projette les métadonnées des nœuds de tous les modèles présentant des bords sortants depuis le nœud *a* en 1 à 3 sauts.
+ Requêtes à saut fixe

  ```
  SELECT p FROM EntityGraph MATCH p = (a)-[]->(b)<-[]-(c)
  ```

  Cette requête fait correspondre et projette les métadonnées des entités et des arêtes entrantes vers *b.*
+ Requêtes non dirigées

  ```
  SELECT p FROM EntityGraph MATCH p = (a)-[]-(b)-[]-(c)
  ```

  Cette requête correspond et projette les métadonnées des nœuds dans des modèles à 1 saut reliant *a* et *c* via *b.*

  ```
  {
      "columnDescriptions": [
          {
              "name": "path",
              "type": "PATH"
          }
      ],
      "rows": [
          {
              "rowData": [
                  {
                      "path": [
                          {
                              "entityId": "a",
                              "entityName": "a"
                          },
                          {
                              "relationshipName": "a-to-b-relation",
                              "sourceEntityId": "a",
                              "targetEntityId": "b"
                          },
                          {
                              "entityId": "b",
                              "entityName": "b"
                          }
                      ]
                  }
              ]
          },
          {
              "rowData": [
                  {
                      "path": [
                          {
                              "entityId": "b",
                              "entityName": "b"
                          },
                          {
                              "relationshipName": "b-to-c-relation",
                              "sourceEntityId": "b",
                              "targetEntityId": "c"
                          },
                          {
                              "entityId": "c",
                              "entityName": "c"
                          }
                      ]
                  }
              ]
          }
      ]
  }
  ```

  Cette réponse à la `PATH` requête comprend uniquement des métadonnées qui identifient tous les nœuds et les arêtes de chacun path/pattern entre *a* et *c* via *b.*

**LIMITE** et **DÉCALAGE** :  

```
SELECT e.entityName
FROM EntityGraph MATCH (e)
WHERE e.entityName LIKE 'room_%'
LIMIT 10
OFFSET 5
```
`LIMIT`indique le nombre de résultats à renvoyer dans la requête, ainsi `OFFSET` que le nombre de résultats à ignorer.

**LIMIT** et **MaxResults** :  
L'exemple suivant montre une requête qui renvoie 500 résultats au total, mais qui n'en affiche que 50 à la fois par appel d'API. Ce modèle peut être utilisé lorsque vous devez limiter le nombre de résultats affichés, par exemple si vous ne pouvez afficher que 50 résultats dans une interface utilisateur.  

```
aws iottwinmaker execute-query \
--workspace-id exampleWorkspace \
--query-statement "SELECT e FROM EntityGraph MATCH (e) LIMIT 500"\
--max-results 50
```
+ Le `LIMIT` mot clé affecte la requête et limite les lignes qui en résultent. Si vous devez contrôler le nombre de résultats renvoyés par appel d'API sans limiter le nombre total de résultats renvoyés, utilisez`LIMIT`.
+ `max-results`est un paramètre facultatif pour l'[action d'ExecuteQuery API](https://docs.aws.amazon.com//iot-twinmaker/latest/apireference/API_ExecuteQuery.html). `max-results`s'applique uniquement à l'API et à la façon dont les résultats sont lus dans les limites de la requête ci-dessus.

  L'utilisation `max-results` dans une requête vous permet de réduire le nombre de résultats affichés sans limiter le nombre réel de résultats renvoyés.
La requête ci-dessous passe par la page de résultats suivante. Cette requête utilise l'appel d'`ExecuteQuery`API pour renvoyer les lignes 51 à 100, où la page de résultats suivante est spécifiée par le `next-token` — dans ce cas, le jeton est :. `"H7kyGmvK376L"`  

```
aws iottwinmaker execute-query \
--workspace-id exampleWorkspace \
--query-statement "SELECT e FROM EntityGraph MATCH (e) LIMIT 500"\
--max-results 50
--next-token "H7kyGmvK376L"
```
+ La `next-token` chaîne indique la page de résultats suivante. Pour plus d'informations, consultez l'action de [ ExecuteQuery](https://docs.aws.amazon.com//iot-twinmaker/latest/apireference/API_ExecuteQuery.html#API_ExecuteQuery_RequestSyntax)l'API.

AWS IoT TwinMaker Les limites d'une requête Knowledge Graph sont les suivantes : 


****  

| Nom de la limite | Quota | Ajustable | 
| --- | --- | --- | 
|  Délai d'exécution de la requête  | 10 secondes | Non | 
|  Nombre maximum de sauts  | 10 | Oui | 
|  Nombre maximum de `JOIN` self-s  | 20 | Oui | 
|  Nombre maximum de champs projetés  | 20 | Oui | 
|  Nombre maximum d'expressions conditionnelles (`AND`,`OR`,`NOT`)  | 10 | Oui | 
|  Longueur maximale d'un modèle d'`LIKE`expression (y compris les caractères génériques et les échappements)  | 20 | Oui | 
| Nombre maximum d'éléments pouvant être spécifiés dans une IN clause | 10 | Oui | 
| Valeur maximale pour OFFSET | 3000 | Oui | 
|  Valeur maximale pour `LIMIT`  | 3000 | Oui | 
|  Valeur maximale pour les traversées (`OFFSET`\$1`LIMIT`)  | 3000 | Oui |