Compartilhar via

MATCH (Transact-SQL)

Aplica-se a: SQL Server 2017 (14.x) e versões posteriores do Banco de Dados SQL do AzureBanco de Dados SQL do Azure Banco de Dados SQL banco de dados SQL do Banco de Dados SQL do Azurebanco de dados SQL no Microsoft Fabric

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

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 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 determinados em um grafo 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.

Remarks

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.
Não há suporte para operadores OR e NOT 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 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';

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

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

Mais padrões

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

Conteúdo relacionado

  • Last updated on