Príručka jazyka GQL pre graf v službe Microsoft Fabric

GQL (Graph Query Language) je jazyk dotazov štandardizovaný v norme ISO pre databázy grafu. Pomocou jazyka GQL môžete pomocou služby Graph v službe Microsoft Fabric efektívne dotazovať, analyzovať a pracovať s údajmi v grafe.

Rovnaká pracovná skupina ISO, ktorá štandardizuje SQL, vyvíja GQL. V dôsledku toho GQL zdieľa mnohé koncepty s SQL vrátane výrazov, predikátov a typov údajov. Ak máte skúsenosti s JAZYKOM SQL, väčšinu týchto znalostí môžete uplatniť na GQL.

Tento článok poskytuje komplexný odkaz na jazyk GQL v grafe. Zahŕňa:

• Základné koncepty: Graf štruktúr údajov, vzorov a základov dotazov
• Základné príkazy: MATCH, FILTER, LET, ORDER BY, LIMITa RETURN
• Typy údajov a výrazy: Typy hodnôt, operátory a vstavané funkcie
• Pokročilé techniky: multi-vyhlásenie zloženie, premennej rozsahu, a agregačné stratégie

Poznámka

Oficiálna medzinárodná norma pre GQL je ISO/IEC 39075 Information Technology - Database Languages - GQL.

Ak hľadáte sprievodný materiál orientovaný na úlohy a nie úplný odkaz na jazyk, pozrite si podrobných sprievodcov:

• Písanie bežných dotazov GQL – susedov, prechádzania viacerými skokmi, zdieľaných pripojení a kontrol existencie entity
• Filtrovanie a agregované údaje grafu – funkcie FILTER, WHERE, GROUP BY a agregačné funkcie
• Zapisovanie vzorových dotazov grafu – vzory viacnásobného skoku, režimy cesty, opätovné použitie premenných a VOLITEĽNÁ ZHODa
• Optimalizácia výkonu dotazov jazyka GQL – stratégia filtrovania, limity prechádzania a kľúčové odporúčania obmedzení

Požiadavky

Skôr než začnete, uistite sa, že poznáte tieto koncepty:

• Basic pochopenie databáz – užitočné je pracovať s ľubovoľným databázovým systémom, ako je napríklad relačný (SQL), NoSQL alebo graf.
• Koncepty grafu – pochopenie uzlov, okrajov a vzťahov v prepojených údajoch.
• Základy dotazov – znalosť základných konceptov dotazov, ako je filtrovanie, zoraďovanie a agregácia.

Odporúčané pozadie:

• Skúsenosti s jazykmi SQL alebo openCypher uľahčujú učenie sa syntaxe GQL (sú to korene GQL).
• Znalosť modelovania údajov pomáha pri navrhovaní schémy grafu.
• Pochopenie vášho konkrétneho prípadu použitia v prípade grafových údajov.

Čo potrebujete:

• Prístup k pracovnému priestoru grafu s možnosťami dotazov.
• Vzorové údaje alebo ochota pracovať s našimi príkladmi sociálnej siete.
• Základný textný editor na písanie dotazov.

Prepitné

Ak ste nováčikom v grafových databázach, skôr ako budete pokračovať v tejto príručke, začnite s prehľadom dátových modelov v grafoch .

Čo robí GQL špeciálne

Jazyk GQL je navrhnutý špeciálne pre údaje grafu. Vďaka tomuto návrhu je prirodzené a intuitívne pracovať s prepojenými informáciami.

Na rozdiel od SQL, ktorý sa spolieha na spojenia tabuliek a vyjadruje vzťahy, GQL používa vzory vizuálových grafov. Tieto vzory priamo odrážajú spojenie entít, vďaka čomu sú dotazy ľahšie čitateľné a zrozumiteľnejšie.

Predpokladajme, že chcete nájsť ľudí a ich priateľov (ľudí, ktorí sa navzájom poznajú), ktorí sa narodili pred rokom 1999. Takto GQL vyjadruje túto podmienku pomocou vzoru vizuálneho grafu:

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

Tento dotaz nájde priateľov (ľudí, ktorí sa poznajú) ktorí sa narodili pred rokom 1999. (person:Person)-[:knows]-(friend:Person) Vzor vizuálne zobrazuje štruktúru vzťahov, ktorú hľadáte. Podobne ako kreslenie diagramu údajov.

Základy GQL

Pred skokom do dotazov, pochopiť tieto základné koncepty, ktoré tvoria základ GQL:

• V grafoch sa ukladajú údaje ako uzly (entity) a okraje (vzťahy), pričom každá z nich má označenia a vlastnosti.
• Typy grafov fungujú ako schémy a definujú, ktoré uzly a okraje môžu v grafe existovať.
• Obmedzenia sú ďalšie pravidlá a obmedzenia, ktoré typy grafov ukladajú na grafy na vynútenie integrity údajov.
• Dotazy používajú príkazy ako MATCH, FILTERa RETURN na spracovanie údajov a zobrazenie výsledkov.
• Vzory popisujú štruktúry grafov, ktoré chcete nájsť, pomocou intuitívnej vizuálnej syntaxe.
• Výrazy vykonávajú výpočty a porovnania s údajmi, podobne ako výrazy SQL.
• Predikáty sú booleovské výrazy hodnôt, ktoré filtrujú výsledky v rámci dotazov.
• Typy hodnôt definujú, aké druhy hodnôt môžete spracovať a uložiť.

Pochopenie údajov grafu

