Panduan bahasa GQL untuk grafik di Microsoft Fabric

GQL (Graph Query Language) adalah bahasa kueri standar ISO untuk database grafik. Gunakan GQL untuk mengkueri, menganalisis, dan bekerja dengan data grafik secara efisien dengan grafik di Microsoft Fabric.

Grup kerja ISO yang sama yang menstandarkan SQL mengembangkan GQL. Akibatnya, GQL berbagi banyak konsep dengan SQL, termasuk ekspresi, predikat, dan jenis data. Jika Anda memiliki pengalaman SQL, Anda dapat menerapkan banyak pengetahuan tersebut ke GQL.

Artikel ini adalah panduan end-to-end untuk GQL dalam grafik. Dokumen ini menjelaskan bagaimana bahasa tersebut saling terhubung dan menautkan ke referensi fokus untuk detail sintaks dan tipe yang lengkap. Ini mencakup:

  • Konsep inti: Struktur data grafik, pola, dan dasar-dasar kueri
  • Pernyataan penting: MATCH, , FILTER, LET, WHENORDER BYLIMIT, , danRETURN
  • Jenis dan ekspresi data: Jenis nilai, operator, dan fungsi bawaan
  • Teknik lanjutan: Komposisi multi-pernyataan, cakupan variabel, dan strategi agregasi

Nota

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

Jika Anda mencari panduan berorientasi tugas daripada panduan bahasa, lihat panduan caranya:

Gunakan artikel referensi fokus saat Anda membutuhkan detail lengkap:

Informasi yang diperlukan Artikel definitif
Sekilas sintaksis Referensi cepat GQL
Sintaks komposisi node, tepi, jalur, dan pola Pola graf GQL
Operator, predikat, dan fungsi Ekspresi, predikat, dan fungsi GQL
Sintaks literal, perilaku nilai, dan konversi tipe Nilai dan jenis nilai GQL
Definisi dan batasan tipe graf Jenis graf GQL
Cakupan fitur ISO GQL saat ini Kesesuaian standar GQL
Pembatasan dan batasan khusus Fabric saat ini Batasan saat ini

Prasyarat

Sebelum memulai, pastikan Anda terbiasa dengan konsep-konsep ini:

  • pemahaman Basic 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 ruang kerja grafik dengan kemampuan kueri.
  • 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, sehingga sintaksnya secara langsung mengekspresikan bagaimana entitas terhubung. Di mana SQL biasanya mengekspresikan hubungan melalui gabungan antar tabel, GQL menggunakan pola grafik yang menyerupai diagram data.

Sebagai contoh, kueri berikut menemukan pasangan orang yang saling mengenal dan keduanya lahir sebelum tahun 1999:

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

Pola (person:Person)-[:knows]-(friend:Person) menunjukkan struktur hubungan yang sesuai. Variabel mengikat kedua orang tersebut sehingga kueri dapat memfilter dan mengembalikan properti mereka.

Dasar-dasar GQL

Konsep-konsep ini menjadi dasar GQL:

  • Grafik berisi node dan tepi dengan label dan properti.
  • Tipe graf secara formal mendefinisikan tipe node, tipe tepi, dan batasan yang diizinkan dalam sebuah grafik.
  • Kueri menggunakan pernyataan seperti MATCH, FILTER, dan RETURN untuk memproses data dan menghasilkan hasil.
  • Pola-pola menggambarkan struktur grafik agar sesuai.
  • Ekspresi menghitung, mengubah, dan membandingkan nilai.
  • Predikat adalah ekspresi Boolean yang digunakan untuk menguji kondisi.
  • Tipe nilai mendefinisikan jenis nilai yang dapat diproses oleh kueri dan properti grafik dapat disimpan.

Memahami data grafik

Untuk bekerja dengan GQL, Anda perlu memahami struktur grafik properti berlabel yang dikueri oleh bahasa tersebut.

Simpul dan tepi: blok penyusun

