Terjemahan disediakan oleh mesin penerjemah. Jika konten terjemahan yang diberikan bertentangan dengan versi bahasa Inggris aslinya, utamakan versi bahasa Inggris.

# Menganalisis eksekusi kueri Neptune menggunakan `explain` SPARQL
<a name="sparql-explain"></a>

Amazon Neptune telah menambahkan fitur SPARQL bernama *explain*. Fitur ini adalah alat swalayan untuk memahami pendekatan eksekusi yang diambil oleh mesin Neptune. Anda meminta dengan menambahkan parameter `explain` ke panggilan HTTP yang mengirimkan kueri SPARQL.

Fitur `explain` menyediakan informasi tentang struktur logis rencana eksekusi kueri. Anda dapat menggunakan informasi ini untuk mengidentifikasi potensi hambatan evaluasi dan eksekusi. Anda kemudian dapat menggunakan [petunjuk kueri](sparql-query-hints.md) untuk meningkatkan rencana eksekusi kueri Anda.

**Topics**
+ [Memahami bagaimana mesin kueri SPARQL Neptune bekerja.](sparql-explain-engine.md)
+ [Cara menggunakan `explain` SPARQL untuk menganalisis eksekusi kueri Neptune](sparql-explain-using.md)
+ [Contoh `explain` SPARQL yang dipanggil di Neptune](sparql-explain-examples.md)
+ [Operator `explain` SPARQL Neptune](sparql-explain-operators.md)
+ [Keterbatasan `explain` SPARQL di Neptune](sparql-explain-limitations.md)

# Memahami bagaimana mesin kueri SPARQL Neptune bekerja.
<a name="sparql-explain-engine"></a>

Untuk menggunakan informasi yang disediakan fitur `explain` SPARQL, Anda perlu memahami beberapa rincian tentang cara mesin kueri Amazon Neptune SPARQL bekerja.

Mesin menerjemahkan setiap kueri SPARQL ke dalam alur operator. Mulai dari operator pertama, solusi perantara yang dikenal sebagai *daftar pengikatan* mengalir melalui alur operator ini. Anda dapat memikirkan daftar pengikatan sebagai tabel di mana header tabel adalah bagian dari variabel yang digunakan dalam kueri. Setiap baris dalam tabel mewakili hasil, sampai titik evaluasi.

Mari kita asumsikan bahwa dua prefiks namespace telah didefinisikan untuk data kami:

```
  @prefix ex:   <http://example.com> .
  @prefix foaf: <http://xmlns.com/foaf/0.1/> .
```

Berikut ini akan menjadi contoh dari daftar pengikatan sederhana dalam konteks ini:

```
  ?person       | ?firstName
  ------------------------------------------------------
  ex:JaneDoe    | "Jane"
  ex:JohnDoe    | "John"
  ex:RichardRoe | "Richard"
```

Untuk masing-masing dari tiga orang, daftar tersebut mengikat variabel `?person` ke pengenal dari orang tersebut, dan variabel `?firstName` ke nama depat orang tersebut.

Dalam kasus umum, variabel dapat tetap tidak terikat, jika, misalnya, ada pemilihan `OPTIONAL` variabel dalam kueri yang tanpa nilai dalam data.

Operator `PipelineJoin` adalah contoh dari operator mesin kueri Neptune yang ada dalam output `explain`. Operator tersebut dibutuhkan sebagai set mengikat masuk dari operator sebelumnya dan bergabung dengan pola triple, misalnya `(?person, foaf:lastName, ?lastName)`. Operasi ini menggunakan pengikatan untuk variabel `?person` dalam stream inputnya, menggantikannya ke dalam pola triple, dan mencari triple dari database.

Ketika dieksekusi dalam konteks pengikatan masuk dari tabel sebelumnya, `PipelineJoin`akan mengevaluasi tiga pencarian, yaitu berikut ini:

```
  (ex:JaneDoe,    foaf:lastName, ?lastName)
  (ex:JohnDoe,    foaf:lastName, ?lastName)
  (ex:RichardRoe, foaf:lastName, ?lastName)
```

Pendekatan ini disebut evaluasi *as-bound*. Solusi dari proses evaluasi ini digabungkan kembali dengan solusi yang masuk, mengalasi `?lastName` yang terdeteksi dalam solusi yang masuk. Dengan asumsi bahwa Anda menemukan nama terakhir untuk ketiga orang tersebut, operator akan menghasilkan daftar mengikat keluar yang akan terlihat seperti ini:

```
  ?person       | ?firstName | ?lastName
  ---------------------------------------
  ex:JaneDoe    | "Jane"     | "Doe"
  ex:JohnDoe    | "John"     | "Doe"
  ex:RichardRoe | "Richard"  | "Roe"
```

Daftar mengikat keluar ini kemudian berfungsi sebagai input untuk operator berikutnya dalam alur. Pada akhirnya, output dari operator terakhir dalam alur mendefinisikan hasil kueri.

Alur operator sering linier, dalam arti bahwa setiap operator mengeluarkan solusi untuk satu operator terhubung. Namun, dalam beberapa kasus, mereka dapat memiliki struktur yang lebih kompleks. Misalnya, operator `UNION` dalam kueri SPARQL dipetakan ke operasi `Copy`. Operasi ini menduplikat binding dan meneruskan salinan menjadi dua subplan, satu untuk sisi kiri dan yang lainnya untuk sisi kanan `UNION`.

Untuk informasi lebih lanjut tentang operator, lihat [Operator `explain` SPARQL Neptune](sparql-explain-operators.md).

# Cara menggunakan `explain` SPARQL untuk menganalisis eksekusi kueri Neptune
<a name="sparql-explain-using"></a>

Fitur `explain` SPARQL adalah alat swalayan di Amazon Neptune yang membantu Anda memahami pendekatan eksekusi yang diambil oleh mesin Neptune. Untuk meminta `explain`, Anda melewatkan parameter ke permintaan HTTP atau HTTPS dalam bentuk `explain=mode`.

Nilai mode dapat menjadi salah satu dari `static`, `dynamic`, atau `details`:
+ Dalam mode *statis*, `explain` mencetak hanya struktur statis dari rencana kueri.
+ Dalam mode *dinamis*, `explain` juga mencakup aspek dinamis dari rencana kueri. Aspek-aspek ini mungkin menyertakan jumlah binding menengah mengalir melalui operator, rasio binding masuk ke binding keluar, dan total waktu yang dibutuhkan oleh operator.
+ Dalam mode *detail*, `explain` mencetak informasi yang ditampilkan di mode `dynamic` ditambah rincian tambahan seperti string kueri SPARQL aktual dan perkiraan jumlah rentang untuk pola yang mendasari operator gabungan.

