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

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.

Neo4j es un grafo de propiedades

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.

Cypher

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.

(entidad)-->(curso) 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)

(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

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

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.

(profesor)-[:HA_DICTADO]->(curso) 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

(profesor:Humano)-[:HA_DICTADO]->(curso) 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.

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);

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

Retornar una propiedad 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;

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)

Obtener propiedades de la relación 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

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;

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;

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

Rutas

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.

Búsqueda de rutas, simplificado 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.)

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);

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

Filtros, Ordenamiento y más

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

Filtro simple : WHERE y etiquetas 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;

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;

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;

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);

Ordenamiento Limitar y descartar 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;

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;

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

DISTINCT Colecciones 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;

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