Partilhar via

MATCH (Transact-SQL)

Aplica-se a: SQL Server 2017 (14.x) e versões posteriores Base de Dados SQL do AzureInstância GeridaBase de Dados SQL no Microsoft Fabric Preview

Especifica uma condição de pesquisa para um gráfico. MATCH só pode ser usado com nós gráficos e tabelas de borda, na instrução SELECT como parte da cláusula WHERE.

Transact-SQL convenções de sintaxe

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

Especifica o padrão a ser pesquisado ou o caminho a percorrer no gráfico. Esse padrão usa a sintaxe de arte ASCII para percorrer um caminho no gráfico. O padrão vai de um nó para outro através de uma aresta, na direção da seta fornecida. Nomes de borda ou aliases são fornecidos entre parênteses. Os nomes ou aliases dos nós aparecem nas duas extremidades da seta. A seta pode ir em qualquer direção no padrão.

node_alias

Nome ou alias de uma tabela de nós 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 encontrar o caminho mais curto entre dois nós dados em um gráfico ou entre um determinado nó e todos os outros nós em um gráfico. Ele usa um padrão de comprimento arbitrário como entrada, que é pesquisado repetidamente em um gráfico. Introduzido no SQL Server 2019. Requer o SQL Server 2019 ou posterior.

arbitrary_length_match_pattern

Especifica os nós e bordas que devem ser percorridos repetidamente até que o nó desejado seja atingido ou até que o número máximo de iterações, conforme especificado no padrão, seja atendido.

al_pattern_quantifier

O padrão de comprimento arbitrário usa quantificadores de padrão de estilo de expressão regular para especificar o número de vezes que um determinado padrão de pesquisa é repetido. Os quantificadores de padrão de pesquisa suportados são:

  • +: Repita o padrão 1 ou mais vezes. Encerre assim que um caminho mais curto for encontrado.
  • {1,n}: Repita o padrão de 1 a n vezes. Encerre assim que um caminho mais curto for encontrado.

Remarks

Os nomes dos nós 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 aresta pode apontar em qualquer direção, mas deve ter uma direção explícita.
Os operadores OR e NOT não são suportados no padrão MATCH.
MATCH pode ser combinado com outras expressões usando And na cláusula WHERE. No entanto, não há suporte para combiná-lo com outras expressões usando OR ou NOT.

Examples

Encontrar um amigo

O exemplo a seguir cria uma tabela de nó Person e uma tabela de borda de amigos, 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';

Encontrar amigo de um amigo

O exemplo a seguir tenta encontrar 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';

Encontre pessoas a 1-3 saltos de distância de uma determinada pessoa

O exemplo a seguir encontra o caminho mais curto entre Jacó e todas as pessoas às quais Jacó está conectado no gráfico a um a três saltos de distância dele.

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

A seguir estão mais algumas 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);

Related content