MATCH (Transact-SQL)

  • Artikel

Gilt für: SQL Server 2017 (14.x) und höher Azure SQL-DatenbankAzure SQL Managed Instance

Gibt eine Suchbedingung für einen Graph an. MATCH kann in der SELECT-Anweisung nur mit dem Diagrammknoten und Edgetabellen als Teil der WHERE-Klausel verwendet werden.

Transact-SQL-Syntaxkonventionen

Syntax

MATCH (<graph_search_pattern>)

<graph_search_pattern>::=
  {  
      <simple_match_pattern> 
    | <arbitrary_length_match_pattern>  
    | <arbitrary_length_match_last_node_predicate> 
  }

<simple_match_pattern>::=
  {
      LAST_NODE(<node_alias>) | <node_alias>   { 
          { <-( <edge_alias> )- } 
        | { -( <edge_alias> )-> }
        <node_alias> | LAST_NODE(<node_alias>)
        } 
  }
  [ { AND } { ( <simple_match_pattern> ) } ]
  [ ,...n ]

<node_alias> ::=
  node_table_name | node_table_alias 

<edge_alias> ::=
  edge_table_name | edge_table_alias


<arbitrary_length_match_pattern>  ::=
  { 
    SHORTEST_PATH( 
      <arbitrary_length_pattern> 
      [ { AND } { <arbitrary_length_pattern> } ] 
      [ ,…n] 
    )
  } 

<arbitrary_length_match_last_node_predicate> ::=
  {  LAST_NODE( <node_alias> ) = LAST_NODE( <node_alias> ) }


<arbitrary_length_pattern> ::=
	{  LAST_NODE( <node_alias> )   | <node_alias>
     ( <edge_first_al_pattern> [<edge_first_al_pattern>…,n] )
     <al_pattern_quantifier> 
  }
 	|  ( {<node_first_al_pattern> [<node_first_al_pattern> …,n] )
  	  	<al_pattern_quantifier> 
        LAST_NODE( <node_alias> ) | <node_alias> 
 }
	
<edge_first_al_pattern> ::=
  { (  
        { -( <edge_alias> )->   } 
      | { <-( <edge_alias> )- } 
      <node_alias>
	  ) 
  } 

<node_first_al_pattern> ::=
  { ( 
      <node_alias> 
        { <-( <edge_alias> )- } 
      | { -( <edge_alias> )-> }
 	  ) 
  } 


<al_pattern_quantifier> ::=
  {
	    +
	  | { 1 , n }
  }

n -  positive integer only.

Hinweis

Informationen zum Anzeigen der Transact-SQL-Syntax für SQL Server 2014 (12.x) und früher finden Sie unter Dokumentation zu früheren Versionen.

Argumente

graph_search_pattern
Gibt das Suchmuster oder den Pfad an, das bzw. der im Graph durchlaufen werden soll. Dieses Muster verwenden eine ASCII-Syntax, um den Pfad im Graph zu durchlaufen. Dieses Muster läuft in der Richtung des angegebenen Pfeils über einen Edge von einem Knoten zum anderen. Edge-Namen und -Aliase werden in Klammern bereitgestellt. Namen oder Aliase von Knoten werden an den beiden Enden des Pfeils angezeigt. Der Pfeil kann im Muster in beide Richtungen zeigen.

node_alias
Name oder Alias einer Knotentabelle, die in der FROM-Klausel angegeben ist.

edge_alias
Name oder Alias einer Edgetabelle, die in der FROM-Klausel angegeben ist.

SHORTEST_PATH Diese Funktion wird verwendet, um den kürzesten Weg zwischen zwei gegebenen Knoten in einem Graph oder zwischen einem bestimmten Knoten und allen anderen Knoten in einem Graph zu finden. Als Eingabe dient ein beliebiges Längenmuster, das in einem Graph wiederholt durchsucht wird. Eingeführt in SQL Server 2019. Hierfür ist SQL Server 2019 oder höher erforderlich.

arbitrary_length_match_pattern
Gibt die Knoten und Edges an, die wiederholt durchlaufen werden müssen, bis der gewünschte Knoten erreicht ist oder bis die im Muster angegebene maximale Anzahl von Iterationen erreicht ist.

