Neo4j – Una guía rápida de devniel Parte II - Por Daniel Flores

1. Neo4j – Una guía rápida de devniel.comParte 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. (profesor)-[:HA_DICTADO]->(curso) Entonces nuestro patrón de búsqueda sería más específico a través de la siguiente sentencia : 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 profesorpuede ser etiquetado bajo el label de Humano, entonces el patrón : (profesor:Humano)-[:HA_DICTADO]->(curso) Retornaría al profesor Revismientras 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 < 100AND 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:HumanoAND 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 1LIMIT 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.desdein [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; MATCH (n)-[:CONOCE]->(m) RETURN DISTINCT m.nombre, (abs(n.edad - m.edad)) as diferencia, n.nombre; Funciones colectivas