Question

我显然缺少了一些东西，当我运行以下查询时，我得到40ms的响应：

FOR t IN tt
FOR a in aa 
FILTER a.from._key == t._key
AND a.value == @v
LIMIT 20 RETURN t

但是当我添加排序时，查询将一直运行直到必须将其杀死！

FOR t IN tt
FOR a in aa
FILTER a.from._key == t._key
AND a.value == @v
SORT t.identifier.value ASC
LIMIT 20 RETURN t

我在identifier.value上有一个跳过列表索引，但是当我查看执行计划时，会看到一个可怕的完整集合扫描。

2 EnumerateCollectionNode 240126 - FOR t IN tt   /* full collection scan */

我在tt中有250000个文档，例如：

{
  “_key”: "CA0350ED-4929-3D1A-37A5-8AB951CE3AB5"
  "type": “f.g.h”,
  "identifier": {
    “dist”: “N”,
    "value": "Matt100145 ZZZ"
  }
}

和500000个文档，例如：

{
  “_key”: "1BBDE335-B118-3ED5-DE3B-77D822822210"
  "type": “a.b.c”,
  "from": {
    "_key": "CA0350ED-4929-3D1A-37A5-8AB951CE3AB5",
    "value": "Matt100145 ZZZ”
    }
  },
  "value": “ZZZ”
}

tt中的所有identifier.value值都是MattNUMBER ZZZ（测试数据），是否可能引起麻烦？

没有排序的查询计划如下：

Execution plan:
 Id   NodeType        Est.   Comment
  1   SingletonNode      1   * ROOT
  9   IndexNode          2     - FOR a IN aa   /* hash index scan */
  8   IndexNode          2       - FOR t IN tt   /* primary index scan */
  6   LimitNode          2         - LIMIT 0, 20
  7   ReturnNode         2         - RETURN t

Indexes used:
 By   Type      Collection   Unique   Sparse   Selectivity   Fields        Ranges
  9   hash      aa   false    false        50.00 %   [ `value` ]   (a.`value` == "Matt123")
  8   primary   tt       true     false       100.00 %   [ `_key` ]    (a.`from`.`_key` == t.`_key`)

并带有SORT的样子：

Execution plan:
 Id   NodeType                   Est.   Comment
  1   SingletonNode                 1   * ROOT
  2   EnumerateCollectionNode   85706     - FOR t IN tt   /* full collection scan */
  6   CalculationNode           85706       - LET #4 = t.`identifier`.`value`   /* attribute expression */   /* collections used: t : tt */
 10   IndexNode                 85706       - FOR a IN aa   /* hash index scan */
 11   CalculationNode           85706         - LET #2 = (a.`value` == "Matt123")   /* simple expression */   /* collections used: a : aa */
  5   FilterNode                85706         - FILTER #2
  7   SortNode                  85706         - SORT #4 ASC
  8   LimitNode                    20         - LIMIT 0, 20
  9   ReturnNode                   20         - RETURN t

Indexes used:
 By   Type   Collection   Unique   Sparse   Selectivity   Fields            Ranges
 10   hash   aa   false    false        50.00 %   [ `from._key` ]   (a.`from`.`_key` == t.`_key`)

有人可以帮忙吗？

Answer 1

在您的情况下，尚不清楚两个集合中实际上存在哪些索引。提到了一个索引，但是要运行得好，两个索引会更好。这是我使用的设置：

db.tt.ensureIndex({ type: "skiplist", fields: ["identifier.value"] });
db.aa.ensureIndex({ type: "skiplist", fields: ["value"] });

通过此设置和一些示例数据，我使用ArangoDB 3.3.12获得的执行计划是：

查询字符串： FOR t IN tt FOR a IN aa过滤器a.from._key == t._key AND a.value == @v LIMIT 20返回t

Execution plan:
 Id   NodeType         Est.   Comment
  1   SingletonNode       1   * ROOT
  9   IndexNode       25000     - FOR a IN aa   /* skiplist index scan */
  8   IndexNode       25000       - FOR t IN tt   /* primary index scan */
  6   LimitNode          20         - LIMIT 0, 20
  7   ReturnNode         20         - RETURN t

Indexes used:
 By   Type       Collection   Unique   Sparse   Selectivity   Fields        Ranges
  9   skiplist   aa           false    false            n/a   [ `value` ]   (a.`value` == 123)
  8   primary    tt           true     false       100.00 %   [ `_key` ]    (a.`from`.`_key` == t.`_key`)

这似乎是一个不错的执行计划。您可以检查这些索引是否对您有帮助？

（注意：下一次，请发布您创建的所有索引以及完整的执行计划，而不仅仅是片段，这样您就可以获得更精确的帮助）

跳过列表排序缓慢？

1 个答案: