Espressioni, predicati e funzioni GQL

Questo articolo fornisce informazioni di riferimento complete per espressioni, predicati e funzioni predefinite GQL disponibili in graph nelle query di Microsoft Fabric. Usare questo riferimento per comprendere come eseguire calcoli, filtrare i risultati e trasformare i dati nelle query del grafo.

Per una panoramica del linguaggio di query GQL e degli esempi di query end-to-end, vedere guida al linguaggio GQL. Per informazioni sui tipi di dati supportati e sulla sintassi letterale, vedere Valori GQL e tipi di valore.

Literals

I valori letterali sono espressioni semplici che restituiscono direttamente il valore dichiarato. L'articolo Relativo ai valori GQL e ai tipi di valore illustra in dettaglio i valori letterali di ogni tipo di valore.

Esempio:

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

Per una sintassi letterale dettagliata per ogni tipo di dati, vedere Valori GQL e tipi valore.

Predicates

I predicati sono espressioni booleane usate comunemente per filtrare i risultati nelle query GQL. Restituiscono TRUE, FALSEo UNKNOWN (null).

Predicati di confronto

Usare questi operatori per confrontare i valori:

• = (uguale)
• <> (diverso da)
• < (minore di)
• > (maggiore di)
• <= (minore o uguale)
• >= (maggiore o uguale)

GQL usa la logica a tre valori in cui i confronti con valori Null restituiscono UNKNOWN:

Per un comportamento di confronto specifico, vedere la documentazione per ogni tipo di valore nei valori GQL e nei tipi valore.

Esempio:

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

Se entrambi gli operandi sono numeri, GQL li confronta tramite i loro valori numerici.

Espressioni logiche

Combinare condizioni con operatori logici:

• AND (entrambe le condizioni true)
• OR (entrambe le condizioni true)
• NOT (nega condizione)
• XOR (disgiunzione esclusiva - true quando è vero esattamente un operando)

Esempio:

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

Predicati di esistenza delle proprietà

Per verificare se esistono proprietà, usare questi predicati:

p.locationIP IS NOT NULL
p.browserUsed IS NULL

Sottoquery di esistenza

Usa una sottoquery procedura-form EXISTS per testare se una query annidata restituisce almeno una riga:

EXISTS {
  <query statements>
  RETURN <columns>
}

Il risultato è un valore booleano non nullo:

• TRUE se la sottoquery restituisce una o più righe.
• FALSE se la sottoquery non restituisce righe.

Le variabili già nell'ambito sono implicitamente disponibili all'interno della sottoquery. Le variabili introdotte solo all'interno della sottoquery non sono disponibili al di fuori di essa.

Uso EXISTS in un filtro:

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

Usare NOT EXISTS per mantenere righe per le quali la sottoquery non restituisce righe. Puoi anche usare EXISTS in LET, RETURN, ORDER BY, e aggregare espressioni di filtro o sorgente. EXISTS non è supportato all'interno di un filtro di predicati di lista.

Per maggiori informazioni sulle sottoquery correlate, consulta l'affermazioneCALL nella guida linguistica GQL.

Elencare i predicati di appartenenza

Verificare se i valori si trovano negli elenchi:

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

Funzioni predicate a lista

Usa una funzione predicato di lista per valutare un'espressione booleana per gli elementi di una lista:

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

La sorgente può essere un letterale di lista, una proprietà a valore di lista, una variabile o una lista di gruppo da un pattern a lunghezza variabile.

Le funzioni hanno i seguenti significati:

Il seguente esempio valuta tutte e quattro le funzioni su un elenco dinamicamente costruito:

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

Tutti e quattro i valori restituiti sono TRUE.

Puoi anche valutare le proprietà degli elementi da un elenco. In questo esempio, connections è la lista di gruppi creata dal pattern di spigoli a lunghezza variabile:

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

I predicati di lista usano una logica a tre valori. La tabella descrive il risultato in termini dei valori prodotti dall'espressione filtro per gli elementi della lista:

Se la lista sorgente è nulla, ogni funzione restituisce UNKNOWN. Un elemento di lista nullo contribuisce al risultato della valutazione del filtro con quell'elemento legato a nullo; non rende automaticamente il risultato della funzione sconosciuto.

