ArangoDB

一、ArangoDB 安装（CentOs7）

1.下载安装包
	https://www.arangodb.com/download/
2.安装arangodb
	这边下载的Centos,rpm安装包
	rpm -ivh arangodb3-3.9.0-1.0.x86_64.rpm
3.设置root密码
	运行arango-secure-installation
4.为了能在局域网中访问WEB界面，修改配置文件/etc/arangodb3/arangod.conf
	将endpoint = tcp://127.0.0.1:8529，默认端口为8529
	更改为主机ip,例如endpoint = tcp://10.41.144.24:8529
5.开启arangoDB
	systemctl start arangodb3.service
	#systemctl stop arangodb3.service#关闭arangoDB
	#systemctl restart arangodb3.service#重启arangoDB
6.查看arangoDB运行状态
	systemctl status arangodb3.service ,出现active为正常运行

Configuration file:
  /etc/arangodb3/arangod.conf
Start ArangoDB shell client:
  > /usr/bin/arangosh
Start ArangoDB service:
  > systemctl start arangodb3.service
Enable ArangoDB service:
  > systemctl enable arangodb3.service

二、ArangoDB基本概念

AQL：arangodb的查询语言，可与类似于SQL。
Collections：分成Docunment和Edge两种类型，分别储存文档和边的信息
Document：可以储存一条记录，每一条类似于一个neo4j的节点
Edge：可以储存一条记录，与document不同，edge储存的是节点之间的关系（带有_from和_to）
graph：根据指定的一个或多个document和edge进行结合，组成一个graph
View：视图、对collections中的文档建立视图，已用来提供arangosearch的查询

三、ArangoDB基本使用

3.1、新增

• 语法是 INSERT document INTO collectionName。document是一个对象，它由属性键和值对组成。
• 属性键周围的引号在AQL中是可选的。
• 键总是字符序列(字符串)，
• 属性值可以有不同的类型

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

		_id:Characters/1539
		_rev:_duTGg8K---
		_key:1539

• _id则为表名和key的结合,_key为数据文档中这一条数据的键,_rev为系统管理的版本（revision id）

• 数据类型

	零
	布尔(真、假)
	数(整数和浮点数)
	字符串
	数组
	对象

3.2、删除

• 根据key对文档中相应的一条数据进行删除

REMOVE "1539" IN Characters

3.3、修改

  update "1539" with { "name": "NedUpdate" } in Characters

• replace的使用
• 用replace字段的话会将原来的数据删除掉，将新的填充进去，而不是只替换输入的参数

 replace "1539" with{ "_key": "1539", "_id": "Characters/1539", "name": "NedRepalce", "id": "9f8a12152a844671aa9c9c7021303fcc", "sample": "弦酿坭苛忒蜩铬难怩遇汗昂浩筷烯母浑伫娠甄咀展郏帘岣晾拐捂妊幢胫镝蟓酉杓圻藤缱哑守陕锸焖桑狂写驹漾黯" } in Characters

3.4、 查询

• 根据id在文档内进行记录查找

 return document ("Characters", "1966")

3.5、for语句

• 用for语句对文档内的所有文档进行遍历查询

for node in Characters return node

3.6、limit的使用

• limit关键词要放在return前面

for node in Characters limit 1 return node

• 还可以使用LIMIT来跳过一定数量的记录返回下一个n个文档：

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

3.7、filter的使用

• filter作为aql语句中的筛选条件，和sql相同，放在句中

for  node in Characters  filter  node.name == "Ned" return node
for node in Characters  filter  node.name =~"Ned" return node

• 当查询一条记录（一个节点）的时候，可以有一个或者多个筛选条件，这是可以用多个filter进行过滤

for node in Characters  filter node._key=="2053" filter node.name=="Ned1" return node

• 也可以根据需要用and、or进行连接

for node in Characters filter node.name =="Ned1" and node._key =="2053" return node

• 范围查询

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

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

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

3.8、排序语法

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

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

四、图查询

• 图查询是建立在collections中的节点文档（document）和关系文档（edge）之上。
• 一个图可以包含一个或多个节点文档和关系文档的组合。每一组关系文档需要声明起始节点所在文档和结束节点所在文档。

4.1、数据准备及生成图关系

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

• 新增单个图关系

孩子节点 --> 指向父节点
INSERT { _from: "Characters/9148", _to: "Characters/9139" } INTO ChildOf

4.2、查看关系图

FOR c IN ChildOf
    RETURN c

• 但发现关系图的顶点都是用id表示，不易看清楚，可以使用以下语句查看

FOR c IN ChildOf
	//CONCAT(c._from,DOCUMENT(c._from).name)
    RETURN {_key:c._key,_id:c._id,_from:DOCUMENT(c._from).name,_to:DOCUMENT(c._to).name,_rev:c._rev}

4.3、从孩子找父母

FOR c IN Characters
    FILTER c.name == "Bran"
	//1..1分别表示最小最大遍历深度，OUTBOUND表示沿着边的方向，INBOUND表示反方向
    FOR v IN 1..1 OUTBOUND c ChildOf
        RETURN v.name

