Conformité aux normes Gremlin dans Amazon Neptune

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

Neptune implémente certaines étapes de Gremlin de manière native dans son moteur et utilise l'implémentation d'Apache TinkerPop Gremlin pour en traiter d'autres (voirAssistance native à Gremlin Step dans Amazon Neptune).

Note

Pour des exemples concrets de ces différences d'implémentation présentées dans Gremlin Console et Amazon Neptune, consultez laUtilisation de Gremlin pour accéder au graphique dans Amazon Neptune section du Quick Start.

Normes applicables pour Gremlin

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

• Pour les formats numériques, Gremlin suit la norme IEEE 754 (IEEE 754-2019) - Norme IEEE pour l'arithmétique en virgule flottante. Pour plus d'informations, consultez également la page Wikipedia (IEEE 754).

Variables et paramètres dans les scripts

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

Bien que Neptune ne prenne pas en charge les variables Gremlin ni le paramétrage dans les scripts, vous pouvez souvent trouver des exemples de scripts pour Gremlin Server sur Internet contenant des déclarations de variables, telles 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();

Les exemples de paramètres sont généralement associés à des avertissements concernant les pertes de performances 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 au TinkerPop serveur Gremlin que lorsqu'il utilise leGremlinGroovyScriptEngine. Ils ne s'appliquent pas lorsque Gremlin Server utilise la grammairegremlin-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 pas à vous soucier de ne pas pouvoir paramétrer. 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. Il ne prend donc pas en charge les variablesGremlinGroovyScriptEngine, le paramétrage ou labindings propriété. Par conséquent, les problèmes liés à l'échec du paramétrage ne s'appliquent pas à Neptune. Avec Neptune, il est parfaitement sûr de soumettre la requête telle quelle, là où l'on devrait normalement la paramétrer. 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 associé.

Valeurs autorisées	Classe
id, key, étiquette, value	org.apache.tinkerpop.gremlin.structure.T
T.id, T.key, T. étiquette, Valeur T.	org.apache.tinkerpop.gremlin.structure.T
set, seul	org.apache.tinkerpop.gremlin.structure. VertexProperty. Cardinalité
asc, desc, mélanger	org.apache.tinkerpop.gremlin.process.traversal.Order
Commander .asc, Order.desc, Order.shuffle	org.apache.tinkerpop.gremlin.process.traversal.Order
global, local	org.apache.tinkerpop.gremlin.process.traversal.Scope
Champ d'application mondial, Champ d'application local	org.apache.tinkerpop.gremlin.process.traversal.Scope
Tout, first, last, mélangé	org.apache.tinkerpop.gremlin.process.traversal.Pop
normSack	org.apache.tinkerpop.gremlin.process.traversal. SackFunctions. Barrière
Tout ajouter, and, assigner, div, max, min, moins, mult, or, sum, Sum Long	org.apache.tinkerpop.gremlin.process.traversal.Operator
clés, values	org.apache.tinkerpop.gremlin.structure.Column
BOTH, IN, OUT	org.apache.tinkerpop.gremlin.structure.Direction
n'importe quel, Aucun(e)	org.apache.tinkerpop.gremlin.process.traversal.step. TraversalOptionParent.Choisissez

Code Java

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

Exécution de scripts

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 à 10 minutes seulement. VoirSessions basées sur des scripts Gremlin et la référence deTinkerPop session pour plus d'informations.

Transactions

Neptune ouvre une nouvelle transaction au début de chaque traversée avec Gremlin et clôture la transaction une fois la traversée réussie. 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

Cela ne s'applique qu'aux méthodes dans lesquelles vous envoyez la requête Gremlin sous forme de chaîne de texte (voirTransactions avec Gremlin).

Identifiants des sommets et des arêtes

Les identifiants Neptune Gremlin Vertex et Edge doivent être de typeString. Si vous ne spécifiez pas un ID lorsque vous ajoutez un vertex ou un edge, un UUID est généré et converti en chaîne ; par exemple, "48af8178-50ce-971a-fc41-8c9a954cea62". Ces chaînes d'identification prennent en charge les caractères Unicode et ne peuvent pas dépasser 55 Mo.

Note

Cela signifie que les identifiants fournis par l'utilisateur sont pris en charge, mais qu'ils sont facultatifs dans le cas d'une utilisation normale. Toutefois, laLoad commande Neptune nécessite que tous les identifiants soient spécifiés à l'aide du champ ~id au format Neptune CSV.

Identifiants fournis par l'utilisateur

