Conformité d'Amazon Neptune avec les normes Gremlin

Les sections suivantes fournissent une vue d'ensemble de l'implémentation Neptune de Gkremlin et de ses différences par rapport à l'implémentation Apache. TinkerPop

Neptune implémente certaines étapes de Gkremlin de manière native dans son moteur et utilise l'implémentation d'Apache TinkerPop Gkremlin pour en traiter d'autres (voir). Prise en charge des étapes Gremlin natives dans Amazon Neptune

Note

Pour obtenir des exemples concrets de ces différences implémentation dans la console Gremlin et dans Amazon Neptune, consultez la section Utilisation de Gremlin pour accéder au graphe dans Amazon Neptune du Quick Start.

Normes applicables pour Gremlin

• Le langage G705 est défini par la TinkerPop documentation Apache et l' TinkerPop implémentation Apache de G705 plutôt que par une spécification formelle.

• Pour les formats numériques, Gremlin suit la norme IEEE 754 (IEEE 754-2019 - IEEE Standard for Floating-Point Arithmetic ; voir aussi la page Wikipedia sur IEEE 754 pour plus d'informations).

Variables et paramètres dans les scripts

En ce qui concerne les variables pré-liées, l'objet de traversée g est pré-lié dans Neptune, et l'objet graph n'est pas pris en charge.

Bien que Neptune ne prenne pas en charge les variables Gremlin ni le paramétrage dans des scripts, vous pouvez souvent rencontrer sur Internet des exemples de scripts contenant des déclarations de variables, tels que :

String query = "x = 1; g.V(x)";
List<Result> results = client.submit(query).all().get();

Il existe également de nombreux exemples qui utilisent le paramétrage (ou les liaisons) lors de la soumission de requêtes, tels que :

Map<String,Object> params = new HashMap<>();
params.put("x",1);
String query = "g.V(x)";
List<Result> results = client.submit(query).all().get();

Ces exemples de paramètres sont généralement associés à des avertissements sur les pénalités de performance possibles en cas de non-paramétrage lorsque cela est possible. Il existe de nombreux exemples de ce type TinkerPop que vous pouvez rencontrer, et ils semblent tous assez convaincants quant à la nécessité de paramétrer.

Cependant, les fonctionnalités de déclaration de variables et de paramétrage (ainsi que les avertissements) ne s'appliquent qu'au TinkerPop serveur Gremlin lorsqu'il utilise le. GremlinGroovyScriptEngine Elles ne s'appliquent pas lorsque le serveur Gremlin utilise la grammaire gremlin-language ANTLR de Gremlin pour analyser les requêtes. La grammaire ANTLR ne prend en charge ni les déclarations de variables ni le paramétrage. Ainsi, lorsque vous utilisez ANTLR, vous n'avez rien à craindre en cas de non-paramétrage. La grammaire ANTLR étant une composante plus récente TinkerPop, les anciens contenus que vous pouvez rencontrer sur Internet ne reflètent généralement pas cette distinction.

Neptune utilise la grammaire ANTLR dans son moteur de traitement des requêtes plutôt que le moteur GremlinGroovyScriptEngine. Il ne prend donc pas en charge les variables, le paramétrage ni la propriété bindings. Par conséquent, les problèmes potentiels liés au non-paramétrage ne s'appliquent pas dans Neptune. Avec Neptune, il est parfaitement sûr de soumettre simplement la requête telle quelle, alors que beaucoup la paramétrerait. Par conséquent, l'exemple précédent peut être simplifié sans aucune perte de performance comme suit :

String query = "g.V(1)";
List<Result> results = client.submit(query).all().get();

TinkerPop énumérations

Neptune ne prend pas en charge les noms de classe complets pour les valeurs d'énumération. Par exemple, vous devez utiliser single et non org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single dans votre demande Groovy.

Le type d'énumération est déterminé par le type de paramètre.

Le tableau suivant indique les valeurs d'énumération autorisées et le nom TinkerPop complet correspondant.

Valeurs autorisées	Classe
id, key, label, value	org.apache.tinkerpop.gremlin.structure.T
T.id, T.key, T.label, T.value	org.apache.tinkerpop.gremlin.structure.T
set, single	org.apache.tinkerpop.gremlin.structure. VertexProperty. Cardinalité
asc, desc, shuffle	org.apache.tinkerpop.gremlin.process.traversal.Order
Order.asc, Order.desc, Order.shuffle	org.apache.tinkerpop.gremlin.process.traversal.Order
global, local	org.apache.tinkerpop.gremlin.process.traversal.Scope
Scope.global, Scope.local	org.apache.tinkerpop.gremlin.process.traversal.Scope
all, first, last, mixed	org.apache.tinkerpop.gremlin.process.traversal.Pop
normSack	org.apache.tinkerpop.gremlin.process.traversal. SackFunctions. Barrière
addAll, and, assign, div, max, min, minus, mult, or, sum, sumLong	org.apache.tinkerpop.gremlin.process.traversal.Operator
keys, values	org.apache.tinkerpop.gremlin.structure.Column
BOTH, IN, OUT	org.apache.tinkerpop.gremlin.structure.Direction
any, none	org.apache.tinkerpop.gremlin.process.traversal.step. TraversalOptionParent. Choisissez

Code Java

Neptune ne prend pas en charge les appels de méthodes définies par des appels Java ou des appels de bibliothèque Java arbitraires autres que les API Gremlin prises en charge. Par exemple, java.lang.*, Date() et g.V().tryNext().orElseGet() ne sont pas autorisés.

Propriétés des éléments

Neptune ne prend pas en charge l'materializePropertiesindicateur introduit dans la TinkerPop version 3.7.0 pour renvoyer les propriétés des éléments. Par conséquent, Neptune ne renverra toujours que les sommets ou les arêtes en tant que références avec uniquement leur et. id label

Exécution de script

Toutes les requêtes doivent commencer par g qui est l'objet de traversée.

Dans les soumissions de requête de type Chaîne, plusieurs traversées peuvent être émises, séparées par un point-virgule (;) ou un caractère de saut de ligne (\n). Pour être exécutée, chaque instruction autre que la dernière doit se terminer par une étape .iterate(). Seules les données de la traversée finale sont renvoyées. Notez que cela ne s'applique pas aux soumissions de ByteCode requêtes GLV.

Séances

Les sessions dans Neptune sont limitées à seulement 10 minutes. Voir Sessions basées sur des scripts Gremlin et la référence de TinkerPop session pour plus d'informations.

Transactions

Neptune ouvre une nouvelle transaction au début de chaque traversée Gremlin et ferme la transaction lors de la réussite complète de la traversée. La transaction est annulée lorsqu'il y a une erreur.

Plusieurs instructions séparées par un point-virgule (;) ou un caractère de nouvelle ligne (\n) sont incluses dans une seule transaction. Chaque instruction autre que la dernière doit se terminer par une étape next() à exécuter. Seules les données de la traversée finale sont renvoyées.

La logique de transaction manuelle utilisant tx.commit() et tx.rollback() n'est pas prise en charge.

Important

Ceci s'applique uniquement aux méthodes dans lesquelles vous envoyez la requête Gremlin en tant que chaîne de texte (voir Transactions Gremlin).

ID de sommet et ID d'arête

Les ID de sommet et d'arête de Neptune doivent être de type String. Ces chaînes d'ID prennent en charge les caractères Unicode et ne peuvent pas dépasser 55 Mo.

Les ID fournis par l'utilisateur sont pris en charge, mais ils sont facultatifs dans le cas d'une utilisation normale. Si vous ne fournissez pas d'ID lorsque vous ajoutez un sommet ou une arête, Neptune génère un UUID et le convertit en chaîne, sous une forme similaire à celle-ci : "48af8178-50ce-971a-fc41-8c9a954cea62". Ces UUID ne sont pas conformes à la norme RFC. Par conséquent, si vous avez besoin d'UUID standard, vous devrez les générer en externe et les fournir lorsque vous ajouterez des sommets ou des arêtes.

Note

La commande Neptune Load nécessite que vous fournissiez les ID à l'aide du champ ~ id dans le format CSV de Neptune.

ID fournis par l'utilisateur

Les ID fournis par l'utilisateur sont autorisés dans Neptune Gremlin aux conditions suivantes.

• Les ID fournis sont facultatifs.

• Seuls les vertex et les edges sont pris en charge.

• Seul le type String est pris en charge.

Pour créer un nouveau vertex avec un ID personnalisé, utilisez l'étape property avec le mot-clé id : g.addV().property(id, 'customid').

Note

Ne placez pas de guillemets autour du mot-clé id. Il fait référence à T.id.

Tous les ID vertex et ID edge doivent être uniques. Cependant, Neptune permet d'avoir le même ID pour un sommet et une arête.

Si vous essayez de créer un nouveau vertex à l'aide de g.addV() et qu'il existe déjà un vertex ayant cet ID, l'opération échoue. L'exception à cette règle, c'est que si vous précisez une nouvelle étiquette pour le vertex, l'opération réussit, mais elle ajoute la nouvelle étiquette et toute propriété supplémentaire précisée au sommet existant. Rien n'est remplacé. Un nouveau vertex n'est pas créé. L'ID de sommet ne change pas et reste unique.

Par exemple, les commandes suivantes de la console Gremlin aboutissent :

gremlin> g.addV('label1').property(id, 'customid')
gremlin> g.addV('label2').property(id, 'customid')
gremlin> g.V('customid').label()
==>label1::label2

ID de propriété de vertex

Les ID de propriété de vertex sont générés automatiquement et peuvent s'afficher comme nombres positifs ou négatifs lors des requêtes.

Cardinalité des propriétés de sommet

Neptune prend en charge la cardinalité définie et la cardinalité unique. Si elle n'est pas spécifiée, la cardinalité définie est sélectionnée. Cela signifie que si vous définissez une valeur de propriété, une nouvelle valeur est ajoutée à la propriété, mais uniquement si elle n'apparaît pas déjà dans l'ensemble de valeurs. Il s'agit de la valeur d'énumération Gremlin Set.

List n’est pas pris en charge. Pour plus d'informations sur la cardinalité des propriétés, consultez la rubrique Vertex dans le Gkremlin. JavaDoc

Mise à jour d'une propriété de sommet

Pour mettre à jour une valeur de propriété sans ajouter une valeur à l'ensemble des valeurs, spécifiez la cardinalité single lors de l'étape property.

g.V('exampleid01').property(single, 'age', 25)

Cela supprime toutes les valeurs existantes de la propriété.

Étiquettes

Neptune prend en charge plusieurs étiquettes pour un sommet. Lorsque vous créez une étiquette, vous pouvez spécifier plusieurs étiquettes en les séparant par ::. Par exemple, g.addV("Label1::Label2::Label3") ajoute un vertex, avec trois étiquettes différentes. L'étape hasLabel associe ce sommet à l'une de ces trois étiquettes : hasLabel("Label1") hasLabel("Label2") et hasLabel("Label3").

Important

Le délimiteur :: est réservé à cet usage uniquement. Vous ne pouvez pas spécifier plusieurs étiquettes dans l'étape hasLabel. Par exemple, hasLabel("Label1::Label2") ne correspond à rien.

Caractères d'échappement

Neptune résout tous les caractères d'échappement comme décrit dans la section Escaping Special Characters (Échappement des caractères spéciaux) de la documentation du langage Apache Groovy.

Limites Groovy

Neptune ne prend pas en charge les commandes Groovy qui ne commencent pas par g. Cela inclut les calculs (par exemple, 1+1), les appels système (par exemple, System.nanoTime()) et les définitions de variable (par exemple, 1+1).

Important

Neptune ne prend pas en charge les noms de classe complets. Par exemple, vous devez utiliser single et non org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single dans votre demande Groovy.

Sérialisation

Neptune prend en charge les sérialisations suivantes en fonction du type MIME demandé.

Type MIME	Sérialisation	Configuration
application/vnd.gremlin-v1.0+gryo	GryoMessageSerializerV1	ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1]
application/vnd.gremlin-v1.0+gryo-stringd	GryoMessageSerializerV1	serializeResultToString: true}
application/vnd.gremlin-v3.0+gryo	GryoMessageSerializerV3	ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3]
application/vnd.gremlin-v3.0+gryo-stringd	GryoMessageSerializerV3	serializeResultToString: true
application/vnd.gremlin-v1.0+json	GraphSONMessageSerializerGremlinV1	ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1]
application/vnd.gremlin-v2.0+json	GraphSONMessageSerializerV2(fonctionne uniquement avec WebSockets)	ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV2]
application/vnd.gremlin-v3.0+json	GraphSONMessageSerializerV3
application/json	GraphSONMessageSerializerV3	ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3]
application/vnd.graphbinary-v1.0	GraphBinaryMessageSerializerV1

