【NebulaGraph】基础入门(一)

已于 2024-12-28 15:48:39 修改
阅读量1.1k 收藏 11
点赞数 10
分类专栏： Nebula Graph数据库 文章标签： 数据库
于 2024-11-27 11:18:06 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Blue_Pepsi_Cola/article/details/144077510
版权

【NebulaGraph】基础入门一

0. 相关文档

github中文手册：https://github.com/vesoft-inc/nebula/blob/master/README-CN.md
官网： https://www.nebula-graph.com.cn/
相关手册： https://docs.nebula-graph.com.cn/3.8.0/2.quick-start/1.quick-start-overview/
B站： https://space.bilibili.com/472621355
nGQL： https://docs.nebula-graph.com.cn/master/3.ngql-guide/1.nGQL-overview/1.overview/
论坛 https://discuss.nebula-graph.com.cn/
图数据库Nebula Graph初识 ：https://www.bilibili.com/video/BV1b3411v7r5/?spm_id_from=333.337.search-card.all.click&vd_source=240d9002f7c7e3da63cd9a975639409a
Ngbais: https://graph-cn.github.io/ngbatis-docs/

1. 概述

图数据库 Nebula Graph 介绍视频

NebulaGraph 是一款开源的、分布式的、易扩展的原生图数据库，能够承载包含数千亿个点和数万亿条边的超大规模数据集，并且提供毫秒级查询。

NebulaGraph 社区已成长为一个荟聚了众多用户、融合了各类图技术场景实践知识的活跃开源社区。你可以在其中与大家共同交流 NebulaGraph 周边生态项目的应用心得，或者社交媒体、实时推荐、网络安全、金融风控、知识图谱、人工智能等大规模生产场景的实践经验。

NebulaGraph 特点如下：

  1. 全对称分布式架构
  2. 存储与计算分离
  3. 水平可扩展性
  4. RAFT 协议下的数据强一致
  5. 支持 openCypher
  6. 用户鉴权
  7. 支持多种类型的图计算算法

1.1 什么是图数据库

图数据库是专门存储庞大的图形网络并从中检索信息的数据库。它可以将图中的数据高效存储为点（Vertex）和边（Edge），还可以将属性（Property）附加到点和边上。

NebulaGraph以节点表示实体，以边表示实体之间的关系。
在这里插入图片描述

图数据库适合存储大多数从现实抽象出的数据类型。世界上几乎所有领域的事物都有内在联系，像关系型数据库这样的建模系统会提取实体之间的关系，并将关系单独存储到表和列中，而实体的类型和属性存储在其他列甚至其他表中，这使得数据管理费时费力。

NebulaGraph 作为一个典型的图数据库，可以将丰富的关系通过边及其类型和属性自然地呈现。

1.2 NebulaGraph 的优势

  1. 开源
    NebulaGraph 是在 Apache 2.0 条款下开发的。越来越多的人，如数据库开发人员、数据科学家、安全专家、算法工程师，都参与到 NebulaGraph 的设计和开发中来，欢迎访问 NebulaGraph GitHub 主页参与开源项目。

  2. 高性能
    基于图数据库的特性使用 C++ 编写的 NebulaGraph，可以提供毫秒级查询。众多数据库中，NebulaGraph 在图数据服务领域展现了卓越的性能，数据规模越大，NebulaGraph 优势就越大。详情请参见 NebulaGraph benchmarking 页面。

  3. 易扩展
    NebulaGraph 采用 shared-nothing 架构，支持在不停止数据库服务的情况下扩缩容。

  4. 易开发
    NebulaGraph 提供 Java、Python、C++ 和 Go 等流行编程语言的客户端，更多客户端仍在开发中。详情请参见 NebulaGraph clients。

  5. 高可靠访问控制
    NebulaGraph 支持严格的角色访问控制和 LDAP（Lightweight Directory Access Protocol）等外部认证服务，能够有效提高数据安全性。详情请参见验证和授权。

  6. 生态多样化
    NebulaGraph 开放了越来越多的原生工具，例如 NebulaGraph Studio、NebulaGraph Console、NebulaGraph Exchange 等，更多工具可以查看生态工具概览。
    此外，NebulaGraph 还具备与 Spark、Flink、HBase 等产品整合的能力，在这个充满挑战与机遇的时代，大大增强了自身的竞争力。

  7. 兼容 openCypher 查询语言
    NebulaGraph 查询语言，简称为 nGQL，是一种声明性的、部分兼容 openCypher 的文本查询语言，易于理解和使用。详细语法请参见 nGQL 指南。

  8. 面向未来硬件，读写平衡
    闪存型设备有着极高的性能，并且价格快速下降，NebulaGraph 是一个面向 SSD 设计的产品，相比于基于 HDD + 大内存的产品，更适合面向未来的硬件趋势，也更容易做到读写平衡。

  9. 灵活数据建模
    用户可以轻松地在 NebulaGraph 中建立数据模型，不必将数据强制转换为关系表。而且可以自由增加、更新和删除属性。详情请参见数据模型。

  10. 广受欢迎
    腾讯、美团、京东、快手、360 等科技巨头都在使用 NebulaGraph 。详情请参见 NebulaGraph 官网。

  11. 适用场景
    NebulaGraph 可用于各种基于图的业务场景。为节约转换各类数据到关系型数据库的时间，以及避免复杂查询，建议使用 NebulaGraph 。

  12. 欺诈检测
    金融机构必须仔细研究大量的交易信息，才能检测出潜在的金融欺诈行为，并了解某个欺诈行为和设备的内在关联。这种场景可以通过图来建模，然后借助 NebulaGraph，可以很容易地检测出诈骗团伙或其他复杂诈骗行为。

  13. 实时推荐
    NebulaGraph 能够及时处理访问者产生的实时信息，并且精准推送文章、视频、产品和服务。

  14. 知识图谱
    自然语言可以转化为知识图谱，存储在 NebulaGraph 中。用自然语言组织的问题可以通过智能问答系统中的语义解析器进行解析并重新组织，然后从知识图谱中检索出问题的可能答案，提供给提问人。

  15. 社交网络
    人际关系信息是典型的图数据，NebulaGraph 可以轻松处理数十亿人和数万亿人际关系的社交网络信息，并在海量并发的情况下，提供快速的好友推荐和工作岗位查询。

2. 查询语言 nGQL

从SQL角度对比学习nGQL
查询手册
NebulaGraph 查询语言 nGQL 教程 - Part 1
讲师博客

nGQL是 NebulaGraph 使用的的声明式图查询语言，支持灵活高效的图模式，而且 nGQL 是为开发和运维人员设计的类 SQL 查询语言，易于学习。

2.1 NebulaGraph独有的DQL

  • 图拓展：GO
  • 索引反查：LOOKUP
  • 取属性：FETCH PROP
  • 路径与子图：FIND PATH 与 GET SUBGRAPH
  • 管道：|
  • 引用属性：$开头的几个符号，用来描述一些特定的上下文

在这里插入图片描述

在这里插入图片描述

2.1.1 图拓展 GO

在这里插入图片描述

在这里插入图片描述

3. 安装 NebulaGraph

文档 https://docs.nebula-graph.com.cn/3.8.0/2.quick-start/3.quick-start-on-premise/2.install-nebula-graph/

查看当前Linux的版本

[root@hcss-ecs-2ff4 ~]# cat /etc/os-release

在这里插入图片描述

# 下载
[root@hcss-ecs-2ff4 ~]# wget https://oss-cdn.nebula-graph.com.cn/package/nightly/<yyyy.mm.dd>/nebula-graph-<yyyy.mm.dd>-nightly.el7.x86_64.rpm


# 安装
[root@hcss-ecs-2ff4 ~]# sudo rpm -ivh nebula-graph-3.8.0.el7.x86_64.rpm 
Preparing...                          ################################# [100%]
Updating / installing...
   1:nebula-graph-3.8.0-1             ################################# [100%]

4. 启动 NebulaGraph 服务

nebula.service的默认路径是/usr/local/nebula/scripts

[root@hcss-ecs-2ff4 scripts]#  sudo /usr/local/nebula/scripts/nebula.service start all

4.1 查看 NebulaGraph 服务

[root@hcss-ecs-2ff4 scripts]# sudo /usr/local/nebula/scripts/nebula.service status all
[INFO] nebula-metad(7458486): Running as 17094, Listening on 9559
[INFO] nebula-graphd(7458486): Running as 17161, Listening on 9669
[WARN] nebula-storaged after v3.0.0 will not start service until it is added to cluster.
[WARN] See Manage Storage hosts:ADD HOSTS in https://docs.nebula-graph.io/
[INFO] nebula-storaged(7458486): Running as 17198, Listening on 9779