Les identifiants fournis par les utilisateurs sont autorisés dans Neptune Gremlin sous réserve des 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 autorise un sommet et une arête à avoir le même identifiant.

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

Identifiants des propriétés 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.

Propriétés de cardinalité des sommets

Neptune soutient la cardinalité fixe et la cardinalité unique. Si elle n'est pas spécifiée, la cardinalité « set » 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 Gremlin JavaDoc.

Mettre à jour 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é.

Etiquettes

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.

Personnages d'évasion

Neptune résout tous les caractères d'échappement comme décrit dans la section Caractères spéciaux d'évasion de la documentation du langage Apache Groovy.

Limites de Groovy

Neptune ne prend pas en charge les commandes Groovy qui ne commencent pas parg. 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é.

MIME type	Serialization	Configuration
application/vnd.gremlin-v1.0+gryo	GryoMessageSerializerv1d0	Registries d'objets : [org.apache.tinkerpop.gremlin.tinkergraph.structure. TinkerIoRegistryV1d0]
application/vnd.gremlin-v1.0+gryo-stringd	GryoMessageSerializerv1d0	serializeResultToChaîne : true}
application/vnd.gremlin-v3.0+gryo	GryoMessageSerializerv3D0	Registries d'objets : [org.apache.tinkerpop.gremlin.tinkergraph.structure. TinkerIoRegistryversion 3 [0]
application/vnd.gremlin-v3.0+gryo-stringd	GryoMessageSerializerv3D0	serializeResultToChaîne : vrai
application/vnd.gremlin-v1.0+json	MessageSerializerGremlinGraphSon V10	Registries d'objets : [org.apache.tinkerpop.gremlin.tinkergraph.structure. TinkerIoRegistryV1d0]
application/vnd.gremlin-v2.0+json	GraphSonMessageSerializer V2d0   (only works with WebSockets)	Registries d'objets : [org.apache.tinkerpop.gremlin.tinkergraph.structure. TinkerIoRegistryv2d0]
application/vnd.gremlin-v3.0+json	GraphSONMessageSerializerV3d0
application/json	GraphSonMessageSerializer v3D0	Registries d'objets : [org.apache.tinkerpop.gremlin.tinkergraph.structure. TinkerIoRegistryversion 3 [0]
application/vnd.graphbinary-v1.0	GraphBinaryMessageSerializerV1

Étapes Lambda

Neptune n'est pas compatible avec Lambda Steps.

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. Il peut être utilisé dans un contexte de lecture, comme dansg.io((url)).read(), mais pas pour écrire.

Caractéristiques du graphe Gremlin dans Neptune

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

Compatibilité avec Neptune pour lesgraph fonctionnalités

Les fonctionnalités du graphe Neptune, lorsqu'elles sont prises en charge, sont les mêmes que celles qui seraient renvoyées par lagraph.features() commande.

Fonctionnalité de graphiques	Activée ?
Transactions	true
ThreadedTransactions	false
Ordinateur	false
Persistance	true
ConcurrentAccess	true

Neptune prend en charge les fonctionnalités variables

Fonctionnalité variable	Activée ?
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

Neptune prend en charge les fonctionnalités des sommets

Fonction Vertex	Activée ?
MetaProperties	false
DuplicateMultiProperties	false
AddVertices	true
RemoveVertices	true
MultiProperties	true
UserSuppliedIds	true
AddProperty	true
RemoveProperty	true
NumericIds	false
StringIds	true
UuidIds	false
CustomIds	false
AnyIds	false

Neptune prend en charge les fonctionnalités des propriétés des sommets

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

Neptune prend en charge les fonctionnalités de pointe

Fonctionnalité Edge	Activée ?
AddEdges	true
RemoveEdges	true
UserSuppliedIds	true
AddProperty	true
RemoveProperty	true
NumericIds	false
StringIds	true
UuidIds	false
CustomIds	false
AnyIds	false

Neptune prend en charge les fonctionnalités des propriétés périphériques

Fonction de propriété Edge	Activée ?
Propriétés	true
SerializableValues	false
UniformListValues	false
BooleanArrayValues	false
DoubleArrayValues	false
IntegerArrayValues	false
StringArrayValues	false
BooleanValues	true
ByteValues	true
DoubleValues	true
FloatValues	true
IntegerValues	true
LongValues	true
MapValues	false
MixedListValues	false
StringValues	true
ByteArrayValues	false
FloatArrayValues	false
LongArrayValues	false