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.

# Zugriff auf das Neptune-Diagramm mit SPARQL
<a name="access-graph-sparql"></a>

SPARQL ist eine Abfragesprache für das Resource Description Framework (RDF), ein für das Web entwickelts Datenformat für Diagramme. Amazon Neptune ist mit SPARQL 1.1 kompatibel. Das bedeutet, dass Sie eine Verbindung zu einer Neptune-DB-Instance herstellen und das Diagramm mittels der in der Spezifikation [SPARQL 1.1 Query Language](https://www.w3.org/TR/sparql11-query/) beschriebenen Abfragesprache abfragen können.

 Eine Abfrage in SPARQL besteht aus einer `SELECT`-Klausel zur Angabe der Variablen, die zurückgegeben werden sollen, und einer `WHERE`-Klausel, um anzugeben, welche Daten im Diagramm abgeglichen werden sollen. Wenn Sie noch keine Erfahrungen mit SPARQL-Abfragen haben, lesen Sie den Abschnitt [Writing Simple Queries](https://www.w3.org/TR/sparql11-query/#WritingSimpleQueries) in [SPARQL 1.1 Query Language](https://www.w3.org/TR/sparql11-query/).

**Wichtig**  
Zum Laden eines kleinen Datensatzes mag sich `SPARQL UPDATE INSERT` gut eignen, wenn Sie jedoch eine beträchtliche Menge an Daten aus einer Datei laden müssen, siehe [Verwenden des Amazon Neptune Bulk Loaders zur Datenaufnahme](bulk-load.md).

Weitere Hinweise zu den Besonderheiten der Neptune-SPARQL-Implementierung finden Sie unter [Einhaltung von SPARQL-Standards](feature-sparql-compliance.md).

Sie benötigen Folgendes, um starten zu können:
+ Eine Neptune-DB-Instance. Informationen zum Erstellen einer Neptune-DB-Instance finden Sie unter [Einen Amazon Neptune Neptune-Cluster erstellen](get-started-create-cluster.md).
+ Eine Amazon–EC2-Instance in derselben Virtual Private Cloud (VPC), in der sich auch Ihre Neptune-DB-Instance befindet.

**Topics**
+ [

# Mit der RDF4 J-Konsole eine Verbindung zu einer Neptune-DB-Instance herstellen
](access-graph-sparql-rdf4j-console.md)
+ [

# Verwenden von RDF4 J Workbench zum Herstellen einer Verbindung zu einer Neptune-DB-Instance
](access-graph-sparql-rdf4j-workbench.md)
+ [

# Herstellen von Verbindungen mit einer Neptune-DB-Instance über Java
](access-graph-sparql-java.md)
+ [

# SPARQL HTTP-API
](sparql-api-reference.md)
+ [

# SPARQL-Abfragehinweise
](sparql-query-hints.md)
+ [

# Verhalten von SPARQL DESCRIBE in Bezug auf das Standarddiagramm
](sparql-default-describe.md)
+ [

# SPARQL-Abfragestatus-API
](sparql-api-status.md)
+ [

# SPARQL-Abfrageabbruch
](sparql-api-status-cancel.md)
+ [

# Verwenden des SPARQL 1.1-Graph-Store-Protokolls (GSP) über HTTP in Amazon Neptune
](sparql-graph-store-protocol.md)
+ [

# Analysieren der Neptune-Abfrageausführung über SPARQL `explain`
](sparql-explain.md)
+ [

# SPARQL-Verbundabfragen in Neptune mit der Erweiterung `SERVICE`
](sparql-service.md)

# Mit der RDF4 J-Konsole eine Verbindung zu einer Neptune-DB-Instance herstellen
<a name="access-graph-sparql-rdf4j-console"></a>



Mit der RDF4 J Console können Sie mit RDF-Diagrammen und Abfragen (Resource Description Framework) in einer REPL-Umgebung (read-eval-print Loop) experimentieren. 

Sie können eine entfernte Graphdatenbank als Repository hinzufügen und sie von der RDF4 J Console aus abfragen. In diesem Abschnitt werden Sie durch die Konfiguration der RDF4 J Console geführt, um eine Remoteverbindung zu einer Neptune-DB-Instance herzustellen.

**So stellen Sie mit der J Console eine Verbindung zu Neptune her RDF4**

1. Laden Sie das RDF4 J SDK von der [Download-Seite](http://rdf4j.org/download/) auf der RDF4 J-Website herunter.

1. Entpacken Sie die RDF4 J SDK-Zip-Datei.

1. Navigieren Sie in einem Terminal zum RDF4 J SDK-Verzeichnis und geben Sie dann den folgenden Befehl ein, um die RDF4 J Console auszuführen:

   ```
   bin/console.sh
   ```

   Die Ausgabe sollte folgendermaßen oder ähnlich aussehen:

   ```
   14:11:51.126 [main] DEBUG o.e.r.c.platform.PlatformFactory - os.name = linux
   14:11:51.130 [main] DEBUG o.e.r.c.platform.PlatformFactory - Detected Posix platform
   Connected to default data directory
   RDF4J Console 3.6.1
   
   3.6.1
   Type 'help' for help.
   >
   ```

   Sie sehen nun die `>`-Eingabeaufforderung. Dies ist die allgemeine Eingabeaufforderung für die RDF4 J Console. Verwenden Sie diese zum Einrichten von Repositorys und anderen Vorgängen. Ein Repository verfügt über eine eigene Eingabeaufforderung zum Ausführen von Abfragen.

1. Geben Sie an der `>`-Eingabeaufforderung Folgendes ein, um ein SPARQL-Repository für Ihre Neptune-DB-Instance zu erstellen:

    

   ```
   create sparql
   ```

1. Die RDF4 J-Konsole fordert Sie auf, Werte für die Variablen einzugeben, die für die Verbindung mit dem SPARQL-Endpunkt erforderlich sind.

   ```
   Please specify values for the following variables:
   ```

   Geben Sie die folgenden Werte an:    
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/de_de/neptune/latest/userguide/access-graph-sparql-rdf4j-console.html)

   Informationen zum Ermitteln der Adresse Ihrer Neptune-DB-Instance finden Sie im Abschnitt [Verbinden mit Amazo-Neptune-Endpunkten](feature-overview-endpoints.md).

   Wenn die Operation erfolgreich ausgeführt wurde, sehen Sie die folgende Meldung:

    

   ```
   Repository created
   ```

1. Geben Sie an der `>`-Eingabeaufforderung Folgendes ein, um eine Verbindung zur Neptune-DB-Instance herzustellen:

   ```
   open neptune
   ```

   Wenn die Operation erfolgreich ausgeführt wurde, sehen Sie die folgende Meldung:

    

   ```
   Opened repository 'neptune'
   ```

   Sie sehen nun die `neptune>`-Eingabeaufforderung. Über diese Eingabeaufforderung können Sie das Neptune-Diagramm abfragen.

    
**Anmerkung**  
Nach dem Hinzufügen des Repositorys können Sie bei der nächsten Ausführung von `bin/console.sh` sofort den Befehl `open neptune` ausführen, um eine Verbindung zur Neptune-DB-Instance herzustellen.

1. Geben Sie an der `neptune>` Eingabeaufforderung Folgendes ein, um eine SPARQL-Abfrage auszuführen, die bis zu 10 der Triples (subject-predicate-object) im Diagramm zurückgibt, wobei die `?s ?p ?o` Abfrage mit einem Limit von 10 verwendet wird. Ersetzen Sie den Text nach dem Befehl `sparql` durch eine andere SPARQL-Abfrage, wenn Sie etwas anderes abfragen möchten.

   ```
   sparql select ?s ?p ?o where {?s ?p ?o} limit 10
   ```

# Verwenden von RDF4 J Workbench zum Herstellen einer Verbindung zu einer Neptune-DB-Instance
<a name="access-graph-sparql-rdf4j-workbench"></a>

In diesem Abschnitt erfahren Sie, wie Sie mithilfe von RDF4 J Workbench und RDF4 J Server eine Verbindung zu einer Amazon Neptune Neptune-DB-Instance herstellen. RDF4J Server ist erforderlich, da er als Proxy zwischen dem Neptune SPARQL HTTP-REST-Endpunkt und RDF4 J Workbench fungiert. 

RDF4J Workbench bietet eine einfache Oberfläche zum Experimentieren mit einem Diagramm, einschließlich des Ladens lokaler Dateien. Weitere Informationen finden Sie im [Abschnitt Hinzufügen](https://rdf4j.org/documentation/tools/server-workbench/#add) in der RDF4 J-Dokumentation.

**Voraussetzungen**  
Bevor Sie beginnen, führen Sie die folgenden Schritte aus:
+ Installieren Sie Java 1.8 oder höher.
+ Installieren Sie RDF4 J Server und RDF4 J Workbench. Weitere Informationen finden Sie unter [ RDF4J Server und RDF4 J Workbench installieren](https://rdf4j.org/documentation/tools/server-workbench/#installing-rdf4j-server-and-rdf4j-workbench).

**Um RDF4 J Workbench für die Verbindung mit Neptune zu verwenden**

1. Navigieren Sie in einem Webbrowser zu der URL, unter der die RDF4 J Workbench-Web-App bereitgestellt wird. Wenn Sie beispielsweise Apache Tomcat verwenden, lautet die URL: [https: //:8080/rdf4j-workbench/](http://localhost:8080/rdf4j-workbench/). *ec2\$1hostname*

1. Wenn Sie aufgefordert werden, **Connect zu RDF4 J Server** herzustellen, stellen Sie sicher, dass **RDF4J Server** installiert ist und ausgeführt wird und dass die Server-URL korrekt ist. Fahren Sie dann mit dem nächsten Schritt fort.

1. Wählen Sie im linken Bereich **New repository (Neues Repository)** aus.

   Unter **New repository (Neues Repository)**:
   + Wählen Sie aus der Dropdown-Liste **Type (Typ)** **SPARQL endpoint proxy (SPARQL-Endpunkt-Proxy)** aus.
   + Geben Sie als **ID** **neptune** ein.
   + Geben Sie **Neptune-DB-Instance** als **Titel** ein.

   Wählen Sie **Weiter** aus.

1. Unter **New repository (Neues Repository)**:
   + Geben Sie für **SPARQL query endpoint URL (SPARQL-Abfrage-Endpunkt-URL)** `https://your-neptune-endpoint:port/sparql` ein.
   + Geben Sie für **SPARQL update endpoint URL (SPARQL-Aktualisierungs-Endpunkt-URL)** `https://your-neptune-endpoint:port/sparql` ein.

   Informationen zum Ermitteln der Adresse Ihrer Neptune-DB-Instance finden Sie im Abschnitt [Verbinden mit Amazo-Neptune-Endpunkten](feature-overview-endpoints.md). 

   Wählen Sie **Erstellen** aus.

1. Das **neptune**-Repository wird nun in der Liste der Repositorys aufgeführt. Es kann ein paar Minuten dauern, ehe Sie das neue Repository verwenden können.

1. Wählen Sie in der Spalte **Id (ID)** der Tabelle den Link **neptune** aus.

1. Wählen Sie im linken Bereich **Query (Abfrage)** aus. 

    
**Anmerkung**  
Wenn die Menüelemente unter **Explore** deaktiviert sind, müssen Sie möglicherweise erneut eine Verbindung zum RDF4 J Server herstellen und das **Neptune-Repository** erneut auswählen.  
Sie können dies über die **[change] [ändern]**-Links [Ändern] in der oberen rechten Ecke durchführen.

1. Geben Sie im Abfragefeld die folgende SPARQL-Abfrage ein und wählen Sie dann **Execute (Ausführen)** aus.

    

   ```
   select ?s ?p ?o where {?s ?p ?o} limit 10
   ```

    

Im vorherigen Beispiel werden bis zu 10 der Triples (subject-predicate-object) im Diagramm zurückgegeben, wenn die `?s ?p ?o` Abfrage mit einem Limit von 10 verwendet wird. 

# Herstellen von Verbindungen mit einer Neptune-DB-Instance über Java
<a name="access-graph-sparql-java"></a>

Dieser Abschnitt führt Sie durch die Ausführung eines vollständigen Java-Beispiels, in dem eine Verbindung mit einer Amazon-Neptune-DB-Instance hergestellt wird und eine SPARQL-Abfrage ausgeführt wird.

Befolgen Sie diese Anweisungen für eine Amazon-EC2-Instance befolgen, die sich in derselben Virtual Private Cloud (VPC) wie Ihre Neptune-DB-Instance befindet.

**Herstellen einer Verbindung mit Neptune über Java**

1. Installieren Sie Apache Maven auf Ihrer EC2-Instance. Wenn Sie Amazon Linux 2023 (bevorzugt) verwenden, verwenden Sie:

   ```
   sudo dnf update -y
   sudo dnf install maven -y
   ```

   Wenn Sie Amazon Linux 2 verwenden, laden Sie die neueste Binärdatei von [https://maven.apache.org/download.cgi herunter:](https://maven.apache.org/download.cgi:)

   ```
   sudo yum remove maven -y
   wget https://dlcdn.apache.org/maven/maven-3/ <version>/binaries/apache-maven-<version>-bin.tar.gz
   sudo tar -xzf apache-maven-<version>-bin.tar.gz -C /opt/
   sudo ln -sf /opt/apache-maven-<version> /opt/maven
   echo 'export MAVEN_HOME=/opt/maven' >> ~/.bashrc
   echo 'export PATH=$MAVEN_HOME/bin:$PATH' >> ~/.bashrc
   source ~/.bashrc
   ```

1. Dieses Beispiel wurde lediglich mit Java 8 getestet. Geben Sie Folgendes ein, um Java 8 auf Ihrer EC2-Instance zu installieren:

   ```
   sudo yum install java-1.8.0-devel
   ```

1. Geben Sie Folgendes ein, um Java 8 als Standard-Laufzeit Ihrer EC2-Instance festzulegen:

   ```
   sudo /usr/sbin/alternatives --config java
   ```

   Wenn Sie dazu aufgefordert werden, geben Sie die Nummer für Java 8 ein.

1. Geben Sie Folgendes ein, um Java 8 als Standard-Compiler Ihrer EC2-Instance festzulegen: 

   ```
   sudo /usr/sbin/alternatives --config javac
   ```

   Wenn Sie dazu aufgefordert werden, geben Sie die Nummer für Java 8 ein.

1. Erstellen Sie in einem neuen Verzeichnis eine `pom.xml`-Datei und öffnen Sie diese in einem Text-Editor.

1. Kopieren Sie Folgendes in die Datei `pom.xml` und speichern Sie diese. (Sie können die Versionsnummern in der Regel in die neueste stabile Version ändern):

   ```
   <project xmlns="https://maven.apache.org/POM/4.0.0" xmlns:xsi="https://www.w3.org/2001/XMLSchema-instance"
     xsi:schemaLocation="https://maven.apache.org/POM/4.0.0 https://maven.apache.org/maven-v4_0_0.xsd">
     <modelVersion>4.0.0</modelVersion>
     <groupId>com.amazonaws</groupId>
     <artifactId>RDFExample</artifactId>
     <packaging>jar</packaging>
     <version>1.0-SNAPSHOT</version>
     <name>RDFExample</name>
     <url>https://maven.apache.org</url>
     <dependencies>
       <dependency>
         <groupId>org.eclipse.rdf4j</groupId>
         <artifactId>rdf4j-runtime</artifactId>
         <version>3.6</version>
       </dependency>
     </dependencies>
     <build>
       <plugins>
         <plugin>
             <groupId>org.codehaus.mojo</groupId>
             <artifactId>exec-maven-plugin</artifactId>
             <version>1.2.1</version>
             <configuration>
               <mainClass>com.amazonaws.App</mainClass>
             </configuration>
         </plugin>
         <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-compiler-plugin</artifactId>
           <configuration>
             <source>1.8</source>
             <target>1.8</target>
           </configuration>
         </plugin>
       </plugins>
     </build>
   </project>
   ```
**Anmerkung**  
Wenn Sie ein vorhandenes Maven-Projekt ändern, ist die erforderliche Abhängigkeit im vorhergehenden Code hervorgehoben.

1. Zum Erstellen von Unterverzeichnissen für den Beispielquellcode (`src/main/java/com/amazonaws/`), geben Sie Folgendes in die Befehlszeile ein:

   ```
   mkdir -p src/main/java/com/amazonaws/
   ```

1. Erstellen Sie im Verzeichnis `src/main/java/com/amazonaws/` eine Datei namens `App.java` und öffnen Sie diese dann in einem Text-Editor.

1. Kopieren Sie Folgendes in die `App.java`-Datei. *your-neptune-endpoint*Ersetzen Sie durch die Adresse Ihrer Neptune-DB-Instance.
**Anmerkung**  
Informationen zum Ermitteln des Hostnamens Ihrer Neptune-DB-Instance finden Sie im Abschnitt [Verbinden mit Amazo-Neptune-Endpunkten](feature-overview-endpoints.md). 

   ```
   package com.amazonaws;
   
   import org.eclipse.rdf4j.repository.Repository;
   import org.eclipse.rdf4j.repository.http.HTTPRepository;
   import org.eclipse.rdf4j.repository.sparql.SPARQLRepository;
   
   import java.util.List;
   import org.eclipse.rdf4j.RDF4JException;
   import org.eclipse.rdf4j.repository.RepositoryConnection;
   import org.eclipse.rdf4j.query.TupleQuery;
   import org.eclipse.rdf4j.query.TupleQueryResult;
   import org.eclipse.rdf4j.query.BindingSet;
   import org.eclipse.rdf4j.query.QueryLanguage;
   import org.eclipse.rdf4j.model.Value;
   
   public class App
   {
       public static void main( String[] args )
       {
           String sparqlEndpoint = "https://your-neptune-endpoint:port/sparql";
           Repository repo = new SPARQLRepository(sparqlEndpoint);
           repo.initialize();
   
           try (RepositoryConnection conn = repo.getConnection()) {
              String queryString = "SELECT ?s ?p ?o WHERE { ?s ?p ?o } limit 10";
   
              TupleQuery tupleQuery = conn.prepareTupleQuery(QueryLanguage.SPARQL, queryString);
   
              try (TupleQueryResult result = tupleQuery.evaluate()) {
                 while (result.hasNext()) {  // iterate over the result
                      BindingSet bindingSet = result.next();
   
                      Value s = bindingSet.getValue("s");
                      Value p = bindingSet.getValue("p");
                      Value o = bindingSet.getValue("o");
   
                      System.out.print(s);
                      System.out.print("\t");
                      System.out.print(p);
                      System.out.print("\t");
                      System.out.println(o);
                 }
              }
           }
       }
   }
   ```

1. Kompilieren und führen Sie das Beispiel mit folgendem Maven-Befehl aus:

   ```
   mvn compile exec:java
   ```

Das vorherige Beispiel gibt bis zu 10 der Triples (subject-predicate-object) im Diagramm zurück, wenn die `?s ?p ?o` Abfrage mit einem Limit von 10 verwendet wird. Um etwas anderes abzufragen, ersetzen Sie die Abfrage durch eine andere SPARQL-Abfrage.

Die Iteration der Ergebnisse des Beispiels gibt die Werte alle zurückgegebenen Variablen aus. Das `Value`-Objekt wird in einen `String` konvertiert und ausgegeben. Wenn Sie den `SELECT`-Teil der Abfrage ändern, müssen Sie den Code ändern.

# SPARQL HTTP-API
<a name="sparql-api-reference"></a>

SPARQL HTTP-Anforderungen werden am folgenden Endpunkt akzeptiert: `https://your-neptune-endpoint:port/sparql`

Weitere Informationen zum Herstellen einer Verbindung mit Amazon Neptune über SPARQL finden Sie unter [Zugriff auf das Neptune-Diagramm mit SPARQL](access-graph-sparql.md).

Weitere Informationen über das SPARQL-Protokoll und die SPARQL-Abfragesprache finden Sie in den Spezifikationen [SPARQL 1.1 Protocol](https://www.w3.org/TR/sparql11-protocol/#protocol) und [SPARQL 1.1 Query Language](https://www.w3.org/TR/sparql11-query/).

In den folgenden Themen finden Sie Informationen zu SPARQL-RDF-Serialisierungsformaten und zur Verwendung der SPARQL-HTTP-API mit Neptune.

**Contents**
+ [

# Herstellen von Verbindungen mit einer Neptune-DB-Instance über den HTTP-REST-Endpunkt
](access-graph-sparql-http-rest.md)
+ [

# Optionale HTTP-Trailing-Header für mehrteilige SPARQL-Antworten
](access-graph-sparql-http-trailing-headers.md)
+ [

# Von SPARQL in Neptune verwendete RDF-Medientypen
](sparql-media-type-support.md)
  + [

## Von Neptune SPARQL verwendete RDF-Serialisierungsformate
](sparql-media-type-support.md#sparql-serialization-formats)
  + [

## SPARQL-Ergebnisserialisierungsformate, die von Neptune SPARQL verwendet werden
](sparql-media-type-support.md#sparql-serialization-formats-neptune-output)
  + [

## Medientypen, die Neptune zum Importieren von RDF-Daten verwenden kann
](sparql-media-type-support.md#sparql-serialization-formats-input)
  + [

## Medientypen, die Neptune zum Exportieren von Abfrageergebnissen verwenden kann
](sparql-media-type-support.md#sparql-serialization-formats-output)
+ [

# Verwenden von SPARQL UPDATE LOAD zum Importieren von Daten in Neptune
](sparql-api-reference-update-load.md)
+ [

# Verwenden von SPARQL UPDATE UNLOAD zum Löschen von Daten aus Neptune
](sparql-api-reference-unload.md)

# Herstellen von Verbindungen mit einer Neptune-DB-Instance über den HTTP-REST-Endpunkt
<a name="access-graph-sparql-http-rest"></a>

**Anmerkung**  
Neptune unterstützt derzeit kein HTTP/2 für REST-API-Anfragen. Clients müssen HTTP/1.1 verwenden, wenn sie eine Verbindung zu Endpunkten herstellen.

Die folgenden Anweisungen führen Sie durch das Herstellen einer Verbindung zum SPARQL-Endpunkt mittels des **curl**-Befehls und HTTPS. Dabei wird mit HTTP-Syntax eine Verbindung über HTTPS hergestellt. Befolgen Sie diese Anweisungen für eine Amazon-EC2-Instance befolgen, die sich in derselben Virtual Private Cloud (VPC) wie Ihre Neptune-DB-Instance befindet.

Der HTTP-Endpunkt für SPARQL-Abfragen für eine Neptune-DB-Instance ist `https://your-neptune-endpoint:port/sparql`.

**Anmerkung**  
Informationen zum Ermitteln des Hostnamens Ihrer Neptune-DB-Instance finden Sie im Abschnitt [Verbinden mit Amazo-Neptune-Endpunkten](feature-overview-endpoints.md).

Amazon Neptune stellt einen HTTP-Endpunkt für SPARQL-Abfragen bereit. Die REST-Schnittstelle ist mit der SPARQL-Version 1.1. kompatibel.

**ABFRAGE über HTTP POST**  
Im folgenden Beispiel wird **curl** zum Übermitteln einer SPARQL-**`QUERY`** mit HTTP **POST** verwendet.

```
curl -X POST --data-binary 'query=select ?s ?p ?o where {?s ?p ?o} limit 10' https://your-neptune-endpoint:port/sparql
```

Im vorherigen Beispiel werden bis zu 10 der Triples (subject-predicate-object) im Diagramm zurückgegeben, wenn die `?s ?p ?o` Abfrage mit einem Limit von 10 verwendet wird. Um etwas anderes abzufragen, ersetzen Sie diese durch eine andere SPARQL-Abfrage.

**Anmerkung**  
Der Standard-MIME-Medientyp einer Antwort ist `application/sparql-results+json` für `SELECT`- und `ASK`-Abfragen.  
Der Standard-MIME-Typ einer Antwort ist `application/n-quads` für `CONSTRUCT`- und `DESCRIBE`-Abfragen.  
Eine Liste der von Neptune für die Serialisierung verwendeten Medientypen finden Sie unter [Von Neptune SPARQL verwendete RDF-Serialisierungsformate](sparql-media-type-support.md#sparql-serialization-formats).

**UPDATE mit HTTP POST**  
Im folgenden Beispiel wird **curl** zum Übermitteln einer SPARQL-**`UPDATE`** mit HTTP **POST** verwendet.

```
curl -X POST --data-binary 'update=INSERT DATA { <https://test.com/s> <https://test.com/p> <https://test.com/o> . }' https://your-neptune-endpoint:port/sparql
```

Im vorherigen Beispiel wird das folgende Triple in das standardmäßige SPARQL-Diagramm eingefügt: `<https://test.com/s> <https://test.com/p> <https://test.com/o>`

# Optionale HTTP-Trailing-Header für mehrteilige SPARQL-Antworten
<a name="access-graph-sparql-http-trailing-headers"></a>

Die HTTP-Antwort auf SPARQL-Abfragen und -Aktualisierungen wird häufig in mehr als einem Teil oder Block zurückgegeben. Es kann schwierig sein, einen Fehler zu diagnostizieren, der auftritt, nachdem eine Abfrage oder eine Aktualisierung mit dem Senden dieser Blöcke begonnen hat, vor allem, da der erste Block mit dem HTTP-Statuscode `200` eingeht.

Wenn Sie nicht ausdrücklich Trailing-Header anfordern, meldet Neptune einen solchen Fehler nur durch Anfügen einer Fehlermeldung an den Nachrichtentext, der in der Regel beschädigt ist.

Um die Erkennung und Diagnose solcher Probleme zu vereinfachen, können Sie Ihrer Anforderung einen Transfer-Encoding (TE)-Trailer-Header hinzufügen (siehe z. B. die [MDN-Seite zu TE-Anforderungs-Headern](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/TE)). Anschließend fügt Neptune zwei neue Header-Felder in die Trailing-Header der Antwortblöcke ein:
+ `X-Neptune-Status`  –   enthält den Antwortcode gefolgt von einem Kurznamen. Im Erfolgsfall wäre der nachgestellte Header beispielsweise: `X-Neptune-Status: 200 OK`. Bei einem Fehler wäre der Antwortcode ein [Neptune-Engine-Fehlercode](errors-engine-codes.md) wie `X-Neptune-Status: 500 TimeLimitExceededException`.
+ `X-Neptune-Detail`  –   ist bei erfolgreichen Anforderungen leer. Im Fehlerfall ist die JSON-Fehlermeldung enthalten. Da in HTTP-Header-Werten nur ASCII-Zeichen zulässig sind, ist die JSON-Zeichenfolge URL-codiert. Die Fehlermeldung wird weiter an die Antwortmeldung angefügt.

# Von SPARQL in Neptune verwendete RDF-Medientypen
<a name="sparql-media-type-support"></a>

Resource Description Framework (RDF)-Daten können auf viele verschiedene Arten serialisiert werden, von denen SPARQL die meisten nutzen oder ausgeben kann:

## Von Neptune SPARQL verwendete RDF-Serialisierungsformate
<a name="sparql-serialization-formats"></a>
+ **RDF/XML**  –   XML-Serialisierung von RDF, definiert in [RDF 1.1 – XML-Syntax](https://www.w3.org/TR/rdf-syntax-grammar/). Medienntyp: `application/rdf+xml`. Typische Dateierweiterung: `.rdf`.
+ **N-Triples**  –   Ein zeilenbasiertes Nur-Text-Format zum Kodieren eines RDF-Diagramms, definiert in [RDF 1.1 c N-Triples](https://www.w3.org/TR/n-triples/). Medientyp: `application/n-triples`, `text/turtle` oder `text/plain`. Typische Dateierweiterung: `.nt`.
+ **N-Quads**  –   Ein zeilenbasiertes Nur-Text-Format zum Kodieren eines RDF-Diagramms, definiert in RDF 1.1 – N-Quads. Dies ist eine Erweiterung von N-Triples. Medientyp: `application/n-quads` oder `text/x-nquads` bei Kodierung mit 7-Bit-US-ASCII. Typische Dateierweiterung: `.nq`.
+ **Turtle**  –   Eine Textsyntax für RDF, definiert in [RDF 1.1 c Turtle](https://www.w3.org/TR/turtle/), mit der ein RDF-Diagramm vollständig in einem kompakten und natürlichen Textformat geschrieben werden kann, einschließlich Abkürzungen für häufige Nutzungsmuster und Datentypen. Turtle bietet ein hohes Maß an Kompatibilität mit dem N-Triples-Format sowie mit der verdreifachten SPARQL-Mustersyntax. Medientyp: `text/turtle`Typische Dateierweiterung: `.ttl`.
+ **TriG**  –   Eine Textsyntax für RDF, definiert in RDF 1.1 – TriG, mit der ein RDF-Diagramm vollständig in einem kompakten und natürlichen Textformat geschrieben werden kann, einschließlich Abkürzungen für häufige Nutzungsmuster und Datentypen. TriG ist eine Erweiterung des Turtle-Formats. Medienntyp: `application/trig`. Typische Dateierweiterung: `.trig`.
+ **N3 (Notation3)**  –   Eine Zusicherungs- und Logiksprache, definiert in [Notation3 (N3): Eine lesbare RDF-Syntax](https://www.w3.org/TeamSubmission/n3/). N3 erweitert das RDF-Datenmodell durch Hinzufügen von Formeln (Literalen, wobei es sich um die Graphen selbst handelt), Variablen, logischer Folgerung und funktionalen Prädikaten und bietet eine Alternative in Textform zur RDF/XML-Syntax. Medienntyp: `text/n3`. Typische Dateierweiterung: `.n3`.
+ **JSON-LD**  –   Ein Datenserialisierungs- und Messaging-Format, definiert in [JSON-LD 1.0](https://www.w3.org/TR/json-ld/). Medientyp: `application/ld+json`. Typische Dateierweiterung: `.jsonld`.
+ **TriX**  –   Eine Serialisierung von RDF in XML, definiert in [TriX: RDF Triples in XML](https://www.hpl.hp.com/techreports/2004/HPL-2004-56.html). Medienntyp: `application/trix`. Typische Dateierweiterung: `.trix`.
+ **SPARQL JSON Results**  –   Eine Serialisierung von RDF im [SPARQL 1.1-JSON-Format für Abfrageergebnisse](https://www.w3.org/TR/sparql11-results-json). Medienntyp: `application/sparql-results+json`. Typische Dateierweiterung: `.srj`.
+ **RDF4J Binary Format** — Ein Binärformat für die Kodierung von RDF-Daten, dokumentiert im [RDF4J Binary RDF-Format](https://rdf4j.org/documentation/reference/rdf4j-binary). Medienntyp: `application/x-binary-rdf`.

## SPARQL-Ergebnisserialisierungsformate, die von Neptune SPARQL verwendet werden
<a name="sparql-serialization-formats-neptune-output"></a>
+ **SPARQL XML Results**  –   Ein XML-Format für Variablenbindung und boolesche Ergebnisformate, bereitgestellt von der SPARQL-Abfragesprache, definiert in [SPARQL-XML-Format für Abfrageergebnisse (zweite Ausgabe)](https://www.w3.org/TR/rdf-sparql-XMLres/). Medienntyp: `application/sparql-results+xml`. Typische Dateierweiterung: `.srx`.
+ **SPARQL CSV and TSV Results**  –   Verwendung von durch Komma und Tabulator getrennten Werten, um SPARQL-Abfrageergebnisse aus `SELECT`-Abfragen auszudrücken, definiert in [SPARQL 1.1-CSV- und TSV-Formate für Abfrageergebnisse](https://www.w3.org/TR/sparql11-results-csv-tsv/). Medientyp: `text/csv` für durch Komma getrennte Werte und `text/tab-separated-values` für durch Tabulator getrennte Werte. Typische Dateierweiterungen: `.csv` für durch Komma getrennte Werte und `.tsv` für durch Tabulator getrennte Werte.
+ **Binary Results Table**  –   Ein Binärformat zum Kodieren der Ausgabe von SPARQL-Abfragen. Medienntyp: `application/x-binary-rdf-results-table`.
+ **SPARQL JSON Results**  –   Eine Serialisierung von RDF im [SPARQL 1.1-JSON-Format für Abfrageergebnisse](https://www.w3.org/TR/sparql11-results-json/). Medienntyp: `application/sparql-results+json`.

## Medientypen, die Neptune zum Importieren von RDF-Daten verwenden kann
<a name="sparql-serialization-formats-input"></a>

**Medientypen, die vom [Neptune-Massen-Loader](bulk-load.md) unterstützt werden**
+ [N-Triples](https://www.w3.org/TR/n-triples/)
+ [N-Quads](https://www.w3.org/TR/n-quads/)
+ [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/)
+ [Turtle](https://www.w3.org/TR/turtle/)

**Medientypen, die SPARQL UDATE LOAD importieren kann**
+ [N-Triples](https://www.w3.org/TR/n-triples/)
+ [N-Quads](https://www.w3.org/TR/n-quads/)
+ [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/)
+ [Turtle](https://www.w3.org/TR/turtle/)
+ [TriG](https://www.w3.org/TR/trig/)
+ [N3](https://www.w3.org/TeamSubmission/n3/)
+ [JSON-LD](https://www.w3.org/TR/json-ld/)

## Medientypen, die Neptune zum Exportieren von Abfrageergebnissen verwenden kann
<a name="sparql-serialization-formats-output"></a>

Um ein Ausgabeformat für eine SPARQL-Abfrageantwort anzugeben, senden Sie einen `"Accept: media-type"`-Header mit der Abfrageanforderung. Beispiel:

```
curl -H "Accept: application/nquads" ...
```

**RDF-Medientypen, die SPARQL SELECT über Neptune ausgeben kann**
+ [SPARQL-JSON-Ergebnisse](https://www.w3.org/TR/sparql11-results-json) (Standardwert)
+ [SPARQL-XML-Ergebnisse](https://www.w3.org/TR/rdf-sparql-XMLres/)
+ **Binäre Ergebnistabelle** (Medientyp: `application/x-binary-rdf-results-table`)
+ [Comma Separated Values (CSV/durch Komma getrennte Werte)](https://www.w3.org/TR/sparql11-results-csv-tsv/)
+ [TSV (Tab-Separated Values, tabulatorgetrennte Werte)](https://www.w3.org/TR/sparql11-results-csv-tsv/)

**RDF-Medien, die SPARQL ASK über Neptune ausgeben kann**
+ [SPARQL-JSON-Ergebnisse](https://www.w3.org/TR/sparql11-results-json) (Standardwert)
+ [SPARQL-XML-Ergebnisse](https://www.w3.org/TR/rdf-sparql-XMLres/)
+ **Boolesch** (Medientyp: `text/boolean`, mit der Bedeutung „true“ oder „false“)

**RDF-Medientypen, die SPARQL CONSTRUCT über Neptune ausgeben kann**
+ [N-Quads](https://www.w3.org/TR/n-quads/) (Standardwert)
+ [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/)
+ [JSON-LD](https://www.w3.org/TR/json-ld/)
+ [N-Triples](https://www.w3.org/TR/n-triples/)
+ [Turtle](https://www.w3.org/TR/turtle/)
+ [N3](https://www.w3.org/TeamSubmission/n3/)
+ [TriX](https://www.hpl.hp.com/techreports/2004/HPL-2004-56.html)
+ [TriG](https://www.w3.org/TR/trig/)
+ [SPARQL-JSON-Ergebnisse](https://www.w3.org/TR/sparql11-results-json)
+ [RDF4J Binäres RDF-Format](https://rdf4j.org/documentation/reference/rdf4j-binary)

**RDF-Medientypen, die SPARQL DESCRIBE über Neptune ausgeben kann**
+ [N-Quads](https://www.w3.org/TR/n-quads/) (Standardwert)
+ [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/)
+ [JSON-LD](https://www.w3.org/TR/json-ld/)
+ [N-Triples](https://www.w3.org/TR/n-triples/)
+ [Turtle](https://www.w3.org/TR/turtle/)
+ [N3](https://www.w3.org/TeamSubmission/n3/)
+ [TriX](https://www.hpl.hp.com/techreports/2004/HPL-2004-56.html)
+ [TriG](https://www.w3.org/TR/trig/)
+ [SPARQL-JSON-Ergebnisse](https://www.w3.org/TR/sparql11-results-json)
+ [RDF4J Binäres RDF-Format](https://rdf4j.org/documentation/reference/rdf4j-binary)

# Verwenden von SPARQL UPDATE LOAD zum Importieren von Daten in Neptune
<a name="sparql-api-reference-update-load"></a>

Die Syntax des SPARQL UPDATE LOAD-Befehls ist in der [SPARQL 1.1-Aktualisierungsempfehlung](https://www.w3.org/TR/sparql11-update/#load) angegeben:

```
LOAD SILENT (URL of data to be loaded) INTO GRAPH (named graph into which to load the data)
```
+ **`SILENT`**   –   (*Optional*) Bewirkt, dass die Operation auch dann erfolgreich ist, wenn bei der Verarbeitung ein Fehler aufgetreten ist.

  Dies kann nützlich sein, wenn eine einzelne Transaktion mehrere Anweisungen enthält, z. B. `"LOAD ...; LOAD ...; UNLOAD ...; LOAD ...;"`, und die Transaktion abgeschlossen werden soll, auch wenn einige der entfernten Daten nicht verarbeitet werden konnten.
+ *URL of data to be loaded*— (*Erforderlich*) Gibt eine Remote-Datendatei an, die Daten enthält, die in ein Diagramm geladen werden sollen.

  Die Remote-Datei muss eine der folgenden Erweiterungen haben:
  + `.nt`für NTriples.
  + `.nq`für NQuads.
  + `.trig` für Trig.
  + `.rdf` für RDF/XML.
  + `.ttl` für Turtle.
  + `.n3` für N3.
  + `.jsonld` für JSON-LD.
+ **`INTO GRAPH`***(named graph into which to load the data)*— (*Optional*) Gibt den Graphen an, in den die Daten geladen werden sollen.

  Neptune ordnet jedem Triple ein benanntes Diagramm zu. Sie können das benannte Standarddiagramm mithilfe des Fallback-URI (`http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph`) für das benannte Diagramm wie folgt angeben:

  ```
  INTO GRAPH <http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph>
  ```

**Anmerkung**  
Wenn Sie viele Daten laden müssen, sollten Sie den Neptune-Massen-Loader anstelle von UPDATE LOAD verwenden. Weitere Informationen zum Massen-Loader finden Sie unter [Verwenden des Amazon Neptune Bulk Loaders zur Datenaufnahme](bulk-load.md).

Sie können mit `SPARQL UPDATE LOAD` Daten direkt aus Amazon S3 oder aus Dateien laden, die von einem selbst gehosteten Webserver abgerufen wurden. Die Ressourcen, die geladen werden sollen, müssen sich in derselben Region wie der Neptune-Server befinden. Außerdem muss der Endpunkt für die Ressourcen in der VPC zugelassen worden sein. Informationen zum Erstellen eines Amazon-S3-Endpunkts finden Sie unter [Erstellen eines Amazon-S3-VPC-Endpunkts](bulk-load-data.md#bulk-load-prereqs-s3).

Alles `SPARQL UPDATE LOAD` URIs muss mit beginnen`https://`. Dazu gehört Amazon S3 URLs.

Im Gegensatz zum Neptune-Massen-Loader ist ein Aufruf an `SPARQL UPDATE LOAD` vollständig transaktional.

**Laden von Dateien direkt aus Amazon S3 in Neptune über SPARQL UPDATE LOAD**

Da Neptune die Übergabe einer IAM-Rolle an Amazon S3 bei Verwendung von SPARQL UPDATE LOAD nicht erlaubt, muss der betreffende Amazon-S3-Bucket öffentlich sein oder Sie müssen eine [vorsignierte Amazon-S3-URL](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html) in der LOAD-Abfrage verwenden.

Um eine vorsignierte URL für eine Amazon S3 S3-Datei zu generieren, können Sie einen AWS CLI Befehl wie diesen verwenden:

```
aws s3 presign --expires-in (number of seconds) s3://(bucket name)/(path to file of data to load)
```

Anschließend können Sie die resultierende vorsignierte URL in Ihrem `LOAD`-Befehl verwenden:

```
curl https://(a Neptune endpoint URL):8182/sparql \
  --data-urlencode 'update=load (pre-signed URL of the remote Amazon S3 file of data to be loaded) \
                           into graph (named graph)'
```

Weitere Informationen finden Sie auf der Seite zum Thema [Authentifizieren von Anforderungen: Verwenden von Abfrageparametern](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html). Die [Boto3-Dokumentation](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/s3-presigned-urls.html) zeigt, wie ein Python-Skript verwendet wird, um eine vorsignierte URL zu generieren.

Außerdem muss der Inhaltstyp der Dateien, die geladen werden sollen, korrekt eingestellt sein.

1. Sie legen den Inhaltstyp von Dateien beim Hochladen in Amazon S3 mithilfe des Parameters `-metadata` wie folgt fest:

   ```
   aws s3 cp test.nt s3://bucket-name/my-plain-text-input/test.nt --metadata Content-Type=text/plain
   aws s3 cp test.rdf s3://bucket-name/my-rdf-input/test.rdf --metadata Content-Type=application/rdf+xml
   ```

1. Vergewissern Sie sich, dass die Medientyp-Informationen tatsächlich vorhanden sind. Führen Sie Folgendes aus:

   ```
   curl -v bucket-name/folder-name
   ```

   Die Ausgabe dieses Befehls sollte die Medientyp-Informationen anzeigen, die Sie beim Hochladen der Dateien festlegen.

1. Anschließend können Sie diese Dateien mit dem Befehl `SPARQL UPDATE LOAD` in Neptune importieren:

   ```
   curl https://your-neptune-endpoint:port/sparql \
     -d "update=LOAD <https://s3.amazonaws.com/bucket-name/my-rdf-input/test.rdf>"
   ```

Die Schritte oben funktionieren nur für einen öffentlichen Amazon-S3-Bucket oder für einen Bucket, auf den Sie mit einer [vorsignierten Amazon-S3-URL](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html) in der LOAD-Abfrage zugreifen.

 Sie können auch einen Web-Proxy-Server einrichten, um Dateien aus einem privaten Amazon-S3-Bucket zu laden, wie unten gezeigt:

**Verwenden eines Webservers zum Laden von Dateien in Neptune über SPARQL UPDATE LOAD**

1. Installieren Sie einen Webserver auf einem in der VPC ausgeführten Computer, auf dem Neptune gehostet wird. Die Dateien werden dann geladen. Bei Verwendung von Amazon Linux könnten Sie Apache beispielsweise wie folgt installieren:

   ```
   sudo yum install httpd mod_ssl
   sudo /usr/sbin/apachectl start
   ```

1. Definieren Sie den/die MIME-Typ(en) des RDF-Dateinhalts, den Sie laden möchten. SPARQL bestimmt das Eingabeformat des Inhalts anhand des vom Webserver gesendeten `Content-type`-Headers. Sie müssen daher die relevanten MIME-Typen für den Webserver definieren.

   Angenommen, Sie verwenden die folgenden Dateierweiterungen zum Identifizieren von Dateiformaten:
   + `.nt`für NTriples.
   + `.nq`für NQuads.
   + `.trig` für Trig.
   + `.rdf` für RDF/XML.
   + `.ttl` für Turtle.
   + `.n3` für N3.
   + `.jsonld` für JSON-LD.

   Wenn Sie Apache 2 als Webserver verwenden, würden Sie die Datei `/etc/mime.types` bearbeiten und die folgenden Typen hinzufügen:

   ```
    text/plain nt
    application/n-quads nq
    application/trig trig
    application/rdf+xml rdf
    application/x-turtle ttl
    text/rdf+n3 n3
    application/ld+json jsonld
   ```

1. Überprüfen Sie, ob die MIME-artige Zuweisung funktioniert. Sobald ein Webserver in Betrieb ist und RDF-Dateien in einem Format/in Formaten Ihrer Wahl hostet, können Sie die Konfiguration testen, indem Sie von Ihrem lokalen Host eine Anfrage an den Webserver senden.

   Sie können beispielsweise eine Anfrage wie z. B. die Folgende senden:

   ```
   curl -v http://localhost:80/test.rdf
   ```

   Anschließend sollten Sie in einer detaillierten Ausgabe von `curl` eine Zeile ähnlich der Folgenden sehen:

   ```
   Content-Type: application/rdf+xml
   ```

   Daran ist zu erkennen, dass die Zuweisung des Inhaltstyps erfolgreich definiert wurde.

1. Sie sind nun zum Laden von Daten über den Befehl SPARQL UPDATE bereit:

   ```
   curl https://your-neptune-endpoint:port/sparql \
       -d "update=LOAD <http://web_server_private_ip:80/test.rdf>"
   ```

**Anmerkung**  
Die Verwendung von `SPARQL UPDATE LOAD` kann eine Zeitüberschreitung auf dem Webserver auslösen, wenn die zu ladende Quelldatei groß ist. Neptune verarbeitet die Daten der Datei, während sie hinein gestreamt werden. Für eine große Datei kann dies den auf dem Server konfigurierten Zeitüberschreitungswert überschreiten. Dies kann wiederum dazu führen, dass der Server die Verbindung schließt, was zu der folgenden Fehlermeldung führen kann, wenn Neptune auf eine unerwartete EOF-Meldung im Stream trifft:  

```
{
  "detailedMessage":"Invalid syntax in the specified file",
  "code":"InvalidParameterException"
}
```
Wenn Sie diese Meldung erhalten und nicht annehmen, dass Ihre Quelldatei ungültige Syntax enthält, versuchen Sie, die Zeitüberschreitungseinstellungen auf dem Webserver zu erhöhen. Sie können das Problem auch diagnostizieren, indem Sie Debug-Protokolle auf dem Server aktivieren und nach Zeitüberschreitungen suchen.

# Verwenden von SPARQL UPDATE UNLOAD zum Löschen von Daten aus Neptune
<a name="sparql-api-reference-unload"></a>

Neptune stellt auch eine benutzerdefinierte SPARQL-Operation (`UNLOAD`) zum Entfernen von Daten bereit, die in einer Remote-Quelle angegeben sind. `UNLOAD` kann als Gegenstück zur Operation `LOAD` betrachtet werden. Die Syntax ist wie folgt:

```
UNLOAD SILENT (URL of the remote data to be unloaded) FROM GRAPH (named graph from which to remove the data)
```
+ **`SILENT`**   –   (*Optional*) Bewirkt, dass die Operation auch dann erfolgreich ist, wenn bei der Verarbeitung der Daten ein Fehler aufgetreten ist.

  Dies kann nützlich sein, wenn eine einzelne Transaktion mehrere Anweisungen enthält, z. B. `"LOAD ...; LOAD ...; UNLOAD ...; LOAD ...;"`, und die Transaktion abgeschlossen werden soll, auch wenn einige der entfernten Daten nicht verarbeitet werden konnten.
+ *URL of the remote data to be unloaded*— (*Erforderlich*) Gibt eine entfernte Datendatei an, die Daten enthält, die aus einem Diagramm entladen werden sollen.

  Die Remote-Datei muss eine der folgenden Erweiterungen haben (dies sind dieselben Formate, die UPDATE-LOAD unterstützt):
  + `.nt`für NTriples.
  + `.nq`für NQuads.
  + `.trig` für Trig.
  + `.rdf` für RDF/XML.
  + `.ttl` für Turtle.
  + `.n3` für N3.
  + `.jsonld` für JSON-LD.

  Alle Daten, die diese Datei enthält, werden durch die Operation `UNLOAD` aus Ihrem DB-Cluster entfernt.

  Jede Amazon-S3-Authentifizierung muss in der URL enthalten sein, damit die Daten entladen werden können. Sie können eine Amazon-S3-Datei vorsignieren und dann über die resultierende URL sicher auf sie zugreifen. Beispiel:

  ```
  aws s3 presign --expires-in (number of seconds) s3://(bucket name)/(path to file of data to unload)
  ```

  Dann:

  ```
  curl https://(a Neptune endpoint URL):8182/sparql \
    --data-urlencode 'update=unload (pre-signed URL of the remote Amazon S3 data to be unloaded) \
                             from graph (named graph)'
  ```

  Weitere Informationen finden Sie auf der Seite zum Thema [Authentifizieren von Anforderungen: Verwenden von Abfrageparametern](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html).
+ **`FROM GRAPH `***(named graph from which to remove the data)*— (*Optional*) Gibt das benannte Diagramm an, aus dem die entfernten Daten entladen werden sollen.

  Neptune ordnet jedem Triple ein benanntes Diagramm zu. Sie können das benannte Standarddiagramm mithilfe des Fallback-URI (`http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph`) für das benannte Diagramm wie folgt angeben:

  ```
  FROM GRAPH <http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph>
  ```

Auf die gleiche Weise, wie `LOAD` `INSERT DATA { (inline data) }` entspricht, entspricht `UNLOAD` `DELETE DATA { (inline data) }`. Wie `DELETE DATA`, funktioniert `UNLOAD` nicht für Daten, die leere Knoten enthalten.

Wenn ein lokaler Webserver beispielsweise eine Datei mit dem Namen `data.nt` bereitstellt, die die folgenden 2 Tripel enthält:

```
<http://example.org/resource#a> <http://example.org/resource#p> <http://example.org/resource#b> .
<http://example.org/resource#a> <http://example.org/resource#p> <http://example.org/resource#c> .
```

Der folgende Befehl `UNLOAD` würde diese beiden Tripel aus dem benannten Diagramm (`<http://example.org/graph1>`) löschen.

```
UNLOAD <http://localhost:80/data.nt> FROM GRAPH <http://example.org/graph1>
```

Dies hätte den gleichen Effekt wie die Verwendung des folgenden Befehls `DELETE DATA`:

```
DELETE DATA {
  GRAPH <http://example.org/graph1> {
    <http://example.org/resource#a> <http://example.org/resource#p> <http://example.org/resource#b> .
    <http://example.org/resource#a> <http://example.org/resource#p> <http://example.org/resource#c> .
  }
}
```

**Ausnahmen, die durch den Befehl `UNLOAD` ausgelöst werden**
+ **`InvalidParameterException`**   –   Die Daten enthielten leere Knoten. *HTTP-Status*: 400 – Ungültige Anforderung.

  *Meldung*: ` Blank nodes are not allowed for UNLOAD`

   
+ **`InvalidParameterException`**   –   Die Daten enthielten eine fehlerhafte Syntax. *HTTP-Status*: 400 – Ungültige Anforderung.

  *Meldung*: `Invalid syntax in the specified file.`

   
+ **`UnloadUrlAccessDeniedException `**   –   Zugriff wurde abgelehnt. *HTTP-Status*: 400 – Ungültige Anforderung.

  *Meldung*: `Update failure: Endpoint (Neptune endpoint) reported access denied error. Please verify access.`

   
+ **`BadRequestException `**   –   Die Remote-Daten können nicht abgerufen werden. *HTTP-Status*: 400 – Ungültige Anforderung.

  *Meldung*: *(von der HTTP-Antwort abhängig).*

# SPARQL-Abfragehinweise
<a name="sparql-query-hints"></a>

Sie können mit Abfragehinweisen Optimierungs- und Auswertungsstrategien für eine bestimmte SPARQL-Abfrage in Amazon Neptune angeben. 

Abfragehinweise werden mittels zusätzlicher Triple-Muster ausgedrückt, die in die SPARQL-Abfrage eingebettet sind und folgende Teile haben:

```
scope hint value
```
+ *scope* – Bestimmt den Teil der Abfrage, auf den der Abfragehinweis angewendet wird, wie eine bestimmte Gruppe in der Abfrage oder die gesamte Abfrage.
+ *hint* – Identifiziert die Art des anzuwendenden Hinweises.
+ *value* – Legt das Verhalten des jeweiligen Systemaspekts fest.

Die Abfragehinweise und Bereiche werden als vordefinierte Begriffe im Amazon–Neptune-Namespace `http://aws.amazon.com/neptune/vocab/v01/QueryHints#` angezeigt. Die Beispiele in diesem Abschnitt enthalten den Namespace als ein `hint`-Präfix, das in der Abfrage definiert und enthalten ist:

```
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
```

Das folgende Beispiel zeigt beispielsweise, wie Sie einen `joinOrder`-Hinweis in einer `SELECT`-Abfrage einschließen:

```
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
SELECT ... {
 hint:Query hint:joinOrder "Ordered" .
 ...
}
```

Die vorherige Abfrage weist die Neptune-Engine an, Joins in der Abfrage in der *angegebenen* Reihenfolge auszuwerten, und deaktiviert jede automatische Neuanordnung.

Sie sollten bei der Verwendung von Abfragehinweisen folgende Punkte beachten:
+ Sie können in einer einzigen Abfrage verschiedene Abfragehinweise kombinieren. Beispielsweise können Sie den Abfragehinweis `bottomUp` verwenden, um eine Unterabfrage für die Auswertung von unten nach oben zu markieren, und den Abfragehinweis `joinOrder`, um die Join-Anordnung innerhalb der Unterabfrage festzulegen.
+ Sie können den gleichen Abfragehinweis mehrmals in verschiedenen, sich nicht überschneidenden Bereichen verwenden.
+ Abfragehinweise sind Hinweise. Obwohl die Abfrage-Engine in der Regel die Berücksichtigung der angegebenen Abfragehinweise anstrebt, kann sie diese auch ignorieren.
+ Abfragehinweise bewahren die Semantik. Das Hinzufügen eines Abfragehinweises ändert die Ausgabe der Abfrage nicht (ausgenommen die potenzielle Ergebnisreihenfolge, wenn keine Anordnungsgarantien angegeben werden; d. h., wenn die Ergebnisreihenfolge nicht explizit mit ORDER BY durchgesetzt wird). 

Die folgenden Abschnitte enthalten weitere Informationen zu den verfügbaren Abfragehinweisen und ihre Nutzung in Neptune.

**Topics**
+ [

## Bereich der SPARQL-Abfragehinweise in Neptune
](#sparql-query-hints-scope)
+ [

# Der SPARQL-Abfragehinweis `joinOrder`
](sparql-query-hints-joinOrder.md)
+ [

# Der SPARQL-Abfragehinweis `evaluationStrategy`
](sparql-query-hints-evaluationStrategy.md)
+ [

# Der SPARQL-Abfragehinweis `queryTimeout`
](sparql-query-hints-queryTimeout.md)
+ [

# Der SPARQL-Abfragehinweis `rangeSafe`
](sparql-query-hints-rangeSafe.md)
+ [

# Der SPARQL-Abfragehinweis `queryId`
](sparql-query-hints-queryId.md)
+ [

# Der SPARQL-Abfragehinweis `useDFE`
](sparql-query-hints-useDFE.md)
+ [

# SPARQL-Abfragehinweise, die mit DESCRIBE verwendet werden
](sparql-query-hints-for-describe.md)

## Bereich der SPARQL-Abfragehinweise in Neptune
<a name="sparql-query-hints-scope"></a>

Die folgende Tabelle zeigt die verfügbaren Bereiche, zugehörigen Hinweise und Beschreibungen für SPARQL-Abfragehinweise in Amazon Neptune. Das Präfix `hint` in diesen Einträgen stellt den Neptune-Namespace für Hinweise dar:

```
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
```


| Scope | Unterstützter Hinweis | Description | 
| --- | --- | --- | 
| hint:Query | [joinOrder](sparql-query-hints-joinOrder.md) | Der Abfragehinweis gilt für die gesamte Abfrage. | 
| hint:Query | [queryTimeout](sparql-query-hints-queryTimeout.md) | Der Timeout-Wert gilt für die gesamte Abfrage. | 
| hint:Query | [rangeSafe](sparql-query-hints-rangeSafe.md) | Die Typheraufstufung ist für die gesamte Abfrage deaktiviert. | 
| hint:Query | [queryId](sparql-query-hints-queryId.md) | Der Abfrage-ID-Wert gilt für die gesamte Abfrage. | 
| hint:Query | [useDFE](sparql-query-hints-useDFE.md) | Die DFE ist für die gesamte Abfrage aktiviert (oder deaktiviert). | 
| hint:Group | [joinOrder](sparql-query-hints-joinOrder.md) | Der Abfragehinweis gilt für die Elemente auf der obersten Ebene in der angegebenen Gruppe, jedoch nicht für verschachtelte Elemente (z. B. Unterabfragen) oder übergeordnete Elemente. | 
| hint:SubQuery | [evaluationStrategy](sparql-query-hints-evaluationStrategy.md) | Der Hinweis angegeben ist und gilt für eine verschachtelte SELECT-Unterabfrage. Die Unterabfrage wird unabhängig ohne Berücksichtigung von Lösungen ausgewertet, die vor der Unterabfrage berechnet wurden. | 

# Der SPARQL-Abfragehinweis `joinOrder`
<a name="sparql-query-hints-joinOrder"></a>

Wenn Sie eine SPARQL-Abfrage senden, untersucht die Abfrage-Engine von Amazon Neptune die Struktur der Abfrage. Sie ordnet Teile der Abfrage neu an und versucht, den für die Auswertung erforderlichen Aufwand und die Reaktionszeit der Abfrage zu reduzieren.

Beispielsweise wird eine Folge verbundener Triple-Muster in der Regel nicht in der angegebenen Reihenfolge ausgewertet. Sie wird mittels Heuristik und Statistik neu angeordnet, beispielweise der Selektivität der einzelnen Muster und der Art ihrer Verbindung mittels gemeinsamer Variablen. Wenn Ihre Abfrage außerdem komplexere Muster wie Unterabfragen oder komplexe OPTIONAL- oder MINUS-Blöcke enthält FILTERs, ordnet die Neptune-Abfrage-Engine diese nach Möglichkeit neu an, um eine effiziente Bewertungsreihenfolge zu erreichen.

Für komplexere Abfragen ist die Reihenfolge, in der Neptune die Abfrage bewertet, möglicherweise nicht immer optimal. Beispielsweise übersieht Neptune möglicherweise spezifische Instance-Dateneigenschaften (z. B. Power-Knoten im Diagramm), die während der Auswertung der Abfrage auftauchen.

Wenn Sie die genauen Merkmale der Daten kennen und die Reihenfolge der Abfrageausführung manuell festlegen möchten, können Sie den Neptune-Abfragehinweis `joinOrder` verwenden, um anzugeben, dass die Abfrage in der angegebenen Reihenfolge ausgewertet werden soll.

## SPARQL-Hinweissyntax `joinOrder`
<a name="sparql-query-hints-joinOrder-syntax"></a>

Der Abfragehinweis `joinOrder` ist als Triple-Muster angegeben, das in einer SPARQL-Abfrage enthalten ist.

Die folgende Syntax verwendet das Präfix `hint`, das in der Abfrage definiert und eingefügt ist, zur Angabe des Neptune-Abfragehinweis-Namespace:

```
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
scope hint:joinOrder "Ordered" .
```

**Verfügbare Bereiche**
+ `hint:Query`
+ `hint:Group`

Weitere Informationen zu Bereichen von Abfragehinweisen finden Sie unter [Bereich der SPARQL-Abfragehinweise in Neptune](sparql-query-hints.md#sparql-query-hints-scope).

## Beispiel für einen SPARQL-Hinweis `joinOrder`
<a name="sparql-query-hints-joinOrder-example"></a>

Dieser Abschnitt zeigt eine mit und ohne den Abfragehinweis `joinOrder` geschriebene Abfrage und die entsprechenden Optimierungen.

In diesem Beispiel wird davon ausgegangen, dass der Datensatz die folgenden Elemente enthält:
+ Eine einzelne Person mit dem Namen `John`, die 1.000 Personen mit `:likes` markiert hat, darunter `Jane`.
+ Eine einzelne Person mit dem Namen `Jane`, die 10 Personen mit `:likes` markiert hat, darunter `John`.

**Kein Abfragehinweis**  
Die folgende SPARQL-Abfrage extrahiert alle Paare von Personen mit dem Namen `John` und `Jane` aus einem Satz von Daten aus sozialen Netzwerken, die sich gegenseitig mit „Like“ (Gefällt) markiert haben.

```
PREFIX : <https://example.com/>
SELECT ?john ?jane {
  ?person1 :name "Jane" .
  ?person1 :likes ?person2 .
  ?person2 :name "John" .
  ?person2 :likes ?person1 .
}
```

Die Abfrage-Engine von Neptune wertet die Anweisungen möglicherweise in einer anderen Reihenfolge als geschrieben aus. Sie könnte sie beispielsweise in der folgenden Reihenfolge auswerten:

1. Suche nach allen Personen mit dem Namen `John`.

1. Suche nach allen mit `John` über das Edge `:likes` verbundenen Personen.

1. Filtern dieses Satzes nach Personen mit dem Namen `Jane`.

1. Filtern dieses Satzes nach mit `John` über das Edge `:likes` verbundenen Personen.

Entsprechend dem Datensatz ergibt die Auswertung in der Reihenfolge 1.000 Entitäten, die im zweiten Schritt extrahiert werden. Der dritte Schritt engt dies auf den einzelnen Knoten `Jane` ein. Im letzten Schritt wird ermittelt, dass `Jane` den Knoten `John` auch mit `:likes` markiert hat.

**Abfragehinweis**  
Es wäre günstiger, mit dem Knoten `Jane` zu beginnen, da dieser nur 10 ausgehende `:likes` Edges besitzt. Dies reduziert den Aufwand während der Auswertung der Abfrage, da das Extrahieren der 1.000 Entitäten im zweiten Schritt vermieden wird.

Das folgende Beispiel verwendet den Abfragehinweis **joinOrder**, um sicherzustellen, dass der Knoten `Jane` und dessen ausgehenden Kanten zuerst verarbeitet werden, indem die automatische Neuanordnung der Verbindung für die Abfrage deaktiviert ist:

```
PREFIX : <https://example.com/>
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
SELECT ?john ?jane {
  hint:Query hint:joinOrder "Ordered" .
  ?person1 :name "Jane" .
  ?person1 :likes ?person2 .
  ?person2 :name "John" .
  ?person2 :likes ?person1 .
}
```

Ein reales Szenario wäre etwa eine Social-Network-Anwendung, bei der Personen im Netzwerk als Influencer mit zahlreichen Verbindungen oder als normale Nutzer mit wenigen Verbindungen klassifiziert würden. In einem solchen Szenario könnten Sie dafür sorgen, dass in einem Beispiel wie dem obigen der normale Benutzer (`Jane`) vor dem Influencer (`John`) verarbeitet würde.

**Abfragehinweis und Neuanordnung**  
Sie können mit diesem Beispiel einen Schritt weiter gehen. Wenn Sie wissen, dass das `:name`-Attribut für einen Knoten eindeutig ist, könnten Sie die Abfrage durch Neuanordnung und Verwendung des Abfragehinweises `joinOrder` beschleunigen Dieser Schritt stellt sicher, dass die eindeutigen Knoten zuerst extrahiert werden.

```
PREFIX : <https://example.com/>
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
SELECT ?john ?jane {
  hint:Query hint:joinOrder "Ordered" .
  ?person1 :name "Jane" .
  ?person2 :name "John" .
  ?person1 :likes ?person2 .
  ?person2 :likes ?person1 .
}
```

In diesem Fall können Sie die Abfrage auf die folgenden einzelnen Aktionen in jedem Schritt reduzieren:

1. Suchen des Einzelpersonknotens mit `:name` `Jane`.

1. Suchen des Einzelpersonknotens mit `:name` `John`.

1. Prüfen, ob der erste Knoten über eine `:likes`-Edge mit dem zweiten verbunden ist.

1. Prüfen, ob der zweite Knoten über eine `:likes`-Edge mit dem ersten verbunden ist.



**Wichtig**  
Wenn Sie die falsche Reihenfolge wählen, kann der Abfragehinweis `joinOrder` zu erheblichen Leistungseinbußen führen. Das vorangehende Beispiel wäre beispielsweise ineffizient, wenn die `:name`-Attribute nicht eindeutig wären. Hätten alle 100-Knoten den Namen `Jane` und alle 1.000-Knoten den Namen `John`, würde die Abfrage 1.000 \$1 100 (100.000) Paare für `:likes`-Edges prüfen.

# Der SPARQL-Abfragehinweis `evaluationStrategy`
<a name="sparql-query-hints-evaluationStrategy"></a>

Der Abfragehinweis `evaluationStrategy` teilt der Amazon–Neptune-Abfrageengine mit, dass das markierte Abfragefragment von unten nach oben als unabhängige Einheit evaluiert werden soll. Dies bedeutet, dass keine Lösungen aus vorherigen Evaluierungsschritten für die Berechnung des Abfragefragments verwendet werden. Das Abfragefragment wird als selbstständige Einheit evaluiert, und seine produzierten Lösungen werden nach der Berechnung mit dem Rest der Abfrage verbunden.

Die Verwendung des `evaluationStrategy`-Abfragehinweises impliziert die Blockierung eines Abfrageplans (ohne Pipeline); dies bedeutet, dass die Lösungen auf dem mit dem Abfragehinweis versehenen Fragment im Hauptspeicher materialisiert und zwischengespeichert werden. Die Verwendung dieses Abfragehinweises kann die Menge des Hauptspeichers deutlich erhöhen, die für die Evaluierung der Abfrage erforderlich ist, besonders wenn das markierte Abfragefragment eine große Zahl von Ergebnissen berechnet.

## SPARQL-Hinweissyntax `evaluationStrategy`
<a name="sparql-query-hints-evaluationStrategy-syntax"></a>

Der Abfragehinweis `evaluationStrategy` ist als Triple-Muster angegeben, das in einer SPARQL-Abfrage enthalten ist.

Die folgende Syntax verwendet das Präfix `hint`, das in der Abfrage definiert und eingefügt ist, zur Angabe des Neptune-Abfragehinweis-Namespace:

```
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
hint:SubQuery hint:evaluationStrategy "BottomUp" .
```

**Verfügbare Bereiche**
+ `hint:SubQuery`

**Anmerkung**  
Dieser Abfragehinweis wird nur in verschachtelten Unterabfragen unterstützt.

Weitere Informationen zu Bereichen von Abfragehinweisen finden Sie unter [Bereich der SPARQL-Abfragehinweise in Neptune](sparql-query-hints.md#sparql-query-hints-scope).

## Beispiel für einen SPARQL-Hinweis `evaluationStrategy`
<a name="sparql-query-hints-evaluationStrategy-example"></a>



Dieser Abschnitt zeigt eine mit und ohne den Abfragehinweis `evaluationStrategy` geschriebene Abfrage und die entsprechenden Optimierungen.

In diesem Beispiel wird davon ausgegangen, dass der Datensatz über die folgenden Eigenschaften verfügt:
+ Er enthält 1.000 Edges mit der Beschriftung `:connectedTo`.
+ Jeder `component`-Knoten ist mit durchschnittlich 100 anderen `component`-Knoten verbunden.
+ Die typische Anzahl von vier-hop-zyklischen Verbindungen zwischen Knoten liegt bei etwa 100.

Als ein typisches Beispiel kann der `evaluationStrategy`-Hinweis hilfreich sein, um Abfragemuster mit Zyklen zu optimieren.

**Kein Abfragehinweis**  
Die folgende SPARQL-Abfrage extrahiert alle `component`-Knoten, die zyklisch miteinander über vier Hops verbunden sind:

```
PREFIX : <https://example.com/>
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
SELECT * {
  ?component1 :connectedTo ?component2 .
  ?component2 :connectedTo ?component3 .
  ?component3 :connectedTo ?component4 .
  ?component4 :connectedTo ?component1 .
}
```

Das Konzept der Neptune-Abfrageengine besteht darin, diese Abfrage mit den folgenden Schritten auszuwerten:
+ Extrahieren aller 1.000 `connectedTo`-Edges in dem Graph.
+ Erweitern Sie dies um das Hundertfache (die Anzahl der ausgehenden `connectedTo`-Edges von Component2).

  Zwischenergebnisse: 100.000 Knoten.
+ Erweitern Sie dies um das Hundertfache (die Anzahl der ausgehenden `connectedTo`-Edges von Component3).

  Zwischenergebnisse: 10.000.000 Knoten.
+ Scannen Sie die 10.000.000 Knoten für den Zyklusabschluss.

Dies führt zu einem Streaming-Abfrageplan, der eine konstante Menge an Arbeitsspeicher verwendet.

**Abfragehinweis und Unterabfragen**  
Möglicherweise möchten Sie Kompromisse beim Hauptspeicherplatz machen, um die Berechnungen zu beschleunigen. Indem Sie die Abfrage mithilfe eines `evaluationStrategy`-Abfragehinweises umschreiben, können Sie erzwingen, dass die Engine eine Verbindung zwischen kleineren, materialisierten Teilmengen berechnet.

```
PREFIX : <https://example.com/>
          PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
SELECT * {
  {
    SELECT * WHERE {
      hint:SubQuery hint:evaluationStrategy "BottomUp" .
      ?component1 :connectedTo ?component2 .
      ?component2 :connectedTo ?component3 .
    }
  }
  {
    SELECT * WHERE {
      hint:SubQuery hint:evaluationStrategy "BottomUp" .
      ?component3 :connectedTo ?component4 .
      ?component4 :connectedTo ?component1 .
    }
  }
}
```

Anstatt die Triple-Muster nacheinander bei iterativer Verwendung der Ergebnisse vom vorherigen Triple-Muster als Eingabe für die folgenden Muster zu evaluieren, sorgt der `evaluationStrategy`-Hinweis dafür, dass die beiden Unterabfragen unabhängig evaluiert werden. Beide Unterabfragen produzieren 100.000 Knoten für Zwischenergebnisse, die dann miteinander verbunden werden, um die endgültige Ausgabe zu erstellen. 

Wenn Sie Neptune auf den größeren Instance-Typen ausführen, erhöht die temporäre Speicherung dieser beiden Teilmengen von 100 000 die Speichernutzung, ermöglicht damit jedoch deutlich schnellere Auswertungen.

# Der SPARQL-Abfragehinweis `queryTimeout`
<a name="sparql-query-hints-queryTimeout"></a>

Der `queryTimeout`-Abfragehinweis gibt eine Zeitüberschreitung an, die kürzer ist als der `neptune_query_timeout`-Wert, der in der DB-Parameter-Gruppe festlegt ist.

Wenn die Abfrage aufgrund dieses Hinweises beendet wird, wird ein`TimeLimitExceededException` mit einer `Operation terminated (deadline exceeded)`- Nachricht ausgelöst.

## SPARQL-Hinweissyntax `queryTimeout`
<a name="sparql-query-hints-queryTimeout-syntax"></a>

```
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
SELECT ... WHERE {
    hint:Query hint:queryTimeout 10 .
    # OR
    hint:Query hint:queryTimeout "10" .
    # OR
    hint:Query hint:queryTimeout "10"^^xsd:integer .
 ...
}
```

Der Timeout-Wert wird in Millisekunden angegeben.

Der Timeout-Wert muss kleiner sein als der in der DB-Parametergruppe festgelegte `neptune_query_timeout`-Wert. Andernfalls wird eine `MalformedQueryException`-Ausnahme mit einer `Malformed query: Query hint 'queryTimeout' must be less than neptune_query_timeout DB Parameter Group`-Nachricht ausgelöst.

Der `queryTimeout`-Abfragehinweis sollte in der `WHERE`-Klausel der Hauptabfrage oder in der `WHERE`-Klausel einer der Unterabfragen, wie im nachfolgenden Beispiel dargestellt, angegeben werden.

Sie darf in allen Abschnitten queries/subqueries und SPARQL-Updates (wie INSERT und DELETE) nur einmal gesetzt werden. Andernfalls wird eine `MalformedQueryException`-Ausnahme mit einer `Malformed query: Query hint 'queryTimeout' must be set only once`-Nachricht ausgelöst.

**Verfügbare Bereiche**

Der `queryTimeout`-Hinweis kann sowohl auf SPARQL-Abfragen als auch auf Updates angewendet werden.
+ In einer SPARQL-Abfrage kann sie in der WHERE-Klausel der Hauptabfrage oder einer Unterabfrage erscheinen.
+ In einem SPARQL-Update kann er in der INSERT-, DELETE- oder WHERE-Klausel festgelegt werden. Wenn es mehrere Update-Klauseln gibt, kann er nur in einer davon festgelegt werden.

Weitere Informationen zu Bereichen von Abfragehinweisen finden Sie unter [Bereich der SPARQL-Abfragehinweise in Neptune](sparql-query-hints.md#sparql-query-hints-scope).

## Beispiel für einen SPARQL-Hinweis `queryTimeout`
<a name="sparql-query-hints-queryTimeout-example"></a>

Hier finden Sie ein Beispiel für die Verwendung von `hint:queryTimeout` in der `WHERE`-Hauptklausel einer `UPDATE`-Abfrage:

```
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
INSERT {
    ?s ?p ?o
} WHERE {
    hint:Query hint:queryTimeout 100 .
    ?s ?p ?o .
}
```

Hier ist `hint:queryTimeout` eine Unterabfrage in der `WHERE`-Klausel:

```
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
SELECT * {
   ?s ?p ?o .
   {
      SELECT ?s WHERE {
         hint:Query hint:queryTimeout 100 .
         ?s ?p1 ?o1 .
      }
   }
}
```

# Der SPARQL-Abfragehinweis `rangeSafe`
<a name="sparql-query-hints-rangeSafe"></a>

Mit diesem Abfragehinweis können Sie die Typheraufstufung für eine SPARQL-Abfrage deaktivieren.

Wenn Sie eine SPARQL-Abfrage absenden, die einen `FILTER` für einen numerischen Wert oder Bereich enthält, muss die Neptune-Abfrage-Engine normalerweise den Typ heraufstufen, wenn sie die Abfrage ausführt. Das bedeutet, dass sie die Werte aller Typen untersuchen muss, die den Wert enthalten könnten, nach dem Sie filtern.

Wenn Sie beispielsweise nach Werten filtern, die gleich 55 sind, muss die Engine nach Ganzzahlen gleich 55, langen Ganzzahlen gleich 55L, Gleitkommazahlen gleich 55,0 usw. suchen. Jede Typheraufstufung erfordert eine zusätzliche Suche im Speicher. Dies kann dazu führen, dass eine scheinbar einfache Abfrage unerwartet lange dauert, bis sie abgeschlossen ist.

Häufig ist eine Heraufstufung des Typs nicht notwendig, da Sie bereits wissen, dass Sie nur Werte eines bestimmten Typs suchen müssen. In diesem Fall können Sie Ihre Abfragen erheblich beschleunigen, indem Sie die Typheraufstufung mit dem Abfragehinweis `rangeSafe` deaktivieren.

## SPARQL-Hinweissyntax `rangeSafe`
<a name="sparql-query-hints-rangeSafe-syntax"></a>

Der Abfragehinweis `rangeSafe` nimmt den Wert `true` an, um die Typheraufstufung zu deaktivieren. Er akzeptiert auch den Wert `false` (Standard).

**Beispiel.** Das folgende Beispiel zeigt, wie die Typheraufstufung deaktiviert wird, wenn nach einem Ganzzahlwert von `o` größer als 1 gefiltert wird:

```
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
SELECT * {
   ?s ?p ?o .
   hint:Prior hint:rangeSafe 'true' .
   FILTER (?o > '1'^^<http://www.w3.org/2001/XMLSchema#int>)
```

# Der SPARQL-Abfragehinweis `queryId`
<a name="sparql-query-hints-queryId"></a>

Verwenden Sie diesen Abfragehinweis, um einer SPARQL-Abfrage einen eigenen queryId-Wert zuzuweisen.

Beispiel:

```
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
SELECT * WHERE {
  hint:Query hint:queryId "4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47"
  {?s ?p ?o}}
```

Der Wert, den Sie zuweisen, muss für alle Abfragen in der Neptune-DB eindeutig sein.

# Der SPARQL-Abfragehinweis `useDFE`
<a name="sparql-query-hints-useDFE"></a>

Mit diesem Abfragehinweis können Sie die Verwendung der DFE zur Ausführung der Abfrage aktivieren. Standardmäßig verwendet Neptune die DFE nicht, wenn dieser Abfragehinweis nicht auf `true` festgelegt ist, da der Instance-Parameter [neptune\$1dfe\$1query\$1engine](parameters.md#parameters-instance-parameters-neptune_dfe_query_engine) standardmäßig auf `viaQueryHint` festgelegt ist. Wenn Sie diesen Instance-Parameter auf `enabled` festlegen, wird die DFE-Engine für alle Abfragen verwendet, außer Abfragen, bei denen der Abfragehinweis `useDFE` auf `false` festgelegt ist.

Beispiel für die Aktivierung der Verwendung der DFE für eine Abfrage:

```
PREFIX : <https://example.com/>
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>

SELECT ?john ?jane
{
  hint:Query hint:useDFE true .
  ?person1 :name "Jane" .
  ?person1 :likes ?person2 .
  ?person2 :name "John" .
  ?person2 :likes ?person1 .
}
```

# SPARQL-Abfragehinweise, die mit DESCRIBE verwendet werden
<a name="sparql-query-hints-for-describe"></a>

Eine SPARQL-`DESCRIBE`Abfrage stellt einen flexiblen Mechanismus zum Anfordern von Ressourcenbeschreibungen bereit. Die SPARQL-Spezifikationen definieren jedoch nicht die genaue Semantik von `DESCRIBE`.

Ab [Engine-Version 1.2.0.2](engine-releases-1.2.0.2.md) unterstützt Neptune mehrere verschiedene `DESCRIBE`-Modi und -Algorithmen, die für unterschiedliche Situationen geeignet sind.

Dieser Beispieldatensatz kann helfen, die verschiedenen Modi zu veranschaulichen:

```
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
@prefix : <https://example.com/> .

:JaneDoe :firstName "Jane" .
:JaneDoe :knows :JohnDoe .
:JohnDoe :firstName "John" .
:JaneDoe :knows _:b1 .
_:b1 :knows :RichardRoe .

:RichardRoe :knows :JaneDoe .
:RichardRoe :firstName "Richard" .

_:s1 rdf:type rdf:Statement .
_:s1 rdf:subject :JaneDoe .
_:s1 rdf:predicate :knows .
_:s1 rdf:object :JohnDoe .
_:s1 :knowsFrom "Berlin" .

:ref_s2 rdf:type rdf:Statement .
:ref_s2 rdf:subject :JaneDoe .
:ref_s2 rdf:predicate :knows .
:ref_s2 rdf:object :JohnDoe .
:ref_s2 :knowsSince 1988 .
```

Die folgenden Beispiele gehen davon aus, dass eine Beschreibung der Ressource `:JaneDoe` mit einer SPARQL-Abfrage wie dieser angefordert wird:

```
DESCRIBE <https://example.com/JaneDoe>
```

## Der SPARQL-Abfragehinweis `describeMode`
<a name="sparql-query-hints-describeMode"></a>

Der SPARQL-Abfragehinweis `hint:describeMode` wird verwendet, um einen der folgenden, von Neptune unterstützten SPARQL-`DESCRIBE`-Modi auszuwählen:

### Der DESCRIBE-Modus `ForwardOneStep`
<a name="sparql-query-hints-describeMode-ForwardOneStep"></a>

Sie rufen den Modus `ForwardOneStep` wie folgt mit dem Abfragehinweis `describeMode` auf:

```
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
DESCRIBE <https://example.com/JaneDoe>
{
  hint:Query hint:describeMode "ForwardOneStep"
}
```

Der Modus `ForwardOneStep` gibt nur die Attribute und Forward-Links der Ressource zurück, die beschrieben werden soll. Im Beispiel gibt der Modus die Tripel zurück, deren Subjekt `:JaneDoe` ist, die Ressource, die beschrieben werden soll.

```
:JaneDoe :firstName "Jane" .
:JaneDoe :knows :JohnDoe .
:JaneDoe :knows _:b301990159 .
```

Beachten Sie, dass die DESCRIBE-Abfrage Triples mit leeren Knoten zurückgeben kann, z. B.`_:b301990159`, die IDs jedes Mal anders sind als der Eingabedatensatz.

### Der DESCRIBE-Modus `SymmetricOneStep`
<a name="sparql-query-hints-describeMode-SymmetricOneStep"></a>

`SymmetricOneStep` ist der DESCRIBE-Standardmodus, wenn Sie keinen Abfragehinweis angeben. Sie können ihn auch explizit mit dem Abfragehinweis `describeMode` wie folgt aufrufen:

```
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
DESCRIBE <https://example.com/JaneDoe>
{
  hint:Query hint:describeMode "SymmetricOneStep"
}
```

In der Semantik `SymmetricOneStep` gibt `DESCRIBE` die Attribute, Forward- und Reverse-Links der Ressource zurück, die beschrieben werden soll:

```
:JaneDoe :firstName "Jane" .
:JaneDoe :knows :JohnDoe .
:JaneDoe :knows _:b318767375 .

_:b318767631 rdf:subject :JaneDoe .

:RichardRoe :knows :JaneDoe .

:ref_s2 rdf:subject :JaneDoe .
```

### Der DESCRIBE-Modus Concise Bounded Description (`CBD`)
<a name="sparql-query-hints-describeMode-CBD"></a>

Der Modus Concise Bounded Description (`CBD`) wird mit dem Abfragehinweis `describeMode` wie folgt aufgerufen:

```
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
DESCRIBE <https://example.com/JaneDoe>
{
  hint:Query hint:describeMode "CBD"
}
```

In der Semantik `CBD` gibt `DESCRIBE` die Concise Bounded Description (wie [vom W3C definiert](http://www.w3.org/Submission/CBD)) der zu beschreibenden Ressource zurück:

```
:JaneDoe :firstName "Jane" .
:JaneDoe :knows :JohnDoe .
:JaneDoe :knows _:b285212943 .
_:b285212943 :knows :RichardRoe .

_:b285213199 rdf:subject :JaneDoe .
_:b285213199 rdf:type rdf:Statement .
_:b285213199 rdf:predicate :knows .
_:b285213199 rdf:object :JohnDoe .
_:b285213199 :knowsFrom "Berlin" .

:ref_s2 rdf:subject :JaneDoe .
```

Die Concise Bounded Description einer RDF-Ressource (d. h. eines Knotens in einem RDF-Diagramm) ist das kleinste Unterdiagramm um diesen Knoten herum, das eigenständig sein kann. Wenn Sie sich dieses Diagramm als Baum vorstellen, bei dem der angegebene Knoten die Wurzel ist, dann gibt es keine leeren Knoten (bnodes) als Blätter dieses Baums. Da bnodes nicht extern adressiert oder in nachfolgenden Abfragen verwendet werden können, reicht es nicht aus, das Diagramm zu durchsuchen, nur um den oder die nächsten einzelnen Hop(s) vom aktuellen Knoten aus zu finden. Sie müssen auch weit genug gehen, um etwas zu finden, das in nachfolgenden Abfragen verwendet werden kann (d. h. etwas anderes als ein bnode).

#### Berechnen der CBD
<a name="sparql-query-hints-describeMode-CBD-computing"></a>

Für einen bestimmten Knoten (den Startknoten oder die Wurzel) im RDF-Quelldiagramm wird der CBD-Wert dieses Knotens wie folgt berechnet:

1. Fügen Sie in das Unterdiagramm alle Anweisungen im Quelldiagramm ein, deren *Subjekt* der Anweisung der Startknoten ist.

1. Fügen Sie rekursiv für alle vorhandenen Anweisungen im Unterdiagramm, die ein leeres *Knotenobjekt* haben, in das Quelldiagramm alle Anweisungen ein, in denen das *Subjekt* der Anweisung dieser leere Knoten ist und die noch nicht im Unterdiagramm enthalten sind.

1. Fügen Sie rekursiv für alle bisher eingefügten Anweisungen im Unterdiagramm, für alle Konkretisierungen dieser Anweisungen im Quelldiagramm die CBD ab dem `rdf:Statement`-Knoten jeder Konkretisierung ein.

Dies führt zu einem Unterdiagramm, in dem die *Objektknoten* entweder IRI-Referenzen oder Literale sind oder leere Knoten, die nicht als *Subjekt* einer Anweisung im Diagramm dienen. Beachten Sie, dass die CBD nicht mit einzelnen SPARQL SELECT- oder CONSTRUCT-Abfrage berechnet werden kann.

### Der DESCRIBE-Modus Symmetric Concise Bounded Description (`SCBD`)
<a name="sparql-query-hints-describeMode-SCBD"></a>

Der Modus Symmetric Concise Bounded Description (`SCBD`) wird mit dem Abfragehinweis `describeMode` wie folgt aufgerufen:

```
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
DESCRIBE <https://example.com/JaneDoe>
{
  hint:Query hint:describeMode "SCBD"
}
```

In der `SCBD`-Semantik gibt `DESCRIBE` die Symmetric Concise Bounded Description der Ressource zurück (wie vom W3C in [Describing Linked Datasets with the VoID Vocabulary](http://www.w3.org/TR/void/) definiert:

```
:JaneDoe :firstName "Jane" .
:JaneDoe :knows :JohnDoe .
:JaneDoe :knows _:b335544591 .
_:b335544591 :knows :RichardRoe .

:RichardRoe :knows :JaneDoe .

_:b335544847 rdf:subject :JaneDoe .
_:b335544847 rdf:type rdf:Statement .
_:b335544847 rdf:predicate :knows .
_:b335544847 rdf:object :JohnDoe .
_:b335544847 :knowsFrom "Berlin" .

:ref_s2 rdf:subject :JaneDoe .
```

Der Vorteil von CBD und SCBD gegenüber den Modi `ForwardOneStep` und `SymmetricOneStep` besteht darin, dass leere Knoten stets um ihre Darstellung erweitert werden. Dies kann ein wichtiger Vorteil sein, da Sie einen leeren Knoten nicht über SPARQL abfragen können. Darüber hinaus berücksichtigen die Modi CBD und SCBD auch Konkretisierungen.

Beachten Sie, dass der Abfragehinweis `describeMode` auch Teil einer `WHERE`-Klausel sein kann:

```
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
DESCRIBE ?s
WHERE {
  hint:Query hint:describeMode "CBD" .
  ?s rdf:type <https://example.com/Person>
}
```

## Der SPARQL-Abfragehinweis `describeIterationLimit`
<a name="sparql-query-hints-describeIterationLimit"></a>

Der SPARQL-Abfragehinweis `hint:describeIterationLimit` stellt eine **optionale** Einschränkung der maximalen Anzahl iterativer Erweiterungen bereit, die für iterative DESCRIBE-Algorithmen wie CBD und SCBD ausgeführt werden sollen.

Die DESCRIBE-Grenzwerte gelten ANDed zusammen. Wenn also sowohl die Iterationseinschränkung als auch die Befehlseinschränkung angegeben sind, müssen beide Einschränkungen eingehalten werden, bevor die DESCRIBE-Abfrage abgeschnitten wird.

Der Standardwert für diesen Wert ist 5. Sie können ihn auf NULL (0) festlegen, um anzugeben, dass die Anzahl der iterativen Erweiterungen KEINEN Einschränkungen unterliegt.

## Der SPARQL-Abfragehinweis `describeStatementLimit`
<a name="sparql-query-hints-describeStatementLimit"></a>

Der SPARQL-Abfragehinweis `hint:describeStatementLimit` stellt eine **optionale** Einschränkung der maximalen Anzahl von Anweisungen dar, die in einer DESCRIBE-Abfrageantwort enthalten sein dürfen. Er wird nur auf iterative DESCRIBE-Algorithmen wie CBD und SCBD angewendet.

DESCRIBE-Grenzwerte gehören ANDed zusammen. Wenn also sowohl die Iterationseinschränkung als auch die Befehlseinschränkung angegeben sind, müssen beide Einschränkungen eingehalten werden, bevor die DESCRIBE-Abfrage abgeschnitten wird.

Der Standardwert für diesen Wert ist 5 000. Sie können ihn auf NULL (0) festlegen, um anzugeben, dass die Anzahl der zurückgegebenen Anweisungen KEINEN Einschränkungen unterliegt.

# Verhalten von SPARQL DESCRIBE in Bezug auf das Standarddiagramm
<a name="sparql-default-describe"></a>

Über das SPARQL-Abfrageformular [https://www.w3.org/TR/sparql11-query/#describe](https://www.w3.org/TR/sparql11-query/#describe) können Sie Informationen zu Ressourcen abrufen, ohne die Struktur der Daten zu kennen und ohne eine Abfrage schreiben zu müssen. Wie diese Informationen zusammengestellt werden, ist der SPARQL-Implementierung überlassen. Neptune stellt [mehrere Abfragehinweise](sparql-query-hints-for-describe.md) bereit, die verschiedene Modi und Algorithmen zur Verwendung durch `DESCRIBE` aufrufen.

In der Neptune-Implementierung verwendet `DESCRIBE` unabhängig vom Modus ausschließlich Daten im [SPARQL-Standarddiagramm](feature-sparql-compliance.md#sparql-default-graph). Dies entspricht der Art, wie SPARQL Datensätze behandelt (siehe [Specifying RDF Datasets](https://www.w3.org/TR/sparql11-query/#specifyingDataset) in der SPARQL-Spezifikation).

In Neptune enthält das Standarddiagramm alle eindeutigen Tripel in der Vereinigung aller benannten Graphen in der Datenbank, es sei denn, bestimmte benannte Graphen werden mithilfe von Klauseln spezifiziert. `FROM` and/or `FROM NAMED` Alle RDF-Daten in Neptune werden in einem benannten Diagramm gespeichert. Wenn ein Tripel außerhalb eines Kontexts mit einem benannten Diagramm eingefügt wird, speichert Neptune es in einem benannten Graphen mit der Bezeichnung `http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph`.

Wenn ein oder mehrere benannte Diagramme mittels der `FROM`-Klausel angegeben werden, ist das Standarddiagramm die Vereinigung aller eindeutigen Tripel in diesen benannten Diagrammen. Wenn es keine `FROM`-Klausel gibt, jedoch eine oder mehrere `FROM NAMED`-Klauseln, ist das Standarddiagramm leer.

## Beispiele für SPARQL `DESCRIBE`
<a name="sparql-default-describe-examples"></a>

Betrachten Sie die folgende Daten:

```
PREFIX ex: <https://example.com/>

GRAPH ex:g1 {
    ex:s ex:p1 "a" .
    ex:s ex:p2 "c" .
}

GRAPH ex:g2 {
    ex:s ex:p3 "b" .
    ex:s ex:p2 "c" .
}

ex:s ex:p3 "d" .
```

Für diese Abfrage:

```
PREFIX ex: <https://example.com/>
DESCRIBE ?s
FROM ex:g1
FROM NAMED ex:g2
WHERE {
  GRAPH ex:g2 { ?s ?p "b" . }
}
```

Neptune würde Folgendes zurück:

```
ex:s ex:p1 "a" .
ex:s ex:p2 "c" .
```

Hier wird zuerst das Diagrammmuster `GRAPH ex:g2 { ?s ?p "b" }` ausgewertet, was zu Bindungen für `?s` führt. Anschließend wird der Teil `DESCRIBE` anhand des Standarddiagramms ausgewertet, das jetzt `ex:g1` ist.

Für diese Abfrage gilt jedoch Folgendes:

```
PREFIX ex: <https://example.com/>
DESCRIBE ?s 
FROM NAMED ex:g1 
WHERE { 
  GRAPH ex:g1 { ?s ?p "a" . } 
}
```

Neptune würde nichts zurückgeben, da das Standarddiagramm leer ist, wenn eine `FROM NAMED`-Klausel, jedoch keine `FROM`-Klausel vorhanden ist.

In der folgenden Abfrage wird `DESCRIBE` verwendet, ohne dass eine `FROM`- oder `FROM NAMED`-Klausel vorhanden ist:

```
PREFIX ex: <https://example.com/>
DESCRIBE ?s 
WHERE { 
  GRAPH ex:g1 { ?s ?p "a" . } 
}
```

In dieser Situation besteht das Standarddiagramm aus allen eindeutigen Tripeln in der Vereinigung aller benannten Diagramme in der Datenbank (formal die RDF-Zusammenführung). Neptune würde daher Folgendes zurückgeben:

```
ex:s ex:p1 "a" . 
ex:s ex:p2 "c" . 
ex:s ex:p3 "b" .
ex:s ex:p3 "d" .
```

# SPARQL-Abfragestatus-API
<a name="sparql-api-status"></a>

Zum Abrufen des Status von SPARQL-Abfragen verwenden Sie HTTP `GET` oder `POST`, um eine Anforderung an den `https://your-neptune-endpoint:port/sparql/status`-Endpunkt zu senden. 

## SPARQL-Abfragestatus-Anforderungsparameter
<a name="sparql-api-status-get-request"></a>

**queryId (optional)**  
Die ID einer laufenden SPARQL-Abfrage Zeigt nur den Status der angegebenen Abfrage an.

## SPARQL-Abfragestatus-Antwortsyntax
<a name="sparql-api-status-get-response-syntax"></a>

```
{
    "acceptedQueryCount": integer,
    "runningQueryCount": integer,
    "queries": [
      {
        "queryId":"guid",
        "queryEvalStats":
          {
            "subqueries": integer,
            "elapsed": integer,
            "cancelled": boolean
          },
        "queryString": "string"
      }
    ]
}
```

## SPARQL-Abfragestatus-Antwortwerte
<a name="sparql-api-status-get-response-values"></a>

**acceptedQueryCount**  
Die Anzahl der Abfragen, die seit dem letzten Neustart der Neptune-Engine akzeptiert wurden.

**runningQueryCount**  
Die Anzahl der zurzeit laufenden SPARQL-Abfragen

**queries**  
Eine Liste der aktuellen SPARQL-Abfragen

**queryId**  
Eine GUID-ID für die Abfrage Neptune weist diesen ID-Wert automatisch jeder Abfrage zu. Sie können auch eine eigene ID zuweisen (siehe [Einfügen einer benutzerdefinierten ID in eine Neptune-Gremlin- oder -SPARQL-Abfrage](features-query-id.md)). 

**queryEvalStats**  
Statistiken für diese Abfrage

**Unterabfragen**  
Die Anzahl der Unterabfragen in dieser Abfrage

**elapsed**  
Die Dauer in Mikrosekunden, die die Abfrage bis jetzt ausgeführt wurde

**cancelled**  
„True“ gibt an, dass die Abfrage abgebrochen wurde.

**queryString**  
Die gesendete Abfrage

## SPARQL-Abfragestatus-Beispiel
<a name="sparql-api-status-get-example"></a>

Das folgende Beispiel zeigt den Statusbefehl mit Verwendung von `curl` und HTTP `GET`.

```
curl https://your-neptune-endpoint:port/sparql/status
```

Diese Ausgabe zeigt eine einzelne ausgeführte Abfrage.

```
{
    "acceptedQueryCount":9,
    "runningQueryCount":1,
    "queries": [
        {
            "queryId":"fb34cd3e-f37c-4d12-9cf2-03bb741bf54f",
            "queryEvalStats":
                {
                    "subqueries": 0,
                    "elapsed": 29256,
                    "cancelled": false
                },
            "queryString": "SELECT ?s ?p ?o WHERE {?s ?p ?o}"
        }
    ]
}
```

# SPARQL-Abfrageabbruch
<a name="sparql-api-status-cancel"></a>

Zum Abrufen des Status von SPARQL-Abfragen verwenden Sie HTTP `GET` oder `POST`, um eine Anforderung an den `https://your-neptune-endpoint:port/sparql/status`-Endpunkt zu senden.

## SPARQL-Abfrageabruch-Anforderungsparameter
<a name="sparql-api-status-cancel-request"></a>

**cancelQuery**  
(Erforderlich) Weist den Statusbefehl an, eine Abfrage abzubrechen. Dieser Parameter akzeptiert keinen Wert.

**queryId**  
(Erforderlich) Die ID der laufenden SPARQL-Abfrage, die abgebrochen werden soll.

**Still**  
(Optional) Bei `silent=true` wird die laufende Abfrage abgebrochen, und der HTTP-Antwortcode lautet 200. Wenn `silent` nicht vorhanden ist oder bei `silent=false` wird die Abfrage mit einem HTTP 500-Statuscode abgebrochen.

## SPARQL-Abfrageabbruch-Beispiele
<a name="sparql-api-status-cancel-example"></a>

**Beispiel 1: Abbruch mit `silent=false`**  
Es folgt ein Beispiel für den Statusbefehl, der `curl` verwendet, um eine Abfrage abzubrechen, wobei der `silent`-Parameter auf `false` gesetzt ist:

```
curl https://your-neptune-endpoint:port/sparql/status \
  -d "cancelQuery" \
  -d "queryId=4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47" \
  -d "silent=false"
```

Wenn die Abfrage nicht bereits mit dem Streaming der Ergebnisse begonnen hat, würde die abgebrochene Abfrage dann einen HTTP-500-Code mit einer Antwort wie folgt zurückgeben:

```
{
  "code": "CancelledByUserException",
  "requestId": "4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47",
  "detailedMessage": "Operation terminated (cancelled by user)"
}
```

Wenn die Abfrage bereits einen HTTP-200-Code (OK) zurückgegeben hat und mit dem Streaming der Ergebnisse begonnen hat, bevor sie abgebrochen wurde, werden die Informationen zur Zeitbeschränkungsausnahme an den regulären Ausgabe-Stream gesendet.

**Beispiel 2: Abbruch mit `silent=true`**  
Nachfolgend finden Sie ein Beispiel für denselben Statusbefehl wie oben mit Ausnahme des `silent`-Parameters, der jetzt auf `true` gesetzt ist:

```
curl https://your-neptune-endpoint:port/sparql/status \
  -d "cancelQuery" \
  -d "queryId=4d5c4fae-aa30-41cf-9e1f-91e6b7dd6f47" \
  -d "silent=true"
```

Dieser Befehl würde die gleiche Antwort wie bei `silent=false` zurückgeben, aber die abgebrochene Abfrage würde jetzt einen HTTP 200-Code mit einer Antwort wie folgt zurückgeben:

```
{
  "head" : {
    "vars" : [ "s", "p", "o" ]
  },
  "results" : {
    "bindings" : [ ]
  }
}
```

# Verwenden des SPARQL 1.1-Graph-Store-Protokolls (GSP) über HTTP in Amazon Neptune
<a name="sparql-graph-store-protocol"></a>

In der Empfehlung [SPARQL 1.1 Graph Store HTTP Protocol](https://www.w3.org/TR/sparql11-http-rdf-update/) hat das W3C ein HTTP-Protokoll für die Verwaltung von RDF-Diagrammen definiert. Es definiert Operationen für die Entfernung, Erstellung und Ersetzung von RDF-Diagramminhalten und die Hinzufügung von RDF-Anweisungen zu vorhandenem Inhalten.

Das Graph-Store-Protokoll (GSP) ermöglicht die Bearbeitung eines vollständigen Diagramms, ohne komplexe SPARQL-Abfragen schreiben zu müssen.

Neptune unterstützt dieses Protokoll vollständig.

Der Endpunkt für das Graph-Store-Protokoll (GSP) ist:

```
https://your-neptune-cluster:port/sparql/gsp/
```

Um über GSP auf das Standarddiagramm zuzugreifen, verwenden Sie:

```
https://your-neptune-cluster:port/sparql/gsp/?default
```

Um über GSP auf ein benanntes Diagramm zuzugreifen, verwenden Sie:

```
https://your-neptune-cluster:port/sparql/gsp/?graph=named-graph-URI
```

## Besondere Details der Neptune-GSP-Implementierung
<a name="sparql-graph-store-protocol-special"></a>

Neptune setzt die [W3C-Empfehlung](https://www.w3.org/TR/sparql11-http-rdf-update/) mit der GSP-Definition vollständig um. Es gibt jedoch einige Situationen, die die Spezifikation nicht abdeckt.

Ein solcher Fall tritt ein, wenn eine `PUT`- oder `POST`-Anforderung ein oder mehrere benannte Diagramme im Anforderungstext spezifiziert, die sich vom in der Anforderungs-URL angegebenen Diagramm unterscheiden. Dies ist nur möglich, wenn das RDF-Format des Anforderungstexts benannte Graphen unterstützt, z. B. die Verwendung von `Content-Type: application/n-quads` oder`Content-Type: application/trig`.

In diesem Fall fügt Neptune alle im Text benannten Diagramme und das in der URL angegebene benannte Diagramm hinzu oder aktualisiert sie.

Angenommen, Sie beginnen mit einer leeren Datenbank und senden eine `PUT`-Anforderung, um ein Upsert für Stimmen in drei Diagramme auszuführen. Das Diagramm mit dem Namen `urn:votes` enthält alle Stimmen aus allen Wahljahren. Die beiden anderen Diagramme mit den Namen `urn:votes:2005` und `urn:votes:2019` enthalten Stimmen aus bestimmten Wahljahren. Die Anforderung und ihre Nutzlast sehen wie folgt aus:

```
PUT "http://your-Neptune-cluster:port/sparql/gsp/?graph=urn:votes"
  Host: example.com
  Content-Type: application/n-quads

  PAYLOAD:

  <urn:JohnDoe> <urn:votedFor> <urn:Labour> <urn:votes:2005>
  <urn:JohnDoe> <urn:votedFor> <urn:Conservative> <urn:votes:2019>
  <urn:JaneSmith> <urn:votedFor> <urn:LiberalDemocrats> <urn:votes:2005>
  <urn:JaneSmith> <urn:votedFor> <urn:Conservative> <urn:votes:2019>
```

Nach der Ausführung der Anforderung sehen die Daten in der Datenbank wie folgt aus:

```
<urn:JohnDoe>   <urn:votedFor> <urn:Labour>           <urn:votes:2005>
<urn:JohnDoe>   <urn:votedFor> <urn:Conservative>     <urn:votes:2019>
<urn:JaneSmith> <urn:votedFor> <urn:LiberalDemocrats> <urn:votes:2005>
<urn:JaneSmith> <urn:votedFor> <urn:Conservative>     <urn:votes:2019>
<urn:JohnDoe>   <urn:votedFor> <urn:Labour>           <urn:votes>
<urn:JohnDoe>   <urn:votedFor> <urn:Conservative>     <urn:votes>
<urn:JaneSmith> <urn:votedFor> <urn:LiberalDemocrats> <urn:votes>
<urn:JaneSmith> <urn:votedFor> <urn:Conservative>     <urn:votes>
```

Eine weitere mehrdeutige Situation entsteht, wenn in der Anforderungs-URL (mit `PUT`, `POST`, `GET` oder `DELETE`) mehr als ein Diagramm angegeben ist. Beispiel:

```
POST "http://your-Neptune-cluster:port/sparql/gsp/?graph=urn:votes:2005&graph=urn:votes:2019"
```

Oder:

```
GET "http://your-Neptune-cluster:port/sparql/gsp/?default&graph=urn:votes:2019"
```

In diesem Fall gibt Neptune HTTP 400 mit der Meldung zurück, dass in der Anforderungs-URL nur ein Diagramm angegeben werden darf.

# Analysieren der Neptune-Abfrageausführung über SPARQL `explain`
<a name="sparql-explain"></a>

Amazon Neptune hat das SPARQL -Feature *explain* hinzugefügt. Dieses Feature ist ein Self-Service-Tool, um den Ausführungsansatz der Neptune-Engine zu verstehen. Sie rufen diese Funktion auf, indem Sie einem HTTP-Aufruf, der eine SPARQL-Abfrage sendet, einen `explain`-Parameter hinzufügen.

Die `explain`-Funktion bietet Informationen zur logischen Struktur von Abfrageausführungsplänen. Mit diesen Informationen können Sie potenzielle Engpässe bei der Bewertung und Ausführung identifizieren. Anschließend können Sie Ihre Abfrageausführungspläne mit [Abfragetipps](sparql-query-hints.md) verbessern.

**Topics**
+ [

# Funktionsweise der SPARQL-Abfrage-Engine in Neptune
](sparql-explain-engine.md)
+ [

# Verwenden von SPARQL `explain` zur Analyse der Neptune-Abfrageausführung
](sparql-explain-using.md)
+ [

# Beispiele für das Aufrufen von SPARQL `explain` in Neptune
](sparql-explain-examples.md)
+ [

# Neptune SPARQL-Operatoren für `explain`
](sparql-explain-operators.md)
+ [

# Einschränkungen für SPARQL `explain` in Neptune
](sparql-explain-limitations.md)

# Funktionsweise der SPARQL-Abfrage-Engine in Neptune
<a name="sparql-explain-engine"></a>

Um die Informationen zu verwenden, die das SPARQL-Feature `explain` bereitstellt, müssen Sie einige Details zur Funktionsweise der SPARQL-Abfrage-Engine von Amazon Neptune kennen.

Die Engine übersetzt jede SPARQL-Abfrage in eine Operatoren-Pipeline. Ab dem ersten Operator durchlaufen Zwischenlösungen, die als *Bindungslisten* bekannt sind, diese Operator Pipeline. Sie können sich eine Bindungsliste als eine Tabelle vorstellen, in der die Tabellenüberschriften eine Teilmenge der in der Abfrage verwendeten Variablen darstellen. Jede Zeile in der Tabelle steht für ein Ergebnis bis zur kompletten Bewertung.

Angenommen, zwei Namespace-Präfixe wurden für unsere Daten definiert,

```
  @prefix ex:   <http://example.com> .
  @prefix foaf: <http://xmlns.com/foaf/0.1/> .
```

dann ergäbe sich in diesem Kontext das folgende Beispiel einer einfachen Bindungsliste:

```
  ?person       | ?firstName
  ------------------------------------------------------
  ex:JaneDoe    | "Jane"
  ex:JohnDoe    | "John"
  ex:RichardRoe | "Richard"
```

Für alle drei Personen wird die `?person`-Variable von der Liste an einen Bezeichner der Person und die `?firstName`-Variable an den Vornamen der Person gebunden.

Im Allgemeinen können Variablen ungebunden bleiben, wenn beispielsweise eine `OPTIONAL`-Auswahl einer Variable in einer Abfrage vorliegt, für die kein Wert in den Daten vorhanden ist.

Der `PipelineJoin`-Operator ist ein Beispiel für einen Operator der Neptune-Abfrage-Engine in der `explain`-Ausgabe. Dabei wird als Eingabe ein eingehender Bindungssatz aus dem vorherigen Operator übernommen und einem Dreifachmuster, z. B. `(?person, foaf:lastName, ?lastName)` angefügt. Bei diesem Vorgang werden die Bindungen für die `?person`-Variable im Eingabe-Stream verwendet und im Dreifachmuster ersetzt. Außerdem werden die Triplets in der Datenbank nachgeschlagen.

Bei der Ausführung im Kontext der eingehenden Bindungen aus der vorherigen Tabelle würde `PipelineJoin` die folgenden drei Suchvorgänge bewerten:

```
  (ex:JaneDoe,    foaf:lastName, ?lastName)
  (ex:JohnDoe,    foaf:lastName, ?lastName)
  (ex:RichardRoe, foaf:lastName, ?lastName)
```

Dieser Ansatz wird als *as-bound*-Bewertung bezeichnet. Die Lösungen dieses Bewertungsprozess werden den eingehenden Lösungen zugeführt, sodass das erkannte `?lastName`-Objekt in den eingehenden Lösungen aufgefüllt wird. Falls Sie einen Nachnamen für alle drei Personen finden, erstellt der Operator eine ausgehende Bindungsliste, die etwa wie folgt aussieht:

```
  ?person       | ?firstName | ?lastName
  ---------------------------------------
  ex:JaneDoe    | "Jane"     | "Doe"
  ex:JohnDoe    | "John"     | "Doe"
  ex:RichardRoe | "Richard"  | "Roe"
```

Diese ausgehende Bindungsliste dient anschließend als Eingabe für den nächsten Operator in der Pipeline. Am Ende definiert die Ausgabe des letzten Operators in der Pipeline das Abfrageergebnis.

Operator-Pipelines sind häufig linear. Da bedeutet, jeder Operator gibt Lösungen für einen einzelnen verbundenen Operator weiter. In einigen Fällen kann es jedoch zu komplexen Strukturen kommen. Beispiel: Ein `UNION`-Operator in einer SPARQL-Abfrage wird einer `Copy`-Operation zugeordnet. Dieser Vorgang dupliziert die Bindungen und leitet die Kopien an zwei Unterpläne weiter; einer für die linke Seite und der andere für die rechte Seite der `UNION`.

Weitere Informationen zu Operatoren finden Sie unter [Neptune SPARQL-Operatoren für `explain`](sparql-explain-operators.md).

# Verwenden von SPARQL `explain` zur Analyse der Neptune-Abfrageausführung
<a name="sparql-explain-using"></a>

Das SPARQL-Feature `explain` ist ein Self-Service-Tool in Amazon Neptune, das Ihnen hilft, den Ausführungsansatz der Neptune-Engine besser zu verstehen. Wenn Sie `explain` aufrufen, übergeben Sie einen Parameter in der Form `explain=mode` an eine HTTP- oder HTTPS-Anforderung.

Der Moduswert kann `static`, `dynamic` oder `details` sein.
+ Im *statischen* Modus gibt `explain` nur die statische Struktur des Abfrageplans aus.
+ Im *dynamischen* Modus enthält `explain` auch dynamische Aspekte des Abfrageplans. Diese Aspekte können ggf. die Anzahl der durch die Operatoren fließenden Zwischenbindungen, das Verhältnis der eingehenden zu den ausgehenden Bindungen sowie die von den Operatoren insgesamt in Anspruch genommene Zeit enthalten.
+ Im *Detailmodus* werden die im `dynamic`-Modus angezeigten Informationen sowie zusätzliche Details wie die tatsächliche SPARQL-Abfragezeichenfolge und die geschätzte Bereichsanzahl für das Muster , das einem Join-Operator zugrunde liegt, von `explain` gedruckt.

Neptune unterstützt die Verwendung von `explain` mit allen drei SPARQL-Abfragezugriffsprotokollen, die in der Spezifikation [W3C SPARQL 1.1 Protocol](https://www.w3.org/TR/sparql11-protocol/#query-operation) aufgeführt sind:

1. HTTP GET

1. HTTP POST mit URL-verschlüsselten Parametern

1. HTTP POST mit Textparametern

Allgemeine Informationen zur Abfrage-Engine von SPARQL finden Sie unter [Funktionsweise der SPARQL-Abfrage-Engine in Neptune](sparql-explain-engine.md).

Weitere Informationen über die Art der durch das Aufrufen von SPARQL `explain` erstellten Ausgabe finden Sie unter [Beispiele für das Aufrufen von SPARQL `explain` in Neptune](sparql-explain-examples.md).

# Beispiele für das Aufrufen von SPARQL `explain` in Neptune
<a name="sparql-explain-examples"></a>

Die Beispiele in diesem Abschnitt zeigen die Arten von Ausgaben, die Sie durch das Aufrufen des SPARQL-Features `explain` erzeugen können, um die Abfrageausführung in Amazon Neptune zu analysieren.

**Topics**
+ [

## Informationen zur Explain-Ausgabe
](#sparql-explain-example-output)
+ [

## Beispiel für die Ausgabe im Detailmodus
](#sparql-explain-example-details)
+ [

## Beispiel für die Ausgabe im statischen Modus
](#sparql-explain-example-static)
+ [

## Verschiedene Möglichkeiten für die Parameterverschlüsselung
](#sparql-explain-example-parameters)
+ [

## Weitere Ausgabetypen außer text/plain
](#sparql-explain-output-options)
+ [

## Beispiel für die SPARQL-Ausgabe `explain` mit DFE-Aktivierung
](#sparql-explain-output-dfe)

## Informationen zur Explain-Ausgabe
<a name="sparql-explain-example-output"></a>

In diesem Beispiel kennt Jane Doe die beiden Personen John Doe und Richard Roe:

```
@prefix ex: <http://example.com> .
@prefix foaf: <http://xmlns.com/foaf/0.1/> .

ex:JaneDoe foaf:knows ex:JohnDoe .
ex:JohnDoe foaf:firstName "John" .
ex:JohnDoe foaf:lastName "Doe" .
ex:JaneDoe foaf:knows ex:RichardRoe .
ex:RichardRoe foaf:firstName "Richard" .
ex:RichardRoe foaf:lastName "Roe" .
.
```

Wenn Sie den Vornamen aller Personen ermitteln möchten, die Jane Doe kennt, können Sie die folgende Abfrage schreiben:

```
 curl http(s)://your_server:your_port/sparql \
   -d "query=PREFIX foaf: <https://xmlns.com/foaf/0.1/> PREFIX ex: <https://www.example.com/> \
       SELECT ?firstName WHERE { ex:JaneDoe foaf:knows ?person . ?person foaf:firstName ?firstName }" \
   -H "Accept: text/csv"
```

Diese einfache Abfrage gibt Folgendes zurück:

```
firstName
John
Richard
```

Als Nächstes ändern Sie den `curl`-Befehl, um `explain` aufzurufen, indem Sie `-d "explain=dynamic"` hinzufügen und den Standardausgabetyp anstelle von `text/csv` verwenden:

```
 curl http(s)://your_server:your_port/sparql \
   -d "query=PREFIX foaf: <https://xmlns.com/foaf/0.1/> PREFIX ex: <https://www.example.com/> \
       SELECT ?firstName WHERE { ex:JaneDoe foaf:knows ?person . ?person foaf:firstName ?firstName }" \
   -d "explain=dynamic"
```

Die Abfrage gibt jetzt eine Ausgabe in gut lesbarem ASCII-Format (HTTP-Inhaltstyp `text/plain`) zurück. Dabei handelt es sich um die Standardausgabe:

```
╔════╤════════╤════════╤═══════════════════╤═══════════════════════════════════════════════════════╤══════════╤══════════╤═══════════╤═══════╤═══════════╗
║ ID │ Out #1 │ Out #2 │ Name              │ Arguments                                             │ Mode     │ Units In │ Units Out │ Ratio │ Time (ms) ║
╠════╪════════╪════════╪═══════════════════╪═══════════════════════════════════════════════════════╪══════════╪══════════╪═══════════╪═══════╪═══════════╣
║ 0  │ 1      │ -      │ SolutionInjection │ solutions=[{}]                                        │ -        │ 0        │ 1         │ 0.00  │ 0         ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 1  │ 2      │ -      │ PipelineJoin      │ pattern=distinct(ex:JaneDoe, foaf:knows, ?person)     │ -        │ 1        │ 2         │ 2.00  │ 1         ║
║    │        │        │                   │ joinType=join                                         │          │          │           │       │           ║
║    │        │        │                   │ joinProjectionVars=[?person]                          │          │          │           │       │           ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 2  │ 3      │ -      │ PipelineJoin      │ pattern=distinct(?person, foaf:firstName, ?firstName) │ -        │ 2        │ 2         │ 1.00  │ 1         ║
║    │        │        │                   │ joinType=join                                         │          │          │           │       │           ║
║    │        │        │                   │ joinProjectionVars=[?person, ?firstName]              │          │          │           │       │           ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 3  │ 4      │ -      │ Projection        │ vars=[?firstName]                                     │ retain   │ 2        │ 2         │ 1.00  │ 0         ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 4  │ -      │ -      │ TermResolution    │ vars=[?firstName]                                     │ id2value │ 2        │ 2         │ 1.00  │ 1         ║
╚════╧════════╧════════╧═══════════════════╧═══════════════════════════════════════════════════════╧══════════╧══════════╧═══════════╧═══════╧═══════════╝
```

Weitere Informationen zu den Operationen in der `Name`-Spalte und ihren Argumenten finden Sie unter [explain-Operatoren](sparql-explain-operators.md).

In der folgenden Tabelle wird die Ausgabe Zeile für Zeile beschrieben:

1. Beim ersten Schritt in der Hauptabfrage wird immer der `SolutionInjection`-Operator verwendet, um eine Lösung einzubringen. Die Lösung wird dann durch den Bewertungsprozess zum Endergebnis erweitert.

   In diesem Fall bringt er die sogenannte universelle `{ }`-Lösung ein. Bei `VALUES`-Klauseln oder `BIND` bringt dieser Schritt zu Beginn möglicherweise auch komplexere Variablenbindungen ein.

   Die `Units Out`-Spalte zeigt an, dass diese Einzellösung aus dem Operator eingeht. Die `Out #1`-Spalte gibt den Operator an, in den dieser Operator das Ergebnis einbringt. In diesem Beispiel sind alle Operatoren mit dem folgenden Operator in der Tabelle verbunden.

1. Die zweite Schritt ist ein `PipelineJoin`-Element. Es empfängt als Eingabe die einzelne universelle (vollständig uneingeschränkte) Lösung, die durch den vorherigen Operator (`Units In := 1`) erstellt wurde. Es verbindet sich im Tupel-Muster, das vom `pattern`-Argument definiert wird. Dies entspricht einer einfachen Suche nach dem Muster. In diesem Fall wird die dreifache Muster wie folgt definiert:

   ```
   distinct( ex:JaneDoe, foaf:knows, ?person )
   ```

   Das `joinType := join`-Argument gibt an, dass es sich um eine normale Verbindung handelt (andere Typen umfassen `optional`-Joins, `existence check`-Joins usw.).

   Das `distinct := true`-Argument gibt an, dass Sie nur eindeutige Treffer (keine Duplikate) aus der Datenbank extrahieren, und Sie binden die unterschiedlichen Treffer auf deduplizierte Weise an die `joinProjectionVars := ?person`-Variable.

   Die Tatsache, dass der `Units Out`-Spaltenwert 2 lautet, gibt an, dass zwei Lösungen ausgehen. Genauer gesagt handelt es sich dabei um die Bindungen für die `?person`-Variable, mit der die zwei Personen widergespiegelt werden, die Jane Doe laut der Daten kennt:

   ```
    ?person
    -------------
    ex:JohnDoe
    ex:RichardRoe
   ```

1. Die beiden Lösungen aus Stufe 2 gehen als Eingabe (`Units In := 2`) in das zweite `PipelineJoin`-Element ein. Dieser Operator verbindet die beiden vorherigen Lösungen mit dem folgenden Dreifachmuster:

   ```
   distinct(?person, foaf:firstName, ?firstName)
   ```

   Die `?person`-Variable wird mithilfe der eingehenden Lösung des Operators entweder an `ex:JohnDoe` oder `ex:RichardRoe` gebunden. Da `PipelineJoin` den Vornamen John und Richard extrahiert, lauten die beiden ausgehenden Lösungen (Units Out: = 2) wie folgt:

   ```
    ?person       | ?firstName
    ---------------------------
    ex:JohnDoe    | John
    ex:RichardRoe | Richard
   ```

1. Der nächste Projection-Operator übernimmt als Eingabe die beiden Lösungen aus Stufe 3 (`Units In := 2`) und projiziert sie zur `?firstName`-Variable. Dadurch entfallen alle anderen Variablenbindungen in den Zuweisungen und die beiden Bindungen (`Units Out := 2`) werden übergeben:

   ```
    ?firstName
    ----------
    John
    Richard
   ```

1. Um die Leistung zu verbessern, verwendet Neptune nach Möglichkeit interne Bezeichner, die es Begriffen wie URIs und Zeichenkettenliteralen zuweist, und nicht mit den Zeichenketten selbst. Der letzte Operator, `TermResolution`, führt eine Zuweisung aus diesen internen IDs zurück an die entsprechenden Begriffszeichenfolgen durch.

   In regelmäßigen (nicht Explain-)Abfragen wird das vom letzten Operator berechnete Ergebnis dann in das angeforderte Serialisierungsformat serialisiert und an den Client gestreamt.

## Beispiel für die Ausgabe im Detailmodus
<a name="sparql-explain-example-details"></a>

Angenommen, Sie führen die gleiche Abfrage wie zuvor im *Detailmodus* statt im *dynamischen Modus* aus:

```
 curl http(s)://your_server:your_port/sparql \
   -d "query=PREFIX foaf: <https://xmlns.com/foaf/0.1/> PREFIX ex: <https://www.example.com/> \
       SELECT ?firstName WHERE { ex:JaneDoe foaf:knows ?person . ?person foaf:firstName ?firstName }" \
   -d "explain=details"
```

Wie dieses Beispiel zeigt, ist die Ausgabe bis auf einige zusätzliche Details wie der Abfragezeichenfolge am Anfang der Ausgabe und der `patternEstimate`-Anzahl für den `PipelineJoin`-Operator identisch:

```
Query:
PREFIX foaf: <https://xmlns.com/foaf/0.1/> PREFIX ex: <https://www.example.com/>
SELECT ?firstName WHERE { ex:JaneDoe foaf:knows ?person . ?person foaf:firstName ?firstName }

╔════╤════════╤════════╤═══════════════════╤═══════════════════════════════════════════════════════╤══════════╤══════════╤═══════════╤═══════╤═══════════╗
║ ID │ Out #1 │ Out #2 │ Name              │ Arguments                                             │ Mode     │ Units In │ Units Out │ Ratio │ Time (ms) ║
╠════╪════════╪════════╪═══════════════════╪═══════════════════════════════════════════════════════╪══════════╪══════════╪═══════════╪═══════╪═══════════╣
║ 0  │ 1      │ -      │ SolutionInjection │ solutions=[{}]                                        │ -        │ 0        │ 1         │ 0.00  │ 0         ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 1  │ 2      │ -      │ PipelineJoin      │ pattern=distinct(ex:JaneDoe, foaf:knows, ?person)     │ -        │ 1        │ 2         │ 2.00  │ 13        ║
║    │        │        │                   │ joinType=join                                         │          │          │           │       │           ║
║    │        │        │                   │ joinProjectionVars=[?person]                          │          │          │           │       │           ║
║    │        │        │                   │ patternEstimate=2                                     │          │          │           │       │           ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 2  │ 3      │ -      │ PipelineJoin      │ pattern=distinct(?person, foaf:firstName, ?firstName) │ -        │ 2        │ 2         │ 1.00  │ 3         ║
║    │        │        │                   │ joinType=join                                         │          │          │           │       │           ║
║    │        │        │                   │ joinProjectionVars=[?person, ?firstName]              │          │          │           │       │           ║
║    │        │        │                   │ patternEstimate=2                                     │          │          │           │       │           ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 3  │ 4      │ -      │ Projection        │ vars=[?firstName]                                     │ retain   │ 2        │ 2         │ 1.00  │ 1         ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 4  │ -      │ -      │ TermResolution    │ vars=[?firstName]                                     │ id2value │ 2        │ 2         │ 1.00  │ 7         ║
╚════╧════════╧════════╧═══════════════════╧═══════════════════════════════════════════════════════╧══════════╧══════════╧═══════════╧═══════╧═══════════╝
```

## Beispiel für die Ausgabe im statischen Modus
<a name="sparql-explain-example-static"></a>

Nehmen wir an, Sie führen die gleiche Abfrage wie zuvor im *statischen* Modus (Standard) statt im *dynamischen* Modus aus:

```
 curl http(s)://your_server:your_port/sparql \
   -d "query=PREFIX foaf: <https://xmlns.com/foaf/0.1/> PREFIX ex: <https://www.example.com/> \
       SELECT ?firstName WHERE { ex:JaneDoe foaf:knows ?person . ?person foaf:firstName ?firstName }" \
   -d "explain=static"
```

Wie dieses Beispiel zeigt, ist die Ausgabe identisch, abgesehen davon, dass die letzten drei Spalten ausgelassen werden:

```
╔════╤════════╤════════╤═══════════════════╤═══════════════════════════════════════════════════════╤══════════╗
║ ID │ Out #1 │ Out #2 │ Name              │ Arguments                                             │ Mode     ║
╠════╪════════╪════════╪═══════════════════╪═══════════════════════════════════════════════════════╪══════════╣
║ 0  │ 1      │ -      │ SolutionInjection │ solutions=[{}]                                        │ -        ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────╢
║ 1  │ 2      │ -      │ PipelineJoin      │ pattern=distinct(ex:JaneDoe, foaf:knows, ?person)     │ -        ║
║    │        │        │                   │ joinType=join                                         │          ║
║    │        │        │                   │ joinProjectionVars=[?person]                          │          ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────╢
║ 2  │ 3      │ -      │ PipelineJoin      │ pattern=distinct(?person, foaf:firstName, ?firstName) │ -        ║
║    │        │        │                   │ joinType=join                                         │          ║
║    │        │        │                   │ joinProjectionVars=[?person, ?firstName]              │          ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────╢
║ 3  │ 4      │ -      │ Projection        │ vars=[?firstName]                                     │ retain   ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────╢
║ 4  │ -      │ -      │ TermResolution    │ vars=[?firstName]                                     │ id2value ║
╚════╧════════╧════════╧═══════════════════╧═══════════════════════════════════════════════════════╧══════════╝
```

## Verschiedene Möglichkeiten für die Parameterverschlüsselung
<a name="sparql-explain-example-parameters"></a>

Die folgenden Beispielabfragen demonstrieren zwei verschiedene Möglichkeiten beim Aufrufen von SPARQL `explain` Parameter zu verschlüsseln.

**Verwenden der URL-Verschlüsselung** – Dieses Beispiel verwendet die URL-Parameterverschlüsselung und gibt eine *dynamische* Ausgabe an:

```
curl -XGET "http(s)://your_server:your_port/sparql?query=SELECT%20*%20WHERE%20%7B%20%3Fs%20%3Fp%20%3Fo%20%7D%20LIMIT%20%31&explain=dynamic"
```

**Direkte Parameterangabe** – Dies entspricht der vorherigen Abfrage, die Parameter werden jedoch direkt über POST übergeben:

```
 curl http(s)://your_server:your_port/sparql \
   -d "query=SELECT * WHERE { ?s ?p ?o } LIMIT 1" \
   -d "explain=dynamic"
```

## Weitere Ausgabetypen außer text/plain
<a name="sparql-explain-output-options"></a>

In den vorherigen Beispielen wird der Standardausgabetyp `text/plain` verwendet. Neptune kann die SPARQL-Ausgabe `explain` auch in zwei weiteren MIME-Formaten formatieren, `text/csv` und `text/html`. Sie können sie aufrufen, indem Sie den HTTP-`Accept`-Header aufrufen. Dies ist wie folgt mit dem `-H`-Flag in `curl` möglich:

```
  -H "Accept: output type"
```

Hier sind einige Beispiele:

**`text/csv`-Ausgabe**  
Diese Abfrage ruft eine Abfrage des CSV MIME-Typs auf, indem `-H "Accept: text/csv"` angegeben wird:

```
 curl http(s)://your_server:your_port/sparql \
   -d "query=SELECT * WHERE { ?s ?p ?o } LIMIT 1" \
   -d "explain=dynamic" \
   -H "Accept: text/csv"
```

Das CSV-Format ist beim Importieren von Dateien in eine Tabelle oder Datenbank hilfreich, da es die Felder in jeder `explain`-Zeile durch Semikolons (`;`) trennt, wie im folgenden Beispiel dargestellt:

```
ID;Out #1;Out #2;Name;Arguments;Mode;Units In;Units Out;Ratio;Time (ms)
0;1;-;SolutionInjection;solutions=[{}];-;0;1;0.00;0
1;2;-;PipelineJoin;pattern=distinct(?s, ?p, ?o),joinType=join,joinProjectionVars=[?s, ?p, ?o];-;1;6;6.00;1
2;3;-;Projection;vars=[?s, ?p, ?o];retain;6;6;1.00;2
3;-;-;Slice;limit=1;-;1;1;1.00;1
```

 

**`text/html`-Ausgabe**  
Wenn Sie `-H "Accept: text/html"` angeben, generiert `explain` eine HTML-Tabelle:

```
<!DOCTYPE html>
<html>
  <body>
    <table border="1px">
      <thead>
        <tr>
          <th>ID</th>
          <th>Out #1</th>
          <th>Out #2</th>
          <th>Name</th>
          <th>Arguments</th>
          <th>Mode</th>
          <th>Units In</th>
          <th>Units Out</th>
          <th>Ratio</th>
          <th>Time (ms)</th>
        </tr>
      </thead>

      <tbody>
        <tr>
          <td>0</td>
          <td>1</td>
          <td>-</td>
          <td>SolutionInjection</td>
          <td>solutions=[{}]</td>
          <td>-</td>
          <td>0</td>
          <td>1</td>
          <td>0.00</td>
          <td>0</td>
        </tr>

        <tr>
          <td>1</td>
          <td>2</td>
          <td>-</td>
          <td>PipelineJoin</td>
          <td>pattern=distinct(?s, ?p, ?o)<br>
              joinType=join<br>
              joinProjectionVars=[?s, ?p, ?o]</td>
          <td>-</td>
          <td>1</td>
          <td>6</td>
          <td>6.00</td>
          <td>1</td>
        </tr>

        <tr>
          <td>2</td>
          <td>3</td>
          <td>-</td>
          <td>Projection</td>
          <td>vars=[?s, ?p, ?o]</td>
          <td>retain</td>
          <td>6</td>
          <td>6</td>
          <td>1.00</td>
          <td>2</td>
        </tr>

        <tr>
          <td>3</td>
          <td>-</td>
          <td>-</td>
          <td>Slice</td>
          <td>limit=1</td>
          <td>-</td>
          <td>1</td>
          <td>1</td>
          <td>1.00</td>
          <td>1</td>
        </tr>
      </tbody>
    </table>
  </body>
</html>
```

Das HTML wird in einem Browser etwa wie folgt gerendert:

![\[Beispiel einer SPARQL Explain-HTML-Ausgabe.\]](http://docs.aws.amazon.com/de_de/neptune/latest/userguide/images/sparql-explain-dynamic-html-output.png)


## Beispiel für die SPARQL-Ausgabe `explain` mit DFE-Aktivierung
<a name="sparql-explain-output-dfe"></a>

Dies ist ein Beispiel für eine SPARQL-Ausgabe für `explain` bei Aktivierung der alternativen DFE-Abfrage-Engine:

```
╔════╤════════╤════════╤═══════════════════╤═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╤══════════╤══════════╤═══════════╤═══════╤═══════════╗
║ ID │ Out #1 │ Out #2 │ Name              │ Arguments                                                                                                                                                                                                               │ Mode     │ Units In │ Units Out │ Ratio │ Time (ms) ║
╠════╪════════╪════════╪═══════════════════╪═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╪══════════╪══════════╪═══════════╪═══════╪═══════════╣
║ 0  │ 1      │ -      │ SolutionInjection │ solutions=[{}]                                                                                                                                                                                                          │ -        │ 0        │ 1         │ 0.00  │ 0         ║
╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 1  │ 2      │ -      │ HashIndexBuild    │ solutionSet=solutionSet1                                                                                                                                                                                                │ -        │ 1        │ 1         │ 1.00  │ 22        ║
║    │        │        │                   │ joinVars=[]                                                                                                                                                                                                             │          │          │           │       │           ║
║    │        │        │                   │ sourceType=pipeline                                                                                                                                                                                                     │          │          │           │       │           ║
╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 2  │ 3      │ -      │ DFENode           │ DFE Stats=                                                                                                                                                                                                                    │ -        │ 101      │ 100       │ 0.99  │ 32        ║
║    │        │        │                   │ ====> DFE execution time (measured by DFEQueryEngine)                                                                                                                                                                   │          │          │           │       │           ║
║    │        │        │                   │ accepted [micros]=127                                                                                                                                                                                                   │          │          │           │       │           ║
║    │        │        │                   │ ready [micros]=2                                                                                                                                                                                                        │          │          │           │       │           ║
║    │        │        │                   │ running [micros]=5627                                                                                                                                                                                                   │          │          │           │       │           ║
║    │        │        │                   │ finished [micros]=0                                                                                                                                                                                                     │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ ===> DFE execution time (measured in DFENode)                                                                                                                                                                           │          │          │           │       │           ║
║    │        │        │                   │ -> setupTime [ms]=1                                                                                                                                                                                                     │          │          │           │       │           ║
║    │        │        │                   │ -> executionTime [ms]=14                                                                                                                                                                                                │          │          │           │       │           ║
║    │        │        │                   │ -> resultReadTime [ms]=0                                                                                                                                                                                                │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ ===> Static analysis statistics                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ --> 35907 micros spent in parser.                                                                                                                                                                                       │          │          │           │       │           ║
║    │        │        │                   │ --> 7643 micros spent in range count estimation                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ --> 2895 micros spent in value resolution                                                                                                                                                                               │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ --> 39974925 micros spent in optimizer loop                                                                                                                                                                             │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ DFEJoinGroupNode[ children={                                                                                                                                                                                            │          │          │           │       │           ║
║    │        │        │                   │   DFEPatternNode[(?1, TERM[117442062], ?2, ?3) . project DISTINCT[?1, ?2] {rangeCountEstimate=100},                                                                                                                     │          │          │           │       │           ║
║    │        │        │                   │     OperatorInfoWithAlternative[                                                                                                                                                                                        │          │          │           │       │           ║
║    │        │        │                   │       rec=OperatorInfo[                                                                                                                                                                                                 │          │          │           │       │           ║
║    │        │        │                   │         type=INCREMENTAL_PIPELINE_JOIN,                                                                                                                                                                                 │          │          │           │       │           ║
║    │        │        │                   │         costEstimates=OperatorCostEstimates[                                                                                                                                                                            │          │          │           │       │           ║
║    │        │        │                   │           costEstimate=OperatorCostEstimate[in=1.0000,out=100.0000,io=0.0002,comp=0.0000,mem=0],                                                                                                                        │          │          │           │       │           ║
║    │        │        │                   │           worstCaseCostEstimate=OperatorCostEstimate[in=1.0000,out=100.0000,io=0.0002,comp=0.0000,mem=0]]],                                                                                                             │          │          │           │       │           ║
║    │        │        │                   │       alt=OperatorInfo[                                                                                                                                                                                                 │          │          │           │       │           ║
║    │        │        │                   │         type=INCREMENTAL_HASH_JOIN,                                                                                                                                                                                     │          │          │           │       │           ║
║    │        │        │                   │         costEstimates=OperatorCostEstimates[                                                                                                                                                                            │          │          │           │       │           ║
║    │        │        │                   │           costEstimate=OperatorCostEstimate[in=1.0000,out=100.0000,io=0.0003,comp=0.0000,mem=3212],                                                                                                                     │          │          │           │       │           ║
║    │        │        │                   │           worstCaseCostEstimate=OperatorCostEstimate[in=1.0000,out=100.0000,io=0.0003,comp=0.0000,mem=3212]]]]],                                                                                                        │          │          │           │       │           ║
║    │        │        │                   │   DFEPatternNode[(?1, TERM[150997262], ?4, ?5) . project DISTINCT[?1, ?4] {rangeCountEstimate=100},                                                                                                                     │          │          │           │       │           ║
║    │        │        │                   │     OperatorInfoWithAlternative[                                                                                                                                                                                        │          │          │           │       │           ║
║    │        │        │                   │       rec=OperatorInfo[                                                                                                                                                                                                 │          │          │           │       │           ║
║    │        │        │                   │         type=INCREMENTAL_HASH_JOIN,                                                                                                                                                                                     │          │          │           │       │           ║
║    │        │        │                   │         costEstimates=OperatorCostEstimates[                                                                                                                                                                            │          │          │           │       │           ║
║    │        │        │                   │           costEstimate=OperatorCostEstimate[in=100.0000,out=100.0000,io=0.0003,comp=0.0000,mem=6400],                                                                                                                   │          │          │           │       │           ║
║    │        │        │                   │           worstCaseCostEstimate=OperatorCostEstimate[in=100.0000,out=100.0000,io=0.0003,comp=0.0000,mem=6400]]],                                                                                                        │          │          │           │       │           ║
║    │        │        │                   │       alt=OperatorInfo[                                                                                                                                                                                                 │          │          │           │       │           ║
║    │        │        │                   │         type=INCREMENTAL_PIPELINE_JOIN,                                                                                                                                                                                 │          │          │           │       │           ║
║    │        │        │                   │         costEstimates=OperatorCostEstimates[                                                                                                                                                                            │          │          │           │       │           ║
║    │        │        │                   │           costEstimate=OperatorCostEstimate[in=100.0000,out=100.0000,io=0.0010,comp=0.0000,mem=0],                                                                                                                      │          │          │           │       │           ║
║    │        │        │                   │           worstCaseCostEstimate=OperatorCostEstimate[in=100.0000,out=100.0000,io=0.0010,comp=0.0000,mem=0]]]]]                                                                                                          │          │          │           │       │           ║
║    │        │        │                   │ },                                                                                                                                                                                                                      │          │          │           │       │           ║
║    │        │        │                   │ ]                                                                                                                                                                                                                       │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ ===> DFE configuration:                                                                                                                                                                                                 │          │          │           │       │           ║
║    │        │        │                   │ solutionChunkSize=5000                                                                                                                                                                                                  │          │          │           │       │           ║
║    │        │        │                   │ ouputQueueSize=20                                                                                                                                                                                                       │          │          │           │       │           ║
║    │        │        │                   │ numComputeCores=3                                                                                                                                                                                                       │          │          │           │       │           ║
║    │        │        │                   │ maxParallelIO=10                                                                                                                                                                                                        │          │          │           │       │           ║
║    │        │        │                   │ numInitialPermits=12                                                                                                                                                                                                    │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ ====> DFE configuration (reported back)                                                                                                                                                                                 │          │          │           │       │           ║
║    │        │        │                   │ numComputeCores=3                                                                                                                                                                                                       │          │          │           │       │           ║
║    │        │        │                   │ maxParallelIO=2                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ numInitialPermits=12                                                                                                                                                                                                    │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ ===> Statistics & operator histogram                                                                                                                                                                                    │          │          │           │       │           ║
║    │        │        │                   │ ==> Statistics                                                                                                                                                                                                          │          │          │           │       │           ║
║    │        │        │                   │ -> 3741 / 3668 micros total elapsed (incl. wait / excl. wait)                                                                                                                                                           │          │          │           │       │           ║
║    │        │        │                   │ -> 3741 / 3 millis total elapse (incl. wait / excl. wait)                                                                                                                                                               │          │          │           │       │           ║
║    │        │        │                   │ -> 3741 / 0 secs total elapsed (incl. wait / excl. wait)                                                                                                                                                                │          │          │           │       │           ║
║    │        │        │                   │ ==> Operator histogram                                                                                                                                                                                                  │          │          │           │       │           ║
║    │        │        │                   │ -> 47.66% of total time (excl. wait): pipelineScan (2 instances)                                                                                                                                                        │          │          │           │       │           ║
║    │        │        │                   │ -> 10.99% of total time (excl. wait): merge (1 instances)                                                                                                                                                               │          │          │           │       │           ║
║    │        │        │                   │ -> 41.17% of total time (excl. wait): symmetricHashJoin (1 instances)                                                                                                                                                   │          │          │           │       │           ║
║    │        │        │                   │ -> 0.19% of total time (excl. wait): drain (1 instances)                                                                                                                                                                │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ nodeId | out0   | out1 | opName            | args                                             | rowsIn | rowsOut | chunksIn | chunksOut | elapsed* | outWait | outBlocked | ratio    | rate* [M/s] | rate [M/s] | %     │          │          │           │       │           ║
║    │        │        │                   │ ------ | ------ | ---- | ----------------- | ------------------------------------------------ | ------ | ------- | -------- | --------- | -------- | ------- | ---------- | -------- | ----------- | ---------- | ----- │          │          │           │       │           ║
║    │        │        │                   │ node_0 | node_2 | -    | pipelineScan      | (?1, TERM[117442062], ?2, ?3) DISTINCT [?1, ?2]  | 0      | 100     | 0        | 1         | 874      | 0       | 0          | Infinity | 0.1144      | 0.1144     | 23.83 │          │          │           │       │           ║
║    │        │        │                   │ node_1 | node_2 | -    | pipelineScan      | (?1, TERM[150997262], ?4, ?5) DISTINCT [?1, ?4]  | 0      | 100     | 0        | 1         | 874      | 0       | 0          | Infinity | 0.1144      | 0.1144     | 23.83 │          │          │           │       │           ║
║    │        │        │                   │ node_2 | node_4 | -    | symmetricHashJoin |                                                  | 200    | 100     | 2        | 2         | 1510     | 73      | 0          | 0.50     | 0.0662      | 0.0632     | 41.17 │          │          │           │       │           ║
║    │        │        │                   │ node_3 | -      | -    | drain             |                                                  | 100    | 0       | 1        | 0         | 7        | 0       | 0          | 0.00     | 0.0000      | 0.0000     | 0.19  │          │          │           │       │           ║
║    │        │        │                   │ node_4 | node_3 | -    | merge             |                                                  | 100    | 100     | 2        | 1         | 403      | 0       | 0          | 1.00     | 0.2481      | 0.2481     | 10.99 │          │          │           │       │           ║
╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 3  │ 4      │ -      │ HashIndexJoin     │ solutionSet=solutionSet1                                                                                                                                                                                                │ -        │ 100      │ 100       │ 1.00  │ 4         ║
║    │        │        │                   │ joinType=join                                                                                                                                                                                                           │          │          │           │       │           ║
╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 4  │ 5      │ -      │ Distinct          │ vars=[?s, ?o, ?o1]                                                                                                                                                                                                      │ -        │ 100      │ 100       │ 1.00  │ 9         ║
╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 5  │ 6      │ -      │ Projection        │ vars=[?s, ?o, ?o1]                                                                                                                                                                                                      │ retain   │ 100      │ 100       │ 1.00  │ 2         ║
╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 6  │ -      │ -      │ TermResolution    │ vars=[?s, ?o, ?o1]                                                                                                                                                                                                      │ id2value │ 100      │ 100       │ 1.00  │ 11        ║
╚════╧════════╧════════╧═══════════════════╧═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╧══════════╧══════════╧═══════════╧═══════╧═══════════╝
```

# Neptune SPARQL-Operatoren für `explain`
<a name="sparql-explain-operators"></a>

Die folgenden Abschnitte beschreiben die Operatoren und Parameter für das SPARQL-Feature `explain`, die zurzeit in Amazon Neptune verfügbar sind.

**Wichtig**  
Das SPARQL–Feature `explain` wird zurzeit weiter optimiert. Die hier dokumentierten Operatoren und Parameter unterliegen möglicherweise Änderungen in zukünftigen Versionen.

**Topics**
+ [

## `Aggregation`-Operator
](#sparql-explain-operator-aggregation)
+ [

## `ConditionalRouting`-Operator
](#sparql-explain-operator-conditional-routing)
+ [

## `Copy`-Operator
](#sparql-explain-operator-copy)
+ [

## `DFENode`-Operator
](#sparql-explain-operator-dfenode)
+ [

## `Distinct`-Operator
](#sparql-explain-operator-distinct)
+ [

## `Federation`-Operator
](#sparql-explain-operator-federation)
+ [

## `Filter`-Operator
](#sparql-explain-operator-filter)
+ [

## `HashIndexBuild`-Operator
](#sparql-explain-operator-hash-index-build)
+ [

## `HashIndexJoin`-Operator
](#sparql-explain-operator-hash-index-join)
+ [

## `MergeJoin`-Operator
](#sparql-explain-operator-merge-join)
+ [

## `NamedSubquery`-Operator
](#sparql-explain-operator-named-subquery)
+ [

## `PipelineJoin`-Operator
](#sparql-explain-operator-pipeline-join)
+ [

## `PipelineCountJoin`-Operator
](#sparql-explain-operator-pipeline-count-join)
+ [

## `PipelinedHashIndexJoin`-Operator
](#sparql-explain-operator-pipeline-hash-index-join)
+ [

## `Projection`-Operator
](#sparql-explain-operator-projection)
+ [

## `PropertyPath`-Operator
](#sparql-explain-operator-property-path)
+ [

## `TermResolution`-Operator
](#sparql-explain-operator-term-resolution)
+ [

## `Slice`-Operator
](#sparql-explain-operator-slice)
+ [

## `SolutionInjection`-Operator
](#sparql-explain-operator-solution-injection)
+ [

## `Sort`-Operator
](#sparql-explain-operator-sort)
+ [

## `VariableAlignment`-Operator
](#sparql-explain-operator-variable-alignment)

## `Aggregation`-Operator
<a name="sparql-explain-operator-aggregation"></a>

Führt eine oder mehrere Aggregationen durch, mit denen die Semantik der SPARQL-Aggregationsoperatoren wie `count`, `max`, `min`, `sum` und so weiter implementiert wird.

`Aggregation` verfügt über optionale Gruppierung mithilfe von `groupBy`-Klauseln sowie über optionale `having`-Einschränkungen.

**Argumente**
+ `groupBy` – (*Optional*) Stellt die `groupBy`-Klausel zur Angabe der Abfolge von Ausdrücken je nach Gruppierung der eingehenden Lösungen bereit.
+ `aggregates` – (*Erforderlich*) Gibt eine geordnete Liste von Aggregationsausdrücke an.
+ `having` – (*Optional*) Fügt Filtern für Gruppen Einschränkungen hinzu wie durch die `having`-Klausel in der SPARQL-Abfrage angegeben.

## `ConditionalRouting`-Operator
<a name="sparql-explain-operator-conditional-routing"></a>

Leitet eingehende Lösungen auf Grundlage einer bestimmten Bedingung weiter. Lösungen, die die Bedingung erfüllen, werden an die Operator-ID weitergeleitet, die von `Out #1` verwiesen wurde. Dagegen werden Lösungen, die die Bedingung nicht erfüllen, an den Operator weitergeleitet, der von `Out #2` verwiesen wird.

**Argumente**
+ `condition` – (*Erforderlich*) Die Weiterleitungsbedingung.

## `Copy`-Operator
<a name="sparql-explain-operator-copy"></a>

Delegiert den Lösungs-Stream auf die vom angegebenen Modus bestimmte Weise.

**Modi**
+ `forward` – Leitet die Lösungen an den Downstream-Operator weiter, wie von `Out #1` identifiziert. 
+ `duplicate` – Dupliziert die Lösungen und leitet sie an beide Operatoren weiter, die von `Out #1` und `Out #2` identifiziert werden.

`Copy` hat keine Argumente.

## `DFENode`-Operator
<a name="sparql-explain-operator-dfenode"></a>

Dieser Operator ist eine Abstraktion des Plans, der von der alternativen DFE-Abfrage-Engine ausgeführt wird. Der detaillierte DFE-Plan wird in den Argumenten für diesen Operator beschrieben. Das Argument ist zurzeit überladen, indem es die detaillierten Laufzeitstatistiken des DFE-Plans enthält. Es enthält die Zeit, die DFE für die einzelnen Schritte der Abfrageausführung benötigt hat.

Der logisch optimierte abstrakte Syntaxbaum (AST) für den DFE-Abfrageplan wird mit Informationen zu den Operatortypen gedruckt, die bei der Planung berücksichtigt wurden, und zu den Kosten für die Ausführung der Operatoren im besten und schlechtesten Fall. Der AST besteht zurzeit aus den folgenden Knotentypen:
+ `DFEJoinGroupNode` –  Stellt die Vereinigung eines oder mehrerer `DFEPatternNodes` dar.
+ `DFEPatternNode` –  Kapselt ein zugrundeliegendes Muster mit den übereinstimmenden Tupeln, die aus der zugrunde liegenden Datenbank projiziert werden.

Der Unterabschnitt (`Statistics & Operator histogram`) enthält Details zur Ausführungszeit des `DataflowOp`-Plans und zur Aufschlüsselung der von den einzelnen Operatoren genutzten CPU-Zeit. Unterhalb befindet sich eine Tabelle, in der detaillierte Laufzeitstatistiken des von der DFE ausgeführten Plans ausgegeben werden.

**Anmerkung**  
Da die DFE ein experimentelles, im Labor-Modus veröffentlichtes Feature ist, unterliegt das genaue Format der `explain`-Ausgabe möglicherweise Änderungen.

## `Distinct`-Operator
<a name="sparql-explain-operator-distinct"></a>

Berechnet die unterschiedliche Projektion bei einer Teilmenge der Variablen, sodass Duplikate vermieden werden. Dies hat zur Folge, dass die Anzahl eingehender Lösungen größer oder gleich der Anzahl der ausgehenden Lösungen ist.

**Argumente**
+ `vars` – (*Erforderlich*) Die Variablen, auf die die `Distinct`-Projektion angewendet werden soll.

## `Federation`-Operator
<a name="sparql-explain-operator-federation"></a>

Übergibt eine angegebene Abfrage an einen angegebenen Remote-SPARQL-Endpunkt

**Argumente**
+ `endpoint` – (*Erforderlich*) Die Endpunkt-URL in der SPARQL-Anweisung `SERVICE`. Dies kann eine konstante Zeichenfolge sein, oder, wenn der Abfrageendpunkt basierend auf einer Variablen innerhalb derselben Abfrage bestimmt wird, kann es sich um den Variablennamen handeln.
+ `query` – (*Erforderlich*) Die rekonstruierte Abfragezeichenfolge, die an den Remote-Endpunkt gesendet werden soll. Die Engine fügt dieser Abfrage Standardpräfixe hinzu, auch wenn der Client keine angibt.
+ `silent` – (*Erforderlich*) Ein boolescher Wert, der angibt, ob das Schlüsselwort `SILENT` nach dem Schlüsselwort angezeigt wurde. `SILENT` weist die Engine an, bei einem Fehlschlag von `SERVICE` nicht die gesamte Abfrage fehlschlagen zu lassen.

## `Filter`-Operator
<a name="sparql-explain-operator-filter"></a>

Filtert die eingehenden Lösungen. Nur Lösungen, die die Filterbedingung erfüllen, werden an die Upstream-Operator weitergeleitet. Alle anderen werden gelöscht.

**Argumente**
+ `condition` – (*Erforderlich*) Die Filterbedingung.

## `HashIndexBuild`-Operator
<a name="sparql-explain-operator-hash-index-build"></a>

Übernimmt eine Liste der Bindungen und spult sie in einem Hash-Index, dessen Name vom `solutionSet`-Argument definiert wird. In der Regel führen nachfolgende Operatoren Joins für diesen Lösungssatz aus und verweisen ihn mit diesem Namen.

**Argumente**
+ `solutionSet` – (*Erforderlich*) Der Name des Hash-Index-Lösungssatzes.
+ `sourceType` – (*Required*) Der Typ der Quelle, aus der die Bindungen für die Speicherung im Hash-Index abgerufen werden:
  + `pipeline` – Spult die eingehenden Lösungen aus dem Downstream-Operator in der Operator-Pipeline in den Hash-Index.
  + `binding set` – Spult den vom `sourceBindingSet`-Argument angegebenen festen Bindungssatz in den Hash-Index.
+ `sourceBindingSet` – (*Optional*) Wenn das Argument `sourceType` den Wert `binding set` hat, gibt dieses Argument den statischen Bindungssatz an, der in den Hash-Index gespult werden soll.

## `HashIndexJoin`-Operator
<a name="sparql-explain-operator-hash-index-join"></a>

Verbindet die eingehenden Lösungen für den Lösungssatz des Hash-Index, der vom `solutionSet`-Argument identifiziert wird.

**Argumente**
+ `solutionSet` – (*Erfoderlich*) Name des Lösungssatzes, mit dem der Join durchgeführt werden soll. Dies muss ein Hash-Index sein, der in einem vorherigen Schritt mithilfe des Operators `HashIndexBuild` konstruiert wurde.
+ `joinType` – (*Erforderlich*) Der Typ des Join, der ausgeführt werden soll:
  + `join` – Ein normales Join, für das eine exakte Übereinstimmung aller geteilten Variablen erforderlich ist.
  + `optional` – Ein `optional`-Join, für das die SPARQL-`OPTIONAL`-Operatorsemantik verwendet wird.
  + `minus` – Eine `minus`-Operation behält eine Zuordnung, für die kein Join-Partner vorhanden ist, mithilfe der SPARQL-`MINUS`-Operatorsemantik bei.
  + `existence check` – Prüft, ob ein Join-Partner vorhanden ist, und bindet die Variable `existenceCheckResultVar`an das Ergebnis dieser Prüfung.
+ `constraints` – (*Optional*) Zusätzliche Join-Einschränkungen, die während des Join in Betracht gezogen werden. Joins, die diese Einschränkungen nicht erfüllen, werden verworfen.
+ `existenceCheckResultVar` – (*Optional*) Wird nur für Joins verwendet, in denen `joinType` gleich `existence check` ist (siehe zuvor das Argument `joinType`).

## `MergeJoin`-Operator
<a name="sparql-explain-operator-merge-join"></a>

Ein Zusammenführungs-Join über mehrere Lösungen, wie es vom `solutionSets`-Argument identifiziert wird.

**Argumente**
+ `solutionSets` – (*Erforderlich*) Die Lösungssätze, für die ein Join ausgeführt werden soll.

## `NamedSubquery`-Operator
<a name="sparql-explain-operator-named-subquery"></a>

Löst eine Bewertung der Unterabfrage aus, die vom `subQuery`-Argument identifiziert wird, und spult das Ergebnis in den vom `solutionSet`-Argument angegebenen Lösungssatz. Die eingehenden Lösungen für den Operator werden an die Unterabfrage und dann an den nächsten Operator weitergeleitet.

**Argumente**
+ `subQuery` – (*Erforderlich*) Der Name der Unterabfrage, die ausgewertet werden soll. Die Unterabfrage wird in der Ausgabe explizit gerendert.
+ `solutionSet` – (*Erforderlich*) Der Name des Lösungssatzes, in dem das Ergebnis der Unterabfrage gespeichert werden soll.

## `PipelineJoin`-Operator
<a name="sparql-explain-operator-pipeline-join"></a>

Erhält die Ausgabe des vorherigen Operators als Eingabe und verbindet sie mit dem Tupel-Muster, das vom `pattern`-Argument definiert wird.

**Argumente**
+ `pattern`— (*Erforderlich*) Das Muster, das die Form eines Tupels und optional eines Graphen hat subject-predicate-object, das der Verknüpfung zugrunde liegt. Wenn `distinct` für das Muster angegeben wird, extrahiert der Join nur unterschiedliche Lösungen aus den Projektionsvariablen, die vom `projectionVars`-Argument angegeben werden, anstatt alle passenden Lösungen zu extrahieren.
+ `inlineFilters` – (*Optional*) Eine Reihe von Filtern, die auf die Variablen im Muster angewendet werden sollen. Das Muster wird in Verbindung mit diesen Filtern ausgewertet.
+ `joinType` – (*Erforderlich*) Der Typ des Join, der ausgeführt werden soll:
  + `join` – Ein normales Join, für das eine exakte Übereinstimmung aller geteilten Variablen erforderlich ist.
  + `optional` – Ein `optional`-Join, für das die SPARQL-`OPTIONAL`-Operatorsemantik verwendet wird.
  + `minus` – Eine `minus`-Operation behält eine Zuordnung, für die kein Join-Partner vorhanden ist, mithilfe der SPARQL-`MINUS`-Operatorsemantik bei.
  + `existence check` – Prüft, ob ein Join-Partner vorhanden ist, und bindet die Variable `existenceCheckResultVar`an das Ergebnis dieser Prüfung.
+ `constraints` – (*Optional*) Zusätzliche Join-Einschränkungen, die während des Join in Betracht gezogen werden. Joins, die diese Einschränkungen nicht erfüllen, werden verworfen.
+ `projectionVars` – (*Optional*) Die Projektionsvariablen. Werden in Verbindung mit `distinct := true` verwendet, um das Extrahieren unterschiedlicher Projektionen aus einem bestimmten Variablensatz zu erzwingen.
+ `cutoffLimit` – (*Optional*) Ein Abschnittslimit für die Anzahl der extrahierten Join-Partner. Obwohl standardmäßig kein Limit vorliegt, können Sie diesen Wert bei Ausführen von Joins auf 1 festlegen, um `FILTER (NOT) EXISTS`-Klauseln zu implementieren, sofern es ausreicht zu beweisen oder zu wiederlegen, dass ein Join-Partner vorhanden ist.

## `PipelineCountJoin`-Operator
<a name="sparql-explain-operator-pipeline-count-join"></a>

Eine Variante von `PipelineJoin`. Anstatt einen Join durchzuführen, werden einfach die übereinstimmenden Join-Partner gezählt und die Anzahl wird an die Variable gebunden, die vom `countVar`-Argument angegeben wird.

**Argumente**
+ `countVar` – (*Erforderlich*) Die Variable, über die das Ergebnis der Zählung, d. h. die Anzahl der Join-Partner, gebunden werden soll.
+ `pattern`— (*Erforderlich*) Das Muster, das die Form eines Tupels und optional eines Graphen hat subject-predicate-object, das der Verknüpfung zugrunde liegt. Wenn `distinct` für das Muster angegeben wird, extrahiert der Join nur unterschiedliche Lösungen aus den Projektionsvariablen, die vom `projectionVars`-Argument angegeben werden, anstatt alle passenden Lösungen zu extrahieren.
+ `inlineFilters` – (*Optional*) Eine Reihe von Filtern, die auf die Variablen im Muster angewendet werden sollen. Das Muster wird in Verbindung mit diesen Filtern ausgewertet.
+ `joinType` – (*Erforderlich*) Der Typ des Join, der ausgeführt werden soll:
  + `join` – Ein normales Join, für das eine exakte Übereinstimmung aller geteilten Variablen erforderlich ist.
  + `optional` – Ein `optional`-Join, für das die SPARQL-`OPTIONAL`-Operatorsemantik verwendet wird.
  + `minus` – Eine `minus`-Operation behält eine Zuordnung, für die kein Join-Partner vorhanden ist, mithilfe der SPARQL-`MINUS`-Operatorsemantik bei.
  + `existence check` – Prüft, ob ein Join-Partner vorhanden ist, und bindet die Variable `existenceCheckResultVar`an das Ergebnis dieser Prüfung.
+ `constraints` – (*Optional*) Zusätzliche Join-Einschränkungen, die während des Join in Betracht gezogen werden. Joins, die diese Einschränkungen nicht erfüllen, werden verworfen.
+ `projectionVars` – (*Optional*) Die Projektionsvariablen. Werden in Verbindung mit `distinct := true` verwendet, um das Extrahieren unterschiedlicher Projektionen aus einem bestimmten Variablensatz zu erzwingen.
+ `cutoffLimit` – (*Optional*) Ein Abschnittslimit für die Anzahl der extrahierten Join-Partner. Obwohl standardmäßig kein Limit vorliegt, können Sie diesen Wert bei Ausführen von Joins auf 1 festlegen, um `FILTER (NOT) EXISTS`-Klauseln zu implementieren, sofern es ausreicht zu beweisen oder zu wiederlegen, dass ein Join-Partner vorhanden ist.

## `PipelinedHashIndexJoin`-Operator
<a name="sparql-explain-operator-pipeline-hash-index-join"></a>

Dies ist ein all-in-one Build-Hash-Index und ein Join-Operator. Er nimmt eine Liste von Bindungen, spult sie in einen Hash-Index und verknüpft dann die eingehenden Lösungen anhand des Hash-Indexes.

**Argumente**
+ `sourceType`  –   (*Required*) Der Typ der Quelle, aus der die Bindungen für die Speicherung im Hash-Index abgerufen werden:
  + `pipeline`  –   Lässt `PipelinedHashIndexJoin` die eingehenden Lösungen aus dem Downstream-Operator in der Operator-Pipeline in den Hash-Index spulen.
  + `binding set`  –   Lässt `PipelinedHashIndexJoin` den vom `sourceBindingSet`-Argument angegebenen festen Bindungssatz in den Hash-Index spulen.
+ `sourceSubQuery `  –   (*Optional*) Wenn das Argument `sourceType` den Wert `pipeline` hat, gibt dieses Argument die Unterabfrage an, die ausgewertet und in den Hash-Index gespoolt wird.
+ `sourceBindingSet `  –   (*Optional*) Wenn das Argument `sourceType` den Wert `binding set` hat, gibt dieses Argument den statischen Bindungssatz an, der in den Hash-Index gespult werden soll.
+ `joinType`  –   (*Erforfderlich*) Der Typ des Join, der ausgeführt werden soll:
  + `join` – Ein normales Join, für das eine exakte Übereinstimmung aller geteilten Variablen erforderlich ist.
  + `optional` – Ein `optional`-Join, für das die SPARQL-`OPTIONAL`-Operatorsemantik verwendet wird.
  + `minus` – Eine `minus`-Operation behält eine Zuordnung, für die kein Join-Partner vorhanden ist, mithilfe der SPARQL-`MINUS`-Operatorsemantik bei.
  + `existence check` – Prüft, ob ein Join-Partner vorhanden ist, und bindet die Variable `existenceCheckResultVar`an das Ergebnis dieser Prüfung.
+ `existenceCheckResultVar` – (*Optional*) Wird nur für Joins verwendet, in denen `joinType` gleich `existence check` ist (siehe zuvor das Argument joinType).

## `Projection`-Operator
<a name="sparql-explain-operator-projection"></a>

Projiziert über eine Teilmenge der Variablen. Die Anzahl der eingehenden Lösungen entspricht der Anzahl der ausgehenden Lösungen, aber die Form der Lösung ist je nach Moduseinstellung unterschiedlich.

**Modi**
+ `retain` – In Lösungen werden nur die Variablen beibehalten, die vom Argument `vars` angegeben werden.
+ `drop` – Alle Variablen, die vom Argument `vars` angegeben werden, werden entfernt.

**Argumente**
+ `vars` – (*Erforderlich*) Die Variablen, die je nach Moduseinstellung beibehalten oder entfernt werden sollen.

## `PropertyPath`-Operator
<a name="sparql-explain-operator-property-path"></a>

Aktiviert rekursive Eigenschaftspfade wie `+` oder `*`. Neptune implementiert einen Festkomma-Iterationsansatz, der auf einer durch das Argument `iterationTemplate` angegebenen Vorlage basiert. Bekannte Variablen der linken oder rechten Seite werden in der Vorlage solange für jede Iteration mit festem Punkt gebunden, bis keine neuen Lösungen gefunden werden können.

**Argumente**
+ `iterationTemplate` – (*Erforderlich*) Der Name der Vorlage für die Unterabfrage, die für die Implementierung der Iteration mit festem Punkt verwendet wird.
+ `leftTerm` – (*Erforderlich*) Der Begriff (Variable oder Konstante) auf der linken Seite des Eigenschaftspfads.
+ `rightTerm` – (*Erforderlich*) Der Begriff (Variable oder Konstante) auf der rechten Seite des Eigenschaftspfads.
+ `lowerBound` – (*Erforderlich*) Die untere Grenze für die Iteration mit festem Punkt (entweder `0` für `*`-Abfragen oder `1` für `+`-Abfragen).

## `TermResolution`-Operator
<a name="sparql-explain-operator-term-resolution"></a>

Übersetzt interne Zeichenfolgekennungswerte zurück in ihre entsprechenden externen Zeichenfolgen oder übersetzt externe Zeichenfolgen in internen Kennungswerte. Dies ist vom Modus abhängig.

**Modi**
+ `value2id`— Ordnet Begriffe wie Literale URIs den entsprechenden internen ID-Werten zu (Kodierung zu internen Werten).
+ `id2value`— Ordnet interne ID-Werte den entsprechenden Begriffen wie Literalen und URIs (Dekodierung interner Werte) zu.

**Argumente**
+ `vars`— (*Erforderlich*) Gibt die Variablen an, deren Zeichenketten oder interne Zeichenketten zugeordnet werden IDs sollen.

## `Slice`-Operator
<a name="sparql-explain-operator-slice"></a>

Implementiert ein Slice mithilfe der Semantik der `LIMIT`- und `OFFSET`-Klauseln von SPARQL über den eingehenden Lösungs-Stream.

**Argumente**
+ `limit` – (*Optional*) Eine Einschränkung für die Lösungen, die weitergeleitet werden sollen.
+ `offset` – (*Optional*) Der Versatz, mit dem Lösungen für die Weiterleitung ausgewertet werden.

## `SolutionInjection`-Operator
<a name="sparql-explain-operator-solution-injection"></a>

Empfängt keine Eingabe. Bringt statische Lösungen in den Abfrageplan ein und nimmt sie in das `solutions`-Argument auf.

Anfragepläne beginnen immer mit dieser statischen Injektion. Wenn einzubringende statische Lösungen aus der Abfrage abgeleitet werden können, indem verschiedene Quellen statischer Bindungen (z. B. aus `VALUES`- oder `BIND`-Klauseln) abgeleitet werden können, bringt der `SolutionInjection`-Operator diese abgeleiteten statischen Lösungen ein. Im einfachsten Fall spiegelt dies Bindungen wider, die von einer äußeren `VALUES`-Klausel angedeutet werden.

Wenn keine statischen Lösungen aus der Abfrage abgeleitet werden können, bringt `SolutionInjection` die leere so genannte universelle Lösung ein, die erweitert und im Abfragebewertungsprozess multipliziert wird.

**Argumente**
+ `solutions` – (*Erforderlich*) Die vom Operator eingefügte Lösungsabfolge.

## `Sort`-Operator
<a name="sparql-explain-operator-sort"></a>

Sortiert den Lösungssatz mithilfe bestimmter Sortierbedingungen.

**Argumente**
+ `sortOrder` – (*Erforderlich*) Eine geordnete Liste von Variablen mit jeweils einer `ASC`-ID (aufsteigenden) oder einer `DESC`-ID (absteigend), die zum Sortieren des Lösungssatzes verwendet wird.

## `VariableAlignment`-Operator
<a name="sparql-explain-operator-variable-alignment"></a>

Prüft Lösungen einzeln und führt bei jeder davon eine Ausrichtung über zwei Variablen durch: ein angegebenes `sourceVar`-Element und ein angegebenes `targetVar`-Element.

Wenn `sourceVar` und `targetVar` in einer Lösung denselben Wert haben, gilt die Variablen als ausgerichtet und die Lösung wird weitergeleitet. Dabei wird das redundante `sourceVar`-Element heraus projiziert.

Wenn die Variablen an unterschiedliche Werte gebunden werden, wird die Lösung vollständig herausgefiltert.

**Argumente**
+ `sourceVar` – (*Erforderlich*) Die Quellvariable, die mit der Zielvariablen verglichen werden soll. Wenn die Ausrichtung in einer Lösung erfolgreich ist, die beiden Variablen also den gleichen Wert haben, wird die Quellvariable heraus projiziert.
+ `targetVar` – (*Erforderlich*) Die Zielvariable, mit der die Quellvariable verglichen werden soll. Wird auch beibehalten, wenn die Ausrichtung erfolgreich ist.

# Einschränkungen für SPARQL `explain` in Neptune
<a name="sparql-explain-limitations"></a>

Die Version der des Neptune-SPARQL–Features `explain` unterliegt den folgenden Einschränkungen.

**Neptune unterstützt explain zurzeit nur in SPARQL SELECT-Abfragen**  
Weitere Informationen zum Bewertungsprozess für andere Abfrageformulare, z. B. `ASK`-, `CONSTRUCT`-, `DESCRIBE`-, und `SPARQL UPDATE`-Abfragen, erhalten Sie, wenn Sie diese Abfragen in eine SELECT-Abfrage umwandeln. Überprüfen die entsprechende SELECT-Abfrage anschließend mit `explain`.

Beispiel: Wenn Sie `explain`-Informationen zu einer `ASK WHERE {...}`-Abfrage erhalten möchten, führen Sie die entsprechende `SELECT WHERE {...} LIMIT 1`-Abfrage mit `explain` aus.

Bei einer `CONSTRUCT {...} WHERE {...}`-Abfrage löschen Sie den `CONSTRUCT {...}`-Teil und führen eine `SELECT`-Abfrage mit `explain` in der zweiten `WHERE {...}`-Klausel durch. Die Auswertung der zweiten `WHERE`-Klausel zeigt in der Regel die wichtigsten Herausforderungen bei der Verarbeitung der `CONSTRUCT`-Abfrage, da Lösungen, die aus dem zweiten `WHERE` in die `CONSTRUCT`-Vorlage eingehen in der Regel einfach nur ersetzt werden müssen.

**Explain-Operatoren können in zukünftigen Versionen geändert werden**  
Die SPARQL `explain`-Operatoren und ihre Parameter können in zukünftigen Versionen geändert werden.

**Die Explain-Ausgabe kann in zukünftigen Versionen geändert werden**  
Beispiel: Spaltenüberschriften können geändert werden und den Tabellen werden möglicherweise weitere Spalten hinzugefügt.

# SPARQL-Verbundabfragen in Neptune mit der Erweiterung `SERVICE`
<a name="sparql-service"></a>

Amazon Neptune unterstützt die SPARQL-Verbundabfrageerweiterung vollständig, die das Schlüsselwort `SERVICE` verwendet. (Weitere Informationen finden Sie unter [SPARQL 1.1-Verbundabfrage](https://www.w3.org/TR/sparql11-federated-query/).)

Das `SERVICE`-Schlüsselwort weist die SPARQL-Abfrage-Engine an, einen Teil der Abfrage für einen Remote-SPARQL-Endpunkt auszuführen und das endgültige Abfrageergebnis zu erstellen. Es sind nur `READ`-Operationen möglich. Die Operationen `WRITE` und `DELETE` werden nicht unterstützt. Neptune kann Verbundabfragen nur für SPARQL-Endpunkte ausführen, auf die in dessen Virtual Private Cloud (VPC) zugegriffen werden kann. Sie können jedoch auch einen Reverse-Proxy in der VPC verwenden, damit auf eine externe Datenquelle innerhalb der VPC zugegriffen werden kann.

**Anmerkung**  
Wenn SPARQL `SERVICE` für die Verbindung einer Abfrage mit zwei oder mehr Neptune-Clustern in derselben VPC verwendet wird, müssen die Sicherheitsgruppen so konfiguriert werden, dass alle diese Neptune-Cluster miteinander kommunizieren können.

**Wichtig**  
SPARQL 1.1 Federation sendet Serviceanfragen in Ihrem Namen, wenn Abfragen und Parameter an externe SPARQL-Endpunkte übergeben werden. Es liegt in Ihrer Verantwortung, zu überprüfen, ob die externen SPARQL-Endpunkte die Datenverarbeitungs- und Sicherheitsanforderungen Ihrer Anwendung erfüllen.

## Beispiel für eine Neptune-Verbundabfrage
<a name="sparql-service-example-1"></a>

Das folgende einfache Beispiel zeigt, wie SPARQL-Verbundabfragen funktionieren.

Angenommen, ein Kunde sendet die folgende Abfrage an *Neptune-1* unter `http://neptune-1:8182/sparql`.

```
SELECT * WHERE {
   ?person rdf:type foaf:Person .
   SERVICE <http://neptune-2:8182/sparql> {
       ?person foaf:knows ?friend .
    }
}
```

1. *Neptune-1* wertet das erste Abfragemuster (*Q-1*) aus, d. h. `?person rdf:type foaf:Person`, verwendet die Ergebnisse zum Auflösen von `?person` in *Q-2* (`?person foaf:knows ?friend`) und übergibt das resultierende Muster an *Neptune-2* unter `http://neptune-2:8182/sparql`.

1. *Neptune-2* wertet *Q-2* aus und sendet die Ergebnisse zurück an *Neptune-1*.

1. *Neptune-1* verbindet die Lösungen für beide Muster und sendet die Ergebnisse an den Kunden zurück.

Dies wird im folgenden Diagramm illustriert:

![\[Flussdiagramm mit ausgewerteten SPARQL-Verbundabfragemustern und zurückgesendeten Antworten an den Client.\]](http://docs.aws.amazon.com/de_de/neptune/latest/userguide/images/federated.png)


**Anmerkung**  
Standardmäßig legt der Optimierer den Punkt in der Abfrageausführung fest, an dem die Anweisung `SERVICE` ausgeführt wird. Sie können diese Platzierung mittels des Abfragehinweises [joinOrder](sparql-query-hints-joinOrder.md) überschreiben.

## Zugriffskontrolle für Verbundabfragen in Neptune
<a name="sparql-service-auth"></a>

Neptune verwendet AWS Identity and Access Management (IAM) für die Authentifizierung und Autorisierung. Die Zugriffskontrolle für eine Verbundabfrage kann mehr als eine Neptune-DB-Instance umfassen. Diese Instances haben möglicherweise unterschiedliche Anforderungen für die Zugriffskontrolle. Unter bestimmten Umständen kann dies Ihre Fähigkeit zum Erstellen einer Verbundabfrage einschränken.

Betrachten Sie das einfache Beispiel im vorherigen Abschnitt. *Neptune-1* ruft *Neptune-2* mit denselben Anmeldeinformationen auf, mit denen es aufgerufen wurde.
+ Wenn *Neptune-1* eine IAM-Authentifizierung und -Autorisierung erfordert, *Neptune-2* jedoch nicht, benötigen Sie zur Ausführung der Verbundabfrage lediglich die entsprechenden IAM-Berechtigungen für *Neptune-1*.
+ Wenn sowohl *Neptune-1* als auch *Neptune-2* eine IAM-Authentifizierung und Autorisierung erfordern, müssen Sie zur Ausführung der Verbundanfrage beiden Datenbanken IAM-Berechtigungen anfügen. Beide Cluster müssen sich außerdem im selben AWS Konto und in derselben Region befinden. Regionsübergreifende and/or kontenübergreifende Verbundabfragearchitekturen werden derzeit nicht unterstützt.
+ Wenn *Neptune-1* nicht IAM-aktiviert ist, *Neptune-2* jedoch IAM-aktiviert ist, können Sie keine Verbundabfrage ausführen. Der Grund hierfür ist, dass *Neptune-1* Ihre IAM-Anmeldeinformationen nicht abrufen und an *Neptune-2* übergeben kann, um den zweiten Teil der Abfrage zu autorisieren.