Nebula基础的查询操作介绍

Nebula基础的查询操作介绍

这里只是对Nebula基础查询进行介绍，其目的是为了让未接触过Nebula的同学最短时间了解其语句。更详细更准确的内可以查看官方文档。 docs.nebula-graph

关于查询这里并没有使用官方例子数据，而是自己实际尝试了文档中的语句。

其他内容

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;

返回结果

V2	count
(“8” :Person{age: 33, name: “小花”, type: “员工”})	1
(“9” :Person{age: 28, name: “大海”, type: “员工”})	2
(“10” :Person{age: 22, name: “小雨”, type: “员工”})	3

多个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;

返回结果

V2	count
(“3” :Person{age: 28, name: “王五”, type: “员工”})	1
(“12” :Person{age: 35, name: “小杨”, type: “领导”})	1
(“6” :Person{age: 22, name: “小红”, type: “员工”})	1
(“17” :Employee{workingAge: 8} :Person{age: 45, name: “小静”, type: “领导”})	1
(“7” :Employee{workingAge: 2} :Person{age: 45, name: “小李”, type: “领导”})	2
(“15” :Person{age: 40, name: “小芳”, type: “领导”})	1
(“2” :Employee{workingAge: 4} :Person{age: 35, name: “李四”, type: “领导”})	1

匹配多个模式

用户可以用英文逗号（,）分隔多个模式。

# 匹配具有标签 "Person" 且属性 "type" 为 "领导" 的节点 "v1"，以及具有标签 "Employee" 且属性 "workingAge" 为 2 的节点 "v2"，然后返回这些节点。
MATCH (v1:Person{type:"领导"}), (v2:Employee{workingAge:2}) RETURN v1,v2;

返回结果

v1	v2
(“17” :Employee{workingAge: 8} :Person{age: 45, name: “小静”, type: “领导”})	(“7” :Employee{workingAge: 2} :Person{age: 45, name: “小李”, type: “领导”})
(“12” :Person{age: 35, name: “小杨”, type: “领导”})	(“7” :Employee{workingAge: 2} :Person{age: 45, name: “小李”, type: “领导”})
(“7” :Employee{workingAge: 2} :Person{age: 45, name: “小李”, type: “领导”})	(“7” :Employee{workingAge: 2} :Person{age: 45, name: “小李”, type: “领导”})
(“15” :Person{age: 40, name: “小芳”, type: “领导”})	(“7” :Employee{workingAge: 2} :Person{age: 45, name: “小李”, type: “领导”})
(“2” :Employee{workingAge: 4} :Person{age: 35, name: “李四”, type: “领导”})	(“7” :Employee{workingAge: 2} :Person{age: 45, name: “小李”, type: “领导”})
(“5” :Employee{workingAge: 10} :Person{age: 40, name: “小明”, type: “领导”})	(“7” :Employee{workingAge: 2} :Person{age: 45, name: “小李”, type: “领导”})

LOOKUP

1. 检索指定 Tag 的所有点 ID。
2. 检索指定 Edge type 的所有边的起始点、目的点和 rank。
3. 统计包含指定 Tag 的点或属于指定 Edge type 的边的数量。
4. 根据 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>] ...];

参数说明

参数	说明
WHERE	指定遍历的过滤条件，还可以结合布尔运算符 AND 和 OR 一起使用。详情请参见 WHERE。
YIELD	定义需要返回的输出。详情请参见 YIELD。
AS	设置别名。
clause	支持 ORDER BY、LIMIT 子句。

查询点信息

于标签（TAG）的属性进行过滤

# 在 "Person" 类型节点中查找具有 "name" 属性为 "张三" 的节点，并返回这些节点的 ID。
LOOKUP ON Person WHERE Person.name == "张三" YIELD id(vertex);

返回数据

id(VERTEX)
1

基于标签（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;

返回数据

properties(VERTEX).name	properties(VERTEX).age
小杨	35
李四	35

检索边

基于边的条件进行过滤，并返回边信息

# 查找具有 "year" 属性为 3 的 "FRIEND" 类型边，并返回这些边。
LOOKUP ON FRIEND WHERE FRIEND.year == 3 YIELD edge AS e;

返回数据

e
[:FRIEND “2”->“3” @0 {year: 3}]
[:FRIEND “3”->“4” @0 {year: 3}]

基于边的条件进行过滤，并返回边信息的属性

# 查找具有 "year" 属性为 3 的 "FRIEND" 类型边，并返回这些边的 "year" 属性。
LOOKUP ON FRIEND WHERE FRIEND.year == 3  YIELD properties(edge).year;

返回数据

properties(EDGE).year
3
3

查询包含某种边的点信息

# 查找所有 "Person" 类型节点，并返回这些节点的 ID，然后限制结果返回前 4 条。
LOOKUP ON Person YIELD id(vertex) | LIMIT 4;

返回数据

id(VERTEX)
12
17
5
3

统计点和边的数量

#  查找所有 "Person" 类型节点，返回这些节点的 ID，并计算节点数目。
LOOKUP ON Person YIELD id(vertex)| YIELD COUNT(*) AS Person_Number;

返回数据

Person_Number
20

