Bagikan melalui

Panduan bahasa GQL

Nota

Fitur ini saat ini dalam pratinjau publik. Pratinjau ini disediakan tanpa perjanjian tingkat layanan, dan tidak disarankan untuk beban kerja produksi. Fitur tertentu mungkin tidak didukung atau mungkin memiliki kemampuan terbatas. Untuk informasi lebih lanjut, lihat Supplemental Terms of Use for Microsoft Azure Previews.

Bahasa Kueri Grafik GQL adalah bahasa kueri standar ISO untuk database grafik. Ini membantu Anda mengkueri dan bekerja dengan data grafik secara efisien.

Grup kerja ISO yang sama yang menstandarkan SQL mengembangkan GQL, sehingga menjaga konsistensi dan kekakuan. Jika Anda terbiasa dengan SQL, Anda akan menemukan banyak kesamaan dalam GQL, seperti ekspresi, predikat, dan jenis. Kesamaan ini membuatnya lebih mudah untuk memulai dengan GQL.

Panduan ini melayani pendatang baru yang mempelajari dasar-dasar GQL dan pengguna berpengalaman yang mencari teknik lanjutan dan informasi referensi yang komprehensif.

Nota

Standar Internasional resmi untuk GQL adalah ISO/IEC 39075 Information Technology - Database Languages - GQL.

Prasyarat

Sebelum menyelam ke GQL, biasakan diri dengan konsep-konsep ini:

  • Pemahaman dasar tentang database - Pengalaman dengan sistem database apa pun seperti relasional (SQL), NoSQL, atau grafik sangat membantu.
  • Konsep grafik - Memahami simpul, tepi, dan hubungan dalam data yang terhubung.
  • Dasar-dasar kueri - Pengetahuan tentang konsep kueri dasar seperti pemfilteran, pengurutan, dan agregasi.

Latar belakang yang direkomendasikan:

  • Pengalaman dengan bahasa SQL atau openCypher membuat pembelajaran sintaks GQL lebih mudah (ini adalah akar GQL).
  • Pemahaman tentang pemodelan data membantu desain skema grafik.
  • Memahami kasus penggunaan spesifik Anda untuk data grafik.

Apa yang Anda butuhkan:

  • Akses ke Microsoft Fabric dengan kemampuan grafik.
  • Contoh data atau kesediaan untuk bekerja dengan contoh jejaring sosial kami.
  • Editor teks dasar untuk menulis kueri.

Petunjuk / Saran

Jika Anda baru menggunakan database grafik, mulailah dengan gambaran umum model data grafik sebelum melanjutkan dengan panduan ini.

Apa yang membuat GQL istimewa

GQL dirancang khusus untuk data grafik. Desain ini membuatnya alami dan intuitif untuk bekerja dengan informasi yang terhubung.

Tidak seperti SQL, yang bergantung pada gabungan tabel untuk mengekspresikan hubungan, GQL menggunakan pola grafik visual. Pola-pola ini secara langsung mencerminkan bagaimana entitas terhubung, membuat kueri lebih mudah dibaca dan lebih mudah dialihkan.

Misalkan Anda ingin menemukan orang dan teman-teman mereka (orang-orang yang saling mengenal) yang keduanya lahir sebelum 1999. Berikut adalah cara GQL mengekspresikan kondisi tersebut menggunakan pola grafik visual:

MATCH (person:Person)-[:knows]-(friend:Person)
WHERE person.birthday < 19990101 
  AND friend.birthday < 19990101
RETURN person.firstName || ' ' || person.lastName AS person_name, 
       friend.firstName || ' ' || friend.lastName AS friend_name

Kueri ini menemukan teman (orang yang saling mengenal) yang sama-sama lahir sebelum 1999. Pola (person:Person)-[:knows]-(friend:Person) secara visual menunjukkan struktur hubungan yang Anda cari - seperti menggambar diagram data Anda.

Dasar-dasar GQL

Sebelum menyelami kueri, pahami konsep inti ini yang membentuk fondasi GQL:

  • Grafik menyimpan data Anda sebagai simpul (entitas) dan tepi (hubungan), masing-masing dengan label dan properti.
  • Jenis grafik bertindak seperti skema, menentukan simpul dan tepi apa yang dapat ada di grafik Anda.
  • Batasan adalah aturan dan batasan tambahan yang diberlakukan jenis grafik pada grafik untuk memberlakukan integritas data.
  • Kueri menggunakan pernyataan seperti MATCH, , FILTERdan RETURN untuk memproses data dan menampilkan hasil.
  • Pola menjelaskan struktur grafik yang ingin Anda temukan menggunakan sintaks visual intuitif.
  • Ekspresi melakukan perhitungan dan perbandingan pada data Anda, mirip dengan ekspresi SQL.
  • Predikat adalah ekspresi nilai boolean yang memfilter hasil dalam kueri.
  • Jenis nilai menentukan jenis nilai apa yang dapat Anda proses dan simpan.

Memahami data grafik

Untuk bekerja secara efektif dengan GQL, Anda perlu memahami bagaimana data grafik disusun. Fondasi ini membantu Anda menulis kueri yang lebih baik dan memodelkan data Anda secara efektif.

Simpul dan tepi: blok penyusun

Di GQL, Anda bekerja dengan grafik properti berlabel. Grafik terdiri dari dua jenis elemen:

  • Simpul biasanya mewakili entitas ("kata benda") dalam sistem Anda—hal-hal seperti orang, organisasi, postingan, atau produk. Mereka adalah objek independen yang ada di domain Anda. Simpul terkadang juga disebut simpul.

  • Tepi mewakili hubungan antara entitas ("kata kerja") - bagaimana entitas Anda terhubung dan berinteraksi.

Misalnya, orang saling mengenal (:knows), organisasi yang beroperasi di wilayah tertentu (:operates), atau pelanggan yang membeli produk (:purchased).
Tepi terkadang juga disebut hubungan.

Setiap elemen grafik memiliki karakteristik ini:

  • ID internal yang secara unik mengidentifikasinya
  • Satu atau beberapa label - nama deskriptif seperti Person atau knows. Di Microsoft Fabric, tepi grafik selalu memiliki satu label.
  • Properti - pasangan nama-nilai yang menyimpan data tentang elemen (seperti firstName: "Alice" atau birthday: "19730108").

Bagaimana grafik disusun