[
  "Catelyn"
]

4.4、从父母找孩子

FOR c IN Characters
    FILTER c.name == "Catelyn"
    FOR v IN 1..1 INBOUND c ChildOf
        RETURN v.name
        
[
  "Robb",
  "Sansa",
  "Arya",
  "Bran"
]

4.5、爷爷找孙子

FOR c IN Characters
    FILTER c.name == "Tywin"
    FOR v IN 2..2 INBOUND c ChildOf
        RETURN v.name
        
--两条路径指向Joffrey
[
  "Joffrey",
  "Joffrey"
]

4.5、孙子找爷爷

FOR c IN Characters
    FILTER c.name == "Joffrey"
    FOR v IN 2..2 OUTBOUND c ChildOf
        RETURN v.name
        
--两条路径指向Tywin
[
  "Tywin",
  "Tywin"
]

--去重
FOR c IN Characters
    FILTER c.name == "Joffrey"
    FOR v IN 2..2 OUTBOUND c ChildOf
        RETURN DISTINCT  v.name
[
  "Tywin"
]

五、地理位置

5.1、数据准备

• 新建collection -Locations(doocument)

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

5.2、发现附近的坐标

• 位置最近的三个坐标

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
  }

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

5.3、查找半径内的位置

• 200 公里 范围内

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)
  }

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

六、嵌入特征

6.1、数据准备

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

6.2、解决特征

• 仅返回每个字符的特征属性

FOR c IN Characters
    RETURN c.traits

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

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

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

• 只使用数组扩展表示法返回英文标签

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

[
  [
    "strong",
    "powerful",
    "loyal"
  ],
  [
    "strong",
    "experienced",
    "polite"
  ],
  [
    "beautiful",
    "powerful",
    "loyal"
  ],
  ...
 ]

• 合并角色和特征
• 我们将字母解析为有意义的特征！但我们也需要知道他们属于哪个角色。因此，我们需要合并字符文档和特征文档中的数据

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

[
  {
    "_id": "Characters/9137",
    "_key": "9137",
    "_rev": "_duXChra---",
    "alive": false,
    "name": "Robert",
    "surname": "Baratheon",
    "traits": [
      "strong",
      "powerful",
      "loyal"
    ]
  },
  {
    "_id": "Characters/9138",
    "_key": "9138",
    "_rev": "_duXChra--_",
    "age": 36,
    "alive": true,
    "name": "Jaime",
    "surname": "Lannister",
    "traits": [
      "strong",
      "experienced",
      "polite"
    ]
  },
  ...
 ]

七、高级语法

运算符

	AND, &&（连词）
	OR, ||(析取)
	NOT, !（否定/反转）

	==（平等的）
	<=（小于或等于）
	>=（大于或等于）
	<（少于）
	>（比...更棒）
	!=（不等）
	IN（包含在数组或范围中），也NOT IN
	LIKE

for

• 有两个数组迭代：对数组的外部迭代 Characters加上对数组的内部迭代Locations

FOR u IN Characters
  FOR l IN Locations
    RETURN { "Characters" : u, "location" : l }

u1 i1
u2 i1
u3 i1

u1 i2
u2 i2
u3 i2

u1 i3
u2 i3
u3 i3

return

//返回完整文档
FOR u IN users
  RETURN u
  
//返回每个文档的一个属性
FOR u IN users
  RETURN u.name

//返回多个属性,可以这样构造一个对象
FOR u IN users
  RETURN { name: u.name, age: u.age }
  
//还支持动态属性名称
FOR u IN users
  RETURN { [ u._id ]: u.age }

FILTER

FOR u IN users
  FILTER u.active == true && u.age < 39
  RETURN u

FOR u IN users
  FILTER u.active == true
  FILTER u.age < 39
  RETURN u
  
FOR u IN users
  FILTER u.active == true
  LIMIT 5
  RETURN u
  
FOR u IN users
  FILTER u.active == true
  LIMIT 5
  FILTER u.gender == "f"
  RETURN u

FOR u IN users
  FILTER u.active == true
  SORT u.age ASC
  LIMIT 5
  FILTER u.gender == "f"
  RETURN u
  
FOR u IN users
  FILTER u.active == true AND u.gender == "f"
  SORT u.age ASC
  LIMIT 5
  RETURN u

SORT

FOR u IN users
  SORT u.lastName, u.firstName, u.id DESC
  RETURN u

LIMIT

FOR u IN users
  LIMIT 5
  RETURN u
  
FOR u IN users
  SORT u.firstName, u.lastName, u.id DESC
  LIMIT 2, 5
  RETURN u

Let

• 变量在 AQL 中是不可变的，这意味着它们不能被重新分配
• 下面的例子中，推荐数量的计算是使用一个LET语句分解出来的，从而避免了在语句中计算两次值RETURN

	LET a = [1, 2, 3]  // initial assignment
	
	a = PUSH(a, 4)     // syntax error, unexpected identifier
	LET a = PUSH(a, 4) // parsing error, variable 'a' is assigned multiple times
	LET b = PUSH(a, 4) // allowed, result: [1, 2, 3, 4]

