GQL-udtryk, prædikater og funktioner

Denne artikel indeholder en omfattende reference til GQL-udtryk, prædikater og indbyggede funktioner, der er tilgængelige i graph i Microsoft Fabric-forespørgsler. Brug denne reference til at forstå, hvordan du udfører beregninger, filtrerer resultater og transformerer data i dine grafforespørgsler.

Du kan få en oversigt over GQL-forespørgselssproget og eksempler på komplette forespørgsler i GQL-sprogvejledningen. Du kan få oplysninger om understøttede datatyper og konstantsyntaks under GQL-værdier og værdityper.

Konstanter

Konstanter er simple udtryk, der direkte evalueres til den angivne værdi. I artiklen GQL-værdier og værdityper forklares konstanter for hver type værdi i detaljer.

Eksempel:

1
1.0d
1.00m
TRUE
"Hello, graph!"
[ 1, 2, 3 ]
NULL

Du kan finde detaljerede konstantsyntaks for hver datatype under GQL-værdier og værdityper.

Prædikater

Prædikater er booleske udtryk, som du ofte bruger til at filtrere resultater i GQL-forespørgsler. De evalueres til TRUE, FALSEeller UNKNOWN (null).

Prædikater til sammenligning

Brug disse operatorer til at sammenligne værdier:

• = (lig med)
• <> (ikke lig med)
• < (mindre end)
• > (større end)
• <= (mindre end eller lig med)
• >= (større end eller lig med)

GQL bruger tre-værdibaseret logik, hvor sammenligninger med null-returnering UNKNOWN:

Du kan se en specifik sammenligningsfunktion i dokumentationen for hver værditype i GQL-værdier og værdityper.

Eksempel:

MATCH (p:Person)
FILTER WHERE p.birthday <= 20050915
RETURN p.firstName

Hvis begge operander er tal, sammenligner GQL dem med deres numeriske værdier.

Logiske udtryk

Kombiner betingelser med logiske operatorer:

• AND (begge betingelser er sande)
• OR (begge betingelser er sande)
• NOT (negerer betingelse)
• XOR (eksklusiv fjernelse – sand, når præcis én operand er sand)

Eksempel:

MATCH (p:Person)
FILTER WHERE p.birthday <= 20050915 AND p.firstName = 'John'
RETURN p.firstName || ' ' || p.lastName AS fullName

Prædikater for egenskabens eksistens

Hvis du vil kontrollere, om der findes egenskaber, skal du bruge disse prædikater:

p.locationIP IS NOT NULL
p.browserUsed IS NULL

Eksistens-underforespørgsler

Brug en procedureform-underforespørgsel EXISTS til at teste, om en indlejret forespørgsel returnerer mindst én række:

EXISTS {
  <query statements>
  RETURN <columns>
}

Resultatet er en ikke-nul boolesk værdi:

• TRUE hvis underforespørgslen returnerer en eller flere rækker.
• FALSE hvis underforespørgslen ikke returnerer nogen rækker.

Variable, der allerede er inden for scope, er implicit tilgængelige inde i underforespørgslen. Variable, der kun introduceres inde i underforespørgslen, er ikke tilgængelige uden for den.

Brug EXISTS i et filter:

MATCH (p:Person)
WHERE EXISTS {
  MATCH (p)-[:knows]->(friend:Person)
  RETURN friend
}
RETURN p.firstName, p.lastName

Brug NOT EXISTS til at bevare rækker, hvor underforespørgslen ikke returnerer nogen rækker. Du kan også bruge EXISTS i LET, RETURN, ORDER BY, og aggregere filter- eller kildeudtryk. EXISTS understøttes ikke i et listepredikatfilter.

For mere information om korrelerede underforespørgsler, se erklæringenCALL i GQL-sprogguiden.

Prædikater for listemedlemskab

Test, om værdierne findes på lister:

p.firstName IN ['Alice', 'Bob', 'Charlie']
p.gender NOT IN ['male', 'female']

List prædikatfunktioner

Brug en listeprædikatfunktion til at evaluere et boolesk udtryk for elementerne i en liste:

ALL(element IN list WHERE predicate)
ANY(element IN list WHERE predicate)
NONE(element IN list WHERE predicate)
SINGLE(element IN list WHERE predicate)

Kilden kan være et listeliteral, en listeværdi-egenskab, en variabel eller en gruppeliste fra et variabel-længde mønster.

Funktionerne har følgende betydninger:

Følgende eksempel evaluerer alle fire funktioner over en dynamisk konstrueret liste:

LET items = [1, 2, 3]
RETURN ALL(x IN items WHERE x > 0) AS all_match,
       ANY(x IN items WHERE x = 2) AS any_match,
       NONE(x IN items WHERE x < 0) AS none_match,
       SINGLE(x IN items WHERE x = 2) AS single_match

Alle fire returnerede værdier er TRUE.

Du kan også evaluere egenskaber ved elementer ud fra en liste. I dette eksempel connections er gruppelisten skabt af det variabel-længde kantmønster:

MATCH (person:Person)-[connections:knows]->{1,4}(friend:Person)
WHERE ALL(connection IN connections WHERE connection.creationDate IS NOT NULL)
RETURN person.firstName, friend.firstName

Listeprædikater bruger tre-værdi logik. Tabellen beskriver resultatet i form af værdierne produceret af filterudtrykket for listeelementerne:

Hvis kildelisten er null, returnerer UNKNOWNhver funktion . Et nullliste-element bidrager med resultatet af at evaluere filteret med det element bundet til null; det gør ikke automatisk funktionsresultatet ukendt.

Elementvariabelen er kun tilgængelig inden for listeprædikatets filterudtryk. Filteret kan også referere til variabler fra den omsluttende forespørgsel. Hvis elementvariabelen har samme navn som en ydre variabel, har den lokale elementvariabel forrang. Indelagte listeprædikater kan på samme måde skygge en ydre elementvariabel.

Aggregerede funktioner kan referere til en omsluttende gruppeliste, men de kan ikke aggregere den lokalt bundne elementvariabel. EXISTS Subforespørgsler understøttes heller ikke i et listeprædikatfilter.

ANY(...) er en listeprædikatfunktion. Forveksl det ikke med ANY SHORTEST sti-søgepræfikset eller den dynamiske ANY værditype.

Prædikater for strengmønster

Søg efter strenge ved hjælp af teknikker til matchning af mønstre:

p.firstName CONTAINS 'John'
p.browserUsed STARTS WITH 'Chrome'
p.locationIP ENDS WITH '.1'

For RE2 regulær udtryksmatchning, brug MSFT.REGEXP_LIKE.

Aritmetiske udtryk

Brug aritmetiske standardoperatorer med numeriske værdier:

• + (tilføjelse)
• - (subtraktion)
• * (multiplikation)
• / (division)

Aritmetiske operatorer følger generelle matematiske konventioner.

Forrang:

Operatorer følger generelt de etablerede regler for prioritet for operatorer, f.eks * . før +. Brug parenteser til at styre evalueringsrækkefølgen efter behov.

Eksempel:

(p.birthday < 20050915 OR p.birthday > 19651231) AND p.gender = 'male'

Regler for tvangsforanstaltninger:

Brug følgende regler i prioriteret rækkefølge:

1. Aritmetiske udtryk, der involverer en tilnærmet numerisk type, returnerer en tilnærmet numerisk type.
2. Aritmetiske udtryk, der involverer både signerede og usignerede heltalstyper, returnerer en signeret heltalstype.

Egenskabsadgang

Access-egenskaber ved hjælp af punktnotation:

p.firstName
edge.creationDate

Listeadgang

Få adgang til listeelementer ved hjælp af nulbaseret indeksering:

interests[0]    -- first element
interests[1]    -- second element

Indbyggede funktioner

GQL understøtter forskellige indbyggede funktioner til databehandling og analyse.

Numeriske funktioner

Brug numeriske funktioner til at transformere numeriske værdier, beregne trigonometriske værdier og skabe heltalsintervaller.

Absolut værdi og magt

Begge funktioner accepterer numeriske værdier. Et nulargument producerer null. En ugyldig numerisk operation, såsom et overløbsresultat POWER , giver en fejl.

RETURN ABS(-1) AS absoluteValue, POWER(2, -2) AS reciprocalSquare

Resultatet er:

Trigonometriske funktioner

De trigonometriske funktioner accepterer én numerisk værdi og returnerer en DOUBLE. Et nulargument producerer null.

Et argument uden for en funktions matematiske domæne giver en fejl.

RETURN COS(0) AS cosine, RADIANS(180) AS angle

Resultatet er:

Heltalsintervaller

