04 neo4j Flashcards
:clear
equivalente a cls
match (anyX) return anyX
match (anyX) return anyX limit 666
retorna tudo da database
retorna no máximo 666 nodos, todas relações entre os 666
(node) [relation]
1) match (x1)–(x2) return x1, x2 limit 1
2) match (x1)-[y]-(x2) return x1, y, x2 limit 1
3) match (x1)-[y]-(x2)
return x1, y, x2
limit 1
returna um unico nodo x1 com conexao com nodo x2
retorna com mais detalhes
3 = 2
match (x1)-[y]->(x2)
return x1, y, x2
limit 1
Observar seta
match (ator:Person)-[relação:ACTED_IN]->(filme:Movie)
return ator, relação, filme
limit 5
retorna 5 relações em que uma Person Acted_In a Movie
match (ator:Person)-[relação:ACTED_IN | DIRECTED]->(filme:Movie)
return ator, relação, filme
limit 10
retorna 10 relações em que uma Person Acted_In OR Directed a Movie
match (filme:Movie)
return filme.title
limit 1
Retorna somente a propertie title de um Movie
match (filme:Movie)
match (diretor:Person)-[:DIRECTED]->(filme)
match (diretor)-[:ACTED_IN]->(filme)
return filme.title, diretor.name
retorna o title do movie e o name da Person que dirirgiu e atuou no filme em questão
match (filme:Movie) optional match (diretor:Person)-[:DIRECTED]->(filme)
retorna todos os filmes da database, naqueles em que o diretor não é também ator, o campo diretor name fica “null”, caso tenha dirigido e atuado aparece o nome dele.
match (pa:Person)-[:HAS_CONTACT]->(pb:Person)-[:HAS_CONTACT]->(pc:Person)
where pa <> pc
return pa.name, pb.name, pc.name
limit 1
retorna os nomes das pessoas pa, pb, pc, sendo pa diferente de pc, em que pa tem contato de pb e pb tem contato de pc
match (p1:Person)-[:HAS_CONTACT]->(p2:Person) optional match (p2)-[:DIRECTED]->(filme:Movie) return p1.name, p2.name, filme.title
limite de linhas do neo4j é 1000
Retorna as Persons p1 que tem contato com as Persons p2, se essa pessoa dirigiu algum filme, aparece o nome de todos os filmes, caso não tenha dirigido, aparece null
match (x {name: ‘Tom Hanks’, born: 1956})
return x
match (x:Person)
where x.name = ‘Tom Hanks’ and x.born = 1956
return x
Sinônimos, Where é melhor
Retorna o nodo em que o nome é Tom Hanks e o Ano de Nascimento é 1956
neo4j é case sensitive
sim
match (x:Person)
where x.born <> 1956
return x
Retorna as pessoas que não foram nascidas em 1956
> =, >, <=,
match (x:Person)
where x.name >= ‘T’
return x
Retorna pessoas cujos nomes começam com T ou letra após no alfabeto
match (x:Person)
where x.born = 1956 or x.born = 1957 or x.born = 1958
return x
match (x:Person)
where x.born in [1956, 1957, 1958]
return x
retorna pessoas que nasceram em 1956, 1957 ou 1958
Sinônimos
match (x:Person)
where x.born >= 1950 and x.born < 1960
return x
retorna pessoas que nasceram entre 1950 e 1959 (incluindo os dois anos)
match (x:Person) where not (x.born >= 1950 and x.born < 1960) return count(x)
retorna quantas pessoas nasceram 1949 ou antes OU 1960 ou depois
match (pessoa:Person)–>(filme:Movie)
where filme.title = ‘Unforgiven’ and not (pessoa)-[:DIRECTED]->(filme)
return pessoa, filme
retorna as pessoas que têm alguma relação com o filme Unforgiven exceto ser diretor
AND
OR
IN
NOT
Booleans
match (pessoa:Person)–>(filme:Movie)
where filme.title = ‘Unforgiven’ and not (pessoa)-[:DIRECTED]->(filme)
return pessoa, filme
retorna as pessoas que têm alguma relação com o filme Unforgiven exceto ser diretor
match (filme:Movie)
where filme.title =~ ‘The.*’
return filme.title
match (filme:Movie)
where filme.title =~ ‘.The.’
return filme.title
match (filme:Movie)
where filme.title =~ ‘The .*’
return filme.title
match (filme:Movie)
where filme.title =~ ‘.+The .*’
return filme.title
retorna todos os filmes que começam com The
retorna bla bla Their além do The no início do título e no meio
retorna se The tem espaço depois (não retorna Their por exemplo)
.+ significa que nao pode ser a primeira palavra, tem que ser no meio
match (valueX:typeX)
where valueX.KeyX =~ ‘(?i).stringX.’
return valueX.KeyX
(?i) faz virar case insensitive
match (ator:Person)-[papel:ACTED_IN]->(filme:Movie)
where filme.title = ‘Top Gun’
return ator.name as Ator, papel.earnings as Ganhos
order by papel.earnings desc
skip 3
limit 2
pode escrever descending no lugar de desc
retorna o nome dos atores de Top Gun e quanto cada um ganhou
tabela em ordem descendente de valores
pula os 3 que mais ganharam
retorna do 4 ao 8o (5)
Resultado será uma tabela com 1a coluna Ator e 2a coluna Ganhos
match (tom:Person{name: “Tom Hanks”})
match (filme:Movie)
match (tom)-[:HAS_CONTACT]->(ator:Person)
match (ator)-[papel:ACTED_IN]->(filme)
where ator.born >= 1960 and papel.earnings > 10000000
return ator.name as ContactName, ator.born as Born, papel.earnings as Earnings
order by papel.earnings desc
Retorna todos os atores que o Tom Hanks tem contato e que foram nascidos em 1960 ou depois e que já gamharam mais de 10 milhões por um único filme
Contatos organizados em ordem descendente de ganhos, renomeadas as colunas para ContactName, Born e Earnings
match (tom:Person{name: “Tom Hanks”})
match (filme:Movie)
match (tom)-[:HAS_CONTACT]->(ator:Person)
match (ator)-[papel:ACTED_IN]->(filme)
where ator.born >= 1960 and papel.earnings > 10000000
return ator.name as ContactName, ator.born as Born, papel.earnings as Earnings
order by papel.earnings desc
Retorna todos os atores que o Tom Hanks tem contato e que foram nascidos em 1960 ou depois e que já gamharam mais de 10 milhões por um único filme
Contatos organizados em ordem descendente de ganhos, renomeadas as colunas para ContactName, Born e Earnings
match (tom:Person{name: “Tom Hanks”})
match (filme:Movie)
match (tom)-[:HAS_CONTACT]->(ator:Person)
match (ator)-[papel:ACTED_IN]->(filme)
where ator.born >= 1960 and papel.earnings > 10000000
return DISTINCT ator.name as ContactName
match (tom:Person{name: “Tom Hanks”})
match (filme:Movie)
match (tom)-[:HAS_CONTACT]->(ator:Person)
match (ator)-[papel:ACTED_IN]->(filme)
where ator.born >= 1960 and papel.earnings > 10000000
return count (DISTINCT ator.name)
Retorna todos os atores que o Tom Hanks tem contato e que foram nascidos em 1960 ou depois e que já gamharam mais de 10 milhões por um único filme, uma única vez por causa do DISTINCT
no segundo conta quantos são
COUNT AVG SUM MIN MAX
Aggregations Functions
match (tom:Person{name: "Tom Hanks"})-[papel:ACTED_IN]->(filme:Movie)
return sum (papel.earnings) as TotalEarningsRetorna TotalEarnings do Tom Hanks, a soma de todos os ganhos em todos os filmes em que atuou
AVG seria average (média)
MAX
MIN
toString (xxx)
toUpper (xxx), toLower
transforma xxx em “xxx”
transforma xxx em XXX, o contrário
return replace (“oh my god”, “o”, “X”)
“Xh my gXd”
return floor (6.8)
return ceil (6.8)
- 0
7. 0
return round (6.51)
return round (6.49)
7
6
match (ator:Person)-[papel:ACTED_IN]->(filme:Movie)
return toUpper(ator.name) as NOME, round(avg(papel.earnings)) as AverageEarnings
order by AverageEarnings desc
limit 1
retorna o ator com a melhor média de ganhos por filme
create (cat:Cat:Animal{“eats”:”Birds”,”sound”:”Meow”})
cria o node “cat”, que é tanto um Cat quanto um Animal, que eats birds e sound Meow
create (cat:Cat{name: “Fluffy”})-[:grooms]->(cat)
cria um gato chamado Fluffy que grooms com ele mesmo
create (joe:Bunny:Animal{name: “Joe Bunny”}),
sarah:Bunny:Animal{name: “Sarah Bunny”}
cria um coelho chamado Joe Bunny e outro chamado Sarah Bunny
match (joe:Bunny{name: “Joe Bunny”}),
(sarah:Bunny{name: “Sarah Bunny”})
merge (joe)-[:loves]->(sarah)
cria um nodo em que joe ama sarah
se já existe não cria, porque é MERGE e não CREATE (que duplicaria)
match (node)-[rel]-()
delete node, rel
Deleta tudo, exceto node sem relationship nenhuma
match (x)-[y]-()
delete x, y
match (x)
delete x
match (x) optional match (x)-[y]-() delete x, y
match (x)
detach delete x
Deleta tudo, exceto node sem relationship nenhuma
Deleta node sem relação
Deleta tudo mesmo
Deleta tudo mesmo (mesma coisa)
match(tom:Person{name:”Tom Hanks”}),
(other)-[contato:HAS_CONTACT]->(tom)
delete contato
Deleta o contato de Tom Hanks em todas as pessoas que têm
optional match (filme:Movie{title: "The Da Vinci Code"})
detach delete filmeExclui esse filme da database e todas suas relações
match (tom:Person{name: “Tom Hanks”})
set tom:Hansome, tom.sex = “male”
return tom
acrescenta sex male pro tom hanks e novo Label (tipo) de Handsome
match (tom:Person{name: “Tom Hanks”})
remove tom.sex
return tom
remove a propriedade sex do tom hanks
match (tom:Person{name: “Tom Hanks”})
remove tom:Handsome
return tom
Remove o label Handsome (Person é um label por exemplo)
match (tom:Person{name: “Tom Hanks”})-[:HAS_CONTACT]->(contact)
with tom, count(contact) as cont
set tom.contatinhos = cont
return tom
adiciona uma propriedade com o numero de contatos do tom
CHANGING RELATIONSHIP TYPES
match (x:Person{name: "Tom Hanks"})-[antiga:HAS_CONTACT]->(y:Person{name: "Halle Berry" })
create (x)-[nova:OLD_CONTACT]->(y)
set nova = antiga
delete antiga
return x, y
cria uma nova relação mantendo todas as propriedades da antiga, apaga a antiga
match (ator:Person)-[papel:ACTED_IN]->(filme:Movie)
with ator, sum(papel.earnings) as Bufunfa
where Bufunfa>=50000000
set ator:Rich, ator.Dindin = Bufunfa
return ator.name, ator.Dindin
Retorna os atores que ja ganharam mais de 50 milhoes na soma de todos os filmes que fizeram
match (ator:Person:Rich)
remove ator:Rich, ator.Dindin
Deleta o label Rich e a propriedade Dindin de todos na database
null
empty
Sem a propriedade solicitada (Undefined)
Propriedade presente mas vazia { }
with (true or false) as resulta
return result
with (true or null) as result
return result
with (false or null) as result
return result
with (true and null) as result
return result
with (false and null) as result
return result
with (null in [1,2,3,null]) as result
return result
with (null = null) as result
return result
with (null is null) as result
return result
true
true
null (undefined)
null (undefined)
false
null (undefined) - não sabemos se é o mesmo null
null (undefined) - não sabemos se é o mesmo null
true ! ! !
Supondo que não existe nenhum endereço cadastrado para Persons:
match (x:Person)
where x.adress is null
return x
match (x:Person)
where x.adress = null
return x
Returns all Persons
Returns “null”
match (pessoa:Person)
with ([‘Address 1’, ‘Address 2’] + [pessoa.address]) as partyDestinations
return [address in partyDestinations where address is not null | address] as Destino
Retorna só address 1 e 2, sem o null
merge (lily:Person{name: ‘Lily James’})
return lily
merge = match or create
(if exists: match, if not: create)
merge ...Person... merge ...Movie... merge () - [] -> () set propertie 1 set propertie 2 return x
merge (local:Location{name: “San Francisco”})
on create set local.criadoEm = timestamp(), local.criadoPor = “Artur Faria”
return local
merge (local:Location{name: “San Francisco”})
on match set local.test = “Troll”
return local
merge (local:Location{name: “San Francisco”})
on match set local.test = “Troll”
return local
Suponha que não existe o Location San Francisco, cria ele com as propriedades criadoEm e criadoPor
Mas por causa de “on create”, se executar o segundo comando, não será criada a nova propriedade
No terceiro vai atualizar com a nova propriedade,
…
x.y = (x.y + 1)
…
vai adicionar +1 na propriedade a cada atualização do valor
merge (k:Person{name: "Keanu Reeves"})
merge (t:Movie{title: "Top Gun"})
merge (k)-[w:WATCH]->(t)
on create set w.times = 1
on match set w.times = w.times + 1
return k, w, tConta quantas vezes e cada vez que o comando é executado aumente em 1, o numero de vezes que Keanu assistiu Top Gun
match (k:Person{name: “Keanu Reeves”})-[:HAS_CONTACT]->(c1)-[:HAS_CONTACT]->(c2)
return k, c2
limit 1
match path=((k:Person{name: “Keanu Reeves”})-[:HAS_CONTACT]->(c1)-[:HAS_CONTACT]->(c2))
return path
limit 1
match path=((k:Person{name: “Keanu Reeves”})-[:HAS_CONTACT*2]->(c2))
return path
limit 1
retorna só o k e c2
retorna o c1 tambem
sinonimo do anterior
return nodes(x)
return relationships(x)
retorna só nodos
retorna só relaçòes?
match (k:Person{name: “Keanu Reeves”})-[:HAS_CONTACT*2..4]->(c)
return c
retorna os contatos que são no mínimo de 2o e no máximo de 4o grau
0 é o próprio k
match (k:Person{name: "Keanu Reeves"})
match (t:Person{name: "Tom Cruise"})
match path=((k)-[:HAS_CONTACT*]->(t))
return length(path)retorna o número de paths entre k e t, mas não necessariamente o menor caminho
match (k:Person{name: "Keanu Reeves"})
match (t:Person{name: "Tom Cruise"})
match path = shortestPath((k)-[:HAS_CONTACT*..30]->(t))
return length(path)
match (k:Person{name: “Keanu Reeves”})
match (t:Person{name: “Tom Cruise”})
match path = allShortestPaths((k)-[:HAS_CONTACT*..30]->(t))
return path, length(path) as path_length
Retorna um único caminho mais curto (não retorna mais de um se ambos são o menor path possível)
allShortestPaths retorna todos os mínimos
match (m:Person)-[:ACTED_IN]->(:Movie{title: “The Matrix”})
match (t:Person)-[:ACTED_IN]->(:Movie{title: “Top Gun”})
match path = allShortestPath((m)-[:HAS_CONTACT*..30]->(t))
return path
retorna caminho de contato entre atores de matrix e top gun