Grafik properti berlabel mengandung dua jenis elemen graf:

  • Node biasanya mewakili entitas, seperti orang, organisasi, postingan, atau produk.
  • Tepi mewakili koneksi antar node, seperti seseorang yang mengenal orang lain atau bekerja di perusahaan.

Setiap elemen graf memiliki identitas internal, satu atau lebih label, dan sekumpulan properti. Label mengklasifikasikan elemen, seperti Person atau knows. Properti adalah pasangan nama-nilai, seperti firstName: 'Alice' atau birthday: 19730108u. Dalam Graph, sebuah tepi selalu memiliki tepat satu label.

Setiap tepi menghubungkan tepat dua node: asal dan target. Arah tepi adalah bagian dari struktur graf. Misalnya, sebuah workAt tepi dapat menghubungkan origin Person ke Company target.

Nota

Saat ini Graph tidak mendukung pembuatan tepi tanpa arah. Anda dapat melakukan query pada tepi terarah yang sudah ada ke arah mana pun dengan menggunakan pola tepi berarah apa pun seperti -[:knows]-.

Graf terbentuk dengan baik: setiap sisi menghubungkan dua simpul yang ada dalam graf yang sama.

Model grafik dan jenis grafik

Model graf Fabric mendefinisikan tipe node, tipe tepi, properti, pemetaan sumber, dan kunci yang tersedia dalam grafik. Tabel ini menentukan baris tabel sumber mana yang menjadi node dan tepi serta bagaimana elemen-elemen tersebut terhubung. Untuk panduan pemodelan, lihat Desain skema grafik.

Standar GQL menggunakan tipe grafik untuk secara formal mendeskripsikan tipe node yang diizinkan, tipe tepi, properti, dan kendala. Tipe graf adalah padanan tingkat bahasa dari struktur yang direpresentasikan oleh model graf Fabric, tetapi saat ini Graph belum menerima deklarasi tipe graf GQL secara langsung. Untuk sintaks formal dan konsep, lihat tipe graf GQL.

Contoh grafik yang digunakan dalam panduan ini

Contohnya menggunakan dataset contoh jejaring sosial, yang mencakup orang, tempat, organisasi, pesan, tag, dan tepi yang menghubungkannya.

Grafik contoh menghubungkan area-area berikut:

  • Orang mengenal orang lain, bekerja di perusahaan, dan belajar di universitas.
  • Kota, negara, atau wilayah, dan benua membentuk hierarki geografis.
  • Forum berisi postingan, dan orang-orang membuat postingan serta komentar.
  • Tag mengkategorikan konten dan mewakili minat orang.

Diagram memperlihatkan skema jejaring sosial.

Untuk struktur contoh lengkap, lihat contoh skema jejaring sosial. Untuk konsep graf umum, lihat Labeled property graphs.

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 berjalan 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 = 'Alice'
RETURN p.firstName, p.lastName, p.birthday

Kueri ini berjalan 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 berjalan 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 memfilter langsung dalam pola dengan menambahkan klausa WHERE . Misalnya, MATCH (n:Person WHERE n.birthday < 19900101) hanya Person cocok dengan node dengan birthday nilai sebelum tahun 1990.

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.
  • FOR: Memperluas daftar menjadi baris, dengan offset berbasis nol atau posisi ordinal berbasis satu opsional.
  • CALL: Menjalankan subquery inline untuk setiap baris input dan menambahkan kolom yang dikembalikan oleh subquery.
  • 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.
  • NEXT: Memulai tahap kueri lain dengan menggunakan kolom yang dikembalikan dari tahap sebelumnya.

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.
  • Proses ini membuat aliran data yang jelas dan dapat diprediksi yang menyederhanakan kueri kompleks.
  • NEXT memulai tahap kueri baru. Hanya kolom yang diproyeksikan oleh pernyataan sebelumnya RETURN yang tersedia pada tahap berikutnya.
  • UNION, UNION DISTINCT, dan UNION ALL menggabungkan hasil dari blok kueri lengkap.

