Overview
The clause ab().src().dest().depth() retrieves paths between a single source node and a single destination node.
Syntax
Clause Alias: PATH type
Method |
Param Type |
Param Spec |
Required |
Description | Alias |
|---|---|---|---|---|---|
src() |
Filter | / | Yes | The conditions of the single source node; error occurs if multiple nodes are specified | NODE |
dest() |
Filter | / | Yes | The conditions of the single destination node; error occurs if multiple nodes are specified | NODE |
depth() |
Range | / | Yes | Depth of the paths (N≥1):depth(N): N edgesdepth(:N): 1~N edgesdepth(M:N): M~N edges (M≥0) |
N/A |
shortest() |
/ or @<schema>.<property> |
LTE-ed numeric edge property | No | Return the (weighted) shortest path. When an edge property is specified, edges without that property will not be considered The shortest() method only supports depth(N), indicating the (weighted) shortest paths within N steps |
N/A |
node_filter() |
Filter | / | No | The conditions that all intermediate nodes in the paths must satisfy | N/A |
edge_filter() |
Filter | / | No | The conditions that all edges in the paths must satisfy | N/A |
path_ascend() |
@<schema>.<property> |
LTE-ed numeric edge property | No | Return paths where the specified property values ascend from source to destination (edges without the property will not be considered) | N/A |
path_descend() |
@<schema>.<property> |
LTE-ed numeric edge property | No | Return paths where the specified property values descend from source to destination (edges without the property will not be considered) | N/A |
direction() |
String | left, right |
No | Direction of all edges in the paths | N/A |
no_circle() |
/ | / | No | Paths with circles will not be returned Exception: When src() and dest() specify the same node and that node does not appear in any intermediate position, the path will still be returned |
N/A |
limit() |
Integer | ≥-1 | No | Number of results to return for each subquery, -1 signifies returning all |
N/A |
Examples
Example Graph
Run these UQLs row by row in an empty graphset to create this graph:
create().edge_property(@default, "weight", int32)
insert().into(@default).nodes([{_id:"A", _uuid:1}, {_id:"B", _uuid:2}, {_id:"C", _uuid:3}, {_id:"D", _uuid:4}, {_id:"E", _uuid:5}, {_id:"F", _uuid:6}])
insert().into(@default).edges([{_uuid:1, _from_uuid:1, _to_uuid:3, weight:1}, {_uuid:2, _from_uuid:5, _to_uuid:2 , weight:1}, {_uuid:3, _from_uuid:1, _to_uuid:5 , weight:4}, {_uuid:4, _from_uuid:4, _to_uuid:3 , weight:2}, {_uuid:5, _from_uuid:5, _to_uuid:4 , weight:3}, {_uuid:6, _from_uuid:2, _to_uuid:1 , weight:2}, {_uuid:7, _from_uuid:6, _to_uuid:1 , weight:4}])
Filter Depth
Example: Find 3-step paths from A to E, carry all properties
ab().src({_id == "A"}).dest({_id == "E"}).depth(3) as p
return p{*}
A --1--> C <--4-- D <--5-- E
Example: Find 1~3-step paths from A to E, carry all properties
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3) as p
return p{*}
A --3--> E
A --1--> C <--4-- D <--5-- E
A <--6-- B <--2-- E
Example: Find 2~3-step paths from A to E, carry all properties
ab().src({_id == "A"}).dest({_id == "E"}).depth(2:3) as p
return p{*}
A --1--> C <--4-- D <--5-- E
A <--6-- B <-2-- E
Non-weighted Shortest Path
Example: Find shortest paths from A to E within 3 steps, carry all properties
ab().src({_id == "A"}).dest({_id == "E"}).depth(3)
.shortest() as p
return p{*}
A --3--> E
Weighted Shortest Path
Example: Find shortest paths from A to E within 3 steps, use @default.weight as weight, carry all properties
ab().src({_id == "A"}).dest({_id == "E"}).depth(3)
.shortest(@default.weight) as p
return p{*}
A <--6-- B <--2-- E
Analysis: Porperty @default.weight should be loaded to engine (LTE).
Filter Intermediate Nodes
Example: Find 1~3-step paths from A to E and not passing D, carry all properties
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3)
.node_filter({_id != "D"}) as p
return p{*}
A --3--> E
A <--6-- B <--2-- E
Filter Edges
Example: Find 1~3-step paths from A to E where the weight of edge is greater than 1, carry all properties
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3)
.edge_filter({weight > 1}) as p
return p{*}
A --3--> E
Edge Property Ascend/Descend
Example: Find 1~3-step paths from A to E with property @default.weight ascending along the path, carry all properties
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3)
.path_ascend(@default.weight) as p
return p{*}
A --3--> E
A --1--> C <--4-- D <--5-- E
Analysis: Porperty @default.weight should be loaded to engine (LTE).
Example: Find 1~3-step paths from A to E with property @default.weight descending along the path, carry all properties
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3)
.path_descend(@default.weight) as p
return p{*}
A --3--> E
A <--6-- B <--2-- E
Analysis: Porperty @default.weight should be loaded to engine (LTE).
Filter Edge Direction
Example: Find 1~3-step paths from A to E with all edges right-pointing, carry all properties
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3)
.direction(right) as p
return p{*}
A --3--> E
Example: Find 1~3-step paths from A to E with all edges left-pointing, carry all properties
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3)
.direction(left) as p
return p{*}
A <--6-- B <--2-- E
Filter Circles
Example: Find 4-step paths from A to E that do not contain circle, carry all properties
ab().src({_id == "A"}).dest({_id == "C"}).depth(4).no_circle() as p
return p{*}
A <--6-- B <--2-- E --3--> D --4--> C
Analysis: Paths with circle will be returned if not using no_circle():
A --3--> E --2--> B --6--> A --1--> C
A <--6-- B <--2-- E --3--> D --4--> C
A <--6-- B <--2-- E <--3-- A --1--> C
limit()
Example: Find a 1~3-step path from A to E, carry all properties
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3).limit(1) as p
return p{*}
A <--6-- B <--2-- E