Introdução ao NEO4J
Tags: neo4j, beginners, database, nosql
Published: 2020-11-28 01:13:42

## O que é o Neo4j?

O [neo4j](https://neo4j.com/) é um banco NoSql que utiliza a teoria de grafos e o [cypher](https://en.wikipedia.org/wiki/Cypher_(query_language)) como sua linguagem oficial ao invés do `sql`, para poder criar um modelo menos genérico que os bancos relacionais, ou seja nele não precisamos de um design de tabelas para podermos popular o banco.

## Definições

###  Nó (node)

É responsável por guardar os dados de uma entidade, podendo ter mais de uma propriedade, mas podendo ter apenas um `label`.

### Relação (relationship)

A relação fica responsável de gravar a relação de um `nó` com o outro, por exemplo um autor pode ter uma relação com o livro.

## Explicando principais comandos

*  <b>MATCH</b>:  usado para dizer qual nó iremos buscar, pode se dizer que é o comando `SELECT` muito usado num banco relacional.
*  <b> CREATE </b>: responsável por criar nós e relacionamentos entre eles.
*  <b> MERGE </b>:  utilizado para criar nós em relações quando eles não existem.
*  <b> SET </b>: muda as propriedades de uma relação ou nó.
*  <b>RETURN</b>:  traz os resultados das consultas.
*  <b>REMOVE</b>: remove uma propriedade de um nó ou relação. Também serve para remover um label do nó.
*  <b>WITH</b>: serve para expor o resultado de um `MATCH` anterior para um próximo `MATCH` ou talvez, para um `RETURN` um pouco mais complexo. É a chave para quebrar patterns complexos em queries menores possivelmente mais rápidas.



## Exemplos de uso dos comandos Cypher

### Cria nó sem label

```
create()
```
###  Retorna todos os nós

```
match (no) 
return no 
```
### Cria nó com valor nome

```
create ({nome: "Doriana"}) 
```
### Retorna nó com o valor especificado

```
match(no {nome: "Doriana"}  ) 
return no
```

### Deleta o nó da variável, ou seja deleta tudo!

```
match (no)
delete no
```

### Cria um label para um nó

```
create (:Pessoa {nome: "Asdrubal"}) 
```

### Filtra pelo um label especifico

```
match (n:Pessoa) return n
```

### Filtra pelo label pessoa e seta a quantidade de dados que se trás da consulta

```
match (n:Pessoa) 
return n 
limit 1
```

### Criando um nó com uma aresta


A aresta é representada pelo sinal de  ` --> `  dessa forma se cria uma aresta sem label,
no exemplo á baixo criamos uma aresta com label   ` -[:Label]-> `

```
create(:Livro 
{titulo: "Alice"})
 -[:Autor]-> (:Pessoa {nome: "Lewis Caroll"})
```

### Criando uma query para associar uma aresta

Na query a baixo criamos duas variáveis  e associamos uma aresta a elas:

```
match (asd:Pessoa {nome: 'Asdrubal'}) 
match (al:Livro {titulo: 'Alice'})
create(asd) -[:Leu]-> (al)

```

### Associando todas pessoas a um livro

```
match (p:Pessoa) 
match (cc:Livro {titulo: 'Crime e Castigo'})
create(p) -[:Leu]-> (cc)
```

```
create (:Pessoa {nome: "Lindaura"})
create (:Pessoa {nome: "Alcebiades"})
match (asd:Pessoa {nome: "Asdrubal"})
match (lind:Pessoa {nome: "Lindaura"})
match (guia:Livro {titulo: "Guia do mochileiro"})
match (hobit:Livro {titulo: "O Hobit"})
create (asd)-[:Leu]-> (guia)
create (asd)-[:Leu]-> (hobit)
create (lind)-[:Leu]-> (guia)
create (lind)-[:Leu]-> (hobit)
```

### Filtra as pessoas que já leram um livro x

```
match (p:Pessoa)
-[:Leu]-> (g:Livro {titulo:"Guia do mochileiro"})
return p
```

### Filtro com duas condições num mesmo `Match` 

```
match (h:Livro{titulo: "O Hobit"})
<-[:Leu]-(p:Pessoa)
-[:Leu]-> (g:Livro {titulo:"Guia do mochileiro"})
return p
```

### Pegando todo mundo que leu Lewis Caroll

```
match (p:Pessoa)
-[:Leu]->(:Livro)-[:Autor]->
(:Pessoa {nome: "Lewis Caroll"})
return p
```

### Filtrando e trazendo livro e pessoa

```
match (p:Pessoa)-[:Leu]->
(l:Livro {titulo: "Crime e Castigo"})
return p,l
```

```
match (p:Pessoa)-[:Leu]->(l:Livro)
<-[:Autor]-(n:Pessoa {nome:"Alcebiades"})
return p,l
```

### Usando um count na query

```
match (p:Pessoa)-[:Leu]->(l:Livro)
<-[:Autor]-(n:Pessoa {nome:"Alcebiades"})
return count(p)
```

```
match (p:Pessoa)-[:Leu]->(l:Livro)
<-[:Autor]-(n:Pessoa {nome:"Alcebiades"})
return count(distinct p)
```

### Método merge

O `merge` verifica se a propriedade foi criada, se não foi criada ele cria, caso já exista você pode acrescentar o `on` e dizer oque le deve fazer:

```
match (p:Pessoa)-[:Leu]->(l:Livro)
<-[:Autor]-(n:Pessoa {nome:"Alcebiades"})
merge (p)-[lei:Leitor]->(n)
on create set lei.livros=1
on match set lei.livros=lei.livros+1
```
```
merge
   (l:Cidade {local: 'Cidade Ademar, São Paulo'})-[:Previsao]->(t:Tempo {data: '15/02/2021',
	hora: '13:16',
	infoAtual: 'Parcialmente nublado',
	infoTemp: 'Tempestades isoladas com raios e trovões',
	maxTemp: '28°C',
	minTemp: '18°C',
	temperatura: '28°C'}) 
    
```
Esse exemplo a baixo é um filtro trazendo a nova propriedade criada:

```
match (p:Pessoa)-[:Leu]->(l:Livro)
<-[:Autor]-(n:Pessoa {nome:"Alcebiades"})
match (p)-[lei:Leitor]->(d)
return p,l,lei,n
```

### Usando where e alterando dados de uma pessoa

```
match (p:Pessoa) where ID(p) = 10
set p.nome = 'João P'
return *
```
<br/> <br/> 
###### Referências:

[NEO4J — Primeiros passos](https://medium.com/neo4j-primeiros-passos/neo4j-primeiros-passos-ee4e319e33bb)

[Uma gentil introdução ao uso de banco de dados orientados a grafos com Neo4j](https://medium.com/accendis-tech/uma-gentil-introdu%C3%A7%C3%A3o-ao-uso-de-banco-de-dados-orientados-a-grafos-com-neo4j-ca148df2d352)

[Documentação neo4j](http://neo4j.com/docs/2.1/cypher-refcard/)