Setiap tepi menyambungkan tepat dua simpul: sumber dan tujuan. Koneksi ini membuat struktur grafik dan menunjukkan bagaimana entitas berhubungan satu sama lain. Arah tepi penting - siapa Person yang follows lain Person membuat hubungan yang diarahkan.

Nota

Graph di Microsoft Fabric saat ini tidak mendukung tepi yang tidak terarah.

Grafik properti seperti yang didukung di Microsoft Fabric selalu terbentuk dengan baik, yang berarti setiap tepi menghubungkan dua simpul yang valid. Jika Anda melihat tepi dalam grafik, kedua titik akhirnya ada di grafik yang sama.

Model grafik dan jenis grafik

Model grafik menjelaskan struktur grafik di Microsoft Fabric. Ini bertindak seperti skema database untuk domain aplikasi Anda. Model grafik mendefinisikan:

  • Simpul dan tepi mana yang dapat ada
  • Label dan properti apa yang dapat mereka miliki
  • Bagaimana simpul dan tepi dapat tersambung

Model grafik juga memastikan integritas data melalui batasan, terutama batasan kunci simpul yang menentukan properti mana yang secara unik mengidentifikasi setiap simpul.

Nota

Anda dapat menentukan model grafik dengan menggunakan sintaks standar GQL. Dalam hal ini, mereka disebut jenis grafik.

Contoh praktis: jejaring sosial

Sepanjang dokumentasi ini, contoh jejaring sosial mengilustrasikan konsep GQL. Memahami domain ini membantu Anda mengikuti contoh dan menerapkan pola serupa ke data Anda sendiri.

Diagram memperlihatkan skema jejaring sosial.

Nota

Contoh jejaring sosial berasal dari LDBC SNB (LDBC Social Network Benchmark) yang diterbitkan oleh GDC (Graph Data Council). Lihat artikel "Tolok Ukur Jejaring Sosial LDBC" untuk detail lebih lanjut.

Entitas jejaring sosial

Jejaring sosial kami mencakup jenis simpul utama ini, mewakili entitas domain:

Orang-orang memiliki informasi pribadi seperti nama, ulang tahun, dan jenis kelamin. Mereka tinggal di kota-kota dan membentuk koneksi sosial.

Tempat membentuk hierarki geografis:

  • Kota-kota seperti "New York" atau "London"
  • Negara/wilayah seperti "Amerika Serikat" atau "Inggris Raya"
  • Benua seperti "Amerika Utara" atau "Eropa"

Organisasi tempat orang menghabiskan waktu:

  • Universitas tempat orang belajar
  • Perusahaan tempat orang bekerja

Konten dan diskusi:

  • Forum dengan judul yang berisi postingan
  • Postingan dengan konten, bahasa, dan gambar opsional
  • Komentar yang membalas postingan atau komentar lainnya
  • Tag yang mengategorikan konten dan mewakili minat

Bagaimana semuanya terhubung

Koneksi antar entitas membuat jaringan menarik:

  • Orang-orang saling mengenal (persahabatan, :knows).
  • Orang bekerja di perusahaan (:workAt) atau belajar di universitas (:studyAt).
  • Orang membuat postingan dan komentar (:hasCreator).
  • Orang menyukai postingan dan komentar (:likes).
  • Postingan, forum, dan komentar dapat memiliki tag (:hasTag).
  • Orang-orang memiliki minat dalam tag tertentu (:hasInterest).
  • Forum berisi postingan (:containerOf) dan memiliki anggota (:hasMember) dan moderator (:hasModerator).

Tepi grafik mewakili hubungan domain. Jaringan kaya ini menciptakan banyak peluang untuk kueri dan analisis yang menarik.

Lihat spesifikasi skema lengkap

Kueri GQL pertama Anda

Sekarang setelah Anda memahami dasar-dasar grafik, mari kita lihat cara mengkueri data grafik menggunakan GQL. Contoh-contoh ini dibangun dari sederhana hingga kompleks, menunjukkan kepada Anda bagaimana pendekatan GQL membuat kueri grafik intuitif dan kuat.

Mulai sederhana: temukan semua orang

Mulailah dengan kueri paling mendasar yang mungkin. Temukan nama (nama depan, nama belakang) semua orang:Person dalam grafik.

MATCH (p:Person)
RETURN p.firstName, p.lastName

Kueri ini dijalankan sebagai berikut:

  1. MATCH menemukan semua simpul berlabel Person.
  2. RETURN menunjukkan nama depan dan belakang mereka.

Menambahkan pemfilteran: menemukan orang tertentu

Sekarang temukan orang dengan karakteristik tertentu. Dalam hal ini, temukan semua orang bernama Alice dan tunjukkan nama dan ulang tahun mereka.

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

Kueri ini dijalankan sebagai berikut:

  1. MATCH menemukan semua simpul (p) berlabel Orang.
  2. FILTER node (p) yang nama depannya adalah Alice.
  3. RETURN menunjukkan nama depan, nama belakang, dan ulang tahun mereka.

Struktur kueri dasar

Kueri GQL dasar semuanya mengikuti pola yang konsisten: urutan pernyataan yang bekerja sama untuk menemukan, memfilter, dan mengembalikan data. Sebagian besar kueri dimulai dengan MATCH untuk menemukan pola dalam grafik dan diakhiri dengan RETURN untuk menentukan output.

Berikut adalah kueri sederhana yang menemukan pasangan orang yang saling mengenal dan berbagi tanggal lahir yang sama, lalu mengembalikan jumlah total pasangan teman tersebut.

MATCH (n:Person)-[:knows]-(m:Person)
FILTER n.birthday = m.birthday
RETURN count(*) AS same_age_friends

Kueri ini dijalankan sebagai berikut:

  1. MATCH menemukan semua pasangan Person simpul yang saling mengenal
  2. FILTER hanya menyimpan pasangan di mana kedua orang memiliki ulang tahun yang sama
  3. RETURN menghitung berapa banyak pasangan teman tersebut yang ada

Petunjuk / Saran

Anda juga dapat melakukan pemfilteran secara langsung sebagai bagian dari pola dengan menambahkan WHERE klausa. Misalnya, MATCH (n:Person WHERE n.age > 23) hanya cocok dengan Person simpul yang propertinya age lebih besar dari 23.

GQL mendukung komentar baris gaya // C, komentar baris gaya -- SQL, dan komentar blok gaya /* */ C.

