Compartilhar via

MATCH (Transact-SQL)

  • Artigo

Aplica-se a: SQL Server 2017 (14.x) e posteriores Banco de Dados SQL do Azure Instância Gerenciada de SQL do Azure

Especifica um critério de pesquisa para um gráfico. MATCH pode ser usada apenas com tabelas de nó de gráfico e borda, na instrução SELECT como parte da cláusula WHERE.

Convenções de sintaxe de Transact-SQL

Sintaxe

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.

Argumentos

graph_search_pattern
Especifica o padrão a ser pesquisado ou o caminho a ser percorrido no gráfico. Esse padrão usa a sintaxe de arte ASCII para percorrer um caminho no gráfico. O padrão varia de um nó para outro por meio de uma borda, na direção da seta fornecida. Os nomes de borda ou aliases são fornecidos em parênteses. Os nomes de nó ou os aliases são exibidos nas duas extremidades da seta. A seta pode apontar para qualquer direção no padrão.

node_alias
Nome ou alias de uma tabela de nó fornecida na cláusula FROM.

edge_alias
Nome ou alias de uma tabela de borda fornecida na cláusula FROM.

SHORTEST_PATH A função de caminho mais curto é usada para localizar o caminho mais curto entre dois nós ou entre um determinado nó e todos os outros nós em um grafo. Ela usa como entrada um padrão de comprimento arbitrário que é pesquisado repetidamente em um gráfico. Introduzida no SQL Server 2019. Requer o SQL Server 2019 ou posterior.

arbitrary_length_match_pattern
Especifica os nós e bordas que precisam ser atravessadas repetidamente até atingir o nó desejado ou o número máximo de iterações, conforme especificado no padrão for atendido.

al_pattern_quantifier
O padrão de comprimento arbitrário considera quantificadores padrão de estilo de expressão regular para especificar o número de vezes que um padrão de pesquisa fornecido é repetido. Os quantificadores padrão de pesquisa compatíveis são:

  • + : Repete o padrão por 1 ou mais vezes. É encerrado assim que encontra um caminho mais curto.
  • {1,n}: repete o padrão 1 por n horas. É encerrado assim que encontra um caminho mais curto.

Comentários

Os nomes de nó dentro de MATCH podem ser repetidos. Em outras palavras, um nó pode ser percorrido um número arbitrário de vezes na mesma consulta.
Um nome de borda não pode ser repetido dentro de MATCH.
Uma borda pode apontar para qualquer direção, mas deve ter uma direção explícita.
Os operadores OR ou NOT não são compatíveis com o padrão MATCH. MATCH pode ser combinado com outras expressões usando AND na cláusula WHERE. No entanto, não há suporte para a combinação dele com outras expressões usando OR ou NOT.

Exemplos

a. Encontrar um amigo

O exemplo a seguir cria uma tabela de nó Person e a tabela de Borda friends, insere alguns dados e, em seguida, usa MATCH para encontrar amigos de Alice, uma pessoa no gráfico.

-- 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. Encontrar um amigo de um amigo

O exemplo a seguir tenta encontrar um amigo de um amigo de 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. Mais padrões de MATCH

Estas são algumas outras maneiras pelas quais um padrão pode ser especificado dentro de 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);

Consulte Também

CREATE TABLE (Grafo do SQL)
INSERT (SQL Graph)]
Processamento de grafo com o SQL Server 2017