AQL 学习笔记

2023.03.07 后端 5 评

AQL 基本语法&用法

发表于 2019-07-01 | 分类于编程 | 浏览 121次

字数统计 3,062 | 阅读时长 15

ArangoDB查询语言（AQL）类似于结构化查询语言（SQL）在它的目的。两者都支持读取和修改集合数据，但AQL不支持数据定义操作，例如创建和删除数据库，集合和索引。

虽然有些关键字重叠，但AQL语法与SQL不同。例如，SQL WHERE和AQL FILTER子句是等效的，因为它们都定义了返回结果的条件。但是，SQL使用预定义的序列来确定WHERE语句必须在哪里出现。在AQL中，子句从左到右执行，因此FILTER查询中子句的位置决定了它的优先级。

尽管有这些差异，任何具有SQL背景的人都应该没有学习AQL的困难。

一、数据预览

本次使用的数据共有43条，每条数据包含姓氏、年龄、活动状态和特征等六个字段

其中每个特征都有一个随机字母作为文档密钥。特质标签有英文和德文。

地点由地名和经纬度组成：

二、基本的CRUD

创建集合：

在创建文档之前，需要创造一个放置它的集合，集合可以通过Web界面，arangosh或驱动程序来创建。AQL无法创建集合。

单击Web界面中的COLLECTIONS，然后单击Add Collection并键入 Charactersname。使用保存确认。新集合就出现在了列表中。

插入单个对象：

使用AQL插入文档

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

语法：

INSERT document INTO collectionName

该文档是一个对象，由属性键和值对组成。属性键的引号在AQL中是可选的。键总是字符串，而属性值可以有不同的类型：

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

批量插入对象：

AQL不允许INSERT在单个查询中针对同一集合的多个操作。但是可以使用FOR循环体，插入多个文档。

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 variableName = valueExpression

LET关键字定义了同名称的变量数据和对象值的数列，格式为[ {...}, {...}, ... ]

FOR variableName IN expression

用于迭代数据数组的每个元素。在每个循环中，将一个元素分配给变量d。然后在INSERT语句中使用此变量。相当于下面的格式：

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

...

检索

检索集合中的所有文档：

FOR c IN Characters
    RETURN c

语法：

FOR variableName IN collectionName

对于集合中的每个文档，依次分配给变量c，然后根据循环体返回该文档。

选取其中一个文档如下：

{
   "_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，只读

检索特定文档：

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

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

语法：

DOCUMENT()

使用_key或_id检索特定文档，该函数还允许一次获取多个文档

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

更新文档：

修改现有文件：

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

删除文件：

语法：

REMOVE _key IN Collectiosname

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

REMOVE "2861650" IN Characters

三、匹配文件

语法：

FILTER

查找满足比_key相等更复杂的条件的文档，能够为要匹配的文档制定任意条件。

等于条件：

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

过滤条件如下：“ 字符文档的属性name必须等于字符串Ned ”。如果条件适用，则返回字符文档。

范围条件：

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 }

//or

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

替代条件：

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

四、排序和限制

限制语法：

LIMIT()

LIMIT后面跟着一个最大显示数的数字,限制结果显示行数。

FOR c IN Characters
    LIMIT 5
    RETURN c.name

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

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

排序语法：

SORT()

DESC降序来反转排序顺序

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
    }

此处FILTER的作用是仅保留surname为非空记录

五、组合

语法：
MERGE()

MERGE()的功能是将对象组合在一起。因为使用了原始字符属性{ traits: … }，所以后者被合并覆盖。

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

六、图操作

创建图：

语法：

