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

# 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).