View a markdown version of this page

Testez le code Gremlin dans le contexte dans lequel vous allez le déployer - 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.

Testez le code Gremlin dans le contexte dans lequel vous allez le déployer

Gremlin propose plusieurs moyens aux clients de soumettre des requêtes au serveur. Ces modes de soumission diffèrent quant à la manière dont les requêtes sont évaluées et au comportement des transactions. Ces différences peuvent entraîner des résultats inattendus si vous développez dans un mode et déployez dans un autre.

Mode script (soumission basée sur des chaînes)

En mode script, le client envoie l'intégralité de la requête au serveur sous forme de chaîne de texte. Le serveur évalue la chaîne complète, y compris toutes les étapes du terminal, et renvoie les résultats au client. Les outils et méthodes suivants utilisent le mode script :

En mode script, le client envoie une requête comme celle-ci au serveur sous la forme d'une chaîne complète :

// Script mode – the entire string, including .next(), is sent to the server
// V('non-existing-id') yields nothing because no vertex with that ID exists
Cluster cluster = Cluster.build().addContactPoint("your-neptune-endpoint")
                         .port(8182).enableSsl(true).create();
Client client = cluster.connect();
client.submit("g.V('existing-id').addV('person').V('non-existing-id').next()");

Le serveur évalue la requête complète, y compris.next(). Si .next() aucun résultat n'est trouvé, le serveur déclenche un NoSuchElementException message et la transaction est annulée.

Mode bytecode (objets traversaux GLV)

En mode bytecode, le client crée un objet de traversée localement à l'aide d'une variante du langage Gremlin (GLV). Le pilote sérialise les étapes de traversée sous forme de bytecode et les envoie au serveur. Étapes du terminal telles que .toList() l'.next()exécution côté client pour répéter les résultats renvoyés par le serveur. Vous pouvez utiliser le mode bytecode avec Java, Python, Go JavaScript, .NET et d'autres TinkerPop-compliant pilotes tiers adaptés à la version du moteur Neptune utilisée.

En mode bytecode, la même requête ressemble à ceci :

// Bytecode mode – the driver sends the traversal steps as bytecode
// .next() executes on the client to iterate results
Cluster cluster = Cluster.build().addContactPoint("your-neptune-endpoint")
                         .port(8182).enableSsl(true).create();
GraphTraversalSource g = traversal().withRemote(
    DriverRemoteConnection.using(cluster));
g.V("existing-id").addV("person").V("non-existing-id").next();

Le pilote envoie uniquement les étapes de traversée (g.V().addV().V()) sous forme de bytecode. Le serveur évalue correctement la traversée, valide la transaction et renvoie le jeu de résultats. Le client appelle ensuite .next() localement pour lire le jeu de résultats. Si le jeu de résultats est vide, le client déclenche unNoSuchElementException, mais la transaction a déjà été validée sur le serveur.

Différences de comportement transactionnel

La principale différence entre ces modes réside dans la manière dont les étapes du terminal affectent les transactions :

  • Mode script  : le serveur évalue les étapes du terminal. Si une étape du terminal .next() échoue parce que le jeu de résultats est vide, le serveur considère la requête comme ayant échoué et annule la transaction. Le serveur ne conserve aucune mutation au cours de la même traversée (telle queaddV()).

  • Mode bytecode  : le client évalue les étapes du terminal. Le serveur évalue uniquement les étapes de traversée, valide correctement la transaction et renvoie les résultats. Si le client appelle .next() ensuite un jeu de résultats vide, il en NoSuchElementException résulte uniquement une erreur côté client. La transaction étant déjà validée, le serveur conserve toutes les mutations.

Étapes terminales

Dans Gremlin, les étapes terminales sont les étapes qui entraînent la soumission d'une traversée à Neptune pour évaluation. En mode bytecode, l'étape terminale déclenche la sérialisation par le pilote et l'envoi de la traversée. En mode script, l'étape du terminal fait partie de la chaîne de requête évaluée sur le serveur. Les étapes terminales sont les suivantes :

  • hasNext()— Indique true si les résultats sont disponibles, false sinon.

  • next()— Renvoie le résultat suivant. Lance NoSuchElementException si aucun résultat n'existe.

  • next(n)— Renvoie les n résultats suivants sous forme de liste.

  • toList()— Renvoie tous les résultats sous forme de liste. Renvoie une liste vide si aucun résultat n'existe.

  • toSet()— Renvoie tous les résultats sous forme d'ensemble. Renvoie un ensemble vide s'il n'existe aucun résultat.

  • iterate()— Réitère tous les résultats sans les renvoyer. Utilisez-le pour les mutations pour lesquelles vous n'avez pas besoin de la valeur de retour.

Note

Les GLV linguistiques individuelles peuvent prévoir des étapes terminales supplémentaires spécifiques à leur mise en œuvre. Consultez les pages spécifiques à chaque langue pour plus de détails.

Si vous développez et testez votre code dans un contexte donné, vous pouvez rencontrer des problèmes. Par exemple, la console Gremlin envoie des requêtes sous forme de scripts. Votre code peut se comporter différemment en production si vous le déployez dans un contexte différent, par exemple via le pilote Java à l'aide d'un bytecode.

Important

Assurez-vous de tester le code Gremlin en utilisant le même mode de soumission que celui dans lequel il sera déployé, afin d'éviter tout comportement de transaction inattendu.