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.
# Accès au graphe Neptune avec Gremlin
/binaries/apache-maven--bin.tar.gz
sudo tar -xzf apache-maven--bin.tar.gz -C /opt/
sudo ln -sf /opt/apache-maven- /opt/maven
echo 'export MAVEN_HOME=/opt/maven' >> ~/.bashrc
echo 'export PATH=$MAVEN_HOME/bin:$PATH' >> ~/.bashrc
source ~/.bashrc
```
1. **Installez Java.** Les bibliothèques Gremlin nécessitent Java 8 ou 11. Vous pouvez installer Java 11 comme suit :
+ Si vous utilisez [Amazon Linux 2 (AL2)](https://aws.amazon.com/amazon-linux-2) :
```
sudo amazon-linux-extras install java-openjdk11
```
+ Si vous utilisez [Amazon Linux 2023 (AL2023)](https://docs.aws.amazon.com/linux/al2023/ug/what-is-amazon-linux.html) :
```
sudo yum install java-11-amazon-corretto-devel
```
+ Pour les autres distributions, utilisez l'instruction qui convient le mieux parmi les suivantes :
```
sudo yum install java-11-openjdk-devel
```
ou :
```
sudo apt-get install openjdk-11-jdk
```
1. **Définissez Java 11 comme environnement d'exécution par défaut sur votre instance EC2 :** entrez ce qui suit pour définir Java 8 comme environnement d'exécution par défaut sur l'instance EC2 :
```
sudo /usr/sbin/alternatives --config java
```
Lorsque vous y êtes invité, saisissez le nombre correspondant à Java 11.
1. **Créez un répertoire appelé `gremlinjava` :**
```
mkdir gremlinjava
cd gremlinjava
```
1. Dans le répertoire `gremlinjava`, créez un fichier `pom.xml`, puis ouvrez-le dans un éditeur de texte:
```
nano pom.xml
```
1. Copiez ce qui suit dans le fichier `pom.xml` et enregistrez-le:
```
UTF-8
4.0.0
com.amazonaws
GremlinExample
jar
1.0-SNAPSHOT
GremlinExample
https://maven.apache.org
org.apache.tinkerpop
gremlin-driver
3.7.2
org.slf4j
slf4j-jdk14
1.7.25
org.apache.maven.plugins
maven-compiler-plugin
2.5.1
11
11
org.codehaus.mojo
exec-maven-plugin
1.3
java
-classpath
com.amazonaws.App
com.amazonaws.App
1.11
-1
```
**Note**
Si vous modifiez un projet Maven existant, la dépendance obligatoire est mise en évidence dans le code précédent.
1. Créez des sous-répertoires pour l'exemple de code source (`src/main/java/com/amazonaws/`) en saisissant ce qui suit sur la ligne de commande :
```
mkdir -p src/main/java/com/amazonaws/
```
1. Dans le répertoire `src/main/java/com/amazonaws/`, créez un fichier `App.java`, puis ouvrez-le dans un éditeur de texte.
```
nano src/main/java/com/amazonaws/App.java
```
1. Copiez ce qui suit dans le fichier `App.java`. Remplacez *your-neptune-endpoint* par l'adresse de votre instance de base de données Neptune. N’incluez *pas* le préfixe `https://` dans la méthode `addContactPoint`.
**Note**
Pour découvrir comment trouver le nom d'hôte de l'instance de base de données Neptune, consultez la section [Connexion aux points de terminaison Amazon Neptune](feature-overview-endpoints.md).
```
package com.amazonaws;
import org.apache.tinkerpop.gremlin.driver.Cluster;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversalSource;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal;
import static org.apache.tinkerpop.gremlin.process.traversal.AnonymousTraversalSource.traversal;
import org.apache.tinkerpop.gremlin.driver.remote.DriverRemoteConnection;
import org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.__;
import org.apache.tinkerpop.gremlin.structure.T;
public class App
{
public static void main( String[] args )
{
Cluster.Builder builder = Cluster.build();
builder.addContactPoint("your-neptune-endpoint");
builder.port(8182);
builder.enableSsl(true);
Cluster cluster = builder.create();
GraphTraversalSource g = traversal().withRemote(DriverRemoteConnection.using(cluster));
// Add a vertex.
// Note that a Gremlin terminal step, e.g. iterate(), is required to make a request to the remote server.
// The full list of Gremlin terminal steps is at https://tinkerpop.apache.org/docs/current/reference/#terminal-steps
g.addV("Person").property("Name", "Justin").iterate();
// Add a vertex with a user-supplied ID.
g.addV("Custom Label").property(T.id, "CustomId1").property("name", "Custom id vertex 1").iterate();
g.addV("Custom Label").property(T.id, "CustomId2").property("name", "Custom id vertex 2").iterate();
g.addE("Edge Label").from(__.V("CustomId1")).to(__.V("CustomId2")).iterate();
// This gets the vertices, only.
GraphTraversal t = g.V().limit(3).elementMap();
t.forEachRemaining(
e -> System.out.println(t.toList())
);
cluster.close();
}
}
```
Pour obtenir de l'aide sur la connexion à Neptune avec SSL/TLS (obligatoire), consultez. [Configuration SSL/TLS](#access-graph-gremlin-java-ssl)
1. Compilez et exécutez l'exemple à l'aide de la commande Maven suivante :
```
mvn compile exec:exec
```
L'exemple précédent renvoie une carte de la clé et les valeurs de chaque propriété pour les deux premiers vertex du graphe à l'aide de la traversée `g.V().limit(3).elementMap()`. Pour interroger quelque chose d'autre, remplacez la traversée par une autre traversée Gremlin avec l'une des méthodes de fin appropriées.
**Note**
La partie finale de la requête Gremlin, `.toList()`, est obligatoire pour soumettre la traversée au serveur à des fins d'évaluation. Si vous n'incluez pas cette méthode ou une autre méthode équivalente, la requête ne sera pas soumise à l'instance de base de données Neptune.
Vous devez également ajouter une terminaison appropriée lorsque vous ajoutez un sommet ou une arête, comme lorsque vous utilisez l'étape `addV( )`.
Les méthodes suivantes soumettent la requête à l'instance de base de données Neptune :
+ `toList()`
+ `toSet()`
+ `next()`
+ `nextTraverser()`
+ `iterate()`
## Configuration SSL/TLS pour le client Java Gremlin
org.apache.tinkerpop
gremlin-driver
${gremlin.version}
com.amazonaws
amazon-neptune-sigv4-signer
${sig4.signer.version}
com.evanlennick
retry4j
0.15.0
```
Voici l'exemple de code :
**Important**
Le `CallExecutor` de Retry4j n'est peut-être pas thread-safe. Envisagez de demander à chaque thread d'utiliser sa propre `CallExecutor` instance ou d'utiliser une bibliothèque de nouvelles tentatives différente.
**Note**
L'exemple suivant a été mis à jour pour inclure l'utilisation de RequestInterceptor (). Cela a été ajouté dans la version TinkerPop 3.6.6. Avant la TinkerPop version 3.6.6, l'exemple de code utilisait HandshakeInterceptor (), qui était obsolète avec cette version.
```
public static void main(String args[]) {
boolean useIam = true;
// Create Gremlin cluster and traversal source
Cluster.Builder builder = Cluster.build()
.addContactPoint(System.getenv("neptuneEndpoint"))
.port(Integer.parseInt(System.getenv("neptunePort")))
.enableSsl(true)
.minConnectionPoolSize(1)
.maxConnectionPoolSize(1)
.serializer(Serializers.GRAPHBINARY_V1D0)
.reconnectInterval(2000);
if (useIam) {
builder.requestInterceptor( r -> {
try {
NeptuneNettyHttpSigV4Signer sigV4Signer =
new NeptuneNettyHttpSigV4Signer("(your region)", new DefaultAWSCredentialsProviderChain());
sigV4Signer.signRequest(r);
} catch (NeptuneSigV4SignerException e) {
throw new RuntimeException("Exception occurred while signing the request", e);
}
return r;
});
}
Cluster cluster = builder.create();
GraphTraversalSource g = AnonymousTraversalSource
.traversal()
.withRemote(DriverRemoteConnection.using(cluster));
// Configure retries
RetryConfig retryConfig = new RetryConfigBuilder()
.retryOnCustomExceptionLogic(getRetryLogic())
.withDelayBetweenTries(1000, ChronoUnit.MILLIS)
.withMaxNumberOfTries(5)
.withFixedBackoff()
.build();
@SuppressWarnings("unchecked")
CallExecutor retryExecutor = new CallExecutorBuilder()
.config(retryConfig)
.build();
// Do lots of queries
for (int i = 0; i < 100; i++){
String id = String.valueOf(i);
@SuppressWarnings("unchecked")
Callable query = () -> g.V(id)
.fold()
.coalesce(
unfold(),
addV("Person").property(T.id, id))
.id().next();
// Retry query
// If there are connection failures, the Java Gremlin client will automatically
// attempt to reconnect in the background, so all we have to do is wait and retry.
Status status = retryExecutor.execute(query);
System.out.println(status.getResult().toString());
}
cluster.close();
}
private static Function getRetryLogic() {
return e -> {
Class exceptionClass = e.getClass();
StringWriter stringWriter = new StringWriter();
String message = stringWriter.toString();
if (RemoteConnectionException.class.isAssignableFrom(exceptionClass)){
System.out.println("Retrying because RemoteConnectionException");
return true;
}
// Check for connection issues
if (message.contains("Timed out while waiting for an available host") ||
message.contains("Timed-out") && message.contains("waiting for connection on Host") ||
message.contains("Connection to server is no longer active") ||
message.contains("Connection reset by peer") ||
message.contains("SSLEngine closed already") ||
message.contains("Pool is shutdown") ||
message.contains("ExtendedClosedChannelException") ||
message.contains("Broken pipe") ||
message.contains(System.getenv("neptuneEndpoint")))
{
System.out.println("Retrying because connection issue");
return true;
};
// Concurrent writes can sometimes trigger a ConcurrentModificationException.
// In these circumstances you may want to backoff and retry.
if (message.contains("ConcurrentModificationException")) {
System.out.println("Retrying because ConcurrentModificationException");
return true;
}
// If the primary fails over to a new instance, existing connections to the old primary will
// throw a ReadOnlyViolationException. You may want to back and retry.
if (message.contains("ReadOnlyViolationException")) {
System.out.println("Retrying because ReadOnlyViolationException");
return true;
}
System.out.println("Not a retriable error");
return false;
};
}
```
# Utilisation de Python pour se connecter à une instance de base de données Neptune
(3).ToList();
foreach(var item in output) {
Console.WriteLine(item);
}
}
catch (Exception e)
{
Console.WriteLine("{0}", e);
}
}
}
}
```
1. Pour exécuter l'exemple, entrez la commande suivante :
```
dotnet run
```
La requête Gremlin à la fin de cet exemple renvoie le nombre d'un seul vertex à des fins de test. Elle est ensuite imprimée sur la console.
**Note**
La partie finale de la requête Gremlin, `Next()`, est obligatoire pour soumettre la traversée au serveur à des fins d'évaluation. Si vous n'incluez pas cette méthode ou une autre méthode équivalente, la requête ne sera pas soumise à l'instance de base de données Neptune.
Les méthodes suivantes soumettent la requête à l'instance de base de données Neptune :
+ `ToList()`
+ `ToSet()`
+ `Next()`
+ `NextTraverser()`
+ `Iterate()`
Utilisez `Next()` si vous avez besoin que les résultats de la requête soient sérialisés et renvoyés, ou `Iterate()` dans le cas contraire.
L'exemple précédent renvoie une liste à l'aide de la traversée `g.V().Limit(3).ToList()`. Pour interroger quelque chose d'autre, remplacez la traversée par une autre traversée Gremlin avec l'une des méthodes de fin appropriées.
## Authentification IAM
).out().out().out().out().out().out().out().out().out().out().limit(1).path()
```
**Important**
Le moteur de requête Neptune ne procède pas ainsi automatiquement.
Breadth-first (`BFS`) est la stratégie d'exécution par défaut et est similaire TinkerGraph dans la plupart des cas. Cependant, il y a certains cas où les stratégies en profondeur en premier (`DFS`) sont préférables.
**BFS (valeur par défaut)**
BFS (dans la largeur en premier) est la stratégie d'exécution par défaut pour l'opérateur `repeat()`.
```
g.V("3").repeat(out()).times(10).limit(1).path()
```
Le moteur Neptune explore entièrement les premières frontières à neuf tronçons avant de rechercher une solution à partir du dixième tronçon. Cette approche est efficace dans de nombreux cas, notamment dans celui d'une requête au chemin le plus court.
Cependant, dans l'exemple précédent, le parcours serait beaucoup plus rapide à l'aide du mode profondeur en premier (`DFS`) pour l'opérateur `repeat()`.
**DFS**
La requête suivante utilise le mode `DFS` (profondeur en premier) pour l'opérateur `repeat()`.
```
g.withSideEffect("Neptune#repeatMode", "DFS").V("3").repeat(out()).times(10).limit(1)
```
Ce mode suit chaque solution jusqu'à la profondeur maximale avant d'explorer la solution suivante.
# Indicateur de requête Gremlin noReordering
<~label> <~>) .]
```
## Instructions d'arc Gremlin
) .]
```
## Instructions de propriété Gremlin
"John" <~>) .]
```
Les instructions de propriété diffèrent des autres en ce sens que leur objet est une valeur primitive (`string`, `date`, `byte`, `short`, `int`, `long`, `float` ou `double`). Leur objet n'est pas un identifiant de ressource pouvant être utilisé comme sujet d'une autre assertion.
Dans le cas de propriétés multiples, chaque valeur de propriété individuelle de l'ensemble reçoit sa propre instruction.
```
g.V("v1").property(set, "phone", "956-424-2563").property(set, "phone", "956-354-3692 (tel:9563543692)")
```
La sortie obtenue est la suivante.
```
StatementEvent[Added( "956-424-2563" <~>) .]
StatementEvent[Added( "956-354-3692" <~>) .]
```
Les propriétés des arêtes sont gérées de la même manière que les propriétés des sommets, mais elles utilisent l'identifiant de bord en position (S). Par exemple, ajouter une propriété à une arête :
```
g.E("e1").property("weight", 0.8)
```
Cela entraîne l'ajout de l'instruction suivante au graphique.
```
StatementEvent[Added( 0.8 <~>) .]
```
# Comment Neptune traite les requêtes Gremlin à l'aide d'index d'instruction
, <~label>, ?, ?)
Known positions: SP
Lookup positions: OG
Index: SPOG
Key range: :<~label>:*
```
**Question : Quelles sont les arêtes sortantes « knows » du sommet `v1` ?**
```
Gremlin code: g.V('v1').out('knows')
Pattern: (, , ?, ?)
Known positions: SP
Lookup positions: OG
Index: SPOG
Key range: ::*
```
**Question : Quels sont les sommets qui ont une étiquette de sommet `Person` ?**
```
Gremlin code: g.V().hasLabel('Person')
Pattern: (?, <~label>, , <~>)
Known positions: POG
Lookup positions: S
Index: POGS
Key range: <~label>::<~>:*
```
**Question : Quels sont les from/to sommets d'une arête donnée ? `e1`**
```
Gremlin code: g.E('e1').bothV()
Pattern: (?, ?, ?, )
Known positions: G
Lookup positions: SPO
Index: GPSO
Key range: :*
```
Neptune **ne possède pas** d'index de déclarations tel qu'un index OSGP de traversée inverse. Ce type d'index peut être utilisé pour collecter toutes les arêtes entrantes sur toutes les étiquettes d'arête, comme dans l'exemple suivant.
**Question : Quels sont les sommets adjacents entrants `v1` ?**
```
Gremlin code: g.V('v1').in()
Pattern: (?, ?, , ?)
Known positions: O
Lookup positions: SPG
Index: OSGP // <-- Index does not exist
```
# Traitement des requêtes Gremlin dans Neptune
, , ?2, ?) X Pattern(?2, , ?3, ?)
The pattern produces a three-column relation (?1, ?2, ?3) like this:
?1 ?2 ?3
================
v1 v2 v3
v1 v2 v4
v1 v5 v6
```
En partageant la variable `?2` entre les deux modèles (à la position O dans le premier modèle et à la position S dans le second modèle), vous créez une jointure entre les voisins à un premier saut et les voisins à deux sauts. Chaque solution Neptune possède des liaisons pour les trois variables nommées, qui peuvent être utilisées pour recréer un [TinkerPopTraverser](http://tinkerpop.apache.org/docs/current/reference/#_the_traverser) (y compris les informations de chemin).
```
```
[La première étape du traitement des requêtes Gkremlin consiste à analyser la requête pour en faire un objet TinkerPop [Traversal](http://tinkerpop.apache.org/docs/current/reference/#traversal), composé d'une série d'étapes. TinkerPop ](http://tinkerpop.apache.org/docs/current/reference/#graph-traversal-steps) Ces étapes, qui font partie du [ TinkerPop projet open source Apache](http://tinkerpop.apache.org/), sont à la fois les opérateurs logiques et physiques qui composent une traversée Gremlin dans l'implémentation de référence. Elles sont toutes deux utilisées pour représenter le modèle de la requête. Il s'agit d'opérateurs exécutables qui peuvent produire des solutions en fonction de la sémantique de l'opérateur qu'ils représentent. Par exemple, `.V()` est à la fois représenté et exécuté par le TinkerPop [GraphStep](http://tinkerpop.apache.org/docs/current/reference/#graph-step).
Ces off-the-shelf TinkerPop étapes étant exécutables, un tel TinkerPop Traversal peut exécuter n'importe quelle requête Gremlin et produire la bonne réponse. Cependant, lorsqu'elles sont exécutées sur un graphique de grande taille, TinkerPop les étapes peuvent parfois être très inefficaces et lentes. Au lieu de les utiliser, Neptune essaie alors de convertir la traversée en forme déclarative composée de groupes de modèles, comme décrit précédemment.
Neptune ne prend actuellement pas en charge tous les opérateurs Gremlin (étapes) dans son moteur de requête natif. Il essaie donc de réduire autant d'étapes que possible en une seule étape `NeptuneGraphQueryStep`, qui contient le plan de requête logique déclaratif pour toutes les étapes qui ont été converties. Idéalement, toutes les étapes sont converties. Mais lorsqu'une étape ne peut pas être convertie, Neptune sort de l'exécution native et reporte l'exécution de toutes les requêtes à partir de ce point jusqu'aux étapes. TinkerPop Il n'essaie pas de jongler avec et sans l'exécution native.
Une fois que les étapes sont converties en plan de requête logique, Neptune exécute une série d'optimiseurs de requête qui réécrivent le plan de requête en fonction de l'analyse statique et des cardinalités estimées. Ces optimiseurs effectuent des opérations telles que la réorganisation des opérateurs en fonction du nombre de plages, la suppression des opérateurs superflus ou redondants, la réorganisation des filtres, le transfert des opérateurs dans différents groupes, etc.
Une fois qu'un plan de requête optimisé est généré, Neptune crée un pipeline d'opérateurs physiques qui effectuent le travail d'exécution de la requête. Cela inclut la lecture des données à partir des index d'instruction, l'exécution de jointures de différents types, le filtrage, l'organisation, etc. Le pipeline produit un flux de solution qui est ensuite reconverti en un flux d'objets TinkerPop Traverser.
## Sérialisation des résultats de requête
, ?2, ) . project DISTINCT[?1] {rangeCountEstimate=unknown}],
DFEPatternNode[(?1, ?3, ?4, ?5) . project ALL[?1, ?4] graphFilters=(!= . ), {rangeCountEstimate=unknown}]
}, {rangeCountEstimate=unknown}
]
} [Vertex(?1):GraphStep@[a], Vertex(?4):VertexStep]
} ,
NeptuneTraverserConverterDFEStep
]
+ not converted into Neptune steps: HasStep([name.eq(josh)]),
Neptune steps:
[
NeptuneInterleavingStep {
StepInfo[joinVars=[?7, ?1], frontierElement=Vertex(?7):HasStep, pathElements={a=(last,Vertex(?1):GraphStep@[a])}, listPathElement={}, indexTime=0ms],
DFEStep(Vertex) {
DFENode {
DFEJoinGroupNode[ children={
DFEPatternNode[(?7, ?8, ?9, ?10) . project ALL[?7, ?9] graphFilters=(!= . ), {rangeCountEstimate=unknown}],
DFEPatternNode[(?12, ?11, ?9, ?13) . project ALL[?9, ?12] graphFilters=(!= . ), {rangeCountEstimate=unknown}]
}, {rangeCountEstimate=unknown}
]
} [Vertex(?9):VertexStep, Vertex(?12):VertexStep]
}
}
]
+ not converted into Neptune steps: WherePredicateStep(eq(a)),
Neptune steps:
[
DFECleanupStep
]
Optimized Traversal
===================
Neptune steps:
[
DFEStep(Vertex) {
DFENode {
DFEJoinGroupNode[ children={
DFEPatternNode[(?1, ?3, ?4, ?5) . project ALL[?1, ?4] graphFilters=(!= defaultGraph[526] . ), {rangeCountEstimate=9223372036854775807}]
}, {rangeCountEstimate=unknown}
]
} [Vertex(?1):GraphStep@[a], Vertex(?4):VertexStep]
} ,
NeptuneTraverserConverterDFEStep
]
+ not converted into Neptune steps: NeptuneHasStep([name.eq(josh)]),
Neptune steps:
[
NeptuneMemoryTrackerStep,
NeptuneInterleavingStep {
StepInfo[joinVars=[?7, ?1], frontierElement=Vertex(?7):HasStep, pathElements={a=(last,Vertex(?1):GraphStep@[a])}, listPathElement={}, indexTime=0ms],
DFEStep(Vertex) {
DFENode {
DFEJoinGroupNode[ children={
DFEPatternNode[(?7, ?8, ?9, ?10) . project ALL[?7, ?9] graphFilters=(!= defaultGraph[526] . ), {rangeCountEstimate=9223372036854775807}],
DFEPatternNode[(?12, ?11, ?9, ?13) . project ALL[?9, ?12] graphFilters=(!= defaultGraph[526] . ), {rangeCountEstimate=9223372036854775807}]
}, {rangeCountEstimate=unknown}
]
} [Vertex(?9):VertexStep, Vertex(?12):VertexStep]
}
}
]
+ not converted into Neptune steps: WherePredicateStep(eq(a)),
Neptune steps:
[
DFECleanupStep
]
WARNING: >> [NeptuneHasStep([name.eq(josh)]), WherePredicateStep(eq(a))] << (or one of the children for each step) is not supported natively yet
Predicates
==========
# of predicates: 8
```
Consultez [Informations dans `explain`](#gremlin-explain-api-results) pour voir une description des sections spécifiques au DFE dans le rapport.
# API Gremlin `profile` dans Neptune
`.
Si la valeur du paramètre est différente de null, les résultats collectés sont renvoyés dans un message de réponse sérialisé au format spécifié par ce paramètre. Le nombre d'opérations d'index nécessaires pour générer ce message de réponse est signalé, ainsi que la taille en octets à envoyer au client.
Les valeurs autorisées sont `` ou n'importe laquelle des valeurs d'énumération valides du type MIME ou TinkerPop du pilote « Serializers ».
```
"application/json" or "GRAPHSON"
"application/vnd.gremlin-v1.0+json" or "GRAPHSON_V1"
"application/vnd.gremlin-v1.0+json;types=false" or "GRAPHSON_V1_UNTYPED"
"application/vnd.gremlin-v2.0+json" or "GRAPHSON_V2"
"application/vnd.gremlin-v2.0+json;types=false" or "GRAPHSON_V2_UNTYPED"
"application/vnd.gremlin-v3.0+json" or "GRAPHSON_V3"
"application/vnd.gremlin-v3.0+json;types=false" or "GRAPHSON_V3_UNTYPED"
"application/vnd.graphbinary-v1.0" or "GRAPHBINARY_V1"
```
+ **profile.indexOps** – `boolean`, valeurs autorisées : `TRUE` et `FALSE`, valeur par défaut : `FALSE`.
Si ce paramètre a la valeur true, il affiche un rapport détaillé de toutes les opérations d'index qui ont eu lieu au cours de l'exécution et de la sérialisation des requêtes. Avertissement : ce rapport peut être très détaillé.
## Exemple de sortie de Neptune Gremlin `profile`
, "AUS", ?) . project ?1 .], {estimatedCardinality=1, indexTime=84, hashJoin=true, joinTime=3, actualTotalOutput=1}
PatternNode[(?1, <~label>, ?2=, <~>) . project ask .], {estimatedCardinality=3374, indexTime=29, hashJoin=true, joinTime=0, actualTotalOutput=61}
RepeatNode {
Repeat {
PatternNode[(?3, ?5, ?1, ?6) . project ?1,?3 . IsEdgeIdFilter(?6) . SimplePathFilter(?1, ?3)) .], {hashJoin=true, estimatedCardinality=50148, indexTime=0, joinTime=3}
}
Emit {
Filter(true)
}
LoopsCondition {
LoopsFilter([?1, ?3],eq(2))
}
}, annotations={repeatMode=BFS, emitFirst=true, untilFirst=false, leftVar=?1, rightVar=?3}
}, finishers=[limit(100)], annotations={path=[Vertex(?1):GraphStep, Repeat[Vertex(?3):VertexStep]], joinStats=true, optimizationTime=495, maxVarId=7, executionTime=323}
},
NeptuneTraverserConverterStep
]
Physical Pipeline
=================
NeptuneGraphQueryStep
|-- StartOp
|-- JoinGroupOp
|-- SpoolerOp(100)
|-- DynamicJoinOp(PatternNode[(?1, , "AUS", ?) . project ?1 .], {estimatedCardinality=1, indexTime=84, hashJoin=true})
|-- SpoolerOp(100)
|-- DynamicJoinOp(PatternNode[(?1, <~label>, ?2=, <~>) . project ask .], {estimatedCardinality=3374, indexTime=29, hashJoin=true})
|-- RepeatOp
|-- (Iteration 0) [visited=1, output=1 (until=0, emit=1), next=1]
|-- BindingSetQueue (Iteration 1) [visited=61, output=61 (until=0, emit=61), next=61]
|-- SpoolerOp(100)
|-- DynamicJoinOp(PatternNode[(?3, ?5, ?1, ?6) . project ?1,?3 . IsEdgeIdFilter(?6) . SimplePathFilter(?1, ?3)) .], {hashJoin=true, estimatedCardinality=50148, indexTime=0})
|-- BindingSetQueue (Iteration 2) [visited=38, output=38 (until=38, emit=0), next=0]
|-- SpoolerOp(100)
|-- DynamicJoinOp(PatternNode[(?3, ?5, ?1, ?6) . project ?1,?3 . IsEdgeIdFilter(?6) . SimplePathFilter(?1, ?3)) .], {hashJoin=true, estimatedCardinality=50148, indexTime=0})
|-- LimitOp(100)
Runtime (ms)
============
Query Execution: 392.686
Serialization: 2636.380
Traversal Metrics
=================
Step Count Traversers Time (ms) % Dur
-------------------------------------------------------------------------------------------------------------
NeptuneGraphQueryStep(Vertex) 100 100 314.162 82.78
NeptuneTraverserConverterStep 100 100 65.333 17.22
>TOTAL - - 379.495 -
Repeat Metrics
==============
Iteration Visited Output Until Emit Next
------------------------------------------------------
0 1 1 0 1 1
1 61 61 0 61 61
2 38 38 38 0 0
------------------------------------------------------
100 100 38 62 62
Predicates
==========
# of predicates: 16
WARNING: reverse traversal with no edge label(s) - .in() / .both() may impact query performance
Results
=======
Count: 100
Output: [v[3], v[3600], v[3614], v[4], v[5], v[6], v[7], v[8], v[9], v[10], v[11], v[12], v[47], v[49], v[136], v[13], v[15], v[16], v[17], v[18], v[389], v[20], v[21], v[22], v[23], v[24], v[25], v[26], v[27], v[28], v[416], v[29], v[30], v[430], v[31], v[9...
Response serializer: GRYO_V3D0
Response size (bytes): 23566
Index Operations
================
Query execution:
# of statement index ops: 3
# of unique statement index ops: 3
Duplication ratio: 1.0
# of terms materialized: 0
Serialization:
# of statement index ops: 200
# of unique statement index ops: 140
Duplication ratio: 1.43
# of terms materialized: 393
```
Outre les plans de requête renvoyés par un appel à Neptune `explain`, les résultats de la requête `profile` incluent des statistiques sur l'exécution des requêtes. Chaque opération de jointure est balisée avec le temps nécessaire à l'exécution de sa jointure, ainsi que le nombre réel de solutions qui lui ont été transmises.
La sortie de `profile` inclut le temps nécessaire à la phase d'exécution de la requête principale, ainsi qu'à la phase de sérialisation si l'option `profile.serializer` a été spécifiée.
La répartition des opérations d'index effectuées au cours de chaque phase est également incluse au bas de la sortie `profile`.
Notez que les exécutions consécutives d'une même requête peuvent afficher des résultats différents en termes d'opérations d'exécution et d'index en raison de la mise en cache.
Pour les requêtes utilisant l'étape `repeat()`, une répartition de la frontière sur chaque itération est disponible si l'étape `repeat()` a été réduite et intégrée dans une étape `NeptuneGraphQueryStep`.
## Différences entre les rapports `profile` lorsque le DFE est activé
, "ANC", ?) . project ask .]
PatternNode[(?3, ?5, ?1, ?6) . project ?1,?3 . IsEdgeIdFilter(?6) .]
PatternNode[(?3, <~label>, ?4, <~>) . project ask .]
PatternNode[(?3, ?7, ?8, <~>) . project ?3,?8 . ContainsFilter(?7 in ()) .]
}, annotations={path=[Vertex(?1):GraphStep, Vertex(?3):VertexStep, PropertyValue(?8):PropertiesStep], maxVarId=9}
},
NeptuneTraverserConverterStep
]
Optimized Traversal
===================
Neptune steps:
[
NeptuneGraphQueryStep(PropertyValue) {
JoinGroupNode {
PatternNode[(?1, , "ANC", ?) . project ?1 .], {estimatedCardinality=1}
PatternNode[(?3, ?5, ?1, ?6) . project ?1,?3 . IsEdgeIdFilter(?6) .], {estimatedCardinality=INFINITY}
PatternNode[(?3, ?7=, ?8, <~>) . project ?3,?8 .], {estimatedCardinality=7564}
}, annotations={path=[Vertex(?1):GraphStep, Vertex(?3):VertexStep, PropertyValue(?8):PropertiesStep], maxVarId=9}
},
NeptuneTraverserConverterStep
]
Predicates
==========
# of predicates: 26
WARNING: reverse traversal with no edge label(s) - .in() / .both() may impact query performance
```
Le message `WARNING` au bas de la sortie apparaît parce que l'étape `in()` de la traversée ne peut pas être gérée à l'aide de l'un des trois index gérés par Neptune (voir [Comment les instructions sont indexées dans Neptune](feature-overview-storage-indexing.md) et [Déclarations Gremlin dans Neptune](gremlin-explain-background-statements.md)). Comme l'étape `in()` ne contient aucun filtre d'arête, elle ne peut pas être résolue à l'aide de l'index `SPOG`, `POGS` ou `GPSO`. À la place, Neptune doit effectuer une analyse d'union pour trouver les sommets demandés, ce qui est beaucoup moins efficace.
Dans cette situation, vous pouvez ajuster la traversée de deux façons. La première consiste à ajouter un ou plusieurs critères de filtrage à l'étape `in()` afin qu'une recherche indexée puisse être utilisée pour résoudre la requête. Concernant l'exemple ci-dessus, cela peut être :
```
g.V().has('code','ANC').in('route').values('code')
```
La sortie de l'API Neptune `explain` pour la traversée révisée ne contient plus le message `WARNING` :
```
*******************************************************
Neptune Gremlin Explain
*******************************************************
Query String
============
g.V().has('code','ANC').in('route').values('code')
Original Traversal
==================
[GraphStep(vertex,[]), HasStep([code.eq(ANC)]), VertexStep(IN,[route],vertex), PropertiesStep([code],value)]
Converted Traversal
===================
Neptune steps:
[
NeptuneGraphQueryStep(PropertyValue) {
JoinGroupNode {
PatternNode[(?1, <~label>, ?2, <~>) . project distinct ?1 .]
PatternNode[(?1, , "ANC", ?) . project ask .]
PatternNode[(?3, ?5, ?1, ?6) . project ?1,?3 . IsEdgeIdFilter(?6) . ContainsFilter(?5 in ()) .]
PatternNode[(?3, <~label>, ?4, <~>) . project ask .]
PatternNode[(?3, ?7, ?8, <~>) . project ?3,?8 . ContainsFilter(?7 in ()) .]
}, annotations={path=[Vertex(?1):GraphStep, Vertex(?3):VertexStep, PropertyValue(?8):PropertiesStep], maxVarId=9}
},
NeptuneTraverserConverterStep
]
Optimized Traversal
===================
Neptune steps:
[
NeptuneGraphQueryStep(PropertyValue) {
JoinGroupNode {
PatternNode[(?1, , "ANC", ?) . project ?1 .], {estimatedCardinality=1}
PatternNode[(?3, ?5=, ?1, ?6) . project ?1,?3 . IsEdgeIdFilter(?6) .], {estimatedCardinality=32042}
PatternNode[(?3, ?7=, ?8, <~>) . project ?3,?8 .], {estimatedCardinality=7564}
}, annotations={path=[Vertex(?1):GraphStep, Vertex(?3):VertexStep, PropertyValue(?8):PropertiesStep], maxVarId=9}
},
NeptuneTraverserConverterStep
]
Predicates
==========
# of predicates: 26
```
Si vous exécutez de nombreuses traversées de ce type, vous pouvez également les exécuter dans un cluster de bases de données Neptune dont l'index `OSGP` facultatif est activé (voir [Activation d'un index OSGP](feature-overview-storage-indexing.md#feature-overview-storage-indexing-osgp)). L'activation d'un index `OSGP` présente des inconvénients :
+ Elle doit être activée dans un cluster de bases de données avant tout chargement de données.
+ Les taux d'insertion des sommets et des arêtes peuvent ralentir de jusqu'à 23 %.
+ L'utilisation du stockage augmente d'environ 20 %.
+ Les requêtes de lecture qui répartissent les demandes sur tous les index peuvent accroître les temps de latence.
L'utilisation d'un index `OSGP` est tout à fait justifiée pour un ensemble restreint de modèles de requêtes, mais à moins que vous ne les exécutiez fréquemment, il est généralement préférable de faire en sorte que les traversées que vous écrivez puissent être résolues à l'aide des trois index principaux.
### Utilisation d'un grand nombre de prédicats