Nota

Pernyataan memiliki urutan logis yang terdefinisi. Tulis kueri sesuai dengan alur data ini daripada mengandalkan strategi eksekusi fisik tertentu.

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 berjalan sebagai berikut:

  1. MATCH menemukan orang yang bekerja di perusahaan.
  2. LET membuat nama lengkap dengan menggabungkan nama depan dan keluarga.
  3. FILTER hanya mempertahankan karyawan perusahaan dengan "Udara" dalam nama perusahaan mereka.
  4. ORDER BY mengurutkan menurut nama lengkap.
  5. LIMIT mengambil 10 hasil pertama.
  6. RETURN Mengembalikan nama lengkap dan nama 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. Untuk detail, lihat Fungsi agregat.

Hasil dan hasil eksekusi

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

  • Hasilnya, biasanya tabel hasil 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 eksekusi gagal, tidak ada tabel hasil yang disertakan dalam hasil eksekusi.

Hasil yang dihilangkan

GQL juga mendefinisikan hasil yang dihilangkan untuk pernyataan yang tidak pernah menghasilkan baris, terlepas dari data atau hasil evaluasi. Hasil yang dihilangkan memiliki kode 00001status penyelesaian berhasil .

Hasil yang dihilangkan berbeda dengan tabel hasil kosong. Tabel kosong berarti kueri yang menghasilkan baris telah dievaluasi tetapi tidak menghasilkan baris. API Query dapat merepresentasikan hasil yang dihilangkan dengan jenis NOTHINGhasil .

Graph menyimpan hasil yang dihilangkan untuk dukungan pernyataan bahasa definisi data (DDL) dan bahasa manipulasi data (DML) di masa depan. Pernyataan kueri saat ini menghasilkan hasil tabel, termasuk tabel kosong.

Informasi status

Selama eksekusi kueri, proses mendeteksi berbagai kondisi penting, seperti kesalahan atau peringatan. Setiap kondisi direkam oleh objek status dalam informasi status hasil eksekusi.

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

Setiap objek status mencakup kode alfanumerik lima karakter dan deskripsi kondisi yang direkam.

API Query menggunakan kode status utama berikut:

Kode status API Meaning
00000 Penyelesaian berhasil dengan setidaknya satu baris.
00001 Penyelesaian berhasil dengan hasil yang hilang. Disediakan untuk dukungan DDL dan DML di masa depan.
01000 Sebuah peringatan atau kondisi informasi.
02000 Tidak ada baris yang tersedia saat ini dari kueri yang menghasilkan baris.
42000 Kesalahan kueri yang dapat diperbaiki oleh pengguna.
50000 Kesalahan sistem atau tidak terklasifikasi.

API mempertahankan status GQLSTATUS kanonik yang dilaporkan oleh mesin kueri di _graphaneGqlStatus anggota rekaman diagnostik. Sebagai contoh, numerik overflow menggunakan GQLSTATUS 22003kanonik , sementara pembagian dengan nol menggunakan 22012; keduanya direpresentasikan dengan 42000 dalam bidang publik status.code .

Penting

Dalam kode aplikasi, gunakan status.code untuk keberhasilan luas dan penanganan kesalahan. Gunakan diagnostik GQLSTATUS kanonik saat Anda perlu membedakan kondisi kueri tertentu. Jangan uji teks deskripsi karena bisa berbeda-beda.

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 status GQL

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: temukan struktur

Pola grafik menggambarkan node, tepi, dan jalur yang akan disesuaikan. Bind variabel ketika pernyataan selanjutnya perlu merujuk pada elemen yang cocok:

MATCH (person:Person)-[employment:workAt]->(company:Company)
RETURN person.firstName, company.name, employment.workFrom

Tempatkan predikat secara inline ketika menentukan node atau tepi mana yang dapat berpartisipasi dalam pola:

MATCH (person:Person WHERE person.firstName = 'Alice')
      -[:knows]->(friend:Person)
RETURN friend.firstName, friend.lastName

Gunakan kembali variabel untuk membutuhkan dua posisi pola agar elemen yang sama dapat diikat. Pisahkan pola dengan koma untuk membentuk struktur graf yang lebih besar. Gunakan kuantor seperti {1,4} untuk mengulangi pola tepi dan mencocokkan jalur panjang variabel.

Mode jalur menggunakan ulang elemen kontrol dalam jalur:

Mode jalur Behavior
WALK Memungkinkan simpul dan tepi berulang. Mode ini adalah default.
TRAIL Mencegah tepi berulang.
SIMPLE Mencegah node berulang kecuali untuk node pertama dan terakhir yang dibagi.
ACYCLIC Mencegah semua node yang berulang.

Awalan pencarian jalur mengontrol jalur mana yang dikembalikan. ALL adalah default. ANY SHORTEST Mengembalikan satu jalur terpendek untuk setiap pasangan sumber-tujuan:

MATCH path = ANY SHORTEST
  (source:Person WHERE source.id = 123u)-[:knows]->{1,4}(target:Person)
RETURN target.id, path_length(path) AS hopCount

Predikat inline membatasi kelayakan jalur sebelum pemilihan jalur. Operasi tingkat MATCH ... WHERE pernyataan dan setelahnya FILTER adalah postfilter. Perbedaan ini dapat mengubah ANY SHORTEST hasil.

Untuk semantik definitif node, edge, path, komposisi, kuantifier, dan penempatan predikat, lihat pola graf GQL. Untuk pembatasan jalur saat ini, lihat Batasan saat ini.

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 . Dengan awalan pencarian jalur seperti ANY SHORTEST, tingkat WHERE pernyataan berlaku setelah pemilihan jalur. Predikat inline sebaliknya membatasi jalur mana yang memenuhi syarat untuk dipilih. Untuk informasi lebih lanjut, lihat Tempatkan predikat sebelum atau sesudah pemilihan jalur.

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

Graph mendukung komposisi pernyataan linear dasar dan penuh, termasuk NEXT. Anda juga dapat menggabungkan blok kueri dengan UNION, UNION DISTINCT, dan UNION ALL. Operasi EXCEPT, INTERSECT, dan OTHERWISE set belum didukung. Untuk informasi selengkapnya, 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. Gunakan OPTIONAL MATCH untuk perilaku gabungan luar kiri.
  • Urutan penyaringan: Filter tingkat WHERE pernyataan setelah pencocokan pola dan pemilihan jalur selesai
  • Komposisi pola: Variabel bersama membatasi pola pada elemen yang sama. Pola yang terputus membentuk produk Kartesius.

Penting

Pola yang terputus memang valid, tetapi produk Kartesian-nya dapat membuat banyak baris. Gunakan variabel bersama ketika pola seharusnya merujuk pada elemen grafik yang sama.

Gabungkan pola dengan 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)

OPTIONAL MATCH pernyataan

Sintaks:

OPTIONAL MATCH <graph pattern> [ WHERE <predicate> ]

OPTIONAL MATCH bekerja seperti MATCH tetapi menggunakan semantik left-outer-join. Jika pola tidak menemukan kecocokan untuk baris input, kueri mempertahankan baris dengan NULL nilai untuk variabel yang tidak cocok alih-alih membuangnya.

Example:

-- Find all people and, if available, their workplace
MATCH (p:Person)
OPTIONAL MATCH (p)-[:workAt]->(c:Company)
RETURN p.firstName, p.lastName, c.name AS company_name

Orang yang tidak bekerja di perusahaan mana pun masih muncul dalam hasil dengan NULL untuk company_name.

Petunjuk / Saran