Pernyataan umum

  • MATCH: Mengidentifikasi pola grafik yang akan ditelusuri—di sinilah Anda menentukan struktur data yang Anda minati.
  • LET: Menetapkan variabel baru atau nilai komputasi berdasarkan data yang cocok—menambahkan kolom turunan ke hasil.
  • FILTER: Mempersempit hasil dengan menerapkan kondisi—menghapus baris yang tidak memenuhi kriteria.
  • ORDER BY: Mengurutkan data yang difilter—membantu mengatur output berdasarkan satu atau beberapa bidang.
  • OFFSET dan LIMIT: Batasi jumlah baris yang ditampilkan—berguna untuk kueri penomoran halaman atau top-k.
  • RETURN: Menentukan output akhir—menentukan data apa yang harus disertakan dalam kumpulan hasil dan melakukan agregasi.

Bagaimana pernyataan bekerja sama

Pernyataan GQL membentuk alur, di mana setiap pernyataan memproses output dari yang sebelumnya. Eksekusi berurutan ini membuat kueri mudah dibaca dan di-debug karena urutan eksekusi cocok dengan urutan pembacaan.

Poin utama:

  • Pernyataan secara efektif dieksekusi secara berurutan.
  • Setiap pernyataan mengubah data dan meneruskannya ke pernyataan berikutnya.
  • Ini menciptakan aliran data yang jelas dan dapat diprediksi yang menyederhanakan kueri kompleks.

Penting

Secara internal, eksekusi pernyataan dapat diurutkan ulang dan pernyataan individual dapat dijalankan secara paralel oleh Microsoft Fabric untuk memaksimalkan performa. Namun, hal ini tidak akan memengaruhi kebenaran hasil.

Contoh komposisi pernyataan

Kueri GQL berikut menemukan 10 orang pertama yang bekerja di perusahaan dengan nama "Air", mengurutkan mereka berdasarkan nama lengkap, dan mengembalikan nama lengkap mereka bersama dengan nama perusahaan mereka.

-- Data flows: Match → Let → Filter → Order → Limit → Return
MATCH (p:Person)-[:workAt]->(c:Company)           -- Input: unit table, Output: (p, c) table
LET fullName = p.firstName || ' ' || p.lastName   -- Input: (p, c) table, Output: (p, c, fullName) table
FILTER c.name CONTAINS 'Air'                      -- Input: (p, c, fullName) table, Output: filtered table
ORDER BY fullName                                 -- Input: filtered table, Output: sorted table
LIMIT 10                                          -- Input: sorted table, Output: top 10 rows table
RETURN fullName, c.name AS companyName            -- Input: top 10 rows table
                                                  -- Output: projected (fullName, companyName) result table

Kueri ini dijalankan sebagai berikut:

  1. MATCH menemukan orang-orang yang bekerja di perusahaan dengan "Air" atas nama mereka.
  2. LET membuat nama lengkap dengan menggabungkan nama depan dan keluarga.
  3. FILTER hanya karyawan Contoso.
  4. ORDER BY mengurutkan menurut nama lengkap.
  5. LIMIT mengambil 10 hasil pertama.
  6. RETURN mengembalikan nama dan lokasi perusahaan.

Variabel menyambungkan data Anda

Variabel, seperti p, , cdan fullName dalam contoh sebelumnya, membawa data antar pernyataan. Saat Anda menggunakan kembali nama variabel, GQL secara otomatis memastikannya merujuk ke data yang sama, menciptakan kondisi gabungan yang kuat. Variabel terkadang juga disebut variabel pengikatan.

Anda dapat mengategorikan variabel dengan cara yang berbeda:

Dengan mengikat sumber:

  • Variabel pola - terikat dengan pola grafik yang cocok
  • Variabel reguler - terikat oleh konstruksi bahasa lain

Jenis variabel pola:

  • Variabel elemen - mengikat ke nilai referensi elemen grafik
    • Variabel node - mengikat ke node individual
    • Variabel edge - mengikat ke tepi individual
  • Variabel jalur - ikat ke nilai jalur yang mewakili jalur yang cocok

Menurut derajat referensi:

  • Variabel singleton - mengikat ke nilai referensi elemen individual dari pola
  • Variabel grup - mengikat ke daftar nilai referensi elemen dari pola panjang variabel (lihat Teknik Agregasi Tingkat Lanjut)

Hasil dan hasil eksekusi

Saat menjalankan kueri, Anda mendapatkan kembali hasil eksekusi yang terdiri dari:

  • Tabel hasil (opsional) dengan data dari pernyataan Anda RETURN .
  • Informasi status yang memperlihatkan apakah kueri berhasil atau tidak.

Tabel hasil

Tabel hasil - jika ada - adalah hasil aktual dari eksekusi kueri.

Tabel hasil menyertakan informasi tentang nama dan jenis kolomnya, urutan nama kolom pilihan yang akan digunakan untuk menampilkan hasil, apakah tabel diurutkan, dan baris aktual itu sendiri.

Nota

Jika terjadi kegagalan eksekusi, tidak ada tabel hasil yang disertakan dalam hasil eksekusi.

Informasi status

Berbagai kondisi penting (seperti kesalahan atau peringatan) terdeteksi selama eksekusi kueri. Setiap kondisi tersebut dicatat oleh objek status dalam informasi status hasil eksekusi.

Informasi status terdiri dari objek status utama dan daftar (mungkin kosong) objek status tambahan. Objek status utama selalu ada dan menunjukkan apakah eksekusi kueri berhasil atau gagal.

Setiap objek status menyertakan kode status 5 digit (disebut GQLSTATUS) yang mengidentifikasi kondisi yang direkam serta pesan yang menjelaskannya.

Kode status keberhasilan:

GQLSTATUS Message Kapan
00000 catatan: penyelesaian berhasil Berhasil dengan setidaknya satu baris
00001 catatan: penyelesaian berhasil - hasil yang dihilangkan Berhasil tanpa tabel (saat ini tidak digunakan)
02000 catatan: tidak ada data Berhasil dengan nol baris

Kode status lainnya menunjukkan kesalahan atau peringatan lebih lanjut yang terdeteksi selama eksekusi kueri.

Penting

Dalam kode aplikasi, selalu mengandalkan kode status untuk menguji kondisi tertentu. Kode status dijamin stabil dan makna umumnya tidak akan berubah di masa mendatang. Jangan menguji konten pesan, karena pesan konkret yang dilaporkan untuk kode status dapat berubah di masa mendatang tergantung pada kueri atau bahkan di antara eksekusi kueri yang sama.

Selain itu, objek status dapat berisi objek status penyebab yang mendasar dan rekaman diagnostik dengan informasi lebih lanjut yang mencirikan kondisi yang direkam.