Ak chcete efektívne pracovať s jazykom GQL, musíte pochopiť štruktúru grafových údajov. Táto nadácia vám pomáha písať lepšie dotazy a efektívne modelovať údaje.

Uzly a okraje: stavebné bloky

V jazyku GQL pracujete s grafmi označenými vlastnosťami. Graf sa skladá z dvoch typov prvkov:

• Uzly zvyčajne predstavujú entity ("podstatné mená") vo vašom systéme – napríklad ľudia, organizácie, príspevky alebo produkty. Sú to nezávislé objekty, ktoré existujú vo vašej doméne. Niekedy tiež nazývate uzly vertices.

• Okraje predstavujú vzťahy medzi entitami ("slovesá") – spôsob pripojenia a interakcie vašich entít.

Napríklad ľudia sa navzájom poznajú (:knows), organizácie, ktoré pôsobia v konkrétnych regiónoch (:operates), alebo zákazníci, ktorí nakupovali produkty (:purchased).
Niekedy vzťahy medzi okrajmi nazývate aj okraje.

Každý prvok grafu má tieto vlastnosti:

• Interné ID, ktoré ho jednoznačne identifikuje
• Jedno alebo viacero označení – popisné názvy ako Person alebo knows. V grafe majú okraje vždy presne jedno označenie.
• Vlastnosti – páry názov-hodnota, ktoré ukladajú údaje o prvku (napríklad firstName: "Alice" alebo birthday: "19730108").

Ako sú grafy štruktúrované

Každá hrana spája presne dva uzly: počiatok a cieľ. Toto pripojenie vytvorí štruktúru grafu a ukáže, ako entity navzájom súvisia. Na smere okrajov záleží – na Person tom, kto follows iný Person vytvorí cielený vzťah.

Poznámka

Graf v súčasnosti nepodporuje obojsmerné okraje.

Grafy vlastností, ako sú podporované v grafoch, sú vždy dobre naformované, čo znamená, že každý okraj spája dva platné uzly. Ak sa v grafe zobrazuje okraj, obidva jeho koncové body sa nachádzajú v tom istom grafe.

Modely a typy grafov v grafe

Model grafu popisuje štruktúru grafu. Funguje ako schéma databázy pre doménu aplikácie. Definovanie modelov grafu:

• Ktoré uzly a okraje môžu existovať
• Aké označenia a vlastnosti môžu mať
• Ako sa pripájajú uzly a okraje

Modely grafu tiež prostredníctvom obmedzení zabezpečujú integritu údajov, najmä kľúčové obmedzenia uzla , ktoré určujú, ktoré vlastnosti jednoznačne identifikujú každý uzol.

Poznámka

Pomocou štandardnej syntaxe GQL môžete zadať grafové modely. V tomto prípade sa nazývajú typy grafov.

Praktický príklad: sociálna sieť

V celej tejto dokumentácii príklad sociálnej siete ilustruje koncepty jazyka GQL. Princípy tejto domény vám pomôžu postupovať podľa príkladov a použiť podobné vzory na vlastné údaje.

Poznámka

Príklad sociálnej siete je odvodený od knižnice LDBC SNB (LDBC Social Network Benchmark), ktorú zverejnila GDC (Graph Data Council). Ďalšie informácie nájdete v téme "LDBC Social Network Benchmark".

Entity sociálnych sietí

Naša sociálna sieť zahŕňa tieto hlavné druhy uzlov, ktoré predstavujú entity domény:

Ľudia majú osobné informácie, ako sú mená, narodeniny a pohlavie. Žijú v mestách a vytvárajú sociálne spojenia.

Miesta tvoria geografickú hierarchiu:

• Mestá ako "New York" alebo "London"
• Krajiny/oblasti ako "United States" alebo "Spojené kráľovstvo"
• Kontinenty ako "Severná Amerika" alebo "Európa"

Organizácie, v ktorých ľudia trávia čas:

• Univerzity , kde ľudia študujú
• Spoločnosti , v ktorých ľudia pracujú

Obsah a diskusie:

• Fóra s názvami , ktoré obsahujú príspevky
• Príspevky s obsahom, jazykom a voliteľnými obrázkami
• Komentáre , ktoré odpovedá na príspevky alebo iné komentáre
• Značky , ktoré kategorizujú obsah a zastupujú záujmy

Ako sa všetko spája

Pripojenia medzi entitami robia sieť zaujímavou:

• Ľudia sa poznajú navzájom (priateľstvo, :knows).
• Ľudia pracujú v spoločnostiach (:workAt) alebo študujú na univerzitách (:studyAt).
• Ľudia vytvárajú príspevky a komentáre (:hasCreator).
• Ľudia majú radi príspevky a komentáre (:likes).
• Príspevky, fóra a komentáre môžu mať značky (:hasTag).
• Ľudia majú záujem o konkrétne značky (:hasInterest).
• Fóra obsahujú príspevky (:containerOf) a majú členov (:hasMember) a moderátorov (:hasModerator).

Okraje grafu predstavujú vzťahy medzi doménami. Táto bohatá sieť vytvára veľa príležitostí na zaujímavé dotazy a analýzy.

Zobraziť úplnú špecifikáciu schémy

Vaše prvé dotazy GQL

Teraz, keď poznáte základy grafov, pozrime sa, ako dotazovať údaje grafu pomocou jazyka GQL. Tieto príklady sa vytvárajú od jednoduchých po zložité a ukazujú, ako prístup jazyka GQL uľahčuje intuitívne a výkonné dotazy grafu.

Začnite jednoduchý: nájsť všetkých ľudí

Začnite najzákladnejším možným dotazom. Vyhľadajte v grafe mená (krstné meno, priezvisko) všetkých ľudí:Person.

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

Tento dotaz sa spustí takto:

1. MATCH nájde všetky uzly označené ako Person.
2. RETURN zobrazí ich krstné meno a priezvisko.

Pridanie filtrovania: vyhľadanie konkrétnych ľudí

Teraz vyhľadajte ľudí s konkrétnymi vlastnosťami. V tomto prípade vyhľadajte všetkých používateľov, ktorí sa volajú Alice a zobrazia svoje mená a narodeniny.

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

Tento dotaz sa spustí takto:

1. MATCH nájde všetky uzly (p) s označením Osoba.
2. FILTER uzly (p), ktorých krstné meno je Alice.
3. RETURN zobrazí svoje krstné meno, priezvisko a narodeniny.

Základná štruktúra dotazov

Všetky základné dotazy GQL majú konzistentný vzor: postupnosť príkazov, ktoré spoločne pracujú na vyhľadávaní, filtrovaní a vrátení údajov. Väčšina dopytov začína tým, že hľadá vzory v grafe, a končí tým MATCH , RETURN že špecifikuje výstup.

Tu je jednoduchý dotaz, ktorý nájde páry ľudí, ktorí sa poznajú a majú rovnaké narodeniny, a potom vráti celkový počet týchto párov priateľov.

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

Tento dotaz sa spustí takto:

1. MATCH nájde všetky dvojice Person uzlov, ktoré sa navzájom poznajú.
2. FILTER udržiava iba páry, kde obaja ľudia majú rovnaké narodeniny.
3. RETURN počíta, koľko takýchto priateľ pary existujú.

Prepitné

Filtrovanie môžete vykonať aj priamo ako súčasť vzoru tak, že pripojíte klauzulu WHERE . Napríklad sa zhoduje iba s MATCH (n:Person WHERE n.age > 23) uzlami, Person ktorých age vlastnosť je väčšia ako 23.

GQL podporuje komentáre v riadkoch c-style // , komentáre v štýle -- SQL a komentáre blokov c-style /* */ .

Bežné tvrdenia

• MATCH: Identifikuje vzor grafu, ktorý hľadať – tu definujete štruktúru dát, o ktoré máte záujem.
• LET: Priraďuje nové premenné alebo vypočítané hodnoty na základe zodpovedajúcich dát – pridáva odvodené stĺpce k výsledku.
• FILTER: Zužuje výsledky aplikovaním podmienok – odstraňuje riadky, ktoré kritériá nespĺňajú.
• ORDER BY: Triedi filtrované dáta—pomáha organizovať výstup na základe jedného alebo viacerých polí.
• OFFSET a LIMIT: Obmedziť počet vrátených riadkov – užitočné pre stránkovanie alebo top-k dotazy.
• RETURN: Špecifikuje konečný výstup—definuje, aké údaje by mali byť zahrnuté do výsledkovej množiny a vykonáva agregáciu.

Ako navzájom fungujú príkazy

GQL príkazy tvoria pipeline, kde každý príkaz spracováva výstup predchádzajúceho. Toto sekvenčné vykonávanie uľahčuje čitanie a ladenie dotazov, pretože poradie vykonávania zodpovedá poradiu čítania.

Kľúčové body:

• Príkazy sa efektívne vykonávajú postupne.
• Každý príkaz transformuje dáta a odovzdáva ich ďalšiemu.
• Tento proces vytvorí jasný a predvídateľný tok údajov, ktorý zjednodušuje komplexné dotazy.

Dôležité

S cieľom maximalizovať výkon môže graf zmeniť poradie vykonávania príkazov a súbežne spúšťať jednotlivé príkazy. Tieto optimalizácie nemajú vplyv na správnosť výsledkov.

Príklad zloženia vyhlásenia

Nasledujúci dotaz GQL nájde prvých 10 ľudí pracujúcich v spoločnostiach s "Air" v mene, zoradí ich podľa celého mena a vráti ich plné meno spolu s názvom ich spoločností.

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

Tento dotaz sa spustí takto:

1. MATCH Nájdite ľudí, ktorí pracujú vo firmách.
2. LET vytvorí celé mená skombinovaním krstných a rodinných názvov.
3. FILTER ponecháva len zamestnancov spoločností, ktoré majú v názve "Air".
4. ORDER BY zoradí všetko podľa celého mena.
5. LIMIT funkcia získa prvých 10 výsledkov.
6. RETURN Vráti celé mená a názvy spoločností.

Premenné spájajú vaše údaje

Premenné, ako pnapríklad , ca fullName v predchádzajúcich príkladoch, nesú údaje medzi príkazmi. Pri opätovnom použití názvu premennej funkcia GQL automaticky zabezpečí, že bude odkazovať na rovnaké údaje a vytvorí výkonné podmienky spojenia. Premenné sa niekedy nazývajú aj premenné väzby.

Premenné môžete kategorizovať rôznymi spôsobmi:

Podľa zdroja väzby:

• Premenné vzoru – viazané zodpovedajúcimi grafovými vzormi
• Pravidelné premenné – viazané inými konštrukciami jazyka

Typy premenných vzoru:

• Premenné prvkov – naviazané na referenčné hodnoty prvku grafu
  • Premenné uzla – naviazané na jednotlivé uzly
  • Premenné okrajov – naviazané na jednotlivé okraje
• Premenné cesty – naviazané na hodnoty ciest predstavujúce zhodné cesty

Podľa referenčného stupňa:

• Premenné typu singleton – naviazané na referenčné hodnoty jednotlivých prvkov zo vzorov
• Skupinové premenné – naviazané na zoznamy referenčných hodnôt prvkov zo vzorov s premenlivou dĺžkou (pozrite si tému Pokročilé techniky agregácie)

Výsledky a výsledky vykonávania

Pri spustení dotazu získate späť výsledok vykonávania , ktorý sa skladá z týchto:

• (voliteľná) tabuľka výsledkov s údajmi z vášho RETURN príkazu.
• Informácie o stave , ktoré zobrazujú, či dotaz prebehol úspešne alebo nie.

Výsledné tabuľky

Tabuľka výsledkov, ak je prítomná, je skutočným výsledkom vykonania dotazu.

Výsledná tabuľka obsahuje informácie o názve a type jej stĺpcov, preferovanú postupnosť názvov stĺpcov, ktorá sa má použiť na zobrazenie výsledkov, bez ohľadu na to, či je tabuľka zoradená, a samotné skutočné riadky.

Poznámka

Ak je vykonanie neúspešné, do výsledku vykonávania nie je zahrnutá žiadna tabuľka výsledkov.

Informácie o stave

Počas spúšťania dotazu proces zistí rôzne pozoruhodné podmienky, ako sú napríklad chyby alebo upozornenia. Každá podmienka sa zaznamená objektom stavu v informáciách o stave výsledku.

Informácie o stave sa skladá z primárneho objektu stavu a (pravdepodobne prázdneho) zoznamu iných objektov stavu. Objekt primárneho stavu vždy existuje a udáva, či vykonanie dotazu bolo úspešné alebo neúspešné.

Každý objekt stavu obsahuje päťciferný kód stavu (GQLSTATUS), ktorý identifikuje zaznamenanú podmienku, a správu, ktorá ju popisuje.

Kódy stavu úspešnosti:

GQLSTATUS	Správa	Kedy
00000	poznámka: úspešné dokončenie	Úspešné s aspoň jedným riadkom
00001	poznámka: úspešné dokončenie - vynechaný výsledok	Úspech bez tabuľky (momentálne sa nepoužíva)
02000	poznámka: žiadne údaje	Úspech s nulami riadkov

Iné kódy stavu označujú ďalšie chyby alebo upozornenia, ktoré zistí proces vykonávania dotazu.

Dôležité

V kóde aplikácie sa vždy spoliehajte na kódy stavu na testovanie určitých podmienok. Kódy stavu sú zaručene stabilné a ich všeobecný význam sa v budúcnosti nezmení. Nettestujte obsah správ, pretože konkrétne správy nahlásené pre kód stavu sa môžu v budúcnosti zmeniť v závislosti od dotazu, alebo dokonca medzi vykonaním toho istého dotazu.

Objekty stavu môžu okrem toho obsahovať základný objekt stavu príčiny a diagnostickým záznamom s ďalšími informáciami, ktoré charakterizujú zaznamenanú podmienku.

Zobraziť úplný odkaz na kódy GQLSTATUS

Základné koncepty a príkazy

Táto časť sa venuje základným stavebným prvkom, ktoré potrebujete napísať efektívne dotazy GQL. Každý koncept sa stavia na praktických zručnostiach pri písaní dotazov.

Vzory grafu: vyhľadanie štruktúry

Vzory grafu sú jadrom dotazov GQL. Umožňujú popísať štruktúru údajov, ktorú hľadáte, pomocou intuitívnej vizuálnej syntaxe, ktorá vyzerá ako vzťahy, ktoré chcete nájsť.

Jednoduché vzory:

Začnite so základnými vzormi vzťahov:

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

Vzory so špecifickými údajmi:

-- Find employees named Alice
(p:Person)-[:workAt]->(c:Company)
WHERE p.firstName = 'Alice'

-- Find friends who both have birthdays after December 31, 1999
(p:Person)-[:knows]->(f:Person)  
WHERE p.birthday > 19991231 AND f.birthday > 19991231

Výrazy označenia pre flexibilný výber entity:

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

Poznámka

Uzly môžu mať viacero označení, ale okrajové typy s viacerými označeniami zatiaľ nie sú podporované.

Výrazy označenia vám umožňujú zhodovať rôzne druhy uzlov v jednom vzore, vďaka čomu sú dotazy flexibilnejšie.

Opätovné použitie premennej vytvára výkonné spojenia:

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

Opätovné použitie premennej c zabezpečí, že obaja ľudia budú pracovať v tej istej spoločnosti a vytvorí sa obmedzenie automatického spojenia. Tento vzor je kľúčovým vzorom na vyjadrenie vzťahov "rovnaká entita".

Dôležité

Kritický prehľad: Opätovné použitie premenných v vzoroch vytvára štrukturálne obmedzenia. Pomocou tejto techniky môžete vyjadriť zložité grafové vzťahy, napríklad "priatelia, ktorí pracujú v tej istej spoločnosti" alebo "ľudia v tom istom meste".

Filtrovanie na úrovni vzoru s kde:

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

Ohraničené vzory s premenlivou dĺžkou:

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

Režimy cesty na ovládanie prechádzavania:

Režimy cesty ovládajú spôsob, akým nástroj dotazov spracováva opakované prvky počas prechádzania s premenlivou dĺžkou:

Režim cesty	Description
WALK	Umožňuje opakované uzly a okraje. Žiadne obmedzenia pri prechádzaní.
TRAIL	Žiadne opakované okraje, ale uzly sa môžu opakovať. Toto je predvolený režim cesty.
SIMPLE	Žiadne opakované uzly (okrem prvého a posledného sa môže rovnať).
ACYCLIC	Žiadne opakované uzly, ktoré by zabránili akémukoľvek cyklu v ceste.

Používajte TRAIL vzory, aby ste zabránili cyklom počas prechádzania grafom, a zabezpečte, že každý okraj sa navštevuje najviac raz:

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

Použite ACYCLIC vtedy, keď potrebujete zaručiť, že uzol sa nenavštevuje dvakrát:

-- Find paths where no person appears more than once
MATCH ACYCLIC (src:Person)-[:knows]->{1,4}(dst:Person)
WHERE src.firstName = 'Alice'
RETURN dst.firstName, dst.lastName
LIMIT 100

Väzba okraja s premenlivou dĺžkou:

V vzoroch s premenlivou dĺžkou zaznamenávajú okrajové premenné rôzne informácie na základe kontextu:

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

Toto rozlišovanie je rozhodujúce pri správnom používaní okrajových premenných.

Zložité vzory s viacerými vzťahmi:

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

Tento vzorec nájde ľudí spolu s ich pracoviskom aj bydliskom a ukazuje, ako sa jedna osoba pripája k viacerým ďalším entitám.

Oboznámte sa s komplexnou syntaxou vzorov a pokročilými technikami

Základné príkazy

Jazyk GQL poskytuje konkrétne typy vyhlásení, ktoré spolupracujú pri spracovávaní údajov grafu postupne. Pochopenie týchto príkazov je nevyhnutné na vytvorenie efektívnych dotazov.

MATCH prehlásenie

Syntax:

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

Príkaz MATCH berie vstupné údaje a vyhľadá vzory grafu. Spája vstupné premenné so vzorovými premennými a výstupmi všetkých zhodných kombinácií.

Vstupné a výstupné premenné:

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

Filtrovanie na úrovni príkazu pomocou WHERE:

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

Môžete uverejniť filtrovanie všetkých zhôd pomocou funkcie WHERE. Tento prístup sa vyhýba samostatnému FILTER príkazu.

Spojenie pomocou vstupných premenných:

Keď MATCH nie je prvý príkaz, spojí vstupné údaje so vzorovými zhodami:

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

Dôležité

Graf podporuje základné a celé lineárne zloženie príkazov (reťazenie MATCH, LET, FILTER, RETURNa ďalšie základné príkazy). Operácie s nastavením, ako sú UNION DISTINCTnapríklad , EXCEPT, INTERSECTa OTHERWISE , ešte nie sú podporované. Ďalšie informácie nájdete v článku o aktuálnych obmedzeniach.

Správanie kľúčového spojenia:

Ako MATCH narába so spojením údajov:

• Rovnosť premenných: Vstupné premenné sa spájajú so vzorovými premennými pomocou zhody rovnosti
• Vnútorné spojenie: Vstupné riadky bez zhody vzorov sa zahodia. Používa sa OPTIONAL MATCH na správanie vonkajšieho spojenia zľava.
• Filtrovanie poradia: Filtre na úrovni WHERE príkazu po dokončení zhody vzoru
• Pripojiteľnosť vzorov: Viaceré vzory musia zdieľať aspoň jednu premennú na správne spojenie
• Výkon: Zdieľané premenné vytvárajú efektívne obmedzenia spojenia

Dôležité

Obmedzenie: Ak tento MATCH príkaz nie je prvým príkazom, aspoň jedna vstupná premenná sa musí spojiť s premennou vzoru. Viaceré vzory musia mať jednu premennú spoločnú.

Viaceré vzory vyžadujú zdieľané premenné:

-- 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 prehlásenie

Syntax:

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

OPTIONAL MATCH Funguje ako MATCH , ale používa sémantiku left-outer-join. Ak vzor nenájde pre vstupný riadok žiadnu zhodu, dotaz si zachová riadok s hodnotami NULL pre nezhodné premenné, namiesto toho, aby ho zahodil.

Príklad:

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

Ľudia, ktorí nepracujú v žiadnej spoločnosti, sa stále zobrazia vo výsledkoch NULL pre company_name.

Prepitné

Použite OPTIONAL MATCH vtedy, keď chcete zahrnúť entity, ktoré nemusia mať konkrétny vzťah, podobne ako SQL LEFT JOIN.

LET prehlásenie

Syntax:

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

Príkaz LET vytvorí vypočítané premenné a umožní transformáciu údajov v rámci kanála dotazu.

Vytvorenie základnej premennej:

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

Zložité výpočty:

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

Správanie kľúčov:

• Nástroj dotazov vyhodnotí výrazy pre každý vstupný riadok.
• Výsledky sa stávajú novými stĺpcami vo výstupnej tabuľke.
• Premenné môžu odkazovať iba na existujúce premenné z predchádzajúcich príkazov.
• Nástroj dotazov súbežne vyhodnotí viacero priradení v jednom LET príkaze (žiadne krížové odkazy).

FILTER prehlásenie

Syntax:

FILTER [ WHERE ] <predicate>

Príkaz FILTER poskytuje presnú kontrolu nad tým, ktoré údaje prechádzajú vaším kanálom dotazu.

Základné filtrovanie:

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

Zložité logické podmienky:

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

Vzorce filtrovania vedomé nulou:

Na bezpečné spracovanie hodnôt null použite tieto vzory:

• Kontrola hodnôt: p.firstName IS NOT NULL – má krstné meno
• Overenie údajov: p.id > 0 – platné ID
• Spracovanie chýbajúcich údajov: NOT coalesce(p.locationIP, '10.x.x.x') STARTS WITH '10.x.x.x' – nepripojili sa z lokálnej siete
• Kombinovanie podmienok: Použitie AND/OR s explicitnými kontrolami null pre zložitú logiku