4.2 连接 NebulaGraph

下载NebulaGraph Console v3.8.0 https://github.com/vesoft-inc/nebula-console/releases
在这里插入图片描述

# 下载好的，直接修改名字
[root@hcss-ecs-2ff4 ~]# mv nebula-console-linux-amd64-v3.8.0 nebula-console

# 启动
[root@hcss-ecs-2ff4 ~]# chmod 111 nebula-console
[root@hcss-ecs-2ff4 ~]# ./nebula-console -addr 127.0.0.1 -port 9669  -u root -p 123

4.3 注册 Storage 服务

添加 Storage 主机。

# 执行如下命令添加主机：
(root@nebula) [(none)]> ADD HOSTS 127.0.0.1:9779
Execution succeeded (time spent 886µs/1.129304ms)

Fri, 29 Nov 2024 11:04:34 CST


(root@nebula) [(none)]> SHOW HOSTS;
+-------------+------+----------+--------------+----------------------+------------------------+---------+
| Host        | Port | Status   | Leader count | Leader distribution  | Partition distribution | Version |
+-------------+------+----------+--------------+----------------------+------------------------+---------+
| "127.0.0.1" | 9779 | "ONLINE" | 0            | "No valid partition" | "No valid partition"   | "3.8.0" |
+-------------+------+----------+--------------+----------------------+------------------------+---------+
Got 1 rows (time spent 626µs/949.033µs)

5. 创建图空间

# 创建图空间
CREATE SPACE default_value (vid_type = INT, partition_num = 100, replica_factor = 1, charset = utf8, collate = utf8_bin);

CREATE SPACE [IF NOT EXISTS] <space_name> (vid_type=<vid_type_definition>, [partition_num=<num>, replica_factor=<num>, charset=<charset>, collate=<collate>]);

  • IF NOT EXISTS：如果图空间已存在，则不会重复创建。
  • vid_type：顶点 ID 的类型，必须指定。可选值：
    • FIXED_STRING(N)，如：FIXED_STRING(30)。
    • INT。
  • partition_num：分区数量（可选，默认值为100）。
  • replica_factor：副本因子（可选，默认值为1）。
  • charset：字符集（可选，默认值为utf8）。
  • collate：排序规则（可选，默认值为utf8_bin）。
# 查看图空间
(root@nebula) [(none)]> SHOW SPACES
+-----------------+
| Name            |
+-----------------+
| "default_value" |
+-----------------+
Got 1 rows (time spent 501µs/784.596µs)

Fri, 29 Nov 2024 11:19:39 CST

# 使用已创建的图空间
(root@nebula) [(none)]> USE default_value
Execution succeeded (time spent 531µs/771.766µs)

Fri, 29 Nov 2024 11:23:06 CST

# 如果图空间已创建，但忘记了其配置，可通过以下命令查看：
DESCRIBE SPACE default_value;

(root@nebula) [default_value]> DESCRIBE SPACE default_value;
+----+-----------------+------------------+----------------+---------+------------+----------+---------+
| ID | Name            | Partition Number | Replica Factor | Charset | Collate    | Vid Type | Comment |
+----+-----------------+------------------+----------------+---------+------------+----------+---------+
| 1  | "default_value" | 100              | 1              | "utf8"  | "utf8_bin" | "INT64"  |         |
+----+-----------------+------------------+----------------+---------+------------+----------+---------+
Got 1 rows (time spent 473µs/776.239µs)

Fri, 29 Nov 2024 11:24:17 CST

6. 在Nebula Graph中创建标签

在Nebula Graph中我们将具有相同属性的点分为一组，该组即为一个标签。

语法格式：

CREATE TAG [IF NOT EXISTS] <tag_name> (<property_name> <data_type>[, <property_name> <data_type>, ...]);
  • IF NOT EXISTS：如果标签已存在，则不会报错。
  • <tag_name>：标签名称，用于标识顶点的类型。
  • <property_name>：属性名称，定义顶点的属性。
  • <data_type>：属性的数据类型，例如 INT, STRING, DOUBLE, BOOL。
# 首先创建一个图空间
CREATE SPACE nba (vid_type = INT, partition_num = 100, replica_factor = 1, charset = utf8, collate = utf8_b
in);
Execution succeeded (time spent 997µs/1.229848ms)

(root@nebula) [default_value]> SHOW SPACES;

+-----------------+
| Name            |
+-----------------+
| "default_value" |
| "nba"           |
+-----------------+
Got 2 rows (time spent 516µs/795.042µs)

Fri, 29 Nov 2024 14:44:18 CST


(root@nebula) [nba]> DESCRIBE SPACE nba;
+----+-------+------------------+----------------+---------+------------+----------+---------+
| ID | Name  | Partition Number | Replica Factor | Charset | Collate    | Vid Type | Comment |
+----+-------+------------------+----------------+---------+------------+----------+---------+
| 2  | "nba" | 100              | 1              | "utf8"  | "utf8_bin" | "INT64"  |         |
+----+-------+------------------+----------------+---------+------------+----------+---------+
Got 1 rows (time spent 513µs/849.617µs)

Fri, 29 Nov 2024 15:00:18 CST

# 使用nba图空间
(root@nebula) [default_value]> USE nba;
Execution succeeded (time spent 488µs/716.369µs)

Fri, 29 Nov 2024 14:45:20 CST

# 创建标签
(root@nebula) [nba]> CREATE TAG player(name string, age int);
Execution succeeded (time spent 836µs/1.07131ms)

Fri, 29 Nov 2024 14:47:40 CST

# 查看标签的详细信息
(root@nebula) [nba]> DESCRIBE TAG player;
+--------+----------+-------+---------+---------+
| Field  | Type     | Null  | Default | Comment |
+--------+----------+-------+---------+---------+
| "name" | "string" | "YES" |         |         |
| "age"  | "int64"  | "YES" |         |         |
+--------+----------+-------+---------+---------+
Got 2 rows (time spent 558µs/852.676µs)

Fri, 29 Nov 2024 14:53:41 CST

# 查看已有TAGS
(root@nebula) [nba]> show tags
+----------+
| Name     |
+----------+
| "player" |
+----------+
Got 1 rows (time spent 525µs/792.71µs)

Fri, 29 Nov 2024 14:56:50 CST

7. 在Nebula Graph中创建边

创建边类型（Edge Type）

CREATE EDGE IF NOT EXISTS friendship (since INT, close_level DOUBLE);
  • 边类型名称：friendship
    属性：
  • since：边的建立年份，INT 类型。
  • close_level：亲密度，DOUBLE 类型。

插入边数据
创建边类型后，可以插入具体数据。

示例 1：插入一条边

INSERT EDGE friendship(since, close_level) VALUES "1"->"2": (2015, 0.9);
  • 边类型：friendship
  • 起始顶点 ID：“1”
  • 目标顶点 ID：“2”
  • 属性值：
  • since：2015
  • close_level：0.9
# 创建一个边
(root@nebula) [nba]> CREATE EDGE follow(degree int);
Execution succeeded (time spent 765µs/1.003863ms)

Fri, 29 Nov 2024 15:19:30 CST

(root@nebula) [nba]> show edges;
+----------+
| Name     |
+----------+
| "follow" |
+----------+
Got 1 rows (time spent 565µs/856.762µs)

Fri, 29 Nov 2024 15:20:01 CST

# 创建server EDGE
(root@nebula) [nba]> CREATE EDGE server(start_year int, end_year int);
Execution succeeded (time spent 771µs/1.035395ms)

Fri, 29 Nov 2024 15:23:19 CST

(root@nebula) [nba]> SHOW EDGES;
+----------+
| Name     |
+----------+
| "follow" |
| "server" |
+----------+
Got 2 rows (time spent 522µs/793.396µs)

Fri, 29 Nov 2024 15:23:48 CST

示例 2：插入多条边

INSERT EDGE friendship(since, close_level) VALUES 
"1"->"3": (2016, 0.8), 
"2"->"4": (2017, 0.6);
  • 插入两条边：
    • “1” -> “3”，属性值 (2016, 0.8)
    • “2” -> “4”，属性值 (2017, 0.6)

8. Nebula Graph中点、标签、边的区别

在 Nebula Graph 中，点（Vertex）、标签（Tag）、**边（Edge）**是构建图数据库的基本元素。它们的角色和作用各不相同，但共同组成了图数据模型。

8.1 点（Vertex）

  • 定义：点是图数据库的基本单元，用来表示一个实体或对象。
  • 特性：
    • 每个点有一个唯一的标识符（VID，顶点 ID）。
    • 点可以属于一个或多个标签（Tag），从而拥有不同的属性。
  • 用途：常用于表示具体的对象，例如用户、地点、商品等。
    示例
  • 点 VID=1 表示一个用户。
  • 点 VID=“Beijing” 表示一个城市。

8.2 标签（Tag）

  • 定义：标签是点的分类或类型，用来定义点的属性结构。
  • 特性：
    • 标签是点的“类型”或“特征”，类似于关系型数据库中的“表”。
    • 每个标签包含一组属性（property），这些属性定义了点的结构。
    • 一个点可以有多个标签，从而具有多个类别的属性。

用途：定义点的属性结构，按分类存储点的数据。

示例
标签 person 定义了一组点的属性：

CREATE TAG person (name STRING, age INT);

使用标签后：

  • 点 VID=1 使用 person 标签，表示某用户的名字和年龄
INSERT VERTEX person(name, age) VALUES 1: ("Alice", 25);

8.3 边

定义：边是两个点之间的关系，用来描述它们之间的连接。
特性：

  • 边有起点（src_vertex）和终点（dst_vertex）。
  • 边可以有类型（edge_type），用来描述关系的含义。
  • 边可以包含属性，用来描述关系的特性。
  • 边是有方向的，但可以定义双向关系。

用途：描述点之间的关系及其特性，例如好友关系、购买行为等。

示例
边类型 friendship：

CREATE EDGE friendship (since INT, close_level DOUBLE);

插入边后：

表示用户 VID=1 与用户 VID=2 从 2015 年起是好友，亲密度为 0.9：

INSERT EDGE friendship(since, close_level) VALUES 1->2: (2015, 0.9);

8.4 总结：点、标签、边的区别

在这里插入图片描述

8.5 图结构示例

假设我们有以下数据：

  1. 点 1 是一个人，标签为 person。
  2. 点 2 是一个人，标签为 person。
  3. 点 3 是一家公司，标签为 company。
  4. 点 1 和点 2 之间存在朋友关系，点 1 和点 3 之间存在雇佣关系。

图结构定义：

-- 定义标签
CREATE TAG person (name STRING, age INT);
CREATE TAG company (name STRING, industry STRING);

-- 定义边类型
CREATE EDGE friendship (since INT);
CREATE EDGE employment (role STRING);

-- 插入点
INSERT VERTEX person(name, age) VALUES 1: ("Alice", 30);
INSERT VERTEX person(name, age) VALUES 2: ("Bob", 28);
INSERT VERTEX company(name, industry) VALUES 3: ("TechCorp", "IT");

-- 插入边
INSERT EDGE friendship(since) VALUES 1->2: (2015);
INSERT EDGE employment(role) VALUES 1->3: ("Engineer");

9. 在 Nebula Graph 中插入点

9.1 简单插入

在 Nebula Graph 中，点（Vertex）是图数据模型的基本元素，用于表示实体。插入点时需要为其指定顶点 ID (VID)，以及点所属的标签（Tag）和相关属性。

插入点的语法

INSERT VERTEX <tag_name>(<property_list>) VALUES <vid>: (<value_list>);

参数说明：

  • <tag_name>：标签名称，用于定义点的属性结构。

  • <property_list>：属性名称列表，用逗号分隔。

  • <vid>：顶点的唯一标识符，类型由图空间的 vid_type 决定：

    • INT：VID 是整数。
    • FIXED_STRING(N)：VID 是字符串。

  • <value_list>：属性值列表，顺序需与 property_list 对应。

插入多个点

INSERT VERTEX person(name, age) VALUES
2: ("Bob", 28),
3: ("Charlie", 35);

在这里插入图片描述

# 插入点
(root@nebula) [nba]> INSERT VERTEX player(name,age) VALUES  100:("Tim Duncan", 42);
Execution succeeded (time spent 1.274ms/1.504816ms)

Fri, 29 Nov 2024 15:59:45 CST

# 查询刚刚插入点的属性
(root@nebula) [nba]> FETCH PROP ON player 100 YIELD player.name, player.age;
+--------------+------------+
| player.name  | player.age |
+--------------+------------+
| "Tim Duncan" | 42         |
+--------------+------------+
Got 1 rows (time spent 883µs/1.197208ms)

Fri, 29 Nov 2024 16:18:22 CST

9.2 创建不同标签，然后插入数据

# 创建tag
(root@nebula) [nba]> CREATE TAG test1(name string);
Execution succeeded (time spent 696µs/925.711µs)

Fri, 29 Nov 2024 16:50:45 CST

(root@nebula) [nba]> CREATE TAG test2(age int);
Execution succeeded (time spent 705µs/957.739µs)

Fri, 29 Nov 2024 16:50:56 CST

# 插入数据
(root@nebula) [nba]> INSERT VERTEX test1(name),test2(age) VALUES 199:("Multitags",22);
Execution succeeded (time spent 735µs/1.007459ms)

Fri, 29 Nov 2024 16:53:15 CST

# 获取属性
(root@nebula) [nba]> FETCH PROP ON test1 199 YIELD test1.name;
+-------------+
| test1.name  |
+-------------+
| "Multitags" |
+-------------+
Got 1 rows (time spent 762µs/1.042179ms)

Fri, 29 Nov 2024 16:54:22 CST

删除点，VID 199

(root@nebula) [nba]> DELETE VERTEX 199;
Execution succeeded (time spent 841µs/1.04931ms)

Fri, 29 Nov 2024 16:56:21 CST


(root@nebula) [nba]> FETCH PROP ON test1 199  YIELD test1.name;
+------------+
| test1.name |
+------------+
+------------+
Empty set (time spent 855µs/1.119496ms)

Fri, 29 Nov 2024 16:57:38 CST

10. 在Nebula Graph中插入边

(root@nebula) [nba]> show edges;
+----------+
| Name     |
+----------+
| "follow" |
| "server" |
+----------+
Got 2 rows (time spent 525µs/782.564µs)

Fri, 29 Nov 2024 17:02:44 CST




(root@nebula) [nba]> DESCRIBE EDGE follow;
+----------+---------+-------+---------+---------+
| Field    | Type    | Null  | Default | Comment |
+----------+---------+-------+---------+---------+
| "degree" | "int64" | "YES" |         |         |
+----------+---------+-------+---------+---------+
Got 1 rows (time spent 601µs/900.076µs)

Fri, 29 Nov 2024 17:06:02 CST





(root@nebula) [nba]> INSERT EDGE follow(degree) VALUES 100->101:(95);
Execution succeeded (time spent 808µs/1.054975ms)

Fri, 29 Nov 2024 17:03:54 CST




(root@nebula) [nba]> FETCH PROP ON follow 100->101 YIELD follow.degree;
+---------------+
| follow.degree |
+---------------+
| 95            |
+---------------+
Got 1 rows (time spent 943µs/1.233496ms)

Fri, 29 Nov 2024 17:06:23 CST


# 多个边关系插入
(root@nebula) [nba]> INSERT EDGE follow(degree) VALUES 100->101:(95), 102->101:(75), 100->103:(70);
Execution succeeded (time spent 802µs/1.018215ms)

Fri, 29 Nov 2024 17:10:35 CST



(root@nebula) [nba]> FETCH PROP ON follow 100->101, 102->101,100->103  YIELD follow.degree;
+---------------+
| follow.degree |
+---------------+
| 95            |
| 70            |
| 75            |
+---------------+
Got 3 rows (time spent 826µs/1.105253ms)

Fri, 29 Nov 2024 17:11:34 CST



(root@nebula) [nba]> INSERT EDGE server(start_year, end_year) VALUES 100->200:(1997,2016), 101->201:(1999,018);
Execution succeeded (time spent 814µs/1.069366ms)

Fri, 29 Nov 2024 17:13:21 CST

(root@nebula) [nba]> FETCH PROP ON server 100->200, 101->201  YIELD server.start_year, server.end_year;
+-------------------+-----------------+
| server.start_year | server.end_year |
+-------------------+-----------------+
| 1997              | 2016            |
| 1999              | 18              |
+-------------------+-----------------+
Got 2 rows (time spent 903µs/1.208452ms)

Fri, 29 Nov 2024 17:14:58 CST

11. 在Nebula Graph中查询数据

已知关系

在这里插入图片描述

# 已知VERTEX的id，查询结果
(root@nebula) [nba]> FETCH PROP ON player 100 YIELD player.name as name ,player.age as age;
+--------------+-----+
| name         | age |
+--------------+-----+
| "Tim Duncan" | 42  |
+--------------+-----+
Got 1 rows (time spent 821µs/1.095093ms)

Sun, 01 Dec 2024 20:46:48 CST

# 更新记录
(root@nebula) [nba]> UPDATE VERTEX 100 SET player.name = "Tim";
Execution succeeded (time spent 103.918ms/104.155213ms)

Sun, 01 Dec 2024 20:49:39 CST

(root@nebula) [nba]> FETCH PROP ON player 100 YIELD player.name as name ,player.age as age;
+-------+-----+
| name  | age |
+-------+-----+
| "Tim" | 42  |
+-------+-----+
Got 1 rows (time spent 798µs/1.072769ms)

# 从VID为100的点开始查询，遍历所有被VID100关注的点
(root@nebula) [nba]> go from 100 over follow YIELD follow.degree;
+---------------+
| follow.degree |
+---------------+
| 95            |
| 70            |
+---------------+



# 年龄大于35的球员，且该球员被VID为100的球员关注，WHERE语句限定年龄，$$符号表示目标点，YIELD语句指定返回的结果
(root@nebula) [nba]> GO FROM 100 OVER follow WHERE $$.player.age > 35 YIELD $$.player.name AS Teammate, $$.player.age AS Age;
+----------+-----+
| Teammate | Age |
+----------+-----+
+----------+-----+
Empty set (time spent 1.884ms/2.152341ms)

Fri, 29 Nov 2024 17:48:46 CST

# 找到VID100关注的球员所效力的球队
# 方法一：通过管道符 |


# 方法二： 通过使用临时变量



# 查询年龄小于100的
(root@nebula) [nba]> LOOKUP ON player WHERE player.age < 100 YIELD player.name as name ,player.age as age;
+------+-----+
| name | age |
+------+-----+
+------+-----+
Empty set (time spent 2.582ms/2.851084ms)

Sun, 01 Dec 2024 20:59:41 CST

在这里插入图片描述

方法一：通过管道符 |
在这里插入图片描述

$∧ 代表边的起始点
$-代表管道符前面查询语句的结果

方法二： 通过使用临时变量
在这里插入图片描述

11. 在Nebula Graph中删除数据

(root@nebula) [nba]> DELETE VERTEX 100;
Execution succeeded (time spent 762µs/980.616µs)

Sun, 01 Dec 2024 20:52:13 CST

nebula> DELETE EDGE follow 100 -> 200;

12. 在Nebula Graph中建立索引

使用 nGQL 查询有些不同，因为您必须在过滤属性之前创建索引。

(root@nebula) [nba]> CREATE TAG INDEX player_age ON player(age);
Execution succeeded (time spent 92.949ms/93.227235ms)

Sun, 01 Dec 2024 20:55:02 CST


(root@nebula) [nba]> REBUILD TAG INDEX player_age;
+------------+
| New Job Id |
+------------+
| 3          |
+------------+
Got 1 rows (time spent 744µs/1.002852ms)

Sun, 01 Dec 2024 20:56:23 CST

在 Nebula Graph 中，REBUILD TAG INDEX 是用来重新构建指定的标签（Tag）的索引的命令。

背景
在 Nebula Graph 中，索引用于加速查询。例如，标签（Tag）索引允许你高效地通过特定属性查询某些节点。当标签的属性或数据发生了较大的更新（如插入、删除或修改），索引可能需要重新构建以确保数据一致性和查询性能。

13. FETCH PROP ON 与GO FROM 两种查询方式的区别

在 Nebula Graph 中，FETCH PROP ON 和 GO FROM 是两种常用的查询语句，但它们的作用和应用场景不同。

13.1 FETCH PROP ON

  • 作用: 获取一个或多个指定节点或边的属性。
  • 特点:
    • 直接操作节点（点）或边的属性，适用于直接获取数据，而不涉及遍历。
    • 是一个点查操作，不涉及图的拓扑结构。
FETCH PROP ON <tag/edge_type> <vid_list>;
  • <tag/edge_type>: 标签（Tag）或边类型（Edge Type）的名称。
  • <vid_list>: 指定要查询的点（VID）或边。
# 获取 VID 为 "1" 的点上，player 标签的所有属性
FETCH PROP ON player 1 YIELD ...;

# 获取从 VID 为 "1" 到 VID 为 "2" 的 follow 边的属性。
FETCH PROP ON follow 1 -> 2;

应用场景:

  • 需要查询某些具体节点或边的详细信息。
  • 数据量较小或明确知道目标 VID 时使用。

13.2 GO FROM

  • 作用: 从一个或多个节点出发，沿着指定的边类型遍历邻接节点，并获取目标节点或边的相关信息。

  • 特点:

    • 用于遍历图结构，适合发现节点之间的关系和路径。
    • 是一个图遍历操作，通常涉及拓扑结构。

  • 语法

GO [<steps>] FROM <vid_list> OVER <edge_type_list> [YIELD <expression_list>];
  • <steps>: 遍历的步数，默认值为 1。
  • <vid_list>: 起始点的 VID。
  • <edge_type_list>: 遍历时要经过的边类型。
  • YIELD: 指定查询返回的属性或表达式。
# 从 VID 为 "1" 的点出发，沿着 follow 边遍历两步，返回 follow 边的 start_time 和目标点的 name 属性。
GO 2 STEPS FROM "1" OVER follow YIELD follow.start_time, $$.player.name;

应用场景:

  • 查询节点之间的关系或路径。
  • 需要通过遍历发现间接相关的节点或边。

在这里插入图片描述

14. NebulaGraph 插入示例数据 basketballplayer

drop space basketballplayer;
create space basketballplayer(partition_num=10,replica_factor=1,vid_type=fixed_string(32));
:sleep 20
use basketballplayer;
create tag player(name string,age int);
create tag team(name string);
create edge serve(start_year int,end_year int);
create edge follow(degree int);
:sleep 20
create tag index player_index_0 on player();
create tag index player_index_1 on player(name(20));
:sleep 20
insert vertex player(name,age) values "player100":("Tim Duncan", 42);
insert vertex player(name,age) values "player101":("Tony Parker", 36);
insert vertex player(name,age) values "player102":("LaMarcus Aldridge", 33);
insert vertex player(name,age) values "player103":("Rudy Gay", 32);
insert vertex player(name,age) values "player104":("Marco Belinelli", 32);
insert vertex player(name,age) values "player105":("Danny Green", 31);
insert vertex player(name,age) values "player106":("Kyle Anderson", 25);
insert vertex player(name,age) values "player107":("Aron Baynes", 32);
insert vertex player(name,age) values "player108":("Boris Diaw", 36);
insert vertex player(name,age) values "player109":("Tiago Splitter", 34);
insert vertex player(name,age) values "player110":("Cory Joseph", 27);
insert vertex player(name,age) values "player111":("David West", 38);
insert vertex player(name,age) values "player112":("Jonathon Simmons", 29);
insert vertex player(name,age) values "player113":("Dejounte Murray", 29);
insert vertex player(name,age) values "player114":("Tracy McGrady", 39);
insert vertex player(name,age) values "player115":("Kobe Bryant", 40);
insert vertex player(name,age) values "player116":("LeBron James", 34);
insert vertex player(name,age) values "player117":("Stephen Curry", 31);
insert vertex player(name,age) values "player118":("Russell Westbrook", 30);
insert vertex player(name,age) values "player119":("Kevin Durant", 30);
insert vertex player(name,age) values "player120":("James Harden", 29);
insert vertex player(name,age) values "player121":("Chris Paul", 33);
insert vertex player(name,age) values "player122":("DeAndre Jordan", 30);
insert vertex player(name,age) values "player123":("Ricky Rubio", 28);
insert vertex player(name,age) values "player124":("Rajon Rondo", 33);
insert vertex player(name,age) values "player125":("Manu Ginobili", 41);
insert vertex player(name,age) values "player126":("Kyrie Irving", 26);
insert vertex player(name,age) values "player127":("Vince Carter", 42);
insert vertex player(name,age) values "player128":("Carmelo Anthony", 34);
insert vertex player(name,age) values "player129":("Dwyane Wade", 37);
insert vertex player(name,age) values "player130":("Joel Embiid", 25);
insert vertex player(name,age) values "player131":("Paul George", 28);
insert vertex player(name,age) values "player132":("Giannis Antetokounmpo", 24);
insert vertex player(name,age) values "player133":("Yao Ming", 38);
insert vertex player(name,age) values "player134":("Blake Griffin", 30);
insert vertex player(name,age) values "player135":("Damian Lillard", 28);
insert vertex player(name,age) values "player136":("Steve Nash", 45);
insert vertex player(name,age) values "player137":("Dirk Nowitzki", 40);
insert vertex player(name,age) values "player138":("Paul Gasol", 38);
insert vertex player(name,age) values "player139":("Marc Gasol", 34);
insert vertex player(name,age) values "player140":("Grant Hill", 46);
insert vertex player(name,age) values "player141":("Ray Allen", 43);
insert vertex player(name,age) values "player142":("Klay Thompson", 29);
insert vertex player(name,age) values "player143":("Kristaps Porzingis", 23);
insert vertex player(name,age) values "player144":("Shaquille O'Neal", 47);
insert vertex player(name,age) values "player145":("JaVale McGee", 31);
insert vertex player(name,age) values "player146":("Dwight Howard", 33);
insert vertex player(name,age) values "player147":("Amar'e Stoudemire", 36);
insert vertex player(name,age) values "player148":("Jason Kidd", 45);
insert vertex player(name,age) values "player149":("Ben Simmons", 22);
insert vertex player(name,age) values "player150":("Luka Doncic", 20);
insert vertex team(name) values "team200":("Warriors");
insert vertex team(name) values "team201":("Nuggets");
insert vertex team(name) values "team202":("Rockets");
insert vertex team(name) values "team203":("Trail Blazers");
insert vertex team(name) values "team204":("Spurs");
insert vertex team(name) values "team205":("Thunders");
insert vertex team(name) values "team206":("Jazz");
insert vertex team(name) values "team207":("Clippers");
insert vertex team(name) values "team208":("Kings");
insert vertex team(name) values "team209":("Timberwolves");
insert vertex team(name) values "team210":("Lakers");
insert vertex team(name) values "team211":("Pelicans");
insert vertex team(name) values "team212":("Grizzlies");
insert vertex team(name) values "team213":("Mavericks");
insert vertex team(name) values "team214":("Suns");
insert vertex team(name) values "team215":("Hornets");
insert vertex team(name) values "team216":("Cavaliers");
insert vertex team(name) values "team217":("Celtics");
insert vertex team(name) values "team218":("Raptors");
insert vertex team(name) values "team219":("76ers");
insert vertex team(name) values "team220":("Pacers");
insert vertex team(name) values "team221":("Bulls");
insert vertex team(name) values "team222":("Hawks");
insert vertex team(name) values "team223":("Knicks");
insert vertex team(name) values "team224":("Pistons");
insert vertex team(name) values "team225":("Bucks");
insert vertex team(name) values "team226":("Magic");
insert vertex team(name) values "team227":("Nets");
insert vertex team(name) values "team228":("Wizards");
insert vertex team(name) values "team229":("Heat");
insert edge follow(degree) values "player100"->"player101":(95);
insert edge follow(degree) values "player100"->"player125":(95);
insert edge follow(degree) values "player101"->"player100":(95);
insert edge follow(degree) values "player101"->"player125":(95);
insert edge follow(degree) values "player101"->"player102":(90);
insert edge follow(degree) values "player125"->"player100":(90);
insert edge follow(degree) values "player102"->"player101":(75);
insert edge follow(degree) values "player102"->"player100":(75);
insert edge follow(degree) values "player103"->"player102":(70);
insert edge follow(degree) values "player104"->"player101":(50);
insert edge follow(degree) values "player104"->"player100":(55);
insert edge follow(degree) values "player104"->"player105":(60);
insert edge follow(degree) values "player105"->"player104":(83);
insert edge follow(degree) values "player105"->"player100":(70);
insert edge follow(degree) values "player105"->"player116":(80);
insert edge follow(degree) values "player107"->"player100":(80);
insert edge follow(degree) values "player108"->"player101":(80);
insert edge follow(degree) values "player108"->"player100":(80);
insert edge follow(degree) values "player109"->"player100":(80);
insert edge follow(degree) values "player109"->"player125":(90);
insert edge follow(degree) values "player113"->"player100":(99);
insert edge follow(degree) values "player113"->"player101":(99);
insert edge follow(degree) values "player113"->"player125":(99);
insert edge follow(degree) values "player113"->"player104":(99);
insert edge follow(degree) values "player113"->"player105":(99);
insert edge follow(degree) values "player113"->"player116":(99);
insert edge follow(degree) values "player113"->"player118":(99);
insert edge follow(degree) values "player113"->"player121":(99);
insert edge follow(degree) values "player113"->"player106":(99);
insert edge follow(degree) values "player113"->"player119":(99);
insert edge follow(degree) values "player113"->"player120":(99);
insert edge follow(degree) values "player114"->"player115":(90);
insert edge follow(degree) values "player114"->"player140":(90);
insert edge follow(degree) values "player114"->"player103":(90);
insert edge follow(degree) values "player116"->"player141":(100);
insert edge follow(degree) values "player118"->"player131":(90);
insert edge follow(degree) values "player118"->"player120":(90);
insert edge follow(degree) values "player120"->"player118":(80);
insert edge follow(degree) values "player121"->"player116":(90);
insert edge follow(degree) values "player121"->"player128":(90);
insert edge follow(degree) values "player121"->"player129":(90);
insert edge follow(degree) values "player124"->"player141":(-1);
insert edge follow(degree) values "player126"->"player116":(13);
insert edge follow(degree) values "player127"->"player114":(90);
insert edge follow(degree) values "player127"->"player148":(70);
insert edge follow(degree) values "player128"->"player116":(90);
insert edge follow(degree) values "player128"->"player121":(90);
insert edge follow(degree) values "player128"->"player129":(90);
insert edge follow(degree) values "player129"->"player116":(90);
insert edge follow(degree) values "player129"->"player121":(90);
insert edge follow(degree) values "player129"->"player128":(90);
insert edge follow(degree) values "player130"->"player149":(80);
insert edge follow(degree) values "player131"->"player118":(95);
insert edge follow(degree) values "player133"->"player114":(90);
insert edge follow(degree) values "player133"->"player144":(90);
insert edge follow(degree) values "player134"->"player121":(-1);
insert edge follow(degree) values "player135"->"player102":(80);
insert edge follow(degree) values "player136"->"player147":(90);
insert edge follow(degree) values "player136"->"player137":(88);
insert edge follow(degree) values "player136"->"player117":(90);
insert edge follow(degree) values "player136"->"player148":(85);
insert edge follow(degree) values "player137"->"player136":(80);
insert edge follow(degree) values "player137"->"player148":(80);
insert edge follow(degree) values "player137"->"player129":(10);
insert edge follow(degree) values "player138"->"player115":(90);
insert edge follow(degree) values "player138"->"player139":(99);
insert edge follow(degree) values "player139"->"player138":(99);
insert edge follow(degree) values "player140"->"player114":(90);
insert edge follow(degree) values "player141"->"player124":(9);
insert edge follow(degree) values "player142"->"player117":(90);
insert edge follow(degree) values "player143"->"player150":(90);
insert edge follow(degree) values "player144"->"player145":(100);
insert edge follow(degree) values "player144"->"player100":(80);
insert edge follow(degree) values "player147"->"player136":(90);
insert edge follow(degree) values "player148"->"player127":(80);
insert edge follow(degree) values "player148"->"player136":(90);
insert edge follow(degree) values "player148"->"player137":(85);
insert edge follow(degree) values "player149"->"player130":(80);
insert edge follow(degree) values "player150"->"player137":(90);
insert edge follow(degree) values "player150"->"player143":(90);
insert edge follow(degree) values "player150"->"player120":(80);
insert edge serve(start_year,end_year) values "player100"->"team204":(1997, 2016);
insert edge serve(start_year,end_year) values "player101"->"team204":(1999, 2018);
insert edge serve(start_year,end_year) values "player101"->"team215":(2018, 2019);
insert edge serve(start_year,end_year) values "player102"->"team203":(2006, 2015);
insert edge serve(start_year,end_year) values "player102"->"team204":(2015, 2019);
insert edge serve(start_year,end_year) values "player103"->"team212":(2006, 2013);
insert edge serve(start_year,end_year) values "player103"->"team218":(2013, 2013);
insert edge serve(start_year,end_year) values "player103"->"team208":(2013, 2017);
insert edge serve(start_year,end_year) values "player103"->"team204":(2017, 2019);
insert edge serve(start_year,end_year) values "player104"->"team200":(2007, 2009);
insert edge serve(start_year,end_year) values "player104"->"team218":(2009, 2010);
insert edge serve(start_year,end_year) values "player104"->"team215"@20102012:(2010, 2012);
insert edge serve(start_year,end_year) values "player104"->"team221":(2012, 2013);
insert edge serve(start_year,end_year) values "player104"->"team204"@20132015:(2013, 2015);
insert edge serve(start_year,end_year) values "player104"->"team208":(2015, 2016);
insert edge serve(start_year,end_year) values "player104"->"team215"@20162017:(2016, 2017);
insert edge serve(start_year,end_year) values "player104"->"team222":(2017, 2018);
insert edge serve(start_year,end_year) values "player104"->"team219":(2018, 2018);
insert edge serve(start_year,end_year) values "player104"->"team204"@20182019:(2018, 2019);
insert edge serve(start_year,end_year) values "player105"->"team216":(2009, 2010);
insert edge serve(start_year,end_year) values "player105"->"team204":(2010, 2018);
insert edge serve(start_year,end_year) values "player105"->"team218":(2018, 2019);
insert edge serve(start_year,end_year) values "player106"->"team204":(2014, 2018);
insert edge serve(start_year,end_year) values "player106"->"team212":(2018, 2019);
insert edge serve(start_year,end_year) values "player107"->"team204":(2013, 2015);
insert edge serve(start_year,end_year) values "player107"->"team224":(2015, 2017);
insert edge serve(start_year,end_year) values "player107"->"team217":(2017, 2019);
insert edge serve(start_year,end_year) values "player108"->"team222":(2003, 2005);
insert edge serve(start_year,end_year) values "player108"->"team214":(2005, 2008);
insert edge serve(start_year,end_year) values "player108"->"team215":(2008, 2012);
insert edge serve(start_year,end_year) values "player108"->"team204":(2012, 2016);
insert edge serve(start_year,end_year) values "player108"->"team206":(2016, 2017);
insert edge serve(start_year,end_year) values "player109"->"team204":(2010, 2015);
insert edge serve(start_year,end_year) values "player109"->"team222":(2015, 2017);
insert edge serve(start_year,end_year) values "player109"->"team219":(2017, 2017);
insert edge serve(start_year,end_year) values "player110"->"team204":(2011, 2015);
insert edge serve(start_year,end_year) values "player110"->"team218":(2015, 2017);
insert edge serve(start_year,end_year) values "player110"->"team220":(2017, 2019);
insert edge serve(start_year,end_year) values "player111"->"team215":(2003, 2011);
insert edge serve(start_year,end_year) values "player111"->"team220":(2011, 2015);
insert edge serve(start_year,end_year) values "player111"->"team204":(2015, 2016);
insert edge serve(start_year,end_year) values "player111"->"team200":(2016, 2018);
insert edge serve(start_year,end_year) values "player112"->"team204":(2015, 2017);
insert edge serve(start_year,end_year) values "player112"->"team226":(2017, 2019);
insert edge serve(start_year,end_year) values "player112"->"team219":(2019, 2019);
insert edge serve(start_year,end_year) values "player113"->"team204":(2016, 2019);
insert edge serve(start_year,end_year) values "player114"->"team218":(1997, 2000);
insert edge serve(start_year,end_year) values "player114"->"team226":(2000, 2004);
insert edge serve(start_year,end_year) values "player114"->"team202":(2004, 2010);
insert edge serve(start_year,end_year) values "player114"->"team204":(2013, 2013);
insert edge serve(start_year,end_year) values "player115"->"team210":(1996, 2016);
insert edge serve(start_year,end_year) values "player116"->"team216"@20032010:(2003, 2010);
insert edge serve(start_year,end_year) values "player116"->"team229":(2010, 2014);
insert edge serve(start_year,end_year) values "player116"->"team216"@20142018:(2014, 2018);
insert edge serve(start_year,end_year) values "player116"->"team210":(2018, 2019);
insert edge serve(start_year,end_year) values "player117"->"team200":(2009, 2019);;
insert edge serve(start_year,end_year) values "player118"->"team205":(2008, 2019);
insert edge serve(start_year,end_year) values "player119"->"team205":(2007, 2016);
insert edge serve(start_year,end_year) values "player119"->"team200":(2016, 2019);
insert edge serve(start_year,end_year) values "player120"->"team205":(2009, 2012);
insert edge serve(start_year,end_year) values "player120"->"team202":(2012, 2019);
insert edge serve(start_year,end_year) values "player121"->"team215":(2005, 2011);
insert edge serve(start_year,end_year) values "player121"->"team207":(2011, 2017);
insert edge serve(start_year,end_year) values "player121"->"team202":(2017, 2021);
insert edge serve(start_year,end_year) values "player122"->"team207":(2008, 2018);
insert edge serve(start_year,end_year) values "player122"->"team213":(2018, 2019);
insert edge serve(start_year,end_year) values "player122"->"team223":(2019, 2019);
insert edge serve(start_year,end_year) values "player123"->"team209":(2011, 2017);
insert edge serve(start_year,end_year) values "player123"->"team206":(2017, 2019);
insert edge serve(start_year,end_year) values "player124"->"team217":(2006, 2014);
insert edge serve(start_year,end_year) values "player124"->"team213":(2014, 2015);
insert edge serve(start_year,end_year) values "player124"->"team208":(2015, 2016);
insert edge serve(start_year,end_year) values "player124"->"team221":(2016, 2017);
insert edge serve(start_year,end_year) values "player124"->"team211":(2017, 2018);
insert edge serve(start_year,end_year) values "player124"->"team210":(2018, 2019);
insert edge serve(start_year,end_year) values "player125"->"team204":(2002, 2018);
insert edge serve(start_year,end_year) values "player126"->"team216":(2011, 2017);
insert edge serve(start_year,end_year) values "player126"->"team217":(2017, 2019);
insert edge serve(start_year,end_year) values "player127"->"team218":(1998, 2004);
insert edge serve(start_year,end_year) values "player127"->"team227":(2004, 2009);
insert edge serve(start_year,end_year) values "player127"->"team226":(2009, 2010);
insert edge serve(start_year,end_year) values "player127"->"team214":(2010, 2011);
insert edge serve(start_year,end_year) values "player127"->"team213":(2011, 2014);
insert edge serve(start_year,end_year) values "player127"->"team212":(2014, 2017);
insert edge serve(start_year,end_year) values "player127"->"team208":(2017, 2018);
insert edge serve(start_year,end_year) values "player127"->"team222":(2018, 2019);
insert edge serve(start_year,end_year) values "player128"->"team201":(2003, 2011);
insert edge serve(start_year,end_year) values "player128"->"team223":(2011, 2017);
insert edge serve(start_year,end_year) values "player128"->"team205":(2017, 2018);
insert edge serve(start_year,end_year) values "player128"->"team202":(2018, 2019);
insert edge serve(start_year,end_year) values "player129"->"team229"@20032016:(2003, 2016);
insert edge serve(start_year,end_year) values "player129"->"team221":(2016, 2017);
insert edge serve(start_year,end_year) values "player129"->"team216":(2017, 2018);
insert edge serve(start_year,end_year) values "player129"->"team229"@20182019:(2018, 2019);
insert edge serve(start_year,end_year) values "player130"->"team219":(2014, 2019);
insert edge serve(start_year,end_year) values "player131"->"team220":(2010, 2017);
insert edge serve(start_year,end_year) values "player131"->"team205":(2017, 2019);
insert edge serve(start_year,end_year) values "player132"->"team225":(2013, 2019);
insert edge serve(start_year,end_year) values "player133"->"team202":(2002, 2011);
insert edge serve(start_year,end_year) values "player134"->"team207":(2009, 2018);
insert edge serve(start_year,end_year) values "player134"->"team224":(2018, 2019);
insert edge serve(start_year,end_year) values "player135"->"team203":(2012, 2019);
insert edge serve(start_year,end_year) values "player136"->"team214"@19961998:(1996, 1998);
insert edge serve(start_year,end_year) values "player136"->"team213":(1998, 2004);
insert edge serve(start_year,end_year) values "player136"->"team214"@20042012:(2004, 2012);
insert edge serve(start_year,end_year) values "player136"->"team210":(2012, 2015);
insert edge serve(start_year,end_year) values "player137"->"team213":(1998, 2019);
insert edge serve(start_year,end_year) values "player138"->"team212":(2001, 2008);
insert edge serve(start_year,end_year) values "player138"->"team210":(2008, 2014);
insert edge serve(start_year,end_year) values "player138"->"team221":(2014, 2016);
insert edge serve(start_year,end_year) values "player138"->"team204":(2016, 2019);
insert edge serve(start_year,end_year) values "player138"->"team225":(2019, 2020);
insert edge serve(start_year,end_year) values "player139"->"team212":(2008, 2019);
insert edge serve(start_year,end_year) values "player139"->"team218":(2019, 2019);
insert edge serve(start_year,end_year) values "player140"->"team224":(1994, 2000);
insert edge serve(start_year,end_year) values "player140"->"team226":(2000, 2007);
insert edge serve(start_year,end_year) values "player140"->"team214":(2007, 2012);
insert edge serve(start_year,end_year) values "player140"->"team207":(2012, 2013);
insert edge serve(start_year,end_year) values "player141"->"team225":(1996, 2003);
insert edge serve(start_year,end_year) values "player141"->"team205":(2003, 2007);
insert edge serve(start_year,end_year) values "player141"->"team217":(2007, 2012);
insert edge serve(start_year,end_year) values "player141"->"team229":(2012, 2014);
insert edge serve(start_year,end_year) values "player142"->"team200":(2011, 2019);
insert edge serve(start_year,end_year) values "player143"->"team223":(2015, 2019);
insert edge serve(start_year,end_year) values "player143"->"team213":(2019, 2020);
insert edge serve(start_year,end_year) values "player144"->"team226":(1992, 1996);
insert edge serve(start_year,end_year) values "player144"->"team210":(1996, 2004);
insert edge serve(start_year,end_year) values "player144"->"team229":(2004, 2008);
insert edge serve(start_year,end_year) values "player144"->"team214":(2008, 2009);
insert edge serve(start_year,end_year) values "player144"->"team216":(2009, 2010);
insert edge serve(start_year,end_year) values "player144"->"team217":(2010, 2011);
insert edge serve(start_year,end_year) values "player145"->"team228":(2008, 2012);
insert edge serve(start_year,end_year) values "player145"->"team201":(2012, 2015);
insert edge serve(start_year,end_year) values "player145"->"team213":(2015, 2016);
insert edge serve(start_year,end_year) values "player145"->"team200":(2016, 2018);
insert edge serve(start_year,end_year) values "player145"->"team210":(2018, 2019);
insert edge serve(start_year,end_year) values "player146"->"team226":(2004, 2012);
insert edge serve(start_year,end_year) values "player146"->"team210":(2012, 2013);
insert edge serve(start_year,end_year) values "player146"->"team202":(2013, 2016);
insert edge serve(start_year,end_year) values "player146"->"team222":(2016, 2017);
insert edge serve(start_year,end_year) values "player146"->"team215":(2017, 2018);
insert edge serve(start_year,end_year) values "player146"->"team228":(2018, 2019);
insert edge serve(start_year,end_year) values "player147"->"team214":(2002, 2010);
insert edge serve(start_year,end_year) values "player147"->"team223":(2010, 2015);
insert edge serve(start_year,end_year) values "player147"->"team229":(2015, 2016);
insert edge serve(start_year,end_year) values "player148"->"team213"@19941996:(1994, 1996);
insert edge serve(start_year,end_year) values "player148"->"team214":(1996, 2001);
insert edge serve(start_year,end_year) values "player148"->"team227":(2001, 2008);
insert edge serve(start_year,end_year) values "player148"->"team213"@20082012:(2008, 2012);
insert edge serve(start_year,end_year) values "player148"->"team223":(2012, 2013);
insert edge serve(start_year,end_year) values "player149"->"team219":(2016, 2019);
insert edge serve(start_year,end_year) values "player150"->"team213":(2018, 2019);

15. 路径 walk、trail、path

在图数据库和图论中，walk、trail 和 path 是描述顶点与顶点之间连接方式的概念，主要用于定义如何遍历或分析图结构。在 NebulaGraph 中，这些概念也有重要的作用，尤其是在路径查询和模式匹配中。

15.1 Walk

  • 定义：Walk 是一种可以重复访问顶点和边的路径。
    • 顶点和边可以被多次重复使用。
    • 没有约束条件，只要符合路径关系即可。
  • 特性：
    • 最宽松的路径规则。
    • 可包含环（即路径中可以有重复的顶点和边）。
  • 用途：
    • 探索所有可能路径：在分析图时，用于探索任意两点之间的所有可能连接，无论是否有环。
    • 循环检测：用于分析某个区域是否有环存在。
  • 示例： 在一个社交网络中，查找从用户A到用户B的所有关系路径，无论这些关系是否重复。

walk类型的路径由有限或无限的边序列构成。遍历时点和边可以重复。

查看示例图，由于 C、D、E 构成了一个环，因此该图包含无限个路径，例如A->B->C->D->E、A->B->C->D->E->C、A->B->C->D->E->C->D。
在这里插入图片描述

15.2 trail（踪迹）

  • 定义：Trail 是一种可以重复访问顶点，但不能重复使用边的路径。

    • 边必须是唯一的（不能重复访问），但顶点可以重复访问。

  • 特性：

    • 介于 Walk 和 Path 之间。
    • 允许回到已经访问过的顶点，但不允许重复走过同一条边。

  • 用途：

    • 分析图中的特定连接：用于查找不重复边的路径，这在表示实际资源（如网络流量、物流运输）时很有用。
    • 查找非重复的传输方式：例如从一个城市到另一个城市的所有独特运输路线。

  • 示例： 查找从用户A到用户B的独特朋友关系路径（不重复的边），但允许访问某些共同朋友多次。

trail类型的路径由有限的边序列构成。遍历时只有点可以重复，边不可以重复。柯尼斯堡七桥问题的路径类型就是trail。

查看示例图，由于边不可以重复，所以该图包含有限个路径，最长路径由 5 条边组成：A->B->C->D->E->C。

在这里插入图片描述

15.3 path

path类型的路径由有限的边序列构成。遍历时点和边都不可以重复。

查看示例图，由于点和边都不可以重复，所以该图包含有限个路径，最长路径由 4 条边组成：A->B->C->D->E。
在这里插入图片描述

2024年11月大数据月报
SmartSi
12-01 1638
2024年11月数据月报，为您准备了阿里、字节、百度等大厂140多篇实践案例
NL2SQL技术方案系列(2)：全系列技术选型完整版：从通用技术选型(向量、图数据库)、大模型选择、Prompt工程、前沿技术方案展示
丨汀、的博客
04-23 2626
NL2SQL技术方案系列(2)：全系列技术选型完整版：从通用技术选型(向量、图数据库)、大模型选择、Prompt工程、前沿技术方案展示
Nebula Graph-04-NebulaGraph nGQL的介绍和使用
苍煜
03-22 2194
nGQL是 NebulaGraph 使用的的声明式图查询语言，支持灵活高效的图模式，而且 nGQL 是为开发和运维人员设计的类 SQL 查询语言，易于学习。整体看下来，nGQL给我的感觉虽然是Nebula Graph 自己研发的语言，但是综合了mysql等关系数据库语言和java等高级编程语言整合而来的。内容太多，需要用心学习。NebulaGraph 独有 DQL 查询语句（Data Query Language）
一文带你学懂分布式图数据库 Nebula Graph 的 Index 实践
weixin_41663412的博客
03-12 972
个人博客导航页（点击右侧链接即可打开个人博客）：大牛带你入门技术栈 导读 索引是数据库系统中不可或缺的一个功能，数据库索引好比是书的目录，能加快数据库的查询速度，其实质是数据库管理系统中一个排序的数据结构。不同的数据库系统有不同的排序结构，目前常见的索引实现类型如 B-Tree index、B+-Tree index、B*-Tree index、Hash index、Bitmap ind...
NebulaGraph 索引深度解析：从基础语法到实战优化的完整指南
最新发布
佑瞻的博客
05-06 646
ngqlWHERE ES_QUERY(user_full_idx, "name:华* AND bio:工程师")-- 显示匹配分数ngqlWHERE ES_QUERY(user_full_idx, "name:小*^4 OR bio:小*")-- 姓名匹配结果分数更高plaintext查询类型 → 结构化查询？├─ 是 → 单属性/复合索引（数值/短字符串）├─ 否 → 全文索引（长文本/模糊搜索）└─ 按类型筛选 → 标签/边类型索引。
NebulaGraph快速入门
樱吹雪
12-31 3079
NebulaGraph是图数据库的一种，不同于mysql类数据库的表关系，整个space内分为顶点（tag）和边(edge)，构成一种图的网状关系，每个顶点都有一个全局唯一的顶点id(vid)。 具体帮助文档：https://docs.nebula-graph.com.cn/ 现进行具体说明： 一、库级操作语句 1、查看所有库： show spaces; 2、查看库信息： describe space sqlLineage; 二、tag语句-》确定顶点的类型和承载信息 1、查看所有tag： show t
NebulaGraph基础（默认看了入门篇）
GodGump的博客
02-28 824
为啥这个常用，因为有的编码为gbk有的UTF甚至还有公司自定义编码，这是为了不乱码（目前可用的字符集为utf8和utf8mb4。集合运算符前后的查询语句中定义的变量名及顺序必需保持一致，例如RETURN a,b,c UNION RETURN a,b,c中的a,b,c的名称及顺序需要保持一致。请注意left和right的顺序，A-B表示在集合 A 中，但是不在集合 B 中的元素。如果登录的用户角色是GOD，或者有权访问该图空间的ADMIN，则返回该图空间内除GOD之外的所有用户角色信息。
快速入门nebula graph
凌陨心
01-20 6874
nubula graph 是一款开源分布式易拓展的原生图数据库，能够承载数千亿个点和数万亿条边的超大规模数据集，并且提供毫秒级查询。
NebulaGraph入门
GodGump的博客
02-28 1368
NebulaGraph 是一款开源的、分布式的、易扩展的原生图数据库，能够承载包含数千亿个点和数万亿条边的超大规模数据集，并且提供毫秒级查询。nGQL是 NebulaGraph 使用的的声明式图查询语言，支持灵活高效的图模式，而且 nGQL 是为开发和运维人员设计的类 SQL 查询语言，易于学习。
150 使用Llama Index实现知识图谱RAG查询引擎：从入门到精通
xycxycooo的博客
09-26 729
通过Llama Index的，我们可以轻松地从现有知识图谱中检索信息，并使用自然语言进行查询。无论是使用Graph RAG还是结合nl2graphquery，Llama Index都提供了强大的工具来处理知识图谱任务。希望这篇博客能帮助你更好地理解和应用知识图谱技术。
【Neo4j 】学习笔记：GraphRAG 宣言：为 GenAI 添加知识
突围
07-15 964
GraphRAG 宣言：为 GenAI 添加知识
3.知识图谱业务落地技术推荐之图数据库汇总
丨汀、的博客
02-13 1495
图数据库的优势 关系型数据库实现了快速的逐行访问和数据一致性(ACID 事务)，但当数据规模变大且数据间关系变得复杂时，使用关系模型检索时需要多个表的属性执行连接操作，数据写入时也需考虑外键约束，从而导致较大的额外开销，产生严重的性能问题。而图数据库则在处理复杂关系上有着天然优势，在海量数据的多对多的复杂实体联系场景中有着异常突出的表现，主要体现在： • 高性能： 图数据库相较于关系型数据库和其它非关系型数据库，在处理深度关联数据时，具有绝对的性能提升。 • 灵活： 图数据库提供了极其灵活的数据模型，可以根
NebulaGraph常用操作入门
u010479989的博客
01-15 1175
找出特定节点 m（ID为 "player100" 的节点）直接连接的节点，以及这些节点 n 直连的下一层节点 l (OPTIONAL MATCH (n)-[]->(l))， 如果没有找到这样的节点 l，查询也会继续， l 的返回值是 null。GO语句采用的路径类型是walk，即遍历时点和边都可以重复。# 查询所有 degree 等于 60 的边，返回边的目的点 ID 和边的 degree 属性值，并为此起始点进行遍历，返回遍历结果。# 查询所有 age 大于 45 的点数据，并返回点数据的 ID。
图数据库NebulaGraph学习
SimpleSimpleSimples的博客
12-22 1983
CREATE SPACE play_space (partition_num = 10, replica_factor = 1, vid_type = INT64) COMMENT = "运动员库表空间";CREATE SPACE play_space (partition_num = 10, replica_factor = 1, vid_type = FIXED_STRING(32)) COMMENT = "运动员库表空间";
NebulaGraph图数据库使用教程
冰万森的博客
07-26 1403
​NebulaGraph 是一个开源的分布式图数据库，相比 Neo4j 来说，它的主要特点是完全的分布式，因此图数据库 NebulaGraph 适合处理数据量超过单机的场景。
Nebula Graph学习篇1_基础概念、初步使用、整合SpringBoot使用
xiaosi的博客
05-09 5613
目录 一、基础概念 二、初步使用 一、基础概念 1、图数据库概念 Nebula Graph 是一款开源的、分布式的、易扩展的原生图数据库，能够承载包含数千亿个点和数万亿条边的超大规模数据集，并且提供毫秒级查询。 官网：https://nebula-graph.com.cn/ segmentfault：https://segmentfault.com/t/nebula 中文文档：https://docs.nebula-graph.com.cn/3.1.0/1.introduction/2.1.path/ g
nebulagraphDB使用教程——常用命令
m0_54230514的博客
09-05 1378
因为studio版本需要与nebulagraph的版本适配，我下载的是nebulagraphDB3.8.0版本，因此需要下载最新版的studio。点击查看文档后也会有版本兼容的对比表格。关于nebulagraphDB的下载，完全依靠最新版官网教程进行下载。然后根据版本兼容去下载合适版本的studio ，下载后使用命令安装。因为我使用的是ubuntu系统，因此下载的是deb的安装包。（可以直接官网下载，也可以先进入文档使用wget命令下载）（下载后根据官网文档的本地部署中的步骤一步一步完成即可）
Nebula Graph-03-NebulaGraph Studio-可视化web工具安装和使用
苍煜
03-21 4143
NebulaGraph Studio（简称 Studio）是一款可以通过 Web 访问的开源图数据库可视化工具，搭配 NebulaGraph 内核使用，提供构图、数据导入、编写 nGQL 查询等一站式服务。产品功能¶使用 Schema 管理功能，用户可以使用图形界面完成图空间、Tag（标签）、Edge Type（边类型）、索引的创建，查看图空间的统计数据，快速上手 NebulaGraph。使用导入功能，通过简单的配置，用户即能批量导入点和边数据，并能实时查看数据导入日志。
Nebula Graph 系列(1) —— 初识 Nebula
qq_38219153的博客
03-03 3289
初识 Nebula 文章目录初识 Nebula前置知识什么是 Nebula什么是图数据库Nebula 的优点Nebula 的使用场景Nebula 的安装二进制压缩包安装使用 nGql 操作 Nebula图空间的操作顶点与边的定义插入顶点和边删除顶点和边查询操作match 语句（openCypehr 支持）lookup 语句go 语句（依据路劲查询属性）fetch 语句（获取指定边或者点的属性值）图与路劲的查询get subgraph 语句find path 子句 前置知识 什么是 Nebula Nebula
sql server 中exists详细用法
05-09
在 SQL Server 中，`EXISTS` 是一个用于检查是否存在符合特定条件的记录的逻辑运算符。`EXISTS` 返回一个布尔值，即 `TRUE` 或 `FALSE`，表示查询结果集是否包含匹配条件的记录。下面是 `EXISTS` 的详细用法： 1. 基本语法： ```sql SELECT column_name(s) FROM table_name WHERE EXISTS (SELECT column_name FROM table_name WHERE condition); ``` 2. 示例： 假设有两个表，分别为 `customers` 和 `orders`， `customers` 表中包含了所有客户的信息，而 `orders` 表中包含了所有的订单信息。我们需要查询所有已经下过订单的客户的姓名和地址，可以使用以下 SQL 语句： ```sql SELECT customerName, address FROM customers WHERE EXISTS (SELECT * FROM orders WHERE orders.customerID = customers.customerID); ``` 在上面的 SQL 语句中，`EXISTS` 子查询中的条件是查找 `orders` 表中的所有记录，其中 `orders.customerID = customers.customerID` 表示连接两个表的条件，即匹配两个表中的 `customerID` 列。如果 `EXISTS` 子查询返回 `TRUE`，则 `customerName` 和 `address` 列的值会被返回。 3. 注意事项： - `EXISTS` 子查询必须包含一个 `SELECT` 语句，该语句必须返回一个结果集。 - `EXISTS` 子查询中的条件必须使用外部查询中的列或表。 - `EXISTS` 子查询中的 `SELECT` 语句可以是任何有效的 T-SQL 查询语句，包括 `SELECT *`。 - `EXISTS` 子查询中的条件可以包含任何有效的 T-SQL 表达式和运算符。 - `EXISTS` 的性能比使用 `JOIN` 进行连接查询要高，特别是在查询大型数据集时。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

boy快快长大

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

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

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

打赏作者

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

抵扣说明：

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

余额充值