1. Neo4j – Una guía rápida de devniel.com
Parte II - Por Daniel Flores
Algunas imágenes fueron tomadas de presentaciones oficiales de Neo4j.org

2. Neo4j es una base de datos orientada a
grafos de código abierto desarrollado en
Java.
Neo4j utiliza como modelo de datos , los
grafos. Específicamente, grafos de
propiedades.
Más de las 30 empresas del Global 2000
usan Neo4j en producción para un
amplio rango de casos de uso.
Neo4j es uno de las pocas bases de
datos orientadas a grafos que cuentan
con un lenguaje de consulta : Cypher.

3. Neo4j es un grafo de propiedades

4. • Un grafo de propiedades consiste de nodos y relaciones
etiquetadas, cada una con propiedades determinadas.
• Los nodos son solo registros, usualmente usados para una entidad o
esquema determinado que se agrupan por etiquetas. Cada uno de
estos registros contienen propiedades y relaciones hacia otros nodos.
• Las relaciones son también registros explícitos en la base de datos.
Conectan a dos nodos y guardan información entre ellos.
• Las propiedades son simples estructuras clave-valor. No hay un
esquema establecido, solo estructura.

5. Cypher

6. • Cypher, un lenguaje declarativo, sintácticamente expresivo, para la interacción
con grafos.
• Declarativo, amigable, fácil de leer y escribir.
• El objetivo de Neo4j, es consolidar Cypher como el lenguaje oficial de todas las
tecnologías orientadas a grafos.
• Cypher a través de técnicas REST para la administración.
• Cypher por medio de Java para plugins.

7. Nodos
Cypher usa ASCII-art para representar patrones. Nosotros
encerramos los nodos entre paréntesis asemejando a un
nodo, dentro del cual encerramos a una variable sobre el cual se
referenciará el valor del nodo.
Por ejemplo, si queremos referirnos a todas las entidades que
tienen relación con algún curso, sea profesor o
alumno, debemos incluir los identificadores entidad y curso con
una sentencia similar a esta:
(entidad)-->(curso)

8. (entidad)-->(curso)
Luego podemos acceder a las propiedades de los
nodos así :
entidad.nombre
curso.nombre
La estructura general sería :
MATCH (entidad)-->(curso)
RETURN entidad.nombre, curso.nombre

9. Relaciones
Las relaciones se capturan entre []
corchetes, donde podemos especificar el
nombre de la variable y el nombre de la relación

10. • Toda relación debe tener un nodo de inicio y
un nodo final, el cual inclusive puede ser el
mismo nodo.
• Toda relación debe tener un tipo.

11. Entonces nuestro patrón de búsqueda sería más específico a
través de la siguiente sentencia :
(profesor)-[:HA_DICTADO]->(curso)
Con lo que la consulta sería así, nótese el sentido de la relación :
MATCH (profesor)-[:HA_DICTADO]->(curso)
Si queremos obtener propiedades específicas de la
relación, entonces capturamos a esta en una variable y luego
accedemos a sus detalles
MATCH (profesor)-[rel:HA_DICTADO]->(curso)
RETURN rel.desde

12. Etiquetas (Labels)
•
•
•
•
Una etiqueta identifica un conjunto de nodos.
Un nodo puede tener múltiples etiquetas.
Puedes buscar nodos por sus etiquetas.
Puedes restringir valores y propiedades de acuerdo a las
etiquetas (un esquema ligero, desde la versión 2.0).
En nuestro ejemplo, el profesor puede ser etiquetado bajo el
label de Humano, entonces el patrón :
(profesor:Humano)-[:HA_DICTADO]->(curso)
Retornaría al profesor Revis mientras que descartaría a Orbus, un
profesor reptiliano de nuestra universidad estelar.

13. Entonces, usualmente manipularemos nodos con etiquetas
con la siguiente sintaxis :
MATCH (node:Etiqueta)
RETURN node ;
MATCH (node:Etiqueta1:Etiqueta2)
RETURN node ;
MATCH (nodo1:Etiqueta)-[:REL]->(nodo2:Etiqueta2)
RETURN nodo1, nodo2 ;
MATCH (nodo)
RETURN LABELS(nodo);

15. Retornar todos los nodos
MATCH (n)
RETURN n;
Retornar todos los nodos con
relación a alguno
MATCH (n)-->(m)
RETURN n, m;

16. Retornar todos los nodos con
relación a otro nodo, pero sin
necesidad de capturar el segundo
MATCH (n)-->()
RETURN n;
Retornar una propiedad
MATCH (humano)-->( )
RETURN humano.nombre;

17. Referirse a una relación
MATCH (nodo)-[rel]->()
RETURN node, rel.propiedad
Obtener el nombre de la relación
MATCH (nodo)-[rel]->()
RETURN node, type(rel)

18. Buscando una relación
MATCH (profesor)-[:HA_DICTADO]->(curso)
RETURN profesor.nombre, curso.nombre
Obtener propiedades de la relación
MATCH (profesor)-[c:HA_DICTADO]->(curso)
RETURN
profesor.nombre, curso.nombre, c.desde

19. Buscar nodos por su etiqueta
MATCH (profesor:Humano)-[:HA_DICTADO]->(curso)
RETURN profesor.nombre, curso.nombre
Buscar nodos por propiedades
específicas
MATCH (p:Humano)
WHERE p.nombre = ‘Revis’
RETURN p;

20. Buscar nodos por propiedades
específicas
MATCH (p:Humano)
WHERE p.nombre = ‘Revis’
RETURN p;
Buscar nodos por propiedades
específicas, simplificado
MATCH (p:Humano {nombre: ‚Revis‛})
RETURN p;

