Průvodce jazykem GQL pro graf v Microsoft Fabric

GQL (Graph Query Language) je standardizovaný dotazovací jazyk ISO pro grafové databáze. Pomocí GQL můžete efektivně dotazovat, analyzovat a pracovat s grafovými daty pomocí grafu v Microsoft Fabric.

Stejná pracovní skupina ISO, která standardizuje SQL, vyvíjí GQL. V důsledku toho GQL sdílí mnoho konceptů s SQL, včetně výrazů, predikátů a datových typů. Pokud máte zkušenosti s SQL, můžete většinu těchto znalostí použít na GQL.

Tento článek obsahuje komplexní referenční informace pro GQL v grafu. Zahrnuje:

Základní koncepty: Datové struktury grafů, vzory a základy dotazů
Základní prohlášení: MATCH, FILTER, LET, ORDER BY, LIMIT, a RETURN
Datové typy a výrazy: Typy hodnot, operátory a předdefinované funkce
Pokročilé techniky: Složení s více příkazy, proměnné a strategie agregace

Poznámka:

Oficiální mezinárodní standard pro GQL je ISO/IEC 39075 Information Technology - Database Languages - GQL.

Pokud místo úplného odkazu na jazyk hledáte pokyny orientované na úkoly, projděte si příručky s postupy:

Psaní běžných dotazů GQL – sousedů , procházení více segmentů směrování, sdílených připojení a kontrol existence entit
Filtrování a agregace dat grafu – FUNKCE FILTER, WHERE, GROUP BY a agregační funkce
Psaní dotazů na vzor grafu – vzory s více segmenty směrování, režimy cesty, opakované použití proměnných a volitelná shoda
Optimalizace výkonu dotazů GQL – strategie filtrování, omezení procházení a doporučení klíčových omezení

Požadavky

Než začnete, ujistěte se, že znáte tyto koncepty:

Basic understanding of databases – Zkušenosti s jakýmkoli databázovým systémem, jako je relační (SQL), NoSQL nebo graf, je užitečné.
Koncepty grafů – Principy uzlů, hran a relací v propojených datech
Základy dotazů – znalost základních konceptů dotazů, jako je filtrování, řazení a agregace

Doporučené pozadí:

Zkušenosti s jazyky SQL nebo openCypher usnadňují výuku syntaxe GQL (jsou to kořeny GQL).
Znalost modelování dat pomáhá s návrhem schématu grafu.
Pochopení konkrétního případu použití pro grafová data

Co potřebujete:

Přístup k pracovnímu prostoru grafu s možnostmi dotazů
Ukázková data nebo ochota pracovat s příklady sociálních sítí
Základní textový editor pro psaní dotazů

Návod

Pokud s grafovými databázemi teprve začínáte, začněte přehledem datových modelů grafu a teprve potom pokračujte v této příručce.

Co dělá GQL speciální

GQL je navržený speciálně pro grafová data. Díky tomuto návrhu je přirozené a intuitivní pracovat s propojenými informacemi.

Na rozdíl od SQL, který spoléhá na spojení tabulek k expresním relacím, používá GQL vzory vizuálního grafu. Tyto vzory přímo zrcadlí způsob propojení entit, což usnadňuje čtení dotazů a usnadňuje jejich odůvodnění.

Předpokládejme, že chcete najít lidi a jejich přátele (lidi, kteří se navzájem znají), kteří se narodili před 1999. Tady je postup, jak GQL vyjadřuje danou podmínku pomocí vzoru vizuálního 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 najde přátele (lidi, kteří se navzájem znají), kteří se narodili před 1999. (person:Person)-[:knows]-(friend:Person) Vzor vizuálně znázorňuje strukturu vztahů, kterou hledáte – podobně jako nakreslení diagramu dat.

Základy GQL

Než se ponoříte do dotazů, seznamte se s těmito základními koncepty, které tvoří základ GQL:

Grafy ukládají data jako uzly (entity) a hrany (relace), z nichž každá má popisky a vlastnosti.
Typy grafů fungují jako schémata a definují, jaké uzly a hrany mohou v grafu existovat.
Omezení jsou další pravidla a omezení, která typy grafů ukládají na grafy k vynucení integrity dat.
Dotazy používají příkazy jako MATCH, FILTERa RETURN zpracování dat a zobrazení výsledků.
Vzory popisují struktury grafu, které chcete najít pomocí intuitivní vizuální syntaxe.
Výrazy provádějí výpočty a porovnání vašich dat, podobně jako výrazy SQL.
Predikáty jsou logické výrazy hodnot, které filtrují výsledky v rámci dotazů.
Typy hodnot definují, jaké druhy hodnot můžete zpracovávat a ukládat.

Principy dat grafu

Abyste mohli efektivně pracovat s GQL, musíte pochopit, jak jsou grafová data strukturovaná. Tento základ vám pomůže efektivně psát lepší dotazy a modelovat data.

Uzly a hrany: stavební bloky

V GQL pracujete s grafy vlastností s popisky. Graf se skládá ze dvou typů prvků:

Uzly obvykle představují entity (podstatná jména) ve vašem systému – například lidé, organizace, příspěvky nebo produkty. Jsou to nezávislé objekty, které existují ve vaší doméně. Někdy také voláte vrcholy uzlů.
Hrany představují vztahy mezi entitami (slovesa) – jak se entity propojují a interagují.

Například lidé se navzájem znají (:knows), organizace, které působí v konkrétních regionech (:operates), nebo zákazníci, kteří nakupovali produkty (:purchased).
Někdy také voláte relace hran.

Každý prvek grafu má tyto vlastnosti:

Interní ID, které ho jednoznačně identifikuje
Jeden nebo více popisků – popisné názvy jako Person nebo knows. V grafu mají hrany vždy přesně jeden popisek.
Vlastnosti – páry name-value, které ukládají data o prvku (například firstName: "Alice" ).birthday: "19730108"

Jak jsou grafy strukturované

Každá hrana spojuje přesně dva uzly: počátek a cíl. Toto připojení vytvoří strukturu grafu a ukazuje, jak spolu entity vzájemně souvisejí. Na směru okrajů záleží – Person kdo follows jiný Person vytvoří nasměrovaný vztah.

Poznámka:

graf v současné době nepodporuje neusměrované hrany.

Grafy vlastností podporované v grafu jsou vždy dobře vytvořené, což znamená, že každá hrana spojuje dva platné uzly. Pokud se v grafu zobrazí okraj, oba jeho koncové body existují ve stejném grafu.

Grafové modely a typy grafů

Grafový model popisuje strukturu grafu. Funguje jako schéma databáze pro vaši doménu aplikace. Modely grafů definují:

Které uzly a hrany mohou existovat
Jaké popisky a vlastnosti můžou mít
Jak se uzly a hrany připojují

Grafové modely také zajišťují integritu dat prostřednictvím omezení, zejména omezení klíče uzlu , která určují, které vlastnosti jednoznačně identifikují jednotlivé uzly.

Poznámka:

Grafové modely můžete zadat pomocí standardní syntaxe GQL. V tomto případě se nazývají typy grafů.

V této dokumentaci ukazuje příklad sociálních sítí koncepty GQL. Porozumění této doméně vám pomůže postupovat podle příkladů a použít podobné vzory pro vaše vlastní data.

Poznámka:

Příklad sociální sítě je odvozen z srovnávacího testu LDBC SNB (LDBC Social Network Benchmark)publikovaného GDC (Graph Data Council). Další informace najdete v tématu "The LDBC Social Network Benchmark".

Naše sociální síť zahrnuje tyto hlavní druhy uzlů, které představují entity domény:

Lidé mají osobní údaje, jako jsou jména, narozeniny a pohlaví. Žijí ve městech a tvoří sociální spojení.

Místa tvoří geografickou hierarchii:

Města jako "New York" nebo "Londýn"
Countries/regions like "USA" nebo "Velká Británie"
Kontinenty jako "Severní Amerika" nebo "Evropa"

Organizace, kde lidé tráví čas:

Univerzity , kde lidé studují
Společnosti , ve kterých lidé pracují

Obsah a diskuze:

Fóra s názvy, které obsahují příspěvky
Příspěvky s obsahem, jazykem a volitelnými obrázky
Komentáře , které odpovídají na příspěvky nebo jiné komentáře
Značky , které kategorizují obsah a představují zájmy

Jak se všechno spojuje

Díky propojení mezi entitami je síť zajímavá:

Lidé se navzájem znají (přátelství, :knows).
Lidé pracují ve společnostech (:workAt) nebo studují na univerzitách (:studyAt).
Lidé vytvářejí příspěvky a komentáře (:hasCreator).
Lidé, jako jsou příspěvky a komentáře (:likes).
Příspěvky, fóra a komentáře můžou obsahovat značky (:hasTag).
Lidé mají zájem o konkrétní značky (:hasInterest).
Fóra obsahují příspěvky (:containerOf) a mají členy (:hasMember) a moderátory (:hasModerator).

Hrany grafu představují vztahy mezi doménami. Tato bohatá síť vytváří mnoho příležitostí pro zajímavé dotazy a analýzu.

Zobrazit úplnou specifikaci schématu

Vaše první dotazy GQL

Teď, když rozumíte základům grafů, se podíváme, jak dotazovat data grafu pomocí GQL. Tyto příklady vycházejí z jednoduchých až složitých a ukazují, jak přístup GQL dělá grafové dotazy intuitivní a výkonné.

Začít jednoduše: najít všechny lidi

Začněte s nejzásadnějším možným dotazem. Najděte jména (křestní jméno, příjmení) všech lidí:Person v grafu.

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

Tento dotaz se spustí takto:

MATCH najde všechny uzly označené Person.
RETURN zobrazuje jejich křestní jméno a příjmení.

Přidání filtrování: Vyhledání konkrétních lidí

Teď najděte lidi s konkrétními charakteristikami. V tomto případě najděte všechny, kteří se jmenují Alice, a zobrazte jejich jména a narozeniny.

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

Tento dotaz se spustí takto:

MATCH najde všechny uzly (p) označenou jako Osoba.
FILTER uzly (p), jejichž křestní jméno je Alice.
RETURN zobrazuje jejich křestní jméno, příjmení a narozeniny.

