Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.
# Mengakses grafik Neptune dengan 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. **Instal Java.** Perpustakaan Gremlin membutuhkan Java 8 atau 11. Anda dapat menginstal Java 11 sebagai berikut:
+ Jika Anda menggunakan [Amazon Linux 2 (AL2)](https://aws.amazon.com/amazon-linux-2):
```
sudo amazon-linux-extras install java-openjdk11
```
+ Jika Anda menggunakan [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
```
+ Untuk distribusi lain, gunakan salah satu dari berikut ini yang sesuai:
```
sudo yum install java-11-openjdk-devel
```
atau:
```
sudo apt-get install openjdk-11-jdk
```
1. **Setel Java 11 sebagai runtime default pada instans EC2 Anda:** Masukkan yang berikut ini untuk menetapkan Java 8 sebagai runtime default pada instans EC2 Anda:
```
sudo /usr/sbin/alternatives --config java
```
Saat diminta, masukkan nomor untuk Java 11.
1. **Buat direktori baru bernama`gremlinjava`:**
```
mkdir gremlinjava
cd gremlinjava
```
1. Di direktori `gremlinjava`, buat file `pom.xml`, lalu buka file tersebut dalam editor teks:
```
nano pom.xml
```
1. Salin JSON berikut ke dalam file `pom.xml` dan simpan filenya:
```
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
```
**catatan**
Jika Anda memodifikasi proyek Maven yang ada, dependensi yang diperlukan disorot dalam kode sebelumnya.
1. Buat subdirektori untuk kode sumber contoh (`src/main/java/com/amazonaws/`) dengan mengetik teks berikut pada baris perintah:
```
mkdir -p src/main/java/com/amazonaws/
```
1. Di direktori `src/main/java/com/amazonaws/`, buat file bernama `App.java`, lalu buka file tersebut dalam editor teks.
```
nano src/main/java/com/amazonaws/App.java
```
1. Salin hal berikut ke dalam file `App.java`. Ganti *your-neptune-endpoint* dengan alamat instans DB Neptunus Anda. *Jangan* sertakan prefiks `https://` di metode `addContactPoint`.
**catatan**
Untuk informasi tentang menemukan nama host instans DB Neptune Anda, lihat [Menghubungkan ke Titik Akhir 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();
}
}
```
Untuk bantuan menghubungkan ke Neptunus SSL/TLS dengan (yang diperlukan), lihat. [Konfigurasi SSL/TLS](#access-graph-gremlin-java-ssl)
1. Kompilasikan dan jalankan sampel menggunakan perintah Maven berikut:
```
mvn compile exec:exec
```
Contoh sebelumnya mengembalikan peta kunci dan nilai-nilai masing-masing properti untuk dua vertex pertama dalam grafik menggunakan traversal `g.V().limit(3).elementMap()`. Untuk mengajukan kueri untuk sesuatu yang lain, ganti dengan traversal Gremlin lain dengan salah satu metode ending yang tepat.
**catatan**
Bagian akhir dari kueri Gremlin, `.toList()`, diperlukan untuk mengirimkan traversal ke server untuk evaluasi. Jika Anda tidak menyertakan metode tersebut atau metode setara lain, kueri tidak diserahkan ke instans DB Neptune.
Anda juga harus menambahkan ending yang tepat ketika Anda menambahkan sebuah vertex atau edge, seperti ketika Anda menggunakan langkah `addV( )`.
Metode berikut mengirimkan kueri ke instans DB Neptune:
+ `toList()`
+ `toSet()`
+ `next()`
+ `nextTraverser()`
+ `iterate()`
## Konfigurasi SSL/TLS untuk klien Gremlin Java
org.apache.tinkerpop
gremlin-driver
${gremlin.version}
com.amazonaws
amazon-neptune-sigv4-signer
${sig4.signer.version}
com.evanlennick
retry4j
0.15.0
```
Berikut adalah kode sampelnya:
**penting**
`CallExecutor`Dari Retry4j mungkin tidak aman untuk utas. Pertimbangkan agar setiap utas menggunakan `CallExecutor` instancenya sendiri, atau gunakan pustaka percobaan ulang yang berbeda.
**catatan**
Contoh berikut telah diperbarui untuk menyertakan penggunaan requestInterceptor (). Ini ditambahkan di TinkerPop 3.6.6. Sebelum TinkerPop versi 3.6.6, contoh kode menggunakan HandshakeInterceptor (), yang tidak digunakan lagi dengan rilis itu.
```
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;
};
}
```
# Menggunakan Python untuk terhubung ke instans DB Neptune
(3).ToList();
foreach(var item in output) {
Console.WriteLine(item);
}
}
catch (Exception e)
{
Console.WriteLine("{0}", e);
}
}
}
}
```
1. Masukkan perintah berikut untuk menjalankan sampel:
```
dotnet run
```
Kueri Gremlin pada akhir contoh ini mengembalikan jumlah vertex tunggal untuk tujuan pengujian. Ini kemudian dicetak ke konsol.
**catatan**
Bagian akhir dari kueri Gremlin, `Next()`, diperlukan untuk mengirimkan traversal ke server untuk evaluasi. Jika Anda tidak menyertakan metode tersebut atau metode setara lain, kueri tidak diserahkan ke instans DB Neptune.
Metode berikut mengirimkan kueri ke instans DB Neptune:
+ `ToList()`
+ `ToSet()`
+ `Next()`
+ `NextTraverser()`
+ `Iterate()`
Gunakan `Next()` jika Anda membutuhkan hasil kueri agar diserialkan dan dikembalikan, atau `Iterate()` jika tidak.
Contoh sebelumnya mengembalikan daftar dengan menggunakan traversal. `g.V().Limit(3).ToList()` Untuk mengajukan kueri untuk sesuatu yang lain, ganti dengan traversal Gremlin lain dengan salah satu metode ending yang tepat.
## Autentikasi IAM
).out().out().out().out().out().out().out().out().out().out().limit(1).path()
```
**penting**
Mesin permintaan Neptune tidak melakukan ini secara otomatis.
Breadth-first (`BFS`) adalah strategi eksekusi default, dan mirip dengan TinkerGraph dalam kebanyakan kasus. Namun, ada kasus-kasus tertentu di mana strategi depth (`DFS`) lebih baik.
**BFS (Default)**
Breadth-first (BFS) adalah strategi eksekusi default untuk operator `repeat()`.
```
g.V("3").repeat(out()).times(10).limit(1).path()
```
Mesin Neptune sepenuhnya mengeksplorasi perbatasan sembilan hop pertama sebelum menemukan sepuluh hop solusi. Hal ini efektif dalam banyak kasus, seperti kueri jalur terpendek.
Namun, untuk contoh sebelumnya, traversal akan jauh lebih cepat menggunakan mode depth-first (`DFS`) untuk operator `repeat()`.
**DFS**
Kueri berikut menggunakan mode depth-first (`DFS`) untuk operator `repeat()`.
```
g.withSideEffect("Neptune#repeatMode", "DFS").V("3").repeat(out()).times(10).limit(1)
```
Ini mengikuti setiap solusi individu ke kedalaman maksimum sebelum menjelajahi solusi berikutnya.
# Petunjuk kueri noReordering Gremlin
<~label> <~>) .]
```
## Pernyataan Gremlin Edge
) .]
```
## Pernyataan Properti Gremlin
"John" <~>) .]
```
Pernyataan properti berbeda dari yang lain dalam hal bahwa objek mereka adalah nilai primitif (`string`, `date`, `byte`, `short`, `int`, `long`, `float`, atau `double`). Objek mereka bukan pengidentifikasi sumber daya yang dapat digunakan sebagai subjek penegasan lain.
Untuk multi-properti, setiap nilai properti individu dalam set menerima pernyataannya sendiri.
```
g.V("v1").property(set, "phone", "956-424-2563").property(set, "phone", "956-354-3692 (tel:9563543692)")
```
Hal ini menyebabkan hal berikut ini.
```
StatementEvent[Added( "956-424-2563" <~>) .]
StatementEvent[Added( "956-354-3692" <~>) .]
```
Properti tepi ditangani mirip dengan properti simpul, tetapi gunakan pengenal tepi di posisi (S). Misalnya, menambahkan properti ke tepi:
```
g.E("e1").property("weight", 0.8)
```
Ini menghasilkan pernyataan berikut yang ditambahkan ke grafik.
```
StatementEvent[Added( 0.8 <~>) .]
```
# Bagaimana Neptune memproses kueri Gremlin menggunakan indeks pernyataan
, <~label>, ?, ?)
Known positions: SP
Lookup positions: OG
Index: SPOG
Key range: :<~label>:*
```
**Pertanyaan: Apa tepi luar 'tahu' dari simpul? `v1`**
```
Gremlin code: g.V('v1').out('knows')
Pattern: (, , ?, ?)
Known positions: SP
Lookup positions: OG
Index: SPOG
Key range: ::*
```
**Pertanyaan: Simpul mana yang memiliki label `Person` simpul?**
```
Gremlin code: g.V().hasLabel('Person')
Pattern: (?, <~label>, , <~>)
Known positions: POG
Lookup positions: S
Index: POGS
Key range: <~label>::<~>:*
```
**Pertanyaan: Apa from/to simpul dari tepi yang diberikan? `e1`**
```
Gremlin code: g.E('e1').bothV()
Pattern: (?, ?, ?, )
Known positions: G
Lookup positions: SPO
Index: GPSO
Key range: :*
```
Satu indeks pernyataan yang **tidak** Neptune miliki adalah indeks OSGP traversal terbalik. Indeks ini dapat digunakan untuk mengumpulkan semua edge masuk di semua label edge, seperti dalam contoh berikut.
**Pertanyaan: Apa `v1` simpul yang berdekatan yang masuk?**
```
Gremlin code: g.V('v1').in()
Pattern: (?, ?, , ?)
Known positions: O
Lookup positions: SPG
Index: OSGP // <-- Index does not exist
```
# Bagaimana kueri Gremlin diproses di 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
```
Dengan berbagi variabel `?2` di dua pola (pada posisi O dalam pola pertama dan posisi S dari pola kedua), Anda membuat gabungan dari tetangga hop pertama ke tetangga hop kedua. [Setiap solusi Neptunus memiliki binding untuk tiga variabel bernama, yang dapat digunakan untuk membuat ulang TinkerPop Traverser (termasuk informasi jalur).](http://tinkerpop.apache.org/docs/current/reference/#_the_traverser)
```
```
[Langkah pertama dalam pemrosesan kueri Gremlin adalah mengurai kueri menjadi objek TinkerPop [Traversal](http://tinkerpop.apache.org/docs/current/reference/#traversal), yang terdiri dari serangkaian langkah. TinkerPop ](http://tinkerpop.apache.org/docs/current/reference/#graph-traversal-steps) Langkah-langkah ini, yang merupakan bagian dari [ TinkerPop proyek Apache](http://tinkerpop.apache.org/) open-source, adalah operator logis dan fisik yang menyusun traversal Gremlin dalam implementasi referensi. Keduanya digunakan untuk mewakili model kueri. Keduanya adalah operator yang dapat dieksekusi yang dapat menghasilkan solusi sesuai dengan semantik operator yang mereka wakili. Misalnya, keduanya `.V()` diwakili dan dieksekusi oleh TinkerPop [GraphStep](http://tinkerpop.apache.org/docs/current/reference/#graph-step).
Karena off-the-shelf TinkerPop langkah-langkah ini dapat dieksekusi, TinkerPop Traversal semacam itu dapat mengeksekusi kueri Gremlin apa pun dan menghasilkan jawaban yang benar. Namun, ketika dieksekusi terhadap grafik besar, TinkerPop langkah-langkah terkadang bisa sangat tidak efisien dan lambat. Alih-alih menggunakannya, Neptune mencoba mengubah traversal menjadi bentuk deklaratif yang terdiri dari grup pola, seperti yang dijelaskan sebelumnya.
Neptune saat ini tidak mendukung semua operator (langkah) Gremlin di mesin kueri aslinya. Jadi Neptune mencoba melakukan collaps pada sebanyak mungkin langkah ke dalam satu `NeptuneGraphQueryStep`, yang berisi rencana kueri logis deklaratif untuk semua langkah-langkah yang telah dikonversi. Idealnya, semua langkah dikonversi. Tetapi ketika sebuah langkah ditemukan yang tidak dapat dikonversi, Neptunus keluar dari eksekusi asli dan menunda semua eksekusi kueri dari titik itu ke langkah-langkahnya. TinkerPop Neptune tidak mencoba untuk menjalin masuk dan keluar dari eksekusi asli.
Setelah langkah-langkah diterjemahkan ke dalam rencana kueri logis, Neptune menjalankan serangkaian pengoptimal kueri yang menulis ulang rencana kueri berdasarkan analisis statis dan perkiraan kardinalitas. Pengoptimal ini melakukan hal-hal seperti mengatur ulang operator berdasarkan jumlah rentang, memangkas operator yang tidak perlu atau berlebihan, mengatur ulang filter, mendorong operator ke dalam kelompok yang berbeda, dan sebagainya.
Setelah rencana kueri yang dioptimalkan diproduksi, Neptune menciptakan alur operator fisik yang melakukan pekerjaan mengeksekusi kueri. Ini termasuk membaca data dari indeks pernyataan, melakukan penggabungan berbagai jenis, penyaringan, pengurutan, dan sebagainya. Pipeline menghasilkan aliran solusi yang kemudian diubah kembali menjadi aliran objek TinkerPop Traverser.
## Serialisasi hasil kueri
, ?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
```
Lihat [Informasi di `explain`](#gremlin-explain-api-results) untuk deskripsi bagian spesifik DFE dalam laporan.
# API `profile` Gremlin di Neptune
`.
Jika non-null, hasil yang dikumpulkan dikembalikan dalam pesan respons serial dalam format yang ditentukan oleh parameter ini. Jumlah operasi indeks yang diperlukan untuk menghasilkan pesan respons dilaporkan bersama dengan ukuran dalam byte yang akan dikirim ke klien.
Nilai yang diizinkan adalah `` atau salah satu jenis MIME yang valid atau nilai enum “Serializers” TinkerPop driver.
```
"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`, nilai yang diizinkan: `TRUE` dan `FALSE`, nilai default: `FALSE`.
Jika true, menunjukkan laporan detail dari semua operasi indeks yang terjadi selama eksekusi dan serialisasi kueri. Peringatan: Laporan ini bisa verbose.
## Contoh output dari `profile` Gremlin Neptune
, "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
```
Selain rencana kueri dikembalikan oleh panggilan ke Neptune `explain`, hasil `profile` menyertakan statistik runtime sekitar eksekusi kueri. Setiap operasi Gabungan ditandai dengan waktu yang dibutuhkan untuk melakukan penggabungannya serta jumlah sebenarnya dari solusi yang melewatinya.
Output `profile` menyertakan waktu yang dibutuhkan selama fase eksekusi kueri inti, serta fase serialisasi jika opsi `profile.serializer` telah ditentukan.
Rincian operasi indeks yang dilakukan selama setiap fase juga disertakan di bagian bawah output `profile`.
Perhatikan bahwa proses berturut-turut dari kueri yang sama dapat menunjukkan hasil yang berbeda dalam hal operasi run-time dan indeks karena caching.
Untuk kueri yang menggunakan langkah `repeat()`, rincian perbatasan pada setiap iterasi tersedia jika langkah `repeat()` didorong ke bawah sebagai bagian dari `NeptuneGraphQueryStep`.
## Perbedaan dalam laporan `profile` saat DFE diaktifkan
, "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
```
Pesan `WARNING` di bagian bawah output terjadi karena langkah `in()` dalam traversal tidak dapat ditangani menggunakan salah satu dari 3 indeks yang Neptune pertahankan (lihat [Bagaimana Pernyataan Diindeks di Neptune](feature-overview-storage-indexing.md) dan [Pernyataan Gremlin di Neptune](gremlin-explain-background-statements.md)). Karena langkah `in()` tidak berisi filter edge, langkah itu tidak dapat diselesaikan menggunakan indeks `SPOG`, `POGS` atau `GPSO`. Sebaliknya, Neptune harus melakukan pemindaian serikat untuk menemukan vertex yang diminta, yang jauh lebih efisien.
Ada dua cara untuk menyetel traversal dalam situasi ini. Yang pertama adalah menambahkan satu atau lebih kriteria penyaringan ke langkah `in()` sehingga pencarian yang diindeks dapat digunakan untuk menyelesaikan kueri. Untuk contoh di atas, ini mungkin:
```
g.V().has('code','ANC').in('route').values('code')
```
Output dari API `explain` Neptune untuk traversal yang direvisi tidak lagi berisi pesan `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
```
Pilihan lain jika Anda menjalankan banyak traversals semacam ini adalah untuk menjalankan traversal tersebut dalam sebuah klaster DB Neptune yang memiliki indeks `OSGP` opsional diaktifkan (lihat [Mengaktifkan Indeks OSGP](feature-overview-storage-indexing.md#feature-overview-storage-indexing-osgp)). Mengaktifkan indeks `OSGP` memiliki kelemahan:
+ Indeks ini harus diaktifkan dalam klaster DB sebelum data dimuat.
+ Tingkat penyisipan untuk vertex dan edge dapat melambat hingga 23%.
+ Penggunaan penyimpanan akan meningkat sekitar 20%.
+ Kueri Baca yang menyebarkan permintaan di semua indeks mungkin telah meningkatkan latensi.
Memiliki indeks `OSGP` lebih masuk akal untuk serangkaian pola kueri terbatas, tetapi kecuali jika Anda sering menjalankannya, biasanya lebih baik untuk mencoba untuk memastikan bahwa traversals yang Anda tulis dapat diselesaikan menggunakan tiga indeks utama.
### Menggunakan jumlah besar predikat