neo4j – una guía rápida de devniel.com parte ii - por daniel flores algunas imágenes fueron...

Neo4j – Una guía rápida de devniel.comParte 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.

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.nombrecurso.nombre

La estructura general sería :

MATCH (entidad)-->(curso)RETURN entidad.nombre, curso.nombre

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

MATCH (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 :

Si queremos obtener propiedades específicas de la relación, entonces capturamos a esta en una variable y luego accedemos a sus detallesMATCH (profesor)-[rel:HA_DICTADO]->(curso)RETURN rel.desde

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.

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

Entonces, usualmente manipularemos nodos con etiquetas con la siguiente sintaxis :

Retornar todos los nodos

MATCH (n)RETURN n;

Retornar todos los nodos con relación a alguno

MATCH (n)-->(m)RETURN n, m;

Retornar todos los nodos con relación a otro nodo, pero sin

necesidad de capturar el segundo

MATCH (n)-->()RETURN n;

Retornar una propiedadMATCH (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)

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 con rutas

MATCH (profesor)-[:HA_DICTADO]->(curso)<-[:HA_LLEVADO]-(alumno)RETURN profesor.nombre, curso.nombre, alumno.nombre;

Búsqueda de rutas, simplificadoMATCH (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, simplificadoMATCH (profesor)-[:HA_DICTADO]->(curso), (alumno)-[:HA_LLEVADO]->(curso)RETURN profesor.nombre, curso.nombre, alumno.nombre;

Referenciar rutas bajo una variableMATCH 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 variablesMATCH r1 = (p)-[:HA_DICTADO]->(c), r2 = (a)-[:HA_LLEVADO]->(c)RETURN r1, r2;

Filtros, Ordenamiento y más

MATCH (n:Humano)WHERE n.nombre = ‘Revis’RETURN n;

Filtro simple : WHERE

MATCH (n:Humano {nombre: “Revis”})RETURN n;

Filtro simple minimalista

MATCH (n:Humano)WHERE n.nombre = “Revis”AND ((n.edad < 100AND NOT (n.edad > 40))OR n.edad = 200)RETURN n;

Filtro simple : WHERE

Filtro simple : WHERE y etiquetasMATCH (n)WHERE n:HumanoRETURN n;

Filtro WHERE, existencia de propiedad

MATCH (n)WHERE n:HumanoAND HAS(n.edad)RETURN n;

Filtro WHERE, expresiones regularesMATCH (n)WHERE n.nombre =~ ‘R.*’RETURN n;

Filtro WHERE, escape en expresiones regulares

MATCH (n)WHERE n.nombre =~ ‘R\/.*’RETURN n;

Filtro WHERE, case-insensitiveMATCH (n)WHERE n.nombre =~ ‘(?i)RE.*’RETURN n;

Filtro WHERE, usando patronesMATCH (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);

OrdenamientoMATCH (n)-[:HA_DICTADO]->()RETURN n.nombre, n.edadORDER BY n.edad ASC;

Limitar y descartarMATCH (p)-[:HA_DICTADO]->(c)RETURN p.nombre, c.nombreSKIP 1LIMIT 1;

MATCH (p)-->(c:Curso)RETURN DISTINCT(p.nombre), p.edad ORDER BY p.edad DESC LIMIT 2;

Ordenamiento y límite, top 2

MATCH (p)-->(c:Curso)RETURN DISTINCT(p.nombre), p.edad ORDER BY p.edad DESC SKIP 1 LIMIT 2;

Ordenamiento y límite, el segundo

RESULTADOS DISTINTOSMATCH (n)-[:HA_DICTADO]->()RETURN n.nombre, n.edadORDER BY n.edad;

DISTINCTMATCH (n)-[:HA_DICTADO]->()RETURN DISTINCT n.nombre, n.edadORDER BY n.edad;

Colecciones

MATCH (n:Humano)-[r:HA_DICTADO]->()WHERE r.desde in [2120,2032,2033]RETURN n.nombre;

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