ArangoDB 查询语言 （AQL） 可用于检索和修改存储在 ArangoDB 中的数据。

执行查询时的常规工作流如下：

• 客户端应用程序将 AQL 查询发送到 ArangoDB 服务器。查询文本包含 ArangoDB 编译结果集所需的一切
• ArangoDB将解析查询，执行它并编译结果。如果查询无效或无法执行，服务器将返回客户端可以处理和响应的错误。如果查询可以成功执行，服务器会将查询结果（如果有）返回给客户端

AQL 主要是一种声明性语言，这意味着查询表示应该实现什么结果，而不是应该如何实现。AQL旨在使人类可读，因此使用英语中的关键字。AQL 的另一个设计目标是客户端独立性，这意味着无论客户端使用哪种编程语言，所有客户端的语言和语法都是相同的。AQL 的进一步设计目标是支持复杂的查询模式和 ArangoDB 提供的不同数据模型。

就其目的而言，AQL 类似于结构化查询语言 （SQL）。AQL 支持读取和修改集合数据，但不支持数据定义操作，例如创建和删除数据库、集合和索引。它是一种纯数据操作语言 （DML），而不是数据定义语言 （DDL） 或数据控制语言 （DCL）。

AQL 查询的语法与 SQL 不同，即使某些关键字重叠也是如此。尽管如此，对于任何具有SQL背景的人来说，AQL都应该很容易理解。

本文章基于arangodb官方文档 3.10翻译引用而来

一 AQL 教程

这是对ArangoDB查询语言AQL的介绍，AQL是围绕小说和奇幻电视剧《权力的游戏》（截至第1季）中的一个小角色数据集构建的。它包括两种语言的性格特征，一些家庭关系，最后但并非最不重要的是一小部分拍摄地点，这使得数据组合变得有趣。

在开始之前，无需导入数据。它是本教程中 AQL 查询的一部分提供的。您可以使用其Web 界面与 ArangoDB 交互，以管理集合和执行查询。

1.1 数据

1.1.1 人物

该数据集包含 43 个字符，包括姓名、姓氏、年龄、存活状态和特征参考。 姓氏和年龄属性并不总是存在。 列特征（已解析）不是本教程中使用的实际数据的一部分，但为了您的方便而包含在内。

1.1.2 特征

有18个独特的特征。每个特征都有一个随机字母作为文档键。特征标签有英语和德语版本。

1.1.3 地点

这个由8个拍摄地点组成的小型集合具有两个属性，一个名称和一个坐标。坐标建模为数字数组，每个数组由纬度和经度值组成。

1.2 基本CURD

1.2.1 创建文档

在我们可以使用 AQL 插入文档之前，我们需要一个地方来放置它们—一个集合。 可以通过 Web 界面、arangosh 或驱动程序管理集合，但是使用 AQL 无法做到这一点。

单击 Web 界面中的 COLLECTIONS，然后单击 Add Collection 并键入 Characters 作为名称。 用保存确认。 新集合应出现在列表中。

接下来，单击查询。 要使用 AQL 创建第一个用于收集的文档，请使用以下 AQL 查询，您可以将其粘贴到查询文本框中并通过单击执行来运行：

1
2
3
4
5
6
7

INSERT {
    "name": "Ned",
    "surname": "Stark",
    "alive": true,
    "age": 41,
    "traits": ["A","H","C","N","P"]
} INTO Characters

语法形式如下:

1

INSERT document INTO collectionName

文档是一个对象，就像您可能从 JavaScript 或 JSON 中知道的那样，它由属性键和值对组成。 属性键周围的引号在 AQL 中是可选的。 键总是字符序列（字符串），而属性值可以有不同的类型：

• null
• boolean (true, false)
• number (integer and floating point)
• string
• array
• object

我们插入的字符文档的名字和姓氏都是字符串值。 活动状态使用布尔值。 年龄是一个数值。 特征是一个字符串数组。 整个文档是一个对象。

让我们在单个查询中添加一堆其他字符：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

LET data = [
    { "name": "Robert", "surname": "Baratheon", "alive": false, "traits": ["A","H","C"] },
    { "name": "Jaime", "surname": "Lannister", "alive": true, "age": 36, "traits": ["A","F","B"] },
    { "name": "Catelyn", "surname": "Stark", "alive": false, "age": 40, "traits": ["D","H","C"] },
    { "name": "Cersei", "surname": "Lannister", "alive": true, "age": 36, "traits": ["H","E","F"] },
    { "name": "Daenerys", "surname": "Targaryen", "alive": true, "age": 16, "traits": ["D","H","C"] },
    { "name": "Jorah", "surname": "Mormont", "alive": false, "traits": ["A","B","C","F"] },
    { "name": "Petyr", "surname": "Baelish", "alive": false, "traits": ["E","G","F"] },
    { "name": "Viserys", "surname": "Targaryen", "alive": false, "traits": ["O","L","N"] },
    { "name": "Jon", "surname": "Snow", "alive": true, "age": 16, "traits": ["A","B","C","F"] },
    { "name": "Sansa", "surname": "Stark", "alive": true, "age": 13, "traits": ["D","I","J"] },
    { "name": "Arya", "surname": "Stark", "alive": true, "age": 11, "traits": ["C","K","L"] },
    { "name": "Robb", "surname": "Stark", "alive": false, "traits": ["A","B","C","K"] },
    { "name": "Theon", "surname": "Greyjoy", "alive": true, "age": 16, "traits": ["E","R","K"] },
    { "name": "Bran", "surname": "Stark", "alive": true, "age": 10, "traits": ["L","J"] },
    { "name": "Joffrey", "surname": "Baratheon", "alive": false, "age": 19, "traits": ["I","L","O"] },
    { "name": "Sandor", "surname": "Clegane", "alive": true, "traits": ["A","P","K","F"] },
    { "name": "Tyrion", "surname": "Lannister", "alive": true, "age": 32, "traits": ["F","K","M","N"] },
    { "name": "Khal", "surname": "Drogo", "alive": false, "traits": ["A","C","O","P"] },
    { "name": "Tywin", "surname": "Lannister", "alive": false, "traits": ["O","M","H","F"] },
    { "name": "Davos", "surname": "Seaworth", "alive": true, "age": 49, "traits": ["C","K","P","F"] },
    { "name": "Samwell", "surname": "Tarly", "alive": true, "age": 17, "traits": ["C","L","I"] },
    { "name": "Stannis", "surname": "Baratheon", "alive": false, "traits": ["H","O","P","M"] },
    { "name": "Melisandre", "alive": true, "traits": ["G","E","H"] },
    { "name": "Margaery", "surname": "Tyrell", "alive": false, "traits": ["M","D","B"] },
    { "name": "Jeor", "surname": "Mormont", "alive": false, "traits": ["C","H","M","P"] },
    { "name": "Bronn", "alive": true, "traits": ["K","E","C"] },
    { "name": "Varys", "alive": true, "traits": ["M","F","N","E"] },
    { "name": "Shae", "alive": false, "traits": ["M","D","G"] },
    { "name": "Talisa", "surname": "Maegyr", "alive": false, "traits": ["D","C","B"] },
    { "name": "Gendry", "alive": false, "traits": ["K","C","A"] },
    { "name": "Ygritte", "alive": false, "traits": ["A","P","K"] },
    { "name": "Tormund", "surname": "Giantsbane", "alive": true, "traits": ["C","P","A","I"] },
    { "name": "Gilly", "alive": true, "traits": ["L","J"] },
    { "name": "Brienne", "surname": "Tarth", "alive": true, "age": 32, "traits": ["P","C","A","K"] },
    { "name": "Ramsay", "surname": "Bolton", "alive": true, "traits": ["E","O","G","A"] },
    { "name": "Ellaria", "surname": "Sand", "alive": true, "traits": ["P","O","A","E"] },
    { "name": "Daario", "surname": "Naharis", "alive": true, "traits": ["K","P","A"] },
    { "name": "Missandei", "alive": true, "traits": ["D","L","C","M"] },
    { "name": "Tommen", "surname": "Baratheon", "alive": true, "traits": ["I","L","B"] },
    { "name": "Jaqen", "surname": "H'ghar", "alive": true, "traits": ["H","F","K"] },
    { "name": "Roose", "surname": "Bolton", "alive": true, "traits": ["H","E","F","A"] },
    { "name": "The High Sparrow", "alive": true, "traits": ["H","M","F","O"] }
]

FOR d IN data
    INSERT d INTO Characters

LET 关键字定义了一个带有名称数据的变量和一个对象数组作为值，所以LET variableName = valueExpression并且表达式是一个文字数组定义，如 [ {…}, {…}, … ]。

FOR variableName IN表达式用于迭代数据数组的每个元素。 在每个循环中，一个元素被分配给变量 d。 然后在 INSERT 语句中使用此变量而不是文字对象定义。 它的作用基本上是：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

INSERT {
    "name": "Robert",
    "surname": "Baratheon",
    "alive": false,
    "traits": ["A","H","C"]
} INTO Characters

INSERT {
    "name": "Jaime",
    "surname": "Lannister",
    "alive": true,
    "age": 36,
    "traits": ["A","F","B"]
} INTO Characters

...

AQL 不允许在单个查询中针对同一集合的多个 INSERT 操作。 然而，它被允许作为 FOR 循环的主体，插入多个文档，就像我们在上面的查询中所做的那样。

1.2.2 查询文档

现在 Characters 集合中有几个文档。 我们可以再次使用 FOR 循环检索它们。 然而，这一次，我们使用它来遍历集合中的所有文档而不是数组：

1
2

FOR c IN Characters
    RETURN c

循环的语法是 FOR variableName IN collectionName。 对于集合中的每个文档，c 被分配一个文档，然后根据循环体返回该文档。 查询返回我们之前存储的所有字符。

其中应该是Ned Stark，类似这个例子：

1
2
3
4
5
6
7
8
9
10

{
   "_key": "2861650",
   "_id": "Characters/2861650",
   "_rev": "_V1bzsXa---",
   "name": "Ned",
   "surname": "Stark",
   "alive": true,
   "age": 41,
   "traits": ["A","H","C","N","P"]
 },

该文档具有我们存储的四个属性，以及数据库系统添加的三个属性。 每个文档都需要一个唯一的_key，用于在集合中标识它。_id 是一个计算属性，是集合名称、正斜杠 / 和文档键的串联。 它唯一标识数据库中的文档。_rev是系统管理的修订 ID。

文档密钥可以由用户在创建文档时提供，或者自动分配唯一值。 以后无法更改。 以下划线 _ 开头的所有三个系统属性都是只读的。

在 AQL 函数 DOCUMENT() 的帮助下，我们可以使用文档键或文档 ID 来检索特定文档

语法形式如下:

1
2
3

RETURN DOCUMENT("Characters", "2861650")
// --- or ---
RETURN DOCUMENT("Characters/2861650")

1
2
3
4
5
6
7
8
9
10
11
12

[
  {
    "_key": "2861650",
    "_id": "Characters/2861650",
    "_rev": "_V1bzsXa---",
    "name": "Ned",
    "surname": "Stark",
    "alive": true,
    "age": 41,
    "traits": ["A","H","C","N","P"]
  }
]

