Questo documento fornisce una panoramica sull'utilizzo del linguaggio di query del grafico con Spanner Graph, inclusa la sintassi per la corrispondenza dei pattern del grafico, e mostra come eseguire query sul grafico. Con Spanner Graph, puoi eseguire query per trovare pattern, attraversare relazioni e ottenere informazioni dai dati del grafico delle proprietà.
Gli esempi riportati in questo documento utilizzano lo schema del grafico che crei in Configura ed esegui query su Spanner Graph. Questo schema è illustrato nel seguente diagramma:
Eseguire una query Spanner Graph
Puoi utilizzare la console Google Cloud , Google Cloud CLI, le librerie client, l'API REST o l'API RPC per eseguire una query Spanner Graph.
Console Google Cloud
I seguenti passaggi mostrano come eseguire una query nella console
Google Cloud . Questi passaggi presuppongono che tu disponga di un'istanza denominata test-instance che contiene un database denominato example-db. Per informazioni su come creare un'istanza con un database, consulta Configurare ed eseguire query su Spanner Graph.
Nella console Google Cloud , vai alla pagina Istanze Spanner.
Fai clic sull'istanza denominata
test-instance.In Database, fai clic sul database denominato
example-db.Apri Spanner Studio, quindi fai clic su Nuova scheda o utilizza la scheda dell'editor.
Inserisci una query nell'editor di query.
Fai clic su Esegui.
Interfaccia a riga di comando gcloud
Per inviare query utilizzando lo strumento a riga di comando gcloud CLI, procedi nel seguente modo:
Se non è già installato, installa gcloud CLI.
In gcloud CLI, esegui questo comando:
Per saperne di più, consulta la guida rapida di Spanner CLI.
API REST
Per inviare query utilizzando l'API REST, utilizza uno dei seguenti comandi:
Per saperne di più, consulta Eseguire query sui dati utilizzando l'API REST e Inizia a utilizzare Spanner con REST.
API RPC
Per inviare query utilizzando l'API RPC, utilizza uno dei seguenti comandi:
Librerie client
Per scoprire di più su come eseguire una query con una libreria client Spanner, consulta quanto segue:
- Esegui query utilizzando la libreria client C++ di Spanner
- Esegui query utilizzando la libreria client C# di Spanner
- Esegui query utilizzando la libreria client Go di Spanner
- Esegui query utilizzando la libreria client Java di Spanner
- Esegui query utilizzando la libreria client Node.js di Spanner
- Esegui query utilizzando la libreria client PHP di Spanner
- Esegui query utilizzando la libreria client Python di Spanner
- Esegui query utilizzando la libreria client Ruby di Spanner
Per saperne di più sulle librerie client di Spanner, consulta la panoramica delle librerie client di Spanner.
Visualizzare i risultati delle query Spanner Graph
Puoi visualizzare una rappresentazione visiva dei risultati della query Spanner Graph in Spanner Studio nella console Google Cloud . Una visualizzazione delle query ti consente di vedere come sono collegati gli elementi restituiti (nodi e archi). In questo modo puoi scoprire pattern, dipendenze e anomalie difficili da individuare quando visualizzi i risultati in una tabella. Per visualizzare una visualizzazione di una query, la query deve restituire nodi completi in formato JSON. In caso contrario, puoi visualizzare i risultati della query solo in formato tabellare. Per saperne di più, consulta Utilizzare le visualizzazioni delle query Spanner Graph.
Struttura della query Spanner Graph
Una query Spanner Graph è costituita da diversi componenti, come il nome del grafico delle proprietà, i pattern di nodi e archi e i quantificatori. Utilizzi questi componenti per creare una query che trova pattern specifici nel grafico. Ogni componente è descritto nella sezione Corrispondenza dei pattern del grafico di questo documento.
La query nella Figura 2 mostra la struttura di base di una
query Spanner Graph. La query inizia specificando il grafico di destinazione, FinGraph, utilizzando la clausola GRAPH. La clausola MATCH definisce quindi il
pattern da cercare. In questo caso, si tratta di un nodo Person connesso a un nodo Account tramite un edge Owns. La clausola RETURN specifica quali proprietà dei nodi corrispondenti restituire.
Corrispondenza di pattern del grafico
La corrispondenza dei pattern del grafico trova pattern specifici all'interno del grafico. I pattern più semplici sono i pattern degli elementi, come i pattern dei nodi che corrispondono ai nodi e i pattern dei bordi che corrispondono ai bordi.
Pattern dei nodi
Un pattern di nodi corrisponde ai nodi del grafico. Questo pattern contiene parentesi corrispondenti, che possono includere facoltativamente una variabile di pattern del grafico, un'espressione di etichetta e filtri delle proprietà.
Trovare tutti i nodi
La seguente query restituisce tutti i nodi del grafico. La variabile n, una variabile
del pattern del grafico, si associa ai nodi corrispondenti. In questo caso, il pattern del nodo
corrisponde a tutti i nodi del grafico.
GRAPH FinGraph
MATCH (n)
RETURN LABELS(n) AS label, n.id;
Questa query restituisce label e id:
| etichetta | id |
|---|---|
| Account | 7 |
| Account | 16 |
| Account | 20 |
| Persona | 1 |
| Persona | 2 |
| Persona | 3 |
Trovare tutti i nodi con un'etichetta specifica
La seguente query corrisponde a tutti i nodi del grafico che hanno l'Person
etichetta.
La query restituisce le proprietà label, id e name dei nodi corrispondenti.
GRAPH FinGraph
MATCH (p:Person)
RETURN LABELS(p) AS label, p.id, p.name;
Questa query restituisce le seguenti proprietà dei nodi corrispondenti:
| etichetta | id | nome |
|---|---|---|
| Persona | 1 | Alex |
| Persona | 2 | Dana |
| Persona | 3 | Lee |
Trova tutti i nodi che corrispondono a un'espressione di etichetta
Puoi creare un'espressione di etichetta con uno o più operatori logici. Ad esempio, la seguente query corrisponde a tutti i nodi del grafico che hanno l'etichetta Person o Account. La variabile
pattern del grafico n espone tutte le
proprietà
dei nodi con l'etichetta Person o Account.
GRAPH FinGraph
MATCH (n:Person|Account)
RETURN LABELS(n) AS label, n.id, n.birthday, n.create_time;
Nei seguenti risultati di questa query:
- Tutti i nodi hanno la proprietà
id. - I nodi corrispondenti all'etichetta
Accounthanno la proprietàcreate_time, ma non hanno la proprietàbirthday. La proprietàbirthdayèNULLper questi nodi. - I nodi corrispondenti all'etichetta
Personhanno la proprietàbirthday, ma non hanno la proprietàcreate_time. La proprietàcreate_timeèNULLper questi nodi.
| etichetta | id | compleanno | create_time |
|---|---|---|---|
| Account | 7 | NULL | 2020-01-10T14:22:20.222Z |
| Account | 16 | NULL | 2020-01-28T01:55:09.206Z |
| Account | 20 | NULL | 2020-02-18T13:44:20.655Z |
| Persona | 1 | 1991-12-21T08:00:00Z | NULL |
| Persona | 2 | 1980-10-31T08:00:00Z | NULL |
| Persona | 3 | 1986-12-07T08:00:00Z | NULL |
Trova tutti i nodi corrispondenti all'espressione dell'etichetta e al filtro delle proprietà
Questa query corrisponde a tutti i nodi del grafico che hanno l'etichetta Person e in cui
la proprietà id è uguale a 1.
GRAPH FinGraph
MATCH (p:Person {id: 1})
RETURN LABELS(p) AS label, p.id, p.name, p.birthday;
Ecco i risultati della query:
| etichetta | id | nome | compleanno |
|---|---|---|---|
| Persona | 1 | Alex | 1991-12-21T08:00:00Z |
Puoi utilizzare la clausola WHERE per formare condizioni di filtro più complesse su
etichette e proprietà.
La seguente query utilizza la clausola WHERE per formare una condizione di filtro più complessa sulle proprietà. Corrisponde a tutti i nodi del grafico che hanno l'etichetta Person e la proprietà birthday è precedente a 1990-01-10.
GRAPH FinGraph
MATCH (p:Person WHERE p.birthday < '1990-01-10')
RETURN LABELS(p) AS label, p.name, p.birthday;
Ecco i risultati della query:
| etichetta | nome | compleanno |
|---|---|---|
| Persona | Dana | 1980-10-31T08:00:00Z |
| Persona | Lee | 1986-12-07T08:00:00Z |
Pattern del bordo
Un pattern di archi corrisponde agli archi o alle relazioni tra i nodi. I pattern del bordo sono
racchiusi tra parentesi quadre ([]) e includono simboli come -, -> o
<- per indicare le direzioni. Un pattern edge può includere facoltativamente una variabile
pattern grafico a cui associare gli edge corrispondenti.
Trova tutti i bordi con etichette corrispondenti
Questa query restituisce tutti gli archi nel grafico con l'etichetta Transfers. La query
associa la variabile del pattern del grafico e agli archi corrispondenti.
GRAPH FinGraph
MATCH -[e:Transfers]->
RETURN e.Id as src_account, e.order_number
Ecco i risultati della query:
| src_account | order_number |
|---|---|
| 7 | 304330008004315 |
| 7 | 304120005529714 |
| 16 | 103650009791820 |
| 20 | 304120005529714 |
| 20 | 302290001255747 |
Trova tutti gli archi corrispondenti all'espressione dell'etichetta e al filtro delle proprietà
Il pattern degli archi di questa query utilizza un'espressione di etichetta e un filtro delle proprietà per trovare
tutti gli archi etichettati con Transfers che corrispondono a un order_number specificato.
GRAPH FinGraph
MATCH -[e:Transfers {order_number: "304120005529714"}]->
RETURN e.Id AS src_account, e.order_number
Ecco i risultati della query:
| src_account | order_number |
|---|---|
| 7 | 304120005529714 |
| 20 | 304120005529714 |
Trova tutti i bordi utilizzando qualsiasi pattern di bordi di direzione
Puoi utilizzare il pattern di arco any direction (-[]-) in una query per trovare gli archi
in entrambe le direzioni. La seguente query trova tutti i trasferimenti con un account
bloccato.
GRAPH FinGraph
MATCH (account:Account)-[transfer:Transfers]-(:Account {is_blocked:true})
RETURN transfer.order_number, transfer.amount;
Ecco i risultati della query:
| order_number | quantità |
|---|---|
| 304330008004315 | 300 |
| 304120005529714 | 100 |
| 103650009791820 | 300 |
| 302290001255747 | 200 |
Pattern del percorso
Un pattern di percorso è costituito da pattern di nodi e archi alternati.
Trovare tutti i percorsi da un nodo specifico utilizzando un pattern di percorso
La seguente query trova tutti i trasferimenti a un account avviati da un account
di proprietà di Person con id uguale a 2.
Ogni risultato corrispondente rappresenta un percorso da Person {id: 2} a un Account connesso tramite il bordo Owns a un altro Account tramite il bordo Transfers.
GRAPH FinGraph
MATCH
(p:Person {id: 2})-[:Owns]->(account:Account)-[t:Transfers]->
(to_account:Account)
RETURN
p.id AS sender_id, account.id AS from_id, to_account.id AS to_id;
Ecco i risultati della query:
| sender_id | from_id | to_id |
|---|---|---|
| 2 | 20 | 7 |
| 2 | 20 | 16 |
Pattern del percorso quantificati
Un pattern quantificato ripete un pattern all'interno di un intervallo specificato.
Trovare un pattern di bordo quantificato
Per trovare percorsi di lunghezza variabile, puoi applicare un quantificatore a un pattern
arco. La seguente query lo dimostra trovando gli account di destinazione
che si trovano a una distanza di 1-3 trasferimenti da un'origine Account con un id di
7.
La query applica il quantificatore {1, 3} al pattern del bordo
-[e:Transfers]->. Questa istruzione indica alla query di trovare i percorsi che ripetono il
pattern di arco Transfers una, due o tre volte. La clausola WHERE viene utilizzata per
escludere l'account di origine dai risultati. La funzione ARRAY_LENGTH viene utilizzata
per accedere a group variable e. Per ulteriori informazioni,
vedi Variabile del gruppo di accesso.
GRAPH FinGraph
MATCH (src:Account {id: 7})-[e:Transfers]->{1, 3}(dst:Account)
WHERE src != dst
RETURN src.id AS src_account_id, ARRAY_LENGTH(e) AS path_length, dst.id AS dst_account_id;
Ecco i risultati della query:
| src_account_id | path_length | dst_account_id |
|---|---|---|
| 7 | 1 | 16 |
| 7 | 1 | 16 |
| 7 | 1 | 16 |
| 7 | 3 | 16 |
| 7 | 3 | 16 |
| 7 | 2 | 20 |
| 7 | 2 | 20 |
Alcune righe nei risultati sono ripetute. Questo perché possono esistere più percorsi che corrispondono al pattern tra gli stessi nodi di origine e destinazione e la query li restituisce tutti.
Trovare una corrispondenza con un pattern di percorso quantificato
La seguente query trova i percorsi tra i nodi Account con uno o due
Transfers archi tramite account intermedi bloccati.
Il pattern di percorso tra parentesi è quantificato e la relativa clausola WHERE specifica
le condizioni per il pattern ripetuto.
GRAPH FinGraph
MATCH
(src:Account)
((a:Account)-[:Transfers]->(b:Account {is_blocked:true}) WHERE a != b){1,2}
-[:Transfers]->(dst:Account)
RETURN src.id AS src_account_id, dst.id AS dst_account_id;
Ecco i risultati della query:
| src_account_id | dst_account_id |
|---|---|
| 7 | 20 |
| 7 | 20 |
| 20 | 20 |
Variabili di gruppo
Una variabile di pattern del grafico dichiarata in un pattern quantificato diventa una variabile di gruppo quando viene accessibile al di fuori di questo pattern. Poi si lega a un array di elementi del grafico corrispondenti.
Puoi accedere a una variabile di gruppo come array. Gli elementi del grafico vengono conservati nell'ordine in cui compaiono lungo i percorsi corrispondenti. Puoi aggregare una variabile di gruppo utilizzando l'aggregazione orizzontale.
Variabile del gruppo di accesso
Nel seguente esempio, si accede alla variabile e come segue:
- Una variabile del pattern del grafico associata a un singolo arco nella clausola
WHEREe.amount > 100quando si trova all'interno del pattern quantificato. - Una variabile di gruppo associata a un array di elementi perimetrali in
ARRAY_LENGTH(e)nell'istruzioneRETURNquando si trova al di fuori del pattern quantificato. - Una variabile di gruppo associata a un array di elementi perimetrali, aggregata da
SUM(e.amount)al di fuori del pattern quantificato. Questo è un esempio di aggregazione orizzontale.
GRAPH FinGraph
MATCH
(src:Account {id: 7})-[e:Transfers WHERE e.amount > 100]->{0,2}
(dst:Account)
WHERE src.id != dst.id
LET total_amount = SUM(e.amount)
RETURN
src.id AS src_account_id, ARRAY_LENGTH(e) AS path_length,
total_amount, dst.id AS dst_account_id;
Ecco i risultati della query:
| src_account_id | path_length | total_amount | dst_account_id |
|---|---|---|---|
| 7 | 1 | 300 | 16 |
| 7 | 2 | 600 | 20 |
Prefissi di ricerca del percorso
Per limitare i percorsi corrispondenti all'interno di gruppi che condividono nodi di origine e destinazione,
puoi utilizzare il ANY o il ANY SHORTEST come
prefisso di ricerca.
Puoi applicare questi prefissi solo prima di un intero pattern di percorso e non puoi
applicarli all'interno delle parentesi.
Corrispondenza tramite ANY
La seguente query trova tutti gli account unici raggiungibili che si trovano a uno o due
Transfers di distanza da un determinato nodo Account.
Il prefisso di ricerca del percorso ANY garantisce che la query restituisca un solo percorso
tra una coppia unica di nodi src e dst Account. Nell'esempio
seguente, anche se puoi raggiungere il nodo Account con {id: 16} in due
percorsi diversi dal nodo di origine Account, la query restituisce un solo percorso.
GRAPH FinGraph
MATCH ANY (src:Account {id: 7})-[e:Transfers]->{1,2}(dst:Account)
LET ids_in_path = ARRAY_CONCAT(ARRAY_AGG(e.Id), [dst.Id])
RETURN src.id AS src_account_id, dst.id AS dst_account_id, ids_in_path;
Ecco i risultati della query:
| src_account_id | dst_account_id | ids_in_path |
|---|---|---|
| 7 | 16 | 7,16 |
| 7 | 20 | 7,16,20 |
Pattern del grafico
Un pattern del grafico è costituito da uno o più pattern di percorso, separati da una virgola (,).
I pattern del grafico possono contenere una clausola WHERE, che consente di accedere a tutte le variabili del pattern del grafico nei pattern di percorso per formare condizioni di filtro. Ogni pattern di percorso produce una raccolta di percorsi.
Corrispondenza utilizzando un pattern del grafico
La seguente query identifica gli account intermediari e i relativi proprietari coinvolti in transazioni di importo superiore a 200, tramite le quali i fondi vengono trasferiti da un account di origine a un account bloccato.
I seguenti pattern del percorso formano il pattern del grafico:
- Il primo pattern trova i percorsi in cui il trasferimento avviene da un account a un account bloccato utilizzando un account intermedio.
- Il secondo pattern trova i percorsi da un account al suo proprietario.
La variabile interm funge da collegamento comune tra i due pattern di percorso, il che
richiede che interm faccia riferimento allo stesso nodo elemento in entrambi i pattern di percorso. In questo modo
viene creata un'operazione di equi-join basata sulla variabile interm.
GRAPH FinGraph
MATCH
(src:Account)-[t1:Transfers]->(interm:Account)-[t2:Transfers]->(dst:Account),
(interm)<-[:Owns]-(p:Person)
WHERE dst.is_blocked = TRUE AND t1.amount > 200 AND t2.amount > 200
RETURN
src.id AS src_account_id, dst.id AS dst_account_id,
interm.id AS interm_account_id, p.id AS owner_id;
Ecco i risultati della query:
| src_account_id | dst_account_id | interm_account_id | owner_id |
|---|---|---|---|
| 20 | 16 | 7 | 1 |
Istruzioni di query lineari
Puoi concatenare più istruzioni del grafico per formare un'istruzione di query lineare. Le istruzioni vengono eseguite nello stesso ordine in cui vengono visualizzate nella query.
Ogni istruzione prende come input l'output dell'istruzione precedente. L'input è vuoto per la prima istruzione.
L'output dell'ultima istruzione è il risultato finale.
Ad esempio, puoi utilizzare istruzioni di query lineari per trovare il trasferimento massimo a un account bloccato. La seguente query trova l'account e il relativo proprietario con il trasferimento in uscita più grande a un account bloccato.
GRAPH FinGraph
MATCH (src_account:Account)-[transfer:Transfers]->(dst_account:Account {is_blocked:true})
ORDER BY transfer.amount DESC
LIMIT 1
MATCH (src_account:Account)<-[owns:Owns]-(owner:Person)
RETURN src_account.id AS account_id, owner.name AS owner_name;
La tabella seguente illustra questo processo mostrando i risultati intermedi passati tra ogni istruzione. Per brevità, vengono mostrate solo alcune proprietà.
| Affermazione | Risultato intermedio (abbreviato) | ||||||||||||
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
MATCH
(src_account:Account)
-[transfer:Transfers]->
(dst_account:Account {is_blocked:true})
|
|
||||||||||||
ORDER BY transfer.amount DESC |
|
||||||||||||
LIMIT 1 |
|
||||||||||||
MATCH
(src_account:Account)
<-[owns:Owns]-
(owner:Person)
|
|
||||||||||||
RETURN
src_account.id AS account_id,
owner.name AS owner_name
|
|
Ecco i risultati della query:
| account_id | owner_name |
|---|---|
7 |
Alex |
Dichiarazione di restituzione
L'istruzione RETURN
specifica cosa restituire dai pattern corrispondenti. Può accedere
alle variabili del pattern del grafico e includere espressioni e altre clausole, come
ORDER BY e GROUP BY.
Spanner Graph non supporta la restituzione di elementi del grafico come risultati della query. Per
restituire l'intero elemento del grafico, utilizza la
funzione TO_JSON
o la
funzione SAFE_TO_JSON.
Tra queste due funzioni, ti consigliamo di utilizzare SAFE_TO_JSON.
Restituisce gli elementi del grafico come JSON
GRAPH FinGraph
MATCH (n:Account {id: 7})
-- Returning a graph element in the final results is NOT allowed. Instead, use
-- the TO_JSON function or explicitly return the graph element's properties.
RETURN TO_JSON(n) AS n;
GRAPH FinGraph
MATCH (n:Account {id: 7})
-- Certain fields in the graph elements, such as TOKENLIST, can't be returned
-- in the TO_JSON function. In those cases, use the SAFE_TO_JSON function instead.
RETURN SAFE_TO_JSON(n) AS n;
Ecco i risultati della query:
| n |
|---|
{"identifier":"mUZpbkdyYXBoLkFjY291bnQAeJEO","kind":"node","labels":["Account"],"properties":{"create_time":"2020-01-10T14:22:20.222Z","id":7,"is_blocked":false,"nick_name":"Vacation
Fund"}} |
Creazione di query più grandi con la parola chiave NEXT
Puoi concatenare più istruzioni di query lineari del grafico utilizzando la parola chiave NEXT.
La prima istruzione riceve un input vuoto e l'output di ogni istruzione successiva
diventa l'input per la successiva.
L'esempio seguente trova il proprietario dell'account con il maggior numero di trasferimenti in entrata concatenando più istruzioni lineari del grafico. Puoi utilizzare la stessa
variabile, ad esempio account, per fare riferimento allo stesso elemento del grafico in
più istruzioni lineari.
GRAPH FinGraph
MATCH (:Account)-[:Transfers]->(account:Account)
RETURN account, COUNT(*) AS num_incoming_transfers
GROUP BY account
ORDER BY num_incoming_transfers DESC
LIMIT 1
NEXT
MATCH (account:Account)<-[:Owns]-(owner:Person)
RETURN account.id AS account_id, owner.name AS owner_name, num_incoming_transfers;
Ecco i risultati della query:
| account_id | owner_name | num_incoming_transfers |
|---|---|---|
16 |
Lee |
3 |
Funzioni ed espressioni
Puoi utilizzare tutte le funzioni (sia aggregate che scalari), gli operatori e le espressioni condizionali di GoogleSQL nelle query Spanner Graph. Spanner Graph supporta anche funzioni e operatori specifici per i grafici.
Funzioni e operatori integrati
In GQL vengono utilizzate le seguenti funzioni e operatori:
PROPERTY_EXISTS(n, birthday): restituisce un valore che indica senha la proprietàbirthday.LABELS(n): restituisce le etichette dincome definite nello schema del grafico.PROPERTY_NAMES(n): Restituisce i nomi delle proprietà din.TO_JSON(n): restituiscenin formato JSON. Per saperne di più, consulta la funzioneTO_JSON.
il predicato PROPERTY_EXISTS, la funzione LABELS e la funzione TO_JSON, nonché altre funzioni integrate come ARRAY_AGG e CONCAT.
GRAPH FinGraph
MATCH (person:Person)-[:Owns]->(account:Account)
RETURN person, ARRAY_AGG(account.nick_name) AS accounts
GROUP BY person
NEXT
RETURN
LABELS(person) AS labels,
TO_JSON(person) AS person,
accounts,
CONCAT(person.city, ", ", person.country) AS location,
PROPERTY_EXISTS(person, is_blocked) AS is_blocked_property_exists,
PROPERTY_EXISTS(person, name) AS name_property_exists
LIMIT 1;
Ecco i risultati della query:
| is_blocked_property_exists | name_property_exists | etichette | account | località | persona |
|---|---|---|---|---|---|
false |
true |
Person |
["Vacation Fund"] |
Adelaide, Australia |
{"identifier":"mUZpbkdyYXBoLlBlcnNvbgB4kQI=","kind":"node","labels":["Person"],"properties":{"birthday":"1991-12-21T08:00:00Z","city":"Adelaide","country":"Australia","id":1,"name":"Alex"}} |
Sottoquery
Una subquery è una query nidificata in un'altra query. I seguenti elenchi contengono le regole per le sottoquery di Spanner Graph:
- Una sottoquery è racchiusa tra una coppia di parentesi graffe
{}. - Una sottoquery potrebbe iniziare con la clausola
GRAPHiniziale per specificare il grafico nell'ambito. Il grafico specificato non deve essere lo stesso utilizzato nella query esterna. - Quando la clausola
GRAPHviene omessa nella sottoquery, si verifica quanto segue:- Il grafico nell'ambito viene dedotto dal contesto della query esterna più vicino.
- La sottoquery deve iniziare con un'istruzione di corrispondenza del pattern del grafico
con
MATCH.
- Una variabile di pattern del grafico dichiarata al di fuori dell'ambito della sottoquery non può essere dichiarata di nuovo all'interno della sottoquery, ma può essere indicata in espressioni o funzioni all'interno della sottoquery.
Utilizza una sottoquery per trovare il numero totale di trasferimenti da ogni account
La seguente query illustra l'utilizzo della sottoquery VALUE. La sottoquery è
racchiusa tra parentesi graffe {} con il prefisso della parola chiave VALUE. La query restituisce il numero totale
di trasferimenti avviati da un account.
GRAPH FinGraph
MATCH (p:Person)-[:Owns]->(account:Account)
RETURN p.name, account.id AS account_id, VALUE {
MATCH (a:Account)-[transfer:Transfers]->(:Account)
WHERE a = account
RETURN COUNT(transfer) AS num_transfers
} AS num_transfers;
Ecco i risultati della query:
| nome | account_id | num_transfers |
|---|---|---|
Alex |
7 |
2 |
Dana |
20 |
2 |
Lee |
16 |
1 |
Per un elenco delle espressioni di sottoquery supportate, consulta Sottoquery di Spanner Graph.
Utilizza una sottoquery per trovare gli account di proprietà di ogni persona
La seguente query utilizza l'istruzione CALL con una sottoquery inline. L'istruzione MATCH
(p:Person) crea una tabella con una singola colonna denominata p.
Ogni riga di questa tabella contiene un nodo Person. L'istruzione CALL (p)
esegue la sottoquery inclusa per ogni riga di questa tabella di lavoro. La sottoquery
trova gli account di proprietà di ogni persona corrispondente p. Più account della stessa persona sono ordinati per ID account.
L'esempio dichiara la variabile del nodo con ambito esterno p dalla clausola MATCH
(p:Person). L'istruzione CALL (p) fa riferimento a questa variabile. Questa
dichiarazione consente di dichiarare nuovamente o dichiarare più volte la variabile nodo in un pattern di percorso della sottoquery. In questo modo, le variabili del nodo p interno ed esterno
vengono associate allo stesso nodo Person nel grafico. Se l'istruzione CALL
non dichiara la variabile del nodo p, la sottoquery considera la variabile
dichiarata nuovamente p come una nuova variabile. Questa nuova variabile è indipendente dalla
variabile con ambito esterno e la sottoquery non la dichiara più volte perché
restituisce risultati diversi. Per saperne di più, consulta la
CALL
dichiarazione.
GRAPH FinGraph
MATCH (p:Person)
CALL (p) {
MATCH (p)-[:Owns]->(a:Account)
RETURN a.Id AS account_Id
ORDER BY account_Id
}
RETURN p.name AS person_name, account_Id
ORDER BY person_name, account_Id;
Risultato
| person_name | account_Id |
|---|---|
| Alex | 7 |
| Dana | 20 |
| Lee | 16 |
Parametri di query
Puoi eseguire query su Spanner Graph con parametri. Per saperne di più, consulta la sintassi e scopri come eseguire query sui dati con parametri nelle librerie client di Spanner.
La seguente query illustra l'utilizzo dei parametri di ricerca.
GRAPH FinGraph
MATCH (person:Person {id: @id})
RETURN person.name;
Eseguire query su grafici e tabelle insieme
Puoi utilizzare le query Graph insieme a SQL per accedere alle informazioni dei grafici e delle tabelle in un'unica istruzione.
L'operatore GRAPH_TABLE accetta una query del grafico lineare e restituisce il risultato in
un formato tabellare che può essere integrato in una query SQL. Questa interoperabilità
consente di arricchire i risultati delle query del grafico con contenuti non grafici e viceversa.
Ad esempio, puoi creare una tabella CreditReports e inserire alcuni report
creditizi, come mostrato nell'esempio seguente:
CREATE TABLE CreditReports (
person_id INT64 NOT NULL,
create_time TIMESTAMP NOT NULL,
score INT64 NOT NULL,
) PRIMARY KEY (person_id, create_time);
INSERT INTO CreditReports (person_id, create_time, score)
VALUES
(1,"2020-01-10 06:22:20.222", 700),
(2,"2020-02-10 06:22:20.222", 800),
(3,"2020-03-10 06:22:20.222", 750);
Successivamente, puoi identificare persone specifiche tramite la corrispondenza dei pattern del grafico in
GRAPH_TABLE e unire i risultati della query del grafico alla tabella CreditReports per
recuperare i punteggi di credito.
SELECT
gt.person.id,
credit.score AS latest_credit_score
FROM GRAPH_TABLE(
FinGraph
MATCH (person:Person)-[:Owns]->(:Account)-[:Transfers]->(account:Account {is_blocked:true})
RETURN DISTINCT person
) AS gt
JOIN CreditReports AS credit
ON gt.person.id = credit.person_id
ORDER BY credit.create_time;
Ecco i risultati della query:
| person_id | latest_credit_score |
|---|---|
1 |
700 |
2 |
800 |
Passaggi successivi
Scopri le best practice per l'ottimizzazione delle query.