Modèle de Chemin

Un modèle de chemin n().e()...n() peut appliquer des filtres sur chaque node et edge d'un chemin indépendamment. Les chemins avec cycle peuvent être filtrés, et le nombre de résultats de sous-requête peut être limité.

Pour l'utilisation des modèles de base n(), e(), etc., veuillez vous référer à Modèles de Base.

Syntaxe:

• Alias de déclaration : supporté (PATH)
• Préfixe : OPTIOANL (retourne un chemin dont les nodes et edges sont tous null pour toute sous-requête qui ne trouve aucun résultat)
• Paramètres optionnels :

Graph d'exemple : (à utiliser pour les exemples suivants)

create().node_schema("country").node_schema("movie").node_schema("director").edge_schema("filmedIn").edge_schema("direct")
create().node_property(@*, "name")
insert().into(@country).nodes([{_id:"C001", _uuid:1, name:"France"}, {_id:"C002", _uuid:2, name:"USA"}])
insert().into(@movie).nodes([{_id:"M001", _uuid:3, name:"Léon"}, {_id:"M002", _uuid:4, name:"The Terminator"}, {_id:"M003", _uuid:5, name:"Avatar"}])
insert().into(@director).nodes([{_id:"D001", _uuid:6, name:"Luc Besson"}, {_id:"D002", _uuid:7, name:"James Cameron"}])
insert().into(@filmedIn).edges([{_uuid:1, _from_uuid:3, _to_uuid:1}, {_uuid:2, _from_uuid:4, _to_uuid:1}, {_uuid:3, _from_uuid:3, _to_uuid:2}, {_uuid:4, _from_uuid:4, _to_uuid:2}, {_uuid:5, _from_uuid:5, _to_uuid:2}])
insert().into(@direct).edges([{_uuid:6, _from_uuid:6, _to_uuid:3}, {_uuid:7, _from_uuid:7, _to_uuid:4}, {_uuid:8, _from_uuid:7, _to_uuid:5}])

Filtrer un Seul Node/Edge

Exemple : Trouver des chemins à un node de @movie, avec toutes les propriétés

n({@movie}) as p
return p{*}

Léon
Avatar
The Terminator

Exemple : Trouver des chemins de 4 étapes de @movie-@country-@movie-@director-@movie, avec toutes les propriétés

n({@movie}).re({@filmedIn}).n({@country})
  .le({@filmedIn}).n({@movie})
  .le({@direct}).n({@director})
  .re({@direct}).n({@movie}) as p
return p{*}

Léon ----> France <---- The Terminator <---- James Cameron ----> Avatar
Léon ----> USA <---- The Terminator <---- James Cameron ----> Avatar
Léon ----> USA <---- Avatar <---- James Cameron ----> The Terminator
The Terminator ----> USA <---- Avatar <---- James Cameron ----> The Terminator
Avatar ----> USA <---- The Terminator <---- James Cameron ----> Avatar

Filtrer Multi-Edge

Exemple : Trouver des chemins de 1 à 4 étapes de Léon à Avatar, avec toutes les propriétés

n({@movie.name == "Léon"}).e()[:4].n({@movie.name == "Avatar"}) as p
return p{*}

Léon ----> France <---- The Terminator ----> USA <---- Avatar
Léon ----> France <---- The Terminator <---- James Cameron ----> Avatar
Léon ----> USA <---- The Terminator <---- James Cameron ----> Avatar
Léon ----> USA <---- Avatar

Filtrer Multi-Edge et Nodes Intermédiaires

Exemple : Trouver des chemins de 1 à 4 étapes de Léon à Avatar sans passer par France, avec toutes les propriétés

n({@movie.name == "Léon"}).e().nf({name != "France"})[:4].n({@movie.name == "Avatar"}) as p
return p{*}

Léon ----> USA <---- The Terminator <---- James Cameron ----> Avatar
Léon ----> USA <---- Avatar

Chemin le Plus Court Non Pondéré

Exemple : Trouver les chemins les plus courts de Léon à Avatar dans un rayon de 4 étapes, avec toutes les propriétés

n({@movie.name == "Léon"}).e()[*:4].n({@movie.name == "Avatar"}) as p
return p{*}

Léon ----> USA <---- Avatar

Analyse : Le modèle multi-edge e()[*:N] ou e().nf()[*:N] qui représente le chemin le plus court doit être le dernier modèle d'edge du chemin.

Filtrer les Cycles

Exemple : Trouver des chemins de 4 étapes de @movie-@country-@movie-@director-@movie, avec le node initial et le node terminal représentant le même node, avec toutes les propriétés

n({@movie} as a).re({@filmedIn}).n({@country})
  .le({@filmedIn}).n({@movie})
  .le({@direct}).n({@director})
  .re({@direct}).n(a) as p
return p{*}

The Terminator ----> USA <---- Avatar <---- James Cameron ----> The Terminator
Avatar ----> USA <---- The Terminator <---- James Cameron ----> Avatar

Exemple : Trouver des chemins de 4 étapes de @movie-@country-@movie-@director-@movie, enlever les chemins avec des cycles, avec toutes les propriétés

n({@movie}).re({@filmedIn}).n({@country})
  .le({@filmedIn}).n({@movie})
  .le({@direct}).n({@director})
  .re({@direct}).n({@movie}).no_circle() as p
return p{*}

Léon ----> France <---- The Terminator <---- James Cameron ----> Avatar
Léon ----> USA <---- The Terminator <---- James Cameron ----> Avatar
Léon ----> USA <---- Avatar <---- James Cameron ----> The Terminator

limit()

Exemple : Trouver deux chemins de 4 étapes de @movie-@country-@movie-@director-@movie, avec toutes les propriétés

n({@movie}).re({@filmedIn}).n({@country})
  .le({@filmedIn}).n({@movie})
  .le({@direct}).n({@director})
  .re({@direct}).n({@movie}).limit(2) as p
return p{*}

Léon ----> France <---- The Terminator <---- James Cameron ----> Avatar
Léon ----> USA <---- The Terminator <---- James Cameron ----> Avatar

OPTIONAL

Exemple : Trouver des chemins de 2 étapes de Luc Besson à Avatar, avec toutes les propriétés; retour null si aucun résultat

optional n({@director.name == "Luc Besson"}).e()[2].n({@movie.name == "Avatar"}) as p
return p{*}

null --null-- null --null-- null

Analyse : Cette requête ne retournera rien si on n'utilise pas OPTIONAL.

Graph d'exemple : (à utiliser pour les exemples suivants)

create().node_schema("customer").node_schema("account").edge_schema("has").edge_schema("transfer")
create().edge_property(@transfer, "time", datetime)
insert().into(@customer).nodes([{_id:"C001", _uuid:1}])
insert().into(@account).nodes([{_id:"A001", _uuid:2}, {_id:"A002", _uuid:3}, {_id:"A003", _uuid:4}, {_id:"A004", _uuid:5}])
insert().into(@has).edges([{_uuid:1, _from_uuid:1, _to_uuid:2}, {_uuid:2, _from_uuid:1, _to_uuid:3}])
insert().into(@transfer).edges([{_uuid:3, _from_uuid:2, _to_uuid:4, time:"2023-03-01"}, {_uuid:4, _from_uuid:2, _to_uuid:5, time:"2023-04-25"}, {_uuid:5, _from_uuid:4, _to_uuid:5, time:"2023-03-27"}, {_uuid:6, _from_uuid:5, _to_uuid:3, time:"2023-02-15"}])

Filtrer 0 Étape

Exemple : Trouver des chemins de transfert externe de 0 à 2 étapes à partir des comptes détenus par C001 vers d'autres comptes, avec toutes les propriétés

n({_id == "C001"}).re({@has}).n({@account})
  .re({@transfer})[0:2].n({@account}) as p
return p{*}

C001 ----> A001
C001 ----> A001 ----> A003
C001 ----> A001 ----> A003 ----> A004
C001 ----> A001 ----> A004
C001 ----> A001 ----> A004 ----> A002
C001 ----> A002

Analyse : Le 0 étape dans le modèle multi-edge e()[0:N] ou e().nf()[0:N] fonctionne uniquement lorsque les n() avant et après ce modèle multi-edge ont la même condition de filtrage.

Filtrage Inter-Étape

Exemple : Trouver des chemins de transfert externe de 2 étapes entre les comptes, avec la propriété time en ordre croissant le long du chemin, avec toutes les propriétés

n({@account}).re({@transfer.time > prev_e.time})[2].n({@account}) as p
return p{*}

A001 ----> A003 ----> A004

Analyse : La propriété @transfer.time doit être chargée dans le moteur (LTE).