21. Otras clausulas disponibles
•
•
•
•
•
•
•
•
•
•
•
•
•
MATCH
WHERE
RETURN
ORDER BY
SKIP / LIMIT
CREATE
MERGE
CREATE UNIQUE
DELETE
SET
REMOVE
FOREACH
WITH

22. Rutas

24. Busquemos a todos los profesores que
enseñan Cálculo junto a los alumnos
que asistieron alguna vez
MATCH (profesor)-[:HA_DICTADO]->(curso)<-[:HA_LLEVADO]-(alumno)
RETURN profesor.nombre, curso.nombre, alumno.nombre;
Entonces, estamos buscando al profesor que HA_DICTADO algún curso y además
obtenemos a los alumnos donde cada uno HA_LLEVADO el curso. Para luego retornar el
nombre de cada una de las entidades encontradas.
Por cada combinación de profesor y alumno en cada curso se retornarán una serie de
resultados.

25. Búsqueda con rutas
MATCH (profesor)-[:HA_DICTADO]->(curso)<-[:HA_LLEVADO]-(alumno)
RETURN profesor.nombre, curso.nombre, alumno.nombre;
Búsqueda de rutas, simplificado
MATCH (profesor)-[:HA_DICTADO]->(curso),
(curso)<-[:HA_LLEVADO]-(alumno)
RETURN profesor.nombre, curso.nombre, alumno.nombre;
(Es importante mantener la variable curso.)

26. Búsqueda por rutas, simplificado
MATCH (profesor)-[:HA_DICTADO]->(curso),
(alumno)-[:HA_LLEVADO]->(curso)
RETURN profesor.nombre, curso.nombre, alumno.nombre;
Referenciar rutas bajo una variable
MATCH r = (p)-[:HA_DICTADO]->(c)<-[:HA_LLEVADO]-(a)
RETURN r;
MATCH r = (p)-[:HA_DICTADO]->(c)<-[:HA_LLEVADO]-(a)
RETURN nodes(r);
MATCH r = (p)-[:HA_DICTADO]->(c)<-[:HA_LLEVADO]-(a)
RETURN rels(r);

27. Referenciar rutas bajo variables
MATCH r1 = (p)-[:HA_DICTADO]->(c),
r2 = (a)-[:HA_LLEVADO]->(c)
RETURN r1, r2;

28. Filtros, Ordenamiento y más

29. Filtro simple : WHERE
MATCH (n:Humano)
WHERE n.nombre = ‘Revis’
RETURN n;
Filtro simple minimalista
MATCH (n:Humano {nombre: ‚Revis‛})
RETURN n;

30. Filtro simple : WHERE
MATCH (n:Humano)
WHERE n.nombre = ‚Revis‛
AND ((n.edad < 100
AND NOT (n.edad > 40))
OR n.edad = 200)
RETURN n;
Filtro simple : WHERE y etiquetas
MATCH (n)
WHERE n:Humano
RETURN n;

31. Filtro WHERE, existencia de propiedad
MATCH (n)
WHERE n:Humano
AND HAS(n.edad)
RETURN n;
Filtro WHERE, expresiones regulares
MATCH (n)
WHERE n.nombre =~ ‘R.*’
RETURN n;

32. Filtro WHERE, escape en expresiones
regulares
MATCH (n)
WHERE n.nombre =~ ‘R/.*’
RETURN n;
Filtro WHERE, case-insensitive
MATCH (n)
WHERE n.nombre =~ ‘(?i)RE.*’
RETURN n;

33. Filtro WHERE, usando patrones
MATCH (profesor)-[:HA_DICTADO]->(curso),
(alumno)-[:HA_LLEVADO]->(curso)
RETURN profesor.nombre, curso.nombre, alumno.nombre;
MATCH (profesor)-[:HA_DICTADO]->(curso), (a)
WHERE (a)-[:HA_LLEVADO]->(curso)
RETURN profesor.nombre, curso.nombre, a.nombre;
MATCH (profesor)-[:HA_DICTADO]->(curso)<--(a)
WHERE NOT (a)-[:HA_LLEVADO]->(curso)
RETURN profesor.nombre, curso.nombre;
MATCH (profesor)-[r]->(curso), (a)
WHERE type(r) =~ ‘HA_.*’
RETURN type(r);

34. Ordenamiento
MATCH (n)-[:HA_DICTADO]->()
RETURN n.nombre, n.edad
ORDER BY n.edad ASC;
Limitar y descartar
MATCH (p)-[:HA_DICTADO]->(c)
RETURN p.nombre, c.nombre
SKIP 1
LIMIT 1;

35. Ordenamiento y límite, top 2
MATCH (p)-->(c:Curso)
RETURN DISTINCT(p.nombre), p.edad
ORDER BY p.edad DESC LIMIT 2;
Ordenamiento y límite, el segundo
MATCH (p)-->(c:Curso)
RETURN DISTINCT(p.nombre), p.edad
ORDER BY p.edad DESC SKIP 1 LIMIT 2;

36. RESULTADOS DISTINTOS
MATCH (n)-[:HA_DICTADO]->()
RETURN n.nombre, n.edad
ORDER BY n.edad;

37. DISTINCT
MATCH (n)-[:HA_DICTADO]->()
RETURN DISTINCT n.nombre, n.edad
ORDER BY n.edad;
Colecciones
MATCH (n:Humano)-[r:HA_DICTADO]->()
WHERE r.desde in [2120,2032,2033]
RETURN n.nombre;

38. RETORNO con un alias
MATCH (n)-[:CONOCE]->(m)
RETURN DISTINCT m.nombre, (n.edad - m.edad) as
diferencia, n.nombre;
Funciones colectivas
MATCH (n)-[:CONOCE]->(m)
RETURN DISTINCT m.nombre, (abs(n.edad - m.edad)) as
diferencia, n.nombre;