Gunakan OPTIONAL MATCH saat Anda ingin menyertakan entitas yang mungkin tidak memiliki hubungan tertentu, mirip dengan SQL LEFT JOIN.

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:

  • Mesin kueri mengevaluasi ekspresi untuk setiap baris input.
  • Hasilnya menjadi kolom baru dalam tabel output.
  • Variabel hanya dapat mereferensikan variabel yang ada dari pernyataan sebelumnya.
  • Beberapa penugasan dalam satu LET pernyataan menggunakan lingkup input yang sama, sehingga sebuah penugasan tidak dapat merujuk penugasan lain dari pernyataan tersebut.

FOR pernyataan

Sintaks:

FOR <variable> IN <list_expression>
  [ WITH OFFSET <offset_variable> | WITH ORDINALITY <ordinality_variable> ]

Pernyataan ini FOR memperluas daftar menjadi baris. Untuk setiap baris input, ia mengeluarkan satu baris output untuk setiap elemen daftar dan mengikat elemen tersebut ke variabel yang ditentukan. Variabel lain dari baris input tetap tersedia.

Gunakan WITH OFFSET untuk mengikat indeks berbasis nol, atau digunakan WITH ORDINALITY untuk mengikat posisi berbasis satu.

LET cities = ['Seattle', 'London', 'Tokyo']
FOR city IN cities WITH ORDINALITY position
RETURN city, position

Kueri ini mengembalikan satu baris untuk setiap kota. Nilainya position adalah 1, 2, dan 3. Jika Anda mengganti WITH ORDINALITY position dengan WITH OFFSET position, nilainya adalah 0, 1, dan 2.

Ekspresi sumber harus dievaluasi ke dalam daftar. Nilai non-daftar menyebabkan kueri gagal.

CALL pernyataan

Gunakan CALL untuk menjalankan subquery inline untuk setiap baris input:

CALL {
  <query statements>
  RETURN <columns>
}

Variabel yang sudah berada dalam lingkup secara implisit tersedia di dalam subkueri. Dari variabel yang dibuat di dalam subquery, hanya kolom dari pernyataan akhir RETURN yang tersedia di luar subquery. Variabel yang dibuat di dalam subquery tetapi tidak dikembalikan tetap lokal.

Subquery yang berkorelasi berikut menghitung jumlah pemberi kerja untuk setiap orang:

MATCH (p:Person)
CALL {
  MATCH (p)-[:workAt]->(company:Company)
  RETURN count(*) AS employerCount
}
RETURN p.firstName, p.lastName, employerCount
ORDER BY employerCount DESC

Sebuah ordinary CALL bertindak seperti inner join yang bergantung. Ia menghasilkan satu baris output untuk setiap baris yang dikembalikan oleh subquery. Jika subquery tidak mengembalikan baris, baris luar yang sesuai tidak akan dikembalikan. Jika mengembalikan beberapa baris, baris luar muncul sekali untuk setiap baris subquery.

Contoh sebelumnya count(*) selalu mengembalikan satu baris subquery karena menggunakan agregat yang tidak dikelompokkan. Seseorang tanpa pemberi kerja yang cocok oleh karena itu memiliki .employerCount0

Gunakan OPTIONAL CALL sebagai join kiri yang bergantung. Ketika subquery tidak mengembalikan baris, ia mempertahankan satu baris luar dan mengatur kolom subquery yang dikembalikan menjadi NULL. Ketika subquery mengembalikan beberapa baris, ia menghasilkan satu baris output untuk setiap baris subquery.

MATCH (p:Person)
OPTIONAL CALL {
  MATCH (p)-[:workAt]->(company:Company)
  RETURN company.name AS companyName
}
RETURN p.firstName, p.lastName, companyName

Anda bisa membuat subquery inline CALL . Subquery bersarang dapat merujuk variabel dari cakupan query yang menyertainya.

Penting

