slide1 n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
Neo4j – Una guía rápida de devniel Parte II - Por Daniel Flores PowerPoint Presentation
Download Presentation
Neo4j – Una guía rápida de devniel Parte II - Por Daniel Flores

Loading in 2 Seconds...

play fullscreen
1 / 38

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


  • 115 Views
  • Uploaded on

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.

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'Neo4j – Una guía rápida de devniel Parte II - Por Daniel Flores' - adora


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
slide1

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

Algunas imágenes fueron tomadas de presentaciones oficiales de Neo4j.org

slide2

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.

slide4

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.
slide6

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
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
(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
Relaciones

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

slide10

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

etiquetas labels
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.

slide13

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

slide17

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

slide20

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
Otras clausulas disponibles
  • MATCH
  • WHERE
  • RETURN
  • ORDER BY
  • SKIP / LIMIT
  • CREATE
  • MERGE
  • CREATE UNIQUE
  • DELETE
  • SET
  • REMOVE
  • FOREACH
  • WITH
busquemos a todos los profesores que ense an c lculo junto a los alumnos que asistieron alguna vez
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
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
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
Referenciar rutas bajo variables

MATCH r1 =(p)-[:HA_DICTADO]->(c),

r2 = (a)-[:HA_LLEVADO]->(c)

RETURN r1, r2;

filtro simple where
Filtro simple : WHERE

MATCH (n:Humano)

WHERE n.nombre = ‘Revis’

RETURN n;

Filtro simple minimalista

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

RETURN n;

filtro simple where1
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;

filtro where existencia de propiedad
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;

filtro where escape en expresiones regulares
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
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
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;

ordenamiento y l mite top 2
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
RESULTADOS DISTINTOS

MATCH (n)-[:HA_DICTADO]->()

RETURN n.nombre, n.edad

ORDER BY n.edad;

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

retorno con un alias
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