Bien que Neptune prenne en charge ces différents types de sérialiseurs, les conseils d'utilisation sont assez simples. Si vous vous connectez à Neptune via HTTP, privilégiez l'utilisation de application/vnd.gremlin-v3.0+json;types=false car les types intégrés dans la version alternative de GraphSon 3 compliquent l'utilisation. Si vous utilisez des TinkerPop pilotes Apache, vous n'aurez probablement pas à faire de choix car vous utiliseriez la valeur par défaut deapplication/vnd.graphbinary-v1.0. Les autres formats restent présents pour des raisons liées à l'héritage.

Note

Le tableau du sérialiseur présenté ici fait référence à la dénomination à partir de la version 3.7.0. TinkerPop Si vous souhaitez en savoir plus sur cette modification, consultez la documentation de TinkerPop mise à niveau. Le support de sérialisation de Gryo est devenu obsolète dans la version 3.4.3 et a été officiellement supprimée dans la version 3.6.0. Si vous utilisez explicitement Gryo ou si vous utilisez une version du pilote qui l'utilise par défaut, vous devez passer à votre pilote GraphBinary ou le mettre à niveau.

Étapes Lambda

Neptune ne prend pas en charge les étapes Lambda.

Méthodes Gremlin non prises en charge

Neptune ne prend pas en charge les méthodes Gremlin suivantes :

• org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.program(org.apache.tinkerpop.gremlin.process.computer.VertexProgram)

• org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.sideEffect(java.util.function.Consumer)

• org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.from(org.apache.tinkerpop.gremlin.structure.Vertex)

• org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.to(org.apache.tinkerpop.gremlin.structure.Vertex)

Par exemple, la traversée suivante n'est pas autorisée : g.V().addE('something').from(__.V().next()).to(__.V().next()).

Important

Ceci s'applique uniquement aux méthodes dans lesquelles vous envoyez la requête Gremlin en tant que chaîne de texte.

Étapes Gremlin non prises en charge

Neptune ne prend pas en charge les étapes Gremlin suivantes :

• L'étape Gremlin io () n'est que partiellement prise en charge dans Neptune. Elle peut être utilisée dans un contexte de lecture, par exemple g.io((url)).read(), mais pas pour écrire.

Fonctionnalités du graphe Gremlin dans Neptune

L'implémentation Neptune de Gremlin n'expose pas l'objet graph. Les tableaux suivants répertorient les fonctionnalités Gremlin et indiquent si Neptune les prend en charge ou non.

Prise en charge Neptune des fonctionnalités graph

Les fonctionnalités de graphe Neptune sont les mêmes que celles qui seraient renvoyées par la commande graph.features().