Akhiri setiap badan inline CALL dengan RETURN. Graph tidak mendukung pemanggilan prosedur bernama atau daftar impor variabel eksplisit seperti CALL (p) { ... }.

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, '10.x.x.x') STARTS WITH '10.x.x.x' - 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 ] [ NULLS FIRST | NULLS LAST ],
         <expression> [ ASC | DESC ] [ NULLS FIRST | NULLS LAST ], ...

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:

MATCH (p:Person)
RETURN p.firstName, p.birthday
ORDER BY p.birthday DESC NULLS LAST, p.firstName ASC

Mengurutkan detail perilaku:

Memahami cara ORDER BY kerjanya:

  • Mesin kueri mengevaluasi ekspresi untuk setiap baris, lalu hasil menentukan urutan baris.
  • Beberapa tombol pengurutan membuat pengurutan hierarkis (primer, sekunder, tersier, dan sebagainya).
  • NULLS FIRST menempatkan nilai null sebelum nilai non-null. NULLS LAST menempatkannya setelah nilai non-null.
  • Penempatan null tidak bergantung pada arah pengurutan. Jika Anda tidak menentukan pengurutan NULLS LAST null, adalah default untuk kedua dan ASCDESC.
  • ASC (naik) adalah urutan default, dan Anda harus secara eksplisit menentukan DESC (turun).
  • Anda dapat mengurutkan berdasarkan nilai terhitung, bukan hanya properti yang disimpan.
Spesifikasi pengurutan Urutan hasil
ASC atau ASC NULLS LAST Nilai non-null dalam urutan menaik, diikuti oleh nilai null.
ASC NULLS FIRST Nilai null, diikuti oleh nilai non-null secara menaik.
DESC atau DESC NULLS LAST Nilai non-null dalam urutan menurun, diikuti oleh nilai null.
DESC NULLS FIRST Nilai null, diikuti oleh nilai non-null secara menurun.

Perhatian