Neptune mendukung penggunaan `explain` dengan semua tiga protokol akses kueri SPARQL yang tercantum dalam spesifikasi [Protokol SPARQL 1.1 W3C](https://www.w3.org/TR/sparql11-protocol/#query-operation), yaitu:

1. HTTP GET

1. HTTP POST menggunakan parameter dikodekan URL

1. HTTP POST menggunakan parameter teks

Untuk informasi tentang mesin kueri SPARQL, lihat [Memahami bagaimana mesin kueri SPARQL Neptune bekerja.](sparql-explain-engine.md).

Untuk informasi tentang jenis output yang dihasilkan dengan menerapkan `explain` SPARQL, lihat [Contoh `explain` SPARQL yang dipanggil di Neptune](sparql-explain-examples.md).

# Contoh `explain` SPARQL yang dipanggil di Neptune
<a name="sparql-explain-examples"></a>

Contoh dalam bagian ini menunjukkan berbagai jenis output Anda dapat hasilkan dengan memanggil fitur `explain` SPARQL untuk menganalisis eksekusi kueri di Amazon Neptune.

**Topics**
+ [Memahami Output Explain](#sparql-explain-example-output)
+ [Contoh output mode rincian](#sparql-explain-example-details)
+ [Contoh dari output mode statis](#sparql-explain-example-static)
+ [Berbagai cara pengkodean parameter](#sparql-explain-example-parameters)
+ [Jenis output lain selain text/plain](#sparql-explain-output-options)
+ [Contoh output `explain` SPARQL saat DFE diaktifkan](#sparql-explain-output-dfe)

## Memahami Output Explain
<a name="sparql-explain-example-output"></a>

Dalam contoh ini, Jane Doe mengenal dua orang, yaitu John Doe dan Richard Roe:

```
@prefix ex: <http://example.com> .
@prefix foaf: <http://xmlns.com/foaf/0.1/> .

ex:JaneDoe foaf:knows ex:JohnDoe .
ex:JohnDoe foaf:firstName "John" .
ex:JohnDoe foaf:lastName "Doe" .
ex:JaneDoe foaf:knows ex:RichardRoe .
ex:RichardRoe foaf:firstName "Richard" .
ex:RichardRoe foaf:lastName "Roe" .
.
```

Untuk menentukan nama depan semua orang yang diketahui Jane Doe, Anda dapat menulis kueri berikut:

```
 curl http(s)://your_server:your_port/sparql \
   -d "query=PREFIX foaf: <https://xmlns.com/foaf/0.1/> PREFIX ex: <https://www.example.com/> \
       SELECT ?firstName WHERE { ex:JaneDoe foaf:knows ?person . ?person foaf:firstName ?firstName }" \
   -H "Accept: text/csv"
```

Kueri sederhana ini mengembalikan hal berikut ini:

```
firstName
John
Richard
```

Berikutnya, mengubah perintah `curl` untuk memangil `explain` dengan menambahkan `-d "explain=dynamic"` dan menggunakan tipe output default alih-alih `text/csv`:

```
 curl http(s)://your_server:your_port/sparql \
   -d "query=PREFIX foaf: <https://xmlns.com/foaf/0.1/> PREFIX ex: <https://www.example.com/> \
       SELECT ?firstName WHERE { ex:JaneDoe foaf:knows ?person . ?person foaf:firstName ?firstName }" \
   -d "explain=dynamic"
```

Kueri sekarang mengembalikan output dalam format ASCII pretty-printed (jenis konten HTTP `text/plain`), yang merupakan tipe output standar:

```
╔════╤════════╤════════╤═══════════════════╤═══════════════════════════════════════════════════════╤══════════╤══════════╤═══════════╤═══════╤═══════════╗
║ ID │ Out #1 │ Out #2 │ Name              │ Arguments                                             │ Mode     │ Units In │ Units Out │ Ratio │ Time (ms) ║
╠════╪════════╪════════╪═══════════════════╪═══════════════════════════════════════════════════════╪══════════╪══════════╪═══════════╪═══════╪═══════════╣
║ 0  │ 1      │ -      │ SolutionInjection │ solutions=[{}]                                        │ -        │ 0        │ 1         │ 0.00  │ 0         ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 1  │ 2      │ -      │ PipelineJoin      │ pattern=distinct(ex:JaneDoe, foaf:knows, ?person)     │ -        │ 1        │ 2         │ 2.00  │ 1         ║
║    │        │        │                   │ joinType=join                                         │          │          │           │       │           ║
║    │        │        │                   │ joinProjectionVars=[?person]                          │          │          │           │       │           ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 2  │ 3      │ -      │ PipelineJoin      │ pattern=distinct(?person, foaf:firstName, ?firstName) │ -        │ 2        │ 2         │ 1.00  │ 1         ║
║    │        │        │                   │ joinType=join                                         │          │          │           │       │           ║
║    │        │        │                   │ joinProjectionVars=[?person, ?firstName]              │          │          │           │       │           ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 3  │ 4      │ -      │ Projection        │ vars=[?firstName]                                     │ retain   │ 2        │ 2         │ 1.00  │ 0         ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 4  │ -      │ -      │ TermResolution    │ vars=[?firstName]                                     │ id2value │ 2        │ 2         │ 1.00  │ 1         ║
╚════╧════════╧════════╧═══════════════════╧═══════════════════════════════════════════════════════╧══════════╧══════════╧═══════════╧═══════╧═══════════╝
```

Untuk rincian tentang operasi di kolom `Name` dan argumennya, lihat [Operator explain](sparql-explain-operators.md).

Hal berikut ini menjelaskan output baris demi baris:

1. Langkah pertama dalam kueri utama selalu menggunakan operator `SolutionInjection` untuk menyuntikkan solusi. Solusinya kemudian diperluas ke hasil akhir melalui proses evaluasi.

   Dalam hal ini, operator menyuntikkan apa yang disebut solusi universal `{ }`. Dengan adanya klausa `VALUES` atau `BIND`, langkah ini mungkin juga menyuntikkan binding variabel yang lebih kompleks untuk memulai.

   Kolom `Units Out` menunjukkan bahwa solusi tunggal ini mengalir keluar dari operator. Kolom `Out #1` menentukan operator tempat operator ini mengumpankan hasilnya. Dalam contoh ini, semua operator terhubung ke operator yang mengikuti dalam tabel.

1. Langkah kedua adalah `PipelineJoin`. Operator menerima sebagai input solusi universal tunggal (sepenuhnya tidak dibatasi) yang dihasilkan oleh operator sebelumnya (`Units In := 1`). Operator menggabungkannya terhadap pola triple yang didefinisikan oleh argumen `pattern`. Hal ini terkait dengan pencarian sederhana untuk pola. Dalam kasus ini, pola triple didefinisikan sebagai berikut:

   ```
   distinct( ex:JaneDoe, foaf:knows, ?person )
   ```

   Argumen `joinType := join` menunjukkan bahwa ini adalah gabungan normal (jenis lain termasuk gabungan `optional`, gabungan `existence check`, dan sebagainya).

   Argumen `distinct := true` mengatakan bahwa Anda mengekstrak hanya kecocokan khas dari database (tidak ada duplikat), dan Anda mengikat kecocokan khas ke variabel `joinProjectionVars := ?person`, dideduplikasi.

   Fakta bahwa nilai kolom `Units Out` adalah 2 menunjukkan bahwa ada dua solusi yang mengalir keluar. Secara khusus, ini adalah binding untuk variabel `?person`, mencerminkan dua orang yang ditunjukkan data yang dikenal Jane Doe:

   ```
    ?person
    -------------
    ex:JohnDoe
    ex:RichardRoe
   ```

1. Dua solusi dari tahap 2 mengalir sebagai input (`Units In := 2`) ke `PipelineJoin` yang kedua. Operator ini bergabung dengan dua solusi sebelumnya dengan pola triple berikut:

   ```
   distinct(?person, foaf:firstName, ?firstName)
   ```

   Variabel `?person` dikenal terikat baik ke `ex:JohnDoe` atau ke `ex:RichardRoe` oleh solusi masuk operator. Dengan begitu, `PipelineJoin` mengekstrak nama pertama, John dan Richard. Dua solusi keluar (Unit Out: = 2) kemudian sebagai berikut:

   ```
    ?person       | ?firstName
    ---------------------------
    ex:JohnDoe    | John
    ex:RichardRoe | Richard
   ```

1. Operator proyeksi berikutnya mengambil sebagai masukan dua solusi dari tahap 3 (`Units In := 2`) dan memproyeksikan ke variabel `?firstName`. Ini menghilangkan semua binding variabel lainnya dalam pemetaan dan melewati pada dua binding (`Units Out := 2`):

   ```
    ?firstName
    ----------
    John
    Richard
   ```

1. Untuk meningkatkan kinerja, Neptunus beroperasi jika memungkinkan pada pengidentifikasi internal yang ditetapkan untuk istilah URIs seperti dan string literal, bukan pada string itu sendiri. Operator terakhir, `TermResolution`, melakukan pemetaan dari pengidentifikasi internal ini kembali ke string istilah yang sesuai.

   Dalam evaluasi kueri biasa (non-explain), hasil dihitung oleh operator terakhir kemudian diserialisasi ke dalam format serialisasi yang diminta dan dialirkan ke klien.

## Contoh output mode rincian
<a name="sparql-explain-example-details"></a>

Misalkan Anda menjalankan kueri yang sama seperti sebelumnya di mode *detail* alih-alih mode *dinamis*:

```
 curl http(s)://your_server:your_port/sparql \
   -d "query=PREFIX foaf: <https://xmlns.com/foaf/0.1/> PREFIX ex: <https://www.example.com/> \
       SELECT ?firstName WHERE { ex:JaneDoe foaf:knows ?person . ?person foaf:firstName ?firstName }" \
   -d "explain=details"
```

Seperti yang ditunjukkan contoh ini, outputnya sama dengan beberapa rincian tambahan seperti string kueri di bagian atas output, dan `patternEstimate` bernilai untuk operator `PipelineJoin`:

```
Query:
PREFIX foaf: <https://xmlns.com/foaf/0.1/> PREFIX ex: <https://www.example.com/>
SELECT ?firstName WHERE { ex:JaneDoe foaf:knows ?person . ?person foaf:firstName ?firstName }

╔════╤════════╤════════╤═══════════════════╤═══════════════════════════════════════════════════════╤══════════╤══════════╤═══════════╤═══════╤═══════════╗
║ ID │ Out #1 │ Out #2 │ Name              │ Arguments                                             │ Mode     │ Units In │ Units Out │ Ratio │ Time (ms) ║
╠════╪════════╪════════╪═══════════════════╪═══════════════════════════════════════════════════════╪══════════╪══════════╪═══════════╪═══════╪═══════════╣
║ 0  │ 1      │ -      │ SolutionInjection │ solutions=[{}]                                        │ -        │ 0        │ 1         │ 0.00  │ 0         ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 1  │ 2      │ -      │ PipelineJoin      │ pattern=distinct(ex:JaneDoe, foaf:knows, ?person)     │ -        │ 1        │ 2         │ 2.00  │ 13        ║
║    │        │        │                   │ joinType=join                                         │          │          │           │       │           ║
║    │        │        │                   │ joinProjectionVars=[?person]                          │          │          │           │       │           ║
║    │        │        │                   │ patternEstimate=2                                     │          │          │           │       │           ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 2  │ 3      │ -      │ PipelineJoin      │ pattern=distinct(?person, foaf:firstName, ?firstName) │ -        │ 2        │ 2         │ 1.00  │ 3         ║
║    │        │        │                   │ joinType=join                                         │          │          │           │       │           ║
║    │        │        │                   │ joinProjectionVars=[?person, ?firstName]              │          │          │           │       │           ║
║    │        │        │                   │ patternEstimate=2                                     │          │          │           │       │           ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 3  │ 4      │ -      │ Projection        │ vars=[?firstName]                                     │ retain   │ 2        │ 2         │ 1.00  │ 1         ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 4  │ -      │ -      │ TermResolution    │ vars=[?firstName]                                     │ id2value │ 2        │ 2         │ 1.00  │ 7         ║
╚════╧════════╧════════╧═══════════════════╧═══════════════════════════════════════════════════════╧══════════╧══════════╧═══════════╧═══════╧═══════════╝
```

## Contoh dari output mode statis
<a name="sparql-explain-example-static"></a>

Misalkan Anda menjalankan kueri yang sama seperti sebelumnya di mode *statis* (default) alih-alih mode *detail*:

```
 curl http(s)://your_server:your_port/sparql \
   -d "query=PREFIX foaf: <https://xmlns.com/foaf/0.1/> PREFIX ex: <https://www.example.com/> \
       SELECT ?firstName WHERE { ex:JaneDoe foaf:knows ?person . ?person foaf:firstName ?firstName }" \
   -d "explain=static"
```

Seperti yang contoh ini tunjukkan, outputnya sama, kecuali bahwa itu menghilangkan tiga kolom terakhir:

```
╔════╤════════╤════════╤═══════════════════╤═══════════════════════════════════════════════════════╤══════════╗
║ ID │ Out #1 │ Out #2 │ Name              │ Arguments                                             │ Mode     ║
╠════╪════════╪════════╪═══════════════════╪═══════════════════════════════════════════════════════╪══════════╣
║ 0  │ 1      │ -      │ SolutionInjection │ solutions=[{}]                                        │ -        ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────╢
║ 1  │ 2      │ -      │ PipelineJoin      │ pattern=distinct(ex:JaneDoe, foaf:knows, ?person)     │ -        ║
║    │        │        │                   │ joinType=join                                         │          ║
║    │        │        │                   │ joinProjectionVars=[?person]                          │          ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────╢
║ 2  │ 3      │ -      │ PipelineJoin      │ pattern=distinct(?person, foaf:firstName, ?firstName) │ -        ║
║    │        │        │                   │ joinType=join                                         │          ║
║    │        │        │                   │ joinProjectionVars=[?person, ?firstName]              │          ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────╢
║ 3  │ 4      │ -      │ Projection        │ vars=[?firstName]                                     │ retain   ║
╟────┼────────┼────────┼───────────────────┼───────────────────────────────────────────────────────┼──────────╢
║ 4  │ -      │ -      │ TermResolution    │ vars=[?firstName]                                     │ id2value ║
╚════╧════════╧════════╧═══════════════════╧═══════════════════════════════════════════════════════╧══════════╝
```

## Berbagai cara pengkodean parameter
<a name="sparql-explain-example-parameters"></a>

Contoh kueri berikut menggambarkan dua cara yang berbeda untuk mengkodekan parameter ketika memanggil `explain` SPARQL.

**Menggunakan pengkodean URL** - Contoh ini menggunakan pengkodean URL parameter, dan menentukan output *dinamis*:

```
curl -XGET "http(s)://your_server:your_port/sparql?query=SELECT%20*%20WHERE%20%7B%20%3Fs%20%3Fp%20%3Fo%20%7D%20LIMIT%20%31&explain=dynamic"
```

**Menentukan parameter secara langsung** — Ini sama dengan kueri sebelumnya kecuali bahwa ia melewatkan parameter melalui POST langsung:

```
 curl http(s)://your_server:your_port/sparql \
   -d "query=SELECT * WHERE { ?s ?p ?o } LIMIT 1" \
   -d "explain=dynamic"
```

## Jenis output lain selain text/plain
<a name="sparql-explain-output-options"></a>

Contoh sebelumnya menggunakan jenis output `text/plain` default. Neptune juga dapat memformat output `explain` SPARQL dalam dua format jenis MIME lainnya, yaitu `text/csv` dan `text/html`. Anda memanggil mereka dengan menetapkan header `Accept` HTTP, yang dapat Anda lakukan menggunakan bendera `-H` di `curl`, sebagai berikut:

```
  -H "Accept: output type"
```

Berikut ini adalah beberapa contohnya:

**Output `text/csv`**  
Kueri ini memanggil output jenis MIME CSV dengan menentukan `-H "Accept: text/csv"`:

```
 curl http(s)://your_server:your_port/sparql \
   -d "query=SELECT * WHERE { ?s ?p ?o } LIMIT 1" \
   -d "explain=dynamic" \
   -H "Accept: text/csv"
```

Format CSV, yang berguna untuk diimport ke dalam spreadsheet atau basis data, memisahkan bidang dalam setiap baris `explain` dengan titik koma (`;`), seperti ini:

```
ID;Out #1;Out #2;Name;Arguments;Mode;Units In;Units Out;Ratio;Time (ms)
0;1;-;SolutionInjection;solutions=[{}];-;0;1;0.00;0
1;2;-;PipelineJoin;pattern=distinct(?s, ?p, ?o),joinType=join,joinProjectionVars=[?s, ?p, ?o];-;1;6;6.00;1
2;3;-;Projection;vars=[?s, ?p, ?o];retain;6;6;1.00;2
3;-;-;Slice;limit=1;-;1;1;1.00;1
```

 

**Output `text/html`**  
Jika Anda menentukan `-H "Accept: text/html"`, maka `explain` menghasilkan tabel HTML:

```
<!DOCTYPE html>
<html>
  <body>
    <table border="1px">
      <thead>
        <tr>
          <th>ID</th>
          <th>Out #1</th>
          <th>Out #2</th>
          <th>Name</th>
          <th>Arguments</th>
          <th>Mode</th>
          <th>Units In</th>
          <th>Units Out</th>
          <th>Ratio</th>
          <th>Time (ms)</th>
        </tr>
      </thead>

      <tbody>
        <tr>
          <td>0</td>
          <td>1</td>
          <td>-</td>
          <td>SolutionInjection</td>
          <td>solutions=[{}]</td>
          <td>-</td>
          <td>0</td>
          <td>1</td>
          <td>0.00</td>
          <td>0</td>
        </tr>

        <tr>
          <td>1</td>
          <td>2</td>
          <td>-</td>
          <td>PipelineJoin</td>
          <td>pattern=distinct(?s, ?p, ?o)<br>
              joinType=join<br>
              joinProjectionVars=[?s, ?p, ?o]</td>
          <td>-</td>
          <td>1</td>
          <td>6</td>
          <td>6.00</td>
          <td>1</td>
        </tr>

        <tr>
          <td>2</td>
          <td>3</td>
          <td>-</td>
          <td>Projection</td>
          <td>vars=[?s, ?p, ?o]</td>
          <td>retain</td>
          <td>6</td>
          <td>6</td>
          <td>1.00</td>
          <td>2</td>
        </tr>

        <tr>
          <td>3</td>
          <td>-</td>
          <td>-</td>
          <td>Slice</td>
          <td>limit=1</td>
          <td>-</td>
          <td>1</td>
          <td>1</td>
          <td>1.00</td>
          <td>1</td>
        </tr>
      </tbody>
    </table>
  </body>
</html>
```

HTML merender dalam browser seperti berikut ini:

![\[Contoh dari output HTML Explain SPARQL.\]](http://docs.aws.amazon.com/id_id/neptune/latest/userguide/images/sparql-explain-dynamic-html-output.png)


## Contoh output `explain` SPARQL saat DFE diaktifkan
<a name="sparql-explain-output-dfe"></a>

Berikut ini adalah contoh output `explain` SPARQL ketika mesin kueri alternatif DFE Neptune diaktifkan:

```
╔════╤════════╤════════╤═══════════════════╤═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╤══════════╤══════════╤═══════════╤═══════╤═══════════╗
║ ID │ Out #1 │ Out #2 │ Name              │ Arguments                                                                                                                                                                                                               │ Mode     │ Units In │ Units Out │ Ratio │ Time (ms) ║
╠════╪════════╪════════╪═══════════════════╪═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╪══════════╪══════════╪═══════════╪═══════╪═══════════╣
║ 0  │ 1      │ -      │ SolutionInjection │ solutions=[{}]                                                                                                                                                                                                          │ -        │ 0        │ 1         │ 0.00  │ 0         ║
╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 1  │ 2      │ -      │ HashIndexBuild    │ solutionSet=solutionSet1                                                                                                                                                                                                │ -        │ 1        │ 1         │ 1.00  │ 22        ║
║    │        │        │                   │ joinVars=[]                                                                                                                                                                                                             │          │          │           │       │           ║
║    │        │        │                   │ sourceType=pipeline                                                                                                                                                                                                     │          │          │           │       │           ║
╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 2  │ 3      │ -      │ DFENode           │ DFE Stats=                                                                                                                                                                                                                    │ -        │ 101      │ 100       │ 0.99  │ 32        ║
║    │        │        │                   │ ====> DFE execution time (measured by DFEQueryEngine)                                                                                                                                                                   │          │          │           │       │           ║
║    │        │        │                   │ accepted [micros]=127                                                                                                                                                                                                   │          │          │           │       │           ║
║    │        │        │                   │ ready [micros]=2                                                                                                                                                                                                        │          │          │           │       │           ║
║    │        │        │                   │ running [micros]=5627                                                                                                                                                                                                   │          │          │           │       │           ║
║    │        │        │                   │ finished [micros]=0                                                                                                                                                                                                     │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ ===> DFE execution time (measured in DFENode)                                                                                                                                                                           │          │          │           │       │           ║
║    │        │        │                   │ -> setupTime [ms]=1                                                                                                                                                                                                     │          │          │           │       │           ║
║    │        │        │                   │ -> executionTime [ms]=14                                                                                                                                                                                                │          │          │           │       │           ║
║    │        │        │                   │ -> resultReadTime [ms]=0                                                                                                                                                                                                │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ ===> Static analysis statistics                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ --> 35907 micros spent in parser.                                                                                                                                                                                       │          │          │           │       │           ║
║    │        │        │                   │ --> 7643 micros spent in range count estimation                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ --> 2895 micros spent in value resolution                                                                                                                                                                               │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ --> 39974925 micros spent in optimizer loop                                                                                                                                                                             │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ DFEJoinGroupNode[ children={                                                                                                                                                                                            │          │          │           │       │           ║
║    │        │        │                   │   DFEPatternNode[(?1, TERM[117442062], ?2, ?3) . project DISTINCT[?1, ?2] {rangeCountEstimate=100},                                                                                                                     │          │          │           │       │           ║
║    │        │        │                   │     OperatorInfoWithAlternative[                                                                                                                                                                                        │          │          │           │       │           ║
║    │        │        │                   │       rec=OperatorInfo[                                                                                                                                                                                                 │          │          │           │       │           ║
║    │        │        │                   │         type=INCREMENTAL_PIPELINE_JOIN,                                                                                                                                                                                 │          │          │           │       │           ║
║    │        │        │                   │         costEstimates=OperatorCostEstimates[                                                                                                                                                                            │          │          │           │       │           ║
║    │        │        │                   │           costEstimate=OperatorCostEstimate[in=1.0000,out=100.0000,io=0.0002,comp=0.0000,mem=0],                                                                                                                        │          │          │           │       │           ║
║    │        │        │                   │           worstCaseCostEstimate=OperatorCostEstimate[in=1.0000,out=100.0000,io=0.0002,comp=0.0000,mem=0]]],                                                                                                             │          │          │           │       │           ║
║    │        │        │                   │       alt=OperatorInfo[                                                                                                                                                                                                 │          │          │           │       │           ║
║    │        │        │                   │         type=INCREMENTAL_HASH_JOIN,                                                                                                                                                                                     │          │          │           │       │           ║
║    │        │        │                   │         costEstimates=OperatorCostEstimates[                                                                                                                                                                            │          │          │           │       │           ║
║    │        │        │                   │           costEstimate=OperatorCostEstimate[in=1.0000,out=100.0000,io=0.0003,comp=0.0000,mem=3212],                                                                                                                     │          │          │           │       │           ║
║    │        │        │                   │           worstCaseCostEstimate=OperatorCostEstimate[in=1.0000,out=100.0000,io=0.0003,comp=0.0000,mem=3212]]]]],                                                                                                        │          │          │           │       │           ║
║    │        │        │                   │   DFEPatternNode[(?1, TERM[150997262], ?4, ?5) . project DISTINCT[?1, ?4] {rangeCountEstimate=100},                                                                                                                     │          │          │           │       │           ║
║    │        │        │                   │     OperatorInfoWithAlternative[                                                                                                                                                                                        │          │          │           │       │           ║
║    │        │        │                   │       rec=OperatorInfo[                                                                                                                                                                                                 │          │          │           │       │           ║
║    │        │        │                   │         type=INCREMENTAL_HASH_JOIN,                                                                                                                                                                                     │          │          │           │       │           ║
║    │        │        │                   │         costEstimates=OperatorCostEstimates[                                                                                                                                                                            │          │          │           │       │           ║
║    │        │        │                   │           costEstimate=OperatorCostEstimate[in=100.0000,out=100.0000,io=0.0003,comp=0.0000,mem=6400],                                                                                                                   │          │          │           │       │           ║
║    │        │        │                   │           worstCaseCostEstimate=OperatorCostEstimate[in=100.0000,out=100.0000,io=0.0003,comp=0.0000,mem=6400]]],                                                                                                        │          │          │           │       │           ║
║    │        │        │                   │       alt=OperatorInfo[                                                                                                                                                                                                 │          │          │           │       │           ║
║    │        │        │                   │         type=INCREMENTAL_PIPELINE_JOIN,                                                                                                                                                                                 │          │          │           │       │           ║
║    │        │        │                   │         costEstimates=OperatorCostEstimates[                                                                                                                                                                            │          │          │           │       │           ║
║    │        │        │                   │           costEstimate=OperatorCostEstimate[in=100.0000,out=100.0000,io=0.0010,comp=0.0000,mem=0],                                                                                                                      │          │          │           │       │           ║
║    │        │        │                   │           worstCaseCostEstimate=OperatorCostEstimate[in=100.0000,out=100.0000,io=0.0010,comp=0.0000,mem=0]]]]]                                                                                                          │          │          │           │       │           ║
║    │        │        │                   │ },                                                                                                                                                                                                                      │          │          │           │       │           ║
║    │        │        │                   │ ]                                                                                                                                                                                                                       │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ ===> DFE configuration:                                                                                                                                                                                                 │          │          │           │       │           ║
║    │        │        │                   │ solutionChunkSize=5000                                                                                                                                                                                                  │          │          │           │       │           ║
║    │        │        │                   │ ouputQueueSize=20                                                                                                                                                                                                       │          │          │           │       │           ║
║    │        │        │                   │ numComputeCores=3                                                                                                                                                                                                       │          │          │           │       │           ║
║    │        │        │                   │ maxParallelIO=10                                                                                                                                                                                                        │          │          │           │       │           ║
║    │        │        │                   │ numInitialPermits=12                                                                                                                                                                                                    │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ ====> DFE configuration (reported back)                                                                                                                                                                                 │          │          │           │       │           ║
║    │        │        │                   │ numComputeCores=3                                                                                                                                                                                                       │          │          │           │       │           ║
║    │        │        │                   │ maxParallelIO=2                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ numInitialPermits=12                                                                                                                                                                                                    │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ ===> Statistics & operator histogram                                                                                                                                                                                    │          │          │           │       │           ║
║    │        │        │                   │ ==> Statistics                                                                                                                                                                                                          │          │          │           │       │           ║
║    │        │        │                   │ -> 3741 / 3668 micros total elapsed (incl. wait / excl. wait)                                                                                                                                                           │          │          │           │       │           ║
║    │        │        │                   │ -> 3741 / 3 millis total elapse (incl. wait / excl. wait)                                                                                                                                                               │          │          │           │       │           ║
║    │        │        │                   │ -> 3741 / 0 secs total elapsed (incl. wait / excl. wait)                                                                                                                                                                │          │          │           │       │           ║
║    │        │        │                   │ ==> Operator histogram                                                                                                                                                                                                  │          │          │           │       │           ║
║    │        │        │                   │ -> 47.66% of total time (excl. wait): pipelineScan (2 instances)                                                                                                                                                        │          │          │           │       │           ║
║    │        │        │                   │ -> 10.99% of total time (excl. wait): merge (1 instances)                                                                                                                                                               │          │          │           │       │           ║
║    │        │        │                   │ -> 41.17% of total time (excl. wait): symmetricHashJoin (1 instances)                                                                                                                                                   │          │          │           │       │           ║
║    │        │        │                   │ -> 0.19% of total time (excl. wait): drain (1 instances)                                                                                                                                                                │          │          │           │       │           ║
║    │        │        │                   │                                                                                                                                                                                                                         │          │          │           │       │           ║
║    │        │        │                   │ nodeId | out0   | out1 | opName            | args                                             | rowsIn | rowsOut | chunksIn | chunksOut | elapsed* | outWait | outBlocked | ratio    | rate* [M/s] | rate [M/s] | %     │          │          │           │       │           ║
║    │        │        │                   │ ------ | ------ | ---- | ----------------- | ------------------------------------------------ | ------ | ------- | -------- | --------- | -------- | ------- | ---------- | -------- | ----------- | ---------- | ----- │          │          │           │       │           ║
║    │        │        │                   │ node_0 | node_2 | -    | pipelineScan      | (?1, TERM[117442062], ?2, ?3) DISTINCT [?1, ?2]  | 0      | 100     | 0        | 1         | 874      | 0       | 0          | Infinity | 0.1144      | 0.1144     | 23.83 │          │          │           │       │           ║
║    │        │        │                   │ node_1 | node_2 | -    | pipelineScan      | (?1, TERM[150997262], ?4, ?5) DISTINCT [?1, ?4]  | 0      | 100     | 0        | 1         | 874      | 0       | 0          | Infinity | 0.1144      | 0.1144     | 23.83 │          │          │           │       │           ║
║    │        │        │                   │ node_2 | node_4 | -    | symmetricHashJoin |                                                  | 200    | 100     | 2        | 2         | 1510     | 73      | 0          | 0.50     | 0.0662      | 0.0632     | 41.17 │          │          │           │       │           ║
║    │        │        │                   │ node_3 | -      | -    | drain             |                                                  | 100    | 0       | 1        | 0         | 7        | 0       | 0          | 0.00     | 0.0000      | 0.0000     | 0.19  │          │          │           │       │           ║
║    │        │        │                   │ node_4 | node_3 | -    | merge             |                                                  | 100    | 100     | 2        | 1         | 403      | 0       | 0          | 1.00     | 0.2481      | 0.2481     | 10.99 │          │          │           │       │           ║
╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 3  │ 4      │ -      │ HashIndexJoin     │ solutionSet=solutionSet1                                                                                                                                                                                                │ -        │ 100      │ 100       │ 1.00  │ 4         ║
║    │        │        │                   │ joinType=join                                                                                                                                                                                                           │          │          │           │       │           ║
╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 4  │ 5      │ -      │ Distinct          │ vars=[?s, ?o, ?o1]                                                                                                                                                                                                      │ -        │ 100      │ 100       │ 1.00  │ 9         ║
╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 5  │ 6      │ -      │ Projection        │ vars=[?s, ?o, ?o1]                                                                                                                                                                                                      │ retain   │ 100      │ 100       │ 1.00  │ 2         ║
╟────┼────────┼────────┼───────────────────┼─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────┼──────────┼──────────┼───────────┼───────┼───────────╢
║ 6  │ -      │ -      │ TermResolution    │ vars=[?s, ?o, ?o1]                                                                                                                                                                                                      │ id2value │ 100      │ 100       │ 1.00  │ 11        ║
╚════╧════════╧════════╧═══════════════════╧═════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════════╧══════════╧══════════╧═══════════╧═══════╧═══════════╝
```

# Operator `explain` SPARQL Neptune
<a name="sparql-explain-operators"></a>

Bagian berikut menjelaskan operator dan parameter untuk fitur `explain` SPARQL yang saat ini tersedia di Amazon Neptune.

**penting**  
Fitur `explain` SPARQL sedang disempurnakan. Operator dan parameter yang didokumentasikan di sini mungkin berubah dalam versi mendatang.

**Topics**
+ [Operator `Aggregation`](#sparql-explain-operator-aggregation)
+ [Operator `ConditionalRouting`](#sparql-explain-operator-conditional-routing)
+ [Operator `Copy`](#sparql-explain-operator-copy)
+ [Operator `DFENode`](#sparql-explain-operator-dfenode)
+ [Operator `Distinct`](#sparql-explain-operator-distinct)
+ [Operator `Federation`](#sparql-explain-operator-federation)
+ [Operator `Filter`](#sparql-explain-operator-filter)
+ [Operator `HashIndexBuild`](#sparql-explain-operator-hash-index-build)
+ [Operator `HashIndexJoin`](#sparql-explain-operator-hash-index-join)
+ [Operator `MergeJoin`](#sparql-explain-operator-merge-join)
+ [Operator `NamedSubquery`](#sparql-explain-operator-named-subquery)
+ [Operator `PipelineJoin`](#sparql-explain-operator-pipeline-join)
+ [Operator `PipelineCountJoin`](#sparql-explain-operator-pipeline-count-join)
+ [Operator `PipelinedHashIndexJoin`](#sparql-explain-operator-pipeline-hash-index-join)
+ [Operator `Projection`](#sparql-explain-operator-projection)
+ [Operator `PropertyPath`](#sparql-explain-operator-property-path)
+ [Operator `TermResolution`](#sparql-explain-operator-term-resolution)
+ [Operator `Slice`](#sparql-explain-operator-slice)
+ [Operator `SolutionInjection`](#sparql-explain-operator-solution-injection)
+ [Operator `Sort`](#sparql-explain-operator-sort)
+ [Operator `VariableAlignment`](#sparql-explain-operator-variable-alignment)

## Operator `Aggregation`
<a name="sparql-explain-operator-aggregation"></a>

Melakukan satu agregasi atau lebih, menerapkan semantik dari operator agregasi SPARQL seperti `count`, `max`, `min`, `sum`, dan sebagainya.

`Aggregation` dilengkapi dengan pengelompokan opsional menggunakan klausa `groupBy`, dan kendala `having` opsional.

**Pendapat**
+ `groupBy` — (*Opsional*) Menyediakan klaus `groupBy` yang menentukan urutan ekspresi yang menurut pengelompokan solusi masuk.
+ `aggregates` — (*Wajib*) Menentukan daftar urut ekspresi agregasi.
+ `having` — (*Opsional*) Menambahkan kendala untuk menyaring grup, seperti yang disiratkan oleh klausul `having` dalam kueri SPARQL.

## Operator `ConditionalRouting`
<a name="sparql-explain-operator-conditional-routing"></a>

Merutekan solusi masuk berdasarkan kondisi tertentu. Solusi yang memenuhi kondisi diarahkan ke ID operator yang direferensikan oleh `Out #1`, sedangkan solusi yang tidak diarahkan ke operator direferensikan oleh `Out #2`.

**Pendapat**
+ `condition` — (*Wajib*) Kondisi perutean.

## Operator `Copy`
<a name="sparql-explain-operator-copy"></a>

Mendelegasikan aliran solusi sebagaimana ditentukan oleh mode tertentu.

**Mode**
+ `forward` — Meneruskan solusi untuk operator hilir yang diidentifikasi oleh `Out #1`. 
+ `duplicate` — Menduplikat solusi dan meneruskannya ke masing-masing dari dua operator yang diidentifikasi oleh `Out #1` dan `Out #2`.

`Copy` tidak memiliki argumen.

## Operator `DFENode`
<a name="sparql-explain-operator-dfenode"></a>

Operator ini merupakan abstraksi dari rencana yang dijalankan oleh mesin kueri alternatif DFE. Rencana DFE rinci diuraikan dalam argumen untuk operator ini. Argumen saat ini kelebihan beban untuk berisi statistik runtime rinci dari rencana DFE. Argumen berisi waktu yang dihabiskan dalam berbagai langkah eksekusi kueri oleh DFE.

Abstrak sintaks tree (AST) yang dioptimalkan logis untuk rencana kueri DFE dicetak dengan informasi tentang jenis operator yang dianggap saat perencanaan dan akibat terbaik dan terburuk terkait untuk menjalankan operator. AST saat ini terdiri dari jenis node berikut:
+ `DFEJoinGroupNode` — Merupakan gabungan dari satu `DFEPatternNodes` atau lebih.
+ `DFEPatternNode` - Merangkum pola mendasar menggunakan tupel yang cocok yang diproyeksikan keluar dari database yang mendasari.

Sub-bagiannya, `Statistics & Operator histogram`, berisi rincian tentang waktu eksekusi rencana `DataflowOp` dan rincian waktu CPU yang digunakan oleh masing-masing operator. Di bawah ini ada tabel yang mencetak statistik runtime rinci dari rencana yang dieksekusi oleh DFE.

**catatan**  
Karena DFE adalah fitur eksperimental yang dirilis dalam mode lab, format tepat output `explain` dapat berubah.

## Operator `Distinct`
<a name="sparql-explain-operator-distinct"></a>

Menghitung proyeksi yang berbeda pada subset dari variabel, menghilangkan duplikat. Akibatnya, jumlah solusi yang mengalir lebih besar dari atau sama dengan jumlah solusi yang mengalir keluar.

**Pendapat**
+ `vars` — (*Wajib*) Variabel tempat proyeksi `Distinct` akan diterapkan.

## Operator `Federation`
<a name="sparql-explain-operator-federation"></a>

Melewatkan kueri tertentu ke titik akhir SPARQL remote yang ditentukan.

**Pendapat**
+ `endpoint` — (*Wajib*) URL titik akhir dalam pernyataan `SERVICE` SPARQL. Ini bisa berupa string konstan, atau jika titik akhir kueri ditentukan berdasarkan variabel dalam kueri yang sama, ia dapat menjadi nama variabel.
+ `query` — (*Wajib*) String kueri yang direkonstruksi yang akan dikirim ke titik akhir remote. Mesin menambahkan prefiks default untuk kueri ini bahkan ketika klien tidak menentukan apapun.
+ `silent` — (*Wajib*) Boolean yang menunjukkan apakah kata kunci `SILENT` muncul setelah kata kunci tersebut. `SILENT` memberi tahu mesin untuk tidak menggagalkan seluruh kueri bahkan jika bagian `SERVICE` remote gagal.

## Operator `Filter`
<a name="sparql-explain-operator-filter"></a>

Menyaring solusi yang masuk. Hanya solusi yang memenuhi kondisi filter yang diteruskan ke operator hulu, dan yang lainnya dijatuhkan.

**Pendapat**
+ `condition` — (*Wajib*) Kondisi filter.

## Operator `HashIndexBuild`
<a name="sparql-explain-operator-hash-index-build"></a>

Membawa daftar binding dan melakukan spools pada mereka ke dalam indeks hash yang namanya didefinisikan oleh argumen `solutionSet`. Biasanya, operator berikutnya melakukan penggabungan terhadap set solusi ini, mengacunya dengan nama itu.

**Pendapat**
+ `solutionSet` — (*Wajib*) Nama set solusi indeks hash.
+ `sourceType` — (*Wajib*) Jenis sumber asal binding yang akan disimpan dalam indeks hash diperoleh:
  + `pipeline` — Melakukan spool pada solusi yang masuk dari operator hilir dalam alur operator ke dalam indeks hash.
  + `binding set` - Melakukan spool pada set mengikat tetap yang ditentukan oleh argumen `sourceBindingSet` ke dalam indeks hash.
+ `sourceBindingSet` — (*Opsional*) Jika nilai argumen `sourceType` adalah `binding set`, argumen ini menentukan set binding statis yang akan di-spool ke dalam indeks hash.

## Operator `HashIndexJoin`
<a name="sparql-explain-operator-hash-index-join"></a>

Menggabungkan solusi masuk terhadap set solusi indeks hash yang diidentifikasi oleh argumen `solutionSet`.

**Pendapat**
+ `solutionSet` — (*Wajib*) Nama set solusi yang akan digabungkan. Ini harus berupa indeks hash yang telah dibangun di langkah sebelumnya menggunakan operator `HashIndexBuild`.
+ `joinType` — (*Wajib*) Jenis gabungan yang akan dilakukan:
  + `join` — Gabungan normal, membutuhkan kecocokan persis antara semua variabel bersama.
  + `optional` — Sebuah gabungan `optional` yang menggunakan semantik operator `OPTIONAL` SPARQL.
  + `minus` — Sebuah operasi `minus` yang mempertahankan pemetaan yang tanpa mitra gabungan, menggunakan semanti operator `MINUS` SPARQL.
  + `existence check` — Memeriksa apakah ada mitra gabungan atau tidak, dan mengikat variabel `existenceCheckResultVar` ke hasil pemeriksaan ini.
+ `constraints` — (*Opsional*) Tambahan kendala gabungan yang dipertimbangkan selama penggabungan. Gabungan yang tidak memenuhi kendala ini dibuang.
+ `existenceCheckResultVar` — (*Opsional*) Hanya digunakan untuk gabungan di mana `joinType` sama dengan `existence check` (lihat argumen `joinType` sebelumnya).

## Operator `MergeJoin`
<a name="sparql-explain-operator-merge-join"></a>

Penggabungan yang digabung di lebih dari beberapa set solusi, seperti yang diidentifikasi oleh argumen `solutionSets`.

**Pendapat**
+ `solutionSets` — (*Wajib*) Set solusi yang akan digabungkan bersama.

## Operator `NamedSubquery`
<a name="sparql-explain-operator-named-subquery"></a>

Memicu evaluasi subkueri yang diidentifikasi oleh argumen `subQuery` dan melakukan spools pada hasil ke dalam set solusi yang ditentukan oleh argumen `solutionSet`. Solusi masuk untuk operator diteruskan ke subkueri dan kemudian ke operator berikutnya.

**Pendapat**
+ `subQuery` — (*Wajib*) Nama subkueri yang akan dievaluasi. Subkueri dirender secara eksplisit dalam output.
+ `solutionSet` — (*Wajib*) Nama set solusi tempat menyimpan hasil subkueri.

## Operator `PipelineJoin`
<a name="sparql-explain-operator-pipeline-join"></a>

Menerima output dari operator sebelumnya sebagai input dan menggabungkannya dengan pola tuple yang didefinisikan oleh argumen `pattern`.

**Pendapat**
+ `pattern`— (*Wajib*) Pola, yang mengambil bentuk subject-predicate-object, dan tupel grafik opsional yang mendasari gabungan. Jika `distinct` ditentukan untuk pola, gabungan hanya mengekstrak solusi yang khas dari variabel proyeksi yang ditentukan oleh `projectionVars`, alih-alih semua solusi yang cocok.
+ `inlineFilters` — (*Opsional*) Satu set filter yang akan diterapkan pada variabel dalam pola. Pola dievaluasi bersamaan dengan filter ini.
+ `joinType` — (*Wajib*) Jenis gabungan yang akan dilakukan:
  + `join` — Gabungan normal, membutuhkan kecocokan persis antara semua variabel bersama.
  + `optional` — Sebuah gabungan `optional` yang menggunakan semantik operator `OPTIONAL` SPARQL.
  + `minus` — Sebuah operasi `minus` yang mempertahankan pemetaan yang tanpa mitra gabungan, menggunakan semanti operator `MINUS` SPARQL.
  + `existence check` — Memeriksa apakah ada mitra gabungan atau tidak, dan mengikat variabel `existenceCheckResultVar` ke hasil pemeriksaan ini.
+ `constraints` — (*Opsional*) Tambahan kendala gabungan yang dipertimbangkan selama penggabungan. Gabungan yang tidak memenuhi kendala ini dibuang.
+ `projectionVars`— (*Opsional*) Variabel proyeksi. Digunakan dalam kombinasi bersama `distinct := true` untuk menegakkan ekstraksi proyeksi khas pada satu set variabel tertentu.
+ `cutoffLimit` — (*Opsional*) Batas cutoff untuk jumlah mitra gabungan yang diekstrak. Meskipun tidak ada batas secara default, Anda dapat mengatur ini ke 1 ketika melakukan gabungan untuk menerapkan klausa `FILTER (NOT) EXISTS`, di mana itu cukup untuk membuktikan atau membantah bahwa ada mitra gabungan.

## Operator `PipelineCountJoin`
<a name="sparql-explain-operator-pipeline-count-join"></a>

Varian dari `PipelineJoin`. Alih-alih bergabung, operator ini hanya menghitung mitra gabungan yang cocok dan mengikat hitungan ke variabel yang ditentukan oleh argumen `countVar`.

**Pendapat**
+ `countVar` — (*Wajib*) Variabel yang akan diikatkan pada hasil hitungan, yaitu jumlah mitra gabungan,.
+ `pattern`— (*Wajib*) Pola, yang mengambil bentuk subject-predicate-object, dan tupel grafik opsional yang mendasari gabungan. Jika `distinct` ditentukan untuk pola, gabungan hanya mengekstrak solusi yang khas dari variabel proyeksi yang ditentukan oleh `projectionVars`, alih-alih semua solusi yang cocok.
+ `inlineFilters` — (*Opsional*) Satu set filter yang akan diterapkan pada variabel dalam pola. Pola dievaluasi bersamaan dengan filter ini.
+ `joinType` — (*Wajib*) Jenis gabungan yang akan dilakukan:
  + `join` — Gabungan normal, membutuhkan kecocokan persis antara semua variabel bersama.
  + `optional` — Sebuah gabungan `optional` yang menggunakan semantik operator `OPTIONAL` SPARQL.
  + `minus` — Sebuah operasi `minus` yang mempertahankan pemetaan yang tanpa mitra gabungan, menggunakan semanti operator `MINUS` SPARQL.
  + `existence check` — Memeriksa apakah ada mitra gabungan atau tidak, dan mengikat variabel `existenceCheckResultVar` ke hasil pemeriksaan ini.
+ `constraints` — (*Opsional*) Tambahan kendala gabungan yang dipertimbangkan selama penggabungan. Gabungan yang tidak memenuhi kendala ini dibuang.
+ `projectionVars`— (*Opsional*) Variabel proyeksi. Digunakan dalam kombinasi bersama `distinct := true` untuk menegakkan ekstraksi proyeksi khas pada satu set variabel tertentu.
+ `cutoffLimit` — (*Opsional*) Batas cutoff untuk jumlah mitra gabungan yang diekstrak. Meskipun tidak ada batas secara default, Anda dapat mengatur ini ke 1 ketika melakukan gabungan untuk menerapkan klausa `FILTER (NOT) EXISTS`, di mana itu cukup untuk membuktikan atau membantah bahwa ada mitra gabungan.

## Operator `PipelinedHashIndexJoin`
<a name="sparql-explain-operator-pipeline-hash-index-join"></a>

Ini adalah indeks hash all-in-one build dan operator gabungan. Dibutuhkan daftar binding, menggulungnya menjadi indeks hash, dan kemudian bergabung dengan solusi yang masuk terhadap indeks hash.

**Pendapat**
+ `sourceType`— (*Wajib*) Jenis sumber dari mana binding untuk menyimpan dalam indeks hash diperoleh, salah satu dari:
  + `pipeline`— Penyebab `PipelinedHashIndexJoin` untuk menggeser solusi yang masuk dari operator hilir di pipa operator ke indeks hash.
  + `binding set`— Penyebab `PipelinedHashIndexJoin` untuk menggeser set pengikatan tetap yang ditentukan oleh `sourceBindingSet` argumen ke dalam indeks hash.
+ `sourceSubQuery `— (*Opsional*) Jika nilai `sourceType` argumen adalah`pipeline`, argumen ini menentukan subquery yang dievaluasi dan spooled ke dalam indeks hash.
+ `sourceBindingSet `— (*Opsional*) Jika nilai `sourceType` argumen adalah`binding set`, argumen ini menentukan set pengikatan statis yang akan di-spooled ke indeks hash.
+ `joinType`— (*Wajib*) Jenis bergabung yang akan dilakukan:
  + `join` — Gabungan normal, membutuhkan kecocokan persis antara semua variabel bersama.
  + `optional` — Sebuah gabungan `optional` yang menggunakan semantik operator `OPTIONAL` SPARQL.
  + `minus` — Sebuah operasi `minus` yang mempertahankan pemetaan yang tanpa mitra gabungan, menggunakan semanti operator `MINUS` SPARQL.
  + `existence check` — Memeriksa apakah ada mitra gabungan atau tidak, dan mengikat variabel `existenceCheckResultVar` ke hasil pemeriksaan ini.
+ `existenceCheckResultVar`— (*Opsional*) Hanya digunakan untuk bergabung di mana `joinType` sama `existence check` (lihat argumen JoinType di atas).

## Operator `Projection`
<a name="sparql-explain-operator-projection"></a>

Memproyeksikan di atas subset variabel. Jumlah solusi yang mengalir masuk sama dengan jumlah solusi yang mengalir keluar, namun bentuk solusinya berbeda, tergantung pengaturan mode.

**Mode**
+ `retain` — Menyimpan dalam solusi hanya variabel yang ditentukan oleh argumen `vars`.
+ `drop` — Jatuhkan semua variabel yang ditentukan oleh argumen `vars`.

**Pendapat**
+ `vars`— (*Wajib*) Variabel yang akan dipertahankan atau dijatuhkan, tergantung pengaturan mode.

## Operator `PropertyPath`
<a name="sparql-explain-operator-property-path"></a>

Memungkinkan jalur properti rekursif seperti `+` atau `*`. Neptune mengimplementasikan pendekatan iterasi titik tetap berdasarkan template yang ditentukan oleh argumen `iterationTemplate`. Variabel sisi kiri atau kanan yang dikenal terikat dalam template untuk setiap iterasi titik tetap, sampai tidak ada lagi solusi baru yang dapat ditemukan.

**Pendapat**
+ `iterationTemplate`— (*Wajib*) Nama dari template subkueri yang digunakan untuk mengimplementasikan iterasi titik tetap.
+ `leftTerm`— (*Wajib*) Istilah (variabel atau konstan) di sisi kiri jalur properti.
+ `rightTerm`— (*Wajib*) Istilah (variabel atau konstan) di sisi kanan jalur properti.
+ `lowerBound`— (*Wajib*) Batas bawah untuk iterasi titik tetap (baik `0` untuk kueri `*`, atau `1` untuk kueri `+`).

## Operator `TermResolution`
<a name="sparql-explain-operator-term-resolution"></a>

Menerjemahkan nilai-nilai pengidentifikasi string internal kembali ke string eksternal mereka yang sesuai, atau menerjemahkan string eksternal ke nilai-nilai pengidentifikasi string internal, tergantung modenya.

**Mode**
+ `value2id`— Memetakan istilah seperti literal dan nilai ID internal yang URIs sesuai (pengkodean ke nilai internal).
+ `id2value`— Memetakan nilai ID internal ke istilah yang sesuai seperti literal dan URIs (decoding nilai internal).

**Pendapat**
+ `vars`— (*Wajib*) Menentukan variabel yang string atau string internal IDs harus dipetakan.

## Operator `Slice`
<a name="sparql-explain-operator-slice"></a>

Mengimplementasikan potongan di atas aliran solusi masuk, menggunakan semantik klausa `LIMIT` dan `OFFSET` SPARQL.

**Pendapat**
+ `limit`— (*Opsional*) Batas pada solusi yang akan diteruskan.
+ `offset`— (*Opsional*) Offset di mana solusi dievaluasi untuk penerusan.

## Operator `SolutionInjection`
<a name="sparql-explain-operator-solution-injection"></a>

Tidak menerima input. Menyuntikkan solusi secara statis ke dalam rencana kueri dan mencatatnya dalam argumen `solutions`.

Rencana kueri selalu dimulai dengan injeksi statis ini. Jika solusi statis yang akan disuntikkan dapat berasal dari kueri itu sendiri dengan menggabungkan berbagai sumber binding statis (misalnya, dari klausa `VALUES` atau `BIND`), maka operator `SolutionInjection` menyuntikkan solusi statis turunan ini. Dalam kasus yang paling sederhana, hal ini mencerminkan binding yang tersirat oleh klausa `VALUES` luar.

Jika tidak ada solusi statis dapat diturunkan dari kueri, `SolutionInjection` menyuntikkan solusi kosong, yang disebut solusi universal, yang diperluas dan digandakan sepanjang proses evaluasi kueri.

**Pendapat**
+ `solutions`— (*Wajib*) Urutan solusi yang disuntikkan oleh operator.

## Operator `Sort`
<a name="sparql-explain-operator-sort"></a>

Mengurutkan set solusi menggunakan kondisi pengurutan tertentu.

**Pendapat**
+ `sortOrder`— (*Wajib*) Daftar variabel yang diurutkan, masing-masing berisi pengidentifikasi `ASC` (naik) atau `DESC` (turun), digunakan secara berurutan untuk mengurutkan set solusi.

## Operator `VariableAlignment`
<a name="sparql-explain-operator-variable-alignment"></a>

Memeriksa solusi satu per satu, melakukan penyelarasan pada masing-masing pada dua variabel: `sourceVar` yang ditentukan dan `targetVar` yang ditentukan.

Jika `sourceVar` dan `targetVar` dalam solusi memiliki nilai yang sama, variabel dianggap selaras dan solusi diteruskan, dengan `sourceVar` berulang diproyeksikan keluar.

Jika variabel terikat ke nilai yang berbeda, solusinya disaring seluruhnya.

**Pendapat**
+ `sourceVar`— (*Wajib*) Variabel sumber, untuk dibandingkan dengan variabel target. Jika penyelarasan berhasil dalam solusi, yang berarti bahwa dua variabel memiliki nilai yang sama, variabel sumber diproyeksikan keluar.
+ `targetVar`— (*Wajib*) Variabel target, sebagai pembanding variabel sumber. Dipertahankan bahkan ketika penyelarasan berhasil.

# Keterbatasan `explain` SPARQL di Neptune
<a name="sparql-explain-limitations"></a>

Rilis fitur `explain` dari SPARQL Neptune memiliki keterbatasan berikut.

**Neptune Saat ini Mendukung Explain Hanya dalam Kueri SPARQL SELECT**  
Untuk informasi tentang proses evaluasi untuk bentuk kueri lainnya, seperti kueri `ASK`, `CONSTRUCT`, `DESCRIBE`, dan `SPARQL UPDATE`, Anda dapat mengubah kueri-kueri ini menjadi kueri SELECT. Kemudian gunakan `explain` untuk memeriksa kueri SELECT sesuai sebagai gantinya.

Misalnya, untuk mendapatkan Informasi `explain` tentang kueri `ASK WHERE {...}`, jalankan kueri `SELECT WHERE {...} LIMIT 1` yang sesuai bersama `explain`.

Demikian pula, untuk kueri `CONSTRUCT {...} WHERE {...}`, jatuhkan bagian `CONSTRUCT {...}` dan jalankan kueri `SELECT` dengan `explain` pada klausa `WHERE {...}` kedua. Mengevaluasi klausa `WHERE` kedua umumnya mengungkapkan tantangan utama memproses kueri `CONSTRUCT`, karena solusi yang mengalir keluar dari `WHERE` kedua ke dalam template `CONSTRUCT` umumnya hanya membutuhkan substitusi langsung.

**Operator Explain Dapat Berubah di Rilis yang Akan Datang**  
Operator `explain` SPARQL dan parameternya dapat berubah dalam rilis yang akan datang.

**Output Explain Dapat Berubah di Rilis yang Akan Datang**  
Misalnya, header kolom bisa berubah, dan lebih banyak kolom mungkin ditambahkan ke tabel.