Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # API SPARQL HTTP Le richieste SPARQL HTTP vengono accettate negli endpoint seguenti: `https://your-neptune-endpoint:port/sparql` Per ulteriori informazioni sulla connessione ad Amazon Neptune con SPARQL, vedi [Accesso al grafo Neptune con SPARQL](access-graph-sparql.md). Per ulteriori informazioni sui protocolli SPARQL e il linguaggio di query, vedi le specifiche [SPARQL 1.1 Protocol](https://www.w3.org/TR/sparql11-protocol/#protocol) e [SPARQL 1.1 Query Language](https://www.w3.org/TR/sparql11-query/). I seguenti argomenti forniscono informazioni sui formati di serializzazione SPARQL RDF e su come utilizzare l'API HTTP di SPARQL con Neptune. **Contents** + [Utilizzo dell'endpoint HTTP REST per connettersi a un'istanza database Neptune](access-graph-sparql-http-rest.md) + [Intestazioni HTTP finali opzionali per risposte SPARQL in più parti](access-graph-sparql-http-trailing-headers.md) + [Tipi di supporti RDF usati da SPARQL in Neptune](sparql-media-type-support.md) + [Formati di serializzazione RDF usati da Neptune SPARQL](sparql-media-type-support.md#sparql-serialization-formats) + [Formati di serializzazione dei risultati SPARQL utilizzati da Neptune SPARQL](sparql-media-type-support.md#sparql-serialization-formats-neptune-output) + [Tipi di supporto che Neptune può utilizzare per importare dati RDF](sparql-media-type-support.md#sparql-serialization-formats-input) + [Tipi di supporto utilizzabili da Neptune per esportare risultati di query](sparql-media-type-support.md#sparql-serialization-formats-output) + [Utilizzo di SPARQL UPDATE LOAD per l'importazione di dati in Neptune](sparql-api-reference-update-load.md) + [Utilizzo di SPARQL UPDATE UNLOAD per eliminare i dati da Neptune](sparql-api-reference-unload.md) # Utilizzo dell'endpoint HTTP REST per connettersi a un'istanza database Neptune **Nota** Neptune attualmente non supporta HTTP/2 per le richieste API REST. I client devono utilizzare HTTP/1.1 per la connessione agli endpoint. Le istruzioni seguenti illustrano come connettersi a un endpoint di SPARQL utilizzando il comando **curl**, collegandosi tramite HTTPS e usando la sintassi HTTP. Segui queste istruzioni da un'istanza Amazon EC2 nello stesso cloud privato virtuale (VPC) dell'istanza database Neptune. L'endpoint HTTP per le query SPARQL in un'istanza database Neptune è: `https://your-neptune-endpoint:port/sparql`. **Nota** Per informazioni su come trovare il nome host dell'istanza database Neptune, consulta la sezione [Connessione agli endpoint Amazon Neptune](feature-overview-endpoints.md). Amazon Neptune fornisce un endpoint HTTP per le query SPARQL. L'interfaccia REST è compatibile con la versione 1.1 di SPARQL. **QUERY tramite HTTP POST** L'esempio seguente utilizza **curl** per inviare una SPARQL **`QUERY`** tramite HTTP **POST**. ``` curl -X POST --data-binary 'query=select ?s ?p ?o where {?s ?p ?o} limit 10' https://your-neptune-endpoint:port/sparql ``` L'esempio precedente restituisce fino a 10 delle triple (subject-predicate-object) nel grafico utilizzando la `?s ?p ?o` query con un limite di 10. Per eseguire una query su qualcos'altro, sostituirla con un'altra query SPARQL . **Nota** Il tipo di supporto MIME predefinito di una risposta è `application/sparql-results+json` per le query `SELECT` e `ASK`. Il tipo MIME predefinito di una risposta è `application/n-quads` per le query `CONSTRUCT` e `DESCRIBE`. Per un elenco dei tipi di supporto utilizzati da Neptune per la serializzazione, consulta [Formati di serializzazione RDF usati da Neptune SPARQL](sparql-media-type-support.md#sparql-serialization-formats). **UPDATE utilizzando HTTP POST** L'esempio seguente utilizza **curl** per inviare una SPARQL **`UPDATE`** tramite HTTP **POST**. ``` curl -X POST --data-binary 'update=INSERT DATA { . }' https://your-neptune-endpoint:port/sparql ``` L'esempio precedente inserisce la seguente tripla nel grafo SPARQL predefinito: ` ` # Intestazioni HTTP finali opzionali per risposte SPARQL in più parti La risposta HTTP alle query e agli aggiornamenti SPARQL viene spesso restituita in più parti o blocchi. Può essere difficile diagnosticare un errore che si verifica dopo che una query o un aggiornamento inizia a inviare questi blocchi, soprattutto perché il primo arriva con un codice di stato HTTP di `200`. A meno che non si richiedano esplicitamente le intestazioni finali, Neptune segnala tale errore solo aggiungendo un messaggio di errore al corpo del messaggio, che di solito è danneggiato. Per facilitare il rilevamento e la diagnosi di questo tipo di problema, puoi includere nella richiesta un'intestazione transfer-encoding (TE) trailers (`te: trailers`) (vedi, ad esempio, [la pagina MDN sulle intestazioni di richiesta TE](https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/TE)). In questo modo Neptune includerà due nuovi campi di intestazione nelle intestazioni finali dei blocchi di risposta: + `X-Neptune-Status`: contiene il codice di risposta seguito da un nome breve. Ad esempio, in caso di esito positivo, l'intestazione finale sarà: `X-Neptune-Status: 200 OK`. In caso di errore, il codice di risposta sarà un [codice di errore del motore Neptune](errors-engine-codes.md) come `X-Neptune-Status: 500 TimeLimitExceededException`. + `X-Neptune-Detail`: è vuoto per le richieste riuscite. In caso di errori, contiene il messaggio di errore JSON. Poiché nei valori di intestazione HTTP sono consentiti solo caratteri ASCII, la stringa JSON è codificata come URL. Inoltre, al corpo del messaggio di risposta viene anche aggiunto il messaggio di errore. # Tipi di supporti RDF usati da SPARQL in Neptune I dati RDF (Resource Description Framework) possono essere serializzati in molti modi diversi e SPARQL può utilizzarne o produrne la maggior parte: ## Formati di serializzazione RDF usati da Neptune SPARQL + **RDF/XML**: serializzazione XML di RDF, definita in [RDF 1.1 XML Syntax](https://www.w3.org/TR/rdf-syntax-grammar/). Tipo di supporto: `application/rdf+xml`. Estensione tipica del file: `.rdf`. + **N-Triples**: un formato di testo normale, basato su riga, per la codifica di un grafo RDF, definito in [RDF 1.1 N-Triples](https://www.w3.org/TR/n-triples/). Tipo di supporto: `application/n-triples`, `text/turtle` o `text/plain`. Estensione tipica del file: `.nt`. + **N-Quads**: un formato di testo normale, basato su riga, per la codifica di un grafo RDF, definito in [RDF 1.1 N-Quads](https://www.w3.org/TR/n-quads/). Si tratta di un'estensione di N-Triples. Tipo di supporto: `application/n-quads` oppure `text/x-nquads` quando codificato con US-ASCII a 7 bit. Estensione tipica del file: `.nq`. + **Turtle**: una sintassi testuale per RDF definita in [RDF 1.1 Turtle](https://www.w3.org/TR/turtle/) che permette a un grafo RDF di essere completamente scritto in una forma di testo naturale e compatta, con abbreviazioni per modelli di utilizzo e tipi di dati comuni. Turtle offre livelli di compatibilità con il formato N-Triples nonché con la sintassi di modello triplice di SPARQL. Tipo di supporto: `text/turtle`Estensione tipica del file `.ttl`. + **TriG**: una sintassi testuale per RDF definita in [RDF 1.1 TriG](https://www.w3.org/TR/trig/) che consente a un grafo RDF di essere completamente scritto in una forma di testo naturale e compatta, con abbreviazioni per modelli di utilizzo e tipi di dati comuni. TriG è un'estensione del formato Turtle. Tipo di supporto: `application/trig`. Estensione tipica del file: `.trig`. + **N3 (Notation3)**: un linguaggio di asserzione e logica definito in [Notation3 (N3): A readable RDF syntax](https://www.w3.org/TeamSubmission/n3/). N3 estende il modello di dati RDF aggiungendo formule (valori letterali che sono essi stessi grafi), variabili, implicazioni logiche e predicati funzionali e fornisce una sintassi testuale alternativa a RDF/XML. Tipo di supporto: `text/n3`. Estensione tipica del file: `.n3`. + **JSON-LD**: un formato di serializzazione dei dati e dei messaggi definito in [JSON-LD 1.0](https://www.w3.org/TR/json-ld/). Tipo di supporto: `application/ld+json`. Estensione tipica del file: `.jsonld`. + **TriX**: una serializzazione di RDF in XML, definita in [TriX: triple RDF in XML](https://www.hpl.hp.com/techreports/2004/HPL-2004-56.html). Tipo di supporto: `application/trix`. Estensione tipica del file: `.trix`. + **SPARQL JSON Results**: una serializzazione di RDF con [SPARQL 1.1 Query Results JSON Format](https://www.w3.org/TR/sparql11-results-json). Tipo di supporto: `application/sparql-results+json`. Estensione tipica del file: `.srj`. + **RDF4J Binary Format** [— Un formato binario per la codifica di dati RDF, documentato nel RDF4 formato J Binary RDF.](https://rdf4j.org/documentation/reference/rdf4j-binary) Tipo di supporto: `application/x-binary-rdf`. ## Formati di serializzazione dei risultati SPARQL utilizzati da Neptune SPARQL + **SPARQL XML Results**: un formato XML per i formati di risultati booleani e di vincolo variabili forniti dal linguaggio di query SPARQL, definito in [SPARQL Query Results XML Format (Second Edition)](https://www.w3.org/TR/rdf-sparql-XMLres/). Tipo di supporto: `application/sparql-results+xml`. Estensione tipica del file: `.srx`. + **SPARQL CSV and TSV Results**: l'uso di valori separati da virgole e valori separati da tabulazione per esprimere i risultati di query SPARQL da query `SELECT`, definito in [SPARQL 1.1 Query Results CSV and TSV Formats](https://www.w3.org/TR/sparql11-results-csv-tsv/). Tipo di supporto: `text/csv` per valori separati da virgola e `text/tab-separated-values` per valori separati da schede. Estensioni tipiche del file: `.csv` per valori separati da virgola e `.tsv` per valori separati da schede. + **Binary Results Table**: un formato binario per la codifica dell'output di query SPARQL. Tipo di supporto: `application/x-binary-rdf-results-table`. + **SPARQL JSON Results**: una serializzazione di RDF con [SPARQL 1.1 Query Results JSON Format](https://www.w3.org/TR/sparql11-results-json/). Tipo di supporto: `application/sparql-results+json`. ## Tipi di supporto che Neptune può utilizzare per importare dati RDF **Tipi di supporto che lo [strumento di caricamento in blocco Neptune](bulk-load.md) può supportare** + [N-Triples](https://www.w3.org/TR/n-triples/) + [N-QUAD](https://www.w3.org/TR/n-quads/) + [RDF/XML](https://www.w3.org/TR/rdf-syntax-grammar/) + [Turtle](https://www.w3.org/TR/turtle/) **Tipi di supporto che possono essere importati da SPARQL UPDATE LOAD** + [N-Triples](https://www.w3.org/TR/n-triples/) + [N-QUAD](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/) ## Tipi di supporto utilizzabili da Neptune per esportare risultati di query Per specificare il formato di output per una risposta a una query di SPARQL, invia un'intestazione `"Accept: media-type"` con la richiesta di query. Esempio: ``` curl -H "Accept: application/nquads" ... ``` **Tipi di supporto RDF che SPARQL SELECT può produrre da Neptune** + [SPARQL JSON Results](https://www.w3.org/TR/sparql11-results-json) (impostazione predefinita) + [SPARQL XML Results](https://www.w3.org/TR/rdf-sparql-XMLres/) + **Binary Results Table** (tipo di supporto: `application/x-binary-rdf-results-table`) + [Comma-Separated Values (CSV)](https://www.w3.org/TR/sparql11-results-csv-tsv/) + [Tab-Separated Values (TSV)](https://www.w3.org/TR/sparql11-results-csv-tsv/) **Tipi di supporto RDF che SPARQL ASK può produrre da Neptune** + [SPARQL JSON Results](https://www.w3.org/TR/sparql11-results-json) (impostazione predefinita) + [SPARQL XML Results](https://www.w3.org/TR/rdf-sparql-XMLres/) + **Boolean** (tipo di supporto: `text/boolean`, ovvero "true" o "false") **Tipi di supporto RDF che SPARQL CONSTRUCT può produrre da Neptune** + [N-QUAD](https://www.w3.org/TR/n-quads/) (impostazione predefinita) + [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 Results](https://www.w3.org/TR/sparql11-results-json) + [RDF4Formato binario RDF J](https://rdf4j.org/documentation/reference/rdf4j-binary) **Tipi di supporto RDF che SPARQL DESCRIBE può produrre da Neptune** + [N-QUAD](https://www.w3.org/TR/n-quads/) (impostazione predefinita) + [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 Results](https://www.w3.org/TR/sparql11-results-json) + [RDF4J Formato binario RDF](https://rdf4j.org/documentation/reference/rdf4j-binary) # Utilizzo di SPARQL UPDATE LOAD per l'importazione di dati in Neptune La sintassi del comando SPARQL UPDATE LOAD è specificata nella [raccomandazione SPARQL 1.1 Update](https://www.w3.org/TR/sparql11-update/#load): ``` LOAD SILENT (URL of data to be loaded) INTO GRAPH (named graph into which to load the data) ``` + **`SILENT`**: (*facoltativo*) fa sì che l'operazione restituisca un esito positivo anche se si è verificato un errore durante l'elaborazione. Ciò può essere utile quando una singola transazione contiene più istruzioni come `"LOAD ...; LOAD ...; UNLOAD ...; LOAD ...;"` e si desidera che la transazione venga completata anche se non è stato possibile elaborare alcuni dati remoti. + *URL of data to be loaded*— (*Obbligatorio*) Speciifica un file di dati remoto contenente dati da caricare in un grafico. Il file remoto deve avere una delle seguenti estensioni: + `.nt`per NTriples. + `.nq`per NQuads. + `.trig` per Trig. + `.rdf` per RDF/XML. + `.ttl` per Turtle. + `.n3` per N3. + `.jsonld` per JSON-LD. + **`INTO GRAPH`***(named graph into which to load the data)*— (*Facoltativo*) Speciifica il grafico in cui devono essere caricati i dati. Neptune associa ogni tripla a un grafo nominato. È possibile specificare il grafo nominato predefinito utilizzando l'URI di fallback del grafo nominato, `http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph`, in questo modo: ``` INTO GRAPH ``` **Nota** Quando devi caricare molti dati, è consigliabile utilizzare lo strumento di caricamento in blocco Neptune anziché UPDATE LOAD. Per ulteriori informazioni sullo strumento di caricamento in blocco, consulta [Utilizzo del bulk loader Amazon Neptune per importare dati](bulk-load.md). Puoi utilizzare `SPARQL UPDATE LOAD` per caricare dati direttamente da Amazon S3 o da file ottenuti da un server Web in self-hosting. Le risorse da caricare devono trovarsi nella stessa regione del server Neptune e l'endpoint per le risorse deve essere consentito nel VCP. Per informazioni su come creare un endpoint Amazon S3, vedi [Creazione di un endpoint VPC Amazon S3](bulk-load-data.md#bulk-load-prereqs-s3). Tutto `SPARQL UPDATE LOAD` URIs deve iniziare con`https://`. Ciò include Amazon S3 URLs. Diversamente dallo strumento di caricamento in blocco Neptune, una chiamata a `SPARQL UPDATE LOAD` è completamente transazionale. **Caricare file da Amazon S3 direttamente in Neptune tramite SPARQL UPDATE LOAD** Poiché Neptune non consente di passare un ruolo IAM ad Amazon S3 quando si utilizza SPARQL UPDATE LOAD, il bucket Amazon S3 in questione deve essere pubblico oppure è necessario utilizzare un [URL Amazon S3 prefirmato](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html) nella query LOAD. Per generare un URL prefirmato per un file Amazon S3, puoi usare AWS CLI un comando come questo: ``` aws s3 presign --expires-in (number of seconds) s3://(bucket name)/(path to file of data to load) ``` Quindi puoi utilizzare l'URL prefirmato risultante nel comando `LOAD`: ``` 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)' ``` Per ulteriori informazioni, consulta [Autenticazione delle richieste: utilizzo dei parametri di query](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html). La [documentazione di Boto3](https://boto3.amazonaws.com/v1/documentation/api/latest/guide/s3-presigned-urls.html) mostra come usare uno script Python per generare un URL prefirmato. Inoltre, il tipo di contenuto dei file da caricare deve essere impostato correttamente. 1. Imposta il tipo di contenuto dei file quando li carichi in Amazon S3 usando il parametro `-metadata`, ad esempio: ``` 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. Conferma che sia presente l'informazione sul tipo di supporto. Esegui: ``` curl -v bucket-name/folder-name ``` L'output di questo comando mostra le informazioni sul tipo di supporto impostate durante il caricamento dei file. 1. Quindi, puoi utilizzare il comando `SPARQL UPDATE LOAD` per importare questi file in Neptune: ``` curl https://your-neptune-endpoint:port/sparql \ -d "update=LOAD " ``` I passaggi precedenti funzionano solo per un bucket Amazon S3 pubblico o per un bucket a cui si accede utilizzando un [URL Amazon S3 prefirmato](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html) nella query LOAD. È inoltre possibile impostare un server proxy Web per il caricamento da un bucket Amazon S3 privato, come illustrato di seguito: **Utilizzare un server Web per caricare file in Neptune con SPARQL UPDATE LOAD** 1. Installa un server Web su una macchina in esecuzione nel VPC che ospita Neptune e i file da caricare. Ad esempio, usando Amazon Linux, puoi installare Apache come segue: ``` sudo yum install httpd mod_ssl sudo /usr/sbin/apachectl start ``` 1. Definisci il tipo/i MIME dei contenuti dei file RDF che andrai a caricare. SPARQL utilizza l'intestazione `Content-type` inviata dal server Web per determinare il formato di input dei contenuti, pertanto è necessario definire i tipi MIME per il server Web. Ad esempio, supponiamo che desideri utilizzare le seguenti estensioni di file per identificare i formati di file: + `.nt`per. NTriples + `.nq`per NQuads. + `.trig` per Trig. + `.rdf` per RDF/XML. + `.ttl` per Turtle. + `.n3` per N3. + `.jsonld` per JSON-LD. Se stai usando Apache 2 come server Web, dovrai modificare il file `/etc/mime.types` e aggiungere i seguenti tipi: ``` 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. Conferma che la mappatura del tipo MIME funziona. Una volta che il server Web è in esecuzione e ospita i file RDF nel formato di tua scelta, puoi testare la configurazione inviando una richiesta al server Web dal tuo host locale. Ad esempio, potresti inviare una richiesta di questo tipo: ``` curl -v http://localhost:80/test.rdf ``` Quindi, nell'output dettagliato di `curl`, dovresti visualizzare una riga come questa: ``` Content-Type: application/rdf+xml ``` Questo dimostra che la mappatura del tipo di contenuto è stata definita correttamente. 1. Ora puoi caricare i dati usando il comando SPARQL UPDATE: ``` curl https://your-neptune-endpoint:port/sparql \ -d "update=LOAD " ``` **Nota** Utilizzando `SPARQL UPDATE LOAD` può attivare un timeout sul server Web quando il file di origine che viene caricato è grande. Neptune elabora i dati del file mentre vengono trasmessi in streaming e per un file di grandi dimensioni che può richiedere più tempo del timeout configurato sul server. Questo a sua volta potrebbe causare la chiusura della connessione del server, che può causare il seguente messaggio di errore quando Neptune incontra un EOF imprevisto nel flusso: ``` { "detailedMessage":"Invalid syntax in the specified file", "code":"InvalidParameterException" } ``` Se si riceve questo messaggio e non si ritiene che il file di origine contenga una sintassi non valida, provare ad aumentare le impostazioni di timeout sul server Web. È inoltre possibile diagnosticare il problema abilitando i registri di debug sul server e cercando i timeout. # Utilizzo di SPARQL UPDATE UNLOAD per eliminare i dati da Neptune Neptune fornisce anche un'operazione SPARQL personalizzata, `UNLOAD`, per rimuovere i dati specificati in un'origine remota. `UNLOAD` può essere considerata una controparte dell'operazione `LOAD`. La sintassi è: ``` UNLOAD SILENT (URL of the remote data to be unloaded) FROM GRAPH (named graph from which to remove the data) ``` + **`SILENT`**: (*facoltativo*) fa sì che l'operazione restituisca un esito positivo anche se si è verificato un errore durante l'elaborazione dei dati. Ciò può essere utile quando una singola transazione contiene più istruzioni come `"LOAD ...; LOAD ...; UNLOAD ...; LOAD ...;"` e si desidera che la transazione venga completata anche se non è stato possibile elaborare alcuni dati remoti. + *URL of the remote data to be unloaded*— (*Obbligatorio*) specifica un file di dati remoto contenente dati da scaricare da un grafico. Il file remoto deve avere una delle seguenti estensioni (sono gli stessi formati supportati da UPDATE-LOAD): + `.nt`per. NTriples + `.nq`per NQuads. + `.trig` per Trig. + `.rdf` per RDF/XML. + `.ttl` per Turtle. + `.n3` per N3. + `.jsonld` per JSON-LD. Tutti i dati contenuti in questo file verranno rimossi dal cluster database dall'operazione `UNLOAD`. Qualsiasi autenticazione Amazon S3 deve essere inclusa nell'URL affinché i dati vengano scaricati. Puoi prefirmare un file Amazon S3 e quindi utilizzare l'URL risultante per accedervi in modo sicuro. Esempio: ``` aws s3 presign --expires-in (number of seconds) s3://(bucket name)/(path to file of data to unload) ``` Quindi: ``` 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)' ``` Per ulteriori informazioni, consulta [Autenticazione delle richieste: utilizzo dei parametri di query](https://docs.aws.amazon.com/AmazonS3/latest/API/sigv4-query-string-auth.html). + **`FROM GRAPH `***(named graph from which to remove the data)*— (*Facoltativo*) Speciifica il grafico denominato da cui devono essere scaricati i dati remoti. Neptune associa ogni tripla a un grafo nominato. È possibile specificare il grafo nominato predefinito utilizzando l'URI di fallback del grafo nominato, `http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph`, in questo modo: ``` FROM GRAPH ``` Nello stesso modo in cui `LOAD` corrisponde a `INSERT DATA { (inline data) }`, `UNLOAD` corrisponde a `DELETE DATA { (inline data) }`. Analogamente a `DELETE DATA`, `UNLOAD` non funziona su dati che contengono nodi vuoti. Ad esempio, se un server Web locale serve un file denominato `data.nt` che contiene le seguenti 2 triple: ``` . . ``` Il comando `UNLOAD` seguente eliminerà queste due triple dal grafo nominato ``: ``` UNLOAD FROM GRAPH ``` Ciò avrà lo stesso effetto dell'utilizzo del comando `DELETE DATA` seguente: ``` DELETE DATA { GRAPH { . . } } ``` **Eccezioni generate dal comando `UNLOAD`** + **`InvalidParameterException`**: sono presenti nodi vuoti nei dati. *Stato HTTP*: 400 Richiesta non valida. *Messaggio*: ` Blank nodes are not allowed for UNLOAD`   + **`InvalidParameterException`**: sintassi non corretta nei dati. *Stato HTTP*: 400 Richiesta non valida. *Messaggio*: `Invalid syntax in the specified file.`   + **`UnloadUrlAccessDeniedException `**: accesso negato. *Stato HTTP*: 400 Richiesta non valida. *Messaggio*: `Update failure: Endpoint (Neptune endpoint) reported access denied error. Please verify access.`   + **`BadRequestException `**: non è possibile recuperare i dati remoti. *Stato HTTP*: 400 Richiesta non valida. *Messaggio*: *(dipende dalla risposta HTTP).*