Übersicht über Graph-Abfragen

Dieses Dokument bietet einen Überblick über die Graph Query Language (GQL) und beschreibt, wie Sie Graph-Abfragen für BigQuery Graph schreiben. Sie können Grafabfragen ausführen, um Muster zu finden, Beziehungen zu durchlaufen und Erkenntnisse aus Ihrem Property-Diagramm zu gewinnen. Die Beispiele in diesem Dokument beziehen sich auf ein Diagramm namens FinGraph, in dem die Beziehungen zwischen Personen, den Konten, die sie besitzen, und Überweisungen zwischen Konten dargestellt sind. Informationen zur Definition des Diagramms finden Sie unter FinGraph-Beispiel.

Abfragestruktur

Eine Diagrammabfrage besteht aus dem Namen des Diagramms, gefolgt von einer oder mehreren linearen Abfrageanweisungen. Jede lineare Abfrage enthält eine oder mehrere Anweisungen, mit denen Sie Graphdaten verarbeiten können, um Musterübereinstimmungen zu finden, Variablen zu definieren, Zwischenergebnisse zu filtern und zu transformieren und Ergebnisse zurückzugeben. Sie führen eine Graphabfrage genauso aus wie eine SQL-Abfrage in BigQuery.

Beispiel für die Struktur einer Graphabfrage.
Beispiel für die Struktur einer Graph-Abfrage.

Musterabgleich für Grafiken

Mit Mustervergleich für Grafiken lassen sich bestimmte Muster in Ihrem Diagramm finden. Die einfachsten Muster sind Elementmuster, z. B. Knotenmuster, die mit Knoten übereinstimmen, und Kantenmuster, die mit Kanten übereinstimmen.

Knotenmuster

Ein Knotenmuster entspricht Knoten in Ihrem Diagramm. Dieses Muster enthält übereinstimmende Klammern, die optional eine Graphmuster-Variable, einen Label-Ausdruck und Property-Filter enthalten können.

Alle Knoten finden

Die folgende Abfrage gibt alle Knoten im Diagramm zurück. Die Variable n, eine Variable für das Diagrammmuster, wird an die übereinstimmenden Knoten gebunden. In diesem Fall entspricht das Knotenmuster allen Knoten im Diagramm.

GRAPH graph_db.FinGraph
MATCH (n)
RETURN LABELS(n) AS label, n.id;

Diese Abfrage gibt label und id zurück:

label id
Account 7
Account 16
Account 20
Person 1
Person 2
Person 3

Alle Knoten mit einem bestimmten Label finden

Die folgende Abfrage stimmt mit allen Knoten im Diagramm überein, die das Person-Label haben. Die Abfrage gibt das Label und einige Attribute der übereinstimmenden Knoten zurück.

GRAPH graph_db.FinGraph
MATCH (p:Person)
RETURN LABELS(p) AS label, p.id, p.name;

Diese Abfrage gibt die folgenden Eigenschaften der übereinstimmenden Knoten zurück:

label id name
Person 1 Alex
Person 2 Dana
Person 3 Lee

Alle Knoten finden, die einem Label-Ausdruck entsprechen

Sie können einen Label-Ausdruck mit einem oder mehreren logischen Operatoren erstellen. Die folgende Abfrage entspricht beispielsweise allen Knoten im Diagramm, die entweder das Label Person oder Account haben. Die Graphmustervariable n macht alle Attribute von Knoten mit dem Label Person oder Account verfügbar.

GRAPH graph_db.FinGraph
MATCH (n:Person|Account)
RETURN LABELS(n) AS label, n.id, n.birthday, n.create_time;

Beachten Sie in den Ergebnissen dieser Abfrage Folgendes:

  • Alle Knoten haben das Attribut id.
  • Knoten, die dem Label Account entsprechen, haben die Property create_time, aber nicht die Property birthday. Das Attribut birthday ist für diese Knoten NULL.
  • Knoten, die dem Label Person entsprechen, haben das Attribut birthday, aber nicht das Attribut create_time. Das Attribut create_time ist für diese Knoten NULL.
label id birthday 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
Person 1 1991-12-21T08:00:00Z NULL
Person 2 1980-10-31T08:00:00Z NULL
Person 3 1986-12-07T08:00:00Z NULL

Alle Knoten finden, die dem Label-Ausdruck und dem Eigenschaftsfilter entsprechen