Upozornenie

Nezabudnite, že podmienky zahŕňajúce hodnoty null vrátia UNKNOWNhodnotu , ktorá tieto riadky filtruje. Explicitné IS NULL kontroly použite, keď potrebujete logiku typu null inclusive.

ORDER BY prehlásenie

Syntax:

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

Zoradenie na viacúrovňovej úrovni s vypočítanými výrazmi:

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)

Spracovanie null pri zoraďovaní:

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

Podrobnosti o správaní pri zoraďovaní:

Pochopenie fungovania ORDER BY :

• Nástroj dotazov vyhodnotí výrazy pre každý riadok a výsledky potom určia poradie riadkov.
• Viaceré kľúče na zoradenie vytvárajú hierarchické zoradenie (primárne, sekundárne, terciárne atď.).
• NULL je vždy najmenšou hodnotou v porovnaní.
• ASC (vzostupne) je predvolené poradie a musíte ho explicitne zadať DESC (zostupne).
• Môžete zoraďovať podľa vypočítaných hodnôt, nie len podľa uložených vlastností.

Upozornenie

Poradie zoradenia, ktoré vytvára, sa zobrazuje iba ORDER BY nasledujúcemu príkazu. ORDER BY Preto sa po ňom RETURN * nevytkne zoradený výsledok.

Porovnať:

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

s:

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

Tento rozdiel má okamžité dôsledky pre dotazy typu Top-k: LIMIT vždy sa musí riadiť príkazom ORDER BY , ktorým sa určuje zamýšľaný spôsob zoradenia.

OFFSETpríkazy a LIMIT

Syntax:

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

Bežné vzory:

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

Dôležité

Pre predvídateľné výsledky stránkovania vždy používajte ORDER BY predtým OFFSET a LIMIT zabezpečte konzistentné zoradenie riadkov v rámci dotazov.

RETURN: projekcia základného výsledku

Syntax:

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

Príkaz RETURN vyprodukuje konečný výstup dotazu zadaním údajov, ktoré sa zobrazia vo výslednej tabuľke.

Základný výstup:

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

Prehľad pomocou aliasov:

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

Kombinovať so zoradením a 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

Spracovanie duplikátov pomocou funkcie 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

Skombinujte s agregáciou:

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

RETURN s projekciou GROUP BY: zoskupeného výsledku

Syntax:

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

Používa GROUP BY sa na zoskupenie riadkov podľa zdieľaných hodnôt a vypočítajte agregačné funkcie v rámci každej skupiny.

Základné zoskupenie s agregáciou:

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

Zoskupenie viacerých stĺpcov:

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

Poznámka

Rozšírené techniky agregácie vrátane vodorovnej agregácie cez vzory s premenlivou dĺžkou nájdete v časti Pokročilé techniky agregácie.

Typy údajov: práca s hodnotami

Jazyk GQL podporuje bohaté typy údajov na ukladanie a manipuláciu s rôznymi druhmi informácií v grafe.

Základné typy hodnôt

• Čísla: INT64, UINT64( FLOAT64 tiež sa to nazýva DOUBLE) pre výpočty a merania
• Text: STRING pre názvy, popisy a textové údaje
• Logika: BOOL s tromi hodnotami: TRUE, FALSE a UNKNOWN (na spracovanie s hodnotou null)
• Čas: ZONED DATETIME pre časové pečiatky s informáciami o časovom pásme
• Kolekcie: LIST<T> pre viacnásobné hodnoty rovnakého typu T, PATH pre výsledky prechádzania grafom
• Prvky grafu: NODE a EDGE na odkazovanie na údaje grafu

Dôležité

Nemôžete použiť určité typy hodnôt ako typy hodnôt vlastností. Nemôžete napríklad použiť žiadne hodnoty zahŕňajúce referenčné hodnoty prvku grafu ako hodnoty vlastností (ako zoznamy uzlov alebo ciest).

Príklady literálov

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

Kritické vzory spracovania null

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

Logické dôsledky s tromi hodnotami

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

Upozornenie

Logika s tromi hodnotami znamená, že NULL = NULL vráti UNKNOWNhodnotu , nie TRUE. Toto správanie ovplyvňuje filtrovanie a spojenia. Vždy použite IS NULL pre testy s hodnotou null.

Oboznámte sa s komplexnými typmi systémových podrobností

Výrazy: transformácia a analýza údajov

Výrazy umožňujú vypočítavať, porovnávať a transformovať údaje v rámci dotazov. Sú podobné výrazom v jazyku SQL, ale majú ďalšie funkcie na spracovanie údajov grafu.

Typy bežných výrazov

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

Zložité zloženie predikátu

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

Zhoda vzoru reťazca

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

Vstavané funkcie podľa kategórie

GQL poskytuje tieto kategórie funkcií pre rôzne potreby spracovania údajov:

• Agregačné funkcie: count(), sum(), avg(), min(), max() na sumarizáciu údajov

• Podmienené výrazy: CASE/WHEN/THEN/ELSE/END a NULLIF() pre podmienenú logiku. Napríklad:

  MATCH (p:Person)
  RETURN p.firstName,
    CASE WHEN p.birthday < 20000101 THEN 'Before 2000' ELSE '2000 or later' END AS era,
    NULLIF(p.gender, 'unknown') AS gender
  

• Funkcie reťazcov: char_length(), , upper(), lower()trim() na spracovanie textu (US ASCII len na mapovanie prípadov)

