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é d'Amazon Neptune avec les normes Gremlin

Les sections suivantes donnent un aperçu de l'implémentation Neptune de Gremlin et de ses différences par rapport à l'implémentation Apache TinkerPop .

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

Normes applicables pour Gremlin

Variables et paramètres dans les scripts

En ce qui concerne les variables pré-limites, l'objet de traversée g se trouve Pre-bound 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 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, la fonction de déclaration de variables et la fonction de paramétrage (ainsi que les avertissements) ne s'appliquent qu'au TinkerPop serveur Gremlin s'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. Étant donné que la grammaire ANTLR est 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();

Exécution de script

Le moteur Gremlin de Neptune analyse les requêtes à l'aide TinkerPop de la grammaire ANTLR. gremlin-language Il n'exécute pas de GremlinGroovyScriptEngine (comme le font certains déploiements de serveurs TinkerPop-based Gremlin). Les scripts soumis à Neptune doivent donc contenir uniquement le langage Gremlin, et non du code Groovy ou Java arbitraire.

Les scripts peuvent être envoyés à Neptune de différentes manières, par exemple via le point de terminaison Gremlin REST, la console https://docs.aws.amazon.com//neptune/latest/userguide/access-graph-gremlin-console.html Gremlin ou via des pilotes de TinkerPop langage (par exemple, le client de script du pilote Java). Les contraintes décrites dans cette section s'appliquent à tous ces chemins de soumission de chaînes de texte.

Il est important de ne pas confondre le langage Gremlin lui-même avec le sucre syntaxique ou les fonctions générales de tout langage de programmation que vous avez pu voir encapsuler des exemples de Gremlin ailleurs. Lorsqu'un tel code apparaît dans des TinkerPop didacticiels ou des exemples en ligne, cela dépend d'un environnement d'exécution Groovy ou Java que Neptune ne fournit pas.

Ce que peut contenir un script

Référencement de valeurs d' TinkerPop énumération

Lorsqu'une valeur d' TinkerPop énumération est attendue comme argument d'étape (par exemple, une cardinalité activée property() ou une commande activéeby()), utilisez les valeurs abrégées reconnues par la grammaire ANTLR. Neptune ne résout pas les noms de classe Java entièrement qualifiés à cette position. Par exemple, n'org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.singleest pas accepté ; utilisez-le à la single place.

Le tableau suivant répertorie les valeurs abrégées autorisées et la TinkerPop classe sous-jacente à laquelle chacune appartient.

Ce qu'un script ne peut pas contenir

Les éléments suivants ne sont pas pris en charge dans les requêtes Gremlin sous forme de chaîne de texte adressées à Neptune, car ils reposent sur le support d'exécution Groovy ou Java que Neptune ne fournit pas :

Propriétés des éléments

Neptune ne prend pas en charge l'materializePropertiesindicateur qui a été 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 des sommets ou des arêtes comme références avec juste leur id et. label

Séances

Les sessions dans Neptune sont limitées à seulement 10 minutes. Consultez 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.

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.

User-supplied Les identifiants sont pris en charge, mais ils sont facultatifs dans le cadre 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.

User-supplied Identifiants

User-supplied Les pièces d'identité sont autorisées dans Neptune Gremlin avec les stipulations suivantes.

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

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 Gremlin. 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").

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.

Sérialisation

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

Avec Neptune, vous pouvez utiliser la plupart des sérialiseurs TinkerPop proposés, qui prennent en charge les différentes versions et configurations de GraphSon et. GraphBinary Consultez le tableau suivant pour les sérialiseurs actuellement pris en charge. Bien que de nombreuses options soient présentes, les conseils à utiliser sont simples :

Étapes Lambda

Neptune ne prend pas en charge les étapes Lambda.

Étapes Gremlin non prises en charge

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

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.

Support de Neptune pour les fonctionnalités graphiques

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

Prise en charge Neptune des fonctionnalités de variable

Prise en charge Neptune des fonctionnalités de sommet

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

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

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