如何估算ArangoDB count函数的执行时间

我正在考虑将ArangoDB用于我的一个新项目，但我一直无法找到关于其可扩展性的很多信息

具体来说，我想了解一些有关计数函数的信息。是否有可靠的方法（可能是公式）来估计计算集合中与简单布尔值匹配的文档数所需的时间

---

集合中的所有文档将具有相同的字段，但值不同。我如何确定数亿份文档需要多长时间？

只需创建一个集合

用户

并根据需要插入任意数量的随机文档

FOR i IN 1..1100000
INSERT { 
  name: CONCAT("test", i), 
  year: 1970 + FLOOR(RAND() * 55),
  gender: i % 2 == 0 ? 'male' : 'female'  
} IN users

然后进行计数：

FOR user IN users
  FILTER user.gender == 'male'
  COLLECT WITH COUNT INTO number
RETURN { 
  number: number 
}

如果在生产中使用此查询，请确保也添加索引。在我的机器上，它将执行时间缩短了100倍以上（0.043秒/1.1mio文档）

请使用EXPLAIN检查您的查询，以进一步估计执行的“成本”

Query string:
 FOR user IN users
   FILTER user.gender == 'male'
   COLLECT WITH COUNT INTO number
   RETURN { 
     number: number 
   }

Execution plan:
 Id   NodeType            Est.   Comment
  1   SingletonNode          1   * ROOT
  8   IndexRangeNode    550001     - FOR user IN users   /* hash index scan */
  5   AggregateNode          1       - COLLECT  WITH COUNT INTO number   /* sorted*/
  6   CalculationNode        1       - LET #4 = { "number" : number }   /* simple expression */
  7   ReturnNode             1       - RETURN #4

Indexes used:
 Id   Type   Collection   Unique   Sparse   Selectivity Est.   Fields     Ranges
  8   hash   users        false    false              0.00 %   `gender`   [ `gender` == "male" ]

Optimization rules applied:
 Id   RuleName
  1   use-index-range
  2   remove-filter-covered-by-index

---

只需创建一个集合

users

，并根据需要插入任意数量的随机文档

FOR i IN 1..1100000
INSERT { 
  name: CONCAT("test", i), 
  year: 1970 + FLOOR(RAND() * 55),
  gender: i % 2 == 0 ? 'male' : 'female'  
} IN users

然后进行计数：

FOR user IN users
  FILTER user.gender == 'male'
  COLLECT WITH COUNT INTO number
RETURN { 
  number: number 
}

如果在生产中使用此查询，请确保也添加索引。在我的机器上，它将执行时间缩短了100倍以上（0.043秒/1.1mio文档）

请使用EXPLAIN检查您的查询，以进一步估计执行的“成本”

Query string:
 FOR user IN users
   FILTER user.gender == 'male'
   COLLECT WITH COUNT INTO number
   RETURN { 
     number: number 
   }

Execution plan:
 Id   NodeType            Est.   Comment
  1   SingletonNode          1   * ROOT
  8   IndexRangeNode    550001     - FOR user IN users   /* hash index scan */
  5   AggregateNode          1       - COLLECT  WITH COUNT INTO number   /* sorted*/
  6   CalculationNode        1       - LET #4 = { "number" : number }   /* simple expression */
  7   ReturnNode             1       - RETURN #4

Indexes used:
 Id   Type   Collection   Unique   Sparse   Selectivity Est.   Fields     Ranges
  8   hash   users        false    false              0.00 %   `gender`   [ `gender` == "male" ]

Optimization rules applied:
 Id   RuleName
  1   use-index-range
  2   remove-filter-covered-by-index

---

只需创建一个集合

users

，并根据需要插入任意数量的随机文档

FOR i IN 1..1100000
INSERT { 
  name: CONCAT("test", i), 
  year: 1970 + FLOOR(RAND() * 55),
  gender: i % 2 == 0 ? 'male' : 'female'  
} IN users

然后进行计数：

FOR user IN users
  FILTER user.gender == 'male'
  COLLECT WITH COUNT INTO number
RETURN { 
  number: number 
}

如果在生产中使用此查询，请确保也添加索引。在我的机器上，它将执行时间缩短了100倍以上（0.043秒/1.1mio文档）

请使用EXPLAIN检查您的查询，以进一步估计执行的“成本”

Query string:
 FOR user IN users
   FILTER user.gender == 'male'
   COLLECT WITH COUNT INTO number
   RETURN { 
     number: number 
   }

Execution plan:
 Id   NodeType            Est.   Comment
  1   SingletonNode          1   * ROOT
  8   IndexRangeNode    550001     - FOR user IN users   /* hash index scan */
  5   AggregateNode          1       - COLLECT  WITH COUNT INTO number   /* sorted*/
  6   CalculationNode        1       - LET #4 = { "number" : number }   /* simple expression */
  7   ReturnNode             1       - RETURN #4

Indexes used:
 Id   Type   Collection   Unique   Sparse   Selectivity Est.   Fields     Ranges
  8   hash   users        false    false              0.00 %   `gender`   [ `gender` == "male" ]

Optimization rules applied:
 Id   RuleName
  1   use-index-range
  2   remove-filter-covered-by-index

---

只需创建一个集合

users

，并根据需要插入任意数量的随机文档

FOR i IN 1..1100000
INSERT { 
  name: CONCAT("test", i), 
  year: 1970 + FLOOR(RAND() * 55),
  gender: i % 2 == 0 ? 'male' : 'female'  
} IN users

然后进行计数：

FOR user IN users
  FILTER user.gender == 'male'
  COLLECT WITH COUNT INTO number
RETURN { 
  number: number 
}

如果在生产中使用此查询，请确保也添加索引。在我的机器上，它将执行时间缩短了100倍以上（0.043秒/1.1mio文档）

请使用EXPLAIN检查您的查询，以进一步估计执行的“成本”

Query string:
 FOR user IN users
   FILTER user.gender == 'male'
   COLLECT WITH COUNT INTO number
   RETURN { 
     number: number 
   }

Execution plan:
 Id   NodeType            Est.   Comment
  1   SingletonNode          1   * ROOT
  8   IndexRangeNode    550001     - FOR user IN users   /* hash index scan */
  5   AggregateNode          1       - COLLECT  WITH COUNT INTO number   /* sorted*/
  6   CalculationNode        1       - LET #4 = { "number" : number }   /* simple expression */
  7   ReturnNode             1       - RETURN #4

Indexes used:
 Id   Type   Collection   Unique   Sparse   Selectivity Est.   Fields     Ranges
  8   hash   users        false    false              0.00 %   `gender`   [ `gender` == "male" ]

Optimization rules applied:
 Id   RuleName
  1   use-index-range
  2   remove-filter-covered-by-index

---

做吧，数一数……做吧，数一数……做吧，数一数……做吧，数一数。。。