Conformité aux normes SPARQL dans Amazon Neptune - Amazon Neptune

Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.

Conformité aux normes SPARQL dans Amazon Neptune

Amazon Neptune se conforme aux normes suivantes lors de la mise en œuvre du langage de requête graphique SPARQL.

Normes applicables pour SPARQL

Spécificités d'implémentation de Neptune SPARQL

Les sections suivantes fournissent des détails spécifiques sur la manière dont SPARQL est implémenté dans Neptune.

Préfixes d'espace de noms par défaut dans Neptune SPARQL

Neptune définit les préfixes suivants par défaut à utiliser dans les requêtes SPARQL. Pour de plus amples informations, veuillez consulter Noms préfixés dans la spécification SPARQL.

  • rdf  – http://www.w3.org/1999/02/22-rdf-syntax-ns#

  • rdfs – http://www.w3.org/2000/01/rdf-schema#

  • owl  – http://www.w3.org/2002/07/owl#

  • xsd  – http://www.w3.org/2001/XMLSchema#

Graphe par défaut SPARQL et graphes nommés

Amazon Neptune associe chaque triple à un graphe nommé. Le graphe par défaut est défini comme l'union de tous les graphes nommés.

Graphe par défaut pour les requêtes

Si vous envoyez une requête SPARQL sans spécifier explicitement un graphe via le mot-clé GRAPH ou des constructions telles que FROM NAMED, Neptune prend toujours en compte tous les triplets dans votre instance de base de données. Par exemple, la requête suivante renvoie tous les triples d'un point de terminaison Neptune SPARQL :

SELECT * WHERE { ?s ?p ?o }

Les triplets qui apparaissent dans plusieurs graphes ne sont renvoyés qu'une seule fois.

Pour plus d'informations sur la spécification du graphe par défaut, consultez la section RDF Dataset dans la spécification de langage de requête SPARQL 1.1.

Spécification du graphe nommé pour le chargement, les insertions ou les mises à jour

Si vous ne spécifiez pas de graphe nommé lors du chargement, de l'insertion ou de la mise à jour de triples, Neptune utilise le graphe nommé de secours défini par l'URIhttp://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph.

Lorsque vous émettez un NeptuneLoaddemande à l'aide d'un format triplé, vous pouvez spécifier le graphe nommé à utiliser pour tous les triples en utilisant leparserConfiguration: namedGraphUriparamètre. Pour plus d'informations sur la syntaxe de la commande Load, consultez Commande Neptune Loader.

Important

Si vous n'utilisez pas ce paramètre, et que vous ne spécifiez pas un graphe nommé, l'URI de secours est utilisé : http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph.

Ce graphe nommé de secours est également utilisé si vous chargez des triplets via SPARQL UPDATE sans fournir explicitement une cible de graphe nommé.

Vous pouvez utiliser le format basé sur les quadrilatères NQuads afin de spécifier un graphe nommé pour chaque triplet de la base de données.

Note

L'utilisation de NQuads vous permet de laisser vide le graphe nommé. Dans ce cas, http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph est utilisé.

Vous pouvez remplacer le graphe nommé par défaut pour NQuads à l'aide de l'option de configuration de l'analyseur namedGraphUri.

Fonctions du constructeur SPARQL XPath prises en charge par Neptune

La norme SPARQL permet aux moteurs SPARQL de prendre en charge un ensemble extensible de fonctions de construction XPath. Neptune prend actuellement en charge les fonctions de construction suivantes, oùxsdle préfixe est défini commehttp://www.w3.org/2001/XMLSchema# :

  • xsd:boolean

  • xsd:integer

  • xsd:double

  • xsd:float

  • xsd:decimal

  • xsd:long

  • xsd:unsignedLong

XSD : Valeurs DateTime dans Neptune

Pour des raisons de performances, Neptune enregistre toujours les valeurs date/heure au format UTC (temps universel coordonné). Cela rend les comparaisons directes très efficaces.

Cela signifie également que si vous entrez undateTimevaleur qui spécifie un fuseau horaire particulier, Neptune traduit la valeur en UTC et supprime ces informations de fuseau horaire. Ensuite, lorsque vous récupérez la valeur dateTime ultérieurement, elle est exprimée en UTC, et non en heure du fuseau horaire d'origine, et vous ne pouvez plus savoir quel était ce fuseau horaire d'origine.

Gestion Neptune des valeurs à virgule flottante spéciales

Neptune gère les valeurs à virgule flottante spéciales dans SPARQL comme suit.

Gestion de SPARQL NaN dans Neptune

Dans Neptune, SPARQL peut accepter une valeur deNaNdans une requête. Aucune distinction n'est faite entre signalisation et silenceNaNvalues. Neptune traite toutNaNvaleurs aussi silencieuses.

D'un point de vue sémantique, aucune comparaison d'une valeur NaN n'est possible, car aucune valeur n'est supérieure, inférieure ou égale à une valeur NaN. Cela signifie qu'une valeur NaN d'un côté d'une comparaison ne correspond jamais à quoi que ce soit de l'autre côté.