• Funkcie grafu: nodes(), , edges()elements(), labels()path_length() na analýzu štruktúr grafu

• Všeobecné funkcie: coalesce()to_json_string() na spracovanie hodnôt null a serializáciu

Poradie operátorov podľa priority pre komplexné výrazy

1. Prístup k vlastnosti (.)
2. Násobenie a delenie (*, /)
3. Sčítanie a odčítanie (+, -)
4. Porovnanie (=, , <><, >, <=, >=)
5. Logická negácia (NOT)
6. Logická konjunkcia (AND)
7. Logická exkluzívna disjunkcia (XOR)
8. Logická disjunkcia (OR)

V predchádzajúcom zozname je operátor s nižším číslom "viaže užšie" ako operátor s vyšším číslom. Napríklad jeNOT n.prop OR m.prop, (NOT n.prop) OR m.prop ale nieNOT (n.prop OR m.prop).

Prepitné

Použite zátvorky na explicitné nastavenie priority. Komplexné výrazy sa jednoduchšie čítajú a ladia, keď je zoskupenie jasné.

Naučte sa obsiahlu syntax výrazov a všetky vstavané funkcie

Pokročilé techniky dotazov

Táto časť zahŕňa sofistikované vzory a techniky na vytváranie zložitých a efektívnych grafových dotazov. Tieto vzory presahujú rámec základného používania vyhlásení, vďaka čomu môžete vytvárať výkonné analytické dotazy.

Zloženie komplexného multištátu

Dôležité

Graf podporuje základné a celé lineárne zloženie. Operácie s nastavením, ako sú UNION DISTINCTnapríklad , EXCEPT, INTERSECTa OTHERWISE , ešte nie sú podporované. Ďalšie informácie nájdete v článku o aktuálnych obmedzeniach.

Pochopenie efektívneho vytvárania komplexných dotazov je rozhodujúce pre pokročilé dotazovanie v grafe.

UNION ALL

Výsledky môžete UNION ALL skombinovať z dvoch alebo viacerých blokov lineárnych dotazov:

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

UNION ALL funkcia ponechá všetky riadky vrátane duplikátov. UNION DISTINCT (ktorý odstraňuje duplikáty) zatiaľ nie je podporovaný.

Postupné poradie vzoru násobku

Reťazenie viacerých príkazov na postupné zostavenie zložitej analýzy:

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

Tento dotaz postupne zvyšuje zložitosť: nájdite firmy, ich zamestnancov, lokality zamestnancov, filtrujte spoločnosti so zamestnancami narodenými pred rokom 1985, vypočítajte priemerný dátum narodenia a zhrňte a zoradte výsledky.

Používanie vodorovnej agregácie

Vodorovná agregácia sa agreguje na vzoroch s premenlivou dĺžkou v rámci jedného riadka:

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

Poznámka

Tento dotaz zatiaľ nie je podporovaný (známy problém).

Rozsah premenných a rozšírený ovládací prvok postupu

Premenné spájajú údaje v rámci príkazov dotazov a umožňujú komplexné prechádzanie grafmi. Pochopenie rozšírených pravidiel rozsahu vám pomáha písať sofistikované dotazy s viacerými príkazmi.

Vzory väzby premennej a rozsahu

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

Opätovné použitie premennej na spojenia v príkazoch

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

Dôležité pravidlá a obmedzenia rozsahu

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

Viditeľnosť premennej v zložitých dotazoch

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

Upozornenie

Premenné v tom istom príkaze sa nemôžu navzájom odkazovať okrem grafových vzorov. Na vytvorenie závislých premenných použite samostatné príkazy.

Pokročilé techniky agregácie

GQL podporuje dva odlišné typy agregácie na analýzu údajov v skupinách a kolekciách: zvislá agregácia so vzormi s premenlivou dĺžkou GROUP BY a vodorovná agregácia.

Zvislá agregácia so zoskupenými podľa

Zvislá agregácia (zahrnutá vRETURNGROUP BYpoložke ) zoskupuje riadky podľa zdieľaných hodnôt a vypočíta agregáty v každej skupine:

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

Tento prístup vytvorí jeden riadok s výsledkom na spoločnosť a agreguje všetkých zamestnancov v rámci každej skupiny.

Vodorovná agregácia s premennými zoznamu skupín

Vodorovná agregácia vypočíta agregácie v kolekciách naviazaných podľa vzorov s premenlivou dĺžkou. Keď používate okraje s premenlivou dĺžkou, premenná okraja sa stane premennou zoznamu skupín , ktorá obsahuje všetky okraje v každej zladenej cesty:

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

Poznámka

Tento dotaz zatiaľ nie je podporovaný (známy problém).

Kľúčové rozdiely medzi zvislou a vodorovnou agregáciou sú:

• Zvislá agregácia sa sumarizuje v riadkoch alebo skupinách riadkov a sumarizuje v riadkoch v každej skupine.
• Vodorovná agregácia sumarizuje prvky v rámci jednotlivých okrajov kolekcií.
• Premenné zoznamu skupín pochádzajú len zo vzorov okrajov s premenlivou dĺžkou.

Kontexty väzby na okraj s premenlivou dĺžkou

Pochopenie toho, ako sú okrajové premenné naviazané na vzory s premenlivou dĺžkou, je rozhodujúce:

Počas zhody vzorov (kontext s jednýmtonom):

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

Vo výsledných výrazoch (kontext skupiny):

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

Poznámka

Tento dotaz zatiaľ nie je podporovaný (známy problém).

Kombinácia zvislej a vodorovnej agregácie

