GQL nyelvi útmutató

Megjegyzés:

Ez a funkció jelenleg nyilvános előzetes verzióban érhető el. Ez az előzetes verzió szolgáltatásszintű szerződés nélkül érhető el, és éles számítási feladatokhoz nem ajánlott. Előfordulhat, hogy bizonyos funkciók nem támogatottak, vagy korlátozott képességekkel rendelkeznek. További információkért lásd: Microsoft Azure Previews Kiegészítő Felhasználási Feltételek.

A GQL gráflekérdezés nyelve a gráfadatbázisok ISO-szabvány szerinti lekérdezési nyelve. Segít a gráfadatok hatékony lekérdezésében és használatában.

A GQL-t ugyanaz az ISO munkacsoport fejleszti, amely az SQL-t szabványosítja, így biztosítva a következetességet és a szigoritást. Ha ismered az SQL-t, sok hasonlóságot találsz a GQL-ben (kifejezések, predikátumok, típusok) – így könnyebb elindulni. Ez az útmutató a GQL alapjait elsajátító kezdőket és a tapasztalt felhasználókat egyaránt szolgálja, fejlett technikákat és átfogó referenciainformációkat keresve.

Megjegyzés:

A GQL hivatalos nemzetközi szabványa az ISO/IEC 39075 Information Technology - Database Languages - GQL.

Előfeltételek

Mielőtt belevág a GQL-be, ismernie kell az alábbi fogalmakat:

• Az adatbázisok alapvető megértése – Hasznos tapasztalat bármilyen adatbázis rendszerrel (például relációs (SQL), NoSQL vagy gráf)
• Gráffogalmak – A csomópontok, élek és kapcsolatok megértése a csatlakoztatott adatokban
• A lekérdezés alapjai – Az olyan alapvető lekérdezési fogalmak ismerete, mint a szűrés, a rendezés és az összesítés

Ajánlott háttér:

• Az SQL vagy openCypher nyelvek tapasztalata megkönnyíti a GQL szintaxisának elsajátítását (ezek a GQL gyökerei).
• Az adatmodellezés ismerete segít a gráfséma tervezésében
• A gráfadatokhoz használt konkrét használati eset ismertetése

Amire szüksége lesz:

• Hozzáférés a Microsoft Fabrichez gráffunkciókkal
• Mintaadatok vagy a közösségi hálózati példákkal való együttműködésre való hajlandóság
• Egyszerű szövegszerkesztő lekérdezések írásához

Jótanács

Ha még nem ismerkedik a gráfadatbázisokkal, az útmutató folytatása előtt kezdje a gráfadatmodellek áttekintésével .

Mi teszi különlegessé a GQL-t?

A GQL kifejezetten gráfadatokhoz készült. Ez természetessé és intuitívvá teszi a kapcsolt információk használatával való munkát.

Az SQL-lel ellentétben, amely a táblacsatlakozásokra támaszkodik a kapcsolatok kifejezésére, a GQL vizuális gráfmintákat használ, amelyek közvetlenül tükrözik, hogyan kapcsolódnak az entitások egymáshoz, így a lekérdezések könnyebben olvashatók és érvelhetők lesznek.

Tegyük fel, hogy olyan embereket és barátaikat szeretnél találni (akik ismerik egymást), akik mindketten 1999 előtt születtek. Így fejezi ki ezt a GQL vizuális gráfmintával:

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

Ez a lekérdezés megkeresi azokat a barátokat (akik ismerik egymást), akik mindketten 1999 előtt születtek. A minta (person:Person)-[:knows]-(friend:Person) vizuálisan a keresett kapcsolatstruktúrát jeleníti meg – hasonlóan az adatok diagramjának rajzolásához.

A GQL alapjai

A lekérdezések megismerése előtt ismerje meg azokat az alapvető fogalmakat, amelyek a GQL alapját képezik:

• A grafikonok csomópontként (entitásként) és élként (kapcsolatokként) tárolják adataidat, mindegyiknek címkéi és tulajdonságai vannak
• A gráftípusok sémákként működnek, meghatározva, hogy milyen csomópontok és élek létezhetnek a gráfban
• A korlátozások további szabályok és korlátozások, amelyeket a gráftípusok a gráfokra szabnak az adatok integritásának biztosítására
• A lekérdezések olyan utasításokat használnak, mint a MATCH, FILTERés RETURN az adatok feldolgozása és az eredmények megjelenítése
• A minták a keresett gráfstruktúrákat írják le intuitív vizuális szintaxissal
• A kifejezések az SQL-kifejezésekhez hasonlóan végeznek számításokat és összehasonlításokat az adatokon
• A predikátumok boole-értékek kifejezések, amelyeket lekérdezéseken belüli eredmények szűrésére használnak
• Az értéktípusok határozzák meg, hogy milyen típusú értékeket lehet feldolgozni és tárolni

A gráfadatok ismertetése

A GQL hatékony használatához ismernie kell a gráfadatok strukturáltságát. Ez az alap segít a jobb lekérdezések írásában és az adatok hatékony modellezésében.

