O documento discute bancos de dados em grafos. Ele explica que esses bancos armazenam dados em forma de nós, arestas e propriedades, representando relacionamentos entre entidades. O documento também apresenta exemplos de uso do Neo4j, um banco de dados em grafo popular, demonstrando como criar e consultar dados nesse modelo.

1. Bancos de Dados
em Grafos
Por Daniel San Martin Pascal Filho
#engenhariadedados
#cienciadedados
1
Exemplo com Neo4J

2. Modelo de Grafos
• É um modelo de banco de dados que utiliza estruturas
de grafos para consultas semânticas.
• Seus dados são representados por nós, arestas e
propriedades.
• Baseado na Teoria dos Grafos
• São um tipo de banco NoSQL.
• Priorizam a relação entre os dados.
• São rápidos pois armazenam os relacionamentos no
banco fisicamente. 2

3. Modelo de Grafos
G= (V,E)
• V são os vértices.
• E é o conjunto de arestas.
Os vértices podem ser entendidos como entidades e as
arestas como relacionamentos entre entidades com outras
entidades ou com ela mesma.
3

4. Caracterização de BDs de Grafos
Bancos em Grafos NoSQL caracterizam-se quanto à
natureza como:
• Grafos simples: composto por nós, arestas, um atributo
e uma direção.
4
A
B
C

5. • Hipergrafo: arestas são conjuntos ao invés de pares que
pode apontar para mais de dois nós ou para outra
aresta.
• Exemplo: V={A,B,C,D} e E={{A,B,C},{A,D,B}}
Caracterização de BDs de Grafos
5A
B
C
D

6. • Grafos com atributos: os vértices e arestas podem
conter atributos.
• Grafos aninhados: no qual um subconjunto de vértices
também pode formar um grafo.
Caracterização de BDs de Grafos
6
Imagem: exemplo de grafo aninhado (hypernode)
Fonte: https://www.slideshare.net/moumie/graph-based-data-models

7. Como surgiram
• Mainframe da IBM usava modelo de dados hierárquico ou de
rede.
• O modelo de dados da rede da década de 1970 não difere do
modelo de grafos devido a falta de uma linguagem de consulta
própria, obrigado a conhecer a localização física dos dados.
• Em 1980, o modelo relacional roubando a atenção do mercado.
• Em 1990, W3C trabalha em padrões como XML e RDF, que
podem ser entendidos como grafos e dados semi-estruturados
crescem.
• A partir de 1998, o NoSQL começa a ganhar força e volta o
interesse em Bancos de Grafos.
7

8. Vantagens dos BDG
• São rápidos pois armazenam os relacionamentos no
banco fisicamente.
• Permitem a recuperação simples e rápida de estruturas
hierárquicas complexas.
• Facilitam a visualização dos dados.
• Queries no contexto de grafos.
• Algoritmos específicos.
• Modelam bem dados com muitas relações e cuja
estrutura é passível de muitas mudanças ao longo do
tempo.
8

9. Desvantagens dos BDG
• Resolvem tipos de problemas específicos.
• Focam em encontrar relações e não agregar dados.
○ Bancos relacionais podem ser mais indicados a quem
precisa fazer um sistema de cadastro de clientes por
exemplo.
• Costumam exigir o aprendizado de linguagens diferentes do
SQL. Ex: Cypher, SparcQL.
• Poucos desenvolvedores utilizam.
• São relativamente menos maduros em relação aos SGBDs.
• Não há padronização.
9

10. Exemplos de aplicações
• Mecanismos de recomendações
• Web Semântica
• Redes sociais
• Investigações
10

11. PRÁTICA COM NEO4J

12. Neo4J
• SGBD em Grafo desenvolvido pela Neo4j, Inc.
• Banco de dados transacional compatível com ACID
• Armazenamento e processamento de grafos de forma
nativa.
• É o mais popular em sua categoria (Grafo + NoSQL)
• Implementado em Java
• Utiliza a linguagem Cypher Query por meio de um
endpoint HTTP
12

13. Neo4J
• Tudo é armazenado na forma de uma aresta, nó ou
atributo.
• Cada nó e aresta podem ter diversos atributos.
• Ambos nós e arestas podem ter rótulos.
• Os rótulos podem ser usados para restringir pesquisas.
13

14. Nós
• Nós são os principais elementos de
dados
• Os nós estão conectados a outros nós
por meio de relacionamentos
• Os nós podem ter uma ou mais
propriedades.
• Os nós têm um ou mais rótulos que
descrevem seu papel no gráfico
14
Fonte: https://neo4j.com/product/
Fonte:https://www.tutorialspoint.com/
neo4j/neo4j_graph_theory_basics.ht
m

15. Relacionamentos
• Relacionamentos conectam dois nós
• Relacionamentos são direcionais
• Os nós podem ter relacionamentos múltiplos e até
recursivos
• Relacionamentos podem ter uma ou mais
propriedades
15
Fonte: https://neo4j.com/product/