La variabile elemento è disponibile solo all'interno dell'espressione filtro del predicato lista. Il filtro può anche fare riferimento a variabili dalla query che lo incarta. Se la variabile elemento ha lo stesso nome di una variabile esterna, la variabile elemento locale ha la precedenza. I predicati di lista annidata possono analogamente ombreggiare una variabile a elemento esterno.

Le funzioni aggregate possono fare riferimento a una lista di gruppi che racchiude, ma non possono aggregare la variabile elementale localmente legata. EXISTS Le sottoquery inoltre non sono supportate all'interno di un filtro di predicati di lista.

ANY(...) è una funzione predicato lista. Non confonderlo con il ANY SHORTEST prefisso di ricerca del percorso o con il ANY tipo di valore dinamico.

Predicati del modello di stringa

Associare le stringhe usando tecniche di ricerca dei criteri:

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

Per il matching delle espressioni regolari di RE2, usa MSFT.REGEXP_LIKE.

Espressioni aritmetiche

Usare operatori aritmetici standard con valori numerici:

• + (addizione)
• - (sottrazione)
• * (moltiplicazione)
• / (divisione)

Gli operatori aritmetici seguono convenzioni matematiche generali.

Precedenza:

In genere, gli operatori seguono regole di precedenza degli operatori stabilite, ad esempio * prima +di . Usare le parentesi per controllare l'ordine di valutazione in base alle esigenze.

Esempio:

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

Regole di coercizione:

Usare le regole seguenti in ordine di precedenza:

1. Le espressioni aritmetiche che coinvolgono un tipo numerico approssimato restituiscono un tipo numerico approssimativo.
2. Le espressioni aritmetiche che coinvolgono sia tipi di interi con segno che senza segno restituiscono un tipo di intero con segno.

Accesso alle proprietà

Accedere alle proprietà usando la notazione punto:

p.firstName
edge.creationDate

Elencare l'accesso

Accedere a elementi elenco usando l'indicizzazione in base zero:

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

Funzioni predefinite

GQL supporta varie funzioni predefinite per l'elaborazione e l'analisi dei dati.

Funzioni numeriche

Utilizzare funzioni numeriche per trasformare i valori numerici, calcolare i valori trigonometrici e creare intervalli interi.

Valore assoluto e potenza

Entrambe le funzioni accettano valori numerici. Un argomento nullo produce nullo. Un'operazione numerica non valida, come un risultato che trabocca POWER , produce un errore.

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

Il risultato è:

Funzioni trigonometriche

Le funzioni trigonometriche accettano un valore numerico e restituiscono un DOUBLE. Un argomento nullo produce nullo.

Un argomento al di fuori del dominio matematico di una funzione produce un errore.

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

Il risultato è:

Intervalli interi

RANGE(start, end) restituisce un elenco di interi da start verso end, usando un passo di 1. RANGE(start, end, step) utilizza il passo non nullo specificato. start, end, e step devono essere interi non nulli. Zero è valido per start o end; solo step deve essere diverso da zero.

L'intervallo include start. Include end solo quando si aggiungono step ripetutamente le sfilate end esattamente. Un passo positivo con start maggiore di end, o un passo negativo con start minore di end, restituisce una lista vuota. Un passo zero produce un errore.

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

Il risultato è:

Se tutti gli argomenti sono interi senza segno, RANGE restituisce un LIST<UINT64>. Altrimenti, restituisce a LIST<INT64> e rifiuta valori che non possono essere rappresentati in sicurezza come interi con segno.

Funzioni di aggregazione

Le funzioni aggregate combinano valori sia tra le righe di input sia all'interno di una lista di gruppi delimitata da un pattern a lunghezza variabile.

Quando una query aggregata non ha colonne di raggruppamento e non riceve righe di input, COUNT restituisce 0, COLLECT_LIST e COLLECT_ELEMENTS restituisce una lista vuota, e le altre funzioni aggregate restituiscono nulla. Non affidarti all'ordine dei valori restituiti da un aggregato di collezione. Con il raggruppamento delle colonne, nessuna riga di input non produce gruppo e quindi nessuna riga di risultato.

Quantificatori di insiemi

Usalo ALL per includere valori duplicati o DISTINCT per rimuoverli. ALL è il valore predefinito per gli aggregati di espressione. COUNT(*) non accetta un quantificatore insieme.

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

Per COLLECT_LIST, DISTINCT rimuove i valori duplicati e mantiene al massimo un nullo. Per COLLECT_ELEMENTS, DISTINCT si applica agli elementi dopo che le liste di input sono state concatenate. DISTINCT non rende COLLECT_ONE deterministico.

Filtri e limiti specifici per aggregato

Aggiungi FILTER (WHERE predicate) dopo un aggregato per includere solo i valori per cui predicate è vero. I risultati falsi e con predicati sconosciuti sono esclusi. Questo filtro riguarda solo quell'aggregato, non le righe di input disponibili per altre espressioni nella stessa RETURN.

Aggiungi LIMIT n all'interno del filtro aggregato per considerare al massimo n le righe di input qualificate. Il filtraggio avviene prima del limite specifico dell'aggregato e DISTINCT viene applicato dopo il limite.

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

Aggregazione tra righe

Un aggregato normalmente combina i valori verticalmente tra le righe di input. Usare GROUP BY per calcolare un risultato per ogni gruppo.

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

Non mettere un aggregato verticale direttamente dentro un altro nello stesso blocco di interrogazione. Ad esempio, SUM(COUNT(*)) è invalido. Usalo NEXT per separare i passaggi di aggregazione quando devi aggregare un risultato aggregato.

Aggregazione all'interno di un percorso abbinato

Una variabile di spigolo legata da un motivo a lunghezza variabile diventa una lista di gruppi. Un aggregato su quella variabile è orizzontale: calcola un risultato all'interno della lista per ogni percorso corrispondente invece di combinare diverse righe di input.

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

Qui, COUNT(knows) restituisce il numero di archi in ogni percorso corrispondente. Le forme orizzontali di COUNT, SUM, AVG, MIN, MAX, COLLECT_LIST, COLLECT_ONE, e COLLECT_ELEMENTS sono sostenute. COUNT(*) e specifiche FILTER per aggregati o LIMIT non sono forme orizzontali.

Un aggregato orizzontale può essere l'ingresso di un aggregato verticale esterno:

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

In questa query, COUNT(knows) calcola una lunghezza per ogni percorso abbinato e MIN combina tali lunghezze tra le righe di input.

Per esempi orientati al compito, vedi Filtra e aggrega dati di grafi.

Espressioni condizionali

Usa una semplice CASE espressione per confrontare un'espressione con uno o più valori e restituire il risultato associato al primo valore uguale:

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

NULLIF:

NULLIF(a, b)restituisce NULLase b è uguale a , in caso contrario restituisce a.

Esempio:

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

Le espressioni cercate CASE WHEN <predicate> non sono supportate. Per instradare le righe per predicati ed eseguire un'istruzione di query o una procedura annidata per il ramo selezionato, si utilizza un'istruzioneWHEN condizionale.

Funzioni stringa

Usa le funzioni stringa per misurare, trasformare, cercare, confrontare e combinare stringhe di caratteri.

Lunghezza del carattere e caso

Usa queste funzioni per misurare o modificare stringhe di caratteri:

Le mappature Unicode possono modificare la lunghezza o la rappresentazione di una stringa:

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

I risultati sono STRASSErispettivamente , i̇, e strasse, . CASEFOLD non è equivalente a LOWER. Ad esempio, il ripiegamento dei casi mappa ß in ss e mappa le forme Σsigma greche , σ, e ς in σ.

Normalizzare le stringhe

GQL definisce quattro moduli di normalizzazione Unicode:

• Forma di normalizzazione C (NFC), composizione canonica.
• Forma di normalizzazione D (NFD), decomposizione canonica.
• Forma di normalizzazione KC (NFKC), composizione di compatibilità.
• Forma di normalizzazione KD (NFKD), decomposizione di compatibilità.

NORMALIZE(string) di default è NFC. Specificare una forma di normalizzazione come secondo argomento:

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

L'argomentazione deve essere una corda.

Corde di rifinitura

Usare TRIM per rimuovere i caratteri spaziali o un carattere specificato da entrambe le estremità, l'inizio o la fine di una stringa:

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

