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à.

SPARQLconformità agli standard in Amazon Neptune

Dopo aver elencato SPARQL gli standard applicabili, le sezioni seguenti forniscono dettagli specifici su come l'SPARQLimplementazione di Neptune si estende o diverge da tali standard.

Amazon Neptune è conforme ai seguenti standard nell'implementazione SPARQL del linguaggio Graph Query.

Standard applicabili per SPARQL

Prefissi dei namespace predefiniti in Neptune SPARQL

Per impostazione predefinita, Neptune definisce i seguenti prefissi da utilizzare nelle query. SPARQL Per ulteriori informazioni, vedere Nomi con prefisso nelle specifiche. SPARQL

SPARQLGrafico predefinito e grafici con nome

Amazon Neptune associa ogni tripla a un grafo denominato. Il grafo predefinito è definito come l'unione di grafi denominati.

Grafico predefinito per query

Se invii una SPARQL query senza specificare esplicitamente un grafico tramite la GRAPH parola chiave o costrutti come, FROM NAMED Neptune considera sempre tutte le triple nell'istanza DB. Ad esempio, la seguente query restituisce tutte le triple da un endpoint di NeptuneSPARQL:

SELECT * WHERE { ?s ?p ?o }

Le triple che appaiono in più grafici vengono restituite una sola volta.

Per informazioni sulla specifica grafica predefinita, vedere la sezione RDFDataset della specifica 1.1 Query Language. SPARQL

Specifica del grafo denominato per caricamento, inserimenti o aggiornamenti

Se non specificate un grafico con nome durante il caricamento, l'inserimento o l'aggiornamento delle triple, Neptune utilizza il grafico di riserva denominato definito da. URI http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph

Quando invii una richiesta Load Neptune utilizzando un formato basato sulla tripla, puoi specificare il grafo nominato da utilizzare per tutte le triple utilizzando il parametro parserConfiguration: namedGraphUri. Per ulteriori informazioni sulla sintassi del comando Load, consulta Comando dello strumento di caricamento Neptune.

Questo grafo di fallback denominato viene anche utilizzato se carichi triple tramite SPARQL UPDATE senza fornire in maniera esplicita una destinazione del grafo denominato.

Puoi utilizzare il formato basato su quadruple N-Quads per specificare un grafo denominato per ogni tripla nel database.

SPARQLXPathFunzioni di costruzione supportate da Neptune

Lo SPARQL standard consente ai SPARQL motori di supportare un set estensibile di funzioni di costruzione. XPath Neptune attualmente supporta le seguenti funzioni costruttore, dove il prefisso xsd è definito come http://www.w3.org/2001/XMLSchema#:

Base predefinita IRI per interrogazioni e aggiornamenti

Poiché un cluster Neptune ha diversi endpoint, l'utilizzo della URL richiesta di una query o di un aggiornamento come IRI base potrebbe portare a risultati imprevisti durante la risoluzione relativa. IRIs

A partire dalla versione 1.2.1.0 del motore, Neptune utilizza http://aws.amazon.com/neptune/default/ come base IRI se una base IRI esplicita non fa parte della richiesta.

Nella richiesta seguente, la base IRI fa parte della richiesta:

BASE <http://example.org/default/>
INSERT DATA { <node1> <id> "n1" }

BASE <http://example.org/default/>
SELECT * { <node1> ?p ?o }

E il risultato sarà:

?p                                                   ?o
http://example.org/default/id                        n1

In questa richiesta, tuttavia, non IRI è inclusa alcuna base:

INSERT DATA { <node1> <id> "n1" }

SELECT * { <node1> ?p ?o }

In tal caso, il risultato sarà:

?p                                                   ?o
http://aws.amazon.com/neptune/default/id             n1

xsd: dateTime Valori in Neptune

Per motivi di prestazioni, Neptune memorizza sempre i valori di data/ora come Coordinated Universal Time (). UTC Questo rende i confronti diretti molto efficienti.

Ciò significa anche che se si inserisce un dateTime valore che specifica un particolare fuso orario, Neptune traduce il valore UTC in e scarta tali informazioni sul fuso orario. Quindi, quando recuperate il dateTime valore in un secondo momento, esso viene espresso inUTC, non nell'ora del fuso orario originale, e non è più possibile determinare quale fosse quel fuso orario originale.

Gestione di Neptune dei valori speciali a virgola mobile

Neptune gestisce i valori speciali in virgola mobile come segue. SPARQL

SPARQLGestione del NaN in Neptune

In NeptuneSPARQL, può accettare un valore NaN di in una query. Non viene fatta alcuna distinzione tra valori NaN di segnalazione e silenziosi. Neptune considera tutti i valori NaN come silenziosi.

Dal punto di vista semantico, non è possibile un confronto di un valore NaN poiché non esistono elementi maggiori di, minori di o uguali a un valore NaN. Ciò significa che un valore NaN su un lato di un confronto in teoria non corrisponde mai a qualcosa sull'altro lato.

Tuttavia, la XSDspecifica considera due xsd:double o più xsd:float NaN valori come uguali. Neptune segue questo principio per il filtro IN, per l'operatore equal nelle espressioni di filtro e per la semantica di corrispondenza esatta (avendo un valore NaN nella posizione dell'oggetto di un modello di tripla).