16. Propriedades
• Propriedades são valores nomeados onde o nome
(ou chave) é uma string
• Propriedades podem ser indexadas e restringidas
• Índices compostos podem ser criados a partir de
múltiplas propriedades
16
Fonte: https://neo4j.com/product/

17. Rótulos
• Os rótulos são usados para agrupar nós em
conjuntos
• Um nó pode ter vários rótulos
• Os rótulos são indexados para acelerar a localização
de nós no grafo
• Índices de rótulos nativos são otimizados para
oferecer mais velocidade nas consultas
17
Fonte: https://neo4j.com/product/

18. Cypher
• Cypher é a linguagem de consulta do Neo4j que
permite aos usuários armazenar e recuperar dados
do banco de dados de gráficos.
• O Neo4j facilita a consulta, o entendimento e o uso
de dados nos grafos.
• O Cypher é fortemente baseado em padrões e é
projetado para reconhecer várias versões desses
padrões em dados, tornando-o uma linguagem
simples e lógica para os usuários aprenderem.
18
Fonte: https://neo4j.com/product/

19. Cypher
• O reconhecimento de padrões é fundamental para o
funcionamento do cérebro.
• Lembre-se: mapas mentais, jogos de memórias.
• O Cypher é fortemente baseado em padrões e é
projetado para reconhecer várias versões desses
padrões em dados, tornando-o uma linguagem
simples e lógica para os usuários aprenderem.
• Nós e relacionamentos são os componentes simples
que constroem a parte mais valiosa e poderosa do
modelo de grafo - o padrão.
19
Fonte: https://neo4j.com/product/

20. Cypher: padrões
• Padrões são a base do Cypher.
• Projetado após ASCII Arte.
• Representa "nós" como círculos e "relacionamentos"
como setas.
○ (ident) -> (ident2)
○ onde ident e ident2 são identificadores.
20

21. Cypher: padrões
(u) - [r: TEM_ACESSO] -> (a).
• Identificadores de relacionamento: são especificados
entre colchetes.
21

22. Cypher: padrões
(l: Leitor) -> (r: Revista)
• Rótulos são especificados de forma parecidas aos
tipos de relacionamento.
22

23. Cypher: padrões
23
Fonte: https://neo4j.com/developer/cypher-query-language/#_why_cypher

24. Cypher: padrões
(l: Leitor) -> (r: Revista)
• Rótulos são especificados de forma parecidas aos
tipos de relacionamento.
24

25. Tipos de propriedades
• Number, um tipo abstrato, que possui os subtipos
Integer e Float
• Strings
• Booleano
• Coordenadas espaciais
• Tipos Temporais: Data, Hora, LocalTime, DateTime,
LocalDateTime e Duration
25

26. Cypher Keywords
MATCH
• Encontre todos os nós com um relacionamento
particular, padrões de nós e relacionamentos.
RETURN
• Retorna nós, relacionamentos, propriedades ou
padrões nos resultados das consultas.
• Necessário nas consultas, mas não para gravação.
26

27. Principais comandos Cypher
• CREATE: criar nós e relacionamentos entre eles.
• DELETE: responsável por apagar nó ou relação
inteira.
• MERGE: criar nós e relações apenas quando eles não
existem na base.
• SET: define as propriedades de uma relação ou nó.
• DETACH DELETE: apagar as relações de um nó a ser
excluído.
27

28. Principais comandos Cypher
• REMOVE: remove uma propriedade de um nó ou
relação. Remove label de nós.
• WITH: expõe o resultado de um MATCH anterior
para um próximo MATCH ou para um RETURN.
Usado para dividir padrões de consultas mais
complexos em menores.
28

29. Neo4J na prática
• A prática a seguir utiliza o Ubuntu14.2 como sistema
operacional.
• Pode-se utilizar uma VM para VirtualBox por
exemplo.
29

30. 30
● Instalar dependências para o add-apt-repository:
$ sudo apt-get update
$ sudo apt-get upgrade
$ sudo apt-get install -y software-properties-common
● Para usar o Neo4J, é necessário ter o Java 8 (ou
superior) instalado. Pode ser o JRE ou o JDK.
● O pode rodar no Oracle JDK, OpenJDK, IBM JVM
e Azul Zing.
Neo4J na prática

31. 31
$ sudo add-apt-repository ppa:openjdk-r/ppa
$ sudo apt-get update
● Adicionar repositório para Java 8:
$ sudo apt-get install oracle-java8-set-default
$ sudo apt-get install openjdk-8-jdk
$ java -version
openjdk version "1.8.0_171"
OpenJDK Runtime Environment (build 1.8.0_171-8u171-
b11-2~14.04-b11)
OpenJDK 64-Bit Server VM (build 25.171-b11, mixed
mode)
● Instalar Java 8:
Neo4J na prática

