Gremlin repeat untill the combined weight is greater than x - graph

Question

Hello I'm messing around with Gremlin to find paths from one node to another. I have a weighted graph and I need to be able to find all the paths that don't exceed a combined weight.
For instance, if I want all the paths from [A] to [D] that don't exceed the weight of 20
[A] -5-> [B] -15-> [C] -20-> [D] - Would not be valid as it exceeds a combined weight of 20
[A] -5-> [B] -15-> [D] - Would return as its combined weight does not exceed 20.
This is my current query
g.V('A').repeat(bothE().otherV().hasLabel('test'))
.until(hasId('D')
.or().loops().is(5)
.or().map(unfold().coalesce(values("weight"),constant(0)).sum().is(gt(20))))
.hasId('D').path().by(valueMap(true))
If I remove the below section of the query it returns the same data so there is something wrong with my logic here.
.or().map(unfold().coalesce(values("weight"),constant(0)).sum().is(gt(20))))
I have considered just filtering this out in the backend API but this doesn't seem like a good practise as a lot of commuting may be wasted as the graph gets larger.

Answer 1

This is a case where the sack step can help a lot. As the query progresses you can continually add the weights found to the current sack value.
Using the air-routes data set, where edges have a distance (dist) property, we can write a query similar to yours that will end when it finds the target or the sack has exceeded the allowed maximum. I added all the parts that start with local just to show some nicely formatted results. Note the second has check. This is needed to make sure we found the intended target in cases where we exited the repeat as the sack limit has been exceeded.
g.withSack(0).
V('3').
repeat(outE().sack(sum).by('dist').inV().simplePath()).
until(hasId('49').or().sack().is(gt(6000)).or().loops().is(3)).
hasId('49').
local(
union(
path().
by('code').
by('dist'),
sack()).
fold()).
limit(3)
which yields
1 [path[AUS, 4901, LHR], 4901]
2 [path[AUS, 748, MEX, 5529, LHR], 6277]
3 [path[AUS, 1209, PIT, 3707, LHR], 4916]
To filter out the results where the total exceeds the target, we can move the test to be after the until
g.withSack(0).
V('3').
repeat(outE().sack(sum).by('dist').inV().simplePath()).
until(hasId('49').or().loops().is(3)).
hasId('49').
where(sack().is(lte(6000))).
local(
union(
path().
by('code').
by('dist'),
sack()).
fold()).
limit(3)
this time all the results are less than the target of 6000.
1 [path[AUS, 4901, LHR], 4901]
2 [path[AUS, 1209, PIT, 3707, LHR], 4916]
3 [path[AUS, 809, ATL, 4198, LHR], 5007]
Using this template you can hopefully build a version of your query.
UPDATED after discussion in the comments. In the absence of sack, you can try something like this. It essentially builds a path of distances, substituting a 0 for where the vertices are, adds that list up, and filters on the sum. It's pretty ugly, but it works!
g.V('3').
repeat(outE().as('d').inV().simplePath()).
until(hasId('49').or().loops().is(3)).
hasId('49').
where(path().by(constant(0)).by('dist').unfold().sum().is(lte(6000))).
path().
by('code').
by('dist').
limit(5)
The results are
1 path[AUS, 4901, LHR]
2 path[AUS, 1209, PIT, 3707, LHR]
3 path[AUS, 809, ATL, 4198, LHR]
4 path[AUS, 755, BNA, 4168, LHR]
5 path[AUS, 1690, BOS, 3254, LHR]
Not having support for sack is going to make everything a lot more complex but this at least is a possible workaround.