Die folgende Abfrage entspricht allen Knoten im Diagramm, die das Label Person und das Attribut id mit dem Wert 1 haben:

GRAPH graph_db.FinGraph
MATCH (p:Person {id: 1})
RETURN LABELS(p) AS label, p.id, p.name, p.birthday;

Das Ergebnis sieht etwa so aus:

label id name birthday
Person 1 Alex 1991-12-21T08:00:00Z

Mit der WHERE-Klausel können Sie komplexere Filterbedingungen für Labels und Attribute erstellen.

In der folgenden Abfrage wird die WHERE-Klausel verwendet, um Knoten zu filtern, für die das Attribut birthday vor 1990-01-10 liegt:

GRAPH graph_db.FinGraph
MATCH (p:Person WHERE p.birthday < '1990-01-10')
RETURN LABELS(p) AS label, p.name, p.birthday;

Das Ergebnis sieht etwa so aus:

label name birthday
Person Dana 1980-10-31T08:00:00Z
Person Lee 1986-12-07T08:00:00Z

Edge-Muster

Ein Kantenmuster entspricht Kanten oder Beziehungen zwischen Knoten. Kantenmuster werden in eckige Klammern ([]) gesetzt und enthalten Symbole wie -, -> oder <-, um Richtungen anzugeben. Ein Kantenmuster kann optional eine Graphmustervariable enthalten, die an übereinstimmende Kanten gebunden wird.

Alle Kanten mit übereinstimmenden Labels finden

Diese Abfrage gibt alle Kanten im Diagramm mit dem Label Transfers zurück. Mit der Abfrage wird die Variable e des Diagrammmusters an die übereinstimmenden Kanten gebunden.

GRAPH graph_db.FinGraph
MATCH -[e:Transfers]->
RETURN e.Id as src_account, e.order_number;

Das Ergebnis sieht etwa so aus:

src_account order_number
7 304330008004315
7 304120005529714
16 103650009791820
20 304120005529714
20 302290001255747

Alle Kanten finden, die dem Label-Ausdruck und dem Eigenschaftsfilter entsprechen

Das Kantenmuster in der folgenden Abfrage verwendet einen Labelausdruck und einen Eigenschaftsfilter, um alle Kanten mit dem Label Transfers zu finden, die einer bestimmten Bestellnummer entsprechen:

GRAPH graph_db.FinGraph
MATCH -[e:Transfers {order_number: "304120005529714"}]->
RETURN e.Id AS src_account, e.order_number;

Das Ergebnis sieht etwa so aus:

src_account order_number
7 304120005529714
20 304120005529714

Alle Kanten mit einem beliebigen Richtungskantenmuster finden

Sie können das any direction-Kantenmuster (-[]-) in einer Abfrage verwenden, um Kanten in beide Richtungen abzugleichen. Mit der folgenden Abfrage werden alle Überweisungen mit einem gesperrten Konto gefunden:

GRAPH graph_db.FinGraph
MATCH (account:Account)-[transfer:Transfers]-(:Account {is_blocked:true})
RETURN transfer.order_number, transfer.amount;

Das Ergebnis sieht etwa so aus:

order_number amount
304330008004315 300
304120005529714 100
103650009791820 300
302290001255747 200

Pfadmuster

Ein Pfadmuster besteht aus abwechselnden Knoten- und Kantenmustern.

Alle Pfade von einem bestimmten Knoten mit einem Pfadmuster finden

Mit der folgenden Abfrage werden alle Überweisungen an ein Konto gefunden, die von einem Konto mit id gleich 2 initiiert wurden, das Person gehört.

Jedes übereinstimmende Ergebnis stellt einen Pfad von einem Person-Knoten dar, wenn id gleich 2 ist, über einen verbundenen Account-Knoten mit einer Owns-Kante zu einem anderen Account-Knoten mit einer Transfers-Kante.

GRAPH graph_db.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;

Das Ergebnis sieht etwa so aus:

sender_id from_id to_id
2 20 7
2 20 16

Quantifizierte Pfadmuster

Ein quantifiziertes Muster wiederholt ein Muster innerhalb eines angegebenen Bereichs.

Quantifiziertes Kantenmuster abgleichen