Cependant, leSpécification XSDtraite deuxxsd:doubleouxsd:float NaNvaleurs égales. Neptune suit cela pourINfiltre, pour l'opérateur égal dans les expressions de filtre et pour une sémantique de correspondance exacte (ayant unNaNdans la position de l'objet d'un motif triple).

Gestion des valeurs infinies SPARQL dans Neptune

Dans Neptune, SPARQL peut accepter une valeur deINFou-INFdans une requête.INFse compare comme étant supérieure à toute autre valeur numérique, et-INFse compare à une valeur inférieure à toute autre valeur numérique.

Deux valeurs INF avec des signes correspondants sont égales l'une à l'autre quel que soit leur type (par exemple, un nombre à virgule flottante -INF est égal à un double -INF).

Bien sûr, aucune comparaison avec une valeur NaN n'est possible, car aucune valeur n'est supérieure, inférieure ou égale à une valeur NaN.

Gestion des zéros négatifs par SPARQL dans Neptune

Neptune normalise une valeur zéro négative en zéro non signé. Des valeurs nulles négatives peuvent être utilisées dans une requête, mais elles ne sont pas enregistrées en tant que telles dans la base de données et elles sont comparées comme étant égales à des zéros non signés.

Limitation Neptune des valeurs de longueur arbitraires

Neptune limite la taille de stockage des valeurs entières, à virgule flottante et décimales XSD dans SPARQL à 64 bits. L'utilisation de valeurs plus élevées se traduit par uneInvalidNumericDataExceptionErreur.

Neptune étend la comparaison Equals dans SPARQL

La norme SPARQL définit une logique ternaire pour les expressions de valeur, dans lesquelles une expression de valeur peut être évaluée à true, false ou error. La sémantique par défaut pour l'égalité des termes telle que définie dans la spécification SPARQL 1.1, qui s'applique aux comparaisons = et != dans des conditions FILTER génère une error lors de la comparaison de types de données qui ne sont pas comparables explicitement dans la table des opérateurs dans la spécification.

Ce comportement peut entraîner des résultats non intuitifs, comme dans l'exemple suivant.

Données :

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

Requête 1 :

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

Requête 2 :

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

Avec la sémantique SPARQL par défaut utilisée par Neptune avant la version 1.0.2.1, les deux requêtes renverraient un résultat vide. En effet, ?o = "127.0.0.2"^^<http://example.com/IPAddress>, lorsqu'il est évalué pour ?o := "127.0.0.1"^^<http://example.com/IPAddress>, génère le résultat error plutôt que false, car aucune règle de comparaison explicite n'est spécifiée pour le type de données personnalisé <http://example.com/IPAddress>. Par conséquent, la version négative dans la deuxième requête produit également une error. Dans les deux requêtes, error provoque le filtrage de la solution candidate.

À partir de la version 1.0.2.1, Neptune a étendu l'opérateur d'inégalité SPARQL conformément à la spécification. Consultez la section SPARQL 1.1 sur l'extensibilité de l'opérateur, qui permet aux moteurs de définir des règles supplémentaires sur la façon d'effectuer une comparaison entre des types de données intégrés définis par l'utilisateur et non comparables.

À l'aide de cette option, Neptune traite désormais une comparaison de deux types de données qui n'est pas explicitement définie dans la table de mappage des opérateurs comme évaluanttruesi les valeurs littérales et les types de données sont syntaxiquement identiques, et faux dans le cas contraire. Un error n'est en aucun cas produit.

En utilisant ces nouvelles sémantiques, la deuxième requête renverrait "127.0.0.1"^^<http://example.com/IPAddress> au lieu d'un résultat vide.

Gestion des littéraux hors plage dans Neptune SPARQL

La sémantique XSD définit chaque type numérique avec son espace de valeurs, à l'exception de integer et decimal. Ces définitions limitent chaque type à une plage de valeurs. Par exemple, la plage d'une plage xsd:byte est comprise entre -128 et +127, inclusivement. Toute valeur en dehors de cette plage est considérée comme non valide.

Si vous essayez d'attribuer une valeur littérale en dehors de l'espace de valeurs d'un type (par exemple, si vous essayez de définir unxsd:byteà une valeur littérale de 999), Neptune accepte out-of-range valeur telle quelle, sans l'arrondir ni la tronquer. Mais il ne le persiste pas en tant que valeur numérique car le type donné ne peut pas le représenter.

C'est-à-dire que Neptune accepte"999"^^xsd:bytemême s'il s'agit d'une valeur en dehors de la définitionxsd:byteplage de valeurs. Cependant, une fois la valeur conservée dans la base de données, elle ne peut être utilisée que dans la sémantique de correspondance exacte, dans une position d'objet d'un motif triple. Aucun filtre de plage ne peut y être exécuté car out-of-range les littéraux ne sont pas traités comme des valeurs numériques.

La spécification SPARQL 1.1 définitopérateurs de plagedans le formulairenumeric-opérateur-numeric,string-opérateur-string,literal-opérateur-literal, et ainsi de suite. Neptune ne peut pas exécuter un opérateur de comparaison de plages, quelque chose commeinvalid-literal-opérateur-numeric-value.