Condividi tramite

MATCH (Transact-SQL)

  • Articolo

Si applica a: SQL Server 2017 (14.x) e alle sue versioni successive Database SQL di Azure Istanza gestita di SQL di Azure

Specifica una condizione di ricerca per un grafo. Il criterio MATCH può essere usato solo con il nodo del grafico e le tabelle bordi, nell'istruzione SELECT come parte della clausola WHERE.

Convenzioni relative alla sintassi Transact-SQL

Sintassi

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.

Argomenti

graph_search_pattern
Specifica il criterio di ricerca o il percorso da attraversare nel grafico. Questo criterio usa la sintassi grafica ASCII per attraversare un percorso nel grafico. Il criterio passa da un nodo a un altro tramite un bordo, nella direzione della freccia indicata. I nomi o alias dei bordi vengono specificati all'interno di parentesi. I nomi o gli alias dei nodi vengono visualizzati alle due estremità della freccia. La freccia può andare in entrambe le direzioni nel modello.

node_alias
Nome o alias di una tabella nodi specificata nella clausola FROM.

edge_alias
Nome o alias di una tabella bordi specificata nella clausola FROM.

SHORTEST_PATH Funzione viene usata per individuare il percorso più breve tra due nodi specificati in un grafo o tra un determinato nodo e tutti gli altri nodi in un grafo. Accetta come input un criterio di lunghezza arbitraria, di cui viene eseguita ripetutamente la ricerca in un grafo. Introdotta in SQL Server 2019. Richiede SQL Server 2019 o versioni successive.

arbitrary_length_match_pattern
Specifica i nodi e i bordi che devono essere attraversati ripetutamente finché non viene raggiunto il nodo desiderato o fino al numero massimo di iterazioni specificato nel criterio.

al_pattern_quantifier
Il criterio di lunghezza arbitraria accetta quantificatori di criteri nello stile delle espressioni regolari per specificare il numero di volte per cui viene ripetuto un criterio di ricerca specificato. I quantificatori dei criteri di ricerca supportati sono:

  • +: ripetere il criterio 1 o più volte. Terminare non appena viene trovato un percorso più breve.
  • {1,n}: ripetere il modello da 1 a n volte. Terminare non appena viene trovato un percorso più breve.

Osservazioni:

I nomi dei nodi all'interno del criterio MATCH possono essere ripetuti. In altre parole, un nodo può essere attraversato un numero arbitrario di volte nella stessa query.
Il nome di un bordo non può essere ripetuto all'interno del criterio MATCH.
Un bordo può puntare in entrambe le direzioni, ma deve avere una direzione esplicita.
Gli operatori OR e NOT non sono supportati nel criterio MATCH. Il criterio MATCH può essere combinato con altre espressioni tramite l'operatore AND nella clausola WHERE. Non può tuttavia essere combinato con altre espressioni tramite l'operatore OR o NOT.

Esempi

R. Trovare un amico

Nell'esempio seguente viene creata una tabella nodi di persone e una tabella bordi di amici, vengono inseriti alcuni dati e quindi viene usato il criterio MATCH per trovare gli amici di Alice, una persona nel grafo.

-- 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. Trovare un amico di un amico

Nell'esempio seguente si tenta di trovare l'amico di un amico di 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. Altri criteri MATCH

Di seguito sono riportati alcuni altri modi in cui è possibile specificare un criterio all'interno di 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);

Vedi anche

CREATE TABLE (grafo SQL)
INSERT (grafo SQL)
Graph Processing with SQL Server 2017 (Elaborazione di grafi con SQL Server 2017)