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. # SPARQL HTTP-API 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 **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://your-neptune-endpoint:port/sparql ``` Im vorherigen Beispiel wird das folgende Triple in das standardmäßige SPARQL-Diagramm eingefügt: ` ` # Optionale HTTP-Trailing-Header für mehrteilige SPARQL-Antworten 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 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 + **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 + **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 **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 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 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 ``` **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 " ``` 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 " ``` **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 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 ``` 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: ``` . . ``` Der folgende Befehl `UNLOAD` würde diese beiden Tripel aus dem benannten Diagramm (``) löschen. ``` UNLOAD FROM GRAPH ``` Dies hätte den gleichen Effekt wie die Verwendung des folgenden Befehls `DELETE DATA`: ``` DELETE DATA { GRAPH { . . } } ``` **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).*