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

# Petunjuk kueri SPARQL `joinOrder`
<a name="sparql-query-hints-joinOrder"></a>

Ketika Anda mengirimkan kueri SPARQL, mesin kueri Amazon Neptune menyelidiki struktur kueri. Mesin tersebut mengurutkan ulang bagian dari kueri dan mencoba untuk meminimalkan jumlah pekerjaan yang diperlukan untuk evaluasi dan waktu respon kueri.

Misalnya, urutan pola tripel yang terhubung biasanya tidak dievaluasi dalam urutan yang diberikan. Urutan tersebut diurutkan ulang menggunakan heuristik dan statistik seperti selektivitas masing-masing pola dan bagaimana mereka terhubung melalui variabel bersama. Selain itu, jika kueri Anda berisi pola yang lebih kompleks seperti subkueri, FILTERs, atau blok OPSIONAL atau MINUS yang kompleks, mesin kueri Neptunus menyusun ulang jika memungkinkan, bertujuan untuk urutan evaluasi yang efisien.

Untuk kueri yang lebih kompleks, urutan di mana Neptune memilih untuk mengevaluasi kueri mungkin tidak selalu optimal. Misalnya, Neptune mungkin kehilangan karakteristik spesifik data instans (seperti mencapai node daya dalam grafik) yang muncul selama evaluasi kueri.

Jika Anda tahu karakteristik data yang tepat dan ingin secara manual mendikte urutan eksekusi kueri, gunakan petunjuk kueri `joinOrder` Neptune untuk menentukan bahwa kueri dievaluasi dalam urutan yang diberikan.

## Sintaks petunjuk SPARQ `joinOrder`
<a name="sparql-query-hints-joinOrder-syntax"></a>

Petunjuk kueri `joinOrder` ditentukan sebagai pola tripel yang disetakan dalam kueri SPARQL.

Untuk kejelasan, sintaks berikut menggunakan awalan `hint` yang didefinisikan dan disertakan dalam kueri untuk menentukan namespace petunjuk kueri Neptune:

```
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
scope hint:joinOrder "Ordered" .
```

**Cakupan yang Tersedia**
+ `hint:Query`
+ `hint:Group`

Untuk informasi lebih lanjut tentang cakupan petunjuk kueri, lihat [Cakupan petunjuk kueri SPARQL di Neptune](sparql-query-hints.md#sparql-query-hints-scope).

## Contoh petunjuk SPARQL `joinOrder`
<a name="sparql-query-hints-joinOrder-example"></a>

Bagian ini menunjukkan kueri yang ditulis dengan dan tanpa petunjuk kueri `joinOrder` dan optimasi terkait.

Sebagai contoh, asumsikan bahwa set data berisi hal berikut ini:
+ Satu orang bernama `John` yang `:likes` 1.000 orang, termasuk `Jane`.
+ Satu orang bernama `Jane` yang `:likes` 10 orang, termasuk `John`.

**Tidak Ada Petunjuk Kueri**  
Kueri SPARQL berikut mengekstrak semua pasangan orang bernama `John` dan `Jane` yang saling menyukai satu sama lain dari satu set data jejaring sosial:

```
PREFIX : <https://example.com/>
SELECT ?john ?jane {
  ?person1 :name "Jane" .
  ?person1 :likes ?person2 .
  ?person2 :name "John" .
  ?person2 :likes ?person1 .
}
```

Mesin kueri Neptune mungkin mengevaluasi pernyataan dalam urutan yang berbeda dari yang ditulis. Sebagai contoh, mesin mungkin memilih untuk menilai dalam susunan berikut:

1. Temukan semua orang yang bernama `John`.

1. Temukan semua orang yang terhubung ke `John` berdasarkan edge `:likes`.

1. Saring set ini berdasarkan orang yang bernama `Jane`.

1. Saring set ini berdasarkan orang yang terhubung ke `John` berdasarkan edge `:likes`.

Menurut set data, mengevaluasi dalam urutan ini menghasilkan 1.000 entitas yang diekstraksi pada langkah kedua. Langkah ketiga mempersempit ini ke node tunggal, `Jane`. Langkah terakhir kemudian menentukan bahwa `Jane` juga `:likes` node `John`.

**Petunjuk Kueri**  
Akan menguntungkan untuk memulai dengan node `Jane` karena dia hanya memiliki 10 edge `:likes` keluar. Hal ini mengurangi jumlah pekerjaan selama evaluasi kueri dengan menghindari ekstraksi 1.000 entitas selama langkah kedua.

Contoh berikut menggunakan petunjuk kueri **JoinOrder** untuk memastikan bahwa node `Jane` dan edge keluarnya diproses terlebih dulu dengan menonaktifkan semua pengurutan ulang bergabung otomatis untuk kueri:

```
PREFIX : <https://example.com/>
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
SELECT ?john ?jane {
  hint:Query hint:joinOrder "Ordered" .
  ?person1 :name "Jane" .
  ?person1 :likes ?person2 .
  ?person2 :name "John" .
  ?person2 :likes ?person1 .
}
```

Skenario dunia nyata yang berlaku mungkin berupa aplikasi jaringan sosial di mana orang-orang dalam jaringan diklasifikasikan sebagai influencer dengan banyak koneksi atau sebagai pengguna normal dengan beberapa koneksi. Dalam skenario seperti itu, Anda dapat memastikan bahwa pengguna normal (`Jane`) diproses sebelum influencer (`John`) dalam kueri seperti contoh sebelumnya.

**Petunjuk Kueri dan Pengurutan Ulang**  
Anda dapat mengolah contoh ini satu langkah lebih jauh. Jika Anda tahu bahwa atribut `:name` unik untuk node tunggal, Anda bisa mempercepat kueri dengan pengurutan ulang dan menggunakan petunjuk kueri `joinOrder`. Langkah ini memastikan bahwa node unik diekstraksi pertama.

```
PREFIX : <https://example.com/>
PREFIX hint: <http://aws.amazon.com/neptune/vocab/v01/QueryHints#>
SELECT ?john ?jane {
  hint:Query hint:joinOrder "Ordered" .
  ?person1 :name "Jane" .
  ?person2 :name "John" .
  ?person1 :likes ?person2 .
  ?person2 :likes ?person1 .
}
```

Dalam kasus ini, Anda dapat mengurangi kueri untuk tindakan tunggal berikut di setiap langkah:

1. Cari node satu orang dengan `:name` `Jane`.

1. Cari node satu orang dengan `:name` `John`.

1. Pastikan bahwa node pertama terhubung ke node kedua dengan edge `:likes`.

1. Pastikan bahwa node kedua terhubung ke node pertama dengan edge `:likes`.



**penting**  
Jika Anda memilih urutan yang salah, petunjuk kueri `joinOrder` dapat menyebabkan penurunan kinerja yang signifikan. Sebagai contoh, contoh sebelumnya akan menjadi tidak efisien jika atribut `:name` tidak unik. Jika semua 100 node diberi nama `Jane` dan semua 1.000 node diberi nama `John`, maka akhir kueri akan memeriksa 1.000 \$1 100 (100.000) pasang untuk edge `:likes`.