Základní struktura dotazu

Základní dotazy GQL se řídí konzistentním vzorem: posloupnost příkazů, které spolupracují na hledání, filtrování a vracení dat. Většina dotazů začíná hledáním MATCH vzorů v grafu a končí tím, RETURN že specifikuje výstup.

Tady je jednoduchý dotaz, který najde dvojice lidí, kteří se znají a mají stejné narozeniny, a pak vrátí celkový počet těchto párů přátel.

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

Tento dotaz se spustí takto:

MATCH najde všechny dvojice Person uzlů, které navzájem znají.
FILTER udržuje jenom páry, ve kterých mají oba lidé stejné narozeniny.
RETURN počítá, kolik takových přátelských párů existuje.

Návod

Filtrování můžete také provést přímo v rámci vzoru přidáním WHERE klauzule. Například odpovídá MATCH (n:Person WHERE n.age > 23) uzlům, Person jejichž age vlastnost je větší než 23.

GQL podporuje komentáře čar ve stylu // jazyka C, komentáře řádků ve stylu -- SQL a blokové komentáře ve stylu /* */ jazyka C.

Běžná tvrzení

MATCH: Identifikuje vzor grafu, který je třeba hledat – zde definujete strukturu dat, která vás zajímají.
LET: Přiřazuje nové proměnné nebo vypočítané hodnoty na základě shodných dat – přidává odvozené sloupce k výsledku.
FILTER: Zužuje výsledky aplikací podmínek—odstraní řádky, které kritéria nesplňují –
ORDER BY: Třídí filtrovaná data – pomáhá organizovat výstup podle jednoho nebo více polí.
OFFSET a LIMIT: Omezit počet vrácených řádků – užitečné pro stránkování nebo top-k dotazy.
RETURN: Specifikuje konečný výstup—určuje, jaká data by měla být zahrnuta do výsledné množiny a provádí agregaci.

Jak fungují příkazy společně

GQL příkazy tvoří pipeline, kde každý příkaz zpracovává výstup předchozího. Toto sekvenční provedení usnadňuje čtení a ladění dotazů, protože pořadí provádění odpovídá pořadí čtení.

Klíčové body:

Příkazy se efektivně vykonávají sekvenčně.
Každý příkaz převede data a předává je dalšímu.
Tento proces vytvoří jasný předvídatelný tok dat, který zjednodušuje složité dotazy.

Důležité

Aby se maximalizoval výkon, může graf měnit pořadí provádění příkazů a spouštět jednotlivé příkazy paralelně. Tyto optimalizace nemají vliv na správnost výsledků.

Příklad složení příkazů

Následující dotaz GQL najde prvních 10 lidí pracujících ve firmách s "Air" ve jménu, seřadí je podle plného jména a vrací jejich plné jméno spolu s názvem jejich společ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 se spustí takto:

MATCH Najdi lidi, kteří pracují ve firmách.
LET vytváří úplná jména kombinací křestní jména a příjmení.
FILTER ponechává pouze zaměstnance firem, které mají v názvu "Air".
ORDER BY seřadí podle úplného jména.
LIMIT vezme prvních 10 výsledků.
RETURN Vrací celé názvy a názvy společností.

Proměnné propojují vaše data

Proměnné, například p, ca fullName v předchozích příkladech, přenášejí data mezi příkazy. Když znovu použijete název proměnné, GQL automaticky zajistí, že odkazuje na stejná data a vytváří výkonné podmínky spojení. Proměnné se někdy také označují jako vazbové proměnné.

Proměnné můžete kategorizovat různými způsoby:

Podle zdroje vazby:

Proměnné vzoru – svázané odpovídajícími vzory grafu
Běžné proměnné – vázané na konstrukty jiného jazyka

Typy proměnných vzorů:

Proměnné elementů – vazba k referenčním hodnotám elementu grafu
- Proměnné uzlů – vazba na jednotlivé uzly
- Hraniční proměnné – vazba na jednotlivé hrany
Proměnné cesty – vazba k hodnotám cest představujícím odpovídající cesty

Podle referenčního stupně:

Singletonové proměnné – navazujte na jednotlivé referenční hodnoty prvků ze vzorů
Proměnné skupiny – vazba na seznamy referenčních hodnot prvků ze vzorů s proměnlivou délkou (viz Pokročilé techniky agregace)

Výsledky a výsledky provádění

Když spustíte dotaz, získáte zpět výsledek spuštění , který se skládá z:

(volitelná) výsledná tabulka s daty z příkazu RETURN .
Informace o stavu , které ukazují, jestli byl dotaz úspěšný nebo ne.

Tabulky výsledků

Výsledná tabulka ( pokud je k dispozici) je skutečný výsledek provádění dotazu.

Výsledná tabulka obsahuje informace o názvu a typu sloupců, upřednostňovanou sekvenci názvů sloupců, která se má použít pro zobrazení výsledků, zda je tabulka seřazená, a samotné řádky.

Poznámka:

Pokud se provádění nezdaří, do výsledku provádění není zahrnuta žádná tabulka výsledků.

Informace o stavu

Během provádění dotazu proces detekuje různé důležité podmínky, jako jsou chyby nebo upozornění. Každá podmínka je zaznamenána stavovým objektem v informacích o stavu výsledku spuštění.

Informace o stavu se skládají z primárního objektu stavu a (pravděpodobně prázdného) seznamu jiných stavových objektů. Primární stavový objekt vždy existuje a označuje, jestli bylo spuštění dotazu úspěšné nebo neúspěšné.

Každý stavový objekt obsahuje pěticiferný stavový kód (označovaný jako GQLSTATUS), který identifikuje zaznamenanou podmínku a zprávu, která ji popisuje.

Stavové kódy úspěchu:

GQLSTATUS	Message	Když
00000	poznámka: úspěšné dokončení	Úspěch s alespoň jedním řádkem
00001	poznámka: úspěšné dokončení – vynechaný výsledek	Úspěch bez tabulky (aktuálně nepoužívané)
02000	poznámka: žádná data	Úspěch s nulovými řádky

Jiné stavové kódy označují další chyby nebo upozornění, které proces provádění dotazu detekuje.

Důležité

V kódu aplikace vždy spoléhají na stavové kódy k testování určitých podmínek. Stavové kódy jsou zaručeny stabilní a jejich obecný význam se v budoucnu nezmění. Netestujte obsah zpráv, protože konkrétní zpráva hlášená pro stavový kód se může v budoucnu změnit v závislosti na dotazu nebo dokonce mezi spuštěními stejného dotazu.

Kromě toho můžou objekty stavu obsahovat základní objekt stavu příčiny a diagnostický záznam s dalšími informacemi, které charakterizují zaznamenanou podmínku.

Zobrazit kompletní referenční informace ke kódům GQLSTATUS

Základní koncepty a příkazy

Tato část popisuje základní stavební bloky, které potřebujete k psaní efektivních dotazů GQL. Každý koncept vychází z praktických dovedností při psaní dotazů.

Grafové vzory: vyhledání struktury

Grafové vzory jsou jádrem dotazů GQL. Umožňují popsat datovou strukturu, kterou hledáte, pomocí intuitivní vizuální syntaxe, která vypadá jako relace, které chcete najít.

Jednoduché vzory:

Začněte se základními vzory relací:

-- 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 s konkrétními daty:

-- 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 popisků pro flexibilní výběr entity:

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

Poznámka:

Uzly můžou mít více popisků, ale hraniční typy s více popisky se zatím nepodporují.

Výrazy popisků umožňují spárovat různé druhy uzlů v jednom vzoru, aby byly dotazy flexibilnější.

Opakované použití proměnné vytváří výkonné spojení:

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

Opakované použití proměnné c zajišťuje, že oba lidé pracují ve stejné společnosti a vytvářejí omezení automatického spojení. Tento model je klíčovým vzorem pro vyjádření vztahů se stejnou entitou.

Důležité

Kritický přehled: Opakované použití proměnných ve vzorech vytváří strukturální omezení. Pomocí této techniky můžete vyjádřit složité vztahy grafů, jako jsou "přátelé, kteří pracují ve stejné společnosti" nebo "lidé ve stejném městě".

Filtrování na úrovni vzorku pomocí where:

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

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

Ohraničené vzory s proměnlivou délkou:

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

Režimy cesty pro řízení procházení:

Režimy cesty určují, jak dotazovací modul zpracovává opakující se prvky během procházení s proměnnou délkou:

Režim cesty	Description
`WALK`	Umožňuje opakované uzly a hrany. Žádná omezení procházení.
`TRAIL`	Neopakují se hrany, ale uzly se můžou opakovat. Toto je výchozí režim cesty.
`SIMPLE`	Žádné opakující se uzly (s výjimkou prvního a posledního můžou být stejné).
`ACYCLIC`	Žádné opakované uzly, které brání jakémukoli cyklu v cestě.

Pomocí TRAIL vzorů zabráníte cyklům během procházení grafu a zajistíte, aby se každý okraj navštěvoval maximálně jednou:

-- 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žijte ACYCLIC , když potřebujete zaručit, že není dvakrát navštíven žádný uzel:

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

Hraniční vazba s proměnnou délkou:

V vzorech s proměnlivou délkou zachytává hraniční proměnné různé informace v závislosti na 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

Tento rozdíl je zásadní pro správné použití hraničních proměnných.

Složité vzory s více relacemi:

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 vzor najde lidi společně s jejich pracovištěm i bydlištěm a ukazuje, jak se jedna osoba připojuje k více dalším entitám.

Seznámení s komplexní syntaxí vzorů a pokročilými technikami

Základní příkazy

GQL poskytuje konkrétní typy příkazů, které spolupracují na zpracování dat grafu krok za krokem. Pochopení těchto příkazů je nezbytné pro vytváření efektivních dotazů.

Prohlášení `MATCH`

Syntaxe:

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

Příkaz MATCH přebírá vstupní data a vyhledá vzory grafu. Spojí vstupní proměnné se vzorovými proměnnými a výstupy všech shodných kombinací.

Vstupní a výstupní proměnné:

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

Filtrování na úrovni příkazů pomocí where:

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

Všechny shody můžete filtrovat pomocí funkce WHERE. Tento přístup se vyhne samostatnému FILTER příkazu.