Fonctionnalité de graphe	Activé ?
Transactions	vrai
ThreadedTransactions	false
Computer	false
Persistence	true
ConcurrentAccess	true

Prise en charge Neptune des fonctionnalités de variable

Fonctionnalité de variable	Activé ?
Variables	false
SerializableValues	false
UniformListValues	false
BooleanArrayValues	false
DoubleArrayValues	false
IntegerArrayValues	false
StringArrayValues	false
BooleanValues	false
ByteValues	false
DoubleValues	false
FloatValues	false
IntegerValues	false
LongValues	false
MapValues	false
MixedListValues	false
StringValues	false
ByteArrayValues	false
FloatArrayValues	false
LongArrayValues	false

Prise en charge Neptune des fonctionnalités de sommet

Fonctionnalité de sommet	Activé ?
MetaProperties	false
DuplicateMultiProperties	false
AddVertices	true
RemoveVertices	true
MultiProperties	true
UserSuppliedIds	true
AddProperty	true
RemoveProperty	vrai
NumericIds	false
StringIds	vrai
UuidIds	false
CustomIds	false
AnyIds	false

Prise en charge Neptune des fonctionnalités de propriété de sommet

Fonctionnalité de propriété de sommet	Activé ?
UserSuppliedIds	false
AddProperty	true
RemoveProperty	true
NumericIds	true
StringIds	vrai
UuidIds	false
CustomIds	false
AnyIds	false
Properties	vrai
SerializableValues	false
UniformListValues	false
BooleanArrayValues	false
DoubleArrayValues	false
IntegerArrayValues	false
StringArrayValues	false
BooleanValues	true
ByteValues	true
DoubleValues	true
FloatValues	true
IntegerValues	true
LongValues	vrai
MapValues	false
MixedListValues	false
StringValues	vrai
ByteArrayValues	false
FloatArrayValues	false
LongArrayValues	false

Prise en charge Neptune des fonctionnalités d'arête

Fonctionnalité d'arête	Activé ?
AddEdges	true
RemoveEdges	true
UserSuppliedIds	true
AddProperty	true
RemoveProperty	vrai
NumericIds	false
StringIds	vrai
UuidIds	false
CustomIds	false
AnyIds	false

Prise en charge Neptune des fonctionnalités de propriété d'arête

Fonctionnalité de propriété d'arête	Activé ?
Properties	vrai
SerializableValues	false
UniformListValues	false
BooleanArrayValues	false
DoubleArrayValues	false
IntegerArrayValues	false
StringArrayValues	false
BooleanValues	true
ByteValues	true
DoubleValues	true
FloatValues	true
IntegerValues	true
LongValues	vrai
MapValues	false
MixedListValues	false
StringValues	vrai
ByteArrayValues	false
FloatArrayValues	false
LongArrayValues	false