文档密钥对您来说会有所不同。 相应地更改查询。 此处，“2861650”是 Ned Stark 文档的密钥，“2861653”是 Catelyn Stark 的密钥。

DOCUMENT() 函数还允许一次获取多个文档：

1
2
3

RETURN DOCUMENT("Characters", ["2861650", "2861653"])
// --- or ---
RETURN DOCUMENT(["Characters/2861650", "Characters/2861653"])

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

[
  [
    {
      "_key": "2861650",
      "_id": "Characters/2861650",
      "_rev": "_V1bzsXa---",
      "name": "Ned",
      "surname": "Stark",
      "alive": true,
      "age": 41,
      "traits": ["A","H","C","N","P"]
    },
    {
      "_key": "2861653",
      "_id": "Characters/2861653",
      "_rev": "_V1bzsXa--B",
      "name": "Catelyn",
      "surname": "Stark",
      "alive": false,
      "age": 40,
      "traits": ["D","H","C"]
    }
  ]
]

有关更多详细信息，请参阅 DOCUMENT() 函数文档。

1.2.3 更新文档

根据我们的 Ned Stark 文件，他还活着。 当我们知道他死了，我们需要改变alive 属性。 让我们修改现有文件：

1

UPDATE "2861650" WITH { alive: false } IN Characters

语法形式如下:

1

UPDATE documentKey WITH object IN collectionName

它使用列出的属性更新指定的文档（如果它们不存在，则添加它们），但保持其余部分不变。 要替换整个文档内容，您可以使用 REPLACE 而不是 UPDATE：

1
2
3
4
5
6
7

REPLACE "2861650" WITH {
    name: "Ned",
    surname: "Stark",
    alive: false,
    age: 41,
    traits: ["A","H","C","N","P"]
} IN Characters

这也适用于循环，为所有文档添加一个新属性，例如：

1
2

FOR c IN Characters
    UPDATE c WITH { season: 1 } IN Characters

使用变量而不是文字文档键来更新每个文档。 该查询将属性季节添加到文档的顶级。 您可以通过重新运行返回集合中所有文档的查询来检查结果：

1
2

FOR c IN Characters
    RETURN c

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

[
  [
    {
      "_key": "2861650",
      "_id": "Characters/2861650",
      "_rev": "_V1bzsXa---",
      "name": "Ned",
      "surname": "Stark",
      "alive": false,
      "age": 41,
      "traits": ["A","H","C","N","P"],
      "season": 1
    },
    {
      "_key": "2861653",
      "_id": "Characters/2861653",
      "_rev": "_V1bzsXa--B",
      "name": "Catelyn",
      "surname": "Stark",
      "alive": false,
      "age": 40,
      "traits": ["D","H","C"],
      "season": 1
    },
    {
        ...
    }
  ]
]

1.2.4 删除文档

要从集合中完全删除文档，有 REMOVE 操作。 它的工作原理类似于其他修改操作，但没有 WITH 子句：

1

REMOVE "2861650" IN Characters

它也可以用在循环体中以有效地截断集合：

1
2

FOR c IN Characters
    REMOVE c IN Characters

在继续下一章之前，对所有字符文档重新运行顶部的插入查询，以便再次使用数据。

1.2 匹配文档

到目前为止，我们要么查找单个文档，要么返回整个字符集合。 对于查找，我们使用了 DOCUMENT() 函数，这意味着我们只能通过键或 ID 查找文档。

为了找到满足某些比键相等更复杂的标准的文档，AQL 中有 FILTER 操作，它使我们能够为文档制定任意条件来匹配。

1.2.1 Equality condition

1
2
3

FOR c IN Characters
    FILTER c.name == "Ned"
    RETURN c

过滤条件读作：“字符文档的属性名称必须等于字符串 Ned”。 如果条件适用，则返回字符文档。 这同样适用于任何属性：

1
2
3

FOR c IN Characters
    FILTER c.surname == "Stark"
    RETURN c

1.2.2 Range conditions

严格相等是我们可以陈述的一种可能条件。 但是，我们可以制定许多其他条件。 例如，我们可以要求所有成人角色：

1
2
3

FOR c IN Characters
    FILTER c.age >= 13
    RETURN c.name

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[
  "Joffrey",
  "Tyrion",
  "Samwell",
  "Ned",
  "Catelyn",
  "Cersei",
  "Jon",
  "Sansa",
  "Brienne",
  "Theon",
  "Davos",
  "Jaime",
  "Daenerys"
]

运算符>=代表大于或等于，因此返回 13 岁或以上的每个字符（在示例中仅返回他们的名字）。 我们可以通过将运算符更改为小于并使用对象语法定义要返回的属性子集来返回所有小于 13 的字符的名称和年龄：

1
2
3

FOR c IN Characters
    FILTER c.age < 13
    RETURN { name: c.name, age: c.age }

1
2
3
4
5
6

[
  { "name": "Tommen", "age": null },
  { "name": "Arya", "age": 11 },
  { "name": "Roose", "age": null },
  ...
]

您可能会注意到它返回 30 个字符的名称和年龄，大多数年龄为空。 这样做的原因是，如果查询请求属性，则 null 是回退值，但文档中不存在此类属性，并且将 null 与较低的数字进行比较（请参阅类型和值顺序）。 因此，它意外地满足了年龄标准 c.age < 13 (null < 13)。

1.2.3 Multiple conditions

为了不让没有年龄属性的文档通过过滤器，我们可以添加第二个条件：

1
2
3
4

FOR c IN Characters
    FILTER c.age < 13
    FILTER c.age != null
    RETURN { name: c.name, age: c.age }

1
2
3
4

[
  { "name": "Arya", "age": 11 },
  { "name": "Bran", "age": 10 }
]

这同样可以用布尔 AND 运算符编写为：

1
2
3

FOR c IN Characters
    FILTER c.age < 13 AND c.age != null
    RETURN { name: c.name, age: c.age }

第二个条件也可以是 c.age > null。

1.2.4 Alternative conditions

如果您希望文档满足一个或另一个条件，也可能满足不同的属性，请使用 OR：

1
2
3

FOR c IN Characters
    FILTER c.name == "Jon" OR c.name == "Joffrey"
    RETURN { name: c.name, surname: c.surname }

1
2
3
4

[
  { "name": "Joffrey", "surname": "Baratheon" },
  { "name": "Jon", "surname": "Snow" }
]

查看有关过滤器操作的更多详细信息。

1.3 排序和限制

1.3.1 限制结果计数

可能并不总是需要返回所有文档，FOR 循环通常会返回这些文档。 在这些情况下，我们可以使用 LIMIT() 操作限制文档数量：

1
2
3

FOR c IN Characters
    LIMIT 5
    RETURN c.name

1
2
3
4
5
6
7

[
  "Joffrey",
  "Tommen",
  "Tyrion",
  "Roose",
  "Tywin"
]

LIMIT 后跟一个表示最大文档数的数字。 然而，还有第二种语法，它允许您跳过一定数量的记录并返回接下来的 n 个文档：

1
2
3

FOR c IN Characters
    LIMIT 2, 5
    RETURN c.name

1
2
3
4
5
6
7

[
  "Tyrion",
  "Roose",
  "Tywin",
  "Samwell",
  "Melisandre"
]

看看第二个查询如何跳过前两个名字并返回接下来的五个（两个结果都包含 Tyrion、Roose 和 Tywin）。

1.3.2 按照名字排序

直到这里显示的查询返回匹配记录的顺序基本上是随机的。 要以定义的顺序返回它们，我们可以添加 SORT() 操作。 如果与 LIMIT() 结合使用，它会对结果产生很大影响，因为如果您先排序，结果将变得可预测。

1
2
3
4

FOR c IN Characters
    SORT c.name
    LIMIT 10
    RETURN c.name

1
2
3
4
5
6
7
8
9
10
11
12

[
  "Arya",
  "Bran",
  "Brienne",
  "Bronn",
  "Catelyn",
  "Cersei",
  "Daario",
  "Daenerys",
  "Davos",
  "Ellaria"
]

看看它如何按名称排序，然后返回按字母顺序排列的前十个名称。 我们可以像降序一样使用 DESC 反转排序顺序：

1
2
3
4

FOR c IN Characters
    SORT c.name DESC
    LIMIT 10
    RETURN c.name

1
2
3
4
5
6
7
8
9
10
11
12

[
  "Ygritte",
  "Viserys",
  "Varys",
  "Tywin",
  "Tyrion",
  "Tormund",
  "Tommen",
  "Theon",
  "The High Sparrow",
  "Talisa"
]

第一种排序是升序，这是默认顺序。 因为它是默认的，所以不需要明确要求 ASC 顺序。

1.3.3 按多个属性排序

假设我们要按姓氏排序。 许多角色都有一个姓氏。 同姓字符之间的结果顺序未定义。 我们可以先按姓氏排序，再按名字排序：

1
2
3
4
5
6
7
8

FOR c IN Characters
    FILTER c.surname
    SORT c.surname, c.name
    LIMIT 10
    RETURN {
        surname: c.surname,
        name: c.name
    }

1
2
3
4
5
6
7
8
9
10
11
12

[
    { "surname": "Baelish", "name": "Petyr" },
    { "surname": "Baratheon", "name": "Joffrey" },
    { "surname": "Baratheon", "name": "Robert" },
    { "surname": "Baratheon", "name": "Stannis" },
    { "surname": "Baratheon", "name": "Tommen" },
    { "surname": "Bolton", "name": "Ramsay" },
    { "surname": "Bolton", "name": "Roose" },
    { "surname": "Clegane", "name": "Sandor" },
    { "surname": "Drogo", "name": "Khal" },
    { "surname": "Giantsbane", "name": "Tormund" }
]

总体而言，文档按姓氏排序。 如果两个字符的姓氏相同，则比较姓名值并对结果进行排序。

请注意，在排序之前应用过滤器，只让文档通过，实际上具有姓氏值（许多没有它并且会导致结果中的空值）。

1.3.4 按照年纪排序

顺序也可以由数值确定，例如年龄：

1
2
3
4
5
6
7
8

FOR c IN Characters
    FILTER c.age
    SORT c.age
    LIMIT 10
    RETURN {
        name: c.name,
        age: c.age
    }

1
2
3
4
5
6
7
8
9
10
11
12

[
    { "name": "Bran", "age": 10 },
    { "name": "Arya", "age": 11 },
    { "name": "Sansa", "age": 13 },
    { "name": "Jon", "age": 16 },
    { "name": "Theon", "age": 16 },
    { "name": "Daenerys", "age": 16 },
    { "name": "Samwell", "age": 17 },
    { "name": "Joffrey", "age": 19 },
    { "name": "Tyrion", "age": 32 },
    { "name": "Brienne", "age": 32 }
]

应用过滤器来避免没有年龄属性的文档。 其余文档按年龄升序排列，返回最年轻的十个字符的姓名和年龄。

有关更多详细信息，请参阅 SORT 操作和 LIMIT 操作文档。

1.3 Joining together

1.3.1 关联其他文档