Lihat referensi kode GQLSTATUS lengkap

Konsep dan pernyataan penting

Bagian ini mencakup blok penyusun inti yang Anda butuhkan untuk menulis kueri GQL yang efektif. Setiap konsep dibangun menuju keterampilan penulisan kueri praktis.

Pola grafik: menemukan struktur

Pola grafik adalah inti dari kueri GQL. Ini memungkinkan Anda menjelaskan struktur data yang Anda cari menggunakan sintaks visual intuitif yang terlihat seperti hubungan yang ingin Anda temukan.

Pola sederhana:

Mulailah dengan pola hubungan dasar:

-- Find direct friendships
(p:Person)-[:knows]->(f:Person)

-- Find people working at any company
(p:Person)-[:workAt]->(c:Company)

-- Find cities in any country/region
(ci:City)-[:isPartOf]->(co:Country)

Pola dengan data tertentu:

-- Find who works at Microsoft specifically
(p:Person)-[:workAt]->(c:Company)
WHERE p.firstName = 'Annemarie'

-- Find friends who are both young
(p:Person)-[:knows]->(f:Person)  
WHERE p.birthday > 19950101 AND f.birthday > 19950101

Ekspresi label untuk pemilihan entitas fleksibel:

(:Person|Company)-[:isLocatedIn]->(p:City|Country)  -- OR with |
(:Place&City)                                       -- AND with &  
(:Person&!Company)                                  -- NOT with !

Nota

Model grafik dengan beberapa label elemen belum didukung (masalah umum).

Ekspresi label memungkinkan Anda mencocokkan berbagai jenis simpul dalam satu pola, membuat kueri Anda lebih fleksibel.

Penggunaan kembali variabel membuat gabungan yang kuat:

-- Find coworkers: people who work at the same company
(c:Company)<-[:workAt]-(x:Person)-[:knows]-(y:Person)-[:workAt]->(c)

Penggunaan kembali variabel c memastikan kedua orang bekerja di perusahaan yang sama , membuat batasan gabungan otomatis. Pola ini adalah pola kunci untuk mengekspresikan hubungan "entitas yang sama".

Penting

Wawasan kritis: Penggunaan kembali variabel dalam pola menciptakan batasan struktural. Gunakan teknik ini untuk mengekspresikan hubungan grafik yang kompleks seperti "teman yang bekerja di perusahaan yang sama" atau "orang-orang di kota yang sama."

Pemfilteran tingkat pola dengan WHERE:

-- Filter during pattern matching (more efficient)
(p:Person WHERE p.birthday < 19940101)-[:workAt]->(c:Company WHERE c.id > 1000)

-- Filter edges during matching  
(p:Person)-[w:workAt WHERE w.workFrom >= 2000]->(c:Company)

Pola panjang variabel terikat:

(:Person)-[:knows]->{1,3}(:Person)  -- Friends up to 3 degrees away

Pola TRAIL untuk traversal bebas siklus:

Gunakan TRAIL pola untuk mencegah siklus selama traversal grafik, memastikan setiap tepi dikunjungi paling banyak sekali:

-- Find paths without visiting the same :knows edge twice
MATCH TRAIL (src:Person)-[:knows]->{1,4}(dst:Person)
WHERE src.firstName = 'Alice' AND dst.firstName = 'Bob'
RETURN count(*) AS num_connections

-- Find acyclic paths in social networks
MATCH TRAIL (p:Person)-[e:knows]->{,3}(celebrity:Person)
RETURN 
  p.firstName || ' ' || p.lastName AS person_name, 
  celebrity.firstName || ' ' || celebrity.lastName AS celebrity_name, 
  count(e) AS distance
LIMIT 1000

Pengikatan tepi panjang variabel:

Dalam pola panjang variabel, variabel edge menangkap informasi yang berbeda berdasarkan konteks:

-- Edge variable 'e' binds to a single edge for each result row
MATCH (p:Person)-[e:knows]->(friend:Person)
RETURN p.firstName, e.creationDate, friend.firstName  -- e refers to one specific relationship
LIMIT 1000

-- Edge variable 'e' binds to a group list of all edges in the path
MATCH (p:Person)-[e:knows]->{2,4}(friend:Person)  
RETURN 
  p.firstName || ' ' || p.lastName AS person_name, 
  friend.firstName || ' ' || friend.lastName AS friend_name, 
  -- e is a list
  size(e) AS num_edges
LIMIT 1000

Perbedaan ini sangat penting untuk menggunakan variabel edge dengan benar.

Pola kompleks dengan beberapa hubungan:

MATCH (p:Person), (p)-[:workAt]->(c:Company), (p)-[:isLocatedIn]->(city:City)
RETURN p.firstName, p.lastName, c.name AS company_name, city.name AS city_name
LIMIT 1000

Pola ini menemukan orang-orang bersama dengan tempat kerja dan tempat tinggal mereka, menunjukkan bagaimana satu orang terhubung ke beberapa entitas lain.

Pelajari sintaks pola komprehensif dan teknik tingkat lanjut

Pernyataan inti

GQL menyediakan jenis pernyataan tertentu yang bekerja sama untuk memproses data grafik Anda langkah demi langkah. Memahami pernyataan ini sangat penting untuk membangun kueri yang efektif.

MATCH pernyataan

Sintaks:

MATCH <graph pattern>, <graph pattern>, ... [ WHERE <predicate> ]

Pernyataan mengambil MATCH data input dan menemukan pola grafik. Ini menggabungkan variabel input dengan variabel pola dan output semua kombinasi yang cocok.

Variabel input dan output:

-- Input: unit table (no columns, one row)
-- Pattern variables: p, c  
-- Output: table with (p, c) columns for each person-company match
MATCH (p:Person)-[:workAt]->(c:Company)

Pemfilteran tingkat pernyataan dengan menggunakan WHERE:

-- Filter pattern matches
MATCH (p:Person)-[:workAt]->(c:Company) WHERE p.lastName = c.name

Anda dapat memfilter semua kecocokan dengan menggunakan WHERE. Pendekatan ini menghindari pernyataan terpisah FILTER .

Bergabung dengan menggunakan variabel input:

Ketika MATCH bukan pernyataan pertama, itu menggabungkan data input dengan kecocokan pola:

...
-- Input: table with 'targetCompany' column
-- Implicit join: targetCompany (equality join)
-- Output: table with (targetCompany, p, r) columns
MATCH (p:Person)-[r:workAt]->(targetCompany)

Penting

Grafik di Microsoft Fabric belum mendukung komposisi pernyataan arbitrer. Lihat artikel tentang batasan saat ini.

Perilaku penggambungan kunci:

Cara MATCH menangani gabungan data:

  • Kesetaraan variabel: Variabel input bergabung dengan variabel pola dengan menggunakan pencocokan kesetaraan
  • Gabungan dalam: Baris input tanpa kecocokan pola dibuang (tidak ada gabungan kiri atau kanan)
  • Urutan pemfilteran: Filter tingkat WHERE pernyataan setelah pencocokan pola selesai
  • Konektivitas pola: Beberapa pola harus berbagi setidaknya satu variabel untuk gabungan yang tepat
  • Performa: Variabel bersama membuat batasan gabungan yang efisien

Penting

Pembatasan: Jika ini MATCH bukan pernyataan pertama, setidaknya satu variabel input harus bergabung dengan variabel pola. Beberapa pola harus memiliki satu variabel yang sama.

Beberapa pola memerlukan variabel bersama:

-- Shared variable 'p' joins the two patterns
-- Output: people with both workplace and residence data
MATCH (p:Person)-[:workAt]->(c:Company), 
      (p)-[:isLocatedIn]->(city:City)

LET pernyataan

Sintaks:

LET <variable> = <expression>, <variable> = <expression>, ...

Pernyataan ini LET membuat variabel komputasi dan memungkinkan transformasi data dalam alur kueri Anda.

Pembuatan variabel dasar:

MATCH (p:Person)
LET fullName = p.firstName || ' ' || p.lastName
RETURN *
LIMIT 1000

Perhitungan kompleks:

MATCH (p:Person)
LET adjustedAge = 2000 - (p.birthday / 10000),
    fullProfile = p.firstName || ' ' || p.lastName || ' (' || p.gender || ')'
RETURN *
LIMIT 1000

Perilaku utama:

  • Ekspresi dievaluasi untuk setiap baris input
  • Hasil menjadi kolom baru dalam tabel output
  • Variabel hanya dapat mereferensikan variabel yang ada dari pernyataan sebelumnya
  • Beberapa tugas dalam satu LET dievaluasi secara paralel (tidak ada referensi silang)

FILTER pernyataan

Sintaks:

FILTER [ WHERE ] <predicate>

Pernyataan ini FILTER memberikan kontrol yang tepat atas data mana yang dilanjutkan melalui alur kueri Anda.

Pemfilteran dasar:

MATCH (p:Person)
FILTER p.birthday < 19980101 AND p.gender = 'female'
RETURN *

Kondisi logika kompleks:

MATCH (p:Person)
FILTER (p.gender = 'male' AND p.birthday < 19940101) 
  OR (p.gender = 'female' AND p.birthday < 19990101)
  OR p.browserUsed = 'Edge'
RETURN *

Pola pemfilteran sadar null:

Gunakan pola-pola ini untuk menangani nilai null dengan aman:

  • Periksa nilai: p.firstName IS NOT NULL - memiliki nama depan
  • Memvalidasi data: p.id > 0 - ID yang valid
  • Menangani data yang hilang: NOT coalesce(p.locationIP, '127.0.0.1') STARTS WITH '127.0.0' - tidak tersambung dari jaringan lokal
  • Menggabungkan kondisi: Gunakan AND/OR dengan pemeriksaan null eksplisit untuk logika kompleks

Perhatian

Ingat bahwa kondisi yang melibatkan nilai null mengembalikan UNKNOWN, yang memfilter baris tersebut. Gunakan pemeriksaan eksplisit IS NULL saat Anda memerlukan logika null-inclusive.

ORDER BY pernyataan

Sintaks:

ORDER BY <expression> [ ASC | DESC ], <expression> [ ASC | DESC ], ...

Pengurutan multi-tingkat dengan ekspresi komputasi:

MATCH (p:Person)
RETURN *
ORDER BY p.firstName DESC,               -- Primary: by first name (Z-A)
         p.birthday ASC,                 -- Secondary: by age (oldest first)
         p.id DESC                       -- Tertiary: by ID (highest first)

Penanganan null dalam pengurutan:

ORDER BY coalesce(p.gender, 'not specified') DESC -- Treat NULL as 'not specified'

Mengurutkan detail perilaku:

Memahami cara ORDER BY kerjanya:

  • Evaluasi ekspresi: Ekspresi dievaluasi untuk setiap baris, lalu hasil menentukan urutan baris
  • Beberapa tombol sortir: Membuat urutan hierarkis (primer, sekunder, tersier, dll.)
  • Penanganan null: NULL selalu diperlakukan sebagai nilai terkecil dalam perbandingan
  • Urutan default: ASC (naik) adalah default, DESC (turun) harus ditentukan secara eksplisit
  • Pengurutan komputasi: Anda bisa mengurutkan berdasarkan nilai terhitung, bukan hanya properti tersimpan

Perhatian

Urutan pengurutan yang ditetapkan oleh ORDER BY hanya terlihat oleh pernyataan berikut segera . Oleh karena itu, ORDER BY diikuti oleh RETURN * TIDAK menghasilkan hasil yang dipesan.

Membandingkan:

MATCH (a:Person)-[r:knows]->(b:Person)
LET aName = a.firstName || ' ' || a.lastName
LET bName = b.firstName || ' ' || b.lastName
ORDER BY r.creationDate DESC
/* intermediary result _IS_ guaranteed to be ordered here */
RETURN aName, bName, r.creationDate AS since
/* final result _IS_ _NOT_ guaranteed to be ordered here  */

dengan:

MATCH (a:Person)-[r:knows]->(b:Person)
LET aName = a.firstName || ' ' || a.lastName
LET bName = b.firstName || ' ' || b.lastName
/* intermediary result _IS_ _NOT_ guaranteed to be ordered here */
RETURN aName, bName, r.creationDate AS since
ORDER BY r.creationDate DESC
/* final result _IS_ guaranteed to be ordered here              */

Perbedaan ini memiliki konsekuensi langsung untuk kueri "Top-k": LIMIT harus selalu mengikuti ORDER BY pernyataan yang menetapkan urutan pengurutan yang dimaksudkan.

OFFSET dan LIMIT pernyataan

Sintaks:

  OFFSET <offset> [ LIMIT <limit> ]
| LIMIT <limit>

Pola umum:

-- Basic top-N query
MATCH (p:Person)
RETURN *
ORDER BY p.id DESC
LIMIT 10                                 -- Top 10 by ID

Penting

Untuk hasil penomoran halaman yang dapat diprediksi, selalu gunakan ORDER BY sebelum OFFSET dan LIMIT untuk memastikan urutan baris yang konsisten di seluruh kueri.

RETURN: proyeksi hasil dasar

Sintaks:

RETURN [ DISTINCT ] <expression> [ AS <alias> ], <expression> [ AS <alias> ], ...
[ ORDER BY <expression> [ ASC | DESC ], <expression> [ ASC | DESC ], ... ]
[ OFFSET <offset> ]
[ LIMIT <limit> ]

Pernyataan menghasilkan RETURN output akhir kueri Anda dengan menentukan data mana yang muncul dalam tabel hasil.

Output dasar:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN p.firstName || ' ' || p.lastName AS name, 
       p.birthday, 
       c.name

Menggunakan alias untuk kejelasan:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN p.firstName AS first_name, 
       p.lastName AS last_name,
       c.name AS company_name

Gabungkan dengan pengurutan dan top-k:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN p.firstName || ' ' || p.lastName AS name, 
       p.birthday AS birth_year, 
       c.name AS company
ORDER BY birth_year ASC
LIMIT 10

Penanganan duplikat dengan menggunakan DISTINCT:

-- Remove duplicate combinations
MATCH (p:Person)-[:workAt]->(c:Company)
RETURN DISTINCT p.gender, p.browserUsed, p.birthday AS birth_year
ORDER BY p.gender, p.browserUsed, birth_year

Gabungkan dengan agregasi:

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

RETURN dengan GROUP BY: proyeksi hasil yang dikelompokkan

Sintaks:

RETURN [ DISTINCT ] <expression> [ AS <alias> ], <expression> [ AS <alias> ], ...
GROUP BY <variable>, <variable>, ...
[ ORDER BY <expression> [ ASC | DESC ], <expression> [ ASC | DESC ], ... ]
[ OFFSET <offset> ]
[ LIMIT <limit> ]

Gunakan GROUP BY untuk mengelompokkan baris menurut nilai bersama dan menghitung fungsi agregat dalam setiap grup.

Pengelompokan dasar dengan agregasi:

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

Pengelompokan multi-kolom:

MATCH (p:Person)
LET gender = p.gender
LET browser = p.browserUsed
RETURN gender,
       browser,
       count(*) AS person_count,
       avg(p.birthday) AS avg_birth_year,
       min(p.creationDate) AS first_joined,
       max(p.id) AS highest_id
GROUP BY gender, browser
ORDER BY avg_birth_year DESC
LIMIT 10

Nota

Untuk teknik agregasi tingkat lanjut, termasuk agregasi horizontal atas pola panjang variabel, lihat Teknik Agregasi Tingkat Lanjut.

Jenis data: bekerja dengan nilai

GQL mendukung jenis data yang kaya untuk menyimpan dan memanipulasi berbagai jenis informasi dalam grafik Anda.

Jenis nilai dasar

  • Angka: INT64, , UINT64DOUBLEuntuk perhitungan dan pengukuran
  • Teks: STRING untuk nama, deskripsi, dan data tekstual
  • Logika: BOOL dengan tiga nilai: TRUE, FALSE, dan UNKNOWN (untuk penanganan null)
  • Waktu: ZONED DATETIME untuk tanda waktu dengan informasi zona waktu
  • Koleksi: LIST<T> untuk beberapa nilai dari jenis Tyang sama , PATH untuk hasil traversal grafik
  • Elemen grafik: NODE dan EDGE untuk mereferensikan data grafik

Penting

Anda tidak dapat menggunakan jenis nilai tertentu sebagai jenis nilai properti. Secara khusus, Anda tidak dapat menggunakan nilai apa pun yang melibatkan nilai referensi elemen grafik sebagai nilai properti (seperti daftar simpul atau jalur).

Contoh literal

42                                     -- Integer literal
"Hello, graph!"                        -- String  literal
TRUE                                   -- Boolean literal
ZONED_DATETIME('2024-01-15T10:30:00Z') -- DateTime with timezone literakl
[1, 2, 3]                              -- Literal list of integers

Pola penanganan null kritis

-- Equality predicates with NULL always returns UNKNOWN
5 = NULL                              -- Evaluates to UNKNOWN (not FALSE!)
NULL = NULL                           -- Evaluates to UNKNOWN (not TRUE!)

-- Use IS NULL predicates for explicit null testing
p.nickname IS NULL                    -- Evaluates to TRUE if nickname is null
p.nickname IS NOT NULL                -- Evaluates to TRUE if nickname has a value

-- Use the COALESCE function for null-safe value selection
coalesce(p.nickname, p.firstName, '???')  -- Evaluates to first non-null value

Implikasi logika tiga nilai

-- In FILTER statements, only TRUE values pass through
FILTER p.birthday > 0        -- Removes rows where birthday is null or missing or zero

-- It's important to understand that NOT UNKNOWN = UNKNOWN
FILTER NOT (p.birthday > 0)  -- Removes rows where birthday is null or missing or positive

-- Use explicit null handling for inclusive filtering
FILTER p.birthday < 19980101 OR p.birthday IS NULL -- Includes null birthdays

Perhatian

Logika tiga nilai berarti NULL = NULL mengembalikan UNKNOWN, bukan TRUE. Perilaku ini memengaruhi pemfilteran dan gabungan. Selalu gunakan IS NULL untuk pengujian null.

Pelajari detail sistem jenis komprehensif

Ekspresi: mengubah dan menganalisis data

Ekspresi memungkinkan Anda menghitung, membandingkan, dan mengubah data dalam kueri Anda. Mereka mirip dengan ekspresi di SQL tetapi memiliki fitur tambahan untuk menangani data grafik.

Jenis ekspresi umum

p.birthday < 19980101   -- Birth year comparison  
p.firstName || ' ' || p.lastName               -- String concatenation
count(*)                                       -- Aggregation
p.firstName IN ['Alice', 'Bob']                -- List membership
coalesce(p.firstName, p.lastName)              -- Null handling

Komposisi predikat kompleks

-- Combine conditions with proper precedence
FILTER (p.birthday > 19560101 AND p.birthday < 20061231) 
  AND ((p.gender IN ['male', 'female']) OR (p.browserUsed IS NOT NULL))

-- Use parentheses for clarity and correctness
FILTER p.gender = 'female' AND (p.firstName STARTS WITH 'A' OR p.id > 1000)

