MATCH (Transact-SQL)

Gilt für: SQL Server 2017 (14.x) und höhere Versionen von Azure SQL DatabaseAzure SQL Managed InstanceSQL sql database in Microsoft Fabric

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.

Arguments

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

Die kürzeste Pfadfunktion wird verwendet, um den kürzesten Pfad zwischen zwei bestimmten Knoten in einem Diagramm oder zwischen einem bestimmten Knoten und allen anderen Knoten in einem Diagramm 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.

Remarks

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

Examples

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';

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';

Suchen von Personen 1-3 Hops von einer bestimmten Person entfernt

Das folgende Beispiel findet den kürzesten Weg zwischen Jacob und allen Personen, mit denen Jacob in der Grafik verbunden ist, ein bis drei Hops von ihm entfernt.

SELECT
    Person1.name AS PersonName,
    STRING_AGG(Person2.name, '->') WITHIN GROUP (GRAPH PATH) AS Friends
FROM
    Person AS Person1,
    friendOf FOR PATH AS fo,
    Person FOR PATH  AS Person2
WHERE MATCH(SHORTEST_PATH(Person1(-(fo)->Person2){1,3}))
AND Person1.name = 'Jacob'

Weitere 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);

Verwandte Inhalte

• CREATE TABLE (SQL-Graph)
• INSERT (SQL-Diagramm)
• Graph-Verarbeitung mit SQL Server und Azure SQL-Datenbank
• SHORTEST_PATH (Transact-SQL)