我们导入的字符数据，每个字符都有一个属性traits，是一个字符串数组。 但是它不直接存储字符特征：

1
2
3
4
5
6
7

{
    "name": "Ned",
    "surname": "Stark",
    "alive": false,
    "age": 41,
    "traits": ["A","H","C","N","P"]
}

它更像是一个没有明显含义的字母列表。 这里的想法是traits 应该存储另一个集合的文档键，我们可以使用它来将字母解析为诸如“strong”之类的标签。 为实际特征使用另一个集合的好处是，我们可以稍后轻松查询所有现有特征，并以多种语言存储标签，例如在一个中心位置。 如果我们直接嵌入特征

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

{
    "name": "Ned",
    "surname": "Stark",
    "alive": false,
    "age": 41,
    "traits": [
        {
            "de": "stark",
            "en": "strong"
        },
        {
            "de": "einflussreich",
            "en": "powerful"
        },
        {
            "de": "loyal",
            "en": "loyal"
        },
        {
            "de": "rational",
            "en": "rational"
        },
        {
            "de": "mutig",
            "en": "brave"
        }
    ]
}

保持特征变得非常困难。 如果您要重命名或翻译其中之一，则需要找到所有其他具有相同特征的字符文档并在那里执行更改。 如果我们只引用另一个集合中的特征，就像更新单个文档一样简单

1.3.2 导入特征

您可以在下方找到特征数据。 按照创建文档中显示的模式导入它：

• 创建文档集合 Traits
• 将数据分配给 AQL 中的变量，LET data = [ … ]
• 使用 FOR 循环遍历数据的每个数组元素
• INSERT 元素 INTO Traits

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

[
    { "_key": "A", "en": "strong", "de": "stark" },
    { "_key": "B", "en": "polite", "de": "freundlich" },
    { "_key": "C", "en": "loyal", "de": "loyal" },
    { "_key": "D", "en": "beautiful", "de": "schön" },
    { "_key": "E", "en": "sneaky", "de": "hinterlistig" },
    { "_key": "F", "en": "experienced", "de": "erfahren" },
    { "_key": "G", "en": "corrupt", "de": "korrupt" },
    { "_key": "H", "en": "powerful", "de": "einflussreich" },
    { "_key": "I", "en": "naive", "de": "naiv" },
    { "_key": "J", "en": "unmarried", "de": "unverheiratet" },
    { "_key": "K", "en": "skillful", "de": "geschickt" },
    { "_key": "L", "en": "young", "de": "jung" },
    { "_key": "M", "en": "smart", "de": "klug" },
    { "_key": "N", "en": "rational", "de": "rational" },
    { "_key": "O", "en": "ruthless", "de": "skrupellos" },
    { "_key": "P", "en": "brave", "de": "mutig" },
    { "_key": "Q", "en": "mighty", "de": "mächtig" },
    { "_key": "R", "en": "weak", "de": "schwach" }
]

完整的语句如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

LET data =[
    { "_key": "A", "en": "strong", "de": "stark" },
    { "_key": "B", "en": "polite", "de": "freundlich" },
    { "_key": "C", "en": "loyal", "de": "loyal" },
    { "_key": "D", "en": "beautiful", "de": "schön" },
    { "_key": "E", "en": "sneaky", "de": "hinterlistig" },
    { "_key": "F", "en": "experienced", "de": "erfahren" },
    { "_key": "G", "en": "corrupt", "de": "korrupt" },
    { "_key": "H", "en": "powerful", "de": "einflussreich" },
    { "_key": "I", "en": "naive", "de": "naiv" },
    { "_key": "J", "en": "unmarried", "de": "unverheiratet" },
    { "_key": "K", "en": "skillful", "de": "geschickt" },
    { "_key": "L", "en": "young", "de": "jung" },
    { "_key": "M", "en": "smart", "de": "klug" },
    { "_key": "N", "en": "rational", "de": "rational" },
    { "_key": "O", "en": "ruthless", "de": "skrupellos" },
    { "_key": "P", "en": "brave", "de": "mutig" },
    { "_key": "Q", "en": "mighty", "de": "mächtig" },
    { "_key": "R", "en": "weak", "de": "schwach" }
]

for d in data
 INSERT d INTO Traits

1.3.3 解决特征

让我们从简单的开始，只返回每个字符的 traits 属性：

1
2

FOR c IN Characters
    RETURN c.traits

1
2
3
4
5

[
    { "traits": ["A","H","C","N","P"] },
    { "traits": ["D","H","C"] },
    ...
]

另请参阅有关属性访问的对象/文档基础知识。

我们可以将 traits 数组与 DOCUMENT() 函数一起使用，以将元素用作文档键并在 Traits 集合中查找它们：

1
2

FOR c IN Characters
    RETURN DOCUMENT("Traits", c.traits)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63

[
  [
    {
      "_key": "A",
      "_id": "Traits/A",
      "_rev": "_V5oRUS2---",
      "en": "strong",
      "de": "stark"
    },
    {
      "_key": "H",
      "_id": "Traits/H",
      "_rev": "_V5oRUS6--E",
      "en": "powerful",
      "de": "einflussreich"
    },
    {
      "_key": "C",
      "_id": "Traits/C",
      "_rev": "_V5oRUS6--_",
      "en": "loyal",
      "de": "loyal"
    },
    {
      "_key": "N",
      "_id": "Traits/N",
      "_rev": "_V5oRUT---D",
      "en": "rational",
      "de": "rational"
    },
    {
      "_key": "P",
      "_id": "Traits/P",
      "_rev": "_V5oRUTC---",
      "en": "brave",
      "de": "mutig"
    }
  ],
  [
    {
      "_key": "D",
      "_id": "Traits/D",
      "_rev": "_V5oRUS6--A",
      "en": "beautiful",
      "de": "schön"
    },
    {
      "_key": "H",
      "_id": "Traits/H",
      "_rev": "_V5oRUS6--E",
      "en": "powerful",
      "de": "einflussreich"
    },
    {
      "_key": "C",
      "_id": "Traits/C",
      "_rev": "_V5oRUS6--_",
      "en": "loyal",
      "de": "loyal"
    }
  ],
  ...
]

DOCUMENT() 函数可用于通过文档标识符查找单个或多个文档。 在我们的示例中，我们将要从中获取文档的集合名称作为第一个参数（“Traits”）传递，并将文档键数组（_key 属性）作为第二个参数传递。 作为回报，我们获得了每个字符的完整特征文档的数组。

这有点太多信息，所以我们只使用数组扩展符号返回英文标签：

1
2

FOR c IN Characters
    RETURN DOCUMENT("Traits", c.traits)[*].en

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

[
  [
    "strong",
    "powerful",
    "loyal",
    "rational",
    "brave"
  ],
  [
    "beautiful",
    "powerful",
    "loyal"
  ],
  ...
]

1.3.3 合并字符和特征

太好了，我们将字母解析为有意义的特征！ 但是我们还需要知道它们属于哪个角色。 因此，我们需要合并字符文档和特征文档中的数据：

1
2

FOR c IN Characters
    RETURN MERGE(c, { traits: DOCUMENT("Traits", c.traits)[*].en } )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

[
  {
    "_id": "Characters/2861650",
    "_key": "2861650",
    "_rev": "_V1bzsXa---",
    "age": 41,
    "alive": false,
    "name": "Ned",
    "surname": "Stark",
    "traits": [
      "strong",
      "powerful",
      "loyal",
      "rational",
      "brave"
    ]
  },
  {
    "_id": "Characters/2861653",
    "_key": "2861653",
    "_rev": "_V1bzsXa--B",
    "age": 40,
    "alive": false,
    "name": "Catelyn",
    "surname": "Stark",
    "traits": [
      "beautiful",
      "powerful",
      "loyal"
    ]
  },
  ...
]

MERGE()函数将对象合并在一起。 因为我们使用了一个对象 { traits: … } ，它与原始字符属性具有相同的属性名称 traits，后者被合并操作覆盖。

1.3.4 加入另一种方式

DOCUMENT()函数利用主要索引快速查找文档。 但是，它仅限于通过标识符查找文档。 对于我们示例中的用例，完成一个简单的连接就足够了。

还有另一种更灵活的连接语法：在多个集合上嵌套 FOR 循环，使用 FILTER 条件来匹配属性。 对于traits 键数组，需要第三个循环来迭代键：

1
2
3
4
5
6
7
8
9

FOR c IN Characters
  RETURN MERGE(c, {
    traits: (
      FOR key IN c.traits
        FOR t IN Traits
          FILTER t._key == key
          RETURN t.en
    )
  })

对于每个字符，它循环遍历其特征属性（例如 [“D”,”H”,”C”]），并且对于该数组中的每个文档引用，循环遍历特征集合。 存在将文档键与键引用匹配的条件。 在这种情况下，内部 FOR 循环和 FILTER 被转换为主索引查找，而不是构建笛卡尔积，仅过滤掉除单个匹配项之外的所有内容：集合中的文档键是唯一的，因此只能有一个匹配项。

返回每个写出的英文特征，然后将所有特征与字符文档合并。 结果与使用 DOCUMENT() 的查询相同。 但是，这种带有嵌套 FOR 循环和 FILTER 的方法不限于主键。 您也可以使用任何其他属性执行此操作。 为了高效查找，请确保为此属性添加哈希索引。 如果其值是唯一的，则还将索引选项设置为唯一。

1.4 图的遍历

诸如父母和孩子之间的关系可以建模为图。 在 ArangoDB 中，可以通过边缘文档链接两个文档（父字符文档和子字符文档）。 边缘文档存储在边缘集合中，并具有两个附加属性：_from和 _to。 他们通过文档 ID (_id) 引用任意两个文档。

1.4.1ChildOf relations

我们的角色在父母和孩子之间有以下关系（名字只是为了更好地概述）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14

Robb -> Ned
  Sansa -> Ned
   Arya -> Ned
   Bran -> Ned
    Jon -> Ned
   Robb -> Catelyn
  Sansa -> Catelyn
   Arya -> Catelyn
   Bran -> Catelyn
  Jaime -> Tywin
 Cersei -> Tywin
 Tyrion -> Tywin
Joffrey -> Jaime
Joffrey -> Cersei

可视化为图表：

1.4.2 创建edges

要创建所需的边缘文档以将这些关系存储在数据库中，我们可以运行一个结合连接和过滤的查询来匹配正确的字符文档，然后使用它们的 _id 属性将边缘插入到边缘集合 ChildOf 中。

首先，创建一个名为 ChildOf 的新集合，并确保将集合类型更改为 Edge。

然后运行以下查询：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