al_pattern_quantifier
Das beliebige Längenmuster verwendet Quantifizierer für reguläre Ausdrücke, um die Anzahl der Wiederholungen eines bestimmten Suchmusters festzulegen. Die unterstützten Suchmusterquantifizierer sind:

  • + : Das Muster 1 oder mehrmals wiederholen. Beenden, sobald der kürzeste Pfad gefunden wird.
  • {1,n} : Das Muster 1 bis n Male wiederholen. Beenden, sobald der kürzeste Pfad gefunden wird.

Bemerkungen

Die Knotennamen können in MATCH wiederholt werden. D.h., ein Knoten kann beliebig oft in der gleichen Abfrage durchlaufen werden.
Der Name von einem Edge kann nicht in MATCH wiederholt werden.
Ein Edge kann in beide Richtungen zeigen, muss jedoch über eine explizite Richtung verfügen.
Die Operatoren OR und NOT werden nicht im Muster von MATCH unterstützt. MATCH kann mithilfe von AND in der WHERE-Klausel mit anderen Ausdrücken kombiniert werden. Allerdings wird das Verbinden mit Ausdrücken mithilfe von OR oder NOT nicht unterstützt.

Beispiele

A. Finden von Freunden

Im folgenden Beispiel werden eine Knotentabelle für Personen und eine Edgetabelle für Freunde erstellt, Daten eingefügt und dann MATCH verwendet, um die Freunde von Alice (eine Person im Graph) zu finden.

-- Create person node table
CREATE TABLE dbo.Person (ID INTEGER PRIMARY KEY, name VARCHAR(50)) AS NODE;
CREATE TABLE dbo.friend (start_date DATE) AS EDGE;

-- Insert into node table
INSERT INTO dbo.Person VALUES (1, 'Alice');
INSERT INTO dbo.Person VALUES (2,'John');
INSERT INTO dbo.Person VALUES (3, 'Jacob');

-- Insert into edge table
INSERT INTO dbo.friend VALUES ((SELECT $node_id FROM dbo.Person WHERE name = 'Alice'),
       (SELECT $node_id FROM dbo.Person WHERE name = 'John'), '9/15/2011');

INSERT INTO dbo.friend VALUES ((SELECT $node_id FROM dbo.Person WHERE name = 'Alice'),
       (SELECT $node_id FROM dbo.Person WHERE name = 'Jacob'), '10/15/2011');

INSERT INTO dbo.friend VALUES ((SELECT $node_id FROM dbo.Person WHERE name = 'John'),
       (SELECT $node_id FROM dbo.Person WHERE name = 'Jacob'), '10/15/2012');

-- use MATCH in SELECT to find friends of Alice
SELECT Person2.name AS FriendName
FROM Person Person1, friend, Person Person2
WHERE MATCH(Person1-(friend)->Person2)
AND Person1.name = 'Alice';

B. Finden von Freundne von Freunden

Im folgenden Beispiel wird versucht, einen Freund des Freundes von Alice zu finden.

SELECT Person3.name AS FriendName 
FROM Person Person1, friend, Person Person2, friend friend2, Person Person3
WHERE MATCH(Person1-(friend)->Person2-(friend2)->Person3)
AND Person1.name = 'Alice';

C. Weitere MATCH-Muster

Im Folgenden werden einige weitere Möglichkeiten dargestellt, durch die ein Muster in MATCH angegeben werden kann.

-- Find a friend
   SELECT Person2.name AS FriendName
   FROM Person Person1, friend, Person Person2
   WHERE MATCH(Person1-(friend)->Person2);
   
-- The pattern can also be expressed as below

   SELECT Person2.name AS FriendName
   FROM Person Person1, friend, Person Person2 
   WHERE MATCH(Person2<-(friend)-Person1);


-- Find 2 people who are both friends with same person
   SELECT Person1.name AS Friend1, Person2.name AS Friend2
   FROM Person Person1, friend friend1, Person Person2, 
        friend friend2, Person Person0
   WHERE MATCH(Person1-(friend1)->Person0<-(friend2)-Person2);
   
-- this pattern can also be expressed as below

   SELECT Person1.name AS Friend1, Person2.name AS Friend2
   FROM Person Person1, friend friend1, Person Person2, 
        friend friend2, Person Person0
   WHERE MATCH(Person1-(friend1)->Person0 AND Person2-(friend2)->Person0);

Weitere Informationen

CREATE TABLE (SQL-Graph)
INSERT (SQL-Graph)]
Graph Processing with SQL Server 2017 (Graph-Verarbeitung mit SQL Server-2017)