ArangoDB的ASL的常用操作

￡神魔★判官ぃ 2022-04-12 05:09 267阅读 0赞

# arangodb 的 AQL的简单 CURD 操作 #

> [https://www.arangodb.org/3.3/AQL/][https_www.arangodb.org_3.3_AQL] 阅读笔记

## 1、插入数据 ##

*  **单条插入**

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

语法是`INSERT document INTO collectionName`。该`document`是一个对象，您可以从JavaScript或JSON中了解它，它由属性键和值对组成。属性键周围的引号在AQL中是可选的。键总是字符序列（字符串），而属性值可以有不同的类型：

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

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

*  **批量插入**

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": "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

这个有点类似于编程语言，首先把数据复制给data这个变量，然后循环这个变量，挨个插入。`INSERT`语句中使用`d`不是具体的数据，而是变量。

## 2、获取数据 ##

*  获取集合所有数据

FOR c IN Characters
        RETURN c

这个循环和上面的循环又不一样啦，上面的数组data是一个数组变量，而这里的Characters确是一个集合，类似于我们mysql的表，这个循环会把这个collection中的所有数据打印出来，类似于遍历表的操作，例如`select * from`。

返回结果：

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

前面三个带下划线的是系统属性，可以在插入的时候指定或者系统自动赋值，但是数据插入之后就不能修改。带\_都是只读的。id的结构为Collection/\_\_key。

*  获取某条特定id的数据

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

只需要指定id，就可以返回相应的数据。2种书写方式都可行。

还可以一次获取多个文档

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

## 3、更新数据 ##

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

语法是`UPDATE documentKey WITH object IN collectionName`。它使用列出的属性更新指定的文档（如果它们不存在则添加它们），但保持其余不变。要替换整个文档内容，可以使用`REPLACE`：

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

也可以用循环，来为所有的数据修改某个属性，或者添加某个新的属性：

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

## 4、删除文件 ##

要从`collection`中完全删除文档，请执行`REMOVE`操作。它的工作方式与其他修改操作类似，但没有`WITH`子句：

REMOVE "2861650" IN Characters

它也可以在循环体中：

FOR c IN Characters
        REMOVE c IN Characters

# AQL的复杂查询 #

上面的查询只是根据id返回结果，或者返回整个collection。下面我们来看一下有条件的AQL。

## 匹配document ##

### 过滤FILTER ###

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

过滤条件如下：“ 字符文档的属性`name`必须等于`Ned` ”。如果条件成立，则返回字符document。这适用于任何属性：

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

除了`==`，还可以是`>=、<=、>、<`。

有个特殊情况：

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

查询结果：

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

年龄小于13，但是却会出现年龄为`null`。原因是，`null`文档中不存在此类属性，并且`null`将数字与较低的数字进行比较，参考它的值顺序，它意外地满足了年龄标准`c.age < 13`（`null < 13`）。

> # 类型和值顺序 #
> 
> 在检查相等或不等式时或确定值的排序顺序时，AQL使用确定性算法，该算法同时考虑数据类型和实际值。
> 
> 比较操作数首先按其数据类型进行比较，如果操作数具有相同的数据类型，则仅按其数据值进行比较。
> 
> 比较数据类型时使用以下类型顺序：
> 
>     null < bool < number < string < array/list < object/document
> 
> 这意味着*null*是AQL中的最小类型，而*document*是具有最高顺序的类型。如果比较的操作数具有不同的类型，则确定比较结果并完成比较。

### 多种条件 ###

为了不让文档在没有age属性的情况下通过过滤器，我们可以添加第二个标准：

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

这同样可以用布尔`AND`运算符写成：

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

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

### 替代条件 ###

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

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

## 排序和限制 ##

### 限制结果计数 ###

有时候我们可能并不需要返回所有的数据。在这些情况下，我们可以通过`LIMIT()`操作限制文档数量：

FOR c IN Characters
        LIMIT 5
        RETURN c.name

这样就只会返回前5个名字。

`LIMIT`后面跟着一个最大文件数的数字。但是，还有第二种语法，它允许您跳过一定数量的记录并返回下一个*n个*文档：

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

这个语句的意思就是跳过前面2个数据，显示从第3到第8个数据。

### 按名称分类 ###

直到此处显示查询结果的顺序基本上是随机的。要按定义的顺序返回它们，我们可以添加一个`SORT()`操作。如果结合使用`LIMIT()`，它会对结果产生很大影响，因为如果先排序，结果会变得可预测。

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

和SQL一样，我们可以用`DESC`降序来反转排序顺序。第一种是升序，这是默认顺序。因为它是默认值，所以不需要明确要求`ASC`。

### 按多个属性排序 ###

假设我们想按姓氏排序。许多角色都有姓氏。具有相同姓氏的字符之间的结果顺序是未定义的。我们可以先按姓氏排序，然后以名字确定顺序：

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

总的来说，文件按姓氏排序。如果两个字符的`surname`相同，则比较`name`并对结果进行排序。

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

## JOIN ##

### 基础合并 ###

每个人的属性：

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

*Traits* 这个集合里面放的是每个人的特点：

[
        { "_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" },
    ]

通过关联，在返回的结果中把每个人属性的字符改成Trais集合中的相应表示。

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

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

[
      [
        {
          "_key": "A",
          "_id": "Traits/A",
          "_rev": "_V5oRUS2---",
          "en": "strong",
          "de": "stark"
        },
        {
          "_key": "H",
          "_id": "Traits/H",
          "_rev": "_V5oRUS6--E",
          "en": "powerful",
          "de": "einflussreich"
        },
      ...
    ]

这样数据太多，我们可以只使用数组扩展符号返回英文标签：

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

查询结果：

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

### 合并字符和特征 ###

我们也需要知道他们属于哪个角色。因此，我们需要合并字符文档和特征文档中的数据：

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

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

该`MERGE()`功能合并对象组合在一起。因为我们使用了与原始字符属性`{ traits: ... }`具有相同属性名称*特征*的对象 ，所以后者被合并覆盖。

## 图遍历 ##

### 数据准备 ###

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

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

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

转化为图形：

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIwOTg5MTA1_size_16_color_FFFFFF_t_70]

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

运行一下查询：

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

查询细分：

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

### 查询父母 ###

现在边缘链接了字符文档（顶点），我们有一个图表，我们可以查询以找出父母是谁的另一个字符 - 或者在图形术语中，我们想要从一个顶点开始并沿着边缘跟随AQL其他顶点图遍历：

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

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

在上面的查询中，遍历被限制为最小和最大遍历深度1（从起始顶点开始的步数），并且仅遵循`OUTBOUND`方向上的边。我们的边缘从孩子到父母，父母离孩子只有一步之遥，因此它给了我们开始的孩子的父母。`"Characters/2901776"`是起点顶点。请注意，文档ID对您而言会有所不同，因此请将其调整为您的文档ID，例如Bran Stark ：

FOR c IN Characters
        FILTER c.name == "Bran"
        RETURN c._id
    [ "Characters/<YourDocumentkey>" ]

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

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

开始顶点后跟`ChildOf`，这是我们的edge collection。示例查询仅返回每个父项的名称以使结果保持简短：

[
      "Ned",
      "Catelyn"
    ]

同样的结果将以Robb，Arya和Sansa作为起点返回。对于Jon Snow来说，它只会是Ned。

### 查询child ###

我们也可以从反向边缘（`INBOUND`即）的父母查询到孩子们：

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

结果：

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

### 查询孙子 ###

如果我们把父母查询孩子的深度改成2，那就是查询孩子的孩子，就是孙子。

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

结果：

[
      "Joffrey",
      "Joffrey"
    ]

可能有点出乎意料，`Joffrey`两次出现。但是，如果你看图形可视化，你可以看到多条路径从Joffrey（右下角）到Tywin：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIwOTg5MTA1_size_16_color_FFFFFF_t_70 1]

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

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