Spojení pomocí vstupních proměnných:

Pokud MATCH není prvním příkazem, spojí vstupní data s odpovídajícími vzory:

...
-- 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 úplné složení lineárních příkazů (řetězení MATCH, LET, FILTER, RETURN, a další základní příkazy). Nastavit operace jako UNION DISTINCT, , EXCEPTINTERSECTa OTHERWISE zatím nejsou podporované. Další informace najdete v článku o aktuálních omezeních.

Chování při připojování klíčů:

Jak MATCH zpracovává spojování dat:

Rovnost proměnných: Vstupní proměnné se spojují s proměnnými vzorů pomocí porovnávání rovnosti.
Vnitřní spojení: Vstupní řádky bez shody vzorů se zahodí. Slouží OPTIONAL MATCH k chování levého vnějšího spojení.
Pořadí filtrování: Filtry na úrovni WHERE příkazů po dokončení porovnávání vzorů
Připojení vzoru: Více vzorů musí pro správné spojení sdílet aspoň jednu proměnnou.
Výkon: Sdílené proměnné vytvářejí efektivní omezení spojení

Důležité

Omezení: Pokud tento MATCH příkaz není prvním příkazem, musí se alespoň jedna vstupní proměnná spojit s proměnnou vzoru. Více vzorů musí mít jednu společnou proměnnou.

Více vzorů vyžaduje sdílené proměnné:

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

Prohlášení `OPTIONAL MATCH`

Syntaxe:

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

OPTIONAL MATCH funguje jako MATCH , ale používá sémantiku levého vnějšího spojení. Pokud vzor nenajde shodu pro vstupní řádek, dotaz zachová řádek s NULL hodnotami pro chybějící proměnné místo jeho zahození.

Example:

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

Lidé, kteří nepracují v žádné společnosti, se stále zobrazují ve výsledcích NULL pro company_name.

Návod

Použijte OPTIONAL MATCH , pokud chcete zahrnout entity, které nemusí mít určitou relaci, podobně jako SQL LEFT JOIN.

Prohlášení `LET`

Syntaxe:

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

Příkaz LET vytvoří počítané proměnné a umožní transformaci dat v rámci kanálu dotazu.

Vytvoření základní proměnné:

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

Složité výpočty:

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

Klíčové chování:

Dotazovací modul vyhodnocuje výrazy pro každý vstupní řádek.
Výsledky se stanou novými sloupci ve výstupní tabulce.
Proměnné můžou odkazovat pouze na existující proměnné z předchozích příkazů.
Dotazovací modul vyhodnocuje více přiřazení v jednom LET příkazu paralelně (bez křížových odkazů).

Prohlášení `FILTER`

Syntaxe:

FILTER [ WHERE ] <predicate>

Příkaz FILTER poskytuje přesnou kontrolu nad tím, která data procházejí kanálem dotazu.

Základní filtrování:

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

Složité logické podmínky:

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

Vzory filtrování s podporou null:

K bezpečnému zpracování hodnot null použijte tyto vzory:

Kontrola hodnot: – má křestní jméno. p.firstName IS NOT NULL
Ověření dat: p.id > 0 – platné ID
Zpracování chybějících dat: NOT coalesce(p.locationIP, '10.x.x.x') STARTS WITH '10.x.x.x' – nepřipojilo se z místní sítě
Kombinování podmínek: Použití AND/OR s explicitními kontrolami null pro komplexní logiku

Upozornění

Nezapomeňte, že podmínky zahrnující vrácení UNKNOWNhodnot null, které filtrují tyto řádky. Explicitní IS NULL kontroly použijte v případě, že potřebujete logiku inkluzivní hodnoty null.

Prohlášení `ORDER BY`

Syntaxe:

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

Řazení na více úrovních pomocí počítaných výrazů:

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)

Zpracování null při řazení:

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

Podrobnosti o chování řazení:

ORDER BY Principy fungování:

Dotazovací modul vyhodnocuje výrazy pro každý řádek a výsledky určují pořadí řádků.
Více klíčů řazení vytváří hierarchické řazení (primární, sekundární, terciární atd.).
NULL je vždy nejmenší hodnotou v porovnání.
ASC (vzestupně) je výchozí pořadí a musíte explicitně zadat DESC (sestupně).
Můžete řadit podle počítaných hodnot, nejen uložených vlastností.

Upozornění

Pouze následující příkaz může zobrazit pořadí řazení, které ORDER BY se vytvoří. ORDER BY RETURN * Následně proto nevytvářejí seřazený výsledek.

Porovnat:

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

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 rozdíl má okamžité důsledky pro dotazy Top-k: LIMIT vždy musí následovat příkaz ORDER BY , který určuje zamýšlené pořadí řazení.

`OFFSET` a `LIMIT` příkazy

Syntaxe:

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

Obvyklé scénáře:

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

Důležité

Pro předvídatelné výsledky stránkování vždy používejte ORDER BY před OFFSET a LIMIT zajistěte konzistentní řazení řádků napříč dotazy.

`RETURN`: projekce základního výsledku

Syntaxe:

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