INSERT { _from: _id(A), _to: _id(B) } INTO 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(                                    //FIRST()提取第一个元素
        FOR c IN Characters
            FILTER c.name == rel.parent.name                    //筛选条件
            FILTER c.surname == rel.parent.surname
            LIMIT 1
            RETURN c._id                                                 //返回_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                        //剔除_id都为空的记录
    INSERT { _from: childId, _to: parentId } INTO ChildOf       //将数据插入边集合
    RETURN NEW                                                                   //返回数据

也可以直接创建边数据：

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

遍历图：

语法：

FOR v IN 1..1 OUTBOUND _id ChildOf

    RETURN v.name

其中1..1为遍历深度

实例：

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

[
  "Ned",
  "Catelyn"
]

遍历的情况如下图：

若是反向遍历，则需要使用到INBOUND关键字：

FOR c IN Characters
    FILTER c.name == "Tywin"
    FOR v IN 2..2 INBOUND c ChildOf
        RETURN DISTINCT v.name
输出：

[
  "Joffrey"
]

遍历情况如下：

需要注意的是，“1..1”限制了遍历深度为1，“2..2”限制了遍历深度为2，而”1..2”限制遍历深度既可以为1也可以为2。

七、地理空间查询

地点数据

创建地点集合：

录入地点数据：

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

设置地理空间索引：

在COLLECTIONS界面，添加新的Indexes，设置为coordinate字段：

n10.png

查找附近的位置

语法：

NEAR()

找到最接近的坐标参考点

FOR loc IN NEAR(Locations, 53.35, -6.26, 3)
    RETURN {
        name: loc.name,
        latitude: loc.coordinate[0],
        longitude: loc.coordinate[1]
    }

输出：

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

查找半径内的位置

语法：

WITHIN()

从参考点搜索给定半径内的位置

FOR loc IN WITHIN(Locations, 53.35, -6.26, 200 * 1000)
    RETURN {
        name: loc.name,
        latitude: loc.coordinate[0],
        longitude: loc.coordinate[1]
    }

输出

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

按距离查找位置：

语法：

NEAR()或WITHIN()

通过添加一个可选的第五个参数返回到参考点的距离。必须是一个字符串：

FOR loc IN NEAR(Locations, 53.35, -6.26, 3, "distance")
    RETURN {
        name: loc.name,
        latitude: loc.coordinate[0],
        longitude: loc.coordinate[1],
        distance: loc.distance / 1000
    }

输出：

[
  {
    "name": "Vaes Dothrak",
    "latitude": 54.16776,
    "longitude": -6.096125,
    "distance": 91.56658640314431
  },
  {
    "name": "Winterfell",
    "latitude": 54.368321,
    "longitude": -5.581312,
    "distance": 121.66399816395028
  },
  {
    "name": "Dragonstone",
    "latitude": 55.167801,
    "longitude": -6.815096,
    "distance": 205.31879386198324
  }
]

使用AQL遇到的问题：

问题1：如何对查询结果进行计数并返回？

解决方法：

RETURN COUNT(FOR v IN visitors FILTER v.ip == "127.0.0.1" RETURN 1)

图的定义

图(Graph)由顶点和边组成。
同样，一个边缘集合中的边缘可能指向多个顶点集合。 edge 具有方向 ， _from and _to 之间就存在着一种方向性。在查询中，您可以定义边缘关系的方向（OUTBOUND：_from→ _to， INBOUND ：_from← _to，ANY ：_from↔ _to）。

⬇️ 注意：

OUTBOUND - 实际方向
INBOUND - 相反方向
ANY - 任意方向

遍历

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

图的建立

比如父母和孩子之间有以下关系:

创建Documents(Characters)

点此复制数据进行增加

创建Edges(ChildOf)

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

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

然后运行以下查询：
点此复制数据

LET data = [
    {
        "parent": { "name": "Ned", "surname": "Stark" },
        "child": { "name": "Robb", "surname": "Stark" }
    }, {
        "parent": { "name": "Ned", "surname": "Stark" },
        "child": { "name": "Sansa", "surname": "Stark" }
    }
    //code...
]
//核心代码：
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
1234567891011121314151617181920212223242526272829

🏷️ 注意点：

FIRST() 从数据中取第一个元素.
NEW/ OLD ，NEW表示 更改后 的document，OLD表示 更改之前 的document.
字符文档没有用户定义的键。如果有的话，它将使我们能够更轻松地创建边缘，例如：INSERT { _from: "Characters/robb", _to: "Characters/ned" } INTO ChildOf

但是，上述代码是基于角色名称以编程方式创建边缘。

以 对象数组 的形式将关系分配给父变量和子属性，每个子属性分别具有子属性name和surname，并将它们分配给变量data
```
将表达式的结果分配给变量 parentId
```
- 应用两个 过滤条件：字符文档中的名称必须等于中的父名称rel，并且姓氏也必须等于关系数据中给出的姓氏
- 返回字符文档的 ID（子查询的结果是一个包含一个元素的数组，FIRST()将该元素取并将其分配给parentId变量）
```
将表达式的结果分配给变量 childId
```
- 子查询用于查找子字符文档，并以与父文档ID相同的方式返回ID
如果两个子查询中的一个或两个都找不到匹配项，请跳过当前关系，因为创建一条边的两端需要两个ID
返回新的边缘文档（可选）

我们完成了关系的建立，尝试从关系中获取数据

查看关系图

FOR c IN ChildOf
    RETURN c
12

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

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

遍历父母

现在，边链接了字符文档（顶点），我们可以查询一个图以找出谁是另一个字符的父级，我们要从一个顶点开始，然后沿着边到达AQL中的其他顶点图遍历：

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

在上面的查询中，遍历被限制为 最小和最大遍历 深度1（从起始顶点开始要走多少步），并且只能沿OUTBOUND方向沿边。我们的优势是从孩子到父母，而父母离孩子只有一步之遥，因此它使我们成为了孩子的父母。"Characters/2901776"是 起始顶点。

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

还可以将此查询与遍历直接结合使用，以通过修改过滤条件更改起始顶点：

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

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

[
  "Ned",
  "Catelyn"
]
1234

遍历孩子

我们还可以从父母的相反方向（INBOUND）找到孩子：

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

结果：

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

遍历孙子

对于Lannister家族，我们的关系从父母到孙子都有。让我们更改遍历深度以返回孙辈，这意味着要走两步：

FOR c IN Characters
    FILTER c.name == "Tywin"
    FOR v IN 2..2 INBOUND c ChildOf
        RETURN v.name
1234
[
  "Joffrey",
  "Joffrey"
]
1234

深度可变

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

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

结果：

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

5 评论

jazgplznniSogo BrowserWindows 10

10月7日回复

2025年10月新盘做第一批吃螃蟹的人coinsrore.com
新车新盘嘎嘎稳嘎嘎靠谱coinsrore.com
新车首发，新的一年，只带想赚米的人coinsrore.com
新盘上车集合留下我要发发立马进裙coinsrore.com
做了几十年的项目我总结了最好的一个盘（纯干货）coinsrore.com
新车上路，只带前10个人coinsrore.com
新盘首开新盘首开征召客户！！！coinsrore.com
新项目准备上线，寻找志同道合的合作伙伴coinsrore.com
新车即将上线真正的项目，期待你的参与coinsrore.com
新盘新项目，不再等待，现在就是最佳上车机会！coinsrore.com
新盘新盘这个月刚上新盘新车第一个吃螃蟹！coinsrore.com

sbrzgovmvjSogo BrowserWindows 10

鍗庣撼鍏徃鍚堜綔寮€鎴锋墍闇€鏉愭枡锛熺數璇濆彿鐮?5587291507 寰俊STS5099Sogo BrowserWindows 10

11月2日回复

华纳东方明珠客服电话是多少？（▲18288362750?《?微信STS5099? 】
如何联系华纳东方明珠客服？（▲18288362750?《?微信STS5099? 】
华纳东方明珠官方客服联系方式？（▲18288362750?《?微信STS5099?
华纳东方明珠客服热线？（▲18288362750?《?微信STS5099?
华纳东方明珠24小时客服电话？（▲18288362750?《?微信STS5099? 】
华纳东方明珠官方客服在线咨询？（▲18288362750?《?微信STS5099?

11月7日回复

华纳万宝路客服电话是多少？（?183-8890-9465—《?薇-STS5099】【?扣6011643??】
华纳万宝路开户专线联系方式？（?183-8890--9465—《?薇-STS5099】【?扣6011643??】
华纳圣淘沙客服开户电话全攻略，让娱乐更顺畅！（?183-8890--9465—《?薇-STS5099】客服开户流程，华纳圣淘沙客服开户流程图（?183-8890--9465—《?薇-STS5099】

11月17日回复

华纳圣淘沙开户步骤详解（183-8890-9465—?薇-STS5099【6011643】

华纳圣淘沙公司开户流程全解析（183-8890-9465—?薇-STS5099【6011643】
华纳圣淘沙公司账户注册指南（183-8890-9465—?薇-STS5099【6011643】
新手如何开通华纳圣淘沙公司账户（183-8890-9465—?薇-STS5099【6011643】
华纳圣淘沙企业开户标准流程（183-8890-9465—?薇-STS5099【6011643】
华纳圣淘沙公司开户：从零到一（183-8890-9465—?薇-STS5099【6011643】
官方指南：华纳圣淘沙公司开户流程（183-8890-9465—?薇-STS5099【6011643】
华纳圣淘沙公司开户流程说明书（183-8890-9465—?薇-STS5099【6011643】

Hello World

Your description here.