Parcourir un arbre

[pro.l...@gmail.com]

Bonjour,

J'ai construit un arbre sur Neo4j représentant des parcours.

Pour mes tests, j'ai pris c'est parcours:
[['A','B','C'],['A','B'],['A','B','D','C'],['B','C'],['C','A','B','C']]

Ce qui me donne l'arbre suivant:

A -> B -> C (1)

           -> D -> C (2) 
B -> C -> D - > E (3)

C -> A -> B -> C (4)

Dans mon algorithme, je me place aux extrémités de mon arbre qui ont un parcours qui contient par exemple B
Soit ici, toutes les extrémités.

Grâce à une ID, j'arrive à me me placer sur ces extrémités.

Mais voilà que les choses se corsent. Je souhaite remonter l'arbre jusqu'à atteindre B et récupérer toutes les données parcourus.
Soit pour les chemins:
- (1) : C

- (2) : D, C

- (3) : C, D, E
- (4) : C

Je suis parti sur cette requête: "MATCH (n)-[:TO*..]->(m)-[:TO*..]->(l) WHERE n.lettre = B AND ID(l)={id_extremité} RETURN l.lettre, m.lettre"

Si vous avez des suggestions, vous me seriez d'une grande aide.

Merci par avance

 
  





 

[Benoît Simard]

Et poirquoi pas :

MATCH p=(n)-[*]->(m)
WHERE id(m)=12 AND  n.lettre ='b'
RETURN NODES (p)

Avec un index sur l'attribut `lettre` du noeud ce serait mieux.

A+

[pro.l...@gmail.com]

Bonjour à tous,
Finalement, il se trouve que je possède ces données dans neo4j.
Pour éviter la redondance, je souhaiterai plutôt créer des nodes unique correspondant aux différents types d'action possibles  : A, B, C, D
Et mettre des liens en place entre le user (qui a fait le parcours) et les type d'actions qu'il a fait tout en gardant l'information sur l'"ordre"

Imaginons que j'ai un parcrous A, B, B, C

je vois deux possibiliés:

1/

(user)-[date]->(A)

(user)-[date1]->(B)
(user)-[date2]->(B)
(user)-[date]->(C)

Ici, j'ai un user, 3 type d'actions et 4 liens crées

2/

(user)-[[date], poids: 1]->(A)

(user)-[date1, date2], poids: 2]->(B)
(user)-[[date], poids: 1]->(C)

Ici, j'ai un user, 3 type d'actions et 3 liens crées mais avec d'avantage d'informations.

Dans mes requêtes, je vais devoir récupérer l'ordre des actions par dates (parcours).
Savez vous quelle construction est la plus pertinente?

Avez-vous d'autres idées?

Je peux d'avantage détailler au besoin

Merci d'avance pour votre aide



 

[Benoît Simard]

Yop,

Comme toujours, tout dépend du use-case que tu veux faire ...

Faire de la modélisation a distance est un peu compliqué, mais je vais essayer ^^

(user1)-[:HAS_PATH]->(:Path { uuid:'1234567890', date:'2016-10-20' })-[:FIRST_STEP {path_uuid:'1234567890'} ]->(A)-[:NEXT_STEP {path_uuid:'1234567890'}]->(B)-[:NEXT_STEP {path_uuid:'1234567890'}]->(B)-[:NEXT_STEP {path_uuid:'1234567890'}]->(C)

Ici ya un noeud (:Path) qui correspond à un chemin utilisateur avec une date.  Après j'ai chainé les actions avec des relations NEXT_STEP possédant un attribut pour déterminé le parcours de l'utilisateur.

L'inconvénient, c'est qu'avec de la volumétrie, chaque noeud 'Action' va avoir beaucoup de relation du même type, et à partir d'un certain niveau les performances  vont se dégrader (sortir d'un noeud action prendra du temps).

Une solution sera donc de créer dynamiquement un type de relation 'NEXT_STEP' avec directement l'uuid du PATH, ce qui donnerai : 

(user1)-[:HAS_PATH]->(:Path { uuid:'1234567890', date:'2016-10-20' })-[:FIRST_STEP_1234567890]->(A)-[:STEP_1234567890]->(B)-[:STEP_1234567890]->(B)-[:STEP_1234567890]->(C)

Mais le nombre de type de relation n'est pas (encore) infini dans Neo.

Sincèrement.