> options（object，optional）：用于修改遍历的执行。只有以下属性有效，所有其他属性都被忽略：
> 
>  *  uniqueVertices
>     
>     （string）：可选择确保顶点唯一性
>     
>      *  “path” - 保证没有返回带有重复顶点的路径
>      *  “全局” - 保证每次顶点在遍历期间最多访问一次，无论从起始顶点到此顶点有多少条路径。如果你从一个`min depth > 1`在*最小*深度可能根本没有返回之前找到的顶点开始（它仍然可能是路径的一部分）。**注意：** 使用此配置，结果不再具有确定性。如果从*startVertex*到*顶点*有多条路径，*则会*选择其中一条路径。
>      *  “none”（默认值） - 不对顶点应用唯一性检查
>  *  uniqueEdges
>     
>     （string）：可选择确保边缘唯一性
>     
>      *  “path”（默认值） - 保证没有返回带有重复边缘的路径
>      *  “无” - 没有对边缘应用唯一性检查。**注意：** 使用此配置，遍历将遵循边缘中的循环。
>  *  bfs
>     
>     （bool）：可选择使用替代广度优先遍历算法
>     
>      *  true - 遍历将以广度优先执行。结果将首先包含深度为1的所有顶点。比深度为2的所有顶点，依此类推。
>      *  false（默认值） - 遍历将以深度优先执行。对于深度为1的一个顶点，它将首先返回从*最小*深度到*最大*深度的所有路径。对于深度为1的下一个顶点，依此类推。

### 遍历可变深度 ###

为了让`Joffrey`的父母和祖父母回归，我们可以`OUTBOUND`沿着方向行走 并调整遍历深度至少走1步，最多2步：

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

结果：

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

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

[https_www.arangodb.org_3.3_AQL]: https://www.arangodb.org/3.3/AQL/
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIwOTg5MTA1_size_16_color_FFFFFF_t_70]: /images/20220412/f67afa8f6ab14e21994b27aeed10da74.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzIwOTg5MTA1_size_16_color_FFFFFF_t_70 1]: /images/20220412/c68c8613305c44bb8f6051acab25217d.png