LET data = [
    {
        "parent": { "name": "Ned", "surname": "Stark" },
        "child": { "name": "Robb", "surname": "Stark" }
    }, {
        "parent": { "name": "Ned", "surname": "Stark" },
        "child": { "name": "Sansa", "surname": "Stark" }
    }, {
        "parent": { "name": "Ned", "surname": "Stark" },
        "child": { "name": "Arya", "surname": "Stark" }
    }, {
        "parent": { "name": "Ned", "surname": "Stark" },
        "child": { "name": "Bran", "surname": "Stark" }
    }, {
        "parent": { "name": "Catelyn", "surname": "Stark" },
        "child": { "name": "Robb", "surname": "Stark" }
    }, {
        "parent": { "name": "Catelyn", "surname": "Stark" },
        "child": { "name": "Sansa", "surname": "Stark" }
    }, {
        "parent": { "name": "Catelyn", "surname": "Stark" },
        "child": { "name": "Arya", "surname": "Stark" }
    }, {
        "parent": { "name": "Catelyn", "surname": "Stark" },
        "child": { "name": "Bran", "surname": "Stark" }
    }, {
        "parent": { "name": "Ned", "surname": "Stark" },
        "child": { "name": "Jon", "surname": "Snow" }
    }, {
        "parent": { "name": "Tywin", "surname": "Lannister" },
        "child": { "name": "Jaime", "surname": "Lannister" }
    }, {
        "parent": { "name": "Tywin", "surname": "Lannister" },
        "child": { "name": "Cersei", "surname": "Lannister" }
    }, {
        "parent": { "name": "Tywin", "surname": "Lannister" },
        "child": { "name": "Tyrion", "surname": "Lannister" }
    }, {
        "parent": { "name": "Cersei", "surname": "Lannister" },
        "child": { "name": "Joffrey", "surname": "Baratheon" }
    }, {
        "parent": { "name": "Jaime", "surname": "Lannister" },
        "child": { "name": "Joffrey", "surname": "Baratheon" }
    }
]

FOR rel in data
    LET parentId = FIRST(
        FOR c IN Characters
            FILTER c.name == rel.parent.name
            FILTER c.surname == rel.parent.surname
            LIMIT 1
            RETURN c._id
    )
    LET childId = FIRST(
        FOR c IN Characters
            FILTER c.name == rel.child.name
            FILTER c.surname == rel.child.surname
            LIMIT 1
            RETURN c._id
    )
    FILTER parentId != null AND childId != null
    INSERT { _from: childId, _to: parentId } INTO ChildOf
    RETURN NEW

执行完上述命令后，得到如下所示图形关系结果:

字符文档没有用户定义的键。 如果他们有，它将使我们能够更轻松地创建边缘，例如：

1

INSERT { _from: "Characters/robb", _to: "Characters/ned" } INTO ChildOf

但是，基于字符名称以编程方式创建边是一个很好的练习。查询细分：

• 将具有父属性和子属性的对象数组形式的关系分配给变量data
• 对这个数组中的每个元素，给一个变量rel赋值一个关系，然后执行后面的指令
• 将表达式的结果分配给变量 parentId
  • 取一个子查询结果的第一个元素（子查询用括号括起来，但这里也是函数调用）
    • 对于 Characters 集合中的每个文档，将文档分配给变量 c
    • 应用两个过滤条件：字符文档中的名字必须等于 rel 中的父名，并且姓氏也必须等于关系 data 中给出的姓氏
    • 在第一场匹配后停止以提高效率
    • 返回字符文档的ID（子查询的结果是一个只有一个元素的数组，FIRST()取这个元素赋值给parentId变量）
• 将表达式的结果分配给变量 childId
  • 子查询用于查找子字符文档并返回ID，与父文档ID相同（见上文）
• 如果两个子查询中的一个或两个都无法找到匹配项，则跳过当前关系，因为创建一个边需要两个 ID（这只是预防措施）
• 在 ChildOf 集合中插入一个新的边缘文档，边缘从 childId 到 parentId，没有其他属性
• 返回新的边缘文档（可选）

1.4.3 穿越到父母身边

现在边链接字符文档（顶点），我们有一个图，我们可以查询以找出谁是另一个字符的父母——或者用图的术语来说，我们想从一个顶点开始，沿着边到 AQL 中的其他顶点 图遍历：

1
2

FOR v IN 1..1 OUTBOUND "Characters/2901776" ChildOf
    RETURN v.name

这个 FOR 循环不迭代集合或数组，它遍历图形并迭代它找到的连接顶点，顶点文档分配给一个变量（这里是：v）。 它还可以发出它走过的边缘以及从开始到结束到另外两个变量的完整路径。

在上面的查询中，遍历被限制为最小和最大遍历深度为 1（从起始顶点走多少步），并且只沿着 OUTBOUND 方向的边。 我们的边从孩子指向父母，父母离孩子一步之遥，因此它给了我们开始的孩子的父母。 “Characters/2901776”是起始顶点。 请注意，您的文档 ID 会有所不同，因此请将其调整为您的文档 ID，例如 布兰史塔克文件：

1
2
3

FOR c IN Characters
    FILTER c.name == "Bran"
    RETURN c._id

1

[ "Characters/<YourDocumentkey>" ]

您也可以直接将此查询与遍历结合起来，通过调整过滤条件轻松更改起始顶点：

1
2
3
4

FOR c IN Characters
    FILTER c.name == "Bran"
    FOR v IN 1..1 OUTBOUND c ChildOf
        RETURN v.name

起始顶点之后是 ChildOf，它是我们的边集合。 示例查询仅返回每个父级的名称以保持结果简短：

1
2
3
4

[
  "Ned",
  "Catelyn"
]

Robb、Arya 和 Sansa 作为起点将返回相同的结果。 对于琼恩·雪诺来说，只会是奈德。

1.4.4 穿越到孩子们身边

我们也可以从父节点沿着反向边方向（即INBOUND）走到子节点：

1
2
3
4

FOR c IN Characters
    FILTER c.name == "Ned"
    FOR v IN 1..1 INBOUND c ChildOf
        RETURN v.name

1
2
3
4
5
6
7

[
  "Robb",
  "Sansa",
  "Jon",
  "Arya",
  "Bran"
]

1.4.5 穿越到孙子

对于兰尼斯特家族，我们有着从父母到孙子的关系。 让我们改变遍历深度来返回孙子，这意味着正好走两步：

1
2
3
4

FOR c IN Characters
    FILTER c.name == "Tywin"
    FOR v IN 2..2 INBOUND c ChildOf
        RETURN v.name

1
2
3
4

[
  "Joffrey",
  "Joffrey"
]

乔佛里被返回两次可能有点出乎意料。 但是，如果您查看图形可视化，您可以看到从 Joffrey（右下角）到 Tywin 的多条路径：

1
2

Tywin <- Jaime <- Joffrey
Tywin <- Cersei <- Joffrey

作为快速修复，将查询的最后一行更改为RETURN DISTINCT v.name 以仅返回每个值一次。 但请记住，有遍历选项可以在早期抑制重复顶点。

还可以查看 ArangoDB 图课程，它涵盖了基础知识，但也解释了不同的遍历选项和高级图查询。

1.4.6 可变深度遍历

为了返回 Joffrey 的父母和祖父母，我们可以在 OUTBOUND 方向上走边并调整遍历深度至少走 1 步，最多 2 步：

1
2
3
4

FOR c IN Characters
    FILTER c.name == "Joffrey"
    FOR v IN 1..2 OUTBOUND c ChildOf
        RETURN DISTINCT v.name

1
2
3
4
5

[
  "Cersei",
  "Tywin",
  "Jaime"
]

如果我们有更深的家谱，那么只需要改变深度值来查询曾孙和类似的关系。

1.5 地理空间查询

由纬度和经度值组成的地理空间坐标可以存储为两个单独的属性，也可以存储为具有两个数值的数组形式的单个属性。 ArangoDB 可以索引此类坐标以进行快速地理空间查询。

1.5.1 位置数据

让我们将一些拍摄位置插入到一个新的集合 Locations 中，您需要先创建它，然后在 AQL 查询下运行：

1
2
3
4
5
6
7
8
9
10
11
12
13

LET places = [
    { "name": "Dragonstone", "coordinate": [ 55.167801, -6.815096 ] },
    { "name": "King's Landing", "coordinate": [ 42.639752, 18.110189 ] },
    { "name": "The Red Keep", "coordinate": [ 35.896447, 14.446442 ] },
    { "name": "Yunkai", "coordinate": [ 31.046642, -7.129532 ] },
    { "name": "Astapor", "coordinate": [ 31.50974, -9.774249 ] },
    { "name": "Winterfell", "coordinate": [ 54.368321, -5.581312 ] },
    { "name": "Vaes Dothrak", "coordinate": [ 54.16776, -6.096125 ] },
    { "name": "Beyond the wall", "coordinate": [ 64.265473, -21.094093 ] }
]

FOR place IN places
    INSERT place INTO Locations

地图上的坐标及其标签的可视化：

1.5.2 地理空间索引

要基于坐标查询，需要一个地理索引。 它确定哪些字段包含纬度和经度值。

• 转到收藏
• 单击位置集合
• 切换到顶部的索引选项卡
• 单击右侧带有加号的绿色按钮
• 将类型更改为地理索引
• 在字段字段中输入坐标
• 点击创建确认

1.5.3 查找附近的位置

再次使用 FOR 循环，随后的 SORT 操作基于存储的坐标和查询中给定的坐标之间的 DISTANCE()。 这种模式被查询优化器识别。 如果可用，地理索引将用于加速此类查询。

默认排序方向是升序，因此查询首先找到最接近参考点的坐标（距离最近）。 LIMIT 可用于将结果数量限制为最多 n 个匹配项。

在下面的示例中，限制设置为 3。原点（参考点）是爱尔兰都柏林市中心某处的坐标：

1
2
3
4
5
6
7
8
9
10

