Puntos clave: Consultas de Base de Datos de Grafos de Neo4j ofrece una guía detallada para ejecutar consultas en Neo4j, centrada en la creación de nodos y relaciones con ejemplos sintácticos para una gestión eficaz de datos.
- Instrucciones para iniciar el servidor Neo4j y usar el shell.
- Ejemplos de creación de nodos y establecimiento de relaciones.
- Métodos para consultar y listar nodos y sus relaciones.
En la entrada anterior del blog, donde presentamos Neo4j. Aquí explicamos las consultas. Primero, Comienza el servidor y luego abre el shell:
cd neo4j bin
./neo4j start
./cypher-shell -a bolt://localhost:7687 -u neo4j -p xxx
Crea nodo y relaciones
Aquí Crea dos nodos. Cada uno tiene etiqueta Amigos y una propiedad de nombre. Relaciones, ambos pueden tener propiedades también.
CREATE (x:Friends { name: 'Walker' })
CREATE (y:Friends { name: 'Stephen' })
return x,y;
+------------------------------------------------------------+
| x | y |
+------------------------------------------------------------+
| (:Friends {name: "Walker"}) | (:Friends {name: "Stephen"}) |
+------------------------------------------------------------+
1 row available after 15 ms, consumed after another 0 ms
Added 2 nodes, Set 2 properties, Added 2 labels
Nota: La ortografía y el caso están importantes. Neo4j no te avisa si algo está mal escrito. Así que presta atención al crear, por ejemplo, relaciones, ya que estarán vacías sin previo aviso. Así que busca las relaciones creadas y las filas x disponibles después de cada afirmación para Haz que ha funcionado. Luego Crea una relación (llamada arista) de Stephen a Walker. Damos a esta relación el nombre arbitrario Amigo. Ponemos las letras x, y y r delante de los objetos para poder referirnos a ellos en los pasos siguientes. Así que están notación abreviada. Además, aporta el objeto creado al alcance. El procedimiento para Crea una relación están juntar los nodos con una instrucción MATCH y WHERE, luego emitir la Crea con una flecha direccional para indicar la dirección de la relación, o una línea simple, si va en ambas direcciones. Por ejemplo, si Stephen están amigo de Walker, entonces Walker están amigo de Stephen. Así que la flecha podría ser una línea simple. te utiliza líneas dobles --, →, ← cuando te quiera indicar dirección en la sentencia de consultas (es decir, MATCH), pero no en la sentencia de creación.
MATCH (x:Friends),(y:Friends)
WHERE y.name = "Stephen" AND x.name = "Walker"
CREATE (x)-[r:Friend]->(y)
RETURN type(r);
+----------+
| type(r) |
+----------+
| "Friend" |
+----------+
Listar todos los Nodos Amigos
Ahora, probemos con diferentes consultas. Esta lista lista todos los nodos, ya que no le dimos ninguna condición de WHERE .
match(n:Friends)
return n;
+------------------------------+
| n |
+------------------------------+
| (:Friends {name: "Walker"}) |
| (:Friends {name: "Stephen"}) |
+------------------------------+
Haz una lista de todas las relaciones de amistad .
MATCH (a:Friends)-[:Friend]->(b:Friends)
RETURN a.name, b.name;
+----------------------+
| a.name | b.name |
+----------------------+
| "Walker" | "Stephen" |
+----------------------+
Haz a Raj amigo de Stephen.
CREATE (y:Friends { name: 'Raj' });
MATCH (x:Friends),(y:Friends)
WHERE y.name = "Stephen" AND x.name = "Raj"
CREATE (x)-[r:Friend]->(y)
RETURN type(r);
Haz que el comando (principalmente la instrucción MATCH) funcionara prestando atención a los números devueltos. Recuerda lo que dijimos sobre los errores ortográficos y el caso mayúsculo.
1 row available after 3 ms, consumed after another 0 ms
Created 1 relationships
Muestra las relaciones a todos los amigos. Ten en cuenta que ahora incluye la que acabamos de añadir
MATCH (a:Friends)-[r:Friend]->(b:Friends)
RETURN a.name, b.name;
+----------------------+
| a.name | b.name |
+----------------------+
| "Walker" | "Stephen" |
| "Raj" | "Stephen" |
+----------------------+
Añade 1 más, Teresa, y luego Haz que sea amiga de Raj.
CREATE (x:Friends { name: 'Teresa' })
return x;
MATCH (x:Friends),(y:Friends)
WHERE y.name = "Stephen" AND x.name = "Raj"
CREATE (x)-[r:Friend]->(y);
MATCH (x:Friends),(y:Friends)
WHERE y.name = "Raj" AND x.name = "Teresa"
CREATE (x)-[r:Friend]->(y)
RETURN type(r);
A continuación mostramos sus amigos de amigos que no son entre sí. Eso sería Teresa y Stephen no son amigos. Para ponerlo en términos de matemáticas, lo que podría Haz más fácil de entender, podríamos decir que buscamos la intersección del conjunto u y noAmigo y luego aplicamos DONDE NO que encuentren objetos fuera de esa intersección. Para recordar qué amigos tenemos para Haz esto más fácil de Ve, primero:
Match (a:Friends)--(b)
return a,b;
+-------------------------------------------------------------+
| a | b |
+-------------------------------------------------------------+
| (:Friends {name: "Walker"}) | (:Friends {name: "Stephen"}) |
| (:Friends {name: "Stephen"}) | (:Friends {name: "Raj"}) |
| (:Friends {name: "Stephen"}) | (:Friends {name: "Raj"}) |
| (:Friends {name: "Stephen"}) | (:Friends {name: "Walker"}) |
| (:Friends {name: "Raj"}) | (:Friends {name: "Teresa"}) |
| (:Friends {name: "Raj"}) | (:Friends {name: "Stephen"}) |
| (:Friends {name: "Raj"}) | (:Friends {name: "Stephen"}) |
| (:Friends {name: "Teresa"}) | (:Friends {name: "Raj"}) |
+-------------------------------------------------------------+
La consulta de amigos que.noson-amigos-de enumera a Teresa y Stephen porque Teresa no está amiga de Stephen. En otras palabras, la primera parte de la consulta muestra todas las relaciones de las personas listadas en la variable u y luego lista quiénes no están en u.
Match (u:Friends)-[:Friend]->(:Friends)-[:Friend]->(notFriend:Friends)
WHERE NOT (u)-[:Friend]->(notFriend)
RETURN u, notFriend;
+------------------------------------------------------------+
| u | notFriend |
+------------------------------------------------------------+
| (:Friends {name: "Teresa"}) | (:Friends {name: "Stephen"}) |
| (:Friends {name: "Teresa"}) | (:Friends {name: "Stephen"}) |
+------------------------------------------------------------+
Relaciones dirigidas
Ahora Crea una relación en la dirección opuesta: Amigo A < - Amigo B en lugar de Amigo A > Amigo B poniendo la flecha direccional en la primera posición de la frase Crea.
MATCH (x:Friends),(y:Friends)
WHERE y.name = "Raj" AND x.name = "Teresa"
CREATE (x)< -[r:Friend]-(y)
RETURN type(r);
Ahora enumera todas las relaciones, primero la izquierda, luego la no direccional y luego hacia la derecha. Una relación saliente de un nodo de Amigos a otro está igual que una relación entrante, ya que los nodos son iguales. Así que la primera y la última consulta listan las mismas 4 relaciones. Y una consulta bidireccional lista 8, ya que una de entrada y otra de salida califican como una relación en cualquiera de las dos direcciones, que están lo que significa -- Sería más sencillo Ve todo esto si hubiéramos llamado a un conjunto de nodos Clientes y a otro AccountManager, ya que no habría simetría lógica. Construiremos ejemplos así en posteriores entradas del blog que están.
Match (a:Friends)< --(b) return a,b; +------------------------------------------------------------+ | a | b | +------------------------------------------------------------+ | (:Friends {name: "Stephen"}) | (:Friends {name: "Raj"}) | | (:Friends {name: "Stephen"}) | (:Friends {name: "Raj"}) | | (:Friends {name: "Stephen"}) | (:Friends {name: "Walker"}) | | (:Friends {name: "Raj"}) | (:Friends {name: "Teresa"}) | +------------------------------------------------------------+ Match (a:Friends)--(b) return a,b; +-------------------------------------------------------------+ | a | b | +-------------------------------------------------------------+ | (:Friends {name: "Walker"}) | (:Friends {name: "Stephen"}) | | (:Friends {name: "Stephen"}) | (:Friends {name: "Raj"}) | | (:Friends {name: "Stephen"}) | (:Friends {name: "Raj"}) | | (:Friends {name: "Stephen"}) | (:Friends {name: "Walker"}) | | (:Friends {name: "Raj"}) | (:Friends {name: "Teresa"}) | | (:Friends {name: "Raj"}) | (:Friends {name: "Stephen"}) | | (:Friends {name: "Raj"}) | (:Friends {name: "Stephen"}) | | (:Friends {name: "Teresa"}) | (:Friends {name: "Raj"}) | +-------------------------------------------------------------+ 8 rows available after 22 ms, consumed after another 2 ms Match (a:Friends)-->(b)
return a,b;
+------------------------------------------------------------+
| a | b |
+------------------------------------------------------------+
| (:Friends {name: "Walker"}) | (:Friends {name: "Stephen"}) |
| (:Friends {name: "Raj"}) | (:Friends {name: "Stephen"}) |
| (:Friends {name: "Raj"}) | (:Friends {name: "Stephen"}) |
| (:Friends {name: "Teresa"}) | (:Friends {name: "Raj"}) |
+------------------------------------------------------------+
4 rows available after 24 ms, consumed after another 2 ms
Guía de visualización de datos
- La guía para principiantes en visualización de datos
- Introducción a las bases de datos de grafos
- Utiliza casos para bases de datos de grafos
- Introducción a la base de datos de grafos Neo4j
- Consultas a la base de datos de grafos Neo4j
- Explicación de los diagramas de dispersión y líneas de Matplotlib
- Cómo añadir subtramas en Matplotlib
- Escala logarítmica de Matplotlib
- Uso de Matplotlib para dibujar gráficos y diagramas
- Cómo dibujar gráficos 3D con Matplotlib
- Plotly Python Tutorial
- Habilitando a los científicos de datos ciudadanos
Estas publicaciones son mías y no representan necesariamente la posición, estrategias u opinión de BMC.