Nebula基础的查询操作介绍

news/2024/7/7 20:35:14

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;

返回结果

V2count
(“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;

返回结果

V2count
(“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;

返回结果

v1v2
(“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).nameproperties(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_nameend_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;

输出结果

srcdstage
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_typeEdge 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 typeSHOW {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语句显示当前图空间内的所有 TagSHOW TAGS
SHOW EDGESSHOW EDGES语句显示当前图空间内的所有 Edge typeSHOW 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

http://lihuaxi.xjx100.cn/news/1475331.html

相关文章

CTFshow 限时活动 红包挑战9 详细题解

CTFshow 限时活动 红包挑战9 详细题解

CTFshow红包挑战9 题目源码开源了。源码如下&#xff1a; common.php <?phpclass user{public $id;public $username;private $password;public function __toString(){return $this->username;}}class cookie_helper{private $secret "*************"; /…
阅读更多...
html5提供的FileReader是一种异步文件读取文件中的数据

html5提供的FileReader是一种异步文件读取文件中的数据

前言&#xff1a;FileReader是一种异步文件读取机制&#xff0c;结合input:file可以很方便的读取本地文件。 input:file 在介绍FileReader之前&#xff0c;先简单介绍input的file类型。 <input type"file" id"file"> input的file类型会渲染为一个按…
阅读更多...
C++ 网络编程项目fastDFS分布式文件系统（六）--qt(client)+login

C++ 网络编程项目fastDFS分布式文件系统（六）--qt(client)+login

目录 1. 登录和注册协议 1.1 注册协议 1.2 登录协议 2. 单例模式 1. 登录和注册协议 1.1 注册协议 # URL http://192.168.1.100:80/reg # post数据格式 { userName:xxxx, nickName:xxx, firstPwd:xxx, phone:xxx, email:xxx } 2. 服务器端 - Nginx 服务器端的配置。 loc…
阅读更多...
【开发】tips：视频汇聚/视频云存储/视频监控管理平台EasyCVR如何提升网络稳定

【开发】tips：视频汇聚/视频云存储/视频监控管理平台EasyCVR如何提升网络稳定

安防视频监控/视频集中存储/云存储/磁盘阵列EasyCVR平台可拓展性强、视频能力灵活、部署轻快&#xff0c;可支持的主流标准协议有国标GB28181、RTSP/Onvif、RTMP等&#xff0c;以及支持厂家私有协议与SDK接入&#xff0c;包括海康Ehome、海大宇等设备的SDK等。平台既具备传统安…
阅读更多...
前端面试：【前端工程化】自动化测试工具 Jest、Mocha 和 Cypress

前端面试：【前端工程化】自动化测试工具 Jest、Mocha 和 Cypress

嗨&#xff0c;亲爱的前端开发者&#xff01;在构建高质量的前端应用程序时&#xff0c;自动化测试是不可或缺的一部分。本文将深入探讨三个流行的前端自动化测试工具&#xff1a;Jest、Mocha 和 Cypress&#xff0c;以帮助你了解它们的用途、特点以及如何选择适合你项目的测试…
阅读更多...
开始MySQL探索——数据库概述

开始MySQL探索——数据库概述

计算机语言 计算机语言概述 计算机语言&#xff08;Computer Language&#xff09;可以简单的理解为一种计算机和人都能识别的语言。 机器语言 汇编语言 高级语言 机器语言 汇编语言 高级语言 SQL语言基础 SQL的概述 SQL全称&#xff1a;Structured Query Language&…
阅读更多...
储能运行约束的Matlab建模方法

储能运行约束的Matlab建模方法

最近一段时间有很多人问我最优潮流计算中储能系统的建模方法。部分朋友的问题我回复了&#xff0c;有些没有回消息的&#xff0c;我就不再一一回复了&#xff0c;在这里我写一篇博客统一介绍一下。 1.储能系统介绍 首先&#xff0c;让【GPT】简单介绍一下储能系统&#xff1a;…
阅读更多...
Linux学习之vsftpd配置文件

Linux学习之vsftpd配置文件

/etc/vsftpd/vsftpd.conf是主要的vsftpd配置文件&#xff0c;主要涉及大的调整&#xff0c;cat /etc/vsftpd/vsftpd.conf | wc -l可以看到有128行内容。 /etc/vsftpd/ftpusers是禁止用户名单&#xff0c;/etc/vsftpd/user_list可以是白名单&#xff0c;也可以是黑名单。 /et…
阅读更多...
最新文章

Copyright @ 2022~2023