A linguagem de consulta Cypher foi originalmente desenvolvida especificamente para o DBMS gráfico Neo4j . O objetivo do Cypher é fornecer uma linguagem de consulta de banco de dados SQL legível por humanos para bancos de dados de gráficos. Hoje, o Cypher é suportado por vários DBMSs de gráficos. O OpenCypher foi criado para padronizar o Cypher.
As noções básicas de trabalho com o DBMS do Neo4j são descritas no artigo Noções básicas de trabalho com o Neo4j em um navegador .
Para se familiarizar com Cypher, considere um exemplo de uma árvore genealógica emprestada do clássico livro de Prolog de I. Bratko. Este exemplo mostra como adicionar nós e links a um gráfico, como atribuir rótulos e atributos a eles e como fazer perguntas.
Então, vamos ter uma árvore genealógica mostrada na figura abaixo.
Vamos ver como formar o gráfico correspondente no Cypher:
CREATE (pam:Person {name: "Pam"}), (tom:Person {name: "Tom"}), (kate:Person {name: "Kate"}), (mary:Person {name: "Mary"}), (bob:Person {name: "Bob"}), (liz:Person {name: "Liz"}), (dick:Person {name: "Dick"}), (ann:Person {name: "Ann"}), (pat:Person {name: "Pat"}), (jack:Person {name: "Jack"}), (jim:Person {name: "Jim"}), (joli:Person {name: "Joli"}), (pam)-[:PARENT]->(bob), (tom)-[:PARENT]->(bob), (tom)-[:PARENT]->(liz), (kate)-[:PARENT]->(liz), (mary)-[:PARENT]->(ann), (bob)-[:PARENT]->(ann), (bob)-[:PARENT]->(pat), (dick)-[:PARENT]->(jim), (ann)-[:PARENT]->(jim), (pat)-[:PARENT]->(joli), (jack)-[:PARENT]->(joli)
Uma solicitação CREATE para adicionar dados a um DBMS gráfico consiste em duas partes: adicionando nós e adicionando links entre eles. Cada nó a ser adicionado recebe um nome na estrutura desta solicitação, que é usada para criar links. Nós e comunicações podem armazenar documentos. No nosso caso, os nós contêm documentos com os campos de nome e os links do documento não. Também nós e links podem ser rotulados. No nosso caso, os nós recebem o rótulo Pessoa e os links são PAI. O rótulo nas solicitações é destacado por dois pontos antes do nome.
Portanto, o Neo4j nos disse que: Added 12 labels, created 12 nodes, set 12 properties, created 11 relationships, completed after 9 ms.
Vamos ver o que temos:
MATCH (p:Person) RETURN p
Ninguém nos proíbe de editar a aparência do gráfico resultante:
O que pode ser feito com isso? Você pode verificar se, por exemplo, Pam é
Pai de Bob:
MATCH ans = (:Person {name: "Pam"})-[:PARENT]->(:Person {name: "Bob"}) RETURN ans
Obtemos o subgráfico correspondente:
No entanto, isso não é exatamente o que precisamos. Altere a solicitação:
MATCH ans = (:Person {name: "Pam"})-[:PARENT]->(:Person {name: "Bob"}) RETURN ans IS NOT NULL
Agora, em resposta, nos tornamos true . E se perguntarmos:
MATCH ans = (:Person {name: "Pam"})-[:PARENT]->(:Person {name: "Liz"}) RETURN ans IS NOT NULL
Não receberemos nada ... Aqui você precisa adicionar a palavra OPTIONAL , se
o resultado estará vazio e false será retornado:
OPTIONAL MATCH ans = (:Person {name: "Pam"})-[:PARENT]->(:Person {name: "Liz"}) RETURN ans IS NOT NULL
Agora temos a resposta esperada false .
Em seguida, você pode ver quem é o pai de quem:
MATCH (p1:Person)-[:PARENT]->(p2:Person) RETURN p1, p2
Abra a guia de resultados com Text e veja uma tabela com duas colunas:
╒═══════════════╤═══════════════╕ │"p1" │"p2" │ ╞═══════════════╪═══════════════╡ │{"name":"Pam"} │{"name":"Bob"} │ ├───────────────┼───────────────┤ │{"name":"Tom"} │{"name":"Bob"} │ ├───────────────┼───────────────┤ │{"name":"Tom"} │{"name":"Liz"} │ ├───────────────┼───────────────┤ │{"name":"Kate"}│{"name":"Liz"} │ ├───────────────┼───────────────┤ │{"name":"Mary"}│{"name":"Ann"} │ ├───────────────┼───────────────┤ │{"name":"Bob"} │{"name":"Ann"} │ ├───────────────┼───────────────┤ │{"name":"Bob"} │{"name":"Pat"} │ ├───────────────┼───────────────┤ │{"name":"Dick"}│{"name":"Jim"} │ ├───────────────┼───────────────┤ │{"name":"Ann"} │{"name":"Jim"} │ ├───────────────┼───────────────┤ │{"name":"Pat"} │{"name":"Joli"}│ ├───────────────┼───────────────┤ │{"name":"Jack"}│{"name":"Joli"}│ └───────────────┴───────────────┘
O que mais podemos aprender? Por exemplo, quem é o pai de um membro específico do gênero, por exemplo, para Bob:
MATCH (parent:Person)-[:PARENT]->(:Person {name: "Bob"}) RETURN parent.name
╒═════════════╕ │"parent.name"│ ╞═════════════╡ │"Tom" │ ├─────────────┤ │"Pam" │ └─────────────┘
Aqui, como resposta, não solicitamos o nó inteiro, mas apenas seu atributo específico.
Também podemos descobrir quem são os filhos de Bob:
MATCH (:Person {name: "Bob"})-[:PARENT]->(child:Person) RETURN child.name
╒════════════╕ │"child.name"│ ╞════════════╡ │"Ann" │ ├────────────┤ │"Pat" │ └────────────┘
Também podemos perguntar quem tem filhos:
MATCH (parent:Person)-[:PARENT]->(:Person) RETURN parent.name
╒═════════════╕ │"parent.name"│ ╞═════════════╡ │"Pam" │ ├─────────────┤ │"Tom" │ ├─────────────┤ │"Tom" │ ├─────────────┤ │"Kate" │ ├─────────────┤ │"Mary" │ ├─────────────┤ │"Bob" │ ├─────────────┤ │"Bob" │ ├─────────────┤ │"Dick" │ ├─────────────┤ │"Ann" │ ├─────────────┤ │"Pat" │ ├─────────────┤ │"Jack" │ └─────────────┘
Hmm, Tom e Bob se conheceram duas vezes, conserte:
MATCH (parent:Person)-[:PARENT]->(:Person) RETURN DISTINCT parent.name
Adicionamos a palavra DISTINCT ao resultado de retorno da consulta, o que significa
semelhante ao do SQL.
╒═════════════╕ │"parent.name"│ ╞═════════════╡ │"Pam" │ ├─────────────┤ │"Tom" │ ├─────────────┤ │"Kate" │ ├─────────────┤ │"Mary" │ ├─────────────┤ │"Bob" │ ├─────────────┤ │"Dick" │ ├─────────────┤ │"Ann" │ ├─────────────┤ │"Pat" │ ├─────────────┤ │"Jack" │ └─────────────┘
Você também pode perceber que o Neo4j nos devolve os pais na ordem em que foram inseridos na solicitação CREATE .
Vamos agora perguntar quem é avô ou avó:
MATCH (grandparent:Person)-[:PARENT]->()-[:PARENT]->(:Person) RETURN DISTINCT grandparent.name
Ótimo, é isso:
╒══════════════════╕ │"grandparent.name"│ ╞══════════════════╡ │"Tom" │ ├──────────────────┤ │"Pam" │ ├──────────────────┤ │"Bob" │ ├──────────────────┤ │"Mary" │ └──────────────────┘
No modelo de consulta, usamos um nó sem nome intermediário () e duas relações do tipo PARENT .
Agora descobrimos quem é o pai. O pai é um homem que tem um filho. Assim, nos faltam dados sobre quem é o homem. Assim, para determinar quem é mãe, você precisa saber quem é mulher. Adicione as informações relevantes ao nosso banco de dados. Para isso, atribuiremos os rótulos Male e Female aos nós existentes.
MATCH (p:Person) WHERE p.name IN ["Tom", "Dick", "Bob", "Jim", "Jack"] SET p:Male
MATCH (p:Person) WHERE p.name IN ["Pam", "Kate", "Mary", "Liz", "Ann", "Pat", "Joli"] SET p:Female
Vamos explicar o que fizemos aqui: selecionamos todos os nós rotulados como Person , verificamos eles
a propriedade name acordo com a lista especificada entre colchetes e atribuiu aos nós correspondentes o rótulo Male ou Female respectivamente.
Verifique:
MATCH (p:Person) WHERE p:Male RETURN p.name
╒════════╕ │"p.name"│ ╞════════╡ │"Tom" │ ├────────┤ │"Bob" │ ├────────┤ │"Dick" │ ├────────┤ │"Jack" │ ├────────┤ │"Jim" │ └────────┘
MATCH (p:Person) WHERE p:Female RETURN p.name
╒════════╕ │"p.name"│ ╞════════╡ │"Pam" │ ├────────┤ │"Kate" │ ├────────┤ │"Mary" │ ├────────┤ │"Liz" │ ├────────┤ │"Ann" │ ├────────┤ │"Pat" │ ├────────┤ │"Joli" │ └────────┘
Solicitamos todos os nós rotulados Person , que também possuem um rótulo Male ou Female , respectivamente. Mas poderíamos tornar nossos pedidos um pouco diferentes:
MATCH (p:Person:Male) RETURN p.name MATCH (p:Person:Female) RETURN p.name
Vamos dar uma olhada no nosso gráfico novamente:
O Neo4j Browser pintou os nós em duas cores diferentes, de acordo com as marcas Masculino e
Feminino
Ok, agora podemos consultar todos os pais do banco de dados:
MATCH (p:Person:Male)-[:PARENT]->(:Person) RETURN DISTINCT p.name
╒════════╕ │"p.name"│ ╞════════╡ │"Tom" │ ├────────┤ │"Bob" │ ├────────┤ │"Dick" │ ├────────┤ │"Jack" │ └────────┘
E mães:
MATCH (p:Person:Female)-[:PARENT]->(:Person) RETURN DISTINCT p.name
╒════════╕ │"p.name"│ ╞════════╡ │"Pam" │ ├────────┤ │"Kate" │ ├────────┤ │"Mary" │ ├────────┤ │"Ann" │ ├────────┤ │"Pat" │ └────────┘
Vamos agora formular um relacionamento de irmão e irmã. X é irmão de Y,
se ele é homem, e para X e Y há pelo menos um pai em comum. Da mesma forma para
irmã de relacionamento.
Atitude do irmão em Cypher:
MATCH (brother:Person:Male)<-[:PARENT]-()-[:PARENT]->(p:Person) RETURN brother.name, p.name
╒══════════════╤════════╕ │"brother.name"│"p.name"│ ╞══════════════╪════════╡ │"Bob" │"Liz" │ └──────────────┴────────┘
Atitude de irmã em Cypher:
MATCH (sister:Person:Female)<-[:PARENT]-()-[:PARENT]->(p:Person) RETURN sister.name, p.name
╒═════════════╤════════╕ │"sister.name"│"p.name"│ ╞═════════════╪════════╡ │"Liz" │"Bob" │ ├─────────────┼────────┤ │"Ann" │"Pat" │ ├─────────────┼────────┤ │"Pat" │"Ann" │ └─────────────┴────────┘
Assim, podemos descobrir quem é o pai e quem é o avô ou a avó. Mas e os ancestrais mais distantes? Com os bisavôs, os bisavós ou assim por diante? Não escreveremos uma regra correspondente para cada um desses casos, e será sempre mais problemática. De fato, tudo é simples: X é um ancestral para Y se for um ancestral para um pai Y. Cypher fornece um padrão * que permite exigir uma sequência de relações de qualquer tamanho:
MATCH (p:Person)-[*]->(s:Person) RETURN DISTINCT p.name, s.name
Existe realmente um problema nisso: serão quaisquer conexões. Adicione uma referência ao link PARENT :
MATCH (p:Person)-[:PARENT*]->(s:Person) RETURN DISTINCT p.name, s.name
Para não aumentar o comprimento do artigo, encontramos todos os ancestrais de Joli :
MATCH (p:Person)-[:PARENT*]->(:Person {name: "Joli"}) RETURN DISTINCT p.name
╒════════╕ │"p.name"│ ╞════════╡ │"Jack" │ ├────────┤ │"Pat" │ ├────────┤ │"Bob" │ ├────────┤ │"Pam" │ ├────────┤ │"Tom" │ └────────┘
Considere uma regra mais complexa para descobrir quem está relacionado a quem.
Primeiro, parentes são ancestrais e descendentes, por exemplo, filho e mãe, avó e neto. Em segundo lugar, parentes são irmãos e irmãs, incluindo primos, primos em segundo grau e assim por diante, o que em termos de antepassados significa que eles têm um ancestral em comum. E em terceiro lugar, parentes que têm descendentes em comum, por exemplo, marido e mulher, são considerados parentes.
No Cypher, você precisa usar o UNION para muitos padrões:
MATCH (r1:Person)-[:PARENT*]-(r2:Person) RETURN DISTINCT r1.name, r2.name UNION MATCH (r1:Person)<-[:PARENT*]-(:Person)-[:PARENT*]->(r2:Person) RETURN DISTINCT r1.name, r2.name UNION MATCH (r1:Person)-[:PARENT*]->(:Person)<-[:PARENT*]-(r2:Person) RETURN DISTINCT r1.name, r2.name
Aqui, na primeira regra, as conexões são usadas, cuja direção não importa para nós. Essa conexão é indicada sem uma seta, apenas um traço - . A segunda e terceira regra são escritas de uma maneira óbvia e familiar.
Não apresentaremos o resultado da consulta total aqui, apenas dizeremos que os pares de parentes encontrados são 132, o que é consistente com o valor calculado como o número de pares ordenados de 12. Também podemos especificar essa consulta substituindo a ocorrência da variável r1 ou r2 por (:Person {name: "Liz"}) por exemplo, no entanto, no nosso caso, isso não faz muito sentido, pois todas as pessoas em nosso banco de dados são obviamente parentes.
Isso conclui nossa discussão sobre a identificação de relacionamentos entre pessoas em nosso banco de dados.
Por fim, considere como remover nós e links.
Para excluir todas as nossas pessoas, você pode executar a solicitação:
MATCH (p:Person) DELETE p
No entanto, o Neo4j nos dirá que você não pode excluir nós que possuem links.
Portanto, primeiro excluímos os links e depois repetimos a remoção dos nós:
MATCH (p1:Person)-[r]->(p2:Person) DELETE r
O que fizemos agora: comparou duas pessoas entre as quais há uma conexão, nomeou essa conexão como r depois a excluiu.
Conclusão
O artigo mostra como usar os recursos da linguagem de consulta Cypher usando um exemplo simples de um gráfico social. Em particular, examinamos como adicionar nós e links com uma consulta, como procurar dados relacionados, inclusive com links indiretos, e como atribuir rótulos aos nós. Mais informações sobre o Cypher podem ser encontradas nos links abaixo. Um bom ponto de partida é o "Neo4j Cypher Refcard".
O Neo4j está longe de ser o único gráfico DBMS. Entre os outros mais populares estão Cayley , Dgraph com linguagem de consulta GraphQL, multi-modelo ArangoDB e OrientDB . De particular interesse pode ser o Blazegraph, com suporte para RDF e SPARQL.
Referências
Bibliografia
- Robinson Jan, Weber Jim, Eifrem Emil. Bases de dados de gráficos. Novos recursos
por trabalhar com dados relacionados / Por. do inglês - 2ª ed. - M.: DMK-Press,
2016 - 256 s. - Bratko I. Programação em linguagem Prolog para inteligência artificial:
trans. do inglês - M .: Mir, 1990 - 560 p .: doente.
Posfácio
O autor do artigo conhece apenas duas empresas (ambas de São Petersburgo) que usam DBMSs gráficos para seus produtos. Mas eu gostaria de saber quantas empresas de leitores deste artigo as utilizam em seu desenvolvimento. Portanto, proponho participar da pesquisa. Escreva também sobre sua experiência nos comentários, será muito interessante saber.