FOR loc IN Locations
  LET distance = DISTANCE(loc.coordinate[0], loc.coordinate[1], 53.35, -6.25)
  SORT distance
  LIMIT 3
  RETURN {
    name: loc.name,
    latitude: loc.coordinate[0],
    longitude: loc.coordinate[1],
    distance
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

[
  {
    "name": "Vaes Dothrak",
    "latitude": 54.16776,
    "longitude": -6.096125,
    "distance": 91491.58596795711
  },
  {
    "name": "Winterfell",
    "latitude": 54.368321,
    "longitude": -5.581312,
    "distance": 121425.66829502625
  },
  {
    "name": "Dragonstone",
    "latitude": 55.167801,
    "longitude": -6.815096,
    "distance": 205433.7784182078
  }
]

查询返回位置名称，以及以米为单位的坐标和计算距离。 坐标作为两个单独的属性返回。 如果需要，您可以只返回带有简单 RETURN loc 的文档。 或者使用 RETURN MERGE(loc, { distance }) 返回带有添加的距离属性的整个文档。

1.5.4 查找半径内的位置

LIMIT 可以用检查距离的 FILTER 替换，以查找距参考点给定半径内的位置。 请记住，单位是米。 该示例使用半径为 200,000 米（200 公里）：

1
2
3
4
5
6
7
8
9
10

FOR loc IN Locations
  LET distance = DISTANCE(loc.coordinate[0], loc.coordinate[1], 53.35, -6.25)
  SORT distance
  FILTER distance < 200 * 1000
  RETURN {
    name: loc.name,
    latitude: loc.coordinate[0],
    longitude: loc.coordinate[1],
    distance: ROUND(distance / 1000)
  }

1
2
3
4
5
6
7
8
9
10
11
12
13
14

[
  {
    "name": "Vaes Dothrak",
    "latitude": 54.16776,
    "longitude": -6.096125,
    "distance": 91
  },
  {
    "name": "Winterfell",
    "latitude": 54.368321,
    "longitude": -5.581312,
    "distance": 121
  }
]

距离转换为公里并四舍五入以提高可读性。

二 如何调用 AQL

AQL 查询可以使用：

• 网页界面，
• db 对象（在 arangosh 或 Foxx 服务中）
• 原始 HTTP API。

在后台总是有对服务器 API 的调用，但 Web 界面和 db 对象抽象了低级通信细节，因此更易于使用。

ArangoDB Web 界面具有用于 AQL 查询执行的特定选项卡。

您可以使用 db 对象的 _query 和 _createStatement 方法从 ArangoDB Shell 运行 AQL 查询。 本章还介绍了如何在 arangosh 中使用绑定参数、统计、计数和游标。

如果您使用 Foxx，请参阅如何编写数据库查询以获取包括标记模板字符串在内的示例。

如果您想通过 HTTP REST API 从您的应用程序运行 AQL 查询，请参阅 AQL 查询游标的 HTTP 接口中的完整 API 说明。

具体使用方法参见https://www.arangodb.com/docs/3.10/aql/invocation.html

三 AQL基础

• AQL 语法解释了 AQL 语言的结构。
• 数据类型描述了 AQL 支持的原始和复合数据类型。
• 绑定参数：AQL 支持绑定参数的使用。 这允许将查询文本与查询中使用的文字值分开。
• 类型和值顺序：AQL 使用一组规则（使用值和类型）进行相等检查和比较。
• 从集合访问数据：描述不存在或空属性对选择查询的影响。
• 查询结果：AQL 查询的结果是一个值数组。
• 查询错误：错误可能来自 AQL 解析或执行。
• 限制：AQL 查询的已知限制。

3.1 AQL 语法

3.1.1 查询类型

AQL 查询必须返回结果（通过使用 RETURN 关键字表示）或执行数据修改操作（通过使用关键字 INSERT、UPDATE、REPLACE、REMOVE 或 UPSERT 之一表示）。 如果 AQL 解析器在同一查询中检测到多个数据修改操作，或者无法确定查询是数据检索还是修改操作，则 AQL 解析器将返回错误。

AQL 只允许一个查询字符串中的一个查询； 因此，不允许使用分号来表示一个查询的结束和分隔多个查询（如 SQL 中所示）。

3.1.2 空白

可以在查询文本中使用空格（空格、回车、换行和制表位）以提高其可读性。 令牌必须由任意数量的空格分隔。 字符串或名称中的空格必须用引号括起来才能保留。

3.1.3 注释

注释可以嵌入在查询中的任何位置。注释中包含的文本将被 AQL 解析器忽略。

多行注释不能嵌套，这意味着注释中的后续注释开始将被忽略，注释结束将结束注释。

AQL 支持两种类型的注释：

• 单行注释：这些注释以双正斜杠开头，以行尾或查询字符串的末尾结尾（以第一个开头为准）。
• 多行注释：这些注释以正斜杠和星号开头，以星号和后正斜杠结尾。它们可以根据需要跨越任意数量的行。

1
2
3
4
5
6

/* this is a comment */ RETURN 1
/* these */ RETURN /* are */ 1 /* multiple */ + /* comments */ 1
/* this is
   a multi line
   comment */
// a single line comment

3.1.4 关键字

在顶层，AQL 提供以下高级操作：

上述每个操作都可以使用同名的关键字在查询中启动。AQL 查询可以（并且通常确实）包含上述多个操作。

AQL 查询示例 如下所示：

1
2
3

FOR u IN users
  FILTER u.type == "newbie" && u.active == true
  RETURN u.name

在此示例查询中，术语 FOR、FILTER 和 RETURN 根据其名称启动更高级别的操作。 这些术语也是关键字，这意味着它们在语言中具有特殊含义。

例如，查询解析器将使用关键字找出要执行的高级操作。 这也意味着关键字只能在查询中的特定位置使用。 这也使所有关键字都成为保留字，不得用于其预期用途之外的其他目的。

例如，不能将关键字用作不带引号的字面字符串（标识符）用于集合或属性名称。 如果集合或属性需要与关键字具有相同的名称，则需要在查询中引用/转义集合或属性名称（另请参阅名称）。

关键字不区分大小写，这意味着它们可以在查询中指定为小写、大写或混合大小写。 在本文档中，所有关键字都以大写形式编写，以便与其他查询部分区分开来。

除了更高级别的操作关键字之外，还有一些关键字。 在 ArangoDB 的未来版本中可能会添加其他关键字。 目前完整的关键字列表是：

最重要的是，在语言结构中使用了一些不是保留关键字的词。 因此，它们可以用作集合或属性名称而无需引用或转义。 查询解析器可以根据上下文将它们识别为类似关键字：

• KEEP–COLLECT 操作变体
• COUNT (WITH COUNT INTO） –COLLECT 操作变体
• OPTIONS– FOR / Graph Traversal / SEARCH / COLLECT / INSERT / UPDATE / REPLACE / UPSERT / REMOVE 操作
• PRUNE–Graph Traversal, FOR 操作变体
• SEARCH–SEARCH 操作
• TO–Shortest Path / k Shortest Paths 图遍历

最后但并非最不重要的一点是，在某些上下文中可以使用特殊变量。与关键字不同，它们区分大小写：

• CURRENT– 在数组内联表达式中可用
• NEW–插入/更新/更换/UPSERT操作后可用
• OLD–更新/替换/更新/删除操作后可用

如果在同一作用域中定义具有相同名称的变量，则其值将保持为您设置的值。因此，如果要访问特殊变量值，则需要避免使用自己的变量的这些名称。

3.1.5 命名

通常，名称用于标识 AQL 查询中的以下内容：

• 收集
• 属性
• 变量
• 功能

AQL 中的名称始终区分大小写。 集合/视图名称支持的最大长度为 256 字节。 变量名称可以更长，但不鼓励使用。

关键字不得用作名称。 如果保留关键字应用作名称，则名称必须包含在反引号或正引号中。

1
2

FOR doc IN `filter`
  RETURN doc.`sort`

由于反引号，filter和sort在这里被解释为名称而不是关键字。

该示例可以写为：

1
2

FOR f IN ´filter´
  RETURN f.´sort´

您可以使用括号表示法来代替刻度线来访问属性：

1
2

FOR f IN `filter`
  RETURN f["sort"]

sort在这个替代方案中是一个带引号的字符串文字，因此不与保留字冲突。

如果名称中包含连字符减号 (-) 等特殊字符，也需要转义：

1
2

FOR doc IN `my-coll`
  RETURN doc

集合 my-coll 的名称中有一个破折号，但是 - 是 AQL 中用于减法的算术运算符。 反引号将集合名称转义以正确引用集合。 请注意，集合不能用 “ 或 ‘ 引用名称。

3.1.6 集合名称

集合名称可以按原样用于查询。 如果集合碰巧与关键字同名，则名称必须用反引号括起来。

请参阅ArangoDB 中有关集合命名约定的命名约定。

AQL 当前在一个 AQL 查询中最多只能使用 256 个集合。此限制适用于所有涉及的文档和边缘集合的总和。

3.1.7 属性名称

当从集合中引用文档的属性时，必须使用完全限定的属性名称。 这是因为在查询中可能会使用多个属性名称不明确的集合。 为避免歧义，不允许引用不合格的属性名称。

有关属性命名约定的更多信息，请参阅ArangoDB 中的命名约定。

1
2
3
4

FOR u IN users
  FOR f IN friends
    FILTER u.active == true && f.active == true && u.id == f.userId
    RETURN u.name

在上面的示例中，属性名称 active、name、id 和 userId 使用它们所属的集合名称（分别为 u 和 f）进行限定。

3.1.8 变量名称

AQL 允许用户为查询中的其他变量赋值。 分配了值的所有变量都必须具有在查询上下文中唯一的名称。 变量名称必须与同一查询中使用的任何集合名称的名称不同。

1
2
3

FOR u IN users
  LET friends = u.friends
  RETURN { "name" : u.name, "friends" : friends }

在上面的查询中，users是一个集合名，u和friend都是变量名。 这是因为 FOR 和 LET 操作需要目标变量来存储它们的中间结果。

变量名称中允许的字符是字母 a 到 z（大小写）、数字 0 到 9、下划线 (_) 符号和美元 ($) 符号。 变量名不能以数字开头。 如果变量名称以一个或多个下划线字符开头，则下划线后面必须至少跟一个字母（a-z 或 A-Z）。 美元符号只能用作变量名的第一个字符，并且后面必须跟一个字母。

3.2 数据类型

AQL 支持由一个值组成的基元数据类型和由多个值组成的复合数据类型。以下类型可用：

3.2.1 基元类型

3.1.1.1 空值

值可用于表示空值或不存在的值。 它不同于数字值零 () 和其他假值（或零长度字符串）。 它在其他语言中也称为 nil 或 None。null null != 0 false “”

系统可能会在没有值的情况下返回，例如，如果您使用不受支持的值作为参数调用函数，或者您尝试访问不存在的属性。null

3.2.1.2 布尔数据类型

Boolean 数据类型有两个可能的值 。 它们代表逻辑和数学中的两个真值。true false

3.2.1.3 数字文本

数字文字可以是整数或实数值（浮点数）。 它们可以选择使用 或 符号进行签名。 小数点用作可选小数部分的分隔符。 还支持科学记数法（E-notation）+-.

1
2
3
4
5
6
7
8
9
10
11

  1
 +1
 42
 -1
-42
  1.23
-99.99
  0.5
   .5
 -4.87e103
 -4.87E103

以下符号无效，将引发语法错误：

1
2
3
4

 1.
01.23
00.23
00

所有数值在内部都被视为 64 位有符号整数或 64 位双精度浮点值。 使用的内部浮点格式是 IEEE 754。

当通过用户定义的 AQL 函数向 JavaScript 公开任何数字整数值时，超过 32 位精度的数字将转换为浮点值，因此大整数可能会丢失一些精度位。 将 AQL 数值结果转换为 JavaScript（例如将它们返回给 Foxx）时也是如此。

从 ArangoDB v3.7.7 开始，数字整数文字也可以表示为二进制（基数 2）或十六进制（基数 16）数字文字。

• 二进制整数文字的前缀是，例如 .0b 0b10101110
• 十六进制整数文字的前缀是，例如 .0x 0xabcdef02

二进制和十六进制整数文字只能用于无符号整数。 二进制和十六进制数字文字的最大支持值为 232 - 1，即（二进制）或（十六进制）。0b11111111111111111111111111111111 0xffffffff

3.2.1.4 字符串

字符串文字必须用单引号或双引号括起来。 如果要在字符串文字中使用所使用的引号字符本身，则必须使用反斜杠符号对其进行转义。 文字反斜杠也需要用反斜杠转义。

1
2
3
4
5
6
7
8
9
10
11

"yikes!"
"don't know"
"this is a \"quoted\" word"
"this is a longer string."
"the path separator on Windows is \\"

'yikes!'
'don\'t know'
'this is a "quoted" word'
'this is a longer string.'
'the path separator on Windows is \\'

所有字符串文字都必须是 UTF-8 编码的。 如果不是 UTF-8 编码，目前无法使用任意二进制数据。 使用二进制数据的一种解决方法是在存储之前在应用程序端使用 Base64 或其他算法对数据进行编码，并在检索后在应用程序端对其进行解码。

3.2.1.5 复合类型

AQL 支持两种复合类型：

• array：未命名值的组合，每个值都可以通过它们的位置访问。 有时称为列表。
• 对象：命名值的组合，每个值都可以通过它们的名称访问。 文档是顶层的对象。

3.2.1.6 数组/列表

第一个支持的复合类型是数组类型。 数组实际上是（未命名/匿名）值的序列。 可以通过它们的位置访问单个数组元素。 数组中元素的顺序很重要。

数组声明以左方括号开始，以右方括号结束。 声明包含零个、一个或多个表达式，用逗号分隔。 在声明中忽略元素周围的空格，因此可以使用换行符、制表位和空格进行格式化[].

在最简单的情况下，数组为空，因此如下所示：

1

[ ]

数组元素可以是任何合法的表达式值。支持数组嵌套。

1
2
3
4

[ true ]
[ 1, 2, 3 ]
[ -99, "yikes!", [ false, ["no"], [] ], 1 ]
[ [ "fox", "marshal" ] ]

允许最后一个元素后的尾随逗号（在 v3.7.0 中引入）：

1
2
3
4
5

[
  1,
  2,
  3, // trailing comma
]

稍后可以使用访问器通过它们的位置访问单个数组值。 被访问元素的位置必须是一个数值。 位置从 0 开始。也可以使用负索引值来访问从数组末尾开始的数组值。 如果数组的长度未知并且需要访问数组末尾的元素，这会很方便。[]

1
2
3
4
5
6
7
8
9
10
11

// access 1st array element (elements start at index 0)
u.friends[0]

// access 3rd array element
u.friends[2]

// access last array element
u.friends[-1]

// access second to last array element
u.friends[-2]

3.2.1.7 对象/文档

另一个受支持的复合类型是对象（或文档）类型。 对象是零到多个属性的组合。 每个属性都是一个名称/值对。 可以通过名称单独访问对象属性。 这种数据类型也称为字典、映射、关联数组和其他名称。

对象声明以左大括号开始，以右大括号结束。 一个对象包含零到多个属性声明，用符号相互分隔。 声明中会忽略元素周围的空格，因此可以使用换行符、制表位和空格进行格式化 {}、

在最简单的情况下，对象是空的。 它的声明将是：

1

{ }

对象中的每个属性都是一个名称/值对。 属性的名称和值使用冒号分隔。 名称始终是字符串，而值可以是任何类型，包括子对象。：

属性名称是强制性的 - 对象中不能有匿名值。 它可以指定为带引号或不带引号的字符串：

1
2
3

{ name: … }    // unquoted
{ 'name': … }  // quoted (apostrophe / "single quote mark")
{ "name": … }  // quoted (quotation mark / "double quote mark")

如果它包含空格、转义序列或除 ASCII 字母 (-、-)、数字 (-)、下划线 () 和美元符号 () 以外的字符，则必须用引号引起来。 第一个字符必须是字母、下划线或美元符号。a z A Z 0 9 _ $

如果关键字用作属性名称，则属性名称必须用引号或反引号引用或转义：

1
2
3
4
5

{ return: … }    // error, return is a keyword!
{ 'return': … }  // quoted
{ "return": … }  // quoted
{ `return`: … }  // escaped (backticks)
{ ´return´: … }  // escaped (ticks)

允许在最后一个元素后使用尾随逗号（在 v3.7.0 中引入）：

1
2
3
4
5

{
  "a": 1,
  "b": 2,
  "c": 3, // trailing comma
}

也可以使用动态表达式计算属性名称。 要从属性名称表达式中消除常规属性名称的歧义，计算出的属性名称必须括在方括号中：[ … ]

1

{ [ CONCAT("test/", "bar") ] : "someValue" }

属性还有速记符号，这对于轻松返回现有变量非常方便：

1
2
3

LET name = "Peter"
LET age = 42
RETURN { name, age }

以上是通用形式的速记等价物：

1
2
3

LET name = "Peter"
LET age = 42
RETURN { name: name, age: age }

任何有效的表达式都可以用作属性值。 这也意味着嵌套对象可以用作属性值：

1
2
3

{ name : "Peter" }
{ "name" : "Vanessa", "age" : 15 }
{ "name" : "John", likes : [ "Swimming", "Skiing" ], "address" : { "street" : "Cucumber lane", "zip" : "94242" } }

以后可以使用点访问器通过名称访问各个对象属性：

1
2

u.address.city.name
u.friends[0].name.first

也可以使用方括号访问器访问属性：[]

1
2

u["address"]["city"]["name"]
u["friends"][0]["name"]["first"]

与点访问器相比，方括号允许表达式：

1
2
3

LET attr1 = "friends"
LET attr2 = "name"
u[attr1][0][attr2][ CONCAT("fir", "st") ]

如果以一种或另一种方式访问不存在的属性，结果将为 , 没有错误或警告.null

3.3 绑定参数

AQL 支持使用绑定参数，从而允许将查询文本与查询中使用的文字值分开。 将查询文本与文字值分开是一种很好的做法，因为这将防止（恶意）将关键字和其他集合名称注入现有查询中。 这种注入很危险，因为它可能会改变现有查询的含义。

使用绑定参数，无法更改现有查询的含义。 绑定参数可以在查询中可以使用文字的任何地方使用。

3.3.1 语法

绑定参数的一般语法是@name，其中@ 表示这是一个值绑定参数，而name 是实际参数名称。 它可用于替换查询中的值。

1

RETURN @value

对于集合，@@coll 的语法略有不同，其中@@ 表示它是一个集合绑定参数，coll 是参数名称。

1
2

FOR doc IN @@coll
  RETURN doc

关键字和其他语言结构不能被绑定值替换，例如 FOR、FILTER、IN、INBOUND 或函数调用。

绑定参数名称必须以字母 a 到 z（大写或小写）或数字（0 到 9）中的任何一个开头，并且后面可以跟任何字母、数字或下划线符号。

不得在查询代码中引用它们：

1
2
3
4

FILTER u.name == "@name" // wrong
FILTER u.name == @name   // correct
FOR doc IN "@@collection" // wrong
FOR doc IN @@collection   // correct

如果需要在查询中做字符串处理（连接等），则需要使用字符串函数来做：

1
2
3

FOR u IN users
  FILTER u.id == CONCAT('prefix', @id, 'suffix') && u.name == @name
  RETURN u

3.3.2 用法

3.3.2.1 常规

绑定参数值需要在执行时与查询一起传递，但不能作为查询文本本身的一部分。 在 Web 界面中，查询编辑器旁边有一个窗格，可以在其中输入绑定参数。 对于以下查询，将显示两个输入字段以输入参数 id 和 name 的值。

1
2
3

FOR u IN users
  FILTER u.id == @id && u.name == @name
  RETURN u

当使用 db._query() 时（例如在 arangosh 中），则可以为参数传递键值对的对象。 这样的对象也可以传递给 HTTP API 端点 _api/cursor，作为键 bindVars 的属性值：

1
2
3
4
5
6
7

{
  "query": "FOR u IN users FILTER u.id == @id && u.name == @name RETURN u",
  "bindVars": {
    "id": 123,
    "name": "John Smith"
  }
}

查询中声明的绑定参数也必须传递参数值，否则查询将失败。 指定未在查询中声明的参数也会导致错误。

还可以在以下位置找到有关参数绑定的具体信息：

• 带有 Web 界面的 AQL
• AQL with arangosh
• 用于 AQL 查询的 HTTP 接口

3.3.2.2 嵌套属性

绑定参数可用于子属性访问的点表示法和方括号表示法。 它们也可以链接：

1
2
3
4
5
6
7
8
9

LET doc = { foo: { bar: "baz" } }

RETURN doc.@attr.@subattr
// or
RETURN doc[@attr][@subattr]
{
  "attr": "foo",
  "subattr": "bar"
}

上面示例中的两个变体都返回 [ “baz” ] 作为查询结果。

整个属性路径，特别是对于高度嵌套的数据，也可以使用点表示法和单个绑定参数指定，通过将字符串数组作为参数值传递。 数组的元素代表路径的属性键：

1
2
3

LET doc = { a: { b: { c: 1 } } }
RETURN doc.@attr
{ "attr": [ "a", "b", "c" ] }

示例查询返回 [ 1 ] 作为结果。 请注意， { “attr”: “a.b.c” } 将返回名为 a.b.c 的属性的值，而不是具有父级 a 和 b 的属性 c 的值，如 [ “a”, “b”, “c” ] 会。

3.3.3 集合绑定参数

存在一种特殊类型的绑定参数用于注入集合名称。 这种类型的绑定参数有一个以附加@ 符号为前缀的名称，因此在查询中使用@@name。

1
2
3

FOR u IN @@collection
  FILTER u.active == true
  RETURN u

第二个@ 将是绑定参数名称的一部分，在指定 bindVars 时要记住这一点很重要（注意前导@）：

1
2
3
4
5
6

{
  "query": "FOR u IN @@collection FILTER u.active == true RETURN u",
  "bindVars": {
    "@collection": "users"
  }
}

3.4 类型和值顺序

在检查相等或不相等或确定值的排序顺序时，AQL 使用确定性算法，该算法将数据类型和实际值都考虑在内。

比较的操作数首先按其数据类型进行比较，如果操作数具有相同的数据类型，则仅按其数据值进行比较。

比较数据类型时使用以下类型顺序：

1

null  <  bool  <  number  <  string  <  array/list  <  object/document

这意味着 null 是 AQL 中最小的类型，而文档是最高阶的类型。 如果比较的操作数具有不同的类型，则确定比较结果并完成比较。

例如，布尔真值将始终小于任何数字或字符串值、任何数组（甚至是空数组）或任何对象/文档。 此外，任何字符串值（即使是空字符串）将始终大于任何数字值、布尔值、真或假。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

null  <  false
null  <  true
null  <  0
null  <  ''
null  <  ' '
null  <  '0'
null  <  'abc'
null  <  [ ]
null  <  { }

false  <  true
false  <  0
false  <  ''
false  <  ' '
false  <  '0'
false  <  'abc'
false  <  [ ]
false  <  { }

true  <  0
true  <  ''
true  <  ' '
true  <  '0'
true  <  'abc'
true  <  [ ]
true  <  { }

0  <  ''
0  <  ' '
0  <  '0'
0  <  'abc'
0  <  [ ]
0  <  { }

''  <  ' '
''  <  '0'
''  <  'abc'
''  <  [ ]
''  <  { }

[ ]  <  { }

如果两个比较的操作数具有相同的数据类型，则比较操作数的值。 对于原始类型（null、boolean、number 和 string），结果定义如下：

• 空值：null 等于 null
• 布尔值：false小于true
• 数字：数值按其值排序
• string：字符串值使用本地化比较进行排序，使用配置的服务器语言根据该语言的字母顺序规则进行排序

注意：与 SQL 不同，null 可以与任何值进行比较，包括 null 本身，而不会将结果自动转换为 null。

对于复合类型，应用以下特殊规则：

从第一个元素开始，通过逐个位置比较它们的各个元素来比较两个数组值。 对于每个位置，首先比较元素类型。 如果类型不相等，则确定比较结果，比较结束。 如果类型相等，则比较两个元素的值。 如果其中一个数组已完成，而另一个数组在比较位置仍有元素，则 null 将用作完全遍历数组的元素值。

如果数组元素本身是复合值（数组或对象/文档），则比较算法将递归检查元素的子值。 递归地比较元素的子元素。

1
2
3
4
5
6

[ ]  <  [ 0 ]
[ 1 ]  <  [ 2 ]
[ 1, 2 ]  <  [ 2 ]
[ 99, 99 ]  <  [ 100 ]
[ false ]  <  [ true ]
[ false, 1 ]  <  [ false, '' ]

通过检查属性名称和值来比较两个对象/文档操作数。首先比较属性名称。在比较属性名称之前，会创建一个包含两个操作数的所有属性名称的组合数组，并按字典顺序排序。这意味着在比较两个对象/文档时，在对象/文档中声明属性的顺序无关紧要。

然后遍历组合和排序的属性名称数组，然后查找来自两个比较操作数的相应属性。如果对象/文档之一不具有具有所寻求名称的属性，则其属性值被认为是空的。最后，使用前面提到的数据类型和值比较来比较两个对象/文档的属性值。对所有对象/文档属性执行比较，直到有明确的比较结果。如果发现比较结果明确，则比较结束。如果没有明确的比较结果，则认为两个比较的对象/文档相等。

1
2
3
4
5
6
7
8
9

{ }  ==  { "a" : null }

{ }  <  { "a" : 1 }
{ "a" : 1 }  <  { "a" : 2 }
{ "b" : 1 }  <  { "a" : 0 }
{ "a" : { "c" : true } }  <  { "a" : { "c" : 0 } }
{ "a" : { "c" : true, "a" : 0 } }  <  { "a" : { "c" : false, "a" : 1 } }

{ "a" : 1, "b" : 2 }  ==  { "b" : 2, "a" : 1 }

3.5 访问集合中的数据

可以通过在查询中指定集合名称来访问集合数据。集合可以理解为文档数组，这就是它们在 AQL 中的处理方式。集合中的文档通常使用 FOR 关键字访问。请注意，在迭代集合中的文档时，文档的顺序是未定义的。要以明确且确定的顺序遍历文档，还应使用 SORT 关键字。

集合中的数据存储在文档中，每个文档可能具有与其他文档不同的属性。即使对于同一集合的文档也是如此。

因此，遇到不具有在 AQL 查询中查询的部分或全部属性的文档是很正常的。在这种情况下，文档中不存在的属性将被视为它们以 null 值存在。这意味着如果文档具有特定属性并且该属性具有 null 值，或者文档根本没有特定属性，则将文档属性与 null 进行比较将返回 true。

例如，以下查询将返回来自集合 users 中属性 name 值为 null 的所有文档，以及来自根本没有 name 属性的用户的所有文档：

1
2
3

FOR u IN users
  FILTER u.name == null
  RETURN u

此外，null 小于任何其他值（不包括 null 本身）。 这意味着在将属性值与小于或小于等于运算符进行比较时，结果中可能包含具有不存在属性的文档。

例如，以下查询将返回来自集合 users 中具有值小于 39 的属性 age 的所有文档，以及来自集合中根本没有属性 age 的所有文档。

1
2
3

FOR u IN users
  FILTER u.age < 39
  RETURN u

编写查询时应始终考虑此行为。

3.5 查询结果

3.5.1 结果集

AQL 查询的结果是一个值数组。 结果数组中的各个值可能具有也可能不具有同构结构，具体取决于实际查询的内容。

例如，当从具有非同构文档（集合中的各个文档具有不同的属性名称）的集合中返回数据时未经修改，结果值也将具有非同构的结构。 每个结果值本身就是一个文档：

1
2
3
4
5
6
7

FOR u IN users
    RETURN u
[
  { "id": 1, "name": "John", "active": false },
  { "age": 32, "id": 2, "name": "Vanessa" },
  { "friends": [ "John", "Vanessa" ], "id": 3, "name": "Amy" }
]

但是，如果查询集合中的一组固定属性，则查询结果值将具有同构结构。 每个结果值仍然是一个文档：

1
2
3
4
5
6
7

FOR u IN users
    RETURN { "id": u.id, "name": u.name }
[
  { "id": 1, "name": "John" },
  { "id": 2, "name": "Vanessa" },
  { "id": 3, "name": "Amy" }
]

也可以只查询标量值。 在这种情况下，结果集是一个标量数组，每个结果值都是一个标量值：

1
2
3

FOR u IN users
    RETURN u.id
[ 1, 2, 3 ]

如果查询由于找不到匹配的数据而未生成任何结果，它将生成一个空的结果数组：

1

[ ]

3.6 错误

如果查询在语法上无效，则向服务器发出无效查询将导致解析错误。 ArangoDB 将在查询检查期间检测此类错误并中止进一步处理。 相反，会返回错误编号和错误消息，以便修复错误。

如果查询通过解析阶段，则将打开查询中引用的所有集合。 如果任何引用的集合不存在，查询执行将再次中止并返回适当的错误消息。

在某些情况下，执行查询还可能产生运行时错误或警告，这些错误或警告无法通过单独检查查询文本来预测。 这是因为查询可能使用集合中的数据，这些数据也可能是非同质的。 会导致运行时错误或警告的一些示例是：

• 被零除：当在算术除法或模运算中尝试使用值 0 作为除数时将被触发
• 算术运算的操作数无效：当尝试在算术运算中使用任何非数字值作为操作数时将被触发。 这包括一元（一元减、一元加）和二元运算（加、减、乘、除和模）
• 逻辑运算的操作数无效：当尝试在逻辑运算中使用任何非布尔值作为操作数时将被触发。 这包括一元（逻辑非/否定）、二元（逻辑与、逻辑或）和三元运算符

请参阅Arango错误页面，了解错误代码和含义的列表。

3.7 AQL 查询的已知限制

AQL 查询存在以下硬编码限制：

• AQL 查询不能使用超过 1000 个结果寄存器。 每个命名查询变量和内部/匿名查询变量都需要一个结果寄存器，例如 对于中间结果。 子查询也需要结果寄存器。
• AQL 查询在其初始查询执行计划中不能有超过 4000 个执行节点。
• AQL 查询不能使用超过 2048 个集合/分片。
• AQL 查询中的表达式不能嵌套超过 500 级。 例如，表达式 1 + 2 + 3 + 4 有 3 层深（因为它被解释和执行为 1 + (2 + (3 + 4))）

请注意，即使查询仍然低于这些限制，也可能不会产生良好的性能，尤其是当它们必须将来自许多不同集合的数据放在一起时。 还请考虑大型查询（就中间结果大小或最终结果大小而言）可能会使用大量内存，并且可能会达到 AQL 查询的可配置内存限制。

对于 AQL 查询，已知以下其他限制：

• 表达式中使用的子查询从这些表达式中取出并预先执行。 这意味着子查询不参与操作数的惰性求值，例如在三元运算符中。 另见评估子查询。
• 在同一 AQL 查询中将集合用于写入操作后，无法在读取操作中使用该集合。
• 在集群中，所有通过使用集合集（而不是命名图）的遍历动态访问的集合必须在查询的初始 WITH 语句中声明。 要在单个服务器中也需要 WITH 语句（例如，用于测试迁移到集群），请使用选项 —query.require-with 启动服务器

四 运算符

AQL 支持许多可在表达式中使用的运算符。有比较，逻辑，算术和三元运算符。

4.1 比较运算符

比较（或关系）运算符比较两个操作数。它们可以与任何输入数据类型一起使用，并将返回布尔结果值。

支持以下比较运算符：

如果比较可以被评估，则每个比较运算符都返回一个布尔值，如果比较评估为真则返回真，否则返回假。

比较运算符接受第一个和第二个操作数的任何数据类型。 但是，如果 IN 和 NOT IN 的右手操作数是数组，则它们只会返回有意义的结果。 LIKE 和 NOT LIKE 只有在两个操作数都是字符串值时才会执行。 如果比较的操作数具有不同的类型，则所有四个运算符都不会执行隐式类型转换，即它们测试严格相等或不相等（例如，0 与“0”、[0]、false 和 null 不同）。

AQL 中比较操作的一些示例：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

     0  ==  null            // false
     1  >   0               // true
  true  !=  null            // true
    45  <=  "yikes!"        // true
    65  !=  "65"            // true
    65  ==  65              // true
  1.23  >   1.32            // false
   1.5  IN  [ 2, 3, 1.5 ]   // true
 "foo"  IN  null            // false
42  NOT IN  [ 17, 40, 50 ]  // true
 "abc"  ==  "abc"           // true
 "abc"  ==  "ABC"           // false
 "foo"  LIKE  "f%"          // true
 "foo"  NOT LIKE  "f%"      // false
 "foo"  =~  "^f[o].$"       // true
 "foo"  !~  "[a-z]+bar$"    // true

LIKE 运算符检查其左操作数是否与其右操作数中指定的模式匹配。 模式可以由常规字符和通配符组成。 支持的通配符是 匹配单个任意字符，% 匹配任意数量的任意字符。 文字 % 和 需要用反斜杠转义。 反斜杠需要自己转义，这实际上意味着两个反斜杠字符需要位于文字百分号或下划线之前。 在 arangosh 中，需要额外的转义，使其在要转义的字符之前总共有四个反斜杠。

1
2
3

    "abc" LIKE "a%"          // true
    "abc" LIKE "_bc"         // true
"a_b_foo" LIKE "a\\_b\\_foo" // true

LIKE 运算符执行的模式匹配区分大小写。

NOT LIKE 运算符与 LIKE 运算符具有相同的特征，但结果为否定。 因此它与 NOT (… LIKE …) 相同。 请注意括号，这是某些表达式所必需的：

1
2

FOR doc IN coll
  RETURN NOT doc.attr LIKE "…"

返回表达式将被转换为 LIKE(!doc.attr, “…”)，给出意想不到的结果。 NOT(doc.attr LIKE “…”) 变成了更合理的 ! 喜欢（doc.attr，“…”）。

正则表达式运算符 =~ 和 !~ 期望它们的左侧操作数是字符串，而它们的右侧操作数是包含 AQL 函数 REGEX_TEST() 文档中指定的有效正则表达式的字符串。

4.2 数组比较运算符

比较运算符也作为数组变体存在。 在数组变体中，运算符的前缀是关键字 ALL、ANY 或 NONE 之一。 使用这些关键字之一会更改运算符行为，以便对其左侧参数值的所有、任意或不执行比较操作。 因此，预计数组运算符的左侧参数是一个数组。

例子：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

[ 1, 2, 3 ]  ALL IN  [ 2, 3, 4 ]  // false
[ 1, 2, 3 ]  ALL IN  [ 1, 2, 3 ]  // true
[ 1, 2, 3 ]  NONE IN  [ 3 ]       // false
[ 1, 2, 3 ]  NONE IN  [ 23, 42 ]  // true
[ 1, 2, 3 ]  ANY IN  [ 4, 5, 6 ]  // false
[ 1, 2, 3 ]  ANY IN  [ 1, 42 ]    // true
[ 1, 2, 3 ]  ANY ==  2            // true
[ 1, 2, 3 ]  ANY ==  4            // false
[ 1, 2, 3 ]  ANY >  0             // true
[ 1, 2, 3 ]  ANY <=  1            // true
[ 1, 2, 3 ]  NONE <  99           // false
[ 1, 2, 3 ]  NONE >  10           // true
[ 1, 2, 3 ]  ALL >  2             // false
[ 1, 2, 3 ]  ALL >  0             // true
[ 1, 2, 3 ]  ALL >=  3            // false
["foo", "bar"]  ALL !=  "moo"     // true
["foo", "bar"]  NONE ==  "bar"    // false
["foo", "bar"]  ANY ==  "foo"     // true

请注意，这些运算符不会在常规查询中使用索引。 SEARCH 表达式中也支持运算符，其中可以使用 ArangoSearch 的索引。 但是语义有所不同，请参阅 AQL SEARCH 操作。

4.3 逻辑运算符

AQL 中支持以下逻辑运算符：

• &&逻辑和运算符
• ||逻辑或运算符
• !逻辑非/否定运算符

AQL 还支持逻辑运算符的以下替代形式：

• AND逻辑和运算符
• OR逻辑或运算符
• NOT逻辑非/否定运算符

替代形式是别名并且在功能上等同于常规运算符。

AQL 中的两个操作数逻辑运算符将通过短路求值执行（除非操作数之一是或包含子查询。在这种情况下，子查询将在逻辑运算符之前被拉出求值）。

AQL 中逻辑运算符的结果定义如下：

• 如果 lhs && rhs 为 false 或在转换为布尔值时为 false，则将返回 lhs。 如果 lhs 为真或在转换为布尔值时为真，则将返回 rhs
• lh|| rhs 将返回 lhs 如果它为真或在转换为布尔值时为真。 如果 lhs 为 false 或在转换为布尔值时为 false，则将返回 rhs
• ！ value 将返回转换为布尔值的 value 的否定值

AQL 中逻辑运算的一些示例：

1
2
3
4

u.age > 15 && u.address.city != ""
true || false
NOT u.isInvalid
1 || ! 0

允许将非布尔值传递给逻辑运算符。 任何非布尔操作数都将被运算符隐式转换为布尔值，而不会中止查询。

转换为布尔值的工作原理如下：

• null 将被转换为 false
• 布尔值保持不变
• 所有不等于零的数字都为真，零为假
• 空字符串为假，所有其他字符串为真
• 数组 ([ ]) 和对象/文档 ({ }) 为真，无论它们的内容如何

逻辑和和逻辑或操作的结果现在可以具有任何数据类型，并且不一定是布尔值。

例如，以下逻辑运算将返回布尔值：

1
2
3

25 > 1  &&  42 != 7                        // true
22 IN [ 23, 42 ]  ||  23 NOT IN [ 22, 7 ]  // true
25 != 25                                   // false

…而以下逻辑运算不会返回布尔值：

1
2
3
4

   1 || 7                                  // 1
null || "foo"                              // "foo"
null && true                               // null
true && 23                                 // 23

4.4 算术运算符

算术运算符对两个数字操作数执行算术运算。算术运算的结果再次是数值。

AQL 支持以下算术运算符：

• +加法
• -减法
• *乘法
• /划分
• %模

还支持一元加号和一元减号：

1
2
3
4

LET x = -5
LET y = 1
RETURN [-x, +y]
// [5, 1]

对于求幂，有一个数字函数 POW()。 不支持语法 base ** exp。

对于字符串连接，您必须使用字符串函数 CONCAT()。 将两个字符串与加号运算符（“foo”+“bar”）组合将不起作用！ 另请参阅常见错误。

一些算术运算示例：

1
2
3
4
5
6
7

1 + 1
33 - 99
12.4 * 4.5
13.0 / 0.1
23 % 7
-15
+9.99

算术运算符接受任何类型的操作数。将非数字值传递给算术运算符将使用 TO_NUMBER() 函数应用的类型转换规则将操作数转换为数字：

• null 将被转换为 0

• false 将转换为 0，true 将转换为 1

• 有效数值保持不变，但 NaN 和 Infinity 将转换为 0

• 如果字符串值包含数字的有效字符串表示形式，则字符串值将转换为数字。字符串开头或结尾的任何空格都将被忽略。具有任何其他内容的字符串将转换为数字 0

• 一个空数组被转换为 0，一个具有一个成员的数组被转换为其唯一成员的数字表示。具有更多成员的数组将转换为数字 0。

• 对象/文档被转换为数字 0。

产生无效值（例如 1 / 0（被零除））的算术运算将产生 null 结果值。查询不会中止，但您可能会看到警告。

这里有一些例子：

1
2
3
4
5
6
7
8
9
10
11
12
13

   1 + "a"       // 1
   1 + "99"      // 100
   1 + null      // 1
null + 1         // 1
   3 + [ ]       // 3
  24 + [ 2 ]     // 26
  24 + [ 2, 4 ]  // 24
  25 - null      // 25
  17 - true      // 16
  23 * { }       // 0
   5 * [ 7 ]     // 35
  24 / "12"      // 2
   1 / 0         // null (with a 'division by zero' warning)

4.5 三元运算符

AQL 还支持可用于条件评估的三元运算符。 三元运算符期望布尔条件作为它的第一个操作数，如果条件评估为真，则返回第二个操作数的结果，否则返回第三个操作数。

例子

如果 u.age 大于 15 或 u.active 为真，则表达式返回 u.userId。 否则返回空值：

1

u.age > 15 || u.active == true ? u.userId : null

还有一个只有两个操作数的三元运算符的快捷变体。 当布尔条件的表达式和返回值应该相同时，可以使用此变体。

例子

如果 u.value 为真，则表达式计算为 u.value，否则返回固定字符串：

1

u.value ? : 'value is null, 0 or not present'

如果第二个操作数介于 ? 和 : 被省略，而在 u.value 的情况下它将被评估两次？ u.value : ‘值为空’。

表达式中使用的子查询从这些表达式中取出并预先执行。 这意味着子查询不参与操作数的惰性求值，例如在三元运算符中。另请参阅子查询的计算。

4.6 范围运算符

AQL 支持使用 .. 运算符表示简单的数字范围。 此运算符可用于轻松迭代一系列数值。

.. 运算符将生成定义范围内的整数值数组，包括两个边界值。

例子

1

2010..2013

将产生以下结果：

1

[ 2010, 2011, 2012, 2013 ]

使用范围运算符等效于使用范围边界指定的范围内的整数值编写数组。 如果范围运算符的边界是非整数，它们将首先转换为整数值。

还有一个RANGE（） 函数。

4.7 数组运算符

AQL 为数组变量扩展提供了数组运算符 []，为数组收缩提供了 [*]。

4.8 运算符优先级

AQL 中的运算符优先级与其他熟悉的语言类似（优先级最低优先）：

括号 ( 和 ) 可用于强制执行不同的运算符评估顺序。

五 数据查询

有两种基本类型的 AQL 查询：

• 访问数据的查询（读取文档）
• 修改数据的查询（创建、更新、替换、删除文档）

5.1 数据访问查询

使用 AQL 从数据库中检索数据始终包括 RETURN 操作。 它可用于返回静态值，例如字符串：

1

RETURN "Hello ArangoDB!"

查询结果始终是一个元素数组，即使在这种情况下返回单个元素并包含单个元素：["Hello ArangoDB!"]

可以调用函数 DOCUMENT()以通过其文档句柄检索单个文档，例如：

1

RETURN DOCUMENT("users/phil")

RETURN 通常伴随一个 FOR 循环来迭代集合的文档。 以下查询为名为 users 的集合的所有文档执行循环体。 在此示例中，每个文档都保持不变：

1
2

FOR doc IN users
    RETURN doc

无需返回原始文档，您可以轻松创建一个投影：

1
2

FOR doc IN users
    RETURN { user: doc, newAttribute: true }

对于每个用户文档，返回一个具有两个属性的对象。 属性 user 的值设置为用户文档的内容，newAttribute 是一个布尔值 true 的静态属性。

可以将 FILTER、SORT 和LIMIT 等操作添加到循环体中以缩小和排序结果。 除了上面显示的对DOCUMENT() 的调用之外，还可以像这样检索描述用户 phil 的文档：

1
2
3

FOR doc IN users
    FILTER doc._key == "phil"
    RETURN doc

本示例中使用了文档键，但任何其他属性同样可以用于过滤。 由于保证文档键是唯一的，因此不会有多个文档与此过滤器匹配。 对于其他属性，情况可能并非如此。 要返回按名称升序排序的活动用户子集（由名为 status 的属性确定），您可以执行以下操作：

1
2
3
4

FOR doc IN users
    FILTER doc.status == "active"
    SORT doc.name
    LIMIT 10

请注意，操作不必以固定顺序发生，它们的顺序会显着影响结果。 限制过滤器之前的文档数量通常不是您想要的，因为它很容易错过很多满足过滤条件的文档，但由于过早的 LIMIT 子句而被忽略。 由于上述原因，LIMIT通常放在最后，在 FILTER、SORT 等操作之后。

有关更多详细信息，请参阅高级操作一章。

5.2 数据修改查询

AQL 支持以下数据修改操作：

• INSERT：将新文档插入集合
• UPDATE：部分更新集合中的现有文档
• REPLACE：完全替换集合中的现有文档
• REMOVE：从集合中删除现有文档
• UPSERT:有条件地插入或更新集合中的文档

下面是一些使用这些操作的简单示例查询。高级操作 一章 中详细介绍了这些操作。

5.2.1 修改单个文档

让我们从基础开始：对单个文档的INSERT、UPDATE 和REMOVE 操作。 以下是在现有用户集合中插入文档的示例：

1
2
3
4
5

INSERT {
    firstName: "Anna",
    name: "Pavlova",
    profession: "artist"
} IN users

您可以提供新文件的密钥； 如果未提供，ArangoDB 将为您创建一个。

1
2
3
4
5
6

INSERT {
    _key: "GilbertoGil",
    firstName: "Gilberto",
    name: "Gil",
    city: "Fortalezza"
} IN users

由于 ArangoDB 是无模式的，文档的属性可能会有所不同：

1
2
3
4
5
6
7
8
9
10
11
12
13

INSERT {
    _key: "PhilCarpenter",
    firstName: "Phil",
    name: "Carpenter",
    middleName: "G.",
    status: "inactive"
} IN users
INSERT {
    _key: "NatachaDeclerck",
    firstName: "Natacha",
    name: "Declerck",
    location: "Antwerp"
} IN users