Hanya pernyataan berikut yang segera dapat melihat urutan pengurutan yang ORDER BY ditetapkan. Oleh karena itu, ORDER BY diikuti dengan RETURN * tidak menghasilkan hasil yang diurutkan.

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 ] [ NULLS FIRST | NULLS LAST ], ... ]
[ 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 companyId = c.id, companyName = c.name
RETURN companyId,
       companyName,
       count(*) AS employeeCount,
       avg(p.birthday) AS avg_birth_year
GROUP BY companyId, 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 agregasi horizontal atas pola panjang variabel, lihat Fungsi agregat.

Nilai dan jenis nilai

Nilai GQL meliputi nilai Boolean, string, numerik, temporal, list, node, edge, path, null, dan nothing. Tipe dapat dibatalkan kecuali Anda menentukan NOT NULL. Properti menggunakan subset yang didukung dari sistem nilai kueri penuh.

RETURN 42 AS integerValue,
       'Alice' AS stringValue,
       TRUE AS booleanValue,
       [1, 2, 3] AS listValue

Perbandingan dengan null evaluasi ke UNKNOWN; penggunaan IS NULL dan IS NOT NULL untuk uji null. Operasi numerik dapat menerapkan konversi implisit antara tipe numerik yang kompatibel.

Nota

Tidak semua tipe nilai GQL didukung di setiap konteks Graph. Untuk pembatasan properti dan kueri saat ini, lihat Tipe Data.

Untuk sintaks literal, perilaku perbandingan, konversi tipe, dan hierarki tipe, lihat nilai GQL dan tipe nilai.

Expressions

Ekspresi menghitung, membandingkan, mengagregasi, dan mengubah nilai. Bentuk umum meliputi referensi properti, operator aritmatika dan logika, predikat, panggilan fungsi, ekspresi sederhana CASE , dan subkueri:

MATCH (person:Person)
FILTER person.birthday < 19900101
RETURN person.firstName,
       CASE person.gender
         WHEN 'female' THEN 'F'
         WHEN 'male' THEN 'M'
         ELSE 'Other'
       END AS genderCode

GQL menggunakan logika tiga nilai: Ekspresi Boolean dapat mengevaluasi hingga TRUE, FALSE, atau UNKNOWN. A FILTER hanya mempertahankan baris yang predikatnya adalah TRUE.

Agregasi fungsi seperti COUNT, SUM, AVG, MIN, dan MAX merangkum baris. Daftar predikat seperti ALL, ANY, NONE, dan SINGLE evaluasi predikat untuk elemen daftar. Subkueri bentuk EXISTS prosedur menguji apakah kueri bersarang mengembalikan baris.

Untuk perilaku operator, predikat, agregat, dan fungsi lengkap, lihat ekspresi, predikat, dan fungsi GQL. Untuk contoh penyaringan dan pengelompokan berorientasi tugas, lihat Filter dan agregasi data grafik.

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 multistatement yang kompleks

Penting

Grafik mendukung komposisi pernyataan linier dasar dan lengkap. Operasi EXCEPT, INTERSECT, dan OTHERWISE set belum didukung. Untuk informasi selengkapnya, lihat artikel tentang batasan saat ini.

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

UNION dan UNION ALL

Gunakan UNION, UNION DISTINCT, atau UNION ALL untuk menggabungkan hasil dari dua atau lebih blok kueri linier:

<query block>
UNION [ DISTINCT | ALL ]
<query block>

-- Combine results from two separate pattern matches
MATCH (p:Person)-[:workAt]->(c:Company)
RETURN p.firstName AS name, c.name AS affiliation
UNION DISTINCT
MATCH (p:Person)-[:studyAt]->(u:University)
RETURN p.firstName AS name, u.name AS affiliation

Bare UNION setara dengan UNION DISTINCT; keduanya menghapus baris duplikat. UNION ALL menyimpan semua baris, termasuk duplikat.

Setiap blok kueri harus mengembalikan set nama kolom yang sama. Urutan kolom dapat berbeda antar blok, dan tipe data harus kompatibel.

NEXT

Gunakan NEXT untuk menjalankan tahap kueri lain terhadap tabel yang dikembalikan oleh tahap sebelumnya:

<query stage>
RETURN <columns>
NEXT
<query stage>

Kueri berikut menemukan karyawan dan perusahaan mereka, lalu menggunakan node karyawan yang dikembalikan dalam kecocokan pola lain:

MATCH (person:Person)-[:workAt]->(company:Company)
RETURN person, company.name AS companyName
NEXT
MATCH (person)-[:isLocatedIn]->(city:City)
RETURN person.firstName AS employee, companyName, city.name AS city

Hanya kolom yang dikembalikan oleh tahap sebelumnya yang masuk dalam cakupan setelah NEXT. Anda dapat menggunakan beberapa NEXT separator untuk membangun urutan tahap kueri yang lebih panjang.

Setiap tahap dapat berisi gabungan blok query. Sebuah union dievaluasi dalam tahapnya sebelum output tahap tersebut melewati NEXT batas. Jika , , dan C mewakili blok kueri, A UNION B NEXT C mengelompokkan sebagai (A UNION B) NEXT C, sementara A NEXT B UNION C grup sebagai A NEXT (B UNION C). BA

Pernyataan bersyarah

Gunakan pernyataan kondisional untuk mengarahkan setiap baris masuk ke cabang pertama yang predikatnya mengevaluasi ke TRUE:

WHEN <predicate> THEN <linear query statement or { query statements }>
[ WHEN <predicate> THEN <linear query statement or { query statements }> ... ]
[ ELSE <linear query statement or { query statements }> ]

Untuk mengarahkan baris dari tahap kueri sebelumnya, kembalikan kolom yang diperlukan dan gunakan NEXT pernyataan kondisional sebelum tersebut:

MATCH (p:Person)
RETURN p.firstName AS name, p.birthday AS birthday
NEXT
WHEN birthday < 19800101u THEN
  RETURN name, 'Before 1980' AS era
WHEN birthday < 20000101u THEN
  RETURN name, '1980-1999' AS era
ELSE
  RETURN name, '2000 or later' AS era

Setiap WHEN predikat harus Boolean. Mesin kueri mengevaluasi predikat secara berurutan untuk setiap baris input. Predikat yang mengevaluasi atau FALSEUNKNOWN tidak memilih cabangnya. Setelah predikat dievaluasi ke TRUE, predikat berikutnya dan badan cabang yang tidak dipilih tidak dievaluasi. Jika tidak ada predikat yang mengevaluasi ke TRUE dan tidak ELSEada , baris input tidak akan dikembalikan.

Predikat dan badan cabang dapat merujuk kolom dari tahap sebelumnya. Cabang bisa berupa satu pernyataan linier, atau prosedur bersarang yang dikurung dalam kurawal. Gunakan prosedur bersarang ketika cabang membutuhkan beberapa tahap atau pernyataan seperti CALL:

MATCH (p:Person)
RETURN p, p.firstName AS name
NEXT
WHEN p.gender = 'female' THEN {
  CALL {
    MATCH (p)-[:knows]->(friend:Person)
    RETURN count(*) AS friendCount
  }
  RETURN name, friendCount
}
ELSE
  RETURN name, 0u AS friendCount

Setiap cabang memiliki cakupan lokalnya sendiri. Cabang saudara tidak melihat variabel yang dibuat oleh cabang lain, dan hanya kolom dari cabang akhir RETURN yang dipilih yang berlanjut setelah pernyataan kondisional. Setiap cabang harus mengembalikan nama kolom yang sama, dan tipe hasil yang sesuai harus kompatibel. Mesin kueri memaksa tipe yang kompatibel ke tipe output yang sama. Kolom cabang yang dikembalikan dapat menggunakan nama yang sama dengan kolom masuk; nilai cabang menggantikan nilai masuk dalam output kondisional.

Pernyataan kondisional berbeda dengan CASE ekspresi. Graph mendukung ekspresi sederhana CASE <expression> WHEN <value>, tetapi tidak dicari CASE WHEN <predicate> . Untuk informasi lebih lanjut, lihat Ekspresi kondisional.

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 fullName
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 a new variable for the friend
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.

Agregasi baris dan elemen jalur

GQL mendukung dua konteks agregasi:

  • Agregasi vertikal merangkum baris input, yang secara opsional dipartisi berdasarkan GROUP BY variabel.
  • Agregasi horizontal merangkum daftar grup yang dibatasi oleh pola tepi dengan panjang variabel dalam satu jalur yang cocok.
MATCH (person:Person)-[:workAt]->(company:Company)
LET companyId = company.id, companyName = company.name
RETURN companyId, companyName, count(*) AS employeeCount
GROUP BY companyId, companyName

MATCH (:Person)-[connections:knows]->{1,4}(:Person)
RETURN count(connections) AS pathLength

Untuk kueri kelompok, filter khusus agregat, agregat koleksi, dan routing kondisional, lihat Filter dan agregasi data grafik. Untuk aturan hasil agregat lengkap, lihat Fungsi agregat.

Tangani null dan kesalahan kueri

Gunakan tes null eksplisit ketika nilai yang hilang membutuhkan penanganan yang berbeda:

MATCH (person:Person)
FILTER person.browserUsed IS NULL
RETURN person.firstName

Perbandingan dengan null mengevaluasi ke UNKNOWN, yang tidak dipertahankan oleh a.FILTER Gunakan coalesce() saat Anda membutuhkan nilai cadangan.

Hasil kueri meliputi informasi status keberhasilan, peringatan, kondisi tanpa data, kesalahan yang dapat diperbaiki pengguna, dan kesalahan sistem. Gunakan kode status publik untuk aliran kontrol luas dan diagnostik GQLSTATUS kanonik untuk kondisi tertentu. Lihat Hasil dan hasil eksekusi serta referensi kode status GQL.

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

Konten terkait

  • Last updated on