Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

# AWS IoT TwinMaker Wissensgraph
<a name="tm-knowledge-graph"></a>

Der AWS IoT TwinMaker Wissensgraph organisiert alle in Ihren AWS IoT TwinMaker Arbeitsbereichen enthaltenen Informationen und präsentiert sie in einem visuellen Grafikformat. Sie können Abfragen für Ihre Entitäten, Komponenten und Komponententypen ausführen, um visuelle Diagramme zu erstellen, die Ihnen die Beziehungen zwischen Ihren AWS IoT TwinMaker Ressourcen zeigen.

In den folgenden Themen erfahren Sie, wie Sie den Knowledge Graph verwenden und integrieren.

**Topics**
+ [

## AWS IoT TwinMaker Kernkonzepte des Wissensgraphen
](#tm-knowledge-graph-concepts)
+ [

# Wie führe ich AWS IoT TwinMaker Knowledge-Graph-Abfragen aus
](tm-knowledge-graph-use.md)
+ [

# Integration von Knowledge Graph-Szenen
](tm-knowledge-graph-scene.md)
+ [

# Wie benutzt man AWS IoT TwinMaker Knowledge Graph mit Grafana
](tm-knowledge-Grafana-panel.md)
+ [

# AWS IoT TwinMaker Knowledge Graph, zusätzliche Ressourcen
](tm-knowledge-graph-resources.md)

## AWS IoT TwinMaker Kernkonzepte des Wissensgraphen
<a name="tm-knowledge-graph-concepts"></a>

Dieses Thema behandelt die wichtigsten Konzepte und das Vokabular der Knowledge-Graph-Funktion.

**So funktioniert der Knowledge Graph**:  
Der Wissensgraph stellt Beziehungen zwischen Entitäten und ihren Komponenten zum vorhandenen [CreateEntity](https://docs.aws.amazon.com//iot-twinmaker/latest/apireference/API_CreateEntity.html)oder her [ UpdateEntity](https://docs.aws.amazon.com//iot-twinmaker/latest/apireference/API_UpdateEntity.html) APIs. Eine Beziehung ist nur eine Eigenschaft eines speziellen Datentyps [BEZIEHUNG](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), die für eine Komponente einer Entität definiert ist. AWS IoT TwinMaker Knowledge Graph ruft die [ExecuteQuery](https://docs.aws.amazon.com/iot-twinmaker/latest/apireference/API_ExecuteQuery.html)API auf, um eine Abfrage auf der Grundlage von Daten in den Entitäten oder den Beziehungen zwischen ihnen durchzuführen. Knowledge Graph verwendet die flexible PartiQL-Abfragesprache (die von vielen AWS Diensten verwendet wird), die neu hinzugefügte Graph-Match-Syntaxunterstützung bietet, um Ihnen beim Schreiben Ihrer Abfragen zu helfen. Nachdem die Aufrufe getätigt wurden, können Sie die Ergebnisse als Tabelle anzeigen oder sie als Diagramm verbundener Knoten und Kanten visualisieren.

**Wichtige Begriffe im Knowledge Graph**:  
+ **Entitätsgraph**: Eine Sammlung von Knoten und Kanten innerhalb eines Workspace.
+ **Knoten**: Jede Entität in Ihrem Workspace wird zu einem Knoten im Entitätsdiagramm.
+ **Kante**: Jede für eine Komponente einer Entität definierte Beziehungseigenschaft wird zu einer Kante im Entitätsgraphen. Darüber hinaus wird eine hierarchische Eltern-Kind-Beziehung, die mithilfe des parentEntityId Felds einer Entität definiert wurde, auch zu einer Kante im Entitätsdiagramm mit einem Beziehungsnamen "isChildOf". Alle Kanten sind Richtungskanten.
+ **Beziehung**: Eine AWS IoT TwinMaker Beziehung ist ein besonderer Eigenschaftstyp einer Entitätskomponente. Sie können die [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)oder verwenden, um eine Beziehung zu definieren und zu bearbeiten. AWS IoT TwinMaker In muss eine Beziehung in einer Komponente einer Entität definiert werden. Eine Beziehung kann nicht als isolierte Ressource definiert werden. Eine Beziehung muss von einer Entität zur anderen gerichtet sein.

# Wie führe ich AWS IoT TwinMaker Knowledge-Graph-Abfragen aus
<a name="tm-knowledge-graph-use"></a>

Bevor Sie den AWS IoT TwinMaker Knowledge Graph verwenden, stellen Sie sicher, dass Sie die folgenden Voraussetzungen erfüllt haben:
+ Erstellen Sie einen AWS IoT TwinMaker Arbeitsbereich. Sie können einen Workspace in der [AWS IoT TwinMaker Konsole](https://console.aws.amazon.com/iottwinmaker/) erstellen.
+ Machen Sie sich mit dem AWS IoT TwinMaker Entity-Component-System und der Erstellung von Entitäten vertraut. Weitere Informationen finden Sie unter [Erstellen Sie Ihre erste Entität](twinmaker-gs-entity.md).
+ Machen Sie sich mit den AWS IoT TwinMaker Datenkonnektoren vertraut. Weitere Informationen finden Sie unter [AWS IoT TwinMaker Datenanschlüsse](data-connector-interface.md).

**Anmerkung**  
Um den AWS IoT TwinMaker Knowledge Graph verwenden zu können, müssen Sie entweder den **Standard** - oder den **gestaffelten Paketpreis gewählt** haben. Weitere Informationen finden Sie unter [AWS IoT TwinMaker Preismodus wechseln](tm-pricing-mode.md).

Die folgenden Verfahren zeigen Ihnen, wie Sie Abfragen schreiben, ausführen, speichern und bearbeiten.

 **Öffnen Sie den Abfrage-Editor**   

**Um zum Knowledge Graph-Abfrage-Editor zu navigieren**

1. Öffnen Sie die [AWS IoT TwinMaker -Konsole](https://console.aws.amazon.com/iottwinmaker/).

1. Öffnen Sie den Arbeitsbereich, in dem Sie den Knowledge Graph verwenden möchten.

1. Wählen Sie im linken Navigationsmenü den **Abfrage-Editor**.

1. Der Abfrage-Editor wird geöffnet. Sie sind jetzt bereit, Abfragen für die Ressourcen Ihres Workspace auszuführen.

 **Führen Sie eine Abfrage aus**   

**Um eine Abfrage auszuführen und ein Diagramm zu generieren**

1. Wählen Sie im Abfrage-Editor die Registerkarte **Editor**, um den Syntaxeditor zu öffnen.

1. Schreiben Sie im Editor-Bereich die Abfrage, die Sie für die Ressourcen Ihres Workspace ausführen möchten.  
![\[Der Editor-Bereich, in dem eine Abfrage eingegeben wurde.\]](http://docs.aws.amazon.com/de_de/iot-twinmaker/latest/guide/images/kg-query-updated.png)

   In dem gezeigten Beispiel sucht die Anfrage nach Entitäten, die `vav_%` in ihrem Namen enthalten, und organisiert diese Entitäten dann anhand der `feed` Beziehung zwischen ihnen. Dabei wird der folgende Code verwendet.

   ```
   SELECT ahu, vav, r FROM EntityGraph
   MATCH (vav)<-[r:feed]-(ahu)
   WHERE vav.entityName LIKE 'vav_%'
   ```
**Anmerkung**  
Die Knowledge Graph-Syntax verwendet [PartiQL](https://partiql.org/). Informationen zu dieser Syntax finden Sie unter[AWS IoT TwinMaker Knowledge Graph, zusätzliche Ressourcen](tm-knowledge-graph-resources.md).

1. Wählen Sie **Abfrage ausführen**, um die von Ihnen erstellte Anforderung auszuführen.

   Auf der Grundlage Ihrer Anfrage wird ein Diagramm generiert.  
![\[Ein Diagramm mit den Ergebnissen der Abfrage, die in den vorherigen Schritten detailliert beschrieben wurden.\]](http://docs.aws.amazon.com/de_de/iot-twinmaker/latest/guide/images/tm-kg-graph-output.png)

   Das oben gezeigte Beispieldiagramm basiert auf dem Abfragebeispiel in Schritt 2.

1. Die Ergebnisse der Abfrage werden auch in einer Liste dargestellt. Wählen Sie **Ergebnisse** aus, um die Abfrageergebnisse in einer Liste anzuzeigen.

1. Wählen Sie optional **Exportieren als**, um die Abfrageergebnisse im JSON- oder CSV-Format zu exportieren.

Dies deckt die grundlegende Verwendung von Knowledge Graph in der Konsole ab. Weitere Informationen und Beispiele zur Veranschaulichung der Knowledge Graph-Syntax finden Sie unter[AWS IoT TwinMaker Knowledge Graph, zusätzliche Ressourcen](tm-knowledge-graph-resources.md).

# Integration von Knowledge Graph-Szenen
<a name="tm-knowledge-graph-scene"></a>

Sie können AWS IoT App-Kit-Komponenten verwenden, um eine Webanwendung zu erstellen, die den Knowledge Graph in Ihre AWS IoT TwinMaker Szenen integriert. Auf diese Weise können Sie Diagramme erstellen, die auf den 3D-Knoten (den 3D-Modellen, die Ihre Ausrüstung oder Systeme repräsentieren) basieren, die in Ihrer Szene vorhanden sind. Um eine Anwendung zu erstellen, die 3D-Knoten aus Ihrer Szene grafisch darstellt, binden Sie die 3D-Knoten zunächst an Entitäten in Ihrem Workspace. Mit diesem Mapping werden die Beziehungen zwischen den in Ihrer Szene vorhandenen 3D-Modellen und den Entitäten in Ihrem Workspace AWS IoT TwinMaker grafisch dargestellt. Anschließend können Sie eine Webanwendung erstellen, 3D-Modelle mit Ihrer Szene auswählen und deren Beziehungen zu anderen Entitäten in einem Grafikformat untersuchen.

![\[Eine TwinMaker Szene mit einem Wissensdiagramm, das die Beziehungen zwischen 3D-Modellen zeigt.\]](http://docs.aws.amazon.com/de_de/iot-twinmaker/latest/guide/images/intro_kg_scene.png)


Ein Beispiel für eine funktionierende Webanwendung, die die AWS IoT App-Kit-Komponenten verwendet, um Diagramme in einer AWS IoT TwinMaker Szene zu generieren, finden Sie in der [AWS IoT TwinMaker Beispiel-React-App](https://github.com/awslabs/iot-app-kit/blob/3DKG_Demo/examples/react-app/src/components/index.tsx) auf Github.

## AWS IoT TwinMaker Voraussetzungen für Szenendiagramme
<a name="tm-knowledge-graph-prereqs"></a>

Bevor Sie eine Web-App erstellen, die AWS IoT TwinMaker Knowledge Graph in Ihren Szenen verwendet, müssen Sie die folgenden Voraussetzungen erfüllen:
+ Erstellen Sie einen AWS IoT TwinMaker Arbeitsbereich. Sie können einen Workspace in der [AWS IoT TwinMaker Konsole](https://console.aws.amazon.com/iottwinmaker/) erstellen.
+ Machen Sie sich mit dem AWS IoT TwinMaker Entity-Component-System und der Erstellung von Entitäten vertraut. Weitere Informationen finden Sie unter [Erstellen Sie Ihre erste Entität](twinmaker-gs-entity.md).
+ Erstellen Sie eine mit 3D-Modellen gefüllte AWS IoT TwinMaker Szene.
+ Machen Sie sich mit AWS IoT TwinMaker den Komponenten des AWS IoT App-Kits vertraut. Weitere Informationen zu den AWS IoT TwinMaker Komponenten finden Sie unter[Erstellen Sie eine benutzerdefinierte Webanwendung mithilfe von AWS IoT TwinMaker UI-Komponenten](tm-app-kit.md).
+ Machen Sie sich mit den Konzepten und Schlüsselbegriffen von Wissensgraphen vertraut. Siehe [AWS IoT TwinMaker Kernkonzepte des Wissensgraphen](tm-knowledge-graph.md#tm-knowledge-graph-concepts).

**Anmerkung**  
Um den AWS IoT TwinMaker Knowledge Graph und alle zugehörigen Funktionen nutzen zu können, müssen Sie entweder den **Standard** - oder den **gestaffelten** Paketpreis nutzen. Weitere Informationen zur AWS IoT TwinMaker Preisgestaltung finden Sie unter[AWS IoT TwinMaker Preismodus wechseln](tm-pricing-mode.md).

## Binden Sie 3D-Knoten in Ihrer Szene
<a name="tm-knowledge-graph-scene-data-binidng"></a>

Bevor Sie eine Web-App erstellen, die Knowledge Graph in Ihre Szene integriert, binden Sie die in Ihrer Szene vorhandenen 3D-Modelle, die als 3D-Knoten bezeichnet werden, an die zugehörige Workspace-Entität. Wenn Sie beispielsweise ein Modell einer Mixer-Ausrüstung in einer Szene haben und eine entsprechende Entität aufgerufen wird`mixer_0`, erstellen Sie eine **Datenbindung** zwischen dem Modell des Mixers und der Entität, die den Mixer darstellt, sodass das Modell und die Entität grafisch dargestellt werden können.

**Um eine Datenbindungsaktion durchzuführen**

1. Melden Sie sich bei der [AWS IoT TwinMaker -Konsole](https://console.aws.amazon.com/iottwinmaker/) an.

1. Öffnen Sie Ihren Workspace und wählen Sie eine Szene mit den 3D-Knoten aus, die Sie binden möchten.

1. Wählen Sie im Scene Composer einen Knoten (3D-Modell) aus. Wenn Sie einen Knoten auswählen, wird ein Inspektorfenster auf der rechten Seite des Bildschirms geöffnet.

1. Navigieren Sie im Inspektorfenster zum oberen Rand des Bedienfelds und wählen Sie die Schaltfläche **\$1** aus. Wählen Sie dann die Option **Entitätsbindung hinzufügen**. Dadurch wird ein Drop-down-Menü geöffnet, in dem Sie eine Entität auswählen können, die an Ihren aktuell ausgewählten Knoten gebunden werden soll.  
![\[Eine Szene, bei der das Pluszeichen im Inspektorfenster ausgewählt und Entitätsbindung hinzufügen markiert ist.\]](http://docs.aws.amazon.com/de_de/iot-twinmaker/latest/guide/images/binding-step-4.png)

1. Wählen Sie im Dropdownmenü Datenbindung die Entitäts-ID aus, die Sie dem 3D-Modell zuordnen möchten. Wählen Sie in den Feldern **Komponentenname** **und Eigenschaftsname** die Komponenten und Eigenschaften aus, die Sie binden möchten.  
![\[Eine Szene, bei der die Komponenten- und Eigenschaftsnamen im Inspektorfenster ausgewählt wurden.\]](http://docs.aws.amazon.com/de_de/iot-twinmaker/latest/guide/images/binding-step-6.png)

   Sobald Sie eine Auswahl für die Felder **Entitäts-ID**, **Komponentenname** und **Eigenschaftsname** getroffen haben, ist die Bindung abgeschlossen.

1. Wiederholen Sie diesen Vorgang für alle Modelle und Entitäten, die Sie grafisch darstellen möchten.
**Anmerkung**  
Derselbe Datenbindungsvorgang kann für Ihre Szenen-Tags ausgeführt werden. Wählen Sie einfach ein Tag anstelle einer Entität aus und folgen Sie demselben Verfahren, um das Tag an einen Knoten zu binden.

## Erstellen Sie eine Webanwendung
<a name="tm-knowledge-graph-scene-application"></a>

Nachdem Sie Ihre Entitäten gebunden haben, verwenden Sie die AWS IoT App-Kit-Bibliothek, um eine Web-App mit einem Knowledge-Graph-Widget zu erstellen, mit dem Sie Ihre Szene anzeigen und die Beziehungen zwischen Ihren Szenenknoten und Entitäten untersuchen können.

Verwenden Sie die folgenden Ressourcen, um Ihre eigene App zu erstellen:
+ Die [Github-Readme-Dokumentation zum AWS IoT TwinMaker Beispiel für die React-App](https://github.com/awslabs/iot-app-kit/blob/3DKG_Demo/examples/react-app/README.md).
+ Die AWS IoT TwinMaker [Beispielquelle](https://github.com/awslabs/iot-app-kit/blob/3DKG_Demo/examples/react-app/src/components/index.tsx) für die React-App auf Github.
+ Die Dokumentation „[Erste Schritte](https://awslabs.github.io/iot-app-kit/?path=/docs/overview-getting-started--docs)“ für das AWS IoT App-Kit.
+ Die Dokumentation zur [Video Player-Komponente](https://awslabs.github.io/iot-app-kit/?path=/docs/components-videoplayer--docs) für das AWS IoT App-Kit.
+ Die Dokumentation zur [Scene Viewer-Komponente des AWS IoT](https://awslabs.github.io/iot-app-kit/?path=/docs/components-sceneviewer--docs) App-Kits.

Das folgende Verfahren veranschaulicht die Funktionalität der Scene Viewer-Komponente in einer Web-App.

**Anmerkung**  
Dieses Verfahren basiert auf der Implementierung der AWS IoT App Kit Scene Viewer-Komponente in der AWS IoT TwinMaker React-Beispiel-App.

1. Öffnen Sie die Scene Viewer-Komponente der AWS IoT TwinMaker React-Beispiel-App. Geben Sie im Suchfeld einen Entitätsnamen oder einen Teil des Entitätsnamens ein (bei der Suche wird Groß- und Kleinschreibung beachtet) und wählen Sie dann die Schaltfläche **Suchen** aus. Wenn ein Modell an die Entitäts-ID gebunden ist, wird das Modell in der Szene hervorgehoben und ein Knoten der Entität wird im Scene Viewer-Fenster angezeigt.  
![\[Eine Szene, in der das Knowledge Graph-Szenen-Viewer-Fenster angezeigt wird.\]](http://docs.aws.amazon.com/de_de/iot-twinmaker/latest/guide/images/search_select_kg_event.png)

1. Um ein Diagramm aller Beziehungen zu erstellen, wählen Sie einen Knoten im Scene Viewer-Widget aus und klicken Sie auf die Schaltfläche „**Erkunden**“.  
![\[Eine Szene mit dem Knowledge Graph-Szenen-Viewer-Fenster, das ein Diagramm der Beziehungen anzeigt.\]](http://docs.aws.amazon.com/de_de/iot-twinmaker/latest/guide/images/explore_select_kg.png)

1. Drücken Sie die Taste **Löschen**, um Ihre aktuelle Grafikauswahl zu löschen und von vorne zu beginnen.

# Wie benutzt man AWS IoT TwinMaker Knowledge Graph mit Grafana
<a name="tm-knowledge-Grafana-panel"></a>

In diesem Abschnitt erfahren Sie, wie Sie Ihrem AWS IoT TwinMaker Grafana-Dashboard einen Abfrage-Editor hinzufügen, um Abfragen auszuführen und anzuzeigen.

## AWS IoT TwinMaker Voraussetzungen für den Abfrageeditor
<a name="tm-knowledge-graph-Grafana-prereqs"></a>

Bevor Sie den AWS IoT TwinMaker Knowledge Graph in Grafana verwenden, müssen Sie die folgenden Voraussetzungen erfüllen:
+ Erstellen Sie einen AWS IoT TwinMaker Arbeitsbereich. Sie können einen Workspace in der [AWS IoT TwinMaker Konsole](https://console.aws.amazon.com/iottwinmaker/) erstellen.
+  AWS IoT TwinMaker Für die Verwendung mit Grafana konfigurieren. Detaillierte Anweisungen finden Sie unter [AWS IoT TwinMaker Grafana-Dashboard-Integration](grafana-integration.md).

**Anmerkung**  
Um den AWS IoT TwinMaker Knowledge Graph verwenden zu können, müssen Sie entweder den **Standard** - oder den **gestaffelten Paketpreismodus** verwenden. Weitere Informationen finden Sie unter [AWS IoT TwinMaker Preismodus wechseln](tm-pricing-mode.md).

## AWS IoT TwinMaker Berechtigungen für den Abfrageeditor
<a name="tm-knowledge-graph-Grafana-config"></a>

Um den AWS IoT TwinMaker Abfrage-Editor in Grafana verwenden zu können, benötigen Sie eine IAM-Rolle mit der Berechtigung für die Aktion. `iottwinmaker:ExecuteQuery` Fügen Sie diese Berechtigung zu Ihrer Workspace-Dashboard-Rolle hinzu, wie in diesem Beispiel gezeigt:

------
#### [ 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": "*"
        }
    ]
}
```

------

**Anmerkung**  
Wenn Sie Ihre AWS IoT TwinMaker Grafana-Datenquelle konfigurieren, stellen Sie sicher, dass Sie die Rolle mit dieser Berechtigung für das **ARN-Feld Rolle annehmen** verwenden. **Nachdem Sie es hinzugefügt haben, können Sie Ihren Workspace aus dem Drop-down-Menü neben Workspace auswählen.**

Weitere Informationen finden Sie unter [Eine Dashboard-IAM-Rolle erstellen](dashboard-IAM-role.md#dashboard-IAM-role.title).

### Richten Sie den AWS IoT TwinMaker Abfrage-Editor ein
<a name="tm-knowledge-graph-Grafana-panel"></a>

**Um ein neues Grafana-Dashboard-Panel für Knowledge Graph einzurichten**

1. Öffnen Sie Ihr AWS IoT TwinMaker Grafana-Dashboard.

1. Erstellen Sie ein neues **Dashboard-Panel**. Ausführliche Schritte zum Erstellen eines Panels finden Sie unter [Erstellen eines Dashboards](https://grafana.com/docs/grafana/latest/dashboards/build-dashboards/create-dashboard/) in der Grafana-Dokumentation.

1. **Wählen AWS IoT TwinMaker Sie aus der Liste der Visualisierungen den Abfrage-Editor aus.**  
![\[Die Dropdownliste im AWS IoT TwinMaker Dashboard enthält die Option für den AWS IoT TwinMaker Abfrage-Editor.\]](http://docs.aws.amazon.com/de_de/iot-twinmaker/latest/guide/images/tw-query-editor-dropdown.png)

1. Wählen Sie die Datenquelle aus, für die Abfragen ausgeführt werden sollen.

1. **(Optional)** Fügen Sie im dafür vorgesehenen Feld einen Namen für das neue Panel hinzu.

1. Wählen Sie **Anwenden**, um Ihr neues Panel zu speichern und zu bestätigen.

Das Knowledge-Graph-Panel funktioniert auf ähnliche Weise wie der Abfrage-Editor in der AWS IoT TwinMaker Konsole. Sie können Abfragen, die Sie im Panel stellen, ausführen, schreiben und löschen. Weitere Informationen zum Schreiben von Abfragen finden Sie unter[AWS IoT TwinMaker Knowledge Graph, zusätzliche Ressourcen](tm-knowledge-graph-resources.md).

#### Wie benutzt man den AWS IoT TwinMaker Abfrage-Editor
<a name="tm-knowledge-graph-Grafana-use"></a>

Die Ergebnisse Ihrer Abfragen werden auf drei Arten angezeigt, wie in den folgenden Bildern dargestellt: in einem Diagramm visualisiert, in einer Tabelle aufgeführt oder als Zusammenfassung der Ausführung dargestellt.
+ **Graphische Visualisierung:**  
![\[AWS IoT TwinMaker Die Ergebnisse des Abfrageeditors werden als visuelles Diagramm angezeigt.\]](http://docs.aws.amazon.com/de_de/iot-twinmaker/latest/guide/images/kg-vis-graph.png)

  Das visuelle Diagramm zeigt nur Daten für Abfragen an, deren Ergebnis mindestens eine Beziehung enthält. In der Grafik werden Entitäten als Knoten und Beziehungen als gerichtete Kanten im Diagramm angezeigt.
+ **Tabellarische Daten:**  
![\[AWS IoT TwinMaker Die Ergebnisse des Abfrage-Editors werden als tabellarische Daten angezeigt.\]](http://docs.aws.amazon.com/de_de/iot-twinmaker/latest/guide/images/kg-table-data.png)

  Das tabellarische Datenformat zeigt die Daten für alle Abfragen an. Sie können die Tabelle nach bestimmten Ergebnissen oder Teilmengen der Ergebnisse durchsuchen. Die Daten können im JSON- oder CSV-Format exportiert werden.
+ **Zusammenfassung ausführen**  
![\[AWS IoT TwinMaker Die Ergebnisse des Abfrage-Editors werden als Zusammenfassung der Ausführung angezeigt.\]](http://docs.aws.amazon.com/de_de/iot-twinmaker/latest/guide/images/kg-run-sum.png)

  In der Ausführungszusammenfassung werden die Abfrage und Metadaten zum Status der Abfrage angezeigt.

# AWS IoT TwinMaker Knowledge Graph, zusätzliche Ressourcen
<a name="tm-knowledge-graph-resources"></a>

Dieser Abschnitt enthält grundlegende Beispiele für die PartiQL-Syntax, die zum Schreiben von Abfragen im Knowledge Graph verwendet wird, sowie Links zur PartiQL-Dokumentation, die Informationen zum Knowledge Graph-Datenmodell enthält.
+ [ Dokumentation zum PartiQL-Diagrammdatenmodell](https://partiql.org/gpml/graph_model.html)
+ [ Dokumentation zur PartiQL-Diagrammabfrage](https://partiql.org/gpml/graph_query.html)

Diese Reihe von Beispielen zeigt grundlegende Abfragen mit ihren Antworten. Verwenden Sie dies als Referenz, um Ihre eigenen Abfragen zu schreiben.

**Grundlegende Abfragen**  
+ **Ruft alle Entitäten mit einem Filter ab**

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

   Diese Abfrage gibt alle Entitäten in einem Workspace mit dem Namen zurück`room_0`.

  `FROM`Klausel: `EntityGraph` ist die Grafiksammlung, die alle Entitäten und ihre Beziehungen in einem Workspace enthält. Diese Sammlung wird automatisch auf der AWS IoT TwinMaker Grundlage der Entitäten in Ihrem Workspace erstellt und verwaltet.

  `MATCH`Klausel: gibt ein Muster an, das einem Teil des Diagramms entspricht. In diesem Fall `(entity)` entspricht das Muster jedem Knoten im Diagramm und ist an die Entitätsvariable gebunden. Auf die `FROM` Klausel muss die `MATCH` Klausel folgen.

  `WHERE`Klausel: gibt einen Filter für das `entityName` Feld des Knotens an, mit dem der Wert übereinstimmen muss`room_0`.

  `SELECT`Klausel: spezifiziert die `entity` Variable, sodass der gesamte Entitätsknoten zurückgegeben wird.

  **Antwort:**

  ```
  {
    "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
                  }
                ]
              }
            ]
          }
        ]
      }
    ]
  }
  ```

  Die `columnDescriptions` gibt Metadaten über die Spalte zurück, z. B. den Namen und den Typ. Der zurückgegebene Typ ist`NODE`. Dies zeigt an, dass der gesamte Knoten zurückgegeben wurde. Andere Werte für den Typ können sein`EDGE`, die auf eine Beziehung hinweisen würden`VALUE`, oder die auf einen Skalarwert hinweisen würden, z. B. eine Ganzzahl oder eine Zeichenfolge.

  Das `rows` gibt eine Liste von Zeilen zurück. Da nur eine Entität gefunden wurde, `rowData` wird eine zurückgegeben, die alle Felder einer Entität enthält.
**Anmerkung**  
Im Gegensatz zu SQL, wo Sie nur Skalarwerte zurückgeben können, können Sie ein Objekt (als JSON) mit PartiQL zurückgeben.

  Jeder Knoten enthält alle Felder auf Entitätsebene wie `entityId` `arn` und `components` Felder auf Komponentenebene wie und sowie Felder auf Eigenschaftsebene `properties` wie `componentTypeId` und`componentName`, alles als verschachteltes JSON. `propertyName` `propertyValue`
+ **Ruft alle Beziehungen mit einem Filter ab:**

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

  Diese Abfrage gibt alle Beziehungen in einem Arbeitsbereich mit dem Beziehungsnamen zurück`isLocationOf`.

   Die `MATCH` Klausel: gibt ein Muster an, das zwei Knoten (gekennzeichnet durch`()`) entspricht, die durch eine gerichtete Kante (gekennzeichnet durch`-[]->`) miteinander verbunden und an eine Variable gebunden sind, die aufgerufen wird`relationship`.

  Die `WHERE` Klausel: gibt einen Filter für das `relationshipName` Feld der Kante an, in dem sich der Wert befindet`isLocationOf`.

  Die `SELECT` Klausel: gibt die Beziehungsvariable an, sodass der gesamte Kantenknoten zurückgegeben wird.

  **Antwort**

  ```
  {
      "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
      ]
  }
  ```

  Der Typ der Spalte in `columnDescriptions` ist ein`EDGE`.

  Jedes `rowData` steht für eine Kante mit Feldern wie`relationshipName`. Dies entspricht dem Namen der Beziehungseigenschaft, der für die Entität definiert ist. Die`sourceEntityId`, `sourceComponentName` und `sourceComponentTypeId` geben Auskunft darüber, für welche Entität und Komponente die Beziehungseigenschaft definiert wurde. Das `targetEntityId` gibt an, auf welche Entität diese Beziehung zeigt.
+ **Ruft alle Entitäten mit einer bestimmten Beziehung zu einer bestimmten Entität ab**

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

  Diese Abfrage gibt alle Entitätsnamen aller Entitäten zurück, die eine `isLocationOf` Beziehung zu der `room_0` Entität haben.

  Die `MATCH` Klausel: gibt ein Muster an, das zwei beliebigen Knoten (`e1`,`e2`) entspricht, die eine gerichtete Kante (`r`) haben.

  Die `WHERE` Klausel: gibt einen Filter für den Beziehungsnamen und den Namen der Quellentität an.

  Die `SELECT` Klausel: gibt das `entityName` Feld im `e2` Knoten zurück.

  **Antwort**

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

  In den ColumnDescriptions ist der Typ der Spalte, `VALUE` da es sich um eine `entityName` Zeichenfolge handelt.

  Eine Entität,`floor_0`, wird zurückgegeben.

**SPIEL**  
Die folgenden Muster werden in einer `MATCH` Klausel unterstützt:  
+ Entspricht dem Knoten 'b', der auf den Knoten 'a' zeigt:

  ```
  FROM EntityGraph MATCH (a)-[rel]-(b)
  ```
+ Ordnet Knoten 'a' zu, der auf Knoten 'b' zeigt:

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

  Es gibt keine Variable, die an eine Beziehung gebunden ist, vorausgesetzt, dass für die Beziehung kein Filter angegeben werden muss.
+ Ordnen Sie Knoten 'a', der auf Knoten 'b' zeigt, und Knoten 'b', der auf Knoten 'a' zeigt, zu:

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

  Dadurch werden zwei Treffer zurückgegeben: eine von 'a' nach 'b' und eine weitere von 'b' nach 'a', daher wird empfohlen, wo immer möglich gerichtete Kanten zu verwenden.
+ Der Beziehungsname ist auch eine Bezeichnung für das Eigenschaftsdiagramm`EntityGraph`, sodass Sie den Beziehungsnamen einfach hinter einem Doppelpunkt (:) angeben können, anstatt `rel.relationshipName` in der `WHERE` Klausel einen Filter für anzugeben.

  ```
  FROM EntityGraph MATCH (a)-[:isLocationOf]-(b)
  ```
+ Verkettung: Muster können so verkettet werden, dass sie in mehreren Beziehungen übereinstimmen.

  ```
  FROM EntityGraph MATCH (a)-[rel1]->(b)-[rel2]-(c)
  ```
+ Variable Hop-Muster können sich auch über mehrere Knoten und Kanten erstrecken:

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

  Diese Abfrage entspricht jedem Muster mit ausgehenden Kanten von Knoten 'a' innerhalb von 1 bis 5 Hops. Die zulässigen Quantifizierer sind:

  `{m,n}`- zwischen m und n Wiederholungen

  `{m,}`- m oder mehr Wiederholungen.

**VON**:  
Ein Entitätsknoten kann verschachtelte Daten enthalten, z. B. Komponenten, die wiederum weitere verschachtelte Daten wie Eigenschaften enthalten. Auf diese kann zugegriffen werden, indem das Ergebnis des MATCH-Musters unverschachtelt wird.  

```
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'
```
Greifen Sie auf verschachtelte Felder zu, indem Sie Punkte in eine Variable einfügen. `.` Ein Komma (,) wird verwendet, um Entitäten mit den darin enthaltenen Komponenten und dann den Eigenschaften innerhalb dieser Komponenten zu trennen (oder zu verbinden). `AS`wird verwendet, um eine Variable an die nicht verschachtelten Variablen zu binden, sodass sie in den OR-Klauseln verwendet werden können. `WHERE` `SELECT` Diese Abfrage gibt alle Entitäten zurück, die eine mit einem Wert benannte Eigenschaft `meeting` in einer Komponente `roomFunction` mit der Komponententyp-ID enthalten `com.example.query.construction.room`   
Um auf mehrere verschachtelte Felder eines Felds zuzugreifen, z. B. auf mehrere Komponenten in einer Entität, verwenden Sie die Komma-Notation, um eine Verknüpfung durchzuführen.  

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

**WÄHLEN SIE:**  
+ Einen Knoten zurückgeben:

  ```
  SELECT e
  FROM EntityGraph MATCH (e)
  ```
+ Gibt eine Kante zurück:

  ```
  SELECT r
  FROM EntityGraph MATCH (e1)-[r]->(e2)
  ```
+ Gibt einen Skalarwert zurück:

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

  Formatieren Sie den Namen des Ausgabefeldes, indem Sie ihn mit einem Alias versehen. `AS` Hier wird statt `propertyValue` als Spaltenname in der Antwort `roomfunction` zurückgegeben.
+ Aliase zurückgeben:

  ```
  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%'
  ```

  Es wird dringend empfohlen, Aliase zu verwenden, um explizit zu sein, die Lesbarkeit zu erhöhen und Mehrdeutigkeiten in Ihren Abfragen zu vermeiden.

**WO:**  
+ Die unterstützten logischen Operatoren sind `AND``NOT`, und`OR`.
+ Die unterstützten Vergleichsoperatoren sind `<``<=`,`>`,`=>`,`=`, und`!=`.
+ Verwenden Sie das `IN` Schlüsselwort, wenn Sie mehrere `OR` Bedingungen für dasselbe Feld angeben möchten.
+ Filtern Sie nach einem Entitäts-, Komponenten- oder Eigenschaftsfeld:

  ```
  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'
  ```
+ Filtern Sie nach der `configuration` Eigenschaft. Hier `unit` ist der Schlüssel in der Konfigurationsübersicht und der `Celsius` Wert.

  ```
  WHERE p.definition.configuration.unit = 'Celsius'
  ```
+ Prüfen Sie, ob eine Karteneigenschaft einen bestimmten Schlüssel und Wert enthält:

  ```
  WHERE p.propertyValue.length = 20.0
  ```
+ Prüft, ob eine Karteneigenschaft einen bestimmten Schlüssel enthält:

  ```
  WHERE NOT p.propertyValue.length IS MISSING
  ```
+ Prüft, ob eine Listeneigenschaft einen bestimmten Wert enthält:

  ```
  WHERE 10.0 IN p.propertyValue
  ```
+ Verwenden Sie die `lower()` Funktion für Vergleiche ohne Berücksichtigung der Groß- und Kleinschreibung. Standardmäßig wird bei allen Vergleichen zwischen Groß- und Kleinschreibung unterschieden.

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

**WIE**:  
Nützlich, wenn Sie den genauen Wert für ein Feld nicht kennen und eine Volltextsuche für das angegebene Feld durchführen können. `%`steht für Null oder mehr.  

```
WHERE e.entityName LIKE '%room%'
```
+ Infix-Suche: `%room%`
+ Präfix-Suche: `room%`
+ Suffix-Suche: `%room`
+ Wenn Ihre Werte '%' enthalten, fügen Sie ein Escape-Zeichen ein `LIKE` und geben Sie das Escape-Zeichen mit `ESCAPE` an.

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

**EINDEUTIG**:  

```
SELECT DISTINCT c.componentTypeId
FROM EntityGraph MATCH (e), e.components AS c
```
+ Das `DISTINCT` Schlüsselwort entfernt Duplikate aus dem Endergebnis.

  `DISTINCT`wird bei komplexen Datentypen nicht unterstützt.

**ZÄHLEN**  

```
SELECT COUNT(e), COUNT(c.componentTypeId)
FROM EntityGraph MATCH (e), e.components AS c
```
+ Das `COUNT` Schlüsselwort berechnet die Anzahl der Elemente in einem Abfrageergebnis.
+ `COUNT`wird für verschachtelte komplexe Felder und Felder mit Grafikmustern nicht unterstützt.
+ `COUNT`Aggregation wird bei `DISTINCT` verschachtelten Abfragen nicht unterstützt.

  Beispielsweise wird `COUNT(DISTINCT e.entityId)` nicht unterstützt.

**PFAD**  
Die folgenden Musterprojektionen werden bei Abfragen mithilfe der Pfadprojektion unterstützt:  
+ Abfragen mit variablem Hop

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

  Bei dieser Abfrage werden Knoten-Metadaten beliebiger Muster mit ausgehenden Kanten von Knoten *A* innerhalb von 1 bis 3 Hops abgeglichen und projiziert.
+ Hop-Abfragen wurden behoben

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

  Diese Abfrage gleicht Metadaten von Entitäten und eingehenden Kanten ab und projiziert sie auf *b.*
+ Ungerichtete Abfragen

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

  Diese Abfrage vergleicht und projiziert die Metadaten von Knoten in 1-Hop-Mustern, die *a* und *c* über *b* verbinden.

  ```
  {
      "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"
                          }
                      ]
                  }
              ]
          }
      ]
  }
  ```

  Diese `PATH` Abfrageantwort besteht nur aus Metadaten, die alle Knoten und Kanten der einzelnen Knoten path/pattern zwischen *a* und *c* über *b* identifizieren.

**LIMIT** und **OFFSET**:  

```
SELECT e.entityName
FROM EntityGraph MATCH (e)
WHERE e.entityName LIKE 'room_%'
LIMIT 10
OFFSET 5
```
`LIMIT`gibt die Anzahl der Ergebnisse an, die in der Abfrage zurückgegeben werden sollen, und `OFFSET` gibt die Anzahl der Ergebnisse an, die übersprungen werden sollen.

**LIMIT** und **MaxResults:**  
Das folgende Beispiel zeigt eine Abfrage, die insgesamt 500 Ergebnisse zurückgibt, aber nur 50 gleichzeitig pro API-Aufruf anzeigt. Dieses Muster kann verwendet werden, wenn Sie die Anzahl der angezeigten Ergebnisse einschränken müssen, z. B. wenn Sie nur 50 Ergebnisse in einer Benutzeroberfläche anzeigen können.  

```
aws iottwinmaker execute-query \
--workspace-id exampleWorkspace \
--query-statement "SELECT e FROM EntityGraph MATCH (e) LIMIT 500"\
--max-results 50
```
+ Das `LIMIT` Schlüsselwort wirkt sich auf die Abfrage aus und begrenzt die resultierenden Zeilen. Wenn Sie die Anzahl der pro API-Aufruf zurückgegebenen Ergebnisse kontrollieren möchten, ohne die Gesamtzahl der zurückgegebenen Ergebnisse zu begrenzen, verwenden Sie`LIMIT`.
+ `max-results`ist ein optionaler Parameter für die [ExecuteQuery API-Aktion](https://docs.aws.amazon.com//iot-twinmaker/latest/apireference/API_ExecuteQuery.html). `max-results`gilt nur für die API und dafür, wie Ergebnisse im Rahmen der obigen Abfrage gelesen werden.

  Durch die Verwendung `max-results` in einer Abfrage können Sie die Anzahl der angezeigten Ergebnisse reduzieren, ohne die tatsächliche Anzahl der zurückgegebenen Ergebnisse zu begrenzen.
Die folgende Abfrage durchläuft die nächste Ergebnisseite. Diese Abfrage verwendet den `ExecuteQuery` API-Aufruf, um die Zeilen 51-100 zurückzugeben, wobei die nächste Ergebnisseite durch das angegeben wird `next-token` — in diesem Fall lautet das Token:. `"H7kyGmvK376L"`  

```
aws iottwinmaker execute-query \
--workspace-id exampleWorkspace \
--query-statement "SELECT e FROM EntityGraph MATCH (e) LIMIT 500"\
--max-results 50
--next-token "H7kyGmvK376L"
```
+ Die `next-token` Zeichenfolge gibt die nächste Ergebnisseite an. Weitere Informationen finden Sie in der [ ExecuteQuery](https://docs.aws.amazon.com//iot-twinmaker/latest/apireference/API_ExecuteQuery.html#API_ExecuteQuery_RequestSyntax)API-Aktion.

AWS IoT TwinMaker Die Knowledge-Graph-Abfrage hat die folgenden Beschränkungen: 


****  

| Bezeichnung des Limits | Kontingent | Einstellbar | 
| --- | --- | --- | 
|  Zeitüberschreitung für die Abfrageausführung  | 10 Sekunden | Nein | 
|  Maximale Anzahl von Hops  | 10 | Ja | 
|  Maximale Anzahl von Self `JOIN` s  | 20 | Ja | 
|  Maximale Anzahl projizierter Felder  | 20 | Ja | 
|  Maximale Anzahl bedingter Ausdrücke (`AND`,`OR`,`NOT`)  | 10 | Ja | 
|  Maximale Länge eines `LIKE` Ausdrucksmusters (einschließlich Platzhaltern und Escapes)  | 20 | Ja | 
| Maximale Anzahl von Elementen, die in einer Klausel angegeben werden können IN | 10 | Ja | 
| Maximalwert für OFFSET | 3000 | Ja | 
|  Maximalwert für `LIMIT`  | 3000 | Ja | 
|  Höchstwert für Traversierungen (\$1) `OFFSET` `LIMIT`  | 3000 | Ja |