RANGE(start, end) returnerer en liste af heltal fra start mod end, ved hjælp af et trin af 1. RANGE(start, end, step) bruger det specificerede ikke-nul trin. start, end, og step skal være ikke-nul heltal. Nul er gyldig for start eller end; kun step skal være forskellig fra nul.

Rækkevidden inkluderer start. Det gælder end kun, når gentagne gange tilføjer step rækker præcist end . Et positivt trin med start større end end, eller et negativt trin med start mindre end end, returnerer en tom liste. Et nultrin giver en fejl.

RETURN RANGE(0, 10, 3) AS ascending, RANGE(5, 0, -2) AS descending

Resultatet er:

Hvis alle argumenter er usignerede heltal, RANGE returnerer en LIST<UINT64>. Ellers returnerer den a LIST<INT64> og afviser værdier, der ikke sikkert kan repræsenteres som fortegnede heltal.

Aggregeringsfunktioner

Aggregerede funktioner kombinerer værdier enten på tværs af inputrækker eller inden for en gruppeliste, der er afgrænset af et mønster med variabel længde.

Når en aggregeret forespørgsel ikke har grupperingskolonner og ikke modtager input-rækker, COUNT returnerer 0, COLLECT_LIST og COLLECT_ELEMENTS returnerer en tom liste, og de øvrige aggregerede funktioner returnerer null. Stol ikke på rækkefølgen af værdier, der returneres af en samlingsgruppe. Med grupperingskolonner producerer ingen inputrækker ingen gruppe og dermed ingen resultatrække.

Mængdekvantorer

Brug ALL det til at inkludere dubletværdier eller DISTINCT fjerne dem. ALL er standarden for udtryksaggregater. COUNT(*) accepterer ikke en mængdekvantor.

MATCH (person:Person)
RETURN COUNT(person) AS personCount,
       COUNT(DISTINCT person.browserUsed) AS browserCount

For COLLECT_LISTfjerner fjerner DISTINCT de dubblerede værdier og bevarer højst én null. For COLLECT_ELEMENTSgælder for DISTINCT elementerne efter at inputlisterne er sammenkædet. DISTINCT Det gør COLLECT_ONE ikke deterministisk.

Aggregat-specifikke filtre og grænser

Læg FILTER (WHERE predicate) efter et aggregat for kun at inkludere værdier , for hvor predicate er sand. Falske og ukendte prædikatresultater udelukkes. Dette filter påvirker kun denne aggregat, ikke inputrækkerne, der er tilgængelige for andre udtryk i samme RETURN.

Tilføj LIMIT n i aggregationsfilteret for at tage højde for højst n kvalificerende inputrækker. Filtrering sker før den aggregatspecifikke grænse og DISTINCT anvendes efter grænsen.

MATCH (person:Person)
RETURN COUNT(*) AS allPeople,
       COUNT(*) FILTER (WHERE person.birthday < 19900101 LIMIT 5) AS sampleBornBefore1990

Aggregering på tværs af rækker

Et aggregat kombinerer normalt værdier vertikalt på tværs af inputrækker. Brug GROUP BY den til at beregne ét resultat for hver gruppe.

MATCH (p:Person)
RETURN count(*) AS total_people, avg(p.birthday) AS average_birth_year

MATCH (p:Person)-[:isLocatedIn]->(c:City)
RETURN c.id AS cityId, c.name, count(*) AS population, avg(p.birthday) AS average_birth_year
GROUP BY cityId, c.name

Placer ikke én vertikal aggregate direkte inde i en anden i samme forespørgselsblok. For eksempel SUM(COUNT(*)) er ugyldig. Brug NEXT den til at adskille aggregeringstrinene, når du skal aggregere et aggregeret resultat.

Aggregering inden for en matchet sti

En kantvariabel bundet af et mønster med variabel længde bliver til en gruppeliste. Et aggregat over den variabel er horisontalt: det beregner ét resultat i listen for hver matchet sti i stedet for at kombinere forskellige inputrækker.

MATCH (person:Person)-[knows:knows]->{1,5}(friend:Person)
RETURN COUNT(knows) AS pathLength

Her COUNT(knows) returnerer antallet af kanter i hver matchet sti. De horisontale former af COUNT, SUM, AVG, MIN, , COLLECT_LISTMAX, , COLLECT_ONE, og COLLECT_ELEMENTS understøttes. COUNT(*) og aggregat-specifikke FILTER eller LIMIT ikke er horisontale former.

