Memfilter dan mengagregasi data grafik dalam Microsoft Fabric

Pemfilteran mempersempit hasil Anda ke baris yang penting. Agregasi meringkas baris tersebut menjadi hitungan, total, dan rata-rata. Artikel ini memperlihatkan kepada Anda cara menerapkan kedua teknik dalam kueri GQL terhadap grafik dalam Microsoft Fabric.

Contohnya menggunakan himpunan data sampel jejaring sosial. Untuk penjelasan menyeluruh tentang alur dan pernyataan kueri, lihat panduan bahasa GQL.

Gunakan artikel ini untuk penyaringan baris dan pola, agregasi terkelompok dan tidak dikelompokkan, filter khusus agregat, dan routing bersyarat. Untuk membangun pola multihop dan memilih jalur, lihat Tulis kueri pola grafik. Untuk tugas bisnis yang siap disesuaikan, lihat Menulis kueri GQL umum.

Prasyarat

Memfilter baris dengan FILTER

Gunakan FILTER untuk menyimpan hanya baris yang memenuhi kondisi. Tempatkan FILTER setelah MATCH untuk mempersempit hasil yang cocok.

Kueri berikut mengembalikan semua wanita dengan nama dan ulang tahun mereka:

MATCH (p:Person)
FILTER p.gender = 'female'
RETURN p.firstName, p.lastName, p.birthday

Gabungkan beberapa kondisi dengan AND dan OR. Misalnya, kueri berikut mengembalikan nama semua wanita yang lahir sebelum 1990:

MATCH (p:Person)
FILTER p.gender = 'female' AND p.birthday < 19900101
RETURN p.firstName, p.lastName

Tip

Gunakan klausa inline WHERE ketika kondisi menentukan node atau edge mana yang dapat berpartisipasi dalam pertandingan. Gunakan FILTER ketika kondisi berlaku untuk baris yang dihasilkan oleh pernyataan sebelumnya. Penempatan predikat dapat mengubah hasil jalur terpendek; lihat Tempatkan predikat sebelum atau sesudah pemilihan jalur.

Filter selama pencocokan pola

Klausa inline WHERE di dalam MATCH pola membatasi node dan tepi mana yang memenuhi syarat untuk match. Pengoptimal kueri dapat menerapkan predikat yang setara selama pemindaian, sehingga sintaks sebaris pada dasarnya tidak lebih cepat daripada FILTER yang terpisah. Pilih bentuk yang mengekspresikan semantik yang dimaksudkan.

Misalnya, untuk menemukan orang yang lahir sebelum 1994 bersama dengan perusahaan tempat mereka bekerja, membatasi hasil untuk perusahaan yang namanya dimulai dengan 'A':

MATCH (p:Person WHERE p.birthday < 19940101)-[:workAt]->(c:Company WHERE c.name STARTS WITH 'A')
RETURN p.firstName, p.lastName, c.name

Filter properti tepi dengan cara yang sama. Misalnya, untuk menampilkan hanya orang yang mulai bekerja di perusahaan pada tahun 2000 atau setelahnya:

MATCH (p:Person)-[w:workAt WHERE w.workFrom >= 2000]->(c:Company)
RETURN p.firstName, p.lastName, c.name, w.workFrom

Untuk informasi lebih lanjut tentang memilih antara penyaringan inline dan pasca-pertandingan, lihat Optimalkan performa kueri GQL.

Menangani nilai null dalam filter

GQL menggunakan logika tiga nilai: predikat mengevaluasi ke TRUE, , FALSEatau UNKNOWN. Saat nilai properti null, perbandingan mengembalikan UNKNOWN. FILTER memperlakukan UNKNOWN sebagai tidak cocok, maka baris tersebut dikecualikan.

Gunakan IS NULL dan IS NOT NULL untuk menguji nilai null secara eksplisit:

-- Only include people whose browser is known
MATCH (p:Person)
FILTER p.browserUsed IS NOT NULL
RETURN p.firstName, p.browserUsed

Gunakan coalesce() untuk mengganti nilai default saat properti mungkin null:

MATCH (p:Person)
RETURN p.firstName, coalesce(p.browserUsed, 'Unknown browser') AS browser

Perhatian

NULL = NULL bernilai UNKNOWN, bukan TRUE. Selalu gunakan IS NULL untuk menguji nilai null, bukan kesetaraan.

Hasil agregat dengan RETURN

Gunakan fungsi agregat di RETURN untuk meringkas hasil Anda. Graph mendukung fungsi agregat berikut: COUNT, , SUM, MINAVG, MAX, COLLECT_LISTCOLLECT_ONEdan COLLECT_ELEMENTS.

Misalnya, untuk menghitung semua orang dalam grafik:

MATCH (p:Person)
RETURN count(*) AS totalPeople

Untuk menghitung nilai yang berbeda seperti berapa banyak perusahaan yang berbeda mempekerjakan orang:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN count(DISTINCT c) AS companyCount

Masukan filter untuk satu agregasi

Tambahkan FILTER (WHERE predicate) setelah agregat untuk memfilter hanya input agregat tersebut. Agregat lain dalam RETURN yang sama tetap menerima semua baris input.

MATCH (p:Person)
RETURN count(*) AS allPeople,
       count(*) FILTER (WHERE p.birthday < 19900101) AS peopleBornBefore1990

Tambahkan LIMIT di dalam filter agregat untuk menggunakan paling banyak sebanyak itu baris yang memenuhi syarat. Kueri menerapkan predikat sebelum batas khusus agregat.

MATCH (p:Person)
RETURN count(*) FILTER (WHERE p.birthday < 19900101 LIMIT 100) AS sampleCount

FILTER dan LIMIT yang khusus untuk agregat tidak menghapus baris dari bagian kueri lainnya. Gunakan pernyataan FILTER atau klausa WHERE pada tingkat kecocokan saat Anda ingin memfilter aliran baris.

Kumpulkan nilai

Gunakan COLLECT_LIST untuk mengembalikan satu elemen daftar untuk setiap nilai input, termasuk nilai nol. Tambahkan DISTINCT untuk menghapus duplikat.

MATCH (p:Person)
RETURN collect_list(DISTINCT p.browserUsed) AS browsers

COLLECT_ONE Mengembalikan satu nilai input non-null. Nilai yang dipilih tidak deterministik, jadi gunakan hanya ketika nilai dari grup dapat diterima.

COLLECT_ELEMENTS menerima input bernilai daftar dan menggabungkan elemennya menjadi satu daftar:

MATCH (p:Person)
RETURN collect_elements([p.firstName, p.lastName]) AS names

Tanpa mengelompokkan kolom, kueri agregat tanpa baris input akan mengembalikan daftar kosong dari COLLECT_LIST dan COLLECT_ELEMENTS dan null dari COLLECT_ONE.

Mengelompokkan hasil dengan GROUP BY

GROUP BY Gunakan RETURN untuk mengelompokkan baris menurut nilai bersama dan menghitung agregat dalam setiap grup. Pengelompokan ini setara dengan GQL SQL GROUP BY.

Misalnya, untuk menghitung karyawan per perusahaan:

MATCH (p:Person)-[:workAt]->(c:Company)
LET companyId = c.id, companyName = c.name
RETURN companyId, companyName, count(*) AS employeeCount
GROUP BY companyId, companyName
ORDER BY employeeCount DESC

Kelompokkan menurut beberapa kolom dan komputasi beberapa agregat sekaligus. Misalnya, uraikan jumlah orang dan rentang ulang tahun berdasarkan jenis kelamin dan browser, mengembalikan 10 kombinasi yang paling umum:

MATCH (p:Person)
LET gender = p.gender
LET browser = p.browserUsed
RETURN gender,
       browser,
       count(*) AS personCount,
       min(p.birthday) AS earliestBirthday,
       max(p.birthday) AS latestBirthday
GROUP BY gender, browser
ORDER BY personCount DESC
LIMIT 10

Note

Semua ekspresi non-agregat di RETURN harus muncul di GROUP BY. Ekspresi yang tidak ada GROUP BY harus menggunakan fungsi agregat.

Mengurutkan dan membatasi hasil agregat

Gunakan ORDER BY dan LIMIT bersama-sama dengan GROUP BY untuk menemukan hasil N teratas.

Misalnya, untuk menemukan lima kota teratas menurut jumlah penduduk:

MATCH (p:Person)-[:isLocatedIn]->(city:City)
LET cityId = city.id, cityName = city.name
RETURN cityId, cityName, count(*) AS residentCount
GROUP BY cityId, cityName
ORDER BY residentCount DESC
LIMIT 5

Penting

Tempatkan ORDER BY sebelum LIMIT. LIMIT selalu berlaku untuk kumpulan hasil yang sudah diurutkan.

Arahkan baris dengan pernyataan bersyarat

Gunakan pernyataan kondisional untuk mengarahkan setiap baris masuk ke cabang pertama yang cocok. Input dapat berasal dari tahap kueri sebelumnya, bukan hanya agregasi. Sebagai contoh, kueri berikut mengkategorikan perusahaan setelah menghitung jumlah karyawan mereka:

MATCH (p:Person)-[:workAt]->(c:Company)
LET companyId = c.id, companyName = c.name
RETURN companyId, companyName, count(*) AS employeeCount
GROUP BY companyId, companyName
NEXT
WHEN employeeCount >= 100u THEN
  RETURN companyId, companyName, employeeCount, 'Large' AS category
WHEN employeeCount >= 10u THEN
  RETURN companyId, companyName, employeeCount, 'Medium' AS category
ELSE
  RETURN companyId, companyName, employeeCount, 'Small' AS category

Branch dapat menjalankan pernyataan kueri lengkap dan prosedur bersarang, bukan hanya mengembalikan ekspresi. Contoh berikut mengirim tiga baris input melalui bentuk cabang yang berbeda. Satu cabang menjalankan sebuah MATCH, satu cabang menggabungkan dua agregat dengan UNION ALL lalu mengagregasikan hasilnya, dan cabang fallback mengembalikan sebuah konstanta:

FOR selector IN [1, 2, 3]
RETURN selector
NEXT
WHEN selector = 1 THEN
  MATCH (:Person)-[:knows]->(:Person)
  RETURN count(*) AS total, 'Knows edges' AS category
WHEN selector = 2 THEN {
  MATCH (:Person)-[:workAt]->(:Company)
  RETURN count(*) AS partialCount
  UNION ALL
  MATCH (:Person)-[:studyAt]->(:University)
  RETURN count(*) AS partialCount
  NEXT
  RETURN sum(partialCount) AS total, 'Affiliation edges' AS category
}
ELSE
  RETURN 0u AS total, 'No selected metric' AS category

Mesin kueri mengevaluasi predikat secara berurutan untuk setiap baris. Hanya menjalankan cabang pertama yang cocok. Jika sebuah predikat bernilai UNKNOWN, evaluasi dilanjutkan ke cabang berikutnya. Tanpa kondisi ELSE, baris yang tidak cocok dengan cabang WHEN akan dihilangkan.

Pernyataan kondisional berbeda dengan CASE ekspresi. Graph mendukung ekspresi sederhana CASE <expression> WHEN <value> untuk pemilihan nilai berbasis kesetaraan. Ekspresi yang dicari CASE WHEN <predicate> tidak didukung. Untuk informasi lebih lanjut, lihat Pernyataan kondisional.

Konten terkait

  • Last updated on