graph - run - neo4j pagina oficial

Heredar propiedades de un nodo con relación a otro nodo a su hijo en neo4j

Question

Heredar propiedades de todos los padres.

Considera que tengo un gráfico con el siguiente formato. Deseo que las propiedades de un nodo (que estará en el nodo de cuenta, si tiene una relación) las herede su nodo hijo. Suponga que [r: CHILD] mantiene la relación entre el nodo principal y el secundario y la información de la cuenta [r2: ACCOUNT]. Si el nodo tiene más de un padre, necesita heredar de todos sus padres con la primera cuenta:

       (a0:ACCOUNT)<-[:HAS_ACCOUNT]-Morpheus
                                     /
         (a1:ACCOUNT)<-[:HAS_ACCOUNT]-Neo
                                       /
                                       alpha    
                                        / 
                                       gamma    beta - [:HAS_ACCOUNT]->(a2:ACCOUNT)
                                          /    /
                                            A 
                                          /   /
            (a3:ACCOUNT)<-[:HAS_ACCOUNT]-B     C
                                       /  /   /  /
                                      D    E  F   G

Quiero extraer los datos del gráfico anterior algo como esto:

Problema: Dado un nodo, obtenga todos sus hijos y también su cuenta (si tiene una cuenta, por ejemplo: vea el nodo B) o la información heredada de su cuenta. AccountID es parte del nodo de cuenta

Considere la entrada es el nodo A

SALIDA:

|Node | CurrentNode|     Account   |Inherited_Account|
 - - - - - -- - - - - -- - - - - -- - - - - -- - - - - 
|  A  |    A       |     -         |   a1.accountID ,| 
|     |            |               |   a2.accountID  |
 - - - - - -- - - - - -- - - - - -- - - - - -- - - - - 
|  A  |    B       |  a3.accountID |        -        | 
 - - - - - -- - - - - -- - - - - -- - - - - -- - - - - 
|  A  |    D       |               |    a3.accountID | 
 - - - - - -- - - - - -- - - - - -- - - - - -- - - - - 
|  A  |    E       |               |    a3.accountID | 
 - - - - - -- - - - - -- - - - - -- - - - - -- - - - -
|  A  |    C       |               |   a1.accountID ,| 
|     |            |               |   a2.accountID  |
 - - - - - -- - - - - -- - - - - -- - - - - -- - - - - 
|  A  |    F       |               |   a1.accountID ,| 
|     |            |               |   a2.accountID  |
 - - - - - -- - - - - -- - - - - -- - - - - -- - - - - 
|  A  |    G       |               |   a1.accountID ,| 
|     |            |               |   a2.accountID  |
 - - - - - -- - - - - -- - - - - -- - - - - -- - - - - 

Esta fue mi contraseña para recuperar que se me ocurrió, me da todos los informes de todos los padres. A veces no funciona

MATCH (node:Person{personID:"A"})
MATCH (account:ACCOUNT)
MATCH p =(parent:Person)-[:CHILD*1..]->(node)
where (parent)-[:HAS_ACCOUNT]->(account)
UNWIND RELATIONSHIPS(p) AS rel 
WITH p, account, COUNT(DISTINCT rel) AS nRoutes 
RETURN account,p, nRoutes 
ORDER BY nRoutes

Answer 1

Esto es complicado.

Existe una solución Cypher pura, pero es una consulta complicada y requiere algunos filtros potencialmente pesados ​​para eliminar las rutas hacia los nodos de retención de cuentas que están más allá de los nodos más cercanos a la cuenta a lo largo de la misma ruta.

Sin embargo, he encontrado una alternativa mejor utilizando Cypher y el expansor de rutas de APOC , además de un preprocesamiento para agregar una etiqueta a los nodos que son titulares de cuenta.

El expansor de rutas de APOC tiene un medio para expandirse respetando un filtro de etiquetas, y existe un medio para definir una etiqueta que debería podar cualquier cruce adicional, pero debe incluirse como una solución. Lo usaremos para limitar nuestra expansión al obtener antepasados ​​de cuenta para nodos.

Aquí hay una consulta de creación para recrear el gráfico en su ejemplo (aunque etiqueto nodos que NO SON CUENTAS como: Nodo):

// create inherited account graph
create (morpheus:Node{name:''Morpheus''})
create (neo:Node{name:''Neo''})
create (alpha:Node{name:''alpha''})
create (gamma:Node{name:''gamma''})
create (beta:Node{name:''beta''})

create (A:Node{name:''A''})
create (B:Node{name:''B''})
create (C:Node{name:''C''})
create (D:Node{name:''D''})
create (E:Node{name:''E''})
create (F:Node{name:''F''})
create (G:Node{name:''G''})

create (morpheus)-[:CHILD]->(neo)
create (neo)-[:CHILD]->(alpha)
create (alpha)-[:CHILD]->(gamma)
create (gamma)-[:CHILD]->(A)
create (beta)-[:CHILD]->(A)
create (A)-[:CHILD]->(B)
create (A)-[:CHILD]->(C)
create (B)-[:CHILD]->(D)
create (B)-[:CHILD]->(E)
create (C)-[:CHILD]->(F)
create (C)-[:CHILD]->(G)

create (morpheus)-[:HAS_ACCOUNT]->(a0:ACCOUNT{name:''a0''})
create (neo)-[:HAS_ACCOUNT]->(a1:ACCOUNT{name:''a1''})
create (beta)-[:HAS_ACCOUNT]->(a2:ACCOUNT{name:''a2''})
create (B)-[:HAS_ACCOUNT]->(a3:ACCOUNT{name:''a3''})

A continuación, etiquetamos los nodos de retención de cuenta.

MATCH (acc:ACCOUNT)
WITH acc
MATCH (acc)<-[:HAS_ACCOUNT]-(holder)
SET holder:ACCOUNT_HOLDER

Una vez que esté en su lugar, podemos usar la siguiente consulta para obtener su resultado deseado:

// parameterize this in your own query
with ''A'' as nodeName
match (node:Node{name:nodeName})-[r:CHILD*0..]->(currentNode)
with node, currentNode, size(r) as distance
optional match (currentNode)-[:HAS_ACCOUNT]->(acc)
with node, currentNode, distance, collect(acc) as accounts
// we now have all child nodes of the given node and their accounts, if they exist.

// this expands up from each currentNode, 
// stopping each expansion at the closest ACCOUNT_HOLDER node
call apoc.path.expand(currentNode, ''<CHILD'', ''/ACCOUNT_HOLDER'', -1, -1)
yield path
with node, currentNode, distance, accounts, last(nodes(path)) as holder
// get the account for each holder, 
// but only if the current doesn''t have its own accounts
optional match (holder)-[:HAS_ACCOUNT]->(acc)
where size(accounts) = 0
with node, currentNode, accounts, collect(acc) as inherited, distance
order by distance asc
return node, currentNode, accounts, inherited

Sin embargo, tenga en cuenta que incluso con este enfoque, la consulta no creará y reutilizará las soluciones (por ejemplo, una vez que hemos encontrado los antecesores de la cuenta para el nodo A, esa solución no se referencia ni se reutiliza cuando tenemos que obtener la cuenta). -mantener ancestros para nodos, C, F o G). Es posible que desee considerar un procedimiento personalizado para realizar esta complicada operación de coincidencia en código en lugar de Cypher para obtener la máxima eficacia.