Il valore personalizzato del trim deve essere esattamente di un byte. I caratteri Unicode multibyte e le stringhe contenenti più caratteri non sono supportati come valori di trim personalizzati. Una sorgente nulla o un valore di trim personalizzato restituisce null.

Corde di giunzione

STRING_JOIN(list [, delimiter]) si unisce a una lista di fili. Il delimitatore predefinito è una virgola seguita da uno spazio:

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

I risultati sono foo, bar, baz e foo-bar-baz. Una lista vuota restituisce una stringa vuota. Una lista nulla, un delimitatore nullo o un elemento di lista nulla restituisce nulla. Ogni elemento di lista non nullo deve essere una stringa.

Funzioni di espressione regolare

Graph fornisce queste funzioni di espressione regolare come estensioni di GQL:

MSFT.REGEXP_LIKE

Ritorna TRUE quando il pattern corrisponde a qualsiasi parte della stringa sorgente. Se non viene trovata alcuna corrispondenza, restituisce FALSE.

source è la stringa da cercare. pattern è abbinata a qualsiasi sottostringa di source a meno che l'espressione stessa non utilizzi ancoraggi come ^ o $. flags cambia il comportamento di abbinamento come descritto nelle regole e opzioni di abbinamento.

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

Il risultato è TRUE.

MSFT.REGEXP_COUNT

Restituisce il numero di corrispondenti. Se non viene trovata alcuna corrispondenza, restituisce 0.

source è la stringa da cercare, e pattern identifica le corrispondenze da contare. start è la posizione Unicode basata su zero in cui può iniziare l'abbinamento. Una partita deve iniziare a questa posizione o dopo. La posizione non diventa un nuovo inizio per i pattern ancorati. flags cambia il comportamento di abbinamento come descritto nelle regole e opzioni di abbinamento.

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

La ricerca inizia dalla posizione 3, la seconda a, quindi vengono conteggiate solo le cifre 3 e 4 . Il risultato è 2.

MSFT.REGEXP_INSTR

Restituisce la posizione a zero di un gruppo selezionato o di cattura.

source è la stringa da ricercare e pattern identifica le corrispondenze. start è la posizione Unicode basata su zero in cui può iniziare l'abbinamento. Una partita deve iniziare a questa posizione o dopo, che non diventa un nuovo inizio della corda per i pattern ancorati.

occurrence seleziona la prima, seconda o successiva corrispondenza non sovrapposta trovata da start. group Seleziona cosa trovare all'interno di quella corrispondenza: 0 seleziona la corrispondenza completa, e un valore positivo seleziona quel gruppo di cattura numerato. return_option determina quale confine della partita o del gruppo selezionato viene restituito: 0 restituisce la sua posizione iniziale e 1 restituisce la posizione immediatamente dopo la sua fine. flags cambia il comportamento di abbinamento come descritto nelle regole e opzioni di abbinamento.

Se non si trova alcuna occorrenza corrispondente, o se il gruppo di cattura selezionato non partecipa a quell'occorrenza, la funzione restituisce -1.

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

La seconda partita inizia in posizione 3, quindi il risultato è 3.

MSFT.REGEXP_SUBSTR

Restituisce il testo di una corrispondenza o di un gruppo di cattura selezionato.

source è la stringa da ricercare e pattern identifica le corrispondenze. start è la posizione Unicode basata su zero in cui può iniziare l'abbinamento. Una partita deve iniziare a questa posizione o dopo, che non diventa un nuovo inizio della corda per i pattern ancorati.

occurrence seleziona la prima, seconda o successiva corrispondenza non sovrapposta trovata da start. group seleziona il testo da restituire da quella corrispondenza: 0 seleziona la corrispondenza completa, e un valore positivo seleziona quel gruppo di cattura numerato. flags cambia il comportamento di abbinamento come descritto nelle regole e opzioni di abbinamento.

Se non si trova alcuna occorrenza corrispondente, o se il gruppo di cattura selezionato non partecipa a quell'occorrenza, la funzione restituisce nullo.

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

La prima occorrenza è la stringa completa, e il gruppo 2 di cattura è 345, quindi il risultato è 345.

MSFT.REGEXP_REPLACE

Sostituisce il testo corrispondente. Per impostazione predefinita, sostituisce ogni corrispondenza e inserisce letteralmente il testo sostitutivo.

source è la stringa da modificare, e pattern identifica le corrispondenti. replacement è il testo inserito per una partita selezionata. EXACT lo inserisce letteralmente; TEMPLATE interpreta i riferimenti di cattura.

start è la posizione Unicode basata su zero in cui può iniziare la sostituzione. Una partita deve iniziare a questa posizione o dopo. Il testo precedente start viene mantenuto invariato, e la posizione non diventa un nuovo inizio della stringa per i pattern ancorati. Imposta occurrence per 0 sostituire ogni corrispondenza da start, oppure su un valore positivo per sostituire solo quella corrispondenza numerata non sovrapposta. Le partite precedenti successive start rimangono invariate quando viene selezionata una specifica occasione. flags cambia il comportamento di abbinamento come descritto nelle regole e opzioni di abbinamento.

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

Solo la seconda corrispondenza della cifra viene sostituita, quindi il risultato è a1b#c3.

Se non si trova alcuna corrispondenza, la stringa sorgente viene restituita invariata.

Per riutilizzare il testo corrispondente nella sostituzione, specifica TEMPLATE. In questa modalità, \0 si \9 riferisce al match completo e al gruppo di cattura, inserendo \\ letteralmente una barra diagonale. Usa una stringa grezza, preceduta da @, per far passare questi riferimenti senza ulteriori sfuggimenti:

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

Il risultato è Smith John.

Regole e opzioni di abbinamento

I pattern utilizzano la sintassi di espressioni regolari di RE2 e corrispondono alle stringhe Unicode. La sorgente può essere qualsiasi espressione di stringa. Il pattern, le flag e la sostituzione devono essere letterali stringa, e le opzioni numeriche devono essere letterali interi senza segno.

Le corrispondenze si trovano da sinistra a destra senza sovrapporsi. Dopo una corrispondenza a lunghezza zero, l'abbinamento avanza di un punto di codice Unicode.

Le posizioni iniziali e le posizioni restituite sono offset di punti di codice Unicode basati su zero. I numeri di occorrenza sono basati su una sola ocorrenza, tranne che occorrenza 0 significa sostituire ogni occorrenza in MSFT.REGEXP_REPLACE.

La seguente tabella elenca i valori predefiniti per gli argomenti opzionali omisti:

Le bandiere opzionali sono:

Combinare flag in una sola stringa, come 'ims'. Una sorgente nulla restituisce nulla. Una flag non supportata, un'espressione regolare non valida, un'opzione di ritorno non valida o un'occorrenza o numero di gruppo non valida restituisce un errore.

Funzioni del grafo

• nodes(path) : restituisce nodi da un valore di percorso.
• edges(path) : restituisce i bordi da un valore di percorso.
• elements(path) : restituisce tutti i nodi e i bordi da un percorso come elenco singolo, in ordine di percorso.
• labels(node_or_edge) : restituisce le etichette di un nodo o di un bordo come elenco di stringhe.
• path_length(path) : restituisce il numero di bordi in un percorso.
• element_id(node_or_edge) - restituisce l'identificatore di nodo o di bordo come stringa opaca.

ELEMENT_ID accetta un nodo o riferimento di bordo e restituisce nullo per un input nullo. Considera la corda restituita come opaca.

Esempio:

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

Funzioni di elenco

• size(list) : restituisce le dimensioni di un valore di elenco.
• trim(list,n) - riduce una lista ad al massimo n degli elementi.

Esempio:

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

Funzioni temporali

• CURRENT_TIMESTAMP : restituisce il valore datetime con zona corrente.
• ZONED_DATETIME(string) - restituisce l'ora di datazione zonata rappresentata da una stringa ISO 8601.
• DURATION(string) - restituisce la durata diurna rappresentata da una stringa di durata ISO 8601.

Esempio:

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

Usa l'operatore di sottrazione per derivare una durata tra due date orari zonati:

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

Funzioni generica

• coalesce(value1, value2, ...) : restituisce il primo valore non Null.
• to_json_string(value) : converte un valore nella relativa rappresentazione di stringa JSON.

Esempio:

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

Contenuti correlati

• Guida al linguaggio GQL
• Valori e tipi valore GQL
• Modelli di grafo
• Filtrare e aggregare i dati del grafo