Wenn Sie Pfade mit variabler Länge finden möchten, können Sie einen Quantor auf ein Kantenmuster anwenden. Die folgende Abfrage veranschaulicht dies, indem Zielkonten ermittelt werden, die ein bis drei Übertragungen von einer Quelle Account mit einem id-Wert von 7 entfernt sind.

In der Abfrage wird der Quantifizierer {1, 3} auf das Kantenmuster -[e:Transfers]-> angewendet. Dadurch wird die Abfrage angewiesen, Pfade abzugleichen, in denen das Transfers-Kantenmuster ein-, zwei- oder dreimal wiederholt wird. Mit der WHERE-Klausel wird das Quellkonto aus den Ergebnissen ausgeschlossen. Die Funktion ARRAY_LENGTH wird verwendet, um auf die group variable e zuzugreifen.

GRAPH graph_db.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;

Das Ergebnis sieht etwa so aus:

src_account_id path_length dst_account_id
7 1 16
7 1 16
7 3 16
7 3 16
7 2 20
7 2 20

Einige Zeilen in den Ergebnissen werden wiederholt. Das liegt daran, dass zwischen denselben Quell- und Zielknoten mehrere Pfade vorhanden sein können, die dem Muster entsprechen, und die Abfrage alle zurückgibt.

Einem quantifizierten Pfadmuster entsprechen

Mit der folgenden Abfrage werden Pfade zwischen Account-Knoten mit ein bis zwei Transfers-Kanten über zwischengeschaltete Konten gefunden, die blockiert sind.

Das in Klammern gesetzte Pfadmuster wird quantifiziert und seine WHERE-Klausel gibt Bedingungen für das wiederholte Muster an.

GRAPH graph_db.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;

Das Ergebnis sieht etwa so aus:

src_account_id dst_account_id
7 20
7 20
20 20

Gruppenvariablen

Eine in einem quantifizierten Muster deklarierte Graphmustervariable wird zu einer Gruppenvariablen, wenn außerhalb dieses Musters darauf zugegriffen wird. Anschließend wird es an ein Array mit übereinstimmenden Grafikelementen gebunden.

Sie können auf eine Gruppenvariable als Array zugreifen. Die Grafikelemente werden in der Reihenfolge ihrer Darstellung entlang der abgeglichenen Pfade beibehalten. Sie können eine Gruppierungsvariable mit horizontaler Aggregation aggregieren.

Variable für Zugriffsgruppe

Im folgenden Beispiel wird auf die Variable e so zugegriffen:

  • Als Graphmuster-Variable, die an eine einzelne Kante in der WHERE-Klausel gebunden ist,e.amount > 100 wenn sie sich im quantifizierten Muster befindet.
  • Als Gruppierungsvariable, die an ein Array von Edge-Elementen in ARRAY_LENGTH(e) in der RETURN-Anweisung gebunden ist, wenn sie sich außerhalb des quantifizierten Musters befindet.
  • Als Gruppierungsvariable, die an ein Array von Kantenelementen gebunden ist, das von SUM(e.amount) außerhalb des quantifizierten Musters aggregiert wird. Dies ist ein Beispiel für die horizontale Aggregation.
GRAPH graph_db.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;

Das Ergebnis sieht etwa so aus:

src_account_id path_length total_amount dst_account_id
7 1 300 16
7 2 600 20

Präfixe für die Pfadsuche

Wenn Sie die übereinstimmenden Pfade in Gruppen mit gemeinsamen Quell- und Zielknoten einschränken möchten, können Sie das ANY-, ANY SHORTEST- oder ANY CHEAPEST-Pfad-Suchpräfix verwenden. Sie können diese Präfixe nur vor einem gesamten Pfadmuster und nicht innerhalb von Klammern anwenden.

Abgleich mit ANY

Mit der folgenden Abfrage werden alle erreichbaren eindeutigen Konten gefunden, die ein oder zwei Transfers von einem bestimmten Account-Knoten entfernt sind.

Das Pfadsuchpräfix ANY sorgt dafür, dass die Abfrage nur einen Pfad zwischen einem eindeutigen Paar von src- und dst-Account-Knoten zurückgibt. Im folgenden Beispiel ist der Knoten Account zwar über zwei verschiedene Pfade vom Quellknoten Account aus mit {id: 16} erreichbar, die Abfrage gibt aber nur einen Pfad zurück.

GRAPH graph_db.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;

Das Ergebnis sieht etwa so aus:

src_account_id dst_account_id ids_in_path
7 16 7,16
7 20 7,16,20

Abgleich mit ANY SHORTEST

Das Präfix ANY SHORTEST für die Pfadsuche gibt für jedes Paar von Quell- und Zielknoten einen einzelnen Pfad zurück, der aus den Pfaden mit der minimalen Anzahl von Kanten ausgewählt wird.

Mit der folgenden Abfrage wird beispielsweise einer der kürzesten Pfade zwischen einem Account-Knoten mit dem id-Wert 7 und einem Account-Knoten mit dem id-Wert 20 ermittelt. Die Abfrage berücksichtigt Pfade mit ein bis drei Transfers-Kanten.

GRAPH graph_db.FinGraph
MATCH ANY SHORTEST (src:Account {id: 7})-[e:Transfers]->{1, 3}(dst:Account {id: 20})
RETURN src.id AS src_account_id, dst.id AS dst_account_id, ARRAY_LENGTH(e) AS path_length;

Das Ergebnis sieht etwa so aus:

src_account_id dst_account_id path_length
7 20 2

Abgleich mit ANY CHEAPEST

Das Präfix ANY CHEAPEST für die Pfadsuche sorgt dafür, dass für jedes Paar von Quell- und Zielkonten nur ein Pfad mit den geringsten Gesamtkosten für die Berechnung zurückgegeben wird.

Die folgende Abfrage ermittelt einen Pfad mit den geringsten Gesamtkosten für die Berechnung zwischen Account Knoten. Diese Kosten basieren auf der Summe des Attributs amount der Transfers-Kanten. Bei der Suche werden Pfade mit ein bis drei Transfers-Kanten berücksichtigt.

GRAPH graph_db.FinGraph
MATCH ANY CHEAPEST (src:Account)-[e:Transfers COST e.amount]->{1,3}(dst:Account)
LET total_cost = sum(e.amount)
RETURN src.id AS src_account_id, dst.id AS dst_account_id, total_cost;

Das Ergebnis sieht etwa so aus:

src_account_id dst_account_id total_cost
7 7 900
7 16 100
7 20 400
16 7 800
16 16 500
16 20 300
20 7 500
20 16 200
20 20 500

Diagrammmuster

Ein Diagrammmuster besteht aus einem oder mehreren Pfadmuster, die durch ein Komma (,) getrennt sind. Diagrammmuster können eine WHERE-Klausel enthalten, mit der Sie auf alle Variablen des Diagrammmusters in den Pfadmuster zugreifen können, um Filterbedingungen zu erstellen. Jedes Pfadmuster erzeugt eine Sammlung von Pfaden.

Mit einem Graphmuster abgleichen

Mit der folgenden Abfrage werden Vermittlerkonten und ihre Inhaber ermittelt, die an Transaktionsbeträgen über 200 € beteiligt sind, über die Gelder von einem Quellkonto auf ein gesperrtes Konto überwiesen werden.

Die folgenden Pfadmuster bilden das Diagrammmuster:

  • Das erste Muster findet Pfade, bei denen die Übertragung von einem Konto zu einem gesperrten Konto über ein Zwischenkonto erfolgt.
  • Das zweite Muster findet Pfade von einem Konto zur zugehörigen Person.

Die Variable interm dient als gemeinsame Verknüpfung zwischen den beiden Pfadmustern. Dazu muss interm in beiden Pfadmustern auf denselben Elementknoten verweisen. Dadurch wird ein Equi-Join-Vorgang basierend auf der Variablen interm erstellt.

GRAPH graph_db.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;

Das Ergebnis sieht etwa so aus:

src_account_id dst_account_id interm_account_id owner_id
20 16 7 1

Lineare Abfrageanweisungen

Sie können mehrere Graph-Anweisungen verketten, um eine lineare Abfrageanweisung zu bilden. Die Anweisungen werden in der Reihenfolge ausgeführt, in der sie in der Abfrage aufgeführt sind.

  • Jede Anweisung verwendet die Ausgabe der vorherigen Anweisung als Eingabe. Die Eingabe für die erste Anweisung ist leer.

  • Die Ausgabe der letzten Anweisung ist das Endergebnis.

