Průvodce jazykem GQL

Poznámka:

Tato funkce je aktuálně ve verzi Public Preview. Tato verze Preview se poskytuje bez smlouvy o úrovni služeb a nedoporučuje se pro produkční úlohy. Některé funkce nemusí být podporované nebo můžou mít omezené možnosti. Další informace najdete v dodatečných podmínkách použití pro verze Preview v Microsoft Azure.

Jazyk GQL Graph Query Language je standardizovaný dotazovací jazyk ISO pro grafové databáze. Pomáhá efektivně dotazovat a pracovat s grafovými daty.

GQL vyvíjí stejná pracovní skupina ISO, která standardizuje SQL, zajišťující konzistenci a přísnost. Pokud znáte SQL, najdete v GQL mnoho podobností (výrazy, predikáty, typy) – což usnadňuje začátek. Tato příručka slouží jak novým uživatelům, kteří se učí základy GQL, tak zkušení uživatelé hledající pokročilé techniky a komplexní referenční informace.

Poznámka:

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

Požadavky

Než se ponoříte do GQL, měli byste být obeznámeni s těmito koncepty:

• Základní znalosti databází – Zkušenosti s jakýmkoli databázovým systémem (například relačním (SQL), NoSQL nebo grafem) jsou užitečné
• Koncepty grafů – Principy uzlů, hran a relací v propojených datech
• Základy dotazů – Znalost základních konceptů dotazů, jako jsou filtrování, řazení a agregace

Doporučené pozadí:

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

Co budete potřebovat:

• Přístup k Microsoft Fabric s možnostmi grafu
• 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 tomu je přirozené a intuitivní pracovat s propojenými informacemi.

Na rozdíl od SQL, který spoléhá na spojení tabulek k vyjádření vztahů, GQL používá vizuální grafové vzory, které přímo zrcadlí, jak jsou entity propojeny, což usnadňuje čtení a uvažování o dotazech.

Řekněme, že chcete najít lidi a jejich přátele (lidi, kteří se znají), kteří se oba narodili před rokem 1999. Takto to GQL vyjadřuje pomocí vizuálního grafového vzoru:

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í vaše data jako uzly (entity) a hrany (vztahy), každá s označením a vlastnostmi
• Typy grafů fungují jako schémata a definují, jaké uzly a hrany mohou v grafu existovat.
• Omezení jsou další pravidla a omezení uvalená typy grafů na grafy za účelem vynucení integrity dat
• Dotazy používají příkazy jako MATCH, FILTERa RETURN ke 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 booleovské hodnotové výrazy, které se používají k filtrování výsledků v dotazech
• 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 lidi, organizace, příspěvky nebo produkty. Jsou to nezávislé objekty, které existují ve vaší doméně. Uzly se někdy označují také jako vrcholy.

Hrany představují vztahy mezi entitami (slovesa) – jak se entity propojují a komunikují. 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).
Hrany se někdy označují také jako relace.

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 Microsoft Fabric mají hrany grafu vždy přesně jeden štítek.
• Vlastnosti – páry jméno-hodnota, které uchovávají data o prvku (například firstName: "Alice" nebo birthday: "19730108").

Jak jsou grafy strukturované

Každá hrana spojuje přesně dva uzly: zdroj 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:

Graph v Microsoft Fabric momentálně nepodporuje nesměrované hrany.

Grafy vlastností podporované v Microsoft Fabric jsou vždy dobře tvarované, 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ů

Struktura grafu v Microsoft Fabric je popsaná jeho grafovým modelem, který 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 můžou uzly a hrany připojit

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 je možné zadat pomocí standardní syntaxe GQL, v takovém případě se nazývají typy grafů.

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

V této dokumentaci používáme příklad sociální sítě k ilustraci konceptů 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říkladem sociální sítě je LDBC SNB (LDBC Social Network Benchmark) publikovaný GDC (Graph Data Council). Další podrobnosti najdete v článku Srovnávací test sociální sítě LDBC .