Pencocokan pola string

-- Pattern matching with different operators
p.locationIP CONTAINS '192.168'      -- Substring search
p.firstName STARTS WITH 'John'       -- Prefix matching  
p.lastName ENDS WITH 'son'           -- Suffix matching

-- Case-insensitive operations
upper(p.firstName) = 'ALICE'         -- Convert to uppercase for comparison

Fungsi bawaan menurut kategori

GQL menyediakan kategori fungsi ini untuk kebutuhan pemrosesan data yang berbeda:

  • Fungsi agregat: count(), , sum()avg(), min(), max() untuk meringkas data
  • Fungsi string: char_length(), upper(), lower(), trim() untuk pemrosesan teks
  • Fungsi grafik: nodes(), edges(), labels() untuk menganalisis struktur grafik
  • Fungsi umum: coalesce() untuk menangani nilai null dengan anggun

Prioritas operator untuk ekspresi kompleks

  1. Akses properti (.)
  2. Perkalian dan pembagian (*, /)
  3. Penambahan dan pengurangan (+, -)
  4. Perbandingan (=, <>, <, >, <=, >=)
  5. Negasi logis (NOT)
  6. Konjunsi logis (AND)
  7. Disjunction logis (OR)

Dalam daftar sebelumnya, operator dengan angka yang lebih rendah "mengikat lebih ketat" daripada operator dengan angka yang lebih tinggi. Misalnya, NOT n.prop OR m.prop adalah (NOT n.prop) OR m.prop tetapi tidak NOT (n.prop OR m.prop).

Petunjuk / Saran

Gunakan tanda kurung untuk membuat prioritas eksplisit. Ekspresi kompleks lebih mudah dibaca dan di-debug saat pengelompokan jelas.

Pelajari sintaks ekspresi komprehensif dan semua fungsi bawaan

Teknik kueri tingkat lanjut

Bagian ini mencakup pola dan teknik canggih untuk membangun kueri grafik yang kompleks dan efisien. Pola-pola ini melampaui penggunaan pernyataan dasar untuk membantu Anda menyusun kueri analitik yang kuat.

Komposisi multi-pernyataan yang kompleks

Penting

Grafik di Microsoft Fabric belum mendukung komposisi pernyataan arbitrer. Lihat artikel tentang batasan saat ini.

Memahami cara membuat kueri kompleks secara efisien sangat penting untuk kueri grafik tingkat lanjut.

Perkembangan pola multi-langkah

-- Build complex analysis step by step
MATCH (company:Company)<-[:workAt]-(employee:Person)
LET companyName = company.name
MATCH (employee)-[:isLocatedIn]->(city:City)
FILTER employee.birthday < 19850101
LET cityName = city.name
RETURN companyName, cityName, avg(employee.birthday) AS avgBirthday, count(employee) AS employeeCount
GROUP BY companyName, cityName
ORDER BY avgBirthday DESC

Kueri ini secara progresif membangun kompleksitas: temukan perusahaan, karyawan mereka, lokasi karyawan, filter perusahaan dengan karyawan yang lahir sebelum tahun 1985, hitung ulang tahun rata-rata, dan ringkas dan urutkan hasil.

Penggunaan agregasi horizontal

-- Find people and their minimum distance to people working at Microsoft
MATCH TRAIL (p:Person)-[e:knows]->{,5}(:Person)-[:workAt]->(:Company { name: 'Microsoft'})
LET p_name = p.lastName || ', ' || p.firstName
RETURN p_name, min(count(e)) AS minDistance 
GROUP BY p_name
ORDER BY minDistance DESC

Nota

Kueri ini belum didukung (masalah umum).

Cakupan variabel dan kontrol alur tingkat lanjut

Variabel menyambungkan data di seluruh pernyataan kueri dan mengaktifkan traversal grafik yang kompleks. Memahami aturan cakupan tingkat lanjut membantu Anda menulis kueri multi-pernyataan canggih.

Pola pengikatan dan pencakupan variabel

-- Variables flow forward through subsequent statements 
MATCH (p:Person)                                    -- Bind p 
LET fullName = p.firstName || ' ' || p.lastName     -- Bind concatenation of p.firstName and p.lastName as fullNume
FILTER fullName CONTAINS 'Smith'                    -- Filter for fullNames with “Smith” substring (p is still bound)
RETURN p.id, fullName                               -- Only return p.id and fullName (p is dropped from scope)

Penggunaan kembali variabel untuk gabungan di seluruh pernyataan

-- Multi-statement joins using variable reuse
MATCH (p:Person)-[:workAt]->(:Company)          -- Find people with jobs
MATCH (p)-[:isLocatedIn]->(:City)               -- Same p: people with both job and residence
MATCH (p)-[:knows]->(friend:Person)             -- Same p: their social connections
RETURN *

Aturan dan batasan cakupan kritis

-- ✅ Backward references work
MATCH (p:Person)
LET adult = p.birthday < 20061231  -- Can reference p from previous statement
RETURN *

-- ❌ Forward references don't work  
LET adult = p.birthday < 20061231  -- Error: p not yet defined
MATCH (p:Person)
RETURN *

-- ❌ Variables in same LET statement can't reference each other
MATCH (p:Person)
LET name = p.firstName || ' ' || p.lastName,
    greeting = 'Hello, ' || name     -- Error: name not visible yet
RETURN *

-- ✅ Use separate statements for dependent variables
MATCH (p:Person)
LET name = p.firstName || ' ' || p.lastName
LET greeting = 'Hello, ' || name     -- Works: name now available
RETURN *

Visibilitas variabel dalam kueri kompleks

-- Variables remain visible until overridden or query ends
MATCH (p:Person)                     -- p available from here
LET gender = p.gender                -- gender available from here  
MATCH (p)-[:knows]->(e:Person)       -- p still refers to original person
                                     -- e is new variable for managed employee
RETURN p.firstName AS manager, e.firstName AS friend, gender

Perhatian

Variabel dalam pernyataan yang sama tidak dapat saling mereferensikan, kecuali dalam pola grafik. Gunakan pernyataan terpisah untuk pembuatan variabel dependen.

Teknik agregasi tingkat lanjut

GQL mendukung dua jenis agregasi yang berbeda untuk menganalisis data di seluruh grup dan koleksi: agregasi vertikal dengan GROUP BY dan agregasi horizontal melalui pola panjang variabel.

Agregasi vertikal dengan GROUP BY