Csomópontok és élek: az építőelemek

A GQL-ben címkézett tulajdonságdiagramokkal dolgozik. A gráfok kétféle elemből állnak:

A csomópontok általában a rendszerben lévő entitásokat (főneveket) jelölik– például személyeket, szervezeteket, bejegyzéseket vagy termékeket. Ezek független objektumok, amelyek a tartományban léteznek. A csomópontokat csúcsoknak is nevezik.

Az élek az entitások (a "verbs") közötti kapcsolatokat jelölik – az entitások kapcsolódását és interakcióját. Például az emberek ismerik egymást (:knows), olyan szervezeteket, amelyek bizonyos régiókban működnek (:operates), vagy vásárlókat, akik termékeket vásároltak (:purchased).
A szegélyeket néha kapcsolatoknak is nevezik.

Minden gráfelem rendelkezik az alábbi jellemzőkkel:

• Egy belső azonosító, amely egyedileg azonosítja azt
• Egy vagy több címke – leíró nevek, például Person vagy knows. A Microsoft Fabricben a gráf éleinek mindig pontosan egy címkéje van.
• Tulajdonságok—név-érték párok, amelyek adatokat tárolnak az elemről (például firstName: "Alice" vagy birthday: "19730108").

A gráfok felépítése

Minden él pontosan két csomópontot köt össze: egy forrást és egy célhelyet. Ez a kapcsolat létrehozza a gráf struktúráját, és bemutatja, hogyan kapcsolódnak egymáshoz az entitások. A élek iránya számít – az, Person aki follows egy másik Person , irányított kapcsolatot hoz létre.

Megjegyzés:

A Microsoft Fabric grafikonja jelenleg nem támogatja az irányítatlan éleket.

A Microsoft Fabric által támogatott tulajdonsággráfok mindig jól formált, vagyis minden él két érvényes csomópontot köt össze. Ha egy gráf élét látja, mindkét végpontja ugyanabban a gráfban található.

Gráfmodellek és gráftípusok

A Microsoft Fabric gráfszerkezetét a gráfmodell írja le, amely az alkalmazástartomány adatbázissémához hasonlóan működik. A gráfmodellek a következőket határozzák meg:

• Mely csomópontok és élek létezhetnek
• Milyen címkéket és tulajdonságokat tartalmazhatnak
• Csomópontok és élek csatlakoztatása

A gráfmodellek korlátozásokkal biztosítják az adatintegritást, különösen a csomópontkulcsokra vonatkozó korlátozásokat, amelyek meghatározzák , hogy mely tulajdonságok azonosítják egyedileg az egyes csomópontokat.

Megjegyzés:

A gráfmodellek a GQL standard szintaxisával adhatók meg, ebben az esetben gráftípusoknak nevezzük őket.

Gyakorlati példa: közösségi hálózat

Ebben a dokumentációban egy közösségi hálózati példát használunk a GQL-fogalmak szemléltetésére. Ennek a tartománynak a megértése segít követni a példákat, és hasonló mintákat alkalmazni a saját adataira.

Megjegyzés:

A közösségi hálózat például a GDC (Graph Data Council) által közzétett LDBC SNB -ből (LDBC Social Network Benchmark) származik. További részletekért lásd a "The LDBC Social Network Benchmark" (Az LDBC közösségi hálózati teljesítményteszt) című cikket.

A közösségi hálózati entitások

Közösségi hálózatunk az alábbi fő csomóponttípusokat tartalmazza, amelyek a tartomány entitásait képviselik:

Az emberek személyes adatokkal, például névvel, születésnapokkal és nemekkel rendelkeznek. Városokban élnek, és társadalmi kapcsolatokat alkotnak.

A helyek földrajzi hierarchiát alkotnak:

• Városok , mint "New York" vagy "London"
• Olyan országok/régiók , mint az "Egyesült Államok" vagy az "Egyesült Királyság"
• Olyan kontinensek, mint "Észak-Amerika" vagy "Európa"

Olyan szervezetek, ahol a felhasználók időt töltenek:

• Egyetemek, ahol az emberek tanulnak
• Cégek , ahol az emberek dolgoznak

Tartalom és vitafórumok:

• Fórum bejegyzéseket tartalmazó címekkel
• Bejegyzések tartalommal, nyelvvel és választható képekkel
• Bejegyzésekre vagy egyéb megjegyzésekre válaszoló megjegyzések
• Tartalom kategorizálását és érdeklődési köröket képviselő címkék

Hogyan csatlakozik minden?

Az entitások közötti kapcsolatok érdekessé teszik a hálózatot:

• Az emberek ismerik egymást (barátságok, :knows)
• Az emberek cégeknél dolgoznak (:workAt) vagy egyetemeken tanulnak (:studyAt)
• Az emberek hozzászólásokat és hozzászólásokat készítenek (:hasCreator)
• Az emberek kedvelnek a bejegyzéseket és hozzászólásokat (:likes)
• A bejegyzések, fórumok, hozzászólások lehetnek címkék (:hasTag)
• Az embereknek érdeklődnek bizonyos címkék iránt (:hasInterest)
• A fórumok tartalmaznak bejegyzéseket (:containerOf) és tagokat (:hasMember) és moderátorokat (:hasModerator) tartalmaznak

A gráf élek tartománykapcsolatokat jelölnek. Ez a gazdag hálózat számos lehetőséget teremt az érdekes lekérdezések és elemzések számára.

Teljes sémaspecifikáció megtekintése

Az első GQL-lekérdezések

Most, hogy megismerte a gráf alapjait, lássuk, hogyan kérdezhet le gráfadatokat a GQL használatával. Ezek a példák egyszerűről összetettre építenek, és bemutatják, hogyan teszi intuitívsá és hatékonyan a gráflekérdezéseket a GQL megközelítése.

Egyszerű kezdés: az összes személy megkeresése

Kezdjük a lehető legegyszerűbb lekérdezéssel: keressük meg a grafikon összes személy(:Personi) nevét (keresztnév, vezetékneve).

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

Ez a lekérdezés a következőképpen történik:

1. MATCH megkeresi az összes címkével ellátott csomópontot Person
2. RETURN a vezeték- és utónevüket jeleníti meg

Szűrés hozzáadása: adott személyek keresése

Most keressünk olyan embereket, akiknek különleges tulajdonságaik vannak, ebben az esetben mindenki Alice-nek hívja, és mutassuk meg a nevüket és születésnapjukat.

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

Ez a lekérdezés a következőképpen történik:

1. MATCH találja az összes csomópontot (p), amely Személy címkével
2. FILTER csomópontok (p), amelyek keresztneve Alice
3. RETURN megmutatja a keresztnevét, vezetéknevét és születésnapját

Egyszerű lekérdezési struktúra

Az alapszintű GQL-lekérdezések egységes mintát követnek: az adatok kereséséhez, szűréséhez és visszaadásához közösen működő utasítások sorozatát. A legtöbb lekérdezés azzal MATCH kezdődik, hogy mintákat keres a grafikonban, és véget ér azzal, RETURN hogy megadja a kimenetet.

Itt egy egyszerű lekérdezés, amely olyan párokat talál, akik ismerik egymást és ugyanazon a születésnapon vannak, majd visszaadja az összes baráti pár számát.

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

Ez a lekérdezés a következőképpen történik:

1. MATCH megkeresi az Person összes olyan csomópontpárt, amely ismeri egymást
2. FILTER csak azokat a párokat tartja meg, ahol mindkét személynek ugyanaz a születésnapja
3. RETURN megszámolja, hogy hány ilyen barátpár létezik

Jótanács

A szűrés közvetlenül egy minta részeként is elvégezhető egy WHERE záradék hozzáfűzésével. Például csak MATCH (n:Person WHERE n.age > 23) azoknak a csomópontoknak felel meg, Person amelyek age tulajdonsága nagyobb, mint 23.

Megjegyzés:

A GQL támogatja a C stílusú // sorbejegyzéseket, az SQL-stílusú -- sor megjegyzéseit és a C stílusú /* */ blokkbejegyzéseket.

Gyakori állítások

• MATCH: Azonosítja a keresett grafikonmintát – itt definiálod az érdeklődési adatok szerkezetét.
• LET: Új változókat vagy kiszámított értékeket rendel hozzá az egyeztetett adatok alapján—hozzáad származtatott oszlopokat az eredményhez.
• FILTER: Szűkíti az eredményeket feltételek alkalmazásával – eltávolítja azokat a sorokat, amelyek nem felelnek meg a kritériumoknak.
• ORDER BY: Rendezi a szűrt adatokat – segít egy vagy több mező alapján szervezni a kimenetet.
• OFFSET és LIMIT: Korlátozzuk a visszatérő sorok számát – hasznos oldalozáshoz vagy felső k lekérdezésekhez.
• RETURN: Megadja a végső kimenetet — meghatározza, milyen adatokat kell beépíteni az eredményhalmazba, és elvégzi az aggregálást.

Az utasítások együttes működése

A GQL utasítások egy csővezetéket alkotnak, ahol minden utasítás feldolgozza az előző utasítás eredményét. Ez a sorozatos végrehajtás megkönnyíti a lekérdezések olvashatóságát és hibakeresését, mivel a végrehajtási sorrend megegyezik az olvasási sorrenddel.

Összefoglalás:

• A kijelentések hatékonyan egymás után hajtják végre.
• Minden állítás átalakítja az adatokat, és továbbítja a következőnek.
• Ez egy világos, kiszámítható adatáramlást hoz létre, amely egyszerűsíti a bonyolult lekérdezéseket.

Fontos

Belsőleg a kijelentések végrehajtása újrarendezhető, és az egyes utasítások párhuzamosan végrehajthatók a Microsoft Fabric által, hogy maximalizálják a teljesítményt. Ez azonban nem befolyásolja az eredmények helyességét.

Example

A következő GQL lekérdezés megtalálja az első 10 embert, akik olyan cégeknél dolgoznak, ahol "Air" szerepel a nevükben, teljes név szerint rendezi őket, és visszaadja a teljes nevüket a cégük nevével együtt.

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

Ez a lekérdezés a következőképpen történik:

1. MATCH olyan cégeknél dolgozik, ahol "Air" a nevükben szerepel
2. LET teljes neveket hoz létre az első és családnevek kombinálásával
3. FILTER csak Contoso alkalmazottakat tart
4. ORDER BY Sorts teljes név szerint
5. LIMIT Az első 10 eredményt veszi
6. RETURN Visszaadja a neveket és a cégek helyszíneit

Változók kötik össze az adatokat

A változók (például p, cés fullName az előző példákban) adatokat hordoznak az utasítások között. Amikor újra felhasznál egy változónevet, a GQL automatikusan biztosítja, hogy ugyanazokra az adatokra hivatkozzanak, így hatékony illesztési feltételeket hozhat létre. A változókat kötésváltozóknak is nevezik.

A változók különböző módokon kategorizálhatók:

Kötési forrás szerint:

• Mintaváltozók – egyező gráfmintákkal kötve
• Normál változók – más nyelvi szerkezetek által kötött

Mintaváltozó-típusok:

• Elemváltozók – kötés a gráfelem referenciaértékeihez
  • Csomópontváltozók – kötés az egyes csomópontokhoz
  • Élváltozók – kötés az egyes élekhez
• Elérésiút-változók – kötés az egyező elérési utakat képviselő elérésiút-értékekhez

Referenciafok szerint:

• Singleton változók – kötés az egyes elemek referenciaértékeihez mintákból
• Változók csoportosítása – kötés a változóhosszúságú minták elemhivatkozási értékeinek listáihoz (lásd : Advanced Aggregation Techniques)

Végrehajtási eredmények és eredmények

Lekérdezés futtatásakor egy végrehajtási eredményt kap, amely a következőkből áll:

• Egy (nem kötelező) eredménytábla az utasításból származó RETURN adatokkal.
• Állapotinformációk , amelyek azt mutatják, hogy a lekérdezés sikeres volt-e vagy sem.

Eredménytáblák

Az eredménytábla – ha van – a lekérdezés végrehajtásának tényleges eredménye.

Az eredménytáblák információkat tartalmaznak az oszlopok nevéről és típusáról, az eredmények megjelenítéséhez használandó előnyben részesített oszlopnév-sorozatról, a tábla rendezettségéről és magukról a tényleges sorokról.

Megjegyzés:

Végrehajtási hiba esetén a végrehajtási eredmény nem tartalmaz eredménytáblát.

Állapotadatok

A rendszer a lekérdezés végrehajtása során különböző figyelemre méltó feltételeket (például hibákat vagy figyelmeztetéseket) észlel. Minden ilyen feltételt egy állapotobjektum rögzít a végrehajtási eredmény állapotadataiban.

Az állapotinformációk egy elsődleges állapotobjektumból és a további állapotobjektumok (esetleg üres) listájából állnak. Az elsődleges állapotobjektum mindig jelen van, és jelzi, hogy a lekérdezés végrehajtása sikeres vagy sikertelen volt-e.

Minden állapotobjektum tartalmaz egy 5 jegyű állapotkódot (GQLSTATUS néven), amely azonosítja a rögzített feltételt, valamint egy üzenetet, amely leírja azt.

Sikerességi állapotkódok:

GQLSTATUS	Message	Mikor
00000	megjegyzés: sikeres befejezés	Legalább egy sor sikeres
00001	megjegyzés: sikeres befejezés – kihagyott eredmény	Sikeresség tábla nélkül (jelenleg nem használt)
02000	megjegyzés: nincs adat	Siker nulla sor esetén

Más állapotkódok további hibákat vagy figyelmeztetéseket jeleznek, amelyeket a lekérdezés végrehajtása során észleltek.

Teljes GQLSTATUS-kódok hivatkozásának megtekintése

Fontos

Az alkalmazáskódban mindig támaszkodjon állapotkódokra bizonyos feltételek teszteléséhez. Az állapotkódok garantáltan stabilak, és általános jelentésük a jövőben nem változik. Ne tesztelje az üzenetek tartalmát, mert a státuszkódhoz jelentett konkrét üzenet a jövőben változhat a lekérdezéstől függően, vagy akár ugyanazon lekérdezés végrehajtása között.

Emellett az állapotobjektumok tartalmazhatnak egy mögöttes okállapot-objektumot és egy diagnosztikai rekordot is, amely további információkat tartalmaz a rögzített feltételre vonatkozóan.

Alapvető fogalmak és utasítások

Ez a szakasz a hatékony GQL-lekérdezések írásához szükséges alapvető építőelemeket ismerteti. Minden fogalom a gyakorlati lekérdezésírási képességekre épül.

Gráfminták: struktúra keresése

A GQL-lekérdezések középpontjában a gráfminták állnak. Lehetővé teszik, hogy a keresett adatstruktúrát intuitív, vizuális szintaxissal írja le, amely a keresendő kapcsolatokhoz hasonlóan néz ki.

Egyszerű minták:

Kezdje az alapszintű kapcsolati mintákkal:

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

Minták adott adatokkal:

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

Címkekifejezések rugalmas entitásválasztáshoz:

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

Megjegyzés:

A több elemes címkével rendelkező gráfmodellek még nem támogatottak (ismert probléma).

A címkekifejezések lehetővé teszik a különböző típusú csomópontok egyezését egyetlen mintában, így a lekérdezések rugalmasabbak lesznek.

A változók újrafelhasználása hatékony illesztéseket hoz létre:

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

A változó c újbóli használata biztosítja, hogy mindkét személy ugyanabban a vállalatban dolgozhasson, és automatikus csatlakozási kényszert hoz létre. Ez a minta az "azonos entitás" kapcsolatok kifejezésének kulcsmintája.

Fontos

Kritikus megállapítás: A minták változó újrafelhasználása strukturális korlátokat hoz létre. Ez a technika olyan összetett gráfkapcsolatokat fejez ki, mint a "barátok, akik ugyanabban a cégben dolgoznak" vagy "emberek ugyanabban a városban".

Mintaszintű szűrés a WHERE használatával:

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

Határolt változóhosszúságú minták:

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

TRAIL-minták ciklusmentes bejáráshoz:

Mintákkal TRAIL megelőzheti a ciklusokat a gráfok bejárása során, biztosítva, hogy az egyes élek legfeljebb egyszer legyenek látogatva:

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

Változó hosszúságú élkötés:

A változóhosszúságú mintákban az élváltozók a környezet alapján különböző információkat rögzítenek:

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

Ez a megkülönböztetés elengedhetetlen az élváltozók helyes használatához.

Összetett minták több kapcsolattal:

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

Ez a minta megkeresi az embereket a munkahelyükkel és a tartózkodási helyükkel együtt, bemutatva, hogy egy személy hogyan csatlakozik több más entitáshoz.

Átfogó mintaszintaxis és speciális technikák megismerése

Alapvető utasítások

A GQL konkrét utasítástípusokat biztosít, amelyek együtt dolgozzák fel lépésről lépésre a gráfadatokat. Ezeknek az utasításoknak a megértése elengedhetetlen a hatékony lekérdezések létrehozásához.

MATCH nyilatkozat

Szintaxis:

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

Az MATCH utasítás felveszi a bemeneti adatokat, és megkeresi a gráfmintákat, a bemeneti változókat mintaváltozókkal összekapcsolva és az összes megfelelt kombinációt kiadva.

Bemeneti és kimeneti változók:

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

Utasításszintű szűrés a WHERE használatával:

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

Az összes egyezés utószűrhető WHERE, így elkerülve a külön FILTER utasítást.

Csatlakozás bemeneti változókkal:

Ha MATCH nem az első utasítás, akkor a bemeneti adatokat minta egyezésekkel illeszti össze:

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

Fontos

A Microsoft Fabric gráfja még nem támogatja az tetszőleges utasítás-összetételt. Tekintse meg az aktuális korlátozásokról szóló cikket.

Kulcsillesztési viselkedések:

Hogyan MATCH kezeli az adatcsatlakozásokat:

• Változók egyenlősége: A bemeneti változók mintaváltozókkal csatlakoznak egyenlőségegyezéssel
• Belső illesztés: A minta egyezések nélküli bemeneti sorok elvetése (nincs bal/jobb illesztés)
• Szűrési sorrend: Utasításszintű WHERE szűrők a mintaegyeztetés befejezése után
• Mintakapcsolat: Több mintának legalább egy változót meg kell osztania a megfelelő illesztéshez
• Teljesítmény: A megosztott változók hatékony illesztési kényszereket hoznak létre

Fontos

Korlátozás: Ha nem ez MATCH az első utasítás, legalább egy bemeneti változónak csatlakoznia kell egy mintaváltozóhoz. Több mintának egy változóval kell rendelkeznie.

Több mintához közös változók szükségesek:

-- 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 nyilatkozat

Szintaxis:

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

Az LET utasítás kiszámított változókat hoz létre, és lehetővé teszi az adatátalakítást a lekérdezési folyamaton belül.

Alapszintű változó létrehozása:

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

Összetett számítások:

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

Főbb viselkedések:

• A kifejezéseket minden bemeneti sor kiértékeli
• Az eredmények új oszlopokká válnak a kimeneti táblában
• A változók csak az előző utasításokból származó meglévő változókra hivatkozhatnak
• Egyszerre több hozzárendelés LET kiértékelése párhuzamosan történik (kereszthivatkozások nélkül)

FILTER nyilatkozat

Szintaxis:

FILTER [ WHERE ] <predicate>

Az FILTER utasítás pontosan szabályozza, hogy mely adatok haladnak tovább a lekérdezési folyamaton keresztül.

Alapszintű szűrés:

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

Összetett logikai feltételek:

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

Nullérzékeny szűrési minták:

A null értékek biztonságos kezeléséhez használja ezeket a mintákat:

• Értékek ellenőrzése: p.firstName IS NOT NULL - utónévvel rendelkezik
• Adatok érvényesítése: p.id > 0 - érvényes azonosító
• Hiányzó adatok kezelése: NOT coalesce(p.locationIP, '127.0.0.1') STARTS WITH '127.0.0' - nem a helyi hálózatról csatlakozott
• Feltételek kombinálása: Használata AND/OR explicit null-ellenőrzésekkel összetett logikához

Caution

Ne feledje, hogy a null értékeket tartalmazó feltételek visszaadják UNKNOWNazokat a feltételeket, amelyek kiszűrik ezeket a sorokat. Használjon explicit IS NULL ellenőrzéseket, ha null-inclusive logikára van szüksége.

ORDER BY nyilatkozat

Szintaxis:

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

Többszintű rendezés számított kifejezésekkel:

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)

Null értékű kezelés a rendezésben:

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

Rendezési viselkedés részletei:

A működés ismertetése ORDER BY :

• Kifejezéskiértékelés: A kifejezések kiértékelése minden sorban történik, majd az eredmények határozzák meg a sorsorrendet
• Több rendezési kulcs: Hierarchikus rendezés létrehozása (elsődleges, másodlagos, harmadlagos stb.)
• Null kezelés: NULL mindig a legkisebb értékként kezelik az összehasonlításokban
• Alapértelmezett sorrend: ASC (növekvő) az alapértelmezett érték, DESC a (csökkenő) értéket explicit módon kell megadni
• Számított rendezés: Számított értékek szerint rendezhet, nem csak tárolt tulajdonságok szerint

Caution

A létrehozott ORDER BY rendezési sorrend csak az azonnal következő utasítás számára látható. Ezért, ORDER BY majd nem RETURN * hoz létre rendezett eredményt.

Összehasonlít:

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  */

együtt:

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              */

Ennek azonnali következményei vannak a "Top-k" lekérdezésekre: LIMIT mindig kövesse a ORDER BY kívánt rendezési sorrendet megállapító utasítást.

OFFSET és LIMIT állítások

Szintaxis:

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

Gyakori minták:

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

Fontos

A kiszámítható lapozási eredményekhez mindig használja ORDER BY a lekérdezések OFFSETLIMIT közötti konzisztens sorrendezést.

RETURN: alapszintű eredményvetítés

Szintaxis:

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

Az RETURN utasítás a lekérdezés végleges kimenetét adja meg az eredménytáblában megjelenő adatok megadásával.

Egyszerű kimenet:

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

Aliasok használata az egyértelműség érdekében:

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

Kombinálás rendezéssel és 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

Ismétlődő kezelés a DISTINCT használatával:

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

Kombinálás összesítéssel:

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

RETURN amely: GROUP BYcsoportosított eredményvetítés

Szintaxis:

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

Sorok GROUP BY csoportosítása megosztott értékek és számítási összesítő függvények szerint az egyes csoportokon belül.

Alapszintű csoportosítás összesítéssel:

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

Többoszlopos csoportosítás:

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

Megjegyzés:

A speciális aggregációs technikákért, beleértve a változó hosszúságú minták vízszintes összesítését, tekintse meg az Advanced Aggregation Techniques (Speciális összesítési technikák) című témakört.

Adattípusok: értékek használata

A GQL támogatja a gazdag adattípusokat a különböző típusú információk tárolásához és kezeléséhez a gráfban.

Alapértéktípusok:

• Számok: INT64, UINT64számításokhoz DOUBLE és mérésekhez
• Szöveg: STRING nevekhez, leírásokhoz és szöveges adatokhoz
• Logika: BOOL három értékkel: IGAZ, HAMIS és ISMERETLEN (null értékű kezeléshez)
• Idő: ZONED DATETIME időzónával rendelkező időbélyegek esetén
• Gyűjtemények: LIST<T> több azonos típusú Térték esetén , PATH gráf áthaladási eredmények esetén
• Gráfelemek: NODE és EDGE a gráfadatokra való hivatkozáshoz

Fontos

Bizonyos értéktípusok nem támogatottak az ingatlanértékek típusaiként. Különösen minden olyan érték, amely gráfelem-referenciaértékeket tartalmaz, nem használható tulajdonságértékként (például csomópontok vagy útvonalak listái).

Példa literálokra:

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

Kritikus null kezelési minták:

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

Háromértékű logikai következmények:

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

Caution

A háromértékű logika azt jelenti, hogy NULL = NULL a visszaadott érték nem UNKNOWNTRUE. Ez a viselkedés hatással van a szűrésre és az illesztésekre. Null tesztekhez mindig használható IS NULL .

Átfogó típusrendszer-részletek

Kifejezések: adatok átalakítása és elemzése

A kifejezések lehetővé teszik az adatok kiszámítását, összehasonlítását és átalakítását a lekérdezéseken belül. Hasonlóak az SQL-beli kifejezésekhez, de a gráfadatok kezeléséhez további funkciókkal rendelkeznek.

Gyakori kifejezéstípusok:

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

Összetett predikátum-összetétel:

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

Sztringminta egyeztetése:

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

Beépített függvények kategória szerint:

A GQL ezeket a függvénykategóriákat biztosítja a különböző adatfeldolgozási igényekhez:

• Összesítő függvények: count(), sum(), avg(), min()adatok max() összegzéséhez
• Sztringfüggvények: char_length(), upper(), lower()szövegfeldolgozáshoz trim()
• Gráffüggvények: nodes(), edges()labels() gráfstruktúrák elemzéséhez
• Általános függvények: coalesce() null értékek kecses kezeléséhez

Összetett kifejezések operátori elsőbbsége:

1. Tulajdonsághozzáférés (.)
2. Szorzás/osztás (*, /)
3. Összeadás/kivonás (+, -)
4. Összehasonlítás (=, <>, <, >, <=, >=)
5. Logikai tagadás (NOT)
6. Logikai kötőszó (AND)
7. Logikai tiltás (OR)

A fenti listában egy alacsonyabb számú operátor "szorosabban köt hozzá", mint a magasabb számú operátor. Példa: NOT n.prop OR m.prop is (NOT n.prop) OR m.prop , de nem 'NOT (n.prop VAGY m.prop)

Jótanács

Zárójelek használatával egyértelművé teheti az elsőbbséget. Az összetett kifejezések könnyebben olvashatók és hibakeresést végezhetnek, ha a csoportosítás egyértelmű.

Az átfogó kifejezésszintaxis és az összes beépített függvény megismerhető

Speciális lekérdezési technikák

Ez a szakasz összetett, hatékony gráfalapú lekérdezések készítésének kifinomult mintáit és technikáit ismerteti. Ezek a minták túlmutatnak az alapszintű utasításhasználaton, így hatékony elemzési lekérdezéseket hozhatnak össze.

Összetett többutas összetétel

Fontos

A Microsoft Fabric gráfja még nem támogatja az tetszőleges utasítás-összetételt. Tekintse meg az aktuális korlátozásokról szóló cikket.

Az összetett lekérdezések hatékony összeállításának megértése elengedhetetlen a speciális gráfalapú lekérdezésekhez.

Többlépéses minta előrehaladása:

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

Ez a lekérdezés fokozatosan bonyolulttá teszi a helyzetet: keresse meg a cégeket, alkalmazottaikat, helyeket, szűrje azokat a cégeket, amelyek 1985 előtt született alkalmazottakat tartalmaznak, kiszámítják az átlagos születésnapot, összefoglalják és rendezik az eredményeket.

Vízszintes összesítés használata:

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

Megjegyzés:

Ez a lekérdezés még nem támogatott (ismert probléma).

Változó hatóköre és speciális folyamatvezérlés

A változók lekérdezési utasítások között kötik össze az adatokat, és összetett gráfbejárásokat tesznek lehetővé. A speciális hatókörszabályok megismerése segít kifinomult többutas lekérdezések írásában.

Változókötési és hatókörkezelési minták:

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

Változók újrafelhasználása az illesztésekhez az utasítások között:

-- 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 *

Kritikus hatókörkezelési szabályok és korlátozások:

-- ✅ 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 *

Változó láthatósága összetett lekérdezésekben:

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

Caution

Az ugyanabban az utasításban szereplő változók nem hivatkozhatnak egymásra (kivéve a gráfmintákat). A függő változók létrehozásához használjon külön utasításokat.

Speciális összesítési technikák

A GQL két különböző típusú aggregációt támogat az adatok csoportok és gyűjtemények közötti elemzéséhez: függőleges összesítés változó hosszúságú mintákon keresztül és vízszintes összesítéssel GROUP BY .

Függőleges összesítés a GROUP BY használatával

A függőleges aggregáció (a benne RETURNfoglalt) megosztott értékek szerint csoportosítja aGROUP BY sorokat, és kiszámítja az egyes csoportokon belüli összesítéseket:

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

Ez a módszer vállalatonként egy eredménysort hoz létre, amely az egyes csoportokban lévő összes alkalmazottat összesít.

Vízszintes összesítés csoportlista-változókkal

A vízszintes aggregáció a változó hosszúságú minták által kötött gyűjtemények összesítését számítja ki. Változóhosszúságú élek használatakor az élváltozó csoportlista-változóvá válik, amely minden illesztett útvonal minden élét tartalmazza:

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

Megjegyzés:

Ez a lekérdezés még nem támogatott (ismert probléma).

Főbb különbségek:

• A függőleges aggregáció sorok – vagy – csoportosítja a sorokat, és összegzi az egyes csoportok sorait
• A horizontális összesítés az egyes peremhálózat-gyűjteményeken belüli elemeket összegzi
• A csoportlista változói csak változó hosszúságú élmintákból származnak

Változó hosszúságú élkötési környezetek

Az élváltozók változók változóhosszúságú mintákban való kötésének megértése kulcsfontosságú:

Mintaegyeztetés során (önálló környezet):

-- 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 *

Eredménykifejezésekben (csoportkörnyezetben):

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

Megjegyzés:

Ez a lekérdezés még nem támogatott (ismert probléma).

Függőleges és vízszintes összesítés kombinálása

