MATCH (Transact-SQL)MATCH (Transact-SQL)

Anwendungsbereich:Applies to:zwarSQL Server 2017 (14.x)SQL Server 2017 (14.x)yesSQL Server 2017 (14.x)SQL Server 2017 (14.x)und höherAnwendungsbereich:Applies to: zwarSQL Server 2017 (14.x)SQL Server 2017 (14.x)yesSQL Server 2017 (14.x)SQL Server 2017 (14.x) and later

Gibt eine Suchbedingung für einen Graph an.Specifies a search condition for a graph. MATCH kann in der SELECT-Anweisung nur mit dem Diagrammknoten und Edgetabellen als Teil der WHERE-Klausel verwendet werden.MATCH can be used only with graph node and edge tables, in the SELECT statement as part of WHERE clause.

Symbol für Themenlink Transact-SQL-SyntaxkonventionenTopic link icon Transact-SQL Syntax Conventions

SyntaxSyntax

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 oder früher finden Sie unter Dokumentation zu früheren Versionen.To view Transact-SQL syntax for SQL Server 2014 and earlier, see Previous versions documentation.

ArgumenteArguments

graph_search_patterngraph_search_pattern
Gibt das Suchmuster oder den Pfad an, das bzw. der im Graph durchlaufen werden soll.Specifies the pattern to search or path to traverse in the graph. Dieses Muster verwenden eine ASCII-Syntax, um den Pfad im Graph zu durchlaufen.This pattern uses ASCII art syntax to traverse a path in the graph. Dieses Muster läuft in der Richtung des angegebenen Pfeils über einen Edge von einem Knoten zum anderen.The pattern goes from one node to another via an edge, in the direction of the arrow provided. Edge-Namen und -Aliase werden in Klammern bereitgestellt.Edge names or aliases are provided inside parentheses. Namen oder Aliase von Knoten werden an den beiden Enden des Pfeils angezeigt.Node names or aliases appear at the two ends of the arrow. Der Pfeil kann im Muster in beide Richtungen zeigen.The arrow can go in either direction in the pattern.

node_aliasnode_alias
Name oder Alias einer Knotentabelle, die in der FROM-Klausel angegeben ist.Name or alias of a node table provided in the FROM clause.

edge_aliasedge_alias
Name oder Alias einer Edgetabelle, die in der FROM-Klausel angegeben ist.Name or alias of an edge table provided in the FROM clause.

SHORTEST_PATH SHORTEST_PATH
Die 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.Shortest path function is used to find shortest path between two given nodes in a graph or between a given node and all the other nodes in a graph. Als Eingabe dient ein beliebiges Längenmuster, das in einem Graph wiederholt durchsucht wird.It takes an arbitrary length pattern as input, that is searched repeatedly in a graph.

arbitrary_length_match_patternarbitrary_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.Specifies the nodes and edges that must be traversed repeatedly until the desired node is reached or until the maximum number of iterations as specified in the pattern is met.

al_pattern_quantifier al_pattern_quantifier
Das beliebige Längenmuster verwendet Quantifizierer für reguläre Ausdrücke, um die Anzahl der Wiederholungen eines bestimmten Suchmusters festzulegen.The arbitrary length pattern takes regular expression style pattern quantifiers in order to specify the number of times a given search pattern is repeated. Die unterstützten Suchmusterquantifizierer sind:The supported search pattern quantifiers are:

  • + : Das Muster 1 oder mehrmals wiederholen.+: Repeat the pattern 1 or more times. Beenden, sobald der kürzeste Pfad gefunden wird.Terminate as soon as a shortest path is found.
  • {1,n} : Das Muster 1 bis „n“ Male wiederholen.{1,n}: Repeat the pattern 1 to ‘n’ times. Beenden, sobald der kürzeste Pfad gefunden wird.Terminate as soon as a shortest path is found.

BemerkungenRemarks

Die Knotennamen können in MATCH wiederholt werden.The node names inside MATCH can be repeated. D.h., ein Knoten kann beliebig oft in der gleichen Abfrage durchlaufen werden.In other words, a node can be traversed an arbitrary number of times in the same query.
Der Name von einem Edge kann nicht in MATCH wiederholt werden.An edge name cannot be repeated inside MATCH.
Ein Edge kann in beide Richtungen zeigen, muss jedoch über eine explizite Richtung verfügen.An edge can point in either direction, but it must have an explicit direction.
Die Operatoren OR und NOT werden nicht im Muster von MATCH unterstützt.OR and NOT operators are not supported in the MATCH pattern. MATCH kann mithilfe von AND in der WHERE-Klausel mit anderen Ausdrücken kombiniert werden.MATCH can be combined with other expressions using AND in the WHERE clause. Allerdings wird das Verbinden mit Ausdrücken mithilfe von OR oder NOT nicht unterstützt.However, combining it with other expressions using OR or NOT is not supported.

BeispieleExamples

A.A. Finden von FreundenFind a friend

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.The following example creates a Person node table and friends Edge table, inserts some data and then uses MATCH to find friends of Alice, a person in the graph.

-- 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.B. Finden von Freundne von FreundenFind friend of a friend

Im folgenden Beispiel wird versucht, einen Freund des Freundes von Alice zu finden.The following example tries to find friend of a friend of Alice.

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.C. Weitere MATCH-MusterMore MATCH patterns

Im Folgenden werden einige weitere Möglichkeiten dargestellt, durch die ein Muster in MATCH angegeben werden kann.Following are some more ways in which a pattern can be specified inside MATCH.

-- 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 InformationenSee Also

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