Sie können beispielsweise lineare Abfrageanweisungen verwenden, um den maximalen Transfer auf ein gesperrtes Konto zu ermitteln. Mit der folgenden Abfrage werden das Konto und der Inhaber mit der größten abgehenden Überweisung auf ein gesperrtes Konto ermittelt.

GRAPH graph_db.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;

Die folgende Tabelle veranschaulicht diesen Prozess anhand der Zwischenergebnisse, die zwischen den einzelnen Anweisungen übergeben werden. Aus Gründen der Übersichtlichkeit werden nur einige Properties angezeigt.

Aussage Zwischenergebnis (abgekürzt) 
MATCH
  (src_account:Account)
    -[transfer:Transfers]->
  (dst_account:Account {is_blocked:true})
src_account transfer dst_account
{id: 7} {amount: 300.0} {id: 16, is_blocked: true}
{id: 7} {amount: 100.0} {id: 16, is_blocked: true}
{id: 20} {amount: 200.0} {id: 16, is_blocked: true} 

ORDER BY transfer.amount DESC
src_account transfer dst_account
{id: 7} {amount: 300.0} {id: 16, is_blocked: true}
{id: 20} {amount: 200.0} {id: 16, is_blocked: true}
{id: 7} {amount: 100.0} {id: 16, is_blocked: true} 

LIMIT 1
src_account transfer dst_account
{id: 7} {amount: 300.0} {id: 16, is_blocked: true} 

MATCH
  (src_account:Account)
    <-[owns:Owns]-
  (owner:Person)
src_account transfer dst_account gehört Inhaber
{id: 7} {amount: 300.0} {id: 16, is_blocked: true} {person_id: 1, account_id: 7} {id: 1, name: Alex} 
RETURN
  src_account.id AS account_id,
  owner.name AS owner_name
account_id owner_name
7 Alex

Das Ergebnis sieht etwa so aus:

Die Konto-ID von Tinfoil Security owner_name
7 Alex

return-Anweisung

Mit der RETURN-Anweisung wird angegeben, was aus den übereinstimmenden Mustern zurückgegeben werden soll. Sie kann auf Variablen für das Diagrammmuster zugreifen und Ausdrücke und andere Klauseln wie ORDER BY und GROUP BY enthalten.

BigQuery Graph unterstützt nicht die Rückgabe von Grafikelementen als Abfrageergebnisse. Wenn Sie das gesamte Grafikelement zurückgeben möchten, verwenden Sie die Funktion TO_JSON.

Graphelemente als JSON zurückgeben

GRAPH graph_db.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;

Das Ergebnis sieht etwa so aus:

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

Größere Anfragen mit dem Keyword NEXT erstellen

Sie können mehrere lineare Graphabfrageanweisungen mit dem Schlüsselwort NEXT verketten. Die erste Anweisung erhält eine leere Eingabe und die Ausgabe jeder nachfolgenden Anweisung wird zur Eingabe für die nächste.

Im folgenden Beispiel wird der Inhaber des Kontos mit den meisten eingehenden Überweisungen ermittelt, indem mehrere lineare Graph-Anweisungen verkettet werden. Sie können dieselbe Variable, z. B. account, verwenden, um in mehreren linearen Anweisungen auf dasselbe Grafikelement zu verweisen.

GRAPH graph_db.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;

Das Ergebnis sieht etwa so aus:

Die Konto-ID von Tinfoil Security owner_name num_incoming_transfers
16 Lee 3

Sie können auch lineare Abfrageanweisungen mit Mengenoperatoren kombinieren.

Funktionen und Ausdrücke

Sie können alle GoogleSQL-Funktionen (sowohl Aggregat- als auch Skalarfunktionen), Operatoren und bedingten Ausdrücke in Diagrammabfragen verwenden. BigQuery Graph unterstützt auch GQL-Funktionen und GQL-Operatoren, die nur in Diagrammabfragen verwendet werden können.

Die folgende Abfrage enthält eine Mischung aus GQL- und SQL-Funktionen und ‑Operatoren in einer Diagrammabfrage:

GRAPH graph_db.FinGraph
MATCH (person:Person)-[o:Owns]->(account:Account)
WHERE person IS SOURCE OF o
RETURN person, ARRAY_AGG(account.nick_name) AS accounts
GROUP BY person

NEXT

RETURN
  LABELS(person) AS labels,
  accounts,
  CONCAT(person.city, ", ", person.country) AS location,
  TO_JSON(person) AS person
