ArangoDB：使用PRUNE遍历时的奇怪行为

我想遍历一个图并检查每个顶点的度数。如果某个顶点的阶数超过阈值，则该顶点必须包含在结果中，但遍历过程不得遵循该路径。根据文档，修剪选项似乎适合我

我写了这个问题：

FOR v, e IN 3 ANY 'nodes/ce07aa' GRAPH 'test_graph'
   PRUNE (FOR r IN rels FILTER r._from == v._id COLLECT WITH COUNT INTO count RETURN count) + (FOR r IN rels FILTER r._to == v._id COLLECT WITH COUNT INTO count RETURN count) > 100
   RETURN {name: v.name, type: v.type}

但是执行它需要太多的时间。执行计划中有一件奇怪的事情我不明白

Execution plan:
 Id   NodeType                      Est.   Comment
  1   SingletonNode                    1   * ROOT
  8   SubqueryNode                     1     - LET #4 = ...   /* subquery */
  2   SingletonNode                    1       * ROOT
  3   EnumerateCollectionNode   37981389         - FOR r IN rels   /* full collection scan, projections: `_from` */
  4   CalculationNode           37981389           - LET #10 = (r.`_from` == v.`_id`)   /* simple expression */   /* collections used: r : rels */
  5   FilterNode                37981389           - FILTER #10
  6   CollectNode                      1           - COLLECT  WITH COUNT INTO count   /* count */
  7   ReturnNode                       1           - RETURN count
 15   SubqueryNode                     1     - LET #8 = ...   /* subquery */
  9   SingletonNode                    1       * ROOT
 10   EnumerateCollectionNode   37981389         - FOR r IN rels   /* full collection scan, projections: `_to` */
 11   CalculationNode           37981389           - LET #12 = (r.`_to` == v.`_id`)   /* simple expression */   /* collections used: r : rels */
 12   FilterNode                37981389           - FILTER #12
 13   CollectNode                      1           - COLLECT  WITH COUNT INTO count   /* count */
 14   ReturnNode                       1           - RETURN count
 16   TraversalNode                   64     - FOR v  /* vertex */ IN 3..3  /* min..maxPathDepth */ ANY 'nodes/ce07aa' /* startnode */  GRAPH 'test_graph'
 17   CalculationNode                 64       - LET #16 = { "name" : v.`name`, "type" : v.`type` }   /* simple expression */
 18   ReturnNode                      64       - RETURN #16

根据这一点，它不使用索引，而是扫描整个边缘集合

但是，当我试图计算度并在结果中显示时，如下所示：

FOR v, e IN ANY 'nodes/ce07aa' GRAPH 'test_graph'
   let degree = (FOR r IN rels FILTER r._from == v._id COLLECT WITH COUNT INTO count RETURN count) + (FOR r IN rels FILTER r._to == v._id COLLECT WITH COUNT INTO count RETURN count)
   RETURN {name: v.name, type: v.type, degree: degree}

正如我所料：

    Execution plan:
 Id   NodeType          Est.   Comment
  1   SingletonNode        1   * ROOT
  2   TraversalNode        4     - FOR v  /* vertex */ IN 1..1  /* min..maxPathDepth */ ANY 'nodes/ce07aa' /* startnode */  GRAPH 'test_graph'
  9   SubqueryNode         4       - LET #4 = ...   /* subquery */
  3   SingletonNode        1         * ROOT
 20   IndexNode            2           - FOR r IN rels   /* edge index scan, scan only */    
  7   CollectNode          1             - COLLECT  WITH COUNT INTO count   /* count */
  8   ReturnNode           1             - RETURN count
 16   SubqueryNode         4       - LET #8 = ...   /* subquery */
 10   SingletonNode        1         * ROOT
 21   IndexNode            2           - FOR r IN rels   /* edge index scan, scan only */    
 14   CollectNode          1             - COLLECT  WITH COUNT INTO count   /* count */
 15   ReturnNode           1             - RETURN count
 18   CalculationNode      4       - LET #17 = { "name" : v.`name`, "type" : v.`type`, "degree" : (#4 + #8) }   /* simple expression */
 19   ReturnNode           4       - RETURN #17

为什么相同的子查询以如此不同的方式执行？ 是否有更好的方法按顶点的度数过滤顶点

谢谢