Nebula基础的查询操作介绍

已于 2023-08-24 01:05:08 修改
阅读量2.4k 收藏 7
点赞数
分类专栏： 图数据库 文章标签： 数据库 Nebula
于 2023-08-24 01:04:36 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq330983778/article/details/132463709
版权

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
大·风
关注
专栏目录
eclipse nebula部件
12-31
SWT是Eclipse开发框架的基础部分，它是一个与操作系统直接交互的轻量级图形库，允许开发者创建原生的、高性能的用户界面。Nebula项目则是SWT的一个增强版，它提供了许多SWT标准库中没有的组件，比如表格编辑器、树...
图数据库查询与操作指南-以Nebula图数据库为例
DZSpace，专注于计算机科学与技术领域的技术博主，致力于分享实用知识与技巧，帮助读者快速掌握技术要点，共同探索计算机世界的无限可能。欢迎访问DZSpace的博客，一起学习进步！
07-26 559
图数据库查询与操作指南-以Nebula图数据库为例
知识图谱：【图数据库Nebula（七）】——Nebula查询语言nGQL
u013010473的博客
10-24 8054
文章目录nGQL简介图模式单点模式多点关联模式Tag模式属性模式边模式变长模式路径变量索引创建检索操作检索点或边的信息检索点ID检索点Tag检索点或边的单个属性检索点或边的所有属性检索Edge type检索路径引用符引用符列表：引用符示例：MATCH匹配点匹配Tag匹配点的属性匹配点ID匹配连接的点匹配路径匹配边匹配Edge type匹配边的属性匹配定长路径匹配变长路径LOOKUP检索点检索边通过Tag列出所有的对应的点/通过Edge type列出边查找所有Tag为player的点 VID：查找Edge t
【人工智能时代】-NebulaGraph7 种查询（关键词、向量、混合检索），Graph RAG 探索知识图谱
最新发布
xiaoli8748的专栏
09-29 1210
Cypher 是由图数据库支持的一种声明性图查询语言。通过 Cypher，我们告诉知识图谱我们想要什么数据，而不是如何得到结果数据。这使得 Cypher 查询更易读、更好维护。此外，Cypher 易上手使用，且能够表达复杂的图查询。以下，是一个 Cypher 的简单的查询示例：代码语言：javascript复制%%ngql该查询语句将找到与棒球队 “Philadelphia Phillies” 相关的所有实体。是市面上最好的图数据库之一。
Nebula Graph查询语言（nGQL）（一）
qq_29506407的博客
09-02 3840
（一）、概念 nGQL是Nebula Graph使用的的声明式图查询语言，支持灵活高效的图模式，而且nGQL是为开发和运维人员设计的类SQL查询语言，易于学习。 exp：CREATE TAG player(name string, age int); ps：正确使用索引可以加速查询，但是索引会导致写性能下降90%甚至更多，只有在根据点或边的属性定位点或边时才使用索引。 模式（pattern）： 1.1、单...
NebulaGraph7 种查询（关键词、向量、混合检索），Graph RAG 探索知识图谱
丨汀、的博客
01-18 2446
NebulaGraph7 种查询（关键词、向量、混合检索），Graph RAG 探索知识图谱
nebula语法学习
ningyanggege的博客
06-25 1165
一、边的插入命令： 重要的注意事项：边的插入需要使用节点的vid，而不是节点的值。 INSERT EDGE e2 (name, age) VALUES “11”->“13”????“n1”, 1); 二、子图命令查询： MATCH (v:host)-[e1]->(v2)-[e2]->(v3)-[e3]->(v4)-[e4]->(v5)-[e5]->(v6) where v.ip==“xx.yy.zz.dd” RETURN v,v2,v3,v4,v5,v6,e1,e2,e
nebula-graph常用命令
hhhWHUWHF的博客
04-22 1455
1.网页端：http://192.168.56.110:7001/schema。//查找点之间的路径，如A->B之间的全路径、最短路径、最长路径。//匹配标签带条件，where必须指定索引属性。//查找某个顶点输入顶点 STEPS 指定跳数。//查询某个顶点关联的所有子图。//查找某个顶点输出顶点。
Nebula:C ++ 3D游戏引擎
05-04
游戏引擎是开发游戏软件的基础框架，它提供了图形渲染、物理模拟、音频处理、输入处理等一系列工具和接口，帮助开发者快速构建游戏世界，而不必从零开始编写底层代码。 **核心组件** Nebula引擎包含了多个关键组件...
Nebula3 渲染程序向导
06-30
1. **Nebula3引擎架构**：了解Nebula3的基础框架，包括场景管理、图形管道、资源管理和网络通信等模块，这将帮助你更好地理解如何在引擎中集成RTPlugin。 2. **RTPlugin机制**：深入理解RTPlugin的工作原理，包括...
nebula-pi:一款51单片机开发平台！
03-30
1. **易用性**：星云 nebula-pi 提供了友好的用户界面和直观的操作流程，无论是新手还是经验丰富的工程师都能迅速上手。 2. **模块化设计**：硬件部分采用模块化设计，可以根据项目需求灵活组合，降低硬件成本，提高...
Nebula Operator云上技术实践.docx
12-21
通过这个实践过程，你将能够熟练掌握使用 Nebula Operator 在云环境中部署和管理 Nebula Graph 的技能，享受到图数据库带来的高效数据查询和分析能力。同时，了解如何结合 Kubernetes 和 Operator 模式来优化云上...
图数据库nebula
sky302761277的CSDN
12-12 1678
图数据库nebula
arangodb vs nebula 单机顶点插入、查询、统计、分页等基本数据操作性能比对
09-29 1435
前置条件： 单机模式，默认配置，不做任何修改。 客户端测试为单线程操作测试。 服务器机器配置： 4核16g内存机器， centos7， 普通磁盘，非ssd 客户端机器配置： java driver自写的插入程序，同机器同执行环境。 批量插入1000W条数据， 单批次5000条。 nebula: 插入: 10000000, 耗时: 100878 总计耗时： 100s, tps: 10w/s arangodb: 插入: 10000000, 耗时: 637854 总计耗时: 638s,...
Nebula基础的操作介绍
大风的博客
08-24 2160
这里只是对Nebula基础的介绍，其目的是为了让未接触过Nebula的同学最短时间了解其概念和使用。更详细更准确的内可以查看官方文档。
Nebula Graph介绍和SpringBoot环境连接和查询
IOsetting的专栏
10-12 2173
当前Nebula Graph的最新版本是3.2.1, Nebula Graph 的一些特点 1. 支持分布式. 相对于Neo4j, TigerGraph这些图数据库, Nebula 是面向分布式设计的, 因此对集群的支持比较完备, 在规模上上限要高很多. 在实际项目中存储了180亿的点边, 这个数量对于Neo4j和TigerGraph是比较困难的. 1. 支持图空间. 各个图空间的ID是互不干扰的, 但是在同一个图空间里ID的类型和长度必须一致. 注意这个一致约束的是所有的点和边. Nebula 可以使用
nebula数据库常见NGQL语句
weixin_43730107的博客
01-25 887
nebula数据库常见的NGQL语句
NHibernate扩展方法(二) --查询分页
lotustao的专栏
07-28 1042
public static class IQueryExtension     {         #region 分页查询         ///         /// 分页查询         ///         ///         ///         ///         ///         ///         ///    
Nebula Graph图数据库教程介绍
wt334502157的博客
09-14 3586
Space（空间）在 Nebula Graph 中，Space 可以类比为数据库。就像关系型数据库中可以有多个数据库，Nebula Graph 中可以有多个 Space。每个 Space 可以看作是一个独立的数据存储区域，用于存储不同类型的数据。比喻Space 就像是一个大仓库，您可以在仓库中存放不同类型的货物，每个货物都有自己的存储区域。 Tag（标签）和 Vertex（顶点）在 Nebula Graph 中，Tag 类似于表，而 Vertex 类似于表中的行。Tag 定义了一组属性
nebula 数据库查询两个点的最短边
05-25
在 Nebula Graph 中，可以使用最短路径算法来查询两个点之间的最短路径。最短路径算法有多种实现方式，包括 Dijkstra 算法、BFS 算法和 Floyd-Warshall 算法等。 以使用 Dijkstra 算法为例，查询两个点之间的最短边可以按照以下步骤进行： 1. 使用 `GO FROM` 语句遍历出起点到其他所有点的路径，并将路径上的边权值保存下来。 ``` GO FROM <start_vertex> OVER <edge_type> [YIELD <prop_name>] [WHERE <condition>] [LIMIT <N>] ``` 其中 `<start_vertex>` 表示起点的 ID，`<edge_type>` 表示要遍历的边类型，`<prop_name>` 表示要返回的边属性名，`<condition>` 表示过滤条件，`<N>` 表示最多遍历的边数。 2. 对遍历结果进行 Dijkstra 算法求解，得到两个点之间的最短路径和边权值。 ``` FETCH PROP ON <edge_type> <edge_id> YIELD <prop_name> ``` 其中 `<edge_type>` 表示要查询的边类型，`<edge_id>` 表示要查询的边 ID，`<prop_name>` 表示要返回的边属性名。 3. 根据查询结果得到两个点之间的最短边。 综上所述，可以通过 Nebula Graph 提供的查询语句和算法实现查询两个点之间的最短边。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

大·风

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值