Oba typy agregácie môžete kombinovať v sofistikovaných analytických vzoroch:

Poznámka

Tento dotaz zatiaľ nie je podporovaný (známy problém).

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

Prepitné

Vodorovná agregácia má vždy prednosť pred zvislou agregáciou. Ak chcete skonvertovať zoznam skupín na bežný zoznam, použite funkciu collect_list(edges).

Poznámka

Podrobné informácie o agregačných funkciách nájdete v téme Výrazy a funkcie GQL.

Stratégie spracovania chýb

Pochopenie bežných chybových vzorov pomáha písať robustné dotazy.

Oše ak chcete spracovať chýbajúce údaje:

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 *

Použite explicitné kontroly null:

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 *

Ďalšie informácie

Kódy GQLSTATUS

Ako je vysvetlené v časti o výsledkoch dotazu, jazyk GQL vykazuje bohaté informácie o stave súvisiace s úspešným alebo možným zlyhaním spustenia. Úplný zoznam nájdete v téme Odkaz na kódy stavu jazyka GQL .

Vyhradené slová

GQL si vyhradzuje určité kľúčové slová, ktoré nie je možné použiť ako identifikátory, ako sú premenné, názvy vlastností alebo názvy označení. Úplný zoznam nájdete v odkaze na vyhradené slová v jazyku GQL .

Ak potrebujete použiť vyhradené slová ako identifikátory, uniknite im opačnými apostrofmi: `match`, `return`.

Ak sa chcete vyhnúť použitiu vyhradených slov, použite túto konvenciu pomenovania:

• Pri identifikátoroch s jedným slovom pripojte znak podčiarknutia: :Product_
• Pri identifikátoroch s viacerými slovami použite camelCase alebo PascalCase: :MyEntity, :hasAttribute, textColor

Ďalšie kroky

Teraz, keď poznáte základy jazyka GQL, ponúkame vám odporúčaný študijný program:

Pokračujte v budovaní svojej GQL zručnosti

Pre začiatočníkov:

• Vyskúšajte si stručný úvod – postupujte podľa praktického návodu a kurzu na získanie praktických skúseností
• Precvičte si základné dotazy – vyskúšajte príklady z tejto príručky s vlastnými údajmi.
• Vzory grafu Learn – preskúmanie komplexnej syntaxe vzorov
• Preskúmanie typov údajov – vysvetlenie hodnôt a typov hodnôt jazyka GQL

Pre skúsených používateľov:

• Pokročilé výrazy – naučte sa výrazy a funkcie jazyka GQL
• Návrh schémy – naučte sa typy a obmedzenia grafov GQL
• Preskúmanie typov údajov – vysvetlenie hodnôt a typov hodnôt jazyka GQL

Referenčné materiály

Pri rýchlych vyhľadávaniach majte tieto odkazy užitočné:

• Stručné referenčné informácie k jazyku GQL – stručná referenčná obrazovka s syntaxou
• Kódy stavu jazyka GQL – úplný odkaz na kód chyby
• Vyhradené slová GQL – úplný zoznam vyhradených kľúčových slov

Preskúmať graf

Naučte sa platformu:

• Graf dátových modelov – vysvetlenie konceptov grafu a modelovania
• Graph a relačné databázy – vyberte si správny prístup
• Skúsiť Microsoft Fabric zdarma - Získajte praktické skúsenosti
• Komplexné kurzy – kompletné scenáre učenia

Zapojte sa

• Zdieľanie pripomienok – Pomocník pri zlepšovaní dokumentácie a nástrojov
• Pripojte sa ku komunite – pripojte sa k iným odborníkom na databázy grafov
• Neustály prehľad – Sledujte oznámenia o nových funkciách v grafoch

Prepitné

Ak sa chcete naučiť jazyk dotazov ako prvý, začnite s kurzom rýchleho štartu, ak sa chcete radšej učiť prostredníctvom grafových vzorov .

Súvisiaci obsah

Podrobní sprievodcovia:

• Písanie bežných dotazov GQL – praktické vzory dotazov pre susedov, multi-hop, zdieľané pripojenia a ďalšie.
• Filtrovanie a agregované údaje grafu – funkcie FILTER, WHERE, GROUP BY a agregačné funkcie.
• Zapisovanie dotazov vzoru grafu – viac-hopové prechádzanie, režimy cesty, opätovné použitie premenných a voliteľná zhoda.
• Optimalizujte výkon dotazov GQL – osvedčené postupy pri písaní efektívnych dotazov GQL.

Ďalšie podrobnosti o kľúčových témach:

• Príklad schémy sociálnej siete – úplný pracovný príklad schémy grafu.
• Vzory grafu GQL – komplexná syntax vzorov a pokročilé techniky zhôd.
• Výrazy a funkcie GQL – všetky typy výrazov a vstavané funkcie.
• Typy grafov GQL – typy a obmedzenia grafov.
• Hodnoty a typy hodnôt GQL – úplné ovládanie systémových odkazov a spracovania hodnôt.

Rýchle odkazy:

• Skrátený odkaz k GQL – stručná referenčná hodnota syntaxe.
• Kódy stavu jazyka GQL – úplné odkazy na kód chyby.
• Vyhradené slová v jazyku GQL – úplný zoznam vyhradených kľúčových slov.

Graf:

• graph data models (grafové dátové modely ) – vysvetlenie konceptov grafu a modelovania.
• graph a relačné databázy – rozdiely a prípady ich používania.
• Try Microsoft Fabric zdarma.
• Koncové kurzy v Microsoft Fabric.