SPARQLGestione dei valori infiniti in Neptune

In NeptuneSPARQL, può accettare un valore INF di -INF o in una query. INFviene confrontato come maggiore di qualsiasi altro valore numerico e viene -INF confrontato come minore di qualsiasi altro valore numerico.

Due INF valori con segni corrispondenti vengono confrontati come uguali indipendentemente dal tipo (ad esempio, un float è uguale a un -INF doppio). -INF

Non è possibile un confronto con un valore NaN ovviamente poiché non esistono elementi maggiori di, minori di o uguali a un valore NaN.

SPARQLGestione dello zero negativo in Neptune

Neptune normalizza un valore zero negativo a uno zero senza segno. È possibile utilizzare i valori zero negativo in una query, ma non vengono registrati come tali nel database e vengono confrontati come uguali a zero senza segno.

Limitazione di Neptune dei valori di lunghezza arbitraria

Neptune limita la dimensione XSD di archiviazione dei valori interi, in virgola mobile e decimali a 64 bit. SPARQL L'utilizzo di valori più grandi genera un errore InvalidNumericDataException.

Neptune estende il confronto tra pari in SPARQL

Lo SPARQL standard definisce una logica ternaria per le espressioni di valore, in cui un'espressione di valore può restituire o. true false error La semantica predefinita per l'uguaglianza dei termini (come definita nella specifica SPARQL 1.1), che si applica alle condizioni = e i != confronti nelle FILTER condizioni, produce un errore error quando si confrontano tipi di dati che non sono esplicitamente confrontabili nella tabella degli operatori della specifica.

Questo comportamento può portare a risultati non intuitivi, come nell'esempio seguente.

Dati:

<http://example.com/Server/1> <http://example.com/ip> "127.0.0.1"^^<http://example.com/datatype/IPAddress>

Query 1:

SELECT * WHERE {
    <http://example.com/Server/1> <http://example.com/ip> ?o .
    FILTER(?o = "127.0.0.2"^^<http://example.com/datatype/IPAddress>)
}

Query 2:

SELECT * WHERE {
    <http://example.com/Server/1> <http://example.com/ip> ?o .
    FILTER(?o != "127.0.0.2"^^<http://example.com/datatype/IPAddress>)
}

Con la SPARQL semantica predefinita utilizzata da Neptune prima della versione 1.0.2.1, entrambe le query restituirebbero il risultato vuoto. Il motivo è che ?o = "127.0.0.2"^^<http://example.com/IPAddress> quando viene valutato per ?o := "127.0.0.1"^^<http://example.com/IPAddress>, produce un error anziché false perché non esistono regole di confronto esplicite specificate per il tipo di dati personalizzato <http://example.com/IPAddress>. Di conseguenza, anche la versione negata nella seconda query produce un error. In entrambe le query, l'error causa il filtraggio della soluzione candidata.

A partire dalla versione 1.0.2.1, Neptune ha esteso l'operatore di SPARQL disuguaglianza in conformità con le specifiche. Vedi la sezione SPARQL 1.1 sull'estensibilità degli operatori, che consente ai motori di definire regole aggiuntive su come confrontare tipi di dati integrati definiti dall'utente e non confrontabili.

Utilizzando questa opzione, Neptune ora tratta un confronto di due tipi di dati che non è esplicitamente definito nella tabella di mappatura dell'operatore come se restituisse true, se i valori letterali e i tipi di dati sono sintatticamente uguali, altrimenti, false. In ogni caso, non viene prodotto un error.

Usando queste nuove semantiche, la seconda query restituirebbe "127.0.0.1"^^<http://example.com/IPAddress> invece di un risultato vuoto.

Gestione dei Out-of-Range valori letterali in Nettuno SPARQL

XSDla semantica definisce ogni tipo numerico con il relativo spazio di valori, ad eccezione di e. integer decimal Queste definizioni limitano ogni tipo a un intervallo di valori. Ad esempio, l'intervallo di un intervallo xsd:byte è compreso tra -128 e +127, inclusi. Qualsiasi valore al di fuori di questo intervallo è considerato non valido.

Se si tenta di assegnare un valore letterale al di fuori dello spazio dei valori di un tipo (ad esempio, se si tenta di impostare an su un xsd:byte valore letterale di 999), Neptune accetta il valore così com'è, senza arrotondarlo o out-of-range troncarlo. Ma non lo mantiene come valore numerico perché il tipo fornito non può rappresentarlo.

Cioè, Neptune accetta "999"^^xsd:byte anche se è un valore al di fuori dell'intervallo di valori xsd:byte definito. Tuttavia, dopo che il valore viene mantenuto nel database, può essere utilizzato solo nella semantica di corrispondenza esatta, in una posizione oggetto di un modello triplo. Nessun filtro di intervallo può essere eseguito su di esso perché i valori letterali non vengono trattati come valori numerici. out-of-range

La specifica SPARQL 1.1 definisce gli operatori di intervallo nella forma numeric -operator-numeric, -operator-, string -operator- string e literal così via. literal Neptune non può eseguire un operatore di confronto di intervalli simile a invalid-literal-operator-numeric-value.