Agregasi vertikal (tercakup dalam RETURN ) mengelompokkan baris menurut GROUP BYnilai bersama dan menghitung agregat dalam setiap grup:

MATCH (p:Person)-[:workAt]->(c:Company)
RETURN c.name AS companyName, 
       count(*) AS employee_count, 
       avg(p.birthday) AS avg_birth_year
GROUP BY companyName

Pendekatan ini menciptakan satu baris hasil per perusahaan, menggabungkan semua karyawan dalam setiap grup.

Agregasi horizontal dengan variabel daftar grup

Agregasi horizontal menghitung agregat atas koleksi yang terikat oleh pola panjang variabel. Saat Anda menggunakan tepi panjang variabel, variabel edge menjadi variabel daftar grup yang menyimpan semua tepi di setiap jalur yang cocok:

-- Group list variable 'edges' enables horizontal aggregation
MATCH (p:Person)-[edges:knows]->{2,4}(friend:Person)
RETURN p.firstName || ' ' || p.lastName AS person_name, 
       friend.firstName || ' ' || friend.lastName AS friend_name,
       size(edges) AS degrees_of_separation,
       avg(edges.creationDate) AS avg_connection_age,
       min(edges.creationDate) AS oldest_connection

Nota

Kueri ini belum didukung (masalah umum).

Perbedaan utama antara agregasi vertikal dan horizontal adalah:

  • Agregasi vertikal meringkas di seluruh baris atau baris grup dan meringkas di seluruh baris di setiap grup.
  • Agregasi horizontal meringkas elemen dalam koleksi tepi individual.
  • Variabel daftar grup hanya berasal dari pola tepi dengan panjang variabel.

Konteks pengikatan tepi dengan panjang variabel

Memahami bagaimana variabel tepi mengikat dalam pola panjang variabel sangat penting:

Selama pencocokan pola (konteks singleton):

-- Edge variable 'e' refers to each individual edge during filtering
MATCH (p:Person)-[e:knows WHERE e.creationDate > zoned_datetime('2000-01-01T00:00:00Z')]->{2,4}(friend:Person)
-- 'e' is evaluated for each edge in the path during matching
RETURN *

Dalam ekspresi hasil (konteks grup):

-- Edge variable 'edges' becomes a list of all qualifying edges
MATCH (p:Person)-[e:knows]->{2,4}(friend:Person)
RETURN size(e) AS num_edges,                    -- Number of edges in path
       e[0].creationDate AS first_edge,         -- First edge in path
       avg(e.creationDate) AS avg_age           -- Horizontal aggregation

Nota

Kueri ini belum didukung (masalah umum).

Menggabungkan agregasi vertikal dan horizontal

Anda dapat menggabungkan kedua jenis agregasi dalam pola analisis canggih:

Nota

Kueri ini belum didukung (masalah umum).

-- Find average connection age by city pairs
MATCH (p1:Person)-[:isLocatedIn]->(c1:City)
MATCH (p2:Person)-[:isLocatedIn]->(c2:City)
MATCH (p1)-[e:knows]->{1,3}(p2)
RETURN c1.name AS city1,
       c2.name AS city2,
       count(*) AS connection_paths,                  -- Vertical: count paths per city pair
       avg(size(e)) AS avg_degrees,                   -- Horizontal then vertical: path lengths
       avg(avg(e.creationDate)) AS avg_connection_age -- Horizontal then vertical: connection ages
GROUP BY city1, city2

Petunjuk / Saran

Agregasi horizontal selalu diutamakan daripada agregasi vertikal. Untuk mengonversi daftar grup menjadi daftar biasa, gunakan collect_list(edges).

Nota

Untuk referensi fungsi agregat terperinci, lihat ekspresi dan fungsi GQL.

Strategi penanganan kesalahan

Memahami pola kesalahan umum membantu Anda menulis kueri yang kuat.

Tangani data yang hilang dengan anggun:

MATCH (p:Person)
-- Use COALESCE for missing properties
LET displayName = coalesce(p.firstName, p.lastName, 'Unknown')
LET contact = coalesce(p.locationIP, p.browserUsed, 'No info')
RETURN *

Gunakan pemeriksaan null eksplisit:

MATCH (p:Person)
-- Be explicit about null handling
FILTER p.id IS NOT NULL AND p.id > 0
-- Instead of just: FILTER p.id > 0
RETURN *

Informasi Tambahan

Kode GQLSTATUS

Seperti yang dijelaskan di bagian tentang hasil kueri, GQL melaporkan informasi status kaya yang terkait dengan keberhasilan atau potensi kegagalan eksekusi. Lihat referensi kode status GQL untuk daftar lengkapnya.

Kata-kata cadangan

GQL mencadangkan kata kunci tertentu yang tidak dapat Anda gunakan sebagai pengidentifikasi seperti variabel, nama properti, atau nama label. Lihat referensi kata yang dipesan GQL untuk daftar lengkapnya.

Jika Anda perlu menggunakan kata-kata yang dipesan sebagai pengidentifikasi, keluarkan kata-kata tersebut dengan backtick: `match`, `return`.

Untuk menghindari pelepasan kata yang dipesan, gunakan konvensi penamaan ini:

  • Untuk pengidentifikasi kata tunggal, tambahkan garis bawah: :Product_
  • Untuk pengidentifikasi multi-kata, gunakan camelCase atau PascalCase: :MyEntity, , :hasAttributetextColor

Langkah selanjutnya

Sekarang setelah Anda memahami dasar-dasar GQL, berikut adalah jalur pembelajaran yang direkomendasikan:

Lanjutkan membangun keterampilan GQL Anda

Untuk pemula:

Untuk pengguna berpengalaman:

Materi referensi

Pertahankan referensi ini berguna untuk pencarian cepat:

Jelajahi Microsoft Fabric

Pelajari platform:

Terlibat

  • Berbagi umpan balik - Membantu meningkatkan dokumentasi dan alat
  • Bergabung dengan komunitas - Terhubung dengan praktisi database grafik lainnya
  • Tetap diperbarui - Ikuti pengumuman Microsoft Fabric untuk fitur baru

Petunjuk / Saran

Mulailah dengan tutorial mulai cepat jika Anda lebih suka belajar dengan melakukan, atau menyelami pola grafik jika Anda ingin menguasai bahasa kueri terlebih dahulu.

Konten terkait

Detail lebih lanjut tentang topik utama:

Referensi cepat:

Grafik di Microsoft Fabric:

  • Last updated on