Autonet

Overview

The autonet().src().dest().depth() statement retrieves paths between nodes.

When two sets of nodes are provided, the query attempts to find paths between each node in the source set and each node in the destination set. If only one set of nodes is given, each node in the set is paired with all other nodes in the same set to search for paths.

Syntax

Syntax
autonet().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, C and nodes D, E:

UQL
autonet().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
autonet().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
autonet().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
autonet().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
autonet().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
autonet().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
autonet().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
autonet().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
autonet().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
autonet().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
autonet().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
autonet().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
autonet().src({_id in ["A", "C"]}).dest({_id == "E"}).depth(:3).limit(1) as p
return p{*}

Result: p

Using OPTIONAL

In this query, the autonet() 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 autonet().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
autonet().src(n).dest({_id == "D"}).depth(1) as p
return p

Result: p