Příkaz RETURN vytvoří konečný výstup dotazu zadáním toho, která data se zobrazí ve výsledné tabulce.

Základní výstup:

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

Použití aliasů pro přehlednost:

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

Kombinování s řazením a horním 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

Duplicitní zpracování pomocí 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

Kombinovat s agregací:

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

`RETURN` with `GROUP BY`: seskupený výsledek projekce

Syntaxe:

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

Slouží GROUP BY k seskupení řádků podle sdílených hodnot a agregačních funkcí výpočetních funkcí v rámci každé skupiny.

Základní seskupení s agregací:

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

Seskupení s více sloupci:

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:

Pokročilé techniky agregace, včetně vodorovné agregace nad vzory proměnlivé délky, najdete v tématu Pokročilé techniky agregace.

Datové typy: práce s hodnotami

GQL podporuje bohaté datové typy pro ukládání a manipulaci s různými druhy informací v grafu.

Základní typy hodnot

Čísla: INT64, , UINT64FLOAT64(označované DOUBLEtaké ) pro výpočty a měření
Text: STRING pro názvy, popisy a textová data
Logika: BOOL se třemi hodnotami: PRAVDA, NEPRAVDA a UNKNOWN (pro zpracování null)
Čas: ZONED DATETIME pro časová razítka s informacemi o časovém pásmu
Kolekce: LIST<T> pro více hodnot stejného typu T, PATH pro výsledky procházení grafů
Prvky grafu: NODE a EDGE pro odkazování na data grafu

Důležité

Jako typy hodnot vlastností nelze použít určité typy hodnot. Konkrétně nemůžete použít žádné hodnoty zahrnující referenční hodnoty prvků grafu jako hodnoty vlastností (například seznamy uzlů nebo cest).

Příklady literálů

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 zpracování hodnot 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

Důsledky logiky se třemi 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

Upozornění

Logika se třemi hodnotami znamená NULL = NULL , že se vrátí UNKNOWN, ne TRUE. Toto chování má vliv na filtrování a spojení. Vždy používejte IS NULL pro testy s hodnotou null.

Seznámení s podrobnými informacemi o systému typů

Výrazy: transformace a analýza dat

Výrazy umožňují vypočítat, porovnat a transformovat data v rámci dotazů. Jsou podobné výrazům v SQL, ale mají další funkce pro zpracování dat grafu.

Běžné typy výrazů

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

Komplexní predikátové složení

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

Porovnávání vzorů řetězců

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

Předdefinované funkce podle kategorie

GQL poskytuje tyto kategorie funkcí pro různé potřeby zpracování dat:

Agregační funkce: count(), sum(), avg(), min(), pro max() sumarizaci dat

Podmíněné výrazy: CASE/WHEN/THEN/ELSE/END a NULLIF() pro podmíněnou logiku. Napří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

Řetězcové funkce: char_length(), upper(), lower()trim()pro zpracování textu (pouze pro mapování případů v US ASCII)
Grafové funkce: nodes(), edges(), elements(), labels(), pro path_length() analýzu grafových struktur
Obecné funkce: coalesce(), to_json_string() pro zpracování hodnot null a serializace

Priorita operátorů pro komplexní výrazy

Přístup k vlastnostem (.)
Násobení a dělení (*, /)
Sčítání a odčítání (+, -)
Porovnání (=, , <><, >, <=) >=
Logická negace (NOT)
Logická spojení (AND)
Logický exkluzivní disjunkce (XOR)
Logická disjunkce (OR)

V předchozím seznamu operátor s nižším číslem "váže užší" než operátor s vyšším číslem. Například neníNOT n.prop OR m.prop, (NOT n.prop) OR m.prop ale neníNOT (n.prop OR m.prop).

Návod

Pomocí závorek můžete explicitně nastavit prioritu. Komplexní výrazy se snadněji čtou a ladí, když je seskupování jasné.

Seznámení se syntaxí komplexních výrazů a všemi integrovanými funkcemi

Pokročilé techniky dotazování

Tato část popisuje sofistikované vzory a techniky pro vytváření složitých a efektivních grafových dotazů. Tyto vzory jsou nad rámec základního použití příkazů, které vám pomůžou vytvářet výkonné analytické dotazy.

Komplexní vícesměrné složení

Důležité

Graph podporuje základní a úplné složení lineárních příkazů. Nastavit operace jako UNION DISTINCT, , EXCEPTINTERSECTa OTHERWISE zatím nejsou podporované. Další informace najdete v článku o aktuálních omezeních.

Pochopení efektivního vytváření složitých dotazů je zásadní pro pokročilé dotazování grafů.

`UNION ALL`

Slouží UNION ALL ke kombinování výsledků ze dvou nebo více bloků lineárních dotazů:

-- 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 uchovává všechny řádky, včetně duplicit. UNION DISTINCT (který odebere duplicity) se zatím nepodporuje.

Průběh vzorů s více kroky

Zřetězte více příkazů a postupně sestavte komplexní analýzu:

-- 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 postupně zvyšuje složitost: najděte firmy, jejich zaměstnance, umístění zaměstnanců, filtrujte společnosti s zaměstnanci narozenými před rokem 1985, vypočítejte průměrné datum narození a shrňte a seřaděte výsledky.

Použití vodorovné agregace

Vodorovná agregace agreguje vzory s proměnlivou délkou v jednom řádku:

-- 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 se zatím nepodporuje (známý problém).

Rozsah proměnných a pokročilé řízení toku

Proměnné propojují data mezi příkazy dotazů a umožňují komplexní procházení grafů. Porozumění pokročilým pravidlům oboru vám pomůže psát sofistikované dotazy s více příkazy.

Vzory vazeb a oborů proměnných

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

Opakované použití proměnné pro spojení mezi příkazy

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

Kritická pravidla a omezení

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

Viditelnost proměnných ve složitých dotazech

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

Upozornění

Proměnné ve stejném příkazu nemohou vzájemně odkazovat, s výjimkou grafových vzorů. Pro vytvoření závislé proměnné použijte samostatné příkazy.

Pokročilé techniky agregace

GQL podporuje dva různé typy agregace pro analýzu dat napříč skupinami a kolekcemi: vertikální agregace se GROUP BY vzory proměnlivé délky a vodorovná agregace.

Svislá agregace pomocí GROUP BY

Svislá agregace (pokrytá RETURNGROUP BY) seskupuje řádky podle sdílených hodnot a vypočítá agregace v rámci každé skupiny:

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 přístup vytvoří jeden řádek výsledků pro každou společnost a agreguje všechny zaměstnance v rámci každé skupiny.

Vodorovná agregace s proměnnými seznamu skupin

Vodorovná agregace počítá agregace nad kolekcemi vázanými vzory s proměnlivou délkou. Při použití hrany s proměnnou délky se proměnná hrany stane proměnnou seznamu skupin , která obsahuje všechny hrany v každé odpovídající cestě:

-- 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 se zatím nepodporuje (známý problém).

Mezi vertikální a vodorovnou agregací jsou klíčové rozdíly:

Svislá agregace shrnuje řádky nebo seskupuje řádky a shrnuje řádky v každé skupině.
Vodorovná agregace shrnuje prvky v jednotlivých kolekcích okrajů.
Proměnné seznamu skupin pocházejí pouze ze vzorů okrajů s proměnlivou délkou.

Kontexty hraniční vazby s proměnnou délkou

Pochopení toho, jak se hraniční proměnné sváže ve vzorech s proměnlivou délkou, jsou zásadní:

Během porovnávání vzorů (kontext singleton):

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

