Delen via

MATCH (Transact-SQL)

Van toepassing op: SQL Server 2017 (14.x) en latere versies Van Azure SQL DatabaseAzure SQL Managed InstanceSQL Database in Microsoft Fabric Preview

Hiermee geeft u een zoekvoorwaarde voor een grafiek. VERGELIJKEN kan alleen worden gebruikt met grafiekknooppunt- en edge-tabellen, in de SELECT-instructie als onderdeel van de WHERE-component.

Transact-SQL syntaxis-conventies

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

Hiermee geeft u het patroon op dat moet worden gezocht of pad moet worden doorkruist in de grafiek. In dit patroon wordt de ASCII-tekensyntaxis gebruikt om een pad in de grafiek te doorlopen. Het patroon gaat van het ene knooppunt naar het andere via een rand, in de richting van de opgegeven pijl. Edge-namen of -aliassen worden tussen haakjes weergegeven. Knooppuntnamen of aliassen worden weergegeven aan de twee uiteinden van de pijl. De pijl kan in beide richtingen in het patroon gaan.

node_alias

Naam of alias van een knooppunttabel die is opgegeven in de FROM-component.

edge_alias

Naam of alias van een edge-tabel die is opgegeven in de FROM-component.

SHORTEST_PATH

De kortste padfunctie wordt gebruikt om het kortste pad te vinden tussen twee knooppunten in een grafiek of tussen een bepaald knooppunt en alle andere knooppunten in een grafiek. Er wordt een willekeurig lengtepatroon gebruikt als invoer, die herhaaldelijk in een grafiek wordt doorzocht. Geïntroduceerd in SQL Server 2019. Vereist SQL Server 2019 of hoger.

arbitrary_length_match_pattern

Hiermee geeft u de knooppunten en randen die herhaaldelijk moeten worden doorkruist totdat het gewenste knooppunt is bereikt of tot het maximum aantal iteraties zoals opgegeven in het patroon wordt voldaan.

al_pattern_quantifier

Het willekeurige lengtepatroon neemt reguliere kwantificatoren voor expressiestijlen om het aantal keren op te geven dat een bepaald zoekpatroon wordt herhaald. De ondersteunde kwantificatoren voor zoekpatronen zijn:

  • +: Herhaal het patroon 1 of meer keren. Eindig zodra er een kortst pad wordt gevonden.
  • {1,n}: herhaal het patroon 1 tot n tijden. Eindig zodra er een kortst pad wordt gevonden.

Remarks

De knooppuntnamen in VERGELIJKEN kunnen worden herhaald. Met andere woorden, een knooppunt kan een willekeurig aantal keren in dezelfde query worden doorkruist.
Een randnaam kan niet worden herhaald in VERGELIJKEN.
Een rand kan in beide richtingen wijzen, maar moet een expliciete richting hebben.
OF- en NOT-operators worden niet ondersteund in het PATROON VERGELIJKEN.
VERGELIJKEN kan worden gecombineerd met andere expressies met BEHULP van AND in de WHERE-component. Het combineren ervan met andere expressies met OR of NOT wordt echter niet ondersteund.

Examples

Een vriend zoeken

In het volgende voorbeeld worden een tabel person-knooppunt en vrienden Edge-tabel gemaakt, enkele gegevens ingevoegd en vervolgens MATCH gebruikt om vrienden van Alice te vinden, een persoon in de grafiek.

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

Vriend van een vriend zoeken

In het volgende voorbeeld wordt geprobeerd een vriend van een vriend van Alice te vinden.

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

Personen zoeken 1-3 hops weg van een bepaalde persoon

In het volgende voorbeeld vindt u het kortste pad tussen Jacob en alle mensen waarmee Jacob is verbonden in de grafiek één tot drie hops van hem af.

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'

More patterns

Hier volgen nog enkele manieren waarop een patroon kan worden opgegeven in VERGELIJKEN.

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

Related content