LIMIT 1;

Das Ergebnis sieht etwa so aus:

Labels Konten Standort Person
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"}}

Unterabfragen

Eine Unterabfrage ist eine Abfrage, die in einer anderen Abfrage verschachtelt ist. Für Unterabfragen in Diagrammabfragen gelten die folgenden Regeln:

  • Eine Unterabfrage wird in geschweifte Klammern {} gesetzt.
  • Eine Unterabfrage beginnt mit einer GRAPH-Klausel, um den relevanten Graphen anzugeben. Der angegebene Graph muss nicht mit dem in der äußeren Abfrage verwendeten Graph übereinstimmen.
  • Eine Graphmustervariable, die außerhalb des Unterabfragebereichs deklariert wurde, kann nicht noch einmal innerhalb der Unterabfrage deklariert werden. Sie kann jedoch in Ausdrücken oder Funktionen innerhalb der Unterabfrage referenziert werden.

Gesamtzahl der Übertragungen von jedem Konto mit einer Unterabfrage ermitteln

Die folgende Abfrage veranschaulicht die Verwendung der Unterabfrage VALUE. Die Unterabfrage wird in geschweifte Klammern {} eingeschlossen, denen das Keyword VALUE vorangestellt ist. Die Abfrage gibt die Gesamtzahl der Übertragungen zurück, die von einem Konto aus initiiert wurden.

GRAPH graph_db.FinGraph
MATCH (p:Person)-[:Owns]->(account:Account)
RETURN p.name, account.id AS account_id, VALUE {
  GRAPH graph_db.FinGraph
  MATCH (a:Account)-[transfer:Transfers]->(:Account)
  WHERE a = account
  RETURN COUNT(transfer) AS num_transfers
} AS num_transfers;

Das Ergebnis sieht etwa so aus:

Name Die Konto-ID von Tinfoil Security num_transfers
Alex 7 2
Dana 20 2
Lee 16 1

Eine Liste der unterstützten Unterabfrageausdrücke finden Sie unter BigQuery Graph-Unterabfragen.

Suchparameter

Sie können BigQuery Graph mit Parametern abfragen. Weitere Informationen finden Sie in der Syntax und unter Parametrisierte Abfragen ausführen.

Die folgende Abfrage stimmt mit Person-Knoten überein, deren id-Wert mit einem Abfrageparameter übereinstimmt:

GRAPH graph_db.FinGraph
MATCH (person:Person {id: @id})
RETURN person.name;

Diagramme und Tabellen zusammen abfragen

Sie können Grafabfragen und SQL-Abfragen mit dem GRAPH_TABLE-Operator kombinieren.

Der Operator GRAPH_TABLE verwendet eine lineare Diagrammabfrage und gibt das Ergebnis in tabellarischer Form zurück, die in eine SQL-Abfrage eingebunden werden kann. Dank dieser Interoperabilität können Sie die Ergebnisse von Graph-Abfragen mit Nicht-Graph-Inhalten anreichern und umgekehrt.

Sie können beispielsweise eine CreditReports-Tabelle erstellen und einige Kreditberichte einfügen, wie im folgenden Beispiel gezeigt:

CREATE TABLE graph_db.CreditReports (
  person_id     INT64 NOT NULL,
  create_time   TIMESTAMP NOT NULL,
  score         INT64 NOT NULL,
  PRIMARY KEY (person_id, create_time) NOT ENFORCED
);

INSERT INTO graph_db.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);

Als Nächstes können Sie bestimmte Personen durch den Abgleich von Diagrammmustern in GRAPH_TABLE identifizieren und die Ergebnisse der Diagrammabfrage mit der Tabelle CreditReports zusammenführen, um Kreditscores abzurufen.

SELECT
  gt.person.id,
  credit.score AS latest_credit_score
FROM GRAPH_TABLE(
  graph_db.FinGraph
  MATCH (person:Person)-[:Owns]->(:Account)-[:Transfers]->(account:Account {is_blocked:true})
  RETURN DISTINCT person
) AS gt
JOIN graph_db.CreditReports AS credit
  ON gt.person.id = credit.person_id
ORDER BY credit.create_time;

Das Ergebnis sieht etwa so aus:

person_id latest_credit_score
1 700
2 800

Nächste Schritte