AQL验证节点的路径

Question

We're required to have some AQL that validates a specific path to an entity. The current solution performs very poorly, due to needing to scan whole collections.

eg here we have 3 entity 'types': a, b, c (though they are all in a single collection) and specific edge collections between them and we want to establish whether or not there is a connection between _key "123" and _key "234" that goes exactly through a -> b -> c.

FOR a IN entities FILTER e._key == "123" FOR b IN 1..1 OUTBOUND e edges_a_to_b FOR c IN 1..1 INBOUND e_1 edges_c_to_b FILTER e_2._key == "234" ...

This can fan out very quickly!

We have another solution, where we use SHORTEST PATH and specify the appropriate DIRECTION and edge collections which is much faster (>100times). But worry that this approach does not satisfy quite our general case... the order of the edges is not enforced, and we may have to go through the same edge collection more than once, which we cannot do with that syntax.

Is there another way, possibly involving paths in the traversal?

Thanks! Dan.

Answer 1

If i understand correctly you always know the exact path that is required between your two vertices.

So to take your example a -> b -> c , a valid result will have: path.vertices == [a, b, c] So we can use this path to filter on it, which only works if you use a single traversal step instead of multiple ones. So what we try to du is the following pattern:

FOR c,e, path IN <pathlength> <direction> <start> <edge-collections>
  FILTER path.vertices[0] == a // This needs to be formulated correctly
  FILTER path.vertices[1] == b // This needs to be formulated correctly
  FILTER path.vertices[2] == c // This needs to be formulated correctly
  LIMIT 1 // We only net exactly one path, so limit 1 is enough
  [...]

So with this hint is it possible to write the query in the following way:

FOR a IN entities
  FILTER a._key == "123"
  FOR c, e, path IN 2 OUTBOUND a edges_a_to_b, INBOUND edges_b_to_c
    FILTER path.vertices[1] == /* whatever identifies b e.g. vertices[1].type == "b" */
    FILTER path.vertices[2]._key == "234"
    LIMIT 1 /* This will stop as soon as the first match is found, so very important! */
    /* [...] */

This will allow the optimizer to apply the filter conditions as early as possible, und will (almost) use the same algorithm as the shortest path implementation. The trick is to use one traversal instead of multiples to save internal overhead and allow for better optimization.

Also take into account that it might be better to search in the opposite direction:

eg instead of a -> b -> c check for c <- b <- a which might be faster. This depends on the amount of edges per each node. I assume a doctor has many surgeries, but a single patient most likely has only a small amount of surgeries so it is better to start at the patient and check backwards instead of starting at the doctor and check forwards.

Please let me know it this helps already, otherwise we can talk about more details and see if we can find some further optimizations.

Disclaimer: I am part of the Core-Dev team at ArangoDB