Mindkét aggregációs típust összetett elemzési mintákban kombinálhatja:

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

Megjegyzés:

Ez a lekérdezés még nem támogatott (ismert probléma).

Jótanács

A vízszintes összesítés mindig elsőbbséget élvez a függőleges összesítéssel szemben. Ha egy csoportlistát normál listává szeretne alakítani, használja collect_list(edges)a következőt:

Megjegyzés:

Az aggregátumfüggvények részletes referenciáját a GQL-kifejezések és -függvények című témakörben találja.

Hibakezelési stratégiák

A gyakori hibaminták megismerése segít a robusztus lekérdezések írásában.

A hiányzó adatok kezelése kecsesen:

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 *

Explicit null értékű ellenőrzések használata:

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 *

További információk

GQLSTATUS-kódok

A lekérdezési eredményekről szóló szakaszban leírtak szerint a GQL részletes állapotinformációkat közöl a végrehajtás sikerességével vagy lehetséges sikertelenségével kapcsolatban. Tekintse meg a teljes lista GQL-állapotkódjainak hivatkozását .

Fenntartott szavak

A GQL fenntart bizonyos kulcsszavakat, amelyeket nem használhat azonosítóként, például változókként, tulajdonságnevekként vagy címkenevekként. Tekintse meg a teljes lista fenntartott GQL-beli szavainak hivatkozását .

Ha fenntartott szavakat kell azonosítóként használnia, a következő háttérjelekkel meneküljön el: `match`, `return`.

A fenntartott szavak elől való menekülés elkerülése érdekében használja ezt az elnevezési konvenciót:

• Egyszavas azonosítók esetén fűzze hozzá az aláhúzásjelet: :Product_
• Többszavas azonosítók esetén használja a camelCase vagy a PascalCase: :MyEntity, , :hasAttributetextColor

Következő lépések

Most, hogy megismerte a GQL alapjait, itt találja az ajánlott képzési tervet:

A GQL-készségek fejlesztésének folytatása

Kezdőknek:

• Próbálja ki a rövid útmutatót – Gyakorlati tapasztalatért kövesse gyakorlati oktatóanyagunkat
• Alapszintű lekérdezések gyakorlása – Próbálja ki az útmutatóban szereplő példákat saját adataival
• Gráfminták megismerése – Az átfogó mintaszintaxis elsajátítása
• Adattípusok megismerése – A GQL-értékek és az értéktípusok ismertetése

Tapasztalt felhasználók számára:

• Speciális kifejezések – Fő GQL-kifejezések és -függvények
• Sématervezés – GQL-gráftípusok és megkötések megismerése
• Adattípusok megismerése – A GQL-értékek és az értéktípusok ismertetése

Referenciaanyagok

A gyors kereséshez tartsa kéznél ezeket a hivatkozásokat:

• GQL gyorshivatkozás – Szintaxis – gyorshivatkozás
• GQL-állapotkódok – Teljes hibakód-referencia
• Fenntartott GQL-szavak – Fenntartott kulcsszavak teljes listája

A Microsoft Fabric felfedezése

Ismerje meg a platformot:

• Gráfadatmodellek – A gráffogalmak és a modellezés ismertetése
• Gráf és relációs adatbázisok – A megfelelő megközelítés kiválasztása
• Próbálja ki ingyenesen a Microsoft Fabricet – Gyakorlati élmény
• Teljes körű oktatóanyagok – Teljes tanulási forgatókönyvek

Közösségi részvétel

• Visszajelzés megosztása – Dokumentációnk és eszközeink továbbfejlesztése
• Csatlakozás a közösséghez – Csatlakozás más gráfadatbázis-kezelőkkel
• Maradjon naprakész – Új funkciókkal kapcsolatos Microsoft Fabric-közlemények követése

Jótanács

Kezdje a rövid útmutatóval , ha inkább a tanulást szeretné elvégezni, vagy ismerkedjen meg a gráfmintákkal , ha először a lekérdezés nyelvét szeretné elsajátítani.

Kapcsolódó tartalom

További részletek a főbb témakörökről:

• Példa a közösségi hálózat sémájára – A gráfséma teljes munka példája
• GQL-gráfminták – Átfogó mintaszintaxis és speciális egyeztetési technikák
• GQL-kifejezések és függvények – Minden kifejezéstípus és beépített függvény
• GQL-gráftípusok – Gráftípusok és megkötések
• GQL-értékek és értéktípusok – Teljes típusrendszer-referencia és értékkezelés

Gyorshivatkozások:

• GQL rövidített referencia – Szintaxis gyorshivatkozása
• GQL-állapotkódok – Teljes hibakód-referencia
• Fenntartott GQL-szavak – Fenntartott kulcsszavak teljes listája

Gráf a Microsoft Fabricben:

• Gráfadatmodellek – A gráffogalmak és a modellezés ismertetése
• Gráf- és relációs adatbázisok – Különbségek és mikor érdemes használni az egyes adatbázisokat
• Próbálja ki ingyenesen a Microsoft Fabricet
• Teljes körű tananyagok a Microsoft Fabricben