Nebula基础的查询操作介绍
关于查询这里并没有使用官方例子数据，而是自己实际尝试了文档中的语句。
其他内容
数据准备
创建标签
CREATE TAG Person(name string, age int, type string);
CREATE TAG Employee(workingAge int);
创建边类型
CREATE EDGE FRIEND(year int);
CREATE EDGE SUBORDINATE();
创建带标签的点
INSERT VERTEX Person(name, age, type) VALUES
"5":("小明", 40, "领导"),
"17":("小静", 45, "领导"),
... （省略其他插入语句）
插入SUBORDINATE边类型
INSERT EDGE SUBORDINATE() VALUES "7"->"1"@0:(), "7"->"3"@0:(), "7"->"4"@0:(), "7"->"6"@0:(), "7"->"8"@0:() ;
... （省略其他插入语句）
插入FRIEND边类型
INSERT EDGE FRIEND(year) VALUES
"1"->"2"@0:( 5),
"2"->"3"@0:( 3),
"3"->"4"@0:( 3),
... （省略其他插入语句）
创建索引
CREATE TAG INDEX Person_index on Person();
CREATE TAG INDEX Employee_index on Employee();
CREATE TAG INDEX Person_index_1 on Person(name(10), age, type(10));
CREATE TAG INDEX Employee_index_1 on Employee(workingAge);
CREATE EDGE INDEX FRIEND_index on FRIEND(year);
CREATE EDGE INDEX SUBORDINATE_index on SUBORDINATE();
重建索引数据
REBUILD TAG INDEX Person_index,Employee_index;
REBUILD TAG INDEX Employee_index_1,Person_index_1;
REBUILD EDGE INDEX FRIEND_index,SUBORDINATE_index;
确定重建状态
SHOW TAG INDEX STATUS;
一些变量说明
起始点
$^.<tag_name>.<prop_name>
$^: 表示起始点。<tag_name>: 表示点的 Tag 名称。<prop_name>: 表示 Tag 内的属性名称。
目的点
$$.<tag_name>.<prop_name>
$$: 表示目的点。<tag_name>: 表示点的 Tag 名称。<prop_name>: 表示 Tag 内的属性名称。
查询语句 - MATCH
MATCH语句提供基于模式（Pattern）匹配的搜索功能。在进行查询时，MATCH语句使用的路径类型是trail，这意味着点可以重复出现，但边不能重复。
需要注意，我这里使用的是3.0.0版本。在EDGE和TAG操作中需要创建索引
匹配点
匹配所有点
# 在数据库中匹配所有节点，然后返回前 5 个节点
MATCH (v) RETURN v LIMIT 5;
# 返回结果
("1" :Person{age: 30, name: "张三", type: "员工"})
("13" :Person{age: 28, name: "小丽", type: "员工"})
("16" :Person{age: 22, name: "小敏", type: "员工"})
("20" :Person{age: 22, name: "小明", type: "员工"})
("8" :Person{age: 33, name: "小花", type: "员工"})
匹配 Tag
匹配单个标签
# 在数据库中匹配具有 "Person" 标签的节点
MATCH (v:Person) RETURN v LIMIT 3;
# 返回结果
("1" :Person{age: 30, name: "张三", type: "员工"})
("13" :Person{age: 28, name: "小丽", type: "员工"})
("8" :Person{age: 33, name: "小花", type: "员工"})
匹配多个标签
# 在数据库中匹配同时具有 "Person" 和 "Employee" 标签的节点
MATCH (v:Person:Employee) RETURN v LIMIT 2;
# 返回结果
("2" :Employee{workingAge: 4} :Person{age: 35, name: "李四", type: "领导"})
("7" :Employee{workingAge: 2} :Person{age: 45, name: "小李", type: "领导"})
匹配点的属性
需要注意：
- NebulaGraph 3.0.0 之前，匹配 Tag 的前提是 Tag 本身有索引或者 Tag 的某个属性有索引。
- NebulaGraph 3.0.0 开始，匹配 Tag 可以不创建索引，但需要使用 LIMIT 限制输出结果数量。
- NebulaGraph 3.5.0 开始，MATCH 语句支持全表扫描，无需为 Tag 或 Tag 的某个属性创建索引，或者使用 LIMIT 限制输出结果数量，即可执行 MATCH 语句。
MATCH 匹配标签属性
# 在数据库中匹配具有 "Person" 标签且属性 "age" 为 35 的节点
MATCH (v:Person{age: 35}) RETURN v LIMIT 2;
# 返回结果
("12" :Person{age: 35, name: "小杨", type: "领导"})
("2" :Employee{workingAge: 4} :Person{age: 35, name: "李四", type: "领导"})
WHERE 匹配标签属性
#
MATCH (v:Person) WHERE v.Person.age == 35 RETURN v LIMIT 2;
# 返回结果
("2" :Employee{workingAge: 4} :Person{age: 35, name: "李四", type: "领导"})
("12" :Person{age: 35, name: "小杨", type: "领导"})
匹配点 ID
用户可以使用点 ID 去匹配点。id()函数可以检索点的 ID。
#
MATCH (v) WHERE id(v) == '1' RETURN v;
# 返回结果
("1" :Person{age: 30, name: "张三", type: "员工"})
匹配多个ID
注意：你必须先指定 Tag/EdgeType，或者用 LIMIT 子句限制返回数量，才能获取对应类型的所有的点和边。
#
MATCH (v:Person) WHERE id(v) IN {'1','2'} RETURN v;
# 返回结果
("2" :Employee{workingAge: 4} :Person{age: 35, name: "李四", type: "领导"})
("1" :Person{age: 30, name: "张三", type: "员工"})
返回属性
#
MATCH (v:Person) WHERE id(v) IN {'1','2'} RETURN v.Person.name AS name;
# 返回结果
李四
张三
匹配连接的点
使用–符号表示两个方向的边
#
MATCH (v:Person{name:"小明"})--(v2:Person) RETURN v2.Person.name AS Name;
# 返回结果
小芳
李四
小静
赵六
小红
在–符号上增加<或>符号指定边的方向
#
MATCH (v:Person{name:"小明"})-->(v2:Person) RETURN v2.Person.name AS Name;
# 返回结果
李四
小红
小静
增加更多点和边
#
MATCH (v:Person{name:"小明"})-->(v2:Person)-->(v3) RETURN v3.player.name AS Name;
# 如果不需要引用点，可以省略括号中表示点的变量。
MATCH (v:Person{name:"小明"})-->()-->(v3) RETURN v3.player.name AS Name;
# 返回结果
小芳
小李
小李
王五
王五
小杨
匹配路径
查询点的边
#
MATCH p=(v:Person{name:"小明"})-->(v2) RETURN p;
# 返回结果
<("5" :Employee{workingAge: 10} :Person{age: 40, name: "小明", type: "领导"})-[:SUBORDINATE@0 {}]->("2" :Employee{workingAge: 4} :Person{age: 35, name: "李四", type: "领导"})>
<("5" :Employee{workingAge: 10} :Person{age: 40, name: "小明", type: "领导"})-[:FRIEND@0 {year: 6}]->("6" :Person{age: 22, name: "小红", type: "员工"})>
<("5" :Employee{workingAge: 10} :Person{age: 40, name: "小明", type: "领导"})-[:SUBORDINATE@0 {}]->("17" :Employee{workingAge: 8} :Person{age: 45, name: "小静", type: "领导"})>
查询存在的边
#
MATCH ()<-[e]-() RETURN e LIMIT 3;
# 返回结果
[:FRIEND "7"->"8" @0 {year: 2}]
[:SUBORDINATE "7"->"8" @0 {}]
[:SUBORDINATE "7"->"1" @0 {}]
根据类型查询存在的边
#
MATCH ()-[e:SUBORDINATE]->() RETURN e LIMIT 3;
# 返回结果
[:SUBORDINATE "17"->"7" @0 {}]
[:SUBORDINATE "17"->"15" @0 {}]
[:SUBORDINATE "5"->"2" @0 {}]
根据边的属性查询边
#
MATCH (v)-[e:FRIEND{year:3}]->(v2) WHERE id(v) == "2" RETURN e;
# 返回结果
[:FRIEND "2"->"3" @0 {year: 3}]
对点补充过滤
#
MATCH (v:Person{name:"李四"})-[e:FRIEND{year:3}]->(v2) RETURN e;
# 返回结果
[:FRIEND "2"->"3" @0 {year: 3}]
匹配多个类型的边
#
MATCH (v:Person{name:"小明"})-[e:SUBORDINATE|FRIEND]->(v2) RETURN e;
# 返回结果
[:FRIEND "5"->"6" @0 {year: 6}]
[:SUBORDINATE "5"->"17" @0 {}]
[:SUBORDINATE "5"->"2" @0 {}]
匹配多条边
用户可以扩展模式，匹配路径中的多条边。
#
MATCH (v:Person{name:"小明"})-[]->(v2)<-[e:FRIEND]-(v3) RETURN v2, v3;
匹配定长路径
使用<edge_type>*匹配定长路径。hop必须是一个非负整数。
#
MATCH (v:Person{name:"小明"})-[e:FRIEND*3]->(v2) RETURN DISTINCT v2;
# 返回结果
("8" :Person{age: 33, name: "小花", type: "员工"})
匹配变长路径
用户可以在模式中使用<edge_type>*[minHop…maxHop]匹配变长路径。
minHop 可选项。表示路径的最小长度。minHop必须是一个非负整数，默认值为 1。
maxHop 可选项。表示路径的最大长度。maxHop必须是一个非负整数，默认值为无穷大。
# 在数据库中匹配具有 "Person" 标签且属性 "name" 为 "小明" 的节点，以及从它们出发的类型为 "FRIEND" 的边，跳过 3 到 5 次后到达的节点，然后返回这些节点。
MATCH (v:Person{name:"小明"})-[e:FRIEND*3..5]->(v2) RETURN v2;
返回结果
("9" :Person{age: 28, name: "大海", type: "员工"})
("10" :Person
{age: 22, name: "小雨", type: "员工"})
("8" :Person{age: 33, name: "小花", type: "员工"})
("10" :Person{age: 22, name: "小雨", type: "员工"})
("9" :Person{age: 28, name: "大海", type: "员工"})
("10" :Person{age: 22, name: "小雨", type: "员工"})
用户可以使用DISTINCT关键字聚合重复结果。
# 从名为 "小明" 的 "Person" 类型节点出发，通过不定长度的 "FRIEND" 边（跳数在 3 到 5 范围内），到达的节点为 "v2"，返回不重复的 "v2" 节点及其出现的次数。
MATCH (v:Person{name:"小明"})-[e:FRIEND*3..5]->(v2) RETURN DISTINCT v2, COUNT(v2) AS count;
返回结果
多个Edge type设置路径
用户可以指定多个 Edge type 的 hop、minHop和maxHop，这些配置对所有 Edge type 都生效。
# 从名为 "小明" 的 "Person" 类型节点出发，通过不定长度的 "SUBORDINATE" 或 "FRIEND" 边（跳数在 1 到 2 范围内），到达的节点为 "v2"，返回不重复的 "v2" 节点及其出现的次数。
MATCH (v:Person{name:"小明"})-[e:SUBORDINATE|FRIEND*1..2]->(v2) RETURN DISTINCT v2, COUNT(v2) AS count;
返回结果
匹配多个模式
用户可以用英文逗号（,）分隔多个模式。
# 匹配具有标签 "Person" 且属性 "type" 为 "领导" 的节点 "v1"，以及具有标签 "Employee" 且属性 "workingAge" 为 2 的节点 "v2"，然后返回这些节点。
MATCH (v1:Person{type:"领导"}), (v2:Employee{workingAge:2}) RETURN v1,v2;
返回结果
LOOKUP
- 检索指定 Tag 的所有点 ID。
- 检索指定 Edge type 的所有边的起始点、目的点和 rank。
- 统计包含指定 Tag 的点或属于指定 Edge type 的边的数量。
- 根据 WHERE 搜索特定数据。
# 语法
LOOKUP ON {<vertex_tag> | <edge_type>}
[WHERE <expression> [AND <expression> ...]]
YIELD <return_list> [AS <alias>]
[<clause>];
# 返回结果
<return_list>
<prop_name> [AS <col_alias>] [, <prop_name> [AS <prop_alias>] ...];
参数说明
查询点信息
于标签（TAG）的属性进行过滤
# 在 "Person" 类型节点中查找具有 "name" 属性为 "张三" 的节点，并返回这些节点的 ID。
LOOKUP ON Person WHERE Person.name == "张三" YIELD id(vertex);
返回数据
基于标签（TAG）的多个进行过滤
# 在 "Person" 类型节点中查找具有 "type" 属性为 "领导" 且 "age" 属性为 35 或 28 的节点，并返回这些节点的 "name" 和 "age" 属性。
LOOKUP ON Person WHERE Person.type == "领导" AND Person.age IN [35,28] YIELD properties(vertex).name, properties(vertex).age;
返回数据
检索边
基于边的条件进行过滤，并返回边信息
# 查找具有 "year" 属性为 3 的 "FRIEND" 类型边，并返回这些边。
LOOKUP ON FRIEND WHERE FRIEND.year == 3 YIELD edge AS e;
返回数据
基于边的条件进行过滤，并返回边信息的属性
# 查找具有 "year" 属性为 3 的 "FRIEND" 类型边，并返回这些边的 "year" 属性。
LOOKUP ON FRIEND WHERE FRIEND.year == 3 YIELD properties(edge).year;
返回数据
查询包含某种边的点信息
# 查找所有 "Person" 类型节点，并返回这些节点的 ID，然后限制结果返回前 4 条。
LOOKUP ON Person YIELD id(vertex) | LIMIT 4;
返回数据
统计点和边的数量
# 查找所有 "Person" 类型节点，返回这些节点的 ID，并计算节点数目。
LOOKUP ON Person YIELD id(vertex)| YIELD COUNT(*) AS Person_Number;
返回数据
# 查找所有 "FRIEND" 类型边，返回这些边，并计算边的数目。
LOOKUP ON FRIEND YIELD edge AS e| YIELD COUNT(*) AS Follow_Number;
返回数据
GO
# 语法
GO [[<M> TO] <N> STEPS] FROM <vertex_list>
OVER <edge_type_list> [{REVERSELY | BIDIRECT}]
[WHERE <conditions>]
YIELD [DISTINCT] <return_list>
[{SAMPLE <sample_list> | <limit_by_list_clause>}]
[| GROUP BY {<col_name> | <expression> | <position>} YIELD <col_name>]
[| ORDER BY <expression> [{ASC | DESC}]]
[| LIMIT [<offset>,] <number_rows>];
# 结果
<vertex_list> ::=
<vid> [, <vid> ...]
<edge_type_list> ::=
<edge_type> [, <edge_type> ...]
| *
<return_list> ::=
<col_name> [AS <col_alias>] [, <col_name> [AS <col_alias>] ...]
参数说明
匹配边
基于 ID 获取边信息
# 从节点 ID 为 "7" 出发，经过 "FRIEND" 类型边，返回目标节点。
GO FROM "7" OVER FRIEND YIELD dst(edge);
输出结果
基于 ID 获取边信息和距离（2 步）获取边信息
# 从节点 ID 为 "7" 出发，经过 2 步的 "FRIEND" 类型边，返回目标节点。
GO 2 STEPS FROM "7" OVER FRIEND YIELD dst(edge);
输出结果
结果去重
# 从节点 ID 为 "5" 和 "7" 出发，经过 "FRIEND" 类型边，返回不重复的起始节点的 "name" 属性。
GO FROM "5", "7" OVER FRIEND YIELD DISTINCT properties($^).name AS start_name;
输出结果
点匹配
获取开始和处理节点属性
# 从节点 ID 为 "5" 和 "7" 出发，经过 "FRIEND" 类型边，返回不重复的起始节点的 "name" 属性和不重复的目标节点的 "name" 属性。
GO FROM "5", "7" OVER FRIEND YIELD DISTINCT properties($^).name AS start_name, properties($$).name AS end_name;
输出结果
结果分组
# 从节点 ID 为 "5" 和 "7" 出发，经过 "FRIEND" 类型边，获取边的源节点、目标节点和目标节点的 "age" 属性，然后按照源节点进行分组，返回源节点、目标节点集合和目标节点的 "age" 属性集合。
GO FROM "5", "7" OVER FRIEND YIELD src(edge) AS src, dst(edge) AS dst, properties($$).age AS age | GROUP BY $-.src YIELD $-.src AS src, collect_set($-.dst) AS dst, collect($-.age) AS age;
输出结果
IS NOT EMPTY
# 从节点 ID 为 "5" 出发，经过 "SUBORDINATE" 类型边，如果目标节点的 "name" 属性不为空，返回目标节点的边。
GO FROM "5" OVER SUBORDINATE WHERE properties($$).name IS NOT EMPTY YIELD dst(edge);
输出结果
FETCH
FETCH 可以获取指定点或边的属性值。
获取点的属性值
基于 ID 获取点的 TAG 信息。
# 获取节点 ID 为 "5" 的 "Person" 类型节点的属性信息。
FETCH PROP ON Person "5" YIELD properties(vertex);
返回结果
| properties(VERTEX) |
|----------------------------------------------------|
| {age: 40, name: "小明", type: "领导"} |
基于 ID 获取点的 TAG 信息的属性。
# 获取节点 ID 为 "5" 的 "Person" 类型节点的属性信息，并将其 "name" 属性命名为 "name"。
FETCH PROP ON Person "5" YIELD properties(vertex).name AS name;
返回结果
| name |
|------|
| 小明 |
基于多个 ID 获取点的 TAG 信息，使用英文逗号分隔。
# 获取节点 ID 分别为 "5", "6", "7" 的 "Person" 类型节点的属性信息。
FETCH PROP ON Person "5", "6", "7" YIELD properties(vertex);
返回结果
| properties(VERTEX) |
|----------------------------------------------------|
| {age: 22, name: "小红", type: "员工"} |
| {age: 40, name: "小明", type: "领导"} |
| {age: 45, name: "小李", type: "领导"} |
在 FETCH 语句中获取多个 Tag 值，使用英文逗号分隔。
# 获取具有 "Person" 或 "Employee" 标签的节点中，节点 ID 为 "5" 的节点的属性信息，并将其命名为 "v"。
FETCH PROP ON Person, Employee "5" YIELD vertex AS v;
返回结果
| v |
|--------------------------------------------------|
| ("5" :Person{age: 40, name: "小明", type: "领导"}) |
Tag过滤
查询多个 ID 的多个 Tag 值。
# 获取具有 "Person" 或 "Employee" 标签的节点中，节点 ID 分别为 "5", "6" 的节点的属性信息，并将其命名为 "v"。
FETCH PROP ON Person, Employee "5", "6" YIELD vertex AS v;
返回结果
| v |
|--------------------------------------------------|
| ("5" :Person{age: 40, name: "小明", type: "领导"}) |
| ("6" :Person{age: 22, name: "小红", type: "员工"}) |
在 FETCH 语句中使用 * 获取当前图空间所有标签里，点的属性值。
# 获取所有类型的节点中，节点 ID 分别为 "5", "6", "7" 的节点的属性信息，并将其命名为 "v"。
FETCH PROP ON * "5", "6", "7" YIELD vertex AS v;
返回结果
| v |
|--------------------------------------------------|
| ("6" :Person{age: 22, name: "小红", type: "员工"}) |
| ("5" :Person{age: 40, name: "小明", type: "领导"}) |
| ("7" :Person{age: 45, name: "小李", type: "领导"}) |
边匹配
语法
FETCH PROP ON <edge_type> <src_vid> -> <dst_vid>[@<rank>] [, <src_vid> -> <dst_vid> ...]
YIELD <output>;
参数说明
获取边的属性值
# 获取从节点 ID 为 "7" 到节点 ID 为 "10" 的 "FRIEND" 类型边的属性信息。
FETCH PROP ON FRIEND "7" -> "10" YIELD properties(edge);
返回结果
| properties(EDGE) |
|-------------------|
| {year: 9} |
获取点之间边的属性
# 获取从节点 ID 为 "7" 到节点 ID 为 "10" 的 "FRIEND" 类型边的 "year" 属性。
FETCH PROP ON FRIEND "7" -> "10" YIELD properties(edge).year;
返回结果
| properties(EDGE).year |
|------------------------|
| 9 |
获取多条边的属性值，模式之间用英文逗号（,）分隔。
# 获取从节点 ID 为 "7" 到节点 ID 为 "8", "9", "10" 的 "FRIEND" 类型边的属性信息。
FETCH PROP ON FRIEND "7" -> "8","7" -> "9","7" -> "10" YIELD properties(edge);
返回结果
| properties(EDGE) |
|-------------------|
| properties(EDGE) |
| {year: 2} |
| {year: 8} |
| {year: 9} |
基于 rank 获取属性值，
如果有多条边，起始点、目的点和 Edge type 都相同，可以通过指定 rank 获取正确的边属性值。
# 获取从节点 ID 为 "7" 到节点 ID 为 "8" 的 "FRIEND" 类型边的属性信息，并将其命名为 "e"。
FETCH PROP ON FRIEND "7" -> "8"@0 YIELD edge AS e;
返回结果
| e |
|-------------------------------------------|
| [:FRIEND "7"->"8" @0 {year: 2}] |
查询从某个点开始的边的信息
# 从节点 ID 为 "7" 出发，通过 "FRIEND" 类型边的 "src" 和 "dst" 属性，获取对应的边
GO FROM "7" OVER FRIEND YIELD src(edge) AS s, dst(edge) AS d | FETCH PROP ON FRIEND $-.s -> $-.d YIELD properties(edge);
返回结果
SHOW
显示相关源数据信息