FOR u IN users
  LET numRecommendations = LENGTH(u.firstName)
  RETURN {
    "user" : u,
    "numRecommendations" : numRecommendations,
    "isPowerUser" : numRecommendations >= 10
  }

• 另一个用例LET是在子查询中声明一个复杂的计算，使整个查询更具可读性

	FOR u IN users
	  LET friends = (
	  FOR f IN friends 
	    FILTER u.id == f.userId
	    RETURN f
	  )
	  LET memberships = (
	  FOR m IN memberships
	    FILTER u.id == m.userId
	      RETURN m
	  )
	  RETURN { 
	    "user" : u, 
	    "friends" : friends, 
	    "numFriends" : LENGTH(friends), 
	    "memberShips" : memberships 
	  }

COLLECT

• 分组语法

FOR u IN users
  COLLECT city = u.city
  RETURN { 
    "city" : city 
  }

FOR u IN users
  COLLECT city = u.city INTO groups
  RETURN { 
    "city" : city, 
    "usersInCity" : groups 
  }

• 按city分组

[
  {
    "city": null,
    "usersInCity": [
      {
        "u": {
          "_key": "27676",
          "_id": "users/27676",
          "_rev": "_dw4b6qG---",
          "firstName": "Anna",
          "name": "Pavlova",
          "profession": "artist"
        }
      },
      {
        "u": {
          "_key": "PhilCarpenter",
          "_id": "users/PhilCarpenter",
          "_rev": "_dw4cYWK---",
          "firstName": "Phil",
          "name": "Carpenter",
          "middleName": "G.",
          "status": "inactive"
        }
      },
      {
        "u": {
          "_key": "NatachaDeclerck",
          "_id": "users/NatachaDeclerck",
          "_rev": "_dw4cw0q---",
          "firstName": "Natacha",
          "name": "Declerck",
          "location": "Antwerp"
        }
      }
    ]
  },
  {
    "city": "Fortalezza",
    "usersInCity": [
      {
        "u": {
          "_key": "GilbertoGil",
          "_id": "users/GilbertoGil",
          "_rev": "_dw4cMf2---",
          "firstName": "Gilberto",
          "name": "Gil",
          "city": "Fortalezza"
        }
      }
    ]
  }
]

• 按领这个字段分组

FOR u IN users
  COLLECT country = u.country, city = u.city INTO groups
  RETURN { 
    "country" : country, 
    "city" : city, 
    "usersInCity" : groups 
  }

[
  {
    "country": null,
    "city": null,
    "usersInCity": [
      {
        "u": {
          "_key": "27676",
          "_id": "users/27676",
          "_rev": "_dw4b6qG---",
          "firstName": "Anna",
          "name": "Pavlova",
          "profession": "artist"
        }
      },
      {
        "u": {
          "_key": "PhilCarpenter",
          "_id": "users/PhilCarpenter",
          "_rev": "_dw4cYWK---",
          "firstName": "Phil",
          "name": "Carpenter",
          "middleName": "G.",
          "status": "inactive"
        }
      },
      {
        "u": {
          "_key": "NatachaDeclerck",
          "_id": "users/NatachaDeclerck",
          "_rev": "_dw4cw0q---",
          "firstName": "Natacha",
          "name": "Declerck",
          "location": "Antwerp"
        }
      }
    ]
  },
  {
    "country": null,
    "city": "Fortalezza",
    "usersInCity": [
      {
        "u": {
          "_key": "GilbertoGil",
          "_id": "users/GilbertoGil",
          "_rev": "_dw4cMf2---",
          "firstName": "Gilberto",
          "name": "Gil",
          "city": "Fortalezza"
        }
      }
    ]
  }
]

FOR u IN users
  COLLECT country = u.country, city = u.city INTO groups = u.name
  RETURN { 
    "country" : country, 
    "city" : city, 
    "userNames" : groups 
  }
 -------------------------
[
  {
    "country": null,
    "city": null,
    "userNames": [
      "Pavlova",
      "Carpenter",
      "Declerck"
    ]
  },
  {
    "country": null,
    "city": "Fortalezza",
    "userNames": [
      "Gil"
    ]
  }
]

FOR u IN users
  COLLECT country = u.country, city = u.city INTO groups = { 
    "name" : u.name, 
    "isActive" : u.status == "active"
  }
  RETURN { 
    "country" : country, 
    "city" : city, 
    "usersInCity" : groups 
  }
//
[
  {
    "country": null,
    "city": null,
    "usersInCity": [
      {
        "name": "Pavlova",
        "isActive": false
      },
      {
        "name": "Carpenter",
        "isActive": false
      },
      {
        "name": "Declerck",
        "isActive": false
      }
    ]
  },
  {
    "country": null,
    "city": "Fortalezza",
    "usersInCity": [
      {
        "name": "Gil",
        "isActive": false
      }
    ]
  }
]

组长计算

FOR u IN users
  COLLECT WITH COUNT INTO length
  RETURN length

[
  4
]

//等价
RETURN LENGTH(users)

REMOVE

FOR u IN users
  REMOVE { _key: u._key } IN users