# 查找所有 "FRIEND" 类型边，返回这些边，并计算边的数目。
LOOKUP ON FRIEND YIELD edge AS e| YIELD COUNT(*) AS Follow_Number;

返回数据

Follow_Number
11

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

参数说明

参数	说明
<N> STEPS	指定跳数。如果没有指定跳数，默认值 N 为 1。
M TO N STEPS	遍历 M~N 跳的边。如果 M 为 0，输出结果和 M 为 1 相同。
<vertex_list>	用逗号分隔的点 ID 列表，或特殊的引用符 $-.id。
<edge_type_list>	遍历的 Edge type 列表。
REVERSELY | BIDIRECT	默认情况下检索的是 <vertex_list> 的出边（正向），REVERSELY 表示反向，即检索入边；BIDIRECT 为双向，即检索正向和反向，通过返回 <edge_type>._type 字段判断方向，其正数为正向，负数为反向。
WHERE <conditions>	指定遍历的过滤条件。用户可以在起始点、目的点和边使用 WHERE 子句，还可以结合 AND、OR、NOT、XOR 一起使用。
YIELD [DISTINCT] <return_list>	定义需要返回的输出。当前支持 src(edge)、dst(edge)、type(edge) 等。
SAMPLE <sample_list>	用于在结果集中取样。
<limit_by_list_clause>	用于在遍历过程中逐步限制输出数量。
GROUP BY	根据指定属性的值将输出分组。
ORDER BY	指定输出结果的排序规则。
LIMIT [<offset>,] <number_rows>	限制输出结果的行数。详情参见 LIMIT。

匹配边

基于 ID 获取边信息

# 从节点 ID 为 "7" 出发，经过 "FRIEND" 类型边，返回目标节点。
GO FROM "7" OVER FRIEND YIELD dst(edge);

输出结果

dst(EDGE)
10
8
9

基于 ID 获取边信息和距离（2 步）获取边信息

# 从节点 ID 为 "7" 出发，经过 2 步的 "FRIEND" 类型边，返回目标节点。
GO 2 STEPS FROM "7" OVER FRIEND YIELD dst(edge);

输出结果

dst(EDGE)
10
9

结果去重

# 从节点 ID 为 "5" 和 "7" 出发，经过 "FRIEND" 类型边，返回不重复的起始节点的 "name" 属性。
GO FROM "5", "7" OVER FRIEND YIELD DISTINCT properties($^).name AS start_name;

输出结果

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;

输出结果

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

输出结果

src	dst	age
7	{“9”, “10”, “8”}	[22, 33, 28]
5	{“6”}	[22]

IS NOT EMPTY

# 从节点 ID 为 "5" 出发，经过 "SUBORDINATE" 类型边，如果目标节点的 "name" 属性不为空，返回目标节点的边。
GO FROM "5" OVER SUBORDINATE WHERE properties($$).name IS NOT EMPTY YIELD dst(edge);

输出结果

dst(edge)
17
2

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

参数说明

参数	说明
edge_type	Edge type 名称。
src_vid	起始点 ID，表示边的起点。
dst_vid	目的点 ID，表示边的终点。
rank	边的 rank。可选参数，默认值为0。起始点、目的点、Edge type 和 rank 可以唯一确定一条边。
YIELD	定义需要返回的输出。详情请参见 YIELD。

获取边的属性值

# 获取从节点 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);

返回结果

properties(EDGE)
{year: 9}
{year: 2}
{year: 8}

SHOW

显示相关源数据信息

命令	说明	示例
SHOW CHARSET	语句显示当前的字符集	SHOW CHARSET
SHOW COLLATION	语句显示当前的排序规则	SHOW COLLATION
SHOW CREATE SPACE	显示指定图空间的创建语句	SHOW CREATE SPACE <space_name>
SHOW CREATE TAG/EDGE	显示指定 Tag 的基本信息	SHOW CREATE {TAG <tag_name>
SHOW HOSTS	显示集群信息，包括端口、状态、leader、分片、版本等信息	SHOW HOSTS [GRAPH
SHOW INDEX STATUS	显示重建原生索引的作业状态	SHOW {TAG
SHOW INDEXES	列出当前图空间内的所有 Tag 和 Edge type	SHOW {TAG
SHOW PARTS	显示图空间中指定分片或所有分片的信息	SHOW PARTS [<part_id>]
SHOW ROLES	显示分配给用户的角色信息	SHOW ROLES IN <space_name>
SHOW SNAPSHOTS	语句显示所有快照信息	SHOW SNAPSHOTS
SHOW SPACES	显示现存的图空间	SHOW SPACES
SHOW STATS	显示最近一次SUBMIT JOB STATS作业收集的图空间统计信息	SHOW STATS
SHOW TAGS	语句显示当前图空间内的所有 Tag	SHOW TAGS
SHOW EDGES	SHOW EDGES语句显示当前图空间内的所有 Edge type	SHOW EDGES
SHOW USERS	显示用户信息	SHOW USERS;
SHOW SESSIONS	用户可以查询会话信息	SHOW [LOCAL] SESSIONS;SHOW SESSION <Session_Id>
SHOW QUERIES	查看当前 Session 中正在执行的查询请求信息	SHOW [LOCAL] QUERIES
SHOW META LEADER	当前 Meta 集群的 leader 信息	SHOW META LEADER