32. Prática: Neo4J
32
$ sudo update-alternatives --config java
● Caso você já tenha outras versões de Java
instalada é preciso escolher a versão 8:
$ sudo apt-get install oracle-java8-set-default

33. 33
$ wget --no-check-certificate -O -
https://debian.neo4j.org/neotechnology.gpg.key | sudo
apt-key add -
● Instalação Neo4J
$ sudo apt-get install oracle-java8-set-default
Neo4J na prática

34. 34
$ echo 'deb http://debian.neo4j.org/repo stable/' |
sudo tee -a /etc/apt/sources.list.d/neo4j.list
$ sudo apt-get update
$ sudo apt-get install neo4j
● Instalação Neo4J
$ sudo apt-get install oracle-java8-set-default
Neo4J na prática

35. 35
$ sudo -u neo4j neo4j-admin set-initial-password
SUA_SENHA
● Instalação Neo4J
$ sudo apt-get install oracle-java8-set-default
Neo4J na prática

36. 36
Desabilite a autenticação caso ocorra algum problema
$ sudo vi /etc/neo4j/neo4j.conf
# descomente a linha abaixo
dbms.security.auth_enabled=true
● Instalação Neo4J
$ sudo apt-get install oracle-java8-set-default
Neo4J na prática

37. Neo4J: Comandos
37
// Acessando o Cypher Shell
$ cypher-shell
● Criar um nó
● Conectar nós
● Remover um nó
● Atualizar a informação de um nó

38. Neo4J: Comandos
38
CREATE (n {Nome:"Pedro"});
● Criar um nó
MATCH (n {Nome: "Pedro"}) return n;
● Consultar o nó criado
START n=node(*) RETURN count(n);
● Quantos nós temos?

39. Neo4J: Comandos
39
MATCH (n {Nome: "Pedro"}) DELETE n;
● Remover um nó
MATCH (n) OPTIONAL MATCH (n)-[r]-() DELETE n,r;
● Remover tudo!

40. Neo4J: Comandos
40
// os comandos devem ser executados de uma única vez.
CREATE (c1:Cliente {Nome: "Maria", Id: 1 })
CREATE (c2:Cliente {Nome: "João", Id: 2 })
CREATE (c3:Cliente {Nome: "Cris", Id: 3 })
CREATE (v1:Vendedor {Nome: "Matias", Id: 1 })
CREATE (v2:Vendedor {Nome: "Julieta", Id: 2 })
CREATE (p1:Produto {Nome: "Sapato", Id: 1})
CREATE (p2:Produto {Nome: "Camiseta", Id: 2})
CREATE (p3:Produto {Nome: "Bolsa", Id: 3})
CREATE (c1)-[r1:COMPROU {Quantidade: 2}]->(p1)
CREATE (c1)-[r2:COMPROU {Quantidade: 3}]->(p2)
CREATE (c2)-[r3:COMPROU {Quantidade: 2}]->(p1)
CREATE (c3)-[r4:COMPROU {Quantidade: 2}]->(p1)
CREATE (c3)-[r5:COMPROU {Quantidade: 2}]->(p2)
CREATE (c3)-[r6:COMPROU {Quantidade: 2}]->(p3)
CREATE (v1)-[r7:VENDEU_PARA]->(c1)
CREATE (v1)-[r8:VENDEU_PARA]->(c3)
CREATE (v2)-[r9:VENDEU_PARA]->(c2);
● Criando nós e relações

41. Neo4J: Comandos
41
MATCH (n:Produto) RETURN count(n);
● Quantos produtos temos?
MATCH (n:Cliente) RETURN count(n);
● Quantos clientes temos?
MATCH (u:Cliente) return *;
● Quem são nossos clientes?

42. Neo4J: Comandos
42
MATCH (c:Cliente{ Id: 1}), (p:Produto) RETURN *;
● Quais produtos o cliente 1 comprou?
MATCH (c)-[:COMPROU]->(p:Produto {Nome:'Camiseta'})
RETURN c;
● Quem comprou camiseta?
● Qual o produto mais vendido?
MATCH (c)-[r:COMPROU]->(p) RETURN p.Nome ORDER BY
r.Quantidade DESC LIMIT 1;

43. Neo4J: Comandos
43
MATCH (c:Cliente{ Id: 1}), (p:Produto) RETURN *;
● Qual é o vendedor com mais clientes?
MATCH (v)-[r:VENDEU_PARA]->(c) RETURN v.Nome AS
Nome_Vendedor, count(v.Nome) AS Total_Clientes ORDER
BY Total_Clientes DESC LIMIT 1;
● Qual o vendedor que vendeu mais produtos?
● Qual outro produto devemos oferecer para João?
MATCH (joao:Cliente{ Nome:'João'})-[ :COMPROU]-
>(p_joao)<-[:COMPROU]-(clientes)-[:COMPROU]-
>(produtos)
RETURN produtos.Nome;

44. Gostou? Deixe seu Like e Compartilhe.
Obrigado!