Et horisontalt aggregat kan være input til et ydre vertikalt aggregat:

MATCH (person:Person)-[knows:knows]->{1,5}(friend:Person)
RETURN MIN(COUNT(knows)) AS shortestMatchedPath

I denne forespørgsel COUNT(knows) beregnes én længde per matchet sti og MIN kombineres disse længder på tværs af input-raderne.

For opgaveorienterede eksempler, se Filter og aggreger grafdata.

Betingede udtryk

Brug et simpelt CASE udtryk til at sammenligne et udtryk med en eller flere værdier og returner resultatet tilknyttet den første lige værdi:

CASE expression
  WHEN value1 THEN result1
  WHEN value2 THEN result2
  ELSE default_result
END

NULLIF:

NULLIF(a, b) returnerer NULL , hvis a er blig med , ellers returneres a.

Eksempel:

MATCH (p:Person)
RETURN p.firstName,
       CASE p.gender
         WHEN 'male' THEN 'M'
         WHEN 'female' THEN 'F'
         ELSE 'Other'
       END AS gender_code,
       NULLIF(p.browserUsed, 'Unknown') AS browser

Søgte CASE WHEN <predicate> udtryk understøttes ikke. For at rute rækker efter prædikater og køre en forespørgselssætning eller en indlejret procedure for den valgte gren, brug en WHEN betinget sætning.

Streng funktioner

Brug strengfunktioner til at måle, transformere, søge, sammenligne og kombinere tegnstrenge.

Tegnlængde og kasus

Brug disse funktioner til at måle eller ændre tegnstrenge:

Unicode-mappinger kan ændre længden eller repræsentationen af en streng:

RETURN UPPER('straße') AS uppercase,
       LOWER('İ') AS lowercase,
       CASEFOLD('Straße') AS folded

Resultaterne er STRASSEhenholdsvis , i̇, og strasse, . CASEFOLD er ikke ækvivalent med LOWER. For eksempel kortlægger ß kasusfoldning til ss og afbilder de græske sigma-former Σ, σ, og ς til σ.

Normaliser strenge

GQL definerer fire Unicode-normaliseringsformer:

• Normaliseringsform C (NFC), kanonisk sammensætning.
• Normaliseringsform D (NFD), kanonisk dekomponering.
• Normaliseringsform KC (NFKC), kompatibilitetssammensætning.
• Normaliseringsform KD (NFKD), kompatibilitetsdekomponering.

NORMALIZE(string) går som standard til NFC. Angiv en normaliseringsform som det andet argument:

RETURN NORMALIZE('cafe\u0301') AS composed,
       NORMALIZE('café', NFD) AS decomposed

Argumentet skal være en streng.

Trimstrenge

Brug TRIM til at fjerne mellemrumstegn eller et specificeret tegn fra begge ender, begyndelsen eller slutningen af en streng:

RETURN TRIM('  text  ') AS both_ends,
       TRIM(BOTH FROM '  text  ') AS explicit_both,
       TRIM(LEADING FROM '  text  ') AS beginning,
       TRIM(TRAILING FROM '  text  ') AS ending,
       TRIM(LEADING 'f' FROM 'foobar') AS custom_character

Den tilpassede trimværdi skal være præcis én byte. Multibyte Unicode-tegn og strenge, der indeholder flere tegn, understøttes ikke som brugerdefinerede trim-værdier. En null-kilde eller en tilpasset trim-værdi returnerer null.

Sammensæt strenge

STRING_JOIN(list [, delimiter]) slutter sig til en liste af strenge. Standardskilletegnet er et komma efterfulgt af et mellemrum:

RETURN STRING_JOIN(['foo', 'bar', 'baz']) AS default_delimiter,
       STRING_JOIN(['foo', 'bar', 'baz'], '-') AS custom_delimiter

Resultaterne er foo, bar, baz og foo-bar-baz. En tom liste returnerer en tom streng. En nullliste, nulafgrænser eller nullliste-element returnerer null. Hvert ikke-nulliste-element skal være en streng.

Regulære udtryksfunktioner

Graph tilbyder disse regulære udtryksfunktioner som udvidelser til GQL:

MSFT.REGEXP_LIKE

Returneres TRUE , når mønsteret matcher en hvilken som helst del af kildestrengen. Hvis der ikke findes et match, returnerer FALSEden .

source er strengen, der skal søges. pattern matches mod enhver delstreng af source , medmindre udtrykket selv bruger ankre som ^ eller $. flags ændrer matchningsadfærd som beskrevet i Matching-regler og -muligheder.

RETURN MSFT.REGEXP_LIKE('HELLO', 'hello', 'i') AS matches

Resultatet er TRUE.

MSFT.REGEXP_COUNT

Returnerer antallet af matches. Hvis der ikke findes et match, returnerer 0den .

source er strengen, der skal søges i, og pattern identificerer de matches, der skal tælles. start er den nul-baserede Unicode-kodepunktposition, hvor matching kan begynde. En kamp skal starte ved eller efter denne position. Positionen bliver ikke en ny begyndelse for forankrede mønstre. flags ændrer matchningsadfærd som beskrevet i Matching-regler og -muligheder.

RETURN MSFT.REGEXP_COUNT('1a2a3a4', '[0-9]', 3) AS match_count

Søgningen starter på position 3, den anden a, så kun cifrene 3 og 4 tælles. Resultatet er 2.

MSFT.REGEXP_INSTR

Returnerer den nul-baserede position for en valgt match- eller fangstgruppe.

source er strengen, der skal søges i, og pattern identificerer matchene. start er den nul-baserede Unicode-kodepunktposition, hvor matching kan begynde. En kamp skal starte ved eller efter denne position, hvilket ikke bliver en ny begyndelse for strengen for forankrede mønstre.

occurrence vælger det første, andet eller efterfølgende ikke-overlappende match fundet fra start. group Vælger hvad der skal placeres i det match: 0 Vælger det komplette match, og en positiv værdi vælger den nummererede capture-gruppe. return_option bestemmer hvilken grænse for den valgte kamp eller gruppe, der returneres: 0 returnerer sin startposition og 1 returnerer positionen umiddelbart efter afslutningen. flags ændrer matchningsadfærd som beskrevet i Matching-regler og -muligheder.

Hvis der ikke findes nogen matchende forekomst, eller den valgte capture-gruppe ikke deltager i den forekomst, returnerer -1funktionen .

RETURN MSFT.REGEXP_INSTR('banana', 'a', 0, 2) AS match_position

Det andet match starter på position 3, så resultatet er 3.

MSFT.REGEXP_SUBSTR

Returnerer teksten fra en udvalgt kamp- eller fangstgruppe.

source er strengen, der skal søges i, og pattern identificerer matchene. start er den nul-baserede Unicode-kodepunktposition, hvor matching kan begynde. En kamp skal starte ved eller efter denne position, hvilket ikke bliver en ny begyndelse for strengen for forankrede mønstre.

occurrence vælger det første, andet eller efterfølgende ikke-overlappende match fundet fra start. group Vælger teksten, der skal returneres fra det match: 0 vælger det komplette match, og en positiv værdi vælger den nummererede capture-gruppe. flags ændrer matchningsadfærd som beskrevet i Matching-regler og -muligheder.

Hvis der ikke findes nogen matchende forekomst, eller den valgte capture-gruppe ikke deltager i den forekomst, returnerer funktionen null.

RETURN MSFT.REGEXP_SUBSTR(
  '12-345',
  '([0-9]+)-([0-9]+)',
  0,
  1,
  '',
  2
) AS matched_text

Den første forekomst er den komplette streng, og fangstgruppen 2 er 345, så resultatet er 345.

MSFT.REGEXP_REPLACE

Erstatter matchende tekst. Som standard erstatter den hvert match og indsætter erstatningsteksten bogstaveligt talt.

source er strengen, der skal ændres, og pattern identificerer matchene. replacement er teksten indsat for et valgt match. EXACT indsætter det bogstaveligt; TEMPLATE fortolker capture-referencer.

start er den nul-baserede Unicode-kodepunktposition, hvor udskiftning kan begynde. En kamp skal starte ved eller efter denne position. Teksten før start bevares uændret, og positionen bliver ikke en ny begyndelse for strengen for forankrede mønstre. Sæt occurrence til 0 at erstatte hvert match fra start, eller til en positiv værdi for kun at erstatte det nummererede ikke-overlappende match. Tidligere matches forbliver start uændrede, når en specifik hændelse vælges. flags ændrer matchningsadfærd som beskrevet i Matching-regler og -muligheder.

