El lenguaje de consulta Cypher se desarrolló originalmente específicamente para el DBMS gráfico Neo4j . El objetivo de Cypher es proporcionar un lenguaje de consulta de base de datos gráfica legible por humanos similar a SQL. Hoy, Cypher es compatible con varios DBMS de gráficos. OpenCypher fue creado para estandarizar Cypher.
Los conceptos básicos para trabajar con Neo4j DBMS se describen en el artículo Conceptos básicos para trabajar con Neo4j en un navegador .
Para familiarizarse con Cypher, considere un ejemplo de un árbol genealógico tomado del clásico libro de texto Prolog por I. Bratko. Este ejemplo mostrará cómo agregar nodos y enlaces a un gráfico, cómo asignarles etiquetas y atributos y cómo hacer preguntas.
Entonces, tengamos un árbol genealógico que se muestra en la imagen a continuación.
Veamos cómo formar el gráfico correspondiente en Cypher:
CREATE (pam:Person {name: "Pam"}), (tom:Person {name: "Tom"}), (kate:Person {name: "Kate"}), (mary:Person {name: "Mary"}), (bob:Person {name: "Bob"}), (liz:Person {name: "Liz"}), (dick:Person {name: "Dick"}), (ann:Person {name: "Ann"}), (pat:Person {name: "Pat"}), (jack:Person {name: "Jack"}), (jim:Person {name: "Jim"}), (joli:Person {name: "Joli"}), (pam)-[:PARENT]->(bob), (tom)-[:PARENT]->(bob), (tom)-[:PARENT]->(liz), (kate)-[:PARENT]->(liz), (mary)-[:PARENT]->(ann), (bob)-[:PARENT]->(ann), (bob)-[:PARENT]->(pat), (dick)-[:PARENT]->(jim), (ann)-[:PARENT]->(jim), (pat)-[:PARENT]->(joli), (jack)-[:PARENT]->(joli)
Una solicitud CREATE para agregar datos a un DBMS gráfico consta de dos partes: agregar nodos y agregar enlaces entre ellos. A cada nodo que se agregará se le asigna un nombre dentro del marco de esta solicitud, que luego se utiliza para crear enlaces. Los nodos y las comunicaciones pueden almacenar documentos. En nuestro caso, los nodos contienen documentos con los campos de nombre, y los enlaces de documentos no contienen. También se pueden etiquetar nodos y enlaces. En nuestro caso, a los nodos se les asigna la etiqueta Persona y los enlaces son PADRES. La etiqueta en las solicitudes se resalta con dos puntos antes de su nombre.
Entonces, Neo4j nos dijo que: Added 12 labels, created 12 nodes, set 12 properties, created 11 relationships, completed after 9 ms.
Veamos que tenemos:
MATCH (p:Person) RETURN p
Nadie nos prohíbe editar la apariencia del gráfico resultante:
¿Qué se puede hacer con esto? Puede verificar que, por ejemplo, Pam es
Padre de Bob:
MATCH ans = (:Person {name: "Pam"})-[:PARENT]->(:Person {name: "Bob"}) RETURN ans
Obtenemos el subgrafo correspondiente:
Sin embargo, esto no es exactamente lo que necesitamos. Cambiar la solicitud:
MATCH ans = (:Person {name: "Pam"})-[:PARENT]->(:Person {name: "Bob"}) RETURN ans IS NOT NULL
Ahora en respuesta nos hacemos true . Y si preguntamos:
MATCH ans = (:Person {name: "Pam"})-[:PARENT]->(:Person {name: "Liz"}) RETURN ans IS NOT NULL
No obtendremos nada ... Aquí debe agregar la palabra OPTIONAL , luego si
el resultado estará vacío, luego se devolverá false :
OPTIONAL MATCH ans = (:Person {name: "Pam"})-[:PARENT]->(:Person {name: "Liz"}) RETURN ans IS NOT NULL
Ahora obtenemos la respuesta esperada false .
A continuación, puede ver quién es el padre para quién:
MATCH (p1:Person)-[:PARENT]->(p2:Person) RETURN p1, p2
Abra la pestaña de resultados con Text y vea una tabla con dos columnas:
╒═══════════════╤═══════════════╕ │"p1" │"p2" │ ╞═══════════════╪═══════════════╡ │{"name":"Pam"} │{"name":"Bob"} │ ├───────────────┼───────────────┤ │{"name":"Tom"} │{"name":"Bob"} │ ├───────────────┼───────────────┤ │{"name":"Tom"} │{"name":"Liz"} │ ├───────────────┼───────────────┤ │{"name":"Kate"}│{"name":"Liz"} │ ├───────────────┼───────────────┤ │{"name":"Mary"}│{"name":"Ann"} │ ├───────────────┼───────────────┤ │{"name":"Bob"} │{"name":"Ann"} │ ├───────────────┼───────────────┤ │{"name":"Bob"} │{"name":"Pat"} │ ├───────────────┼───────────────┤ │{"name":"Dick"}│{"name":"Jim"} │ ├───────────────┼───────────────┤ │{"name":"Ann"} │{"name":"Jim"} │ ├───────────────┼───────────────┤ │{"name":"Pat"} │{"name":"Joli"}│ ├───────────────┼───────────────┤ │{"name":"Jack"}│{"name":"Joli"}│ └───────────────┴───────────────┘
¿Qué más podemos aprender? Por ejemplo, quién es el padre de un miembro específico del género, por ejemplo, para Bob:
MATCH (parent:Person)-[:PARENT]->(:Person {name: "Bob"}) RETURN parent.name
╒═════════════╕ │"parent.name"│ ╞═════════════╡ │"Tom" │ ├─────────────┤ │"Pam" │ └─────────────┘
Aquí, como respuesta, no solicitamos el nodo completo, sino solo su atributo específico.
También podemos averiguar quiénes son los hijos de Bob:
MATCH (:Person {name: "Bob"})-[:PARENT]->(child:Person) RETURN child.name
╒════════════╕ │"child.name"│ ╞════════════╡ │"Ann" │ ├────────────┤ │"Pat" │ └────────────┘
También podemos preguntar quién tiene hijos:
MATCH (parent:Person)-[:PARENT]->(:Person) RETURN parent.name
╒═════════════╕ │"parent.name"│ ╞═════════════╡ │"Pam" │ ├─────────────┤ │"Tom" │ ├─────────────┤ │"Tom" │ ├─────────────┤ │"Kate" │ ├─────────────┤ │"Mary" │ ├─────────────┤ │"Bob" │ ├─────────────┤ │"Bob" │ ├─────────────┤ │"Dick" │ ├─────────────┤ │"Ann" │ ├─────────────┤ │"Pat" │ ├─────────────┤ │"Jack" │ └─────────────┘
Hmm, Tom y Bob se encontraron dos veces, arréglenlo:
MATCH (parent:Person)-[:PARENT]->(:Person) RETURN DISTINCT parent.name
Agregamos la palabra DISTINCT al resultado devuelto de la consulta, lo que significa
similar a eso en SQL.
╒═════════════╕ │"parent.name"│ ╞═════════════╡ │"Pam" │ ├─────────────┤ │"Tom" │ ├─────────────┤ │"Kate" │ ├─────────────┤ │"Mary" │ ├─────────────┤ │"Bob" │ ├─────────────┤ │"Dick" │ ├─────────────┤ │"Ann" │ ├─────────────┤ │"Pat" │ ├─────────────┤ │"Jack" │ └─────────────┘
También puede notar que Neo4j nos devuelve a los padres en el orden en que fueron ingresados en la solicitud CREATE .
Ahora preguntemos quién es abuelo o abuela:
MATCH (grandparent:Person)-[:PARENT]->()-[:PARENT]->(:Person) RETURN DISTINCT grandparent.name
Genial, eso es todo:
╒══════════════════╕ │"grandparent.name"│ ╞══════════════════╡ │"Tom" │ ├──────────────────┤ │"Pam" │ ├──────────────────┤ │"Bob" │ ├──────────────────┤ │"Mary" │ └──────────────────┘
En la plantilla de consulta, utilizamos un nodo sin nombre intermedio () y dos relaciones de tipo PARENT .
Ahora descubrimos quién es el padre. El padre es un hombre que tiene un hijo. Por lo tanto, nos faltan datos sobre quién es el hombre. En consecuencia, para determinar quién es una madre, necesita saber quién es una mujer. Agregue la información relevante a nuestra base de datos. Para hacer esto, asignaremos las etiquetas Male y Female a los nodos existentes.
MATCH (p:Person) WHERE p.name IN ["Tom", "Dick", "Bob", "Jim", "Jack"] SET p:Male
MATCH (p:Person) WHERE p.name IN ["Pam", "Kate", "Mary", "Liz", "Ann", "Pat", "Joli"] SET p:Female
Expliquemos lo que hicimos aquí: seleccionamos todos los nodos etiquetados como Person , los verificamos
la propiedad de name acuerdo con la lista dada especificada entre corchetes, y asignó a los nodos correspondientes la etiqueta Male o Female respectivamente.
Comprobar:
MATCH (p:Person) WHERE p:Male RETURN p.name
╒════════╕ │"p.name"│ ╞════════╡ │"Tom" │ ├────────┤ │"Bob" │ ├────────┤ │"Dick" │ ├────────┤ │"Jack" │ ├────────┤ │"Jim" │ └────────┘
MATCH (p:Person) WHERE p:Female RETURN p.name
╒════════╕ │"p.name"│ ╞════════╡ │"Pam" │ ├────────┤ │"Kate" │ ├────────┤ │"Mary" │ ├────────┤ │"Liz" │ ├────────┤ │"Ann" │ ├────────┤ │"Pat" │ ├────────┤ │"Joli" │ └────────┘
Solicitamos todos los nodos etiquetados como Person , que también tienen una etiqueta de Male o Female , respectivamente. Pero podríamos hacer que nuestras solicitudes sean un poco diferentes:
MATCH (p:Person:Male) RETURN p.name MATCH (p:Person:Female) RETURN p.name
Echemos un vistazo a nuestro gráfico nuevamente:
Neo4j Browser pintó los nodos en dos colores diferentes según las marcas de Male y
Hembra
Ok, ahora podemos consultar a todos los padres de la base de datos:
MATCH (p:Person:Male)-[:PARENT]->(:Person) RETURN DISTINCT p.name
╒════════╕ │"p.name"│ ╞════════╡ │"Tom" │ ├────────┤ │"Bob" │ ├────────┤ │"Dick" │ ├────────┤ │"Jack" │ └────────┘
Y madres:
MATCH (p:Person:Female)-[:PARENT]->(:Person) RETURN DISTINCT p.name
╒════════╕ │"p.name"│ ╞════════╡ │"Pam" │ ├────────┤ │"Kate" │ ├────────┤ │"Mary" │ ├────────┤ │"Ann" │ ├────────┤ │"Pat" │ └────────┘
Ahora formulemos una relación de hermano y hermana. X es hermano de Y,
si él es un hombre, y para X e Y hay al menos un padre común. Del mismo modo para
relación hermana
Actitud del hermano en Cypher:
MATCH (brother:Person:Male)<-[:PARENT]-()-[:PARENT]->(p:Person) RETURN brother.name, p.name
╒══════════════╤════════╕ │"brother.name"│"p.name"│ ╞══════════════╪════════╡ │"Bob" │"Liz" │ └──────────────┴────────┘
Actitud de hermana en Cypher:
MATCH (sister:Person:Female)<-[:PARENT]-()-[:PARENT]->(p:Person) RETURN sister.name, p.name
╒═════════════╤════════╕ │"sister.name"│"p.name"│ ╞═════════════╪════════╡ │"Liz" │"Bob" │ ├─────────────┼────────┤ │"Ann" │"Pat" │ ├─────────────┼────────┤ │"Pat" │"Ann" │ └─────────────┴────────┘
Entonces, podemos averiguar quién es el padre y quién es el abuelo o la abuela. ¿Pero qué hay de los ancestros más distantes? ¿Con bisabuelos, bisabuelos, etc.? No escribiremos una regla correspondiente para cada caso, y será cada vez más problemático. De hecho, todo es simple: X es un ancestro de Y si es un ancestro de un padre Y. Cypher proporciona un patrón * que le permite requerir una secuencia de relaciones de cualquier longitud:
MATCH (p:Person)-[*]->(s:Person) RETURN DISTINCT p.name, s.name
Realmente hay un problema en esto: será cualquier conexión. Agregue una referencia al enlace PARENT :
MATCH (p:Person)-[:PARENT*]->(s:Person) RETURN DISTINCT p.name, s.name
Para no aumentar la longitud del artículo, encontramos a todos los antepasados de Joli :
MATCH (p:Person)-[:PARENT*]->(:Person {name: "Joli"}) RETURN DISTINCT p.name
╒════════╕ │"p.name"│ ╞════════╡ │"Jack" │ ├────────┤ │"Pat" │ ├────────┤ │"Bob" │ ├────────┤ │"Pam" │ ├────────┤ │"Tom" │ └────────┘
Considere una regla más compleja para descubrir quién está relacionado con quién.
Primero, los parientes son antepasados y descendientes, por ejemplo, un hijo y una madre, abuela y nieto. En segundo lugar, los parientes son hermanos y hermanas, incluidos primos, primos segundos, etc., lo que en términos de antepasados significa que tienen un antepasado común. Y en tercer lugar, los familiares que tienen descendientes comunes, por ejemplo, marido y mujer, se consideran familiares.
En Cypher, debe usar UNION para muchos patrones:
MATCH (r1:Person)-[:PARENT*]-(r2:Person) RETURN DISTINCT r1.name, r2.name UNION MATCH (r1:Person)<-[:PARENT*]-(:Person)-[:PARENT*]->(r2:Person) RETURN DISTINCT r1.name, r2.name UNION MATCH (r1:Person)-[:PARENT*]->(:Person)<-[:PARENT*]-(r2:Person) RETURN DISTINCT r1.name, r2.name
Aquí, en la primera regla, se usan conexiones, cuya dirección no nos importa. Tal conexión se indica sin una flecha, solo un guión - . La segunda y tercera regla están escritas de una manera obvia y familiar.
No presentaremos el resultado de la consulta total aquí, solo diremos que los pares de familiares encontrados son 132, lo que es consistente con el valor calculado como el número de pares ordenados de 12. También podríamos especificar esta consulta reemplazando la aparición de la variable r1 o r2 con (:Person {name: "Liz"}) por ejemplo, sin embargo, en nuestro caso esto no tiene mucho sentido, ya que todas las personas en nuestra base de datos son obviamente familiares.
Esto concluye nuestra discusión sobre la identificación de relaciones entre personas en nuestra base de datos.
Por último, considere cómo eliminar nodos y enlaces.
Para eliminar a todas nuestras personas, puede ejecutar la solicitud:
MATCH (p:Person) DELETE p
Sin embargo, Neo4j nos dirá que no puede eliminar nodos que tienen enlaces.
Por lo tanto, primero eliminamos los enlaces y luego repetimos la eliminación de nodos:
MATCH (p1:Person)-[r]->(p2:Person) DELETE r
Lo que hemos hecho ahora: comparó a dos personas entre las cuales hay una conexión, nombró esta conexión como r y luego la eliminó.
Conclusión
El artículo muestra cómo usar las capacidades del lenguaje de consulta Cypher usando un ejemplo simple de un gráfico social. En particular, examinamos cómo agregar nodos y enlaces con una consulta, cómo buscar datos relacionados, incluso con enlaces indirectos, y cómo asignar etiquetas a los nodos. Puede encontrar más información sobre Cypher en los enlaces a continuación. Un buen punto de partida es la "Neo4j Cypher Refcard".
Neo4j está lejos de ser el único gráfico DBMS. Entre los otros más populares se encuentran Cayley , Dgraph con lenguaje de consulta GraphQL, ArangoDB y OrientDB multimodelos . De particular interés puede ser Blazegraph con soporte para RDF y SPARQL.
Referencias
Bibliografia
- Robinson Jan, Weber Jim, Eifrem Emil. Graficar bases de datos. Nuevas características
para trabajar con datos relacionados / por. del ingles - 2da ed. - M .: DMK-Press,
2016 - 256 s. - Bratko I.Programación en lenguaje Prolog para inteligencia artificial:
trans. del ingles - M.: Mir, 1990 .-- 560 p.: Ill.
Epílogo
El autor del artículo conoce solo dos empresas (ambas de San Petersburgo) que utilizan DBMS de gráficos para sus productos. Pero me gustaría saber cuántas empresas de lectores de este artículo los usan en su desarrollo. Por lo tanto, propongo participar en la encuesta. Escriba también sobre su experiencia en los comentarios, será muy interesante saberlo.