AB

Overview

The ab().src().dest().depth() statement retrieves paths between two sets of nodes by pairing each node in src() with each node in dest() for pathfinding. If n nodes are specified by src() and m nodes by dest(), a total of n * m node pairs will be considered.

Syntax

Syntax
ab().src(<filter?>).dest(<filter?>).depth(<range>)

• Statement alias: Type PATH
  
• Methods:

Example Graph

To create the graph, execute each of the following UQL queries sequentially in an empty graphset:

UQL
create().edge_property(@default, "weight", int32)
insert().into(@default).nodes([{_id:"A"}, {_id:"B"}, {_id:"C"}, {_id:"D"}, {_id:"E"}, {_id:"F"}])
insert().into(@default).edges([{_from:"A", _to:"C", weight:1}, {_from:"E", _to:"B", weight:1}, {_from:"A", _to:"E", weight:4}, {_from:"D", _to:"C", weight:2}, {_from:"E", _to:"D", weight:3}, {_from:"B", _to:"A", weight:2}, {_from:"F", _to:"A", weight:4}])

Finding Paths of Varying Depths

Within N Steps

To find paths within 3 steps between nodes A or C and nodes D or E:

UQL
ab().src({_id in ["A", "C"]}).dest({_id in ["D", "E"]}).depth(:3) as p
return p

Result: p

Exact N Steps

To find paths with exact 3 steps between nodes A, C and nodes D, E:

UQL
ab().src({_id in ["A", "C"]}).dest({_id in ["D", "E"]}).depth(3) as p
return p

Result: p

Within N to M Steps

To find paths with 2 to 3 steps between nodes A, C and nodes D, E:

UQL
ab().src({_id in ["A", "C"]}).dest({_id in ["D", "E"]}).depth(2:3) as p
return p

Result: p

Finding Unweighted Shortest Paths

To find the shortest paths within 5 steps between node A and node D:

UQL
ab().src({_id == "A"}).dest({_id == "D"}).depth(5).shortest() as p
return p

Result: p

Finding Weighted Shortest Paths

To find the shortest paths weighted by the property @default.weight within 5 steps between node A and node D, and compute the total weight of the paths:

UQL
ab().src({_id == "A"}).dest({_id == "D"}).depth(5).shortest(@default.weight) as p
call {
  with p
  uncollect pedges(p) as edges
  return sum(edges.weight) as weights
}
return p, weights

Result:

Filtering Intermediate Nodes

To find paths within 5 steps between node F and nodes E without passing through node D:

UQL
ab().src({_id == "F"}).dest({_id == "E"}).depth(:5).node_filter({_id != "D"}) as p
return p

Result: p

Filtering Edges

To find paths within 3 steps between node A and node E, where the property weight of each edge is greater than 1:

UQL
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3).edge_filter({weight > 1}) as p
return p

Result: p

Setting Ascending or Descending Edge Property Values

To find paths within 3 steps between node A to node E, where the property @default.weight values ascend along the path:

UQL
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3).path_ascend(@default.weight) as p
return p

Result: p

To find paths within 3 steps between node A to node E, where the property @default.weight values descend along the path:

UQL
ab().src({_id == "A"}).dest({_id == "E"}).depth(:3).path_descend(@default.weight) as p
return p

Result: p

Setting Edge Directions

To find paths within 2 to 4 steps between nodes A, C and node E with all edges pointing to the left:

UQL
ab().src({_id in ["A", "C"]}).dest({_id == "E"}).depth(2:3).direction(left) as p
return p

Result: p

Excluding Circles

To find paths with exact 4 steps between node A and E without any circles:

UQL
ab().src({_id == "A"}).dest({_id == "C"}).depth(4).no_circle() as p
return p

Result: p

Without the no_circle() method, three paths will be returned:

UQL
ab().src({_id == "A"}).dest({_id == "C"}).depth(4) as p
return p

Result: p

Using limit()

To find paths within 3 steps between nodes A, C and node E, return only one path for each node pair:

UQL
ab().src({_id in ["A", "C"]}).dest({_id == "E"}).depth(:3).limit(1) as p
return p{*}

Result: p

Using OPTIONAL

In this query, the ab() statement executes two times, each time using one record from n. With the OPTIONAL prefix, the query returns null if no result is found during execution:

UQL
find().nodes({_id in ["A","C"]}) as n
optional ab().src(n).dest({_id == "D"}).depth(1) as p
return p

Result: p

Without the prefix OPTIONAL, only one record is returned:

UQL
find().nodes({_id in ["A","C"]}) as n
ab().src(n).dest({_id == "D"}).depth(1) as p
return p

Result: p