RETURN MSFT.REGEXP_REPLACE('a1b2c3', '[0-9]', '#', 0, 2) AS replaced

Kun det andet cifret match erstattes, så resultatet er a1b#c3.

Hvis der ikke findes et match, returneres kildestrengen uændret.

For at genbruge matchet tekst i erstatningen, angiv TEMPLATE. I denne tilstand \0 refererer det til \9 de komplette kamp- og fangstgrupper, og \\ indsætter en bogstavelig bagskrå. Brug et råt streng-literal, præfikseret med @, for at sende disse referencer uden yderligere undslip:

RETURN MSFT.REGEXP_REPLACE(
  'John Smith',
  @'([A-Za-z]+) ([A-Za-z]+)',
  TEMPLATE @'\2 \1'
) AS reordered_name

Resultatet er Smith John.

Matchningsregler og muligheder

Mønstre bruger RE2 regulær udtrykssyntaks og matcher Unicode-strenge. Kilden kan være enhver strengudtryk. Mønsteret, flagene og erstatningen skal være strengliteraler, og numeriske muligheder skal være usignerede heltalsliteraler.

Matches findes fra venstre mod højre uden overlapp. Efter en nul-længde match avanceres matchningen med ét Unicode-kodepunkt.

Startpositioner og returnerede positioner er nul-baserede Unicode-kodepunkt-offsets. Forekomstnumre er one-baserede, bortset fra at forekomst 0 betyder at erstatte alle forekomster i MSFT.REGEXP_REPLACE.

Følgende tabel viser standardindstillingerne for udeladte valgfrie argumenter:

De valgfrie flag er:

Kombiner flag i én streng, såsom 'ims'. En null-kilde returnerer null. Et ikke-understøttet flag, ugyldigt regulært udtryk, ugyldig returmulighed eller ugyldigt forekomst- eller gruppenummer returnerer en fejl.

Graf funktioner

• nodes(path) – returnerer noder fra en stiværdi.
• edges(path) - returnerer kanter fra en stiværdi.
• elements(path) – returnerer alle noder og kanter fra en sti som en enkelt liste i stirækkefølgen.
• labels(node_or_edge) – returnerer mærkaterne for en node eller kant som en liste over strenge.
• path_length(path) - returnerer antallet af kanter i en sti.
• element_id(node_or_edge) - returnerer node- eller kantidentifikatoren som en uigennemsigtig streng.

ELEMENT_ID accepterer en node- eller kantreference og returnerer null for et nullinput. Behandl den returnerede streng som uigennemsigtig.

Eksempel:

MATCH p=(:Company)<-[:workAt]-(:Person)-[:knows]-{1,3}(:Person)-[:workAt]->(:Company)
RETURN nodes(p) AS chain_of_colleagues, path_length(p) AS hops

Listefunktioner

• size(list) – returnerer størrelsen på en listeværdi.
• trim(list,n) - trimmer en liste til højst n elementer.

Eksempel:

MATCH (p:Person)-[:hasInterest]->(t:Tag)
LET personId = p.id, personName = p.firstName
RETURN personId, personName, collect_list(t.name) AS interests
GROUP BY personId, personName
FILTER size(interests) > 3

Tidsmæssige funktioner

• CURRENT_TIMESTAMP – returnerer den aktuelle zoned datetime.
• ZONED_DATETIME(string) - returnerer den zonede dato-tid repræsenteret ved en ISO 8601-streng.
• DURATION(string) - returnerer dagtidsvarigheden repræsenteret ved en ISO 8601-varighedsstreng.

Eksempel:

RETURN CURRENT_TIMESTAMP AS now,
       DURATION('PT2H') AS twoHours

Brug subtraktionsoperatoren til at udlede en varighed mellem to zonede datotidspunkter:

RETURN ZONED_DATETIME('2026-09-17T12:00:00Z')
       - ZONED_DATETIME('2026-09-17T10:00:00Z') AS elapsed

Generiske funktioner

• coalesce(value1, value2, ...) – returnerer den første værdi, der ikke er null.
• to_json_string(value) – konverterer en værdi til dens JSON-strengrepræsentation.

Eksempel:

MATCH (p:Person)
RETURN coalesce(p.firstName, 'Unknown') AS display_name,
       to_json_string(p) AS person_json

Relateret indhold

• GQL-sprogvejledning
• GQL-værdier og værdityper
• Grafmønstre
• Filter- og aggregeret grafdata