Ve výsledných výrazech (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 se zatím nepodporuje (známý problém).

Kombinování svislé a vodorovné agregace

Oba typy agregace můžete kombinovat v sofistikovaných vzorech analýzy:

Poznámka:

Tento dotaz se zatím nepodporuje (známý 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

Návod

Vodorovná agregace má vždy přednost před vertikální agregací. Chcete-li převést seznam skupin na běžný seznam, použijte collect_list(edges).

Poznámka:

Podrobné referenční informace o agregačních funkcích najdete v tématu Výrazy a funkce jazyka GQL.

Strategie zpracování chyb

Vysvětlení běžných vzorů chyb vám pomůže psát robustní dotazy.

Zpracování chybějících dat elegantně:

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

Další informace

Kódy GQLSTATUS

Jak je vysvětleno v části o výsledcích dotazu, GQL hlásí bohaté informace o stavu související s úspěchem nebo potenciálním selháním spuštění. Úplný seznam najdete v referenčních informacích ke stavových kódům GQL .

Vyhrazená slova

GQL si vyhrazuje určitá klíčová slova, která nemůžete použít jako identifikátory, jako jsou proměnné, názvy vlastností nebo názvy popisků. Úplný seznam najdete v referenčních informacích k rezervovaným slovem GQL .

Pokud potřebujete jako identifikátory použít vyhrazená slova, ucházejte je pomocí zpětných razítek: `match`, `return`.

Pokud se chcete vyhnout úniku vyhrazených slov, použijte tuto konvenci pojmenování:

U jednoslovných identifikátorů připojte podtržítko: :Product_
Pro víceslovné identifikátory použijte camelCase nebo PascalCase: :MyEntity, , :hasAttributetextColor

Další kroky

Teď, když rozumíte základům GQL, najdete doporučený studijní program:

Pokračovat v vytváření dovedností GQL

Pro začátečníky:

Vyzkoušejte rychlý start – Praktické zkušenosti získáte pomocí praktického rychlého startu a kurzu .
Procvičte si základní dotazy – vyzkoušejte příklady z této příručky s vlastními daty.
Seznámení se vzory grafů – Prozkoumání komplexní syntaxe vzorů
Prozkoumání datových typů – Principy hodnot GQL a hodnotových typů

Pro zkušené uživatele:

Pokročilé výrazy – Seznámení s výrazy a funkcemi jazyka GQL
Návrh schématu – Seznámení s typy a omezeními grafů GQL
Prozkoumání datových typů – Principy hodnot GQL a hodnotových typů

Referenční materiály

Pro rychlé vyhledávání vám pomůžou tyto odkazy:

Stručná referenční příručka jazyka GQL – stručná referenční dokumentace syntaxe
Stavové kódy GQL – Kompletní odkaz na kód chyby
Rezervovaná slova GQL – úplný seznam rezervovaných klíčových slov

Prozkoumání grafu

Naučte se platformu:

Datové modely grafů – Principy konceptů grafů a modelování
Grafy vs. relační databáze – Volba správného přístupu
Try Microsoft Fabric zdarma – Získejte praktické zkušenosti
Kompletní kurzy – kompletní scénáře výuky

Zapojení

Sdílení zpětné vazby – Pomozte vylepšit dokumentaci a nástroje
Připojte se ke komunitě – spojte se s dalšími odborníky na grafovou databázi
Zůstaňte v aktualizovaném stavu – Sledujte oznámení grafu o nových funkcích.

Návod

Pokud dáváte přednost učení, začněte kurzem rychlý start nebo se nejprve seznamte se vzory grafů , pokud se chcete nejprve naučit dotazovací jazyk.

Návody:

Psaní běžných dotazů GQL – praktické vzory dotazů pro sousedy, více segmenty směrování, sdílená připojení a další.
Filtrování a agregace dat grafu – FUNKCE FILTER, WHERE, GROUP BY a agregační funkce
Psaní dotazů na vzor grafu – procházení více segmentů směrování, režimy cest, opakované použití proměnných a volitelné porovnávání
Optimalizace výkonu dotazů GQL – osvědčené postupy pro psaní efektivních dotazů GQL

Další podrobnosti o klíčových tématech:

Příklad schématu sociální sítě – Dokončení funkčního příkladu schématu grafu
Vzory grafů GQL – komplexní syntaxe vzorů a pokročilé techniky párování
Výrazy a funkce jazyka GQL – Všechny typy výrazů a předdefinované funkce.
Typy grafů GQL – Typy a omezení grafů
Hodnoty a typy hodnot GQL – Kompletní odkaz na systém typů a zpracování hodnot.

Rychlé odkazy:

Zkrácená referenční dokumentace jazyka GQL – stručná referenční dokumentace syntaxe
Stavové kódy GQL – Kompletní odkaz na kód chyby
Rezervovaná slova GQL – úplný seznam rezervovaných klíčových slov.

Grafu:

datové modely grafu – Principy konceptů grafů a modelování
grafy a relační databáze – rozdíly a kdy je vhodné je použít.
Try Microsoft Fabric zdarma.
End-to-end kurzy v Microsoft Fabric.

Váš názor

Byla tato stránka užitečná?

Last updated on 2026-05-20

Průvodce jazykem GQL pro graf v Microsoft Fabric

Požadavky

Co dělá GQL speciální

Základy GQL

Principy dat grafu

Uzly a hrany: stavební bloky

Jak jsou grafy strukturované

Grafové modely a typy grafů

Praktický příklad: sociální síť

Entity sociálních sítí

Jak se všechno spojuje

Vaše první dotazy GQL

Začít jednoduše: najít všechny lidi

Přidání filtrování: Vyhledání konkrétních lidí

Základní struktura dotazu

Běžná tvrzení

Jak fungují příkazy společně

Příklad složení příkazů

Proměnné propojují vaše data

Výsledky a výsledky provádění

Tabulky výsledků

Informace o stavu

Základní koncepty a příkazy

Grafové vzory: vyhledání struktury

Základní příkazy

Prohlášení MATCH

Prohlášení OPTIONAL MATCH

Prohlášení LET

Prohlášení FILTER

Prohlášení ORDER BY

OFFSET a LIMIT příkazy

RETURN: projekce základního výsledku

RETURN with GROUP BY: seskupený výsledek projekce

Datové typy: práce s hodnotami

Základní typy hodnot

Příklady literálů

Kritické vzory zpracování hodnot null

Důsledky logiky se třemi hodnotami

Výrazy: transformace a analýza dat

Běžné typy výrazů

Komplexní predikátové složení

Porovnávání vzorů řetězců

Předdefinované funkce podle kategorie

Priorita operátorů pro komplexní výrazy

Pokročilé techniky dotazování

Komplexní vícesměrné složení

UNION ALL

Průběh vzorů s více kroky

Použití vodorovné agregace

Rozsah proměnných a pokročilé řízení toku

Vzory vazeb a oborů proměnných

Opakované použití proměnné pro spojení mezi příkazy

Kritická pravidla a omezení

Viditelnost proměnných ve složitých dotazech

Pokročilé techniky agregace

Svislá agregace pomocí GROUP BY

Vodorovná agregace s proměnnými seznamu skupin

Kontexty hraniční vazby s proměnnou délkou

Kombinování svislé a vodorovné agregace

Strategie zpracování chyb

Další informace

Kódy GQLSTATUS

Vyhrazená slova

Další kroky

Pokračovat v vytváření dovedností GQL

Referenční materiály

Prozkoumání grafu

Zapojení

Související obsah

Váš názor

Další materiály

Prohlášení `MATCH`

Prohlášení `OPTIONAL MATCH`

Prohlášení `LET`

Prohlášení `FILTER`

Prohlášení `ORDER BY`

`OFFSET` a `LIMIT` příkazy

`RETURN`: projekce základního výsledku

`RETURN` with `GROUP BY`: seskupený výsledek projekce

`UNION ALL`