Entity sociálních sítí

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"
• Země/oblasti , jako je "Spojené státy" 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 firmách (:workAt) nebo studují na univerzitách (:studyAt)
• Lidé vytvářejí příspěvky a komentáře (:hasCreator)
• Lidé mají rádi příspěvky a komentáře (:likes)
• Příspěvky, fóra, komentáře mohou mít štítky (:hasTag)
• Lidé mají zájem o konkrétní tagy (: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ěme nejzákladně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 provádí následovně:

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

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

Teď najděme lidi s konkrétními vlastnostmi, v tomto případě všechny jménem Alice, a ukažme jejich jména a narozeniny.

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

Tento dotaz se provádí následovně:

1. MATCH najde všechny uzly (p) označené jako Osoba
2. FILTER uzly (p), jejichž křestní jméno je Alice
3. RETURN ukazuje jejich křestní jméno, příjmení a datum narození

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 provádí následovně:

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

Návod

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

Poznámka:

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.
• To vytváří jasný, předvídatelný tok dat, který zjednodušuje složité dotazy.

Důležité

Interně lze provádět příkazy a jednotlivé příkazy provádět paralelně pomocí Microsoft Fabric pro maximalizaci výkonu. To však neovlivní správnost výsledků.

Příklad

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 provádí následovně:

1. MATCH najdu lidi, kteří pracují ve firmách s "Air" v názvu
2. LET Vytváří celá jména kombinací křestního a rodinného jména
3. FILTER ponechávají pouze zaměstnance Contosa
4. ORDER BY třídění podle celého jména
5. LIMIT bere prvních 10 výsledků
6. RETURN Vrací jména a umístění 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é je možné 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 ukazující, 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:

V případě selhání spuštění není do výsledku provádění zahrnuta žádná tabulka výsledků.

Informace o stavu

Během provádění dotazu jsou zjištěny různé důležité podmínky (například chyby nebo upozornění). Každá taková 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 stavového objektu a (pravděpodobně prázdného) seznamu dalších stavových objektů. Primární stavový objekt je vždy přítomný a označuje, zda bylo spuštění dotazu úspěšné nebo neúspěšné.

Každý stavový objekt obsahuje 5místný 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

Další stavové kódy označují další chyby nebo upozornění, která byla zjištěna během provádění dotazu.

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

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 měnit v závislosti na dotazu nebo dokonce mezi vykonáními stejného dotazu.

Objekty stavu mohou navíc obsahovat základní objekt stavu příčiny a diagnostický záznam s dalšími informacemi, které charakterizují zaznamenanou podmínku.

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 who works at Microsoft specifically
(p:Person)-[:workAt]->(c:Company)
WHERE p.firstName = 'Annemarie'

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

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:

Modely grafů s více štítky prvků zatím nejsou podporovány (známý problém).

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í. Tato technika vyjadřuje složité vztahy s grafy, 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

Vzory TRAIL pro procházení bez cyklu:

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

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é s proměnnými vzorů a vypíše všechny odpovídající kombinace.

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 mohou být po filtrování pomocí WHERE, vyhnout se samostatnému FILTER příkazu.

Spojení se vstupními proměnnými:

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é

Graph v Microsoft Fabric zatím nepodporuje složení libovolných příkazů. Přečtěte si článek 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é spojují se vzorovými proměnnými pomocí porovnávání rovnosti.
• Vnitřní spojení: Vstupní řádky bez shody vzorů se zahodí (žádná spojení zleva/doprava)
• 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 se nejedná MATCH o první příkaz, 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í 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í:

• Výrazy se vyhodnocují 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ů.
• Několik přiřazení v jednom se vyhodnocuje LET 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, '127.0.0.1') STARTS WITH '127.0.0' – 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í:

• Vyhodnocení výrazu: Výrazy se vyhodnocují pro každý řádek a výsledky určují pořadí řádků.
• Více klíčů řazení: Vytvoření hierarchického řazení (primární, sekundární, terciární atd.)
• Zpracování hodnoty Null: NULL v porovnání se vždy považuje za nejmenší hodnotu.
• Výchozí pořadí: ASC (vzestupně) je výchozí, DESC (sestupné) musí být explicitně zadáno.
• Počítané řazení: Můžete řadit podle počítaných hodnot, nejen podle uložených vlastností.

Upozornění

Pořadí řazení vytvořené podle ORDER BY je viditelné pouze pro bezprostředně následující příkaz. ORDER BY RETURN * Následně tedy 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  */

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

To má okamžité důsledky pro dotazy "Top-k": LIMIT vždy se musí řídit ORDER BY příkazem, který vytvořil 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, UINT64pro DOUBLE 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é

Některé typy hodnot nejsou podporovány jako typy hodnot nemovitostí. Zejména všechny hodnoty týkající se referenčních hodnot grafových prvků nelze použít jako vlastnosti (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ů. Podobají se výrazům v SQL, ale mají další funkce pro zpracování grafových dat.

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í složení 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)

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
• Řetězcové funkce: char_length(), upper(), lower()trim()pro zpracování textu
• Grafové funkce: nodes(), edges()pro labels() analýzu struktur grafu
• Obecné funkce: coalesce() pro řádné zpracování hodnot null

Priorita operátorů pro komplexní výrazy:

1. Přístup k vlastnostem (.)
2. Násobení/dělení (*, /)
3. Sčítání/odčítání (+, -)
4. Porovnání (=, , <><, >, <=) >=
5. Logická negace (NOT)
6. Logická spojení (AND)
7. Logická disjunkce (OR)

V uvedeném seznamu operátor s nižším číslem "připojuje pevněji" než operátor s vyšším číslem. Příklad: NOT n.prop OR m.prop je ale (NOT n.prop) OR m.prop není 'NOT (n.prop NEBO 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í složení s více příkazy

Důležité

Graph v Microsoft Fabric zatím nepodporuje složení libovolných příkazů. Přečtěte si článek o aktuálních omezeních.

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

Průběh vícestupňového vzoru:

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

-- 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 zatím není podporován (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 zatím není podporován (známý problém).

Hlavní 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 zatím není podporován (známý problém).

Kombinování svislé a vodorovné agregace

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

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

Poznámka:

Tento dotaz zatím není podporován (známý problém).

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 najdete v našem praktickém 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ů – zvládnutí komplexní syntaxe vzorů
• Prozkoumání datových typů – Principy hodnot GQL a hodnotových typů

Pro zkušené uživatele:

• Pokročilé výrazy – výrazy a funkce hlavního 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í Microsoft Fabric

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
• Vyzkoušejte Si Microsoft Fabric zdarma – získejte praktické prostředí
• Kompletní kurzy – kompletní scénáře výuky

Zapojení

• Sdílení zpětné vazby – Pomozte vylepšit naši 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í Microsoft Fabric 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 chcete nejprve zvládnout dotazovací jazyk.

Související obsah

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 grafů a omezení
• 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

Graf v Microsoft Fabric:

• Datové modely grafů – Principy konceptů grafů a modelování
• Grafové a relační databáze – Rozdíly a kdy je vhodné je použít
• Vyzkoušejte Si Microsoft Fabric zdarma
• Kompletní návody v Microsoft Fabric