Skip to main content

图应用开发

语法介绍​

语法编写规范​

语法示例

CREATE GRAPH [ IF NOT EXISTS ] <name>
[ PARTITION_NUM = <integer> ]
[ COMMENT = <string> ]
[ CHARSET = {UTF8 | UTF8MB4 | GBK | GB2312 | GB18030} ];

详细说明

  • 大写单词: 关键字。例如：CREATE, GRAPH。
  • < >：语法片段或子句。例如：<name>, <integer>。
  • [ ]：方括号内的内容是可选的。例如：[IF NOT EXISTS] 表示该片段可以省略。
  • [ ]...：方括号后跟省略号表示该片段可以出现零次或多次。
  • |：选择符，表示需要从提供的选项中选择一个。例如：{UTF8 | UTF8MB4 | GBK | GB2312 | GB18030} 表示需要从这几种字符集中选择一个。

语法介绍​

数据类型​

ArcGraph 图数据库中支持的属性数据类型如下。

英文中文说明
Byte字节类型用于表示二进制数据或存储小的整数值，包括 BYTE。
Integer整数  用于存储整数数据，包括 INT32、INT64 和 BIGINT。
Float单精度浮点数用于存储小数数据，包括 FLOAT。它遵循 IEEE-754 浮点数标准，提供约 7 位十进制有效数字的精度。
Double双精度浮点数用于存储非常大或非常小的浮点数值的数据类型，包括 DOUBLE。它遵循 IEEE-754 浮点数标准，提供约 16 位十进制有效数字的精度。
Boolean布尔值用于存储布尔值（True/False），包括 BOOL 或 BOOLEAN。
Timestamp时间戳用于存储日期和时间数据，包括 TIMESTAMP。
Date日期用于存储日期数据，包括 DATE。
Time时间用于存储时间数据，包括 TIME。
DateTime日期时间用于存储日期和时间数据，包括 DATETIME。
JSON-用于存储结构化的复杂数据，包括 JSON。
说明：
当对该数据类型的属性创建索引时，应使用 ->> 操作符明确指定 JSON 路径，例如 idx_person(name->>'$.last_name')。
String字符串用于存储文本数据，包括 String。
UUID通用唯一标识符是一个 128 位长的标识符，通常用于在分布式系统中唯一标识实体，包括 UUID。
说明：
不支持对该数据类型的属性创建索引。
Array数组数据类型数组数据类型是一种用于存储和操作一组有序元素的数据结构。在图数据库中，数组数据类型可以作为点或边的属性，以存储相同类型的多个值或其他需要按顺序存储的数据。语法定义如下：

ARRAY(<inner_type>[,<capacity>])

  • <inner_type>：表示数组中每个元素的数据类型，支持 INT32、INT64、FLOAT、String 四种类型。
  • [,<capacity>]：（可选）用于预分配数组的最大容量，指定数组能够存储的最大元素数量。

说明：
不支持对该数据类型的属性创建索引。
BigDecimal高精度小数类型用于存储和处理高精度的小数数值，遵循 BIGDECIMAL(prec,scale) 规范。其中，prec 表示总位数精度，取值范围是[10, 50]；scale 表示小数部分的刻度，取值范围是[0, 30]。默认精度设置为 BIGDECIMAL(35, 18)。
说明：
- 允许用户自定义精度范围，当数值超出指定的范围时系统会截断多余部分并以 0 填充，对于超出范围的第一位，系统将根据四舍五入原则进行处理，确保数值在指定精度内以精确格式展示。
- 该类型支持从 String 到 BigDecimal 的隐式类型转换，便于在插入语句中直接使用字符串表示小数，如 INSERT (:sample1 {id: 1, val: '124567890.098765438978967987'});。
-不支持对该数据类型的属性创建索引。
-仅 ArcGraph >= v2.1.1 版本支持此类型。
ST_GEOMETRY地理空间类型用于存储地理空间数据的数据类型。
说明：
仅 ArcGraph >= v2.1.2 版本支持此类型。

ArcGraph 图数据库中支持的非属性数据类型如下。

英文中文说明
List  列表数据类型用于存储一组有序的元素，元素可以是任意数据类型。在 ArcGraph 图数据库中，列表数据类型由“[]”符号和多个元素组成，各个元素间使用英文逗号（,）分隔。请注意，列表数据类型不可以作为点或边的属性。

模式​

ArcGraph 图数据库对 Cypher 查询语言中的模式（Patterns）提供了广泛的支持，以下将介绍 ArcGraph 图数据库中常用的几种模式。

分类说明
Nodes表示图数据库中的点，在 ArcGraph 图数据库中用 Vertex（点）表示。
Related nodes表示多个点以及它们之间的关系。如 (a)-[]->(b)。
Specifiying properties表示在点或边上使用属性以进行精确匹配或查询。
Relationships表示图数据库中各点间的关联关系，在 ArcGraph 图数据库中用 Edge（边）表示。
Variable-length patterns表示允许使用可变长度的模式来匹配具有特定长度的路径。
Path variable表示允许将匹配到的整个路径作为一个整体进行操作或返回。

  • 描述点（Vertex）

    表达方式说明
    ()匿名的点
    (John)指定变量名的点
    (:person)指定点类型的点
    (John:person)指定变量名和点类型的点
    (John:person {name: "John"})有变量名、点类型和属性值的点
    (John:person {name: "John", age: 30})有变量名、点类型和联合属性值的点

  • 描述边（Edge）

    使用一对短横线（即“--”）表示一个无方向边，有方向的边则在其中一端加上一个箭头（即“<--”或“-->”）。方括号表达式“[…]”可用于添加详情，表达式中可以包含变量、属性、类型等信息。边的常见表达方式如下：

    表达方式说明
    --无向边
    -->正向边
    <-- 反向边
    -[r]-> 指定变量名的正向边
    -[:like]->指定边类型的正向边
    -[r:like]->带有变量名和边类型的正向边
    -[r:like {name: "喜欢"}]->带有变量名、边类型、属性值的边

在 ArcGraph 图数据库中，使用类 Cypher 代码将两个简单的模式（Pattern）连接在一起，示例如下：

(:person) -[:like]-> (:person)

子句​

ArcGraph 图数据库支持 Cypher 查询语言中的多种子句（Clauses），这些子句为数据查询提供了强大的功能。以下将介绍 ArcGraph 图数据库中常用的几种子句，关于子句的详细介绍请参见 子句 章节。

子句说明
MATCH用于根据指定的模式（pattern）查询图。详情请参见 基本查询 章节。
OPTIONAL MATCH与 MATCH 子句类似，但不同之处在于，当查询结果为空时，该子句会对缺失部分返回 null 值。
RETURN用于指定查询结果的返回格式。详情请参见 RETURN 章节。
WITH用于在查询过程中将中间结果传递给后续的查询子句，即通过 WITH 子句，将一个查询的输出直接作为下一个查询的输入。详情请参见 WITH 章节。
UNWIND用于将列表元素展开为独立的记录序列。详情请参见 UNWIND 章节。
WHERE用于指定过滤条件，可以与 MATCH、OPTIONAL MATCH 或 WITH 子句组合使用。详情请参见 WHERE 章节。
ORDER BY用于对（中间）结果进行排序，可以与 RETURN 或 WITH 子句组合使用。详情请参见 ORDER BY 章节。
SKIP用于跳过查询结果中的前 n 个记录。详情请参见 SKIP 章节。
LIMIT用于限制查询结果返回的个数。详情请参见 LIMIT 章节。
CREATE用于在图数据库中创建点、边等。
DELETE用于删除指定的点、边等。
SET用于修改已存在的点、边的属性值或类型。
CALL[...YIELD]用于调用图数据库内置过程。
UNION用于合并多个查询的结果。详情请参见 UNION 章节。

表达式​

ArcGraph 图数据库支持 Cypher 查询语言中的多种表达式（Expressions），以下将介绍 ArcGraph 图数据库中常用的几种表达式，关于表达式的详细介绍请参见 表达式 章节。

表达式说明
常量常量表示固定的数值或文本。例如，数字 42、字符串 "hello"、布尔值 true 或 false 等。
变量变量是一种用于指代图数据库中点、边及其属性值的标识符。例如，n:person 中，n 是一个变量，它指代了一个 person 类型。
属性属性是对象的一部分，用于描述对象的特性，例如，一个 Person 对象可能有一个 name 属性。
函数调用函数调用是执行特定函数并向其传递必要参数以执行特定任务的过程。例如，sum(2, 3) 是一个函数调用，其中 sum 是一个函数，2 和 3 是参数。
聚合函数聚合函数是用于对一组值做聚合运算的函数。例如，SUM()、AVG()、MAX()、MIN() 和 COUNT() 。
计算表达式计算表达式由数据和运算符组成，用于执行计算并返回结果，例如，2 + 3 * 4 是一个计算表达式。
谓词表达式谓词表达式返回一个布尔值（true 或 false），通常用于条件判断。例如，x > 10 是一个谓词表达式。

操作符​

ArcGraph 图数据库支持 Cypher 查询语言中的多种操作符，以满足用户对于数据查询、计算、比较和逻辑判断的需求。以下将介绍 ArcGraph 图数据库中常用的几种操作符。

操作符描述
通用操作符用于执行基本的查询操作，如 DISTINCT（用于返回唯一不同的值）、.（用于属性访问）。
数学运算操作符用于在 Cypher 查询中执行基本的数学运算，如 + （加法）、-（减法）、*（乘法）、/（除法）和 %（取模）。
比较运算操作符用于在 Cypher 查询中比较两个值，如 =（等于）、<>（不等于）、!=（不等于）、<（小于）、>（大于）、<=（小于等于）和 >=（大于等于）。
字符串比较操作符用于处理字符串类型的比较操作，如 STARTS WITH（用于检查字符串是否以指定子串开始）、ENDS WITH（用于检查字符串是否以指定子串结束）或 CONTAINS（用于检查字符串是否包含指定子串）。
布尔运算操作符用于在 Cypher 查询中执行逻辑运算，如 AND（逻辑与）、OR（逻辑或）和 NOT（逻辑非）。
字符串操作符主要用于处理字符串类型的值，如 +（用于字符串连接操作）和 IN（用于检查一个值是否存在于一个字符串列表中）。

内置函数​

ArcGraph 图数据库支持丰富的内置函数，这些函数为用户提供了强大的数据处理能力。以下将介绍 ArcGraph 图数据库中常用的几种内置函数，关于内置函数的详细介绍请参见 内置函数 章节。

函数类型说明
字符串函数对字符串进行操作的函数，如 concat()、concat_ws() 等。详情请参见 字符串函数 章节。
数学函数包括常见的数学运算，如 abs()、cos() 等。详情请参见 数学函数 章节。
日期时间函数提供关于时间和日期处理的函数，如 timestamp()、date() 等，详情请参见 日期时间函数 章节。
工具函数提供一些通用函数，如 randomUUID() 等，详情请参见 工具函数 章节。
聚合函数用于对一组值进行计算，并返回单个值作为结果的函数，如 avg()、sum() 等，详情请参见 聚合函数 章节。
Graph 函数用于图数据处理的函数，如 id()、pk() 等，详情请参见 Graph 函数 章节。
转换函数用户数据类型之间相互转换的函数，如 toBoolean()、toFloat() 等，详情请参见 转换函数 章节。
对数函数用于对数计算的函数，如 log()、log10() 等，详情请参见 对数函数 章节。
Partial 函数用于数据脱敏的函数，详情请参见 Partial 函数 章节。
路径函数用于查询和分析路径的函数，如 startNode()、endNode() 等，详情请参见 路径函数 章节。
列表与数组函数用于对列表和数组进行操作的函数，如 size()、head() 等，详情请参见 列表/数组函数 章节。
条件表达式函数主要用于根据条件判断返回不同的结果，详情请参见 条件表达式函数 章节。

字符集和排序规则​

字符集和排序规则是数据库中字符数据处理的两个重要概念。了解字符集和排序规则对于正确处理数据库中的字符数据至关重要。

  • 字符集是计算机系统中用于编码字符的集合，不同的字符集可能包含不同的字符和符号，并且使用不同的编码规则。在图数据库中字符集用于存储和表示文本数据的一组字符编码规则。ArcGraph 系统默认编码方式为 UTF8mb4。
  • 排序规则是字符集中用于比较每个字符的一套规则，它决定了字符在数据库查询中的比较和排序行为。每种字符集可对应一到多个排序规则，每种排序规则对应一种字符集。在涉及字符串比较或排序的操作时，系统会调用对应指定的排序规则算法来确保正确的处理结果。

支持类型​

ArcGraph 支持的字符集及排序规则如下：

字符集

类型说明
UTF-8UTF-8（Unicode Transformation Format-8 bits）是 UNICODE 的变长编码方式，用于表示 Unicode 字符集中的字符。UTF-8 以 8 位字节为单元对 Unicode 字符集进行编码，不使用大尾序和小尾序形式，每个使用 UTF-8 存储的字符，除了第一个字节外，其余字节的前两个比特都是以"10"开始，使文字处理器能快速找出每个字符的开始位置。为了与 ASCII 码兼容，UTF-8 使用可变长度字节来存储 Unicode，用 1～4 个字节表示一个 Unicode 字符编码，可以表示 Unicode 的所有字符。
GBK/GB18030GB18030（全称为：国家标准GB18030-2005《信息技术中文编码字符集》）是中华人民共和国当前最新的内码字集，兼容 GB2312 和 GBK，支持 Unicode 的全部汉字，收录 70244 个汉字。采用多字节编码，支持少数民族文字和日韩汉字，最多可定义 161 万个字符。其字节结构包括单字节、双字节和四字节。

排序规则

排序规则排序结果对应字符集
gb18030_bingb18030 二进制编码排序gb18030
gb18030_chinese_ci按拼音排序gb18030
gbk_bingbk 二进制编码排序gbk
gbk_chinese_ci按拼音排序gbk
utf8_binutf8 二进制编码排序utf8
utf8_pinyinutf8编码拼音排序utf8

设置字符集/排序规则​

ArcGraph 仅支持在图中设置字符集和对应的排序规则，且设置后不支持修改。
语法详情请参见 创建图 章节。

说明：

  • 设置的字符集和排序规则需一一对应，例如字符集设置为 GBK，则排序规则不可设置为 UTF8_BIN。对应情况请参见 支持类型 章节中的“排序规则”表。
  • 设置的字符集和排序规则大小写不敏感。

示例
创建图 graph 并设置字符集为 GBK，排序规则为 GBK_BIN，命令如下：

CREATE GRAPH IF NOT EXISTS graph
CHARSET = GBK
COLLATION = GBK_BIN  
COMMENT = '新图';

DDL 与 Online DDL​

在大多数数据库系统中，执行 DDL 操作（如添加表结构、修改列属性等）时，为了维护数据的一致性和完整性，系统通常会暂时禁止或限制并发的 DML 操作（如数据的增、删、改、查）。对于包含大量数据的表而言，这种 DDL 操作可能会导致 DML 操作长时间被阻塞，从而影响业务流畅性和客户体验。为了解决这一问题，ArcGraph 图数据库自 v2.1.2 版本起支持 Online DDL（即在线数据定义语言）操作，有效降低了 DDL 操作对 DML 操作的影响。

Online DDL​

Online DDL 操作通过对 DDL 执行流程的深入优化和改进，实现了在操作执行期间几乎不阻塞或仅在极短时间内阻塞 DML 操作，从而保障了 ArcGraph 图数据库的高可用性和业务的连续无中断运行。

优势与特点​

  • 提高可用性
    在调整图数据结构时，Online DDL 允许 ArcGraph 图数据库持续处理查询和更新请求，从而大幅减少了因 DDL 操作导致的系统停机时间，确保了业务的连续运行。
  • 支持复杂操作
    Online DDL 操作（如添加索引、修改属性列等）可以在不影响业务正常运行的前提下，在后台静默执行，极大地增强了数据库维护的灵活性与效率。
  • 优化用户体验
    用户在 ArcGraph 图数据库维护期间，仍能正常使用应用程序，提高了用户体验。

支持的操作​

  • 清空/删除图：自 ArcGraph 图数据库 v2.1.2 版本起，将 TRUNCATE GRAPH 和 DROP GRAPH 命令由 DDL 操作升级为 Online DDL 操作，详情请参见 删除图 章节。
  • 删除点/边类型：自 ArcGraph 图数据库 v2.1.2 版本起，将 Drop Vertex 和 Drop Edge 命令由 DDL 操作升级为 Online DDL 操作，详情请参见 删除点类型/删除边类型 章节。
  • 删除索引：自 ArcGraph 图数据库 v2.1.2 版本起，将 Drop Index 命令由 DDL 操作升级为 Online DDL 操作，详情请参见 删除索引 章节。
  • 创建索引：自 ArcGraph 图数据库 v2.1.2 版本起，支持通过 Online DDL 操作执行 Create Index 命令创建索引，详情请参见 创建索引 章节。
  • 修改点/边类型：自 ArcGraph 图数据库 v2.1.2 版本起，支持通过 Online DDL 操作修改除属性名称外的其他点/边类型属性，详情请参见 修改点类型/修改边类型 章节。

Schema GC 机制​

在 Online DDL 执行过程中，ArcGraph 图数据库采用 Schema GC（Schema Garbage Collection）机制，尽可能的减少 DDL 语句对锁等系统资源的占用。该机制不仅实时清除内存中冗余的缓存数据，实现高效的逻辑删除，还针对磁盘上的物理数据实施延迟清理策略，选择合适时机再进行处理，从而确保数据管理的灵活性与系统资源的优化利用。

Schema GC 通过版本控制来确保数据的一致性和可追踪性。每当执行受 Schema GC 支持的操作时，系统都会相应的增加 Schema 的版本号，并记录操作时间和状态变化。在查询操作中，系统会根据当前的 Schema 版本和状态，对存储在键值存储（KV）中的数据进行实时转换，合并内存中的最新数据后返回至 ArcGraph 图数据库的客户端，以确保查询结果的准确性和时效性。

Schema GC 执行策略​

在执行 Schema GC 操作时，系统遵循以下检查策略：

  1. 检查图是否被删除。
  2. 检查图中点和边类型的 Schema 版本数量。
  3. 检查图中是否存在被删除的索引。
  4. 检查图中边类型上是否存在被删除的关联点类型。
  5. 检查被删除的点和边类型个数。

支持的操作​

Schema GC 支持的操作与 Online DDL相同，详情请参见 支持的操作 章节。

Schema GC 参数介绍​

Schema GC 的行为可以通过相关参数进行配置，以下是这些参数及其默认值的详细说明：

参数说明默认值单位
meta_schema_gc_interval设置 ArcGraph 图数据库定期检查是否需要执行 Schema GC 操作的周期。43200 （即 12 小时）秒
meta_schema_grace_period设置图及其内部所有 Schema 修改后等待执行 Schema GC 操作的阈值。3600 （即 1 小时）秒
meta_schema_version_gc_limit设置图内点/边类型 Schema 版本的最大阈值。超过该阈值时，系统将对该图进行 Schema GC 操作，即将存储在键值存储（KV）上的数据变更到最新的版本。6个
meta_dropped_schema_gc_limit设置图中被删除的点/边类型或关联点类型的最大阈值。超过该阈值时，系统将对该图进行 Schema GC 操作，即将存储在键值存储（KV）上的脏数据删除。3个

查看与修改配置​

  • 查看配置
    使用 SHOW CONFIGS LIKE '%schema%'; 命令查看 Schema GC 相关配置，详情请参见 SHOW CONFIGS 章节。
  • 修改配置
    使用 ALTER CONFIG 命令修改 Schema GC 相关配置，详情请参见 更改系统配置项 章节。

示例 1
查看 Schema GC 相关配置。命令如下：

SHOW CONFIGS LIKE '%schema%';

返回结果示例如下：

+-------------------------------+-------+--------------+-----------+----------------------------------------------------+
| config_name                   | value | modify_level | server_id | description                                        |
+===============================+=======+==============+===========+====================================================+
| meta_dropped_schema_gc_limit  | 3     | DYNAMIC      | 1         | meta dropped schema GC policy                      |
+-------------------------------+-------+--------------+-----------+----------------------------------------------------+
| meta_schema_gc_interval       | 43200 | DYNAMIC      | 1         | meta schema GC interval                            |
+-------------------------------+-------+--------------+-----------+----------------------------------------------------+
| meta_schema_grace_period      | 3600  | DYNAMIC      | 1         | meta schema grace period before applying gc policy |
+-------------------------------+-------+--------------+-----------+----------------------------------------------------+
| meta_schema_version_gc_limit  | 6     | DYNAMIC      | 1         | meta schema data version GC policy                 |
+-------------------------------+-------+--------------+-----------+----------------------------------------------------+

示例 2
修改 Schema GC 参数 meta_schema_gc_interval 配置。命令如下：

ALTER CONFIG meta_schema_gc_interval = 40000;

图​

图是由点、边组成的图结构，它由一系列的点、边、索引 Schema 信息以及对应的数据组成。支持对图进行分区管理。

前提条件​

在开始操作前，请确保当前登录用户拥有执行此操作所需权限的角色。有关权限的详细说明，详情请参见 权限 章节。

创建图​

使用 CREATE GRAPH 命令创建图。

语法

create_graph ::= CREATE GRAPH [ IF NOT EXISTS ] <graph_name>
[( PARTITION_NUM = < integer> )]
[ COMMENT = < string > ]
[ CHARSET = {UTF8 | GBK | GB18030} ]
[ COLLATION = {UTF8_BIN | UTF8_PINYIN | GB18030_BIN | GB18030_CHINESE_CI | GBK_BIN | GBK_CHINESE_CI} ];

详细说明

参数说明
[IF NOT EXISTS]    （可选）在创建图时，用于检测指定的图是否已存在于当前 ArcGraph 图数据库中。若不存在则创建图，若已存在，则不进行任何操作。仅通过图名称进行检测，若省略，则不检测。
<graph_name>设置图名称。在同一个 ArcGraph 集群中，图名称必须是唯一的且命名时应遵循特定的规则和要求，命名规则详情请参见 命名规则 章节。
PARTITION_NUM（可选）在创建图时可以指定的分区数量。单机版建议不要设置此参数。如果确实需要设置，请设置为 partition_num=1，此时指定的 HASH 策略将失效。
COMMENT（可选）为了方便用户区分不同的图，可以用 COMMENT 字段增加有意义的信息。
CHARSET（可选）指定该图的字符集，默认为 UTF8。设置后不支持修改，请谨慎操作。字符集详情请参见 字符集和排序规则 章节。
COLLATION（可选）指定该图的字符集排序规则，默认为 UTF8_BIN。设置后不支持修改，请谨慎操作。字符集排序规则详情请参见 字符集和排序规则 章节。

示例
创建一个名为“new1"的图，命令如下：

CREATE GRAPH IF NOT EXISTS new1
CHARSET = utf8
COMMENT = '新图';

切换/使用图​

使用 USE GRAPH 命令，从当前位置，切换到指定图中。

语法

use_graph ::= USE [GRAPH] <graph_name>;

详细说明

参数说明
[GRAPH]（可选）关键字，用于明确指定将要操作的类型是图。
<graph_name>图名称，用于指定将要操作的图的名称。

示例
在当前图中切换到“new1”图中，命令如下：

USE GRAPH new1;

修改图名称​

使用 RENAME GRAPH 命令，对一个图进行重命名操作。

语法

rename_graph ::= RENAME GRAPH <graph_name1> TO <graph_name2>;

详细说明

参数说明
<graph_name1>当前图名称，用于指定将要操作的图的名称。
<graph_name2>修改后的图名称，请确保修改后的名称在当前 ArcGraph 集群中，是唯一的且符合命名规则，命名规则详情请参见 命名规则 章节。

示例
在当前图中将图名称由“new1”改为“new2”，命令如下：

RENAME GRAPH new1 to new2;

查看图详情​

使用 DESC GRAPH 命令查看指定图的详细信息。若需了解更多与图相关的查看操作，请参见 SHOW GRAPHS 章节。

语法

desc_graph ::= DESC GRAPH <graph_name> [ALL|FULL];

详细说明

参数说明
<graph_name>图名称，用于指定将要操作的图的名称。
[ALL|FULL]（可选）用于展示指定图的所有信息或详细信息，若省略，则只展示图的基本信息。
- ALL：用于展示指定图的所有信息，包括该图的详细信息以及该图所包含的点类型和边类型的信息。
- FULL：用于展示指定图的详细信息，包括图 ID、创建时间戳等。请注意，仅 ArcGraph >= v2.1.1 版本支持此参数。

示例 1
查看图“new1”的基本信息，命令如下：

DESC GRAPH new1;

返回结果示例如下：

+------+---------------+-------------+---------+----------+--------+---------+
| name | partition_num | replica_num | charset | collate  | status | comment |
+======+===============+=============+=========+==========+========+=========+
| new1 | 1             | 1           | utf8    | utf8_bin | Normal | 新图    |
+------+---------------+-------------+---------+----------+--------+---------+

示例 2
查看图“new1”的详细信息，命令如下：

DESC GRAPH new1 FULL;

返回结果示例如下：

+---------------------------------+
| graph                           |
+=================================+
| GraphMsg {                      |
|     graph_id: 1026,             |
|     graph_name: "new1",         |
|     charset_name: "utf8",       |
|     collate_name: "utf8_bin",   |
|     comment: "新图",            |
|     create_time: 1711360120473, |
|     partition_number: 1,        |
|     replica_number: 1,          |
|     status: "Normal",           |
|     version: 0,                 |
| }                               |
+---------------------------------+

示例 3
查看图“new1_test”的所有信息，包括其包含的点类型、边类型信息。命令如下：

DESC GRAPH new1_test ALL;

返回结果示例如下：

+---------------------------------+--------------------------------------+--------------------------------------+
| graph                           | vertex                               | edge                                 |
+=================================+======================================+======================================+
| GraphMsg {                      | VertexSchemaMsg {                    | EdgeSchemaMsg {                      |
|     graph_id: 1028,             |     graph_id: 1028,                  |     graph_id: 1028,                  |
|     graph_name: "new1_test",    |     vertex_type_id: 1,               |     edge_type_id: 1,                 |
|     charset_name: "utf8",       |     vertex_type_name: "person",      |     edge_type_name: "like",          |
|     collate_name: "utf8_bin",   |     schema_version: 0,               |     schema_version: 0,               |
|     comment: "新图",            |     data_version: 0,                 |     data_version: 0,                 |
|     create_time: 1718613130383, |     status: "Normal",                |     status: "Normal",                |
|     partition_number: 1,        |     key_type: "int64",               |     properties: [                    |
|     replica_number: 1,          |     key_length: 8,                   |         PropertyMsg {                |
|     status: "Normal",           |     properties: [                    |             property_id: 5,          |
|     version: 0,                 |         PropertyMsg {                |             property_name: "name",   |
| }                               |             property_id: 1,          |             property_type: "string", |
|                                 |             property_name: "_oid",   |             type_length: 0,          |
|                                 |             property_type: "uint64", |             nullable: false,         |
|                                 |             type_length: 8,          |             primary_key: false,      |
|                                 |             nullable: false,         |             default_value: Some(     |
|                                 |             primary_key: false,      |                 ValueMsg {           |
|                                 |             default_value: Some(     |                     object: None,    |
|                                 |                 ValueMsg {           |                 },                   |
|                                 |                     object: None,    |             ),                       |
|                                 |                 },                   |             index_num: 0,            |
|                                 |             ),                       |             order: 0,                |
|                                 |             index_num: 0,            |             comment: "喜欢",         |
|                                 |             order: 0,                |             is_unique: false,        |
|                                 |             comment: "",             |             is_full_text: false,     |
|                                 |             is_unique: true,         |             v_index_type: None,      |
|                                 |             is_full_text: false,     |             is_oid: false,           |
|                                 |             v_index_type: None,      |         },                           |
|                                 |             is_oid: true,            |         PropertyMsg {                |
|                                 |         },                           |             property_id: 6,          |
|                                 |         PropertyMsg {                |             property_name: "since",  |
|                                 |             property_id: 2,          |             property_type: "int64",  |
|                                 |             property_name: "id",     |             type_length: 8,          |
|                                 |             property_type: "int64",  |             nullable: true,          |
|                                 |             type_length: 8,          |             primary_key: false,      |
|                                 |             nullable: false,         |             default_value: Some(     |
|                                 |             primary_key: true,       |                 ValueMsg {           |
|                                 |             default_value: Some(     |                     object: Some(    |
|                                 |                 ValueMsg {           |                         ValueI64(    |
|                                 |                     object: None,    |                             2020,    |
|                                 |                 },                   |                         ),           |
|                                 |             ),                       |                     ),               |
|                                 |             index_num: 0,            |                 },                   |
|                                 |             order: 0,                |             ),                       |
|                                 |             comment: "",             |             index_num: 0,            |
|                                 |             is_unique: true,         |             order: 0,                |
|                                 |             is_full_text: false,     |             comment: "开始时间",     |
|                                 |             v_index_type: None,      |             is_unique: false,        |
|                                 |             is_oid: false,           |             is_full_text: false,     |
|                                 |         },                           |             v_index_type: None,      |
|                                 |         PropertyMsg {                |             is_oid: false,           |
|                                 |             property_id: 3,          |         },                           |
|                                 |             property_name: "name",   |     ],                               |
|                                 |             property_type: "string", |     vertex_type_pair: [              |
|                                 |             type_length: 0,          |         VertexTypePairMsg {          |
|                                 |             nullable: true,          |             from_id: 1,              |
|                                 |             primary_key: false,      |             to_id: 1,                |
|                                 |             default_value: Some(     |             status: "Normal",        |
|                                 |                 ValueMsg {           |             from_name: Some(         |
|                                 |                     object: None,    |                 "person",            |
|                                 |                 },                   |             ),                       |
|                                 |             ),                       |             to_name: Some(           |
|                                 |             index_num: 0,            |                 "person",            |
|                                 |             order: 0,                |             ),                       |
|                                 |             comment: "姓名",         |         },                           |
|                                 |             is_unique: false,        |     ],                               |
|                                 |             is_full_text: false,     |     partition_schema: Some(          |
|                                 |             v_index_type: None,      |         PartitionSchemaMsg {         |
|                                 |             is_oid: false,           |             method: "hash",          |
|                                 |         },                           |             column: "_TYPE",         |
|                                 |         PropertyMsg {                |         },                           |
|                                 |             property_id: 4,          |     ),                               |
|                                 |             property_name: "age",    |     temporal: false,                 |
|                                 |             property_type: "int32",  |     comment: "测试Edge",             |
|                                 |             type_length: 4,          |     indexes: [],                     |
|                                 |             nullable: false,         | }                                    |
|                                 |             primary_key: false,      |                                      |
|                                 |             default_value: Some(     |                                      |
|                                 |                 ValueMsg {           |                                      |
|                                 |                     object: Some(    |                                      |
|                                 |                         ValueI32(    |                                      |
|                                 |                             16,      |                                      |
|                                 |                         ),           |                                      |
|                                 |                     ),               |                                      |
|                                 |                 },                   |                                      |
|                                 |             ),                       |                                      |
|                                 |             index_num: 0,            |                                      |
|                                 |             order: 0,                |                                      |
|                                 |             comment: "年龄",         |                                      |
|                                 |             is_unique: false,        |                                      |
|                                 |             is_full_text: false,     |                                      |
|                                 |             v_index_type: None,      |                                      |
|                                 |             is_oid: false,           |                                      |
|                                 |         },                           |                                      |
|                                 |     ],                               |                                      |
|                                 |     partition_schema: Some(          |                                      |
|                                 |         PartitionSchemaMsg {         |                                      |
|                                 |             method: "hash",          |                                      |
|                                 |             column: "_TYPE",         |                                      |
|                                 |         },                           |                                      |
|                                 |     ),                               |                                      |
|                                 |     temporal: false,                 |                                      |
|                                 |     comment: "测试Vertex",           |                                      |
|                                 |     indexes: [],                     |                                      |
|                                 | }                                    |                                      |
+---------------------------------+--------------------------------------+--------------------------------------+

删除图​

ArcGraph 支持通过下列方式删除图及图中数据，请根据实际情况选择。数据一旦删除，无法恢复，请谨慎操作。

note
  • 自 ArcGraph v2.1.2 版本起，该功能由 DDL 操作升级为 Online DDL 操作。
  • 自 ArcGraph v2.1.2 版本起，执行 TRUNCATE GRAPH/DROP GRAPH 命令成功后，数据将立即从 ArcGraph 图数据库中逻辑删除且不可见，但存储于磁盘上的物理数据需等 Schema GC 任务执行后才会被彻底删除。
  • 自 ArcGraph v2.1.2 版本起，通过执行 SHOW FULL GRAPHS; 命令可查看已删除但未回收的图。这些图的 ID 不变，但名字会被定义为 _{name}_{timestamp} 格式，如 _new1_1724929262231783。

清空图​

使用 TRUNCATE GRAPH 命令清空图数据，即仅删除图中的点边数据，保留图中点类型和边类型。该操作将彻底清除图中的所有点数据和边数据，请谨慎执行。

语法

TRUNCATE GRAPH [IF EXISTS] <graph_name>;

详细说明

参数说明
<graph_name>图名称，用于指定将要操作的图的名称。
[IF EXISTS]（可选）在清空图时，用于检测指定的图是否存在于当前 ArcGraph 图数据库中，若存在则清空图，若不存在则显示成功但不进行任何操作。仅通过图名称进行检测，若省略，则不检测。
说明：
仅 ArcGraph >= v2.1.2 版本支持此参数。

示例 1
删除名为“new2”的图中的所有点数据和边数据，命令如下：

TRUNCATE GRAPH new2;

示例 2
当 ArcGraph >= v2.1.2 版本时，检查并清空名为“new2”的图。命令如下：

TRUNCATE GRAPH IF EXISTS new2;

删除所有数据​

使用 DROP GRAPH 命令删除整个图，包括图中点类型、边类型、点数据、边数据等所有数据。这是一种破坏性操作，请谨慎执行。

语法

DROP GRAPH [IF EXISTS] <graph_name> [FORCE];

详细说明

参数说明
[IF EXISTS]（可选）在删除图时，用于检测指定的图是否存在于当前 ArcGraph 图数据库中，若存在则删除图，若不存在则显示成功但不进行任何操作。仅通过图名称进行检测，若省略，则不检测。
<graph_name>图名称，用于指定将要操作的图的名称。
[FORCE]（可选）使用 FORCE 命令可强制删除图。若省略则可能会因为图的当前状态导致删除失败。
普通删除​

示例
删除名为“new2”的图。

DROP GRAPH IF EXISTS new2;
强制删除​

若图因当前状态无法正常删除时，可使用 FORCE 命令强制删除。

示例
强制删除名为“new2”的图，命令如下：

DROP GRAPH IF EXISTS new2 FORCE;

点类型​

在 ArcGraph 图数据库中，点类型是用来定义一组拥有相同特征的点的模型，点类型的相关操作需要在图中进行。

前提条件​

在开始操作前，请确保当前登录用户拥有执行此操作所需权限的角色。有关权限的详细说明，详情请参见 权限 章节。

创建点类型​

使用 CREATE VERTEX 命令创建点类型，创建点类型时可同时创建相关索引。

语法

create_vertex ::= CREATE VERTEX [IF NOT EXISTS] <vertex_name>
                ( <vertex_body> [, <vertex_body>]... )
                [PARTITION BY HASH ( _TYPE | _ID)]
                [ COMMENT = < string > ];

vertex_body ::= <property_def>
			| <embedded_index>;

property_def ::= { <primary_key> | <normal_property> };
primary_key ::= PRIMARY KEY <property_name> { STRING ( <integer> ) | INT64 } [MASKED [WITH ( FUNCTION = PARTIAL (<integer>, <string>, <integer>))]] [COMMENT <string>];
normal_property ::= <property_name> <property_type> [<nullable>] [MASKED [WITH ( FUNCTION = PARTIAL (<integer>, <string>, <integer>))]] [DEFAULT default_value] [COMMENT <string>];
property_type ::= { INT32 | INT64 | BOOLEAN ... };
nullable ::= [NOT] NULL;

embedded_index ::= INDEX <index_name> ( <index_property> [, <index_property>]... ) [UNIQUE];
index_property ::= <property_name> [->> json_path];

详细说明

参数说明
[IF NOT EXISTS]（可选）在创建点类型时，用于检测当前图中是否已存在该点类型。若不存在则创建点类型，若已存在，则不进行任何操作。仅通过点类型名称进行检测，不检测具体属性，若省略，则不检测。
<vertex_name>设置点类型名称。在同一个图中，点类型名称必须是唯一的且命名时应遵循特定的规则和要求，命名规则详情请参见 命名规则 章节。
<vertex_body>用于定义点类型的属性（<property_def>）和索引（<embedded_index>）信息，支持同时设置多个属性或索引，可用英文逗号（“,”）分隔。
<property_def>用于定义点类型的属性，支持定义主键属性（<primary_key>）和普通属性（<normal_property>）。
<primary_key>用于定义点类型的主键属性，每个点类型只能设置一个主键属性，该属性用于唯一标识该点类型。通过 pk() 函数可查询点的主键值，详情请参见 pk() 章节。支持设置以下数据类型：
  • STRING ( <integer> )
    • 当 ArcGraph < v2.1.2 版本时 integer 长度设置范围为 1~1024，请避免设置过长。
    • 当 ArcGraph >= v2.1.2 版本时，integer 可省略或设置为大于等于 0 的值，若省略或设置为 0 时，表示字符串长度无限制。
  • INT64
  • INT32（仅 ArcGraph >= v2.1.2 版本支持）
  • BIGINT（仅 ArcGraph >= v2.1.2 版本支持）
<normal_property>用于定义点类型的普通属性，支持同时设置多个并用英文逗号（“,”）分隔。
<property_name>设置普通属性的名称。同一个点类型下属性名称必须是唯一的且命名时应遵循特定的规则和要求，命名规则详情请参见 命名规则 章节。
<property_type>定义属性的数据类型，支持 INT32、INT64 等多种数据类型，详情请参见 数据类型 章节。
<nullable>（可选）表示指定属性是否可以为空。
- NOT NULL：表示该属性值不可为空。
- NULL：表示该属性值可以为空，默认为 NULL。
<embedded_index>用于定义点类型的索引，以提高查询性能和数据检索速度。支持设置多种索引类型，详情请参见 索引 章节。
<index_name>设置索引的名称。同一个点类型下索引名称必须是唯一的且命名时应遵循特定的规则和要求，命名规则详情请参见 命名规则 章节。
<index_property>定义被索引的属性，支持同时对多个属性进行索引并用英文逗号（“,”）分隔。
说明：
- 若属性的数据类型为 Array、UUID 或 BigDecimal 类型，则不支持在该属性上创建索引。
- 若属性的数据类型为 JSON 类型，则在该属性上创建索引时应使用 ->> 操作符明确指定 JSON 路径，例如 idx_person(name->>'$.last_name')。
[UNIQUE]（可选）表示该索引要求索引的属性值必须是唯一的。
[->> json_path]（可选）是一种在 JSON 对象结构中定位和提取数据的查询语言。通过使用路径表达式，可以帮助我们轻松地在嵌套的 JSON 数据结构中定位和提取指定的数据，详情请参见 JSON 简介 章节。
[PARTITION BY HASH ( _TYPE|_ID)]（可选）表明该点类型采用的分区方式，包括 HASH(_TYPE) 和 HASH(_ID)。如果想利用分布式查询提升查询效率，建议采用 HASH(_ID)分区方式；如果点数量较少（<1百万），建议采用 HASH(_TYPE)分区方式。单机版建议不要设置此参数。如果确实需要设置，请设置为 partition_num=1，此时指定的 HASH 策略将失效。
COMMENT（可选）为了方便用户区分不同的点类型，可以用 COMMENT 字段增加有意义的信息。
MASKED（可选）表示查询时显示该字段值是否对某些用户进行隐藏部分值，如身份证号会隐藏中间几位个数。
[DEFAULT default_value] （可选）用于定义属性的默认值，即当 INSERT 语句没有为列提供值情况下，该属性的值。

示例 1
在当前图中创建“person”点类型，命令如下：

CREATE VERTEX IF NOT EXISTS person 
  (
	PRIMARY KEY id INT(64),
	name STRING COMMENT '姓名',
	age INT(32) NOT NULL DEFAULT '16' COMMENT '年龄',
	INDEX name_index(name) UNIQUE
    )
  COMMENT = '测试Vertex';

示例 2
在当前图中创建包含 ARRAY 属性的“PersonArray”点类型，命令如下：

CREATE VERTEX IF NOT EXISTS PersonArray 
  (
	PRIMARY KEY id INT(64),
	name STRING COMMENT '姓名',
	hobbies ARRAY(STRING) COMMENT '兴趣爱好列表'
    )
  COMMENT = '测试Vertex';

修改点类型​

使用 ALTER VERTEX 命令修改当前图中的点类型，ArcGraph 图数据库版本不同支持的修改功能略有不同，请以实际情况为准。

修改点类型名称​

修改点类型的名称，修改后的新名称不能是当前图中已存在的点类型名称，命名规则详情请参见 命名规则 章节。

语法

rename_vertex ::= ALTER VERTEX <vertex_name> RENAME TO <vertex_name>;

示例
在当前图中将点类型名称“person”修改为“women”，命令如下：

ALTER VERTEX person RENAME TO women;

管理点类型属性​

在当前图中使用 ALTER VERTEX 命令管理点类型中的属性。

增加属性​

为点类型增加属性，可以丰富点类型的数据模型，使其更好地满足业务需求。

语法

alter_vertex_properties ::= ALTER VERTEX <vertex_name> <add_property_body>
add_property_body ::= ADD [COLUMN] <property_name> <property_type> [NULL | NOT NULL] [DEFAULT default_value] [COMMENT < string >]
                      [, ADD [COLUMN] <property_name> <property_type> [NULL | NOT NULL] [DEFAULT default_value] [COMMENT < string >]]...;

详细说明

参数说明
<vertex_name>用于指定将要增加属性的点类型的名称。需要指定正确的点类型名称，以确保属性被添加到正确的对象上。
[COLUMN]（可选）用于指明将要添加的是一个列（属性）。
<property_name>用于为新属性设置名称。同一个点类型下属性名称必须是唯一的且命名时应遵循特定的规则和要求，命名规则详情请参见 命名规则 章节。
<property_type>定义属性的数据类型，支持 INT32、INT64 等多种数据类型，详情请参见 数据类型 章节。
[NULL|NOT NULL]（可选）表示指定属性是否可以为空。
- NULL：表示该属性值可以为空，默认为 NULL。
- NOT NULL：表示该属性值不可为空，需为该属性设置默认值。
[DEFAULT default_value]（可选）用于定义属性的默认值，即当 INSERT 语句没有为列提供值情况下，该属性的值。
[COMMENT < string >]（可选）用于为新属性提供对应的描述或注释。
note
  • 自 ArcGraph v2.1.1 版本起支持此功能。
  • 自 ArcGraph v2.1.2 版本起，该功能由 DDL 操作升级为 Online DDL 操作。

示例 1
在当前图中为“person”点类型增加“firstName”属性，命令如下：

ALTER VERTEX person ADD firstName string;

示例 2
在当前图中为“person”点类型增加“new_firstName”属性并为该属性添加对应描述，命令如下：

ALTER VERTEX person ADD new_firstName string COMMENT "new firstName";

示例 3
在当前图中为“person”点类型增加“native_place”属性并为该属性添加对应描述和默认值，命令如下：

ALTER VERTEX person ADD native_place string NOT NULL DEFAULT "beijing" COMMENT "native_place";
修改属性名称​

修改点类型中属性的名称。

语法

rename_vertex_property ::= ALTER VERTEX <vertex_name> <rename_property_body>
rename_property_body ::= RENAME PROPERTY <property_name> TO <property_name> 
                         [, RENAME PROPERTY <property_name> TO <property_name>]...;

详细说明

  • 修改后的属性名称不能为当前点类型中已存在的属性名称。
  • 该语句只能全部成功或者全部失败，不会存在改成功一半的情况。
  • 若修改的属性存在关联的索引，则会自动同步修改索引信息中的属性名称。

示例
在当前图中将“person”点类型的“name”和“age”属性名称分别修改为“first”和“degree”，命令如下：

ALTER VERTEX person RENAME PROPERTY name TO first, RENAME PROPERTY age TO degree;
修改属性特性​

自 ArcGraph v2.1.2 版本起，支持通过 Online DDL 操作修改点类型中属性的数据类型、空/非空约束及注释等特性。

note
  • 若属性上已创建索引，则该属性不支持此操作。
  • 若将属性设置为非空（NOT NULL）属性，则必须同时指定默认值。

语法

alter_vertex_properties ::= ALTER VERTEX <vertex_name> 
                            MODIFY [COLUMN] <property_name> <property_type> [NULL | NOT NULL] [DEFAULT default_value] [COMMENT < string >];

支持转换的数据类型

原数据类型可转换类型
Int32String、Int64、BigInt
Int64、BigInt、Boolean 、Double、Float、Timestamp、Date、Time 、DateTime 、Json、ArrayString

示例 1
在当前图中将“person”点类型的“degree”属性数据类型由“INT(32)”修改为“String”类型。命令如下：

ALTER VERTEX person
  MODIFY COLUMN degree String;

示例 2
在当前图中将“person”点类型的“new_firstName”属性由允许为空值修改为必须非空，并设置默认值为“default name”。命令如下：

ALTER VERTEX person
  MODIFY COLUMN new_firstName String NOT NULL DEFAULT 'default name';

示例 3
在当前图中将“person”点类型的“new_firstName”属性的注释由“new firstName”修改为“new firstName test”。命令如下：

ALTER VERTEX person
  MODIFY COLUMN new_firstName String COMMENT "new firstName test";
删除属性​

自 ArcGraph v2.1.2 版本起，支持通过 Online DDL 操作删除点类型中的属性。请注意，若属性上已创建索引，则该属性不支持此操作。

语法

alter_vertex_properties ::= ALTER VERTEX <vertex_name> DROP [COLUMN] <property_name>;

示例
在当前图中删除“person”点类型中的“degree”属性，命令如下：

ALTER VERTEX person
 DROP COLUMN degree;

修改点类型注释​

自 ArcGraph v2.1.2 版本起，支持通过 Online DDL 操作修改点类型的注释属性（即 COMMENT）。

语法

alter_vertex_comment ::= ALTER VERTEX <vertex_name> COMMENT = <string>;

示例
在当前图中将“person”点类型的注释修改为“person1”，命令如下：

ALTER VERTEX person
 COMMENT = 'person1';

查看点类型详情​

使用 DESC VERTEX 命令查看指定点类型的详细信息。若需了解更多与点类型相关的查看操作，请参见 SHOW VERTEXES 章节。

语法

desc_vertex ::= DESC VERTEX <vertex_name> [FULL];

详细说明

参数说明
<vertex_name>点类型名称，用于指定将要操作的点类型的名称。
[FULL]（可选）用于展示指定点类型的详细信息。若省略，则只展示该点类型的基本信息。
说明：
仅 ArcGraph >= v2.1.1 版本支持此参数。

示例 1
在当前图中查看“person”点类型的基本信息，命令如下：

DESC VERTEX person;

返回结果示例如下：

+------+--------+------+---------+---------+-------+
| name | type   | null | key     | default | extra |
+======+========+======+=========+=========+=======+
| _oid | uint64 | NO   | OID     |         |       |
+------+--------+------+---------+---------+-------+
| id   | int64  | NO   | PRIMARY |         |       |
+------+--------+------+---------+---------+-------+
| name | string | YES  | INDEX   |         |       |
+------+--------+------+---------+---------+-------+
| age  | int32  | NO   |         | 16      |       |
+------+--------+------+---------+---------+-------+

示例 2
在当前图中查看“person”点类型的详细信息，命令如下：

DESC VERTEX person FULL;

返回结果示例如下：

+--------------------------------------------+
| vertex                                     |
+============================================+
| VertexSchemaMsg {                          |
|     graph_id: 1028,                        |
|     vertex_type_id: 1,                     |
|     vertex_type_name: "person",            |
|     schema_version: 0,                     |
|     data_version: 0,                       |
|     status: "Normal",                      |
|     key_type: "int64",                     |
|     key_length: 8,                         |
|     properties: [                          |
|         PropertyMsg {                      |
|             property_id: 1,                |
|             property_name: "_oid",         |
|             property_type: "uint64",       |
|             type_length: 8,                |
|             nullable: false,               |
|             primary_key: false,            |
|             default_value: Some(           |
|                 ValueMsg {                 |
|                     object: None,          |
|                 },                         |
|             ),                             |
|             index_num: 0,                  |
|             order: 0,                      |
|             comment: "",                   |
|             is_unique: true,               |
|             is_full_text: false,           |
|             v_index_type: None,            |
|             is_oid: true,                  |
|         },                                 |
|         PropertyMsg {                      |
|             property_id: 2,                |
|             property_name: "id",           |
|             property_type: "int64",        |
|             type_length: 8,                |
|             nullable: false,               |
|             primary_key: true,             |
|             default_value: Some(           |
|                 ValueMsg {                 |
|                     object: None,          |
|                 },                         |
|             ),                             |
|             index_num: 1,                  |
|             order: 0,                      |
|             comment: "",                   |
|             is_unique: true,               |
|             is_full_text: false,           |
|             v_index_type: None,            |
|             is_oid: false,                 |
|         },                                 |
|         PropertyMsg {                      |
|             property_id: 3,                |
|             property_name: "name",         |
|             property_type: "string",       |
|             type_length: 0,                |
|             nullable: true,                |
|             primary_key: false,            |
|             default_value: Some(           |
|                 ValueMsg {                 |
|                     object: None,          |
|                 },                         |
|             ),                             |
|             index_num: 1,                  |
|             order: 0,                      |
|             comment: "姓名",               |
|             is_unique: false,              |
|             is_full_text: false,           |
|             v_index_type: None,            |
|             is_oid: false,                 |
|         },                                 |
|         PropertyMsg {                      |
|             property_id: 4,                |
|             property_name: "age",          |
|             property_type: "int32",        |
|             type_length: 4,                |
|             nullable: false,               |
|             primary_key: false,            |
|             default_value: Some(           |
|                 ValueMsg {                 |
|                     object: Some(          |
|                         ValueI32(          |
|                             16,            |
|                         ),                 |
|                     ),                     |
|                 },                         |
|             ),                             |
|             index_num: 0,                  |
|             order: 0,                      |
|             comment: "年龄",               |
|             is_unique: false,              |
|             is_full_text: false,           |
|             v_index_type: None,            |
|             is_oid: false,                 |
|         },                                 |
|     ],                                     |
|     partition_schema: Some(                |
|         PartitionSchemaMsg {               |
|             method: "hash",                |
|             column: "_TYPE",               |
|         },                                 |
|     ),                                     |
|     temporal: false,                       |
|     comment: "测试Vertex",                 |
|     indexes: [                             |
|         IndexSchemaMsg {                   |
|             index_id: 2,                   |
|             index_name: "name_index",      |
|             index_type: "Vertex",          |
|             graph_id: 1028,                |
|             properties: [                  |
|                 IndexPropertyMsg {         |
|                     property_id: 3,        |
|                     property_name: "name", |
|                     property_path: None,   |
|                     unique: true,          |
|                 },                         |
|             ],                             |
|             status: "Ready",               |
|             type_id: 1,                    |
|             unique: true,                  |
|             version: 0,                    |
|             is_fulltext: false,            |
|             v_index_type: None,            |
|             is_primary_key: false,         |
|         },                                 |
|         IndexSchemaMsg {                   |
|             index_id: 1,                   |
|             index_name: "person_pk_index", |
|             index_type: "Vertex",          |
|             graph_id: 1028,                |
|             properties: [                  |
|                 IndexPropertyMsg {         |
|                     property_id: 2,        |
|                     property_name: "id",   |
|                     property_path: None,   |
|                     unique: true,          |
|                 },                         |
|             ],                             |
|             status: "Ready",               |
|             type_id: 1,                    |
|             unique: true,                  |
|             version: 0,                    |
|             is_fulltext: false,            |
|             v_index_type: None,            |
|             is_primary_key: true,          |
|         },                                 |
|     ],                                     |
| }                                          |
+--------------------------------------------+

删除点类型​

删除点类型时，会将该点类型中的点数据删除，同时如果带 CASCADE 选项，则会删除边类型中涉及的该点类型的 Vertex Pairs，如果不带 CASCADE 选项，如果该点类型存在于其它边类型中，则不允许删除；请谨慎操作。

语法

drop_vertex ::= DROP VERTEX [IF EXISTS] <vertex_name> [CASCADE] [FORCE];

详细说明

参数说明
[IF EXISTS]（可选）在删除点类型时，用于检测指定的点类型是否存在于当前图中，若存在则删除点类型，若不存在则显示成功但不进行任何操作。仅通过点类型名称进行检测，若省略，则不检测。
<vertex_name>点类型名称，用于指定将要操作的点类型的名称。
[CASCADE]（可选）使用 CASCADE 命令可删除存在关联关系的点类型。
[FORCE]（可选）使用 FORCE 命令可强制删除点类型。若省略则可能会因为点类型的当前状态导致删除失败。
note
  • 自 ArcGraph v2.1.2 版本起，该功能由 DDL 操作升级为 Online DDL 操作。
  • 自 ArcGraph v2.1.2 版本起，执行 DROP VERTEX 命令成功后，数据将立即从 ArcGraph 图数据库中逻辑删除且不可见，但存储于磁盘上的物理数据需等 Schema GC 任务执行后才会被彻底删除。
  • 自 ArcGraph v2.1.2 版本起，通过执行 SHOW FULL VERTEXES; 命令可以查看已删除但未回收的点类型。这些点类型的 ID 不变，但名字会被定义为 _{name}_{timestamp} 格式，如 _person_1724922449757360。

删除独立的点类型​

若点类型无与之关联的边类型，可使用 DROP VERTEX 命令删除独立的点类型。

示例
在当前图中删除名为“person”的点类型，命令如下：

DROP VERTEX IF EXISTS person;

删除存在关联关系的点类型​

若点类型有与之关联的边类型，可使用 CASCADE 命令删除点类型。

示例
在当前图中删除名为“person”的点类型，命令如下：

DROP VERTEX IF EXISTS person CASCADE;

强制删除点类型​

若点类型因当前状态无法正常删除时，可使用 FORCE 命令强制删除点类型。

示例
在当前图中强制删除名为“person”的点类型，命令如下：

DROP VERTEX IF EXISTS person FORCE;

边类型​

在 ArcGraph 图数据库中，边类型是用来定义一组拥有相同特征的边的模型，需要在图中进行边类型的相关操作。

前提条件​

在开始操作前，请确保当前登录用户拥有执行此操作所需权限的角色。有关权限的详细说明，详情请参见 权限 章节。

创建边类型​

使用 CREATE EDGE 为数据库创建边类型，创建边类型时可同时创建相关索引。

语法

create_edge ::= CREATE [TEMPORAL] EDGE [IF NOT EXISTS] <edge_name>
				( <edge_body> [, <edge_body>]... )
				[ COMMENT = < string > ];

edge_body ::= <edge_end_point>
			| <normal_property>
			| <embedded_index>;

edge_end_point ::= FROM vertex_name TO vertex_name;

详细说明
部分参数说明如下，其他参数说明请参考 创建点类型 章节。

参数说明
[TEMPORAL]（可选）表示该边类型是时态边类型。时态边类型通常用于表示随时间变化的关系，详情请参见 时态图 章节。
<edge_name>设置边类型名称。在同一个图中，边类型名称必须是唯一的且命名时应遵循特定的规则和要求，命名规则详情请参见 命名规则 章节。
<edge_body>用于定义边类型的关联点类型（<edge_end_point>，即起点类型和终点类型）、属性（<normal_property> ）和索引（<embedded_index>）信息，支持同时设置多个关联点类型、属性或索引，可用英文逗号（“,”）分隔。
<edge_end_point> 用于定义该边类型的关联点类型，两者可以为同一个点类型。

说明：
ArcGraph 2.1 版本创建边类型时不支持 primary key，若设置，则客户端会显示 InvalidStatement 错误。

示例 1
在当前图中创建一个命名为“like”的边类型，命令如下:

CREATE EDGE like  (
  name string NOT NULL COMMENT '喜欢',
  since INT(64) default '2020' COMMENT '开始时间',
  FROM person TO person,
  INDEX index_a(name) 
  )
  COMMENT = '测试Edge';

示例 2
在当前图中创建包含 ARRAY 属性的“FRIEND_OF”边类型，命令如下：

CREATE EDGE FRIEND_OF  (
  commonHobbies ARRAY(STRING) COMMENT '共同爱好列表',
  FROM PersonArray TO PersonArray
  )
  COMMENT = '测试Edge';

修改边类型​

使用 ALTER EDGE 命令修改当前图中的边类型，ArcGraph 图数据库版本不同支持的修改功能略有不同，请以实际情况为准。

修改边类型名称​

修改边类型的名称，修改后的新名称不能是当前图中已存在的边类型名称，命名规则详情请参见 命名规则 章节。
语法

rename_edge ::= ALTER EDGE <edge_name> RENAME TO <edge_name>;

示例
在当前图中将边类型名称“like”修改为“knows”，命令如下：

ALTER EDGE like RENAME TO knows;

管理边类型属性​

在当前图中使用 ALTER EDGE 命令管理边类型中的属性。

增加属性​

为边类型增加属性，可以丰富边类型的数据模型，使其更好地满足业务需求。

语法

alter_edge_properties ::= ALTER EDGE <edge_name> <add_property_body>
add_property_body ::= ADD [COLUMN] <property_name> <property_type> [NULL | NOT NULL] [DEFAULT default_value] [COMMENT < string >]
                      [, ADD [COLUMN] <property_name> <property_type> [NULL | NOT NULL] [DEFAULT default_value] [COMMENT < string >]]...;

详细说明

参数说明
<edge_name>用于指定将要增加属性的边类型的名称。需要指定正确的边类型名称，以确保属性被添加到正确的对象上。
[COLUMN]（可选）用于指明将要添加的是一个列（属性）。
<property_name>用于为新属性设置名称。同一个边类型下属性名称必须是唯一的且命名时应遵循特定的规则和要求，命名规则详情请参见 命名规则 章节。
<property_type>定义属性的数据类型，支持 INT32、INT64 等多种数据类型，详情请参见 数据类型 章节。
[NULL | NOT NULL] （可选）表示指定属性是否可以为空。
- NULL：表示该属性值可以为空，默认为 NULL。
- NOT NULL：表示该属性值不可为空，需为该属性设置默认值。
[DEFAULT default_value]（可选）用于定义属性的默认值，即当 INSERT 语句没有为列提供值情况下，该属性的值。
[COMMENT < string >]（可选）用于为新属性提供对应的描述或注释。
note
  • 自 ArcGraph v2.1.1 版本起支持此功能。
  • 自 ArcGraph v2.1.2 版本起，该功能由 DDL 操作升级为 Online DDL 操作。

示例 1
在当前图中为“knows”边类型增加“createDate”属性，命令如下：

ALTER EDGE knows ADD createDate String;

示例 2
在当前图中为“knows”边类型增加“new_createDate”属性并为该属性添加对应描述，命令如下：

ALTER EDGE knows ADD new_createDate String COMMENT "new createDate";

示例 3
在当前图中为“knows”边类型增加“native_place”属性并为该属性添加对应描述和默认值，命令如下：

ALTER EDGE knows ADD native_place String NOT NULL DEFAULT "beijing" COMMENT "native_place";
修改属性名称​

修改边类型中属性的名称。

语法

rename_edge_property ::= ALTER EDGE <edge_name> <rename_property_body>	
rename_property_body ::= RENAME PROPERTY <property_name> TO <property_name> 
                         [, RENAME PROPERTY <property_name> TO <property_name>]...;

详细说明

  • 修改后的属性名称不能为当前边类型中已存在的属性名称。
  • 该语句只能全部成功或者全部失败，不会存在改成功一半的情况。
  • 若修改的属性存在关联的索引，则会自动同步修改索引信息中的属性名称。

示例
在当前图中将“knows”边类型的“location”和“time”属性名称分别修改为“site”和“date”，命令如下：

ALTER EDGE knows RENAME PROPERTY location TO site, RENAME PROPERTY time TO date;
修改属性特性​

自 ArcGraph v2.1.2 版本起，支持通过 Online DDL 操作修改边类型中属性的数据类型、空/非空约束及注释等特性。支持转换的数据类型请参见 修改点类型属性特性 章节。

note
  • 若属性上已创建索引，则该属性不支持此操作。
  • 若将属性设置为非空（NOT NULL）属性，则必须同时指定默认值。

语法

alter_edge_properties ::= ALTER EDGE <edge_name>  
                          MODIFY [COLUMN] <property_name> <property_type> [NULL | NOT NULL] [DEFAULT default_value] [COMMENT < string >];

示例 1
在当前图中将“knows”边类型的“since”属性数据类型由“INT(64)”修改为“String”类型。命令如下：

ALTER EDGE knows
 MODIFY since String;

示例 2
在当前图中将“knows”边类型的“new_createDate”属性由允许为空值更改为必须非空，并设置默认值为“default new_createDate”。命令如下：

ALTER EDGE knows
  MODIFY COLUMN new_createDate String NOT NULL DEFAULT 'default new_createDate';

示例 3
在当前图中将“knows”边类型的“new_createDate”属性的注释由“new createDate”修改为“new createDate test”。命令如下：

ALTER EDGE knows
  MODIFY COLUMN new_createDate  string COMMENT "new createDate test";
删除属性​

自 ArcGraph v2.1.2 版本起，支持通过 Online DDL 操作删除边类型中属性。请注意，若属性上已创建索引，则该属性不支持此操作。

语法

alter_edge_properties ::=ALTER EDGE <edge_name> DROP [COLUMN] <property_name>;

示例
在当前图中删除“knows”边类型的“since”属性，命令如下：

ALTER EDGE knows
 DROP since;

修改注释​

自 ArcGraph v2.1.2 版本起，支持通过 Online DDL 操作修改边类型中属性的注释（即 COMMENT）。

语法

alter_edge_comment ::= ALTER EDGE <edge_name> COMMENT = <string>;

示例
在当前图中修改“knows”边类型注释，命令如下：

ALTER EDGE knows
 COMMENT = '测试Edge1';

增加/删除关联点类型​

自 ArcGraph v2.1.2 版本起，支持通过 Online DDL 操作增加/删除边类型关联的点类型。

语法

alter_edge_endpoint ::= {ADD | DROP} FROM <vertex_name> TO <vertex_name>;

示例 1
在当前图中增加“like”边类型的关联点类型“person”和“person”，命令如下：

ALTER EDGE like
 ADD FROM  person TO person;

示例 2
在当前图中删除“like”边类型的关联点类型“person”和“person”，命令如下：

ALTER EDGE like
 DROP FROM  person TO person;

查看边类型详情​

使用 DESC EDGE 命令查看指定边类型的详细信息。若需了解更多与边类型相关的查看操作，请参见 SHOW EDGES 章节。

语法

desc_edge ::= DESC EDGE <edge_name> [FULL];

详细说明

参数说明
<edge_name>边类型名称，用于指定将要操作的边类型的名称。
[FULL]（可选）用于展示指定边类型的详细信息。若省略，则只展示该边类型的基本信息。
说明：
仅 ArcGraph >= v2.1.1 版本支持此参数。

示例 1
在当前图中查看“like”边类型的基本信息，命令如下：

DESC EDGE like;

返回结果示例如下：

+-------+--------+------+-------+---------+-------+
| name  | type   | null | key   | default | extra |
+=======+========+======+=======+=========+=======+
| name  | string | NO   | INDEX |         |       |
+-------+--------+------+-------+---------+-------+
| since | int64  | YES  |       | 2020    |       |
+-------+--------+------+-------+---------+-------+

示例 2
在当前图中查看“like”边类型的详细信息，命令如下：

DESC EDGE like FULL;

返回结果示例如下：

+--------------------------------------------+
| edge                                       |
+============================================+
| EdgeSchemaMsg {                            |
|     graph_id: 1028,                        |
|     edge_type_id: 1,                       |
|     edge_type_name: "like",                |
|     schema_version: 0,                     |
|     data_version: 0,                       |
|     status: "Normal",                      |
|     properties: [                          |
|         PropertyMsg {                      |
|             property_id: 5,                |
|             property_name: "name",         |
|             property_type: "string",       |
|             type_length: 0,                |
|             nullable: false,               |
|             primary_key: false,            |
|             default_value: Some(           |
|                 ValueMsg {                 |
|                     object: None,          |
|                 },                         |
|             ),                             |
|             index_num: 1,                  |
|             order: 0,                      |
|             comment: "喜欢",               |
|             is_unique: false,              |
|             is_full_text: false,           |
|             v_index_type: None,            |
|             is_oid: false,                 |
|         },                                 |
|         PropertyMsg {                      |
|             property_id: 6,                |
|             property_name: "since",        |
|             property_type: "int64",        |
|             type_length: 8,                |
|             nullable: true,                |
|             primary_key: false,            |
|             default_value: Some(           |
|                 ValueMsg {                 |
|                     object: Some(          |
|                         ValueI64(          |
|                             2020,          |
|                         ),                 |
|                     ),                     |
|                 },                         |
|             ),                             |
|             index_num: 0,                  |
|             order: 0,                      |
|             comment: "开始时间",           |
|             is_unique: false,              |
|             is_full_text: false,           |
|             v_index_type: None,            |
|             is_oid: false,                 |
|         },                                 |
|     ],                                     |
|     vertex_type_pair: [                    |
|         VertexTypePairMsg {                |
|             from_id: 1,                    |
|             to_id: 1,                      |
|             status: "Normal",              |
|             from_name: Some(               |
|                 "person",                  |
|             ),                             |
|             to_name: Some(                 |
|                 "person",                  |
|             ),                             |
|         },                                 |
|     ],                                     |
|     partition_schema: Some(                |
|         PartitionSchemaMsg {               |
|             method: "hash",                |
|             column: "_TYPE",               |
|         },                                 |
|     ),                                     |
|     temporal: false,                       |
|     comment: "测试Edge",                   |
|     indexes: [                             |
|         IndexSchemaMsg {                   |
|             index_id: 3,                   |
|             index_name: "index_a",         |
|             index_type: "Edge",            |
|             graph_id: 1028,                |
|             properties: [                  |
|                 IndexPropertyMsg {         |
|                     property_id: 5,        |
|                     property_name: "name", |
|                     property_path: None,   |
|                     unique: false,         |
|                 },                         |
|             ],                             |
|             status: "Ready",               |
|             type_id: 1,                    |
|             unique: false,                 |
|             version: 0,                    |
|             is_fulltext: false,            |
|             v_index_type: None,            |
|             is_primary_key: false,         |
|         },                                 |
|     ],                                     |
| }                                          |
+--------------------------------------------+

删除边类型​

使用 DROP EDGE 命令删除边类型。删除边类型时，会将边类型中的边数据同步删除，请谨慎操作。

语法

drop_edge ::= DROP EDGE [IF EXISTS] <edge_name> [FORCE];

详细说明

参数说明
[IF EXISTS]（可选）在删除边类型时，用于检测指定的边类型是否存在于当前图中，若存在则删除边类型，若不存在则显示成功但不进行任何操作。仅通过边类型名称进行检测，若省略，则不检测。
<edge_name>边类型名称，用于指定将要操作的边类型的名称。
[FORCE]（可选）使用 FORCE 命令可强制删除边类型。若省略则可能会因为边类型的当前状态导致删除失败。
note
  • 自 ArcGraph v2.1.2 版本起，该功能由 DDL 操作升级为 Online DDL 操作。
  • 自 ArcGraph v2.1.2 版本起，执行 DROP EDGE 命令成功后，数据将立即从 ArcGraph 图数据库中逻辑删除且不可见，但存储于磁盘上的物理数据需等 Schema GC 任务执行后才会被彻底删除。
  • 自 ArcGraph v2.1.2 版本起，通过执行 SHOW FULL EDGES; 命令可以查看已删除但未回收的边类型。这些边类型的 ID 不变，但名字会被定义为 _{name}_{timestamp} 格式，如 _like_1724929319723310。

普通删除​

示例
在当前图中删除“like”的边类型，命令如下：

DROP EDGE IF EXISTS like;

强制删除边类型​

若边类型因当前状态无法正常删除时，可使用 FORCE 命令强制删除。
示例
强制删除“like”的边类型，命令如下：

DROP EDGE IF EXISTS like FORCE;

索引​

索引是数据库中用于提高数据检索性能的一种数据结构。它类似于书籍的目录，可以加快数据库查询操作的速度。

索引的作用是通过创建一个快速访问路径，减少数据库查询时需要扫描的数据量。它可以根据指定的列或字段值创建，并将其存储在特定的数据结构中，以便快速定位和访问数据。

索引的主要类型如下。

类型说明
普通索引最基本的索引，它没有任何限制。
主键索引是一种特殊的唯一索引，一个表只能有一个主键，不允许有空值。
组合索引指多个字段上创建的索引，只有在查询条件中使用了创建索引时的第一个字段，索引才会被使用。

创建索引​

在当前图中创建索引，语法详细说明请参考 创建点类型 章节。

语法

create_index ::= CREATE {VERTEX|EDGE}  INDEX [IF NOT EXISTS] <index_name>
                ON <schema_name> (<index_property> [, <index_property>]...)
                [COMMENT <string>];
        index_property ::= <property_name> [->> json_path];
note
  • 自 ArcGraph v2.1.2 版本起，支持通过 Online DDL 操作执行 Create index 创建索引。
  • 自 ArcGraph v2.1.2 版本起，执行 Create index 命令后， ArcGraph 图数据库服务器的后台会生成一个异步创建索引的任务（通常称为 Job），待任务完成后该索引自动转为 Ready 状态，表明它已准备好被查询使用。通过 SHOW JOBS 命令查看任务的执行情况，详情请参见 SHOW JOBS 章节。
  • 自 ArcGraph v2.1.2 版本起，执行 SHOW FULL {VERTEX|EDGE} INDEXES; 命令可以查看索引的详细信息，包括对应的创建任务 job_id，若 job_id 为空，则表示该索引已创建完成，请参见 SHOW INDEXES 章节。

示例 1
在当前图中为“person”点类型的“name”属性创建索引，命令如下：

CREATE VERTEX INDEX idx_person ON person(name) COMMENT 'person first name index';

返回结果示例如下：

+-----------------------------------------------------------------------------------------+
| Asynchronously creating vertex type index idx_person and job id is 10101966083883663148 |
+=========================================================================================+
+-----------------------------------------------------------------------------------------+

示例 2
在当前图中为“like”边类型的“since”属性创建索引。命令如下：

CREATE EDGE INDEX idx_like ON like(since) COMMENT 'like first since index';

返回结果示例如下：

+-------------------------------------------------------------------------------------+
| Asynchronously creating edge type index idx_like and job id is 14363432717764659822 |
+=====================================================================================+
+-------------------------------------------------------------------------------------+

查看索引详情​

在当前图中使用 DESC INDEX 命令查看指定索引的详细信息。若需了解更多与索引相关的查看操作，请参见 SHOW INDEXES 章节。

语法

desc_index ::= DESC {VERTEX|EDGE} INDEX <schema_name> [FULL];

详细说明

参数说明
<schema_name>索引名称，用于指定将要操作的索引的名称。
[FULL]（可选）用于展示指定索引的详细信息。若省略，则只展示该索引的基本信息。
说明：
仅 ArcGraph >= v2.1.1 版本支持此参数。

示例 1
在当前图中查看点类型中“name_index”索引的基本信息，命令如下：

DESC VERTEX INDEX name_index;

返回结果示例如下：

+------+------+--------+--------+------+---------+
| name | path | type   | unique | null | default |
+======+======+========+========+======+=========+
| name |      | string | YES    | YES  |         |
+------+------+--------+--------+------+---------+

示例 2
在当前图中查看点类型中“name_index”索引的详细信息，命令如下：

DESC VERTEX INDEX name_index FULL;

返回结果示例如下：

+------------------------------------+
| index                              |
+====================================+
| IndexSchemaMsg {                   |
|     index_id: 3,                   |
|     index_name: "name_index",      |
|     index_type: "Vertex",          |
|     graph_id: 1026,                |
|     properties: [                  |
|         IndexPropertyMsg {         |
|             property_id: 3,        |
|             property_name: "name", |
|             property_path: None,   |
|             unique: true,          |
|         },                         |
|     ],                             |
|     status: "Ready",               |
|     type_id: 1,                    |
|     unique: true,                  |
|     version: 0,                    |
|     is_fulltext: false,            |
|     v_index_type: None,            |
|     is_primary_key: false,         |
| }                                  |
+------------------------------------+

示例 3
在当前图中查看边类型中“index_a”索引的基本信息，命令如下：

DESC EDGE INDEX index_a;

返回结果示例如下：

+------+------+--------+--------+------+---------+
| name | path | type   | unique | null | default |
+======+======+========+========+======+=========+
| name |      | string | NO     | NO   |         |
+------+------+--------+--------+------+---------+

删除索引​

在当前图中删除索引，可使用 FORCE 命令强制删除索引。
语法

drop_index ::= DROP {VERTEX|EDGE} INDEX [IF EXISTS] <index_name> [FORCE];
note
  • 自 ArcGraph v2.1.2 版本起，该功能由 DDL 操作升级为 Online DDL 操作。
  • 自 ArcGraph v2.1.2 版本起，执行删除索引命令成功后，数据将立即从 ArcGraph 图数据库中逻辑删除且不可见，但存储于磁盘上的物理数据需等 Schema GC 任务执行后才会被彻底删除。
  • 自 ArcGraph v2.1.2 版本起，通过执行 SHOW FULL {VERTEX|EDGE} INDEXES; 命令可以查看已删除但未回收的索引。这些索引的 ID 不变，但名字会被定义为 _{name}_{timestamp} 格式，如 _idx_person_1724931030554177。

示例 1

DROP VERTEX INDEX idx_person;

示例 2

DROP EDGE INDEX idx_like;

示例 3

DROP VERTEX INDEX idx_person FORCE;

DML（增 | 删 | 改）​

DML 是一种用于操作数据库中数据的语言。在 ArcGraph 图数据库中使用 DML 对点数据、边数据进行新增、修改、删除等操作。

前提条件​

  • 已创建并使用图
  • 已创建点类型
  • 已创建与点类型相关联的边类型

新增数据​

语法

insert ::= INSERT <insert_value> [, <insert_value>]... ;
insert_value ::= <vertex_value>|<edge_value>;
vertex_value ::= (:<vertex_type> <properties>);
properties ::= '{' <property_name> : <expression> [ ',' <property_name> : <expression> ]... '}' ;
edge_value ::= <vertex_value>-'[':<edge_type> [<properties> |<_ts> ]']'-><vertex_value>;

详细说明

参数说明
<insert_value>表示将要插入的点或边的值。
<vertex_value>表示将要插入的点的值。
<edge_value>表示将要插入的边的值。
<vertex_type>表示将要操作的点类型。
<properties>表示将要插入的点的属性及其对应的值。
<property_name>表示属性名称。同一个点类型下属性名称必须是唯一的且命名时应遵循特定的规则和要求，命名规则详情请参见 命名规则 章节。
<expression>表示属性的数据值，详情请参见 表达式 章节。
<edge_type>表示将要操作的边类型。
<_ts>一种特殊属性，用于表示时间戳。当边中包含此属性时，我们称之为时态边，因为它与时间紧密相关。

新增点数据​

使用 INSERT 命令，为点类型中新增点数据。若同时新增多个点数据，可用“,”隔开点数据进行新增。

示例 1
在当前图中，为“person”点类型中插入“John”点数据，命令如下：

INSERT (:person {id:1, name:'John', age:30});

示例 2
在当前图中，同时为“person”点类型中插入“Mary”和“Jerry”点数据，命令如下：

INSERT (:person {id:2, name:'Mary', age:25}), (:person {id:3, name:'Jerry', age:22});

示例 3
在当前图中，为“PersonArray”点类型中插入包含 ARRAY 属性的点数据，命令如下：

INSERT (:PersonArray {id:1, name:'Tom', hobbies:['Reading', 'Swimming', 'Cycling']});

详细说明

  • INSERT 插入子句不可在 MATCH 查询子句之后。
  • INSERT 插入子句插入点数据时，必须包含具体点类型以及点数据的主键信息。

新增边数据​

使用 INSERT 命令，可以新增边数据，包括时态边数据。新增时态边数据详情请参见 新增时态边数据 章节。

示例 1
在当前图中，为“like”边类型中插入边数据，命令如下：

INSERT (a:person {id:1})-[:like {name:'喜欢'}]->(b:person {id:2});

示例 2
在当前图中，为“like”边类型中插入多个边数据，用“,”隔开，命令如下：

INSERT (:person {id:1})-[:like {name:'喜欢'}]->(:movie {id:1}),(:person {id:2})-[:like {name:'喜欢'}]->(:movie {id:1});

示例 3
在当前图中，为“FRIEND_OF”边类型中插入包含 ARRAY 属性的边数据。命令如下：

INSERT (:PersonArray {id:1})-[:FRIEND_OF {commonHobbies:['Reading','Cycling']}]->(:PersonArray {id:2});

详细说明

  • INSERT 插入子句不可在 MATCH 查询子句之后。
  • 每一个 INSERT 插入子句，至多允许一个边类型。
  • INSERT 子句插入边数据时，连接的点必须包含具体点类型以及点数据的主键信息。
  • _ts 作为一个特殊属性放在边类型中，它作为保留字不允许被用作普通属性名称。

修改数据​

语法

update_set ::= MATCH <pattern_part>
            [WHERE <expression>]
            SET <set_item> [, <set_item>];
set_item = <schema_name> . <property_name> = <expression>;

详细说明

参数说明
<pattern_part>定义一种描述点或边的模式，可以是一个或多个。
[WHERE <expression>]（可选）定义一种过滤条件，用于过滤匹配的点或边。
<set_item>定义将要修改的变量名称和属性名称。
<schema_name>表示 SET 语句前查询出的点或边的变量名称。
<property_name>表示将要修改的属性名称。
<expression>表示属性的数据值，详情请参见 表达式 章节。

修改点数据​

使用 SET 命令修改点属性。

示例 1
在当前图中，修改“John”点的名称为“Michael”，命令如下：

MATCH (n:person)
WHERE n.name = 'John'
SET n.name = 'Michael';

示例 2
在当前图中，同时修改“person”点类型下“Michael”点数据的多个属性，命令如下：

MATCH (n:person {id:1, name:'Michael', age:30})
SET n.name = 'John1', n.age = 28;

示例 3
在当前图中，将“person”点类型下所有点数据的多个属性值同时修改为相同的属性值，命令如下：

MATCH (n:person)
SET n.name = 'John1', n.age = '30';

详细说明

  • SET 语句前必须有 query 语句。
  • SET语句中只对 propertyName=value 中定义的属性值进行修改，其他属性保持不变。
  • 不能直接通过传入一个 map 形式的数据来修改点的属性值。在对点进行操作时，需要逐个修改每个属性的值，而不能一次性修改整个点的属性。
  • 不支持修改主键 id。

修改边数据​

使用 SET 命令修改边属性。

示例
在当前图中，修改边属性，命令如下：

MATCH (n:person {name:'John'})-[r:like]->(m)
SET r.name = 'xihuan1';

详细说明

  • SET 语句前必须有 query 语句。
  • SET 语句中只对propertyName=value中定义的属性值进行修改，其他属性保持不变。
  • 不能直接通过传入一个 map 形式的数据来修改边对象的属性值。在对边对象进行操作时，需要逐个修改每个属性的值，而不能一次性修改整个边对象的属性。
  • 不支持修改主键 id 和 _ts 值。

删除数据​

语法

delete ::= MATCH <pattern_part>
         [WHERE <expression>] [{DETACH|NODETACH}] 
         DELETE {<vertex_name>|<edge_name>};

详细说明

参数说明
<pattern_part>定义一种描述点或边的模式，可以是一个或多个。
[WHERE <expression>]（可选）定义一种过滤条件，用于过滤匹配的点或边。
[{DETACH|NODETACH}]（可选）表示同时删除点和与之相关联的边。
<vertex_name>表示将要删除的点变量名称。
<edge_name>表示将要删除的边变量名称。

删除独立的点​

使用 DELETE 删除独立的点，若该点有与之相关联的边，则提示操作错误，此时，需要同时删除点和与之相关联的边。

示例
在当前图中，删除“John”点，命令如下：

MATCH (n:person {name:'John'})
DELETE n;

同时删除点及其关联边​

DELETE 子句的默认模式是 NODETACH 模式。在这种模式下，删除点时，若该点有与之相关联的边，则删除操作失败。所以需要搭配 DETACH 子句使用，才可以同时删除点和与之相关联的边。

示例
在当前图中，删除“John”点和与之相关联的边，命令如下：

MATCH (p:person {id:1, name:'John'})
DETACH DELETE p;

同时删除点类型及其关联边​

使用 DETACH DELETE 删除指定点类型及其包含的所有点和与点相关联的边。

示例
在当前图中，删除“person”点类型中的所有点和与点相关联的边，命令如下：

MATCH (p:person)
DETACH DELETE p;

基本查询​

DQL 是一种用于查询数据库中数据的语言。在 ArcGraph 图数据库中，用户通过使用 DQL 语言可以从数据库中检索所需的数据，并根据特定的条件和要求进行过滤、排序和聚合。这使得用户可以轻松地获取所需的数据，并进行进一步的分析和处理。

语法

	<query> ::= <match> <return> ;

	match ::=
	    MATCH <pattern_part>
	    [WHERE <expression>]

	return ::=
	    RETURN [DISTINCT] <projection_list>
	    [<order>]
	    [SKIP <integer>] [LIMIT <integer>]

	pattern_part ::= { <variable> = <pattern_element> | <pattern_element> }

	pattern_element ::= <node_pattern> [ <pattern_element_chain> ]...

	pattern_element_chain ::= <relationship_pattern> <node_pattern>

	relationship_pattern ::=
        {
            <- <relationship_detail> ->
            | <- <relationship_detail> -
            | - <relationship_detail> ->
            | - <relationship_detail> -
        }

	relationship_detail ::= '[' [<variable>] [<relationship_types>][<range_literal>] [<properties>] ']'

	relationship_types ::= : <rel_type_name> [ '|' <rel_type_name> ]...

	range_literal ::= * [<integer>] ['..' [<integer>]]

	node_pattern ::= ([<variable>] [<node_labels>] [<properties>])

	node_labels ::= : <label_name> [ '|' <label_name> ]...

	properties ::= '{' <property_name> : <expression> [ ',' <property_name> : <expression> ]... '}'

	projection_list ::= *
        | <projection_item> [',' <projection_item>]...

	projection_item ::=
        { <expression> AS <variable> | <expression> }

	order ::= ORDER BY <sort_item> [ ',' <sort_item> ]...

	sort_item ::= <expression> [ {ASCENDING | ASC | DESCENDING | DESC} ]

查询点​

查询所有的点​

查询当前图中所有的点。

示例
在当前图中查询所有的点。命令如下：

MATCH (n) RETURN n;

返回结果示例如下：

+-----------------------------------------------------------------------------------------+
| n                                                                                       |
+=========================================================================================+
| vid: [_oid: 36998642535497729, label: person], properties: [36998642535497729, 2, Mary] |
+-----------------------------------------------------------------------------------------+
| vid: [_oid: 36998642535497728, label: person], properties: [36998642535497728, 1, John] |
+-----------------------------------------------------------------------------------------+
| vid: [_oid: 73027439569141762, label: book], properties: [73027439569141762, 1, book1]  |
+-----------------------------------------------------------------------------------------+

查询指定点类型的点​

  • 查询单个点类型的点

    查询当前图中某一个点类型的所有点。

    示例 1
    在当前图中查询“person”点类型中的所有点。命令如下：

    MATCH (m:person) RETURN m;

    返回结果示例如下：

    +-----------------------------------------------------------------------------------------+
    | m                                                                                       |
    +=========================================================================================+
    | vid: [_oid: 36998642535497729, label: person], properties: [36998642535497729, 2, Mary] |
    +-----------------------------------------------------------------------------------------+
    | vid: [_oid: 36998642535497728, label: person], properties: [36998642535497728, 1, John] |
    +-----------------------------------------------------------------------------------------+

    示例 2
    在当前图中查询“person”点类型中的 id 为“1”的点，命令如下：

    MATCH (m:person{id:1}) RETURN m;

    返回结果示例如下：

    +-----------------------------------------------------------------------------------------+
    | m                                                                                       |
    +=========================================================================================+
    | vid: [_oid: 36998642535497728, label: person], properties: [36998642535497728, 1, John] |
    +-----------------------------------------------------------------------------------------+

  • 查询多个点类型的点

    查询当前图中多个点类型的所有点，可以用“|”（“或”符号）将不同点类型连接在一起，各点类型间为“或”的关系。

    示例 1
    在当前图中查询“person”和“book”点类型中的所有点。命令如下：

    MATCH (m:person|book)
    RETURN m;

    返回结果示例如下：

    +-----------------------------------------------------------------------------------------+
    | m                                                                                       |
    +=========================================================================================+
    | vid: [_oid: 73027439569141762, label: book], properties: [73027439569141762, 1, book1]  |
    +-----------------------------------------------------------------------------------------+
    | vid: [_oid: 36998642535497728, label: person], properties: [36998642535497728, 1, John] |
    +-----------------------------------------------------------------------------------------+
    | vid: [_oid: 36998642535497729, label: person], properties: [36998642535497729, 2, Mary] |
    +-----------------------------------------------------------------------------------------+

查询与指定点相关联的点​

查询当前图中，1 跳范围内与指定点相关联的所有点。ArcGraph 图数据库中，在不考虑边的类型和方向的情况下，通常使用 -- 符号表示与之相关。

示例 1
在当前图中查询 1 跳范围内与“John”相关的所有点。命令如下：

MATCH (a: person {name: 'John'})--(m)
RETURN m;

返回结果示例如下：

+-----------------------------------------------------------------------------------------+
| m                                                                                       |
+=========================================================================================+
| vid: [_oid: 36998642535497729, label: person], properties: [36998642535497729, 2, Mary] |
+-----------------------------------------------------------------------------------------+
| vid: [_oid: 36998642535497729, label: person], properties: [36998642535497729, 2, Mary] |
+-----------------------------------------------------------------------------------------+

示例 2
在当前图中查询 1 跳范围内与“John”相关的“person”点类型中的所有点。命令如下：

MATCH (n:person { name: 'John' })--(m:person)
RETURN m;

返回结果示例如下：

+-----------------------------------------------------------------------------------------+
| m                                                                                       |
+=========================================================================================+
| vid: [_oid: 36998642535497729, label: person], properties: [36998642535497729, 2, Mary] |
+-----------------------------------------------------------------------------------------+
| vid: [_oid: 36998642535497729, label: person], properties: [36998642535497729, 2, Mary] |
+-----------------------------------------------------------------------------------------+

查询有向边相关联的点​

在当前图中，当需要查询 1 跳范围内通过有向边连接的点时，可以用 -->（即正向边）或 <--（即反向边）表示。

  • 查询通过正向边/反向边相关的所有点

    示例 1
    在当前图中查询 1 跳范围内通过正向边相关的所有点。命令如下：

    MATCH (n)-->(m)
    RETURN m;

    返回结果示例如下：

    +-----------------------------------------------------------------------------------------+
    | m                                                                                       |
    +=========================================================================================+
    | vid: [_oid: 36998642535497728, label: person], properties: [36998642535497728, 1, John] |
    +-----------------------------------------------------------------------------------------+
    | vid: [_oid: 36998642535497729, label: person], properties: [36998642535497729, 2, Mary] |
    +-----------------------------------------------------------------------------------------+

    示例 2
    在当前图中查询 1 跳范围内通过反向边相关的所有点。命令如下：

    MATCH (n)<--(m)
    RETURN m;

    返回结果示例如下：

    +-----------------------------------------------------------------------------------------+
    | m                                                                                       |
    +=========================================================================================+
    | vid: [_oid: 36998642535497729, label: person], properties: [36998642535497729, 2, Mary] |
    +-----------------------------------------------------------------------------------------+
    | vid: [_oid: 36998642535497728, label: person], properties: [36998642535497728, 1, John] |
    +-----------------------------------------------------------------------------------------+

  • 查询与指定点通过正向边/反向边相关的所有点

    示例 1
    在当前图中查询 1 跳范围内与指定点“John”通过正向边相关的所有点。命令如下：

    MATCH (n:person { name: 'John' })-->(m)
    RETURN m;

    返回结果示例如下：

    +-----------------------------------------------------------------------------------------+
    | m                                                                                       |
    +=========================================================================================+
    | vid: [_oid: 36998642535497729, label: person], properties: [36998642535497729, 2, Mary] |
    +-----------------------------------------------------------------------------------------+

    示例 2
    在当前图中查询 1 跳范围内与指定点“John”通过反向边相关的所有点。命令如下：

    MATCH (n:person { name: 'John' })<--(m)
    RETURN m;

    返回结果示例如下：

    +-----------------------------------------------------------------------------------------+
    | m                                                                                       |
    +=========================================================================================+
    | vid: [_oid: 36998642535497729, label: person], properties: [36998642535497729, 2, Mary] |
    +-----------------------------------------------------------------------------------------+

查询与指定边类型相关联的所有点​

  • 查询单个边类型相关联的所有点

    查询当前图中某一个边类型关联的所有点。

    示例 1
    在当前图中查询与“Mary”具有“like”关联关系的所有点。命令如下：

    MATCH (n)-[:like]->(m:person {name: 'Mary'})
    RETURN n;

    返回结果示例如下：

    +-----------------------------------------------------------------------------------------+
    | n                                                                                       |
    +=========================================================================================+
    | vid: [_oid: 36998642535497728, label: person], properties: [36998642535497728, 1, John] |
    +-----------------------------------------------------------------------------------------+

    示例 2
    在当前图中查询具有“like”关联关系的所有点，命令如下：

    MATCH (n)-[:like]->(m)
    RETURN n;

    返回结果示例如下：

    +-----------------------------------------------------------------------------------------+
    | n                                                                                       |
    +=========================================================================================+
    | vid: [_oid: 36998642535497729, label: person], properties: [36998642535497729, 2, Mary] |
    +-----------------------------------------------------------------------------------------+
    | vid: [_oid: 36998642535497728, label: person], properties: [36998642535497728, 1, John] |
    +-----------------------------------------------------------------------------------------+

  • 查询多个边类型相关联的所有点

    查询当前图中多个边类型关联的所有点，可以用“|”（“或”符号）将不同边类型连接在一起，各边类型间为“或”的关系。

    示例
    在当前图中查询具有“like”或“know”关联关系的所有点。命令如下：

    MATCH (n)-[:like|know]->(m:person {name: 'Mary'})
    RETURN n;

    返回结果示例如下：

    +-----------------------------------------------------------------------------------------+
    | n                                                                                       |
    +=========================================================================================+
    | vid: [_oid: 36998642535497728, label: person], properties: [36998642535497728, 1, John] |
    +-----------------------------------------------------------------------------------------+

查询边​

查询所有的边​

查询当前图中 1 跳范围内所有的边。

示例
在当前图中查询 1 跳范围内所有的边。命令如下：

MATCH (n)-[r]->(m)
RETURN r;

返回结果示例如下：

+-----------------------------------------------------------------------------------------------------------------------------------------------------+
| r                                                                                                                                                   |
+=====================================================================================================================================================+
| eid: [src: [_oid: 36990974638948352, label: person], dest: [_oid: 36990974643142657, label: person], label: like, _ts: 0], properties: [喜欢, 2020] |
+-----------------------------------------------------------------------------------------------------------------------------------------------------+

查询指定点之间的边​

查询 1 跳范围内与指定点相关联的所有边。

示例
在当前图中查询 1 跳范围内“John”与“Mary”之间所有的边。命令如下：

MATCH (n:person { name: 'John' })-[r]->(m:person { name: 'Mary' })
RETURN r;

返回结果示例如下：

+-----------------------------------------------------------------------------------------------------------------------------------------------------+
| r                                                                                                                                                   |
+=====================================================================================================================================================+
| eid: [src: [_oid: 36990974638948352, label: person], dest: [_oid: 36990974643142657, label: person], label: like, _ts: 0], properties: [喜欢, 2020] |
+-----------------------------------------------------------------------------------------------------------------------------------------------------+

查询边类型属性​

在当前图中，查询两个点之间边的类型以及属性。

示例 1
在当前图中查询“John”与“Mary”之间所有边的边类型。命令如下：

MATCH (n:person { name: 'John' })-[r]->(m:person { name: 'Mary' })
RETURN type(r);

返回结果示例如下：

+---------+
| type(r) |
+=========+
| like    |
+---------+

示例 2
在当前图中查询“John”与“Mary”之间所有边的属性“name”。命令如下：

MATCH (n:person { name: 'John' })-[r]->(m:person { name: 'Mary' })
RETURN r.name;

返回结果示例如下：

+--------+
| r.name |
+========+
| 喜欢   |
+--------+

查询多重边​

在 ArcGraph 图数据库中，通过 () -[]- () 边模式，可以将多个边连接在一起。

示例
在当前图中查询名为“John”的人正在学习的书籍，以及这些书籍的作者。命令如下：

MATCH (n:person { name: 'John' })-[:learning]->(p:book)<-[:author]-(m:person) 
RETURN p.name, m.name;

返回结果示例如下：

+--------+--------+
| p.name | m.name |
+========+========+
| book1  | Mary   |
+--------+--------+

查询可变长度边​

当两点间的边、路径长度、点的度数等可变时，使用 -[:TYPE*minHops..maxHops]→ 语句可查找满足条件的点。-[:TYPE*minHops..maxHops]→ 语句的详细说明如下：

  • -[:TYPE*minHops..maxHops]→ 语句中，minHops 和 maxHops 表示路径中边的数量（跳数）的边界值。
  • minHops 表示路径中至少要经过的边数。默认情况下，其取值范围为大于等于 0 的整数，可根据实际情况设置该参数值，当省略该参数时则使用默认值 1；当设置为 0 时，则表示可以包括起点本身（即没有边的路径）。
  • maxHops 表示路径中最多可以经过的边数，默认情况下，其取值范围为 1~8 的整数。可根据实际情况设置该参数值，当省略该参数时则使用默认值 8。通过 SET SESSION 或 SET GLOBAL 命令调整 compiler_max_var_hops 参数可以自定义 maxHops 的取值范围，详情请参见 更改系统变量 章节。
  • 当未给定边界值时，表示 minHops 和 maxHops 参数使用默认值，此时 minHops 和 maxHops 间的“..”可省略，例如 [:like*]，表示长度为 1~8 跳范围内的路径。
  • 当只给定一个边界值并省略 minHops 和 maxHops 间的“..”时，表示该路径长度固定。例如 [:like*2]，表示该路径长度固定为 2。
  • 当两个点之间的路径长度为零时，即零度边，意味着它们实际上是同一个点，因此，即使在没有边数据的边类型上进行匹配，返回结果仍会包含该点本身。

示例 1
在当前图中查询路径长度为 0 跳且与“John”有“like”关联关系的所有点，命令如下：

MATCH (m:person {name: 'John'})-[*0]-(x)
RETURN x;

返回结果示例如下：

+-----------------------------------------------------------------------------------------+
| x                                                                                       |
+=========================================================================================+
| vid: [_oid: 36998642535497728, label: person], properties: [36998642535497728, 1, John] |
+-----------------------------------------------------------------------------------------+

示例 2

MATCH (m:person {name: 'John'})-[*0..1]-(x)
RETURN x;

返回结果示例如下：

+-----------------------------------------------------------------------------------------+
| x                                                                                       |
+=========================================================================================+
| vid: [_oid: 36998642535497728, label: person], properties: [36998642535497728, 1, John] |
+-----------------------------------------------------------------------------------------+
| vid: [_oid: 36998642535497729, label: person], properties: [36998642535497729, 2, Mary] |
+-----------------------------------------------------------------------------------------+
| vid: [_oid: 36998642535497729, label: person], properties: [36998642535497729, 2, Mary] |
+-----------------------------------------------------------------------------------------+

示例 3
在当前图中查询 1~3 跳范围内与“John”有“like”关联关系的所有点，命令如下：

MATCH (n:person {name:'John'})-[:like*1..3]->(m:person)
RETURN m.name;

返回结果示例如下：

+--------+
| m.name |
+========+
| Mary   |
+--------+
| John   |
+--------+
| Mary   |
+--------+

示例 4
在当前图中查询 1~2 跳范围内与“John”有“like”关联关系的所有点，命令如下：

MATCH (n:person {name:'John'}) - [r:like * ..2] -> (m:person)
RETURN m.name;

返回结果示例如下：

+--------+
| m.name |
+========+
| Mary   |
+--------+
| John   |
+--------+

示例 5
默认情况下，在当前图中查询 1~8 跳范围内与“John”有“like”关联关系的所有点，命令如下：

MATCH (n:person {name:'John'}) - [r:like * ..] -> (m:person)
RETURN m.name;

返回结果示例如下：

+--------+
| m.name |
+========+
| Mary   |
+--------+
| John   |
+--------+
| Mary   |
+--------+
| John   |
+--------+
| Mary   |
+--------+
| John   |
+--------+
| Mary   |
+--------+
| John   |
+--------+

示例 6
在当前图中查询路径长度为 2 跳且与“John”有“like”关联关系的所有点，命令如下：

MATCH (n:person {name:'John'}) - [r:like *2] -> (m:person)
RETURN m.name;

返回结果示例如下：

+--------+
| m.name |
+========+
| John   |
+--------+

查询路径​

在 ArcGraph 图数据库中，通过路径查询可以查找和返回当前图中从一点到另一点的完整路径。路径的基本查询如下，更多操作请参考 路径函数 章节。

查询所有路径​

在当前图中查询和返回长度大于等于 1 跳的所有路径。

示例
在当前图中查询长度大于等于 1 跳的所有路径。命令如下：

MATCH p = (n)-[*]->()  
RETURN p;

返回结果示例如下：

+---------------------------------------------------------------------------------------------------------------------------------+
| p                                                                                                                               |
+=================================================================================================================================+
| Path: [                                                                                                                         |
|     Vertex _oid: 36998642535497728, label: person                                                                               |
| ->  Edge   src: [_oid: 36998642535497728, label: person], dest: [_oid: 36998642535497729, label: person], label: like, _ts: 0   |
| ->  Vertex _oid: 36998642535497729, label: person                                                                               |
| ]                                                                                                                               |
+---------------------------------------------------------------------------------------------------------------------------------+

查询从指定点开始的所有路径​

在 ArcGraph 图数据库中，查询从指定点开始的所有路径。

示例
在当前图中查询从“John”点开始的所有路径。命令如下：

MATCH p = (n:person {name:'John'})-[*]->()  
RETURN p;

返回结果示例如下：

+---------------------------------------------------------------------------------------------------------------------------------+
| p                                                                                                                               |
+=================================================================================================================================+
| Path: [                                                                                                                         |
|     Vertex _oid: 36998642535497728, label: person                                                                               |
| ->  Edge   src: [_oid: 36998642535497728, label: person], dest: [_oid: 36998642535497729, label: person], label: like, _ts: 0   |
| ->  Vertex _oid: 36998642535497729, label: person                                                                               |
| ]                                                                                                                               |
+---------------------------------------------------------------------------------------------------------------------------------+

查询指定长度范围内的所有路径​

查询路径长度在指定范围内的所有路径。

示例
在当前图中查询通过“like”边连接的 id 为“1”和“3”的“person”点之间，路径长度在 1 到 3 范围内的所有路径。命令如下：

MATCH  p=allPath((m: person {id: 1})-[e:like*1..3]->(n:person{id: 2}) )
RETURN p;

返回结果示例如下：

+---------------------------------------------------------------------------------------------------------------------------------+
| p                                                                                                                               |
+=================================================================================================================================+
| Path: [                                                                                                                         |
|     Vertex _oid: 36998015365414912, label: person                                                                               |
| ->  Edge   src: [_oid: 36998015365414912, label: person], dest: [_oid: 36998015365414913, label: person], label: like, _ts: 0   |
| ->  Vertex _oid: 36998015365414913, label: person                                                                               |
| ->  Edge   src: [_oid: 36998015365414913, label: person], dest: [_oid: 36998015365414914, label: person], label: like, _ts: 0   |
| ->  Vertex _oid: 36998015365414914, label: person                                                                               |
| ]                                                                                                                               |
+---------------------------------------------------------------------------------------------------------------------------------+
| Path: [                                                                                                                         |
|     Vertex _oid: 36998015365414912, label: person                                                                               |
| ->  Edge   src: [_oid: 36998015365414912, label: person], dest: [_oid: 36998015365414915, label: person], label: like, _ts: 0   |
| ->  Vertex _oid: 36998015365414915, label: person                                                                               |
| ->  Edge   src: [_oid: 36998015365414915, label: person], dest: [_oid: 36998015365414914, label: person], label: like, _ts: 0   |
| ->  Vertex _oid: 36998015365414914, label: person                                                                               |
| ]                                                                                                                               |
+---------------------------------------------------------------------------------------------------------------------------------+

查询最短路径​

查询两点间存在的最短路径。当存在多条最短路径时，ShortestPath() 函数将随机选择一条最短路径返回。

示例
在当前图中查询通过“like”边连接的 id 为“1”和“3”的“person”点之间，路径长度不超过 3 跳的单个最短路径。命令如下：

MATCH  p=ShortestPath((m: person {id: 1})-[e:like*..3]-(n:person{id: 3}) )
RETURN p;

返回结果示例如下：

+---------------------------------------------------------------------------------------------------------------------------------+
| p                                                                                                                               |
+=================================================================================================================================+
| Path: [                                                                                                                         |
|     Vertex _oid: 36998015365414912, label: person                                                                               |
| ->  Edge   src: [_oid: 36998015365414912, label: person], dest: [_oid: 36998015365414913, label: person], label: like, _ts: 0   |
| ->  Vertex _oid: 36998015365414913, label: person                                                                               |
| ->  Edge   src: [_oid: 36998015365414913, label: person], dest: [_oid: 36998015365414914, label: person], label: like, _ts: 0   |
| ->  Vertex _oid: 36998015365414914, label: person                                                                               |
| ]                                                                                                                               |
+---------------------------------------------------------------------------------------------------------------------------------+

查询所有最短路径​

查询两点之间存在的所有最短路径。

示例
在当前图中查询通过“like”边连接的 id 为“1”和“3”的“person”点之间，路径长度不超过 3 跳的所有最短路径。命令如下：

MATCH (m: person {id: 1}),(n:person{id: 3})  WITH m,n, 
allShortestPaths((m)-[e:like*..3]->(n)) AS p 
RETURN p;

返回结果示例如下：

+---------------------------------------------------------------------------------------------------------------------------------+
| p                                                                                                                               |
+=================================================================================================================================+
| Path: [                                                                                                                         |
|     Vertex _oid: 36998015365414912, label: person                                                                               |
| ->  Edge   src: [_oid: 36998015365414912, label: person], dest: [_oid: 36998015365414913, label: person], label: like, _ts: 0   |
| ->  Vertex _oid: 36998015365414913, label: person                                                                               |
| ->  Edge   src: [_oid: 36998015365414913, label: person], dest: [_oid: 36998015365414914, label: person], label: like, _ts: 0   |
| ->  Vertex _oid: 36998015365414914, label: person                                                                               |
| ]                                                                                                                               |
+---------------------------------------------------------------------------------------------------------------------------------+
| Path: [                                                                                                                         |
|     Vertex _oid: 36998015365414912, label: person                                                                               |
| ->  Edge   src: [_oid: 36998015365414912, label: person], dest: [_oid: 36998015365414915, label: person], label: like, _ts: 0   |
| ->  Vertex _oid: 36998015365414915, label: person                                                                               |
| ->  Edge   src: [_oid: 36998015365414915, label: person], dest: [_oid: 36998015365414914, label: person], label: like, _ts: 0   |
| ->  Vertex _oid: 36998015365414914, label: person                                                                               |
| ]                                                                                                                               |
+---------------------------------------------------------------------------------------------------------------------------------+

子句​

RETURN​

在 MATCH 查询语句中，可以使用 RETURN 子句对想要查询的内容加以界定并返回，界定的内容可以是点、边或属性。

如果只查询属性值，建议不要返回完整的点或边。这样做有助于提高查询性能，减少数据传输量和处理时间。

  • 返回点

    使用 RETURN 子句返回所需的点。

    示例
    查询名为“John”的点，命令如下：

    MATCH  (n:person {name:'John'}) 
    RETURN n;

    返回结果示例如下：

    +---------------------------------------------------------------------------------------------+
    | n                                                                                           |
    +=============================================================================================+
    | vid: [_oid: 36990974638948352, label: person], properties: [36990974638948352, 1, John, 30] |
    +---------------------------------------------------------------------------------------------+

  • 返回边

    使用 RETURN 子句返回所需的边。

    示例
    返回“John”喜欢的人的边，命令如下：

    MATCH (n:person {name:'John'})-[r:like]->(:person)
    RETURN r;

    返回结果示例如下：

    +-----------------------------------------------------------------------------------------------------------------------------------------------------+
    | r                                                                                                                                                   |
    +=====================================================================================================================================================+
    | eid: [src: [_oid: 36990974638948352, label: person], dest: [_oid: 36990974643142657, label: person], label: like, _ts: 0], properties: [喜欢, 2020] |
    +-----------------------------------------------------------------------------------------------------------------------------------------------------+

  • 返回属性

    返回属性时，请使用点操作符来获取属性。若要返回属性值，则该点所属的点类型不能省略。

    示例
    返回“John”点的 name 属性，命令如下：

    MATCH (n:person {name:'John'})
    RETURN n.name;

    返回结果示例如下：

    +----------+
    | n.name   |
    +==========+
    | John     |
    +----------+

  • 返回所有元素

    如果要返回查询中的所有点、边和路径，使用“*”符号。

    示例
    返回查询“John”过程中，所有与之相关的点、边和路径。命令如下：

    MATCH p =(a:person {name:'John'})-[r]->(b) 
    RETURN *;

    返回结果示例如下：

    +---------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+
    | a                                                                                           | b                                                                                           | p                                                                                                                             | r                                                                                                                                                   |
    +=============================================================================================+=============================================================================================+===============================================================================================================================+=====================================================================================================================================================+
    | vid: [_oid: 36990974638948352, label: person], properties: [36990974638948352, 1, John, 30] | vid: [_oid: 36990974643142657, label: person], properties: [36990974643142657, 2, Mary, 25] | Path: [                                                                                                                       | eid: [src: [_oid: 36990974638948352, label: person], dest: [_oid: 36990974643142657, label: person], label: like, _ts: 0], properties: [喜欢, 2020] |
    |                                                                                             |                                                                                             |     Vertex _oid: 36990974638948352, label: person                                                                             |                                                                                                                                                     |
    |                                                                                             |                                                                                             | ->  Edge   src: [_oid: 36990974638948352, label: person], dest: [_oid: 36990974643142657, label: person], label: like, _ts: 0 |                                                                                                                                                     |
    |                                                                                             |                                                                                             | ->  Vertex _oid: 36990974643142657, label: person                                                                             |                                                                                                                                                     |
    |                                                                                             |                                                                                             | ]                                                                                                                             |                                                                                                                                                     |
    +---------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------------------+

  • 列别名
    查询结果返回的列名可能是数据库中存储的原始列名或属性名。但有时这些列名可能过长、不易理解或与其他列冲突。为了解决这个问题，可以使用列别名来为查询结果中的列或属性提供一个更简洁、易懂的名称。

    列别名可以在查询中使用“AS +新名称”来定义。

    示例
    返回“John”点的 name 属性，但重命名为“former_name”曾用名。命令如下：

    MATCH (n:person {name:'John'}) 
    RETURN n.name AS former_name;

    返回结果示例如下：

    +-------------+
    | former_name |
    +=============+
    | John        |
    +-------------+

  • 结果去重

    使用 DISTINCT 子句，为返回结果去除重复项。

    示例
    查询并返回与“John”点有关联关系的点，若数据重复，则只返回一个，命令如下：

    MATCH (a:person {name:'John'})-->(b:person)
    RETURN DISTINCT b.name;

    返回结果示例如下：

    +--------+
    | b.name |
    +========+
    | Mary   |
    +--------+

  • 其他表达式

    查询中的 RETURN 部分也可以用来返回常量，表达式，函数等。

    • 计算表达式支持”+“、”-“、”*“、”/“、”%“等二元操作符，和”+“、”-“、”^(幂次)“等一元操作。
    • 函数目前只支持 id 和 type 函数。

    示例 1
    使用 RETURN 返回计算表达式，命令如下：

    MATCH (m:person {name:'John'})-[r:like]->(n:person) 
    RETURN n.id, n.id%10+1, 1;

    返回结果示例如下：

    +------+---------------+---+
    | n.id | n.id % 10 + 1 | 1 |
    +======+===============+===+
    | 2    | 3             | 1 |
    +------+---------------+---+

    示例 2
    使用 RETURN 返回点的 ID 和点类型 ID。命令如下：

    MATCH (m:person) -[:like] -> (n:person)
    WHERE id(m) = 1
    RETURN id(n), type_id(n);

    返回结果示例如下：

    +-------+------------+
    | id(n) | type_id(n) |
    +=======+============+
    | 1     | 1          |
    +-------+------------+

WITH​

WITH 子句在图数据库查询中起到非常关键的作用，它能够将多个查询语句串联起来，并传递一部分查询结果作为下一查询的起始点。这使得查询过程更加灵活，并能显著减少重复计算和数据冗余。

说明：

  • WITH 子句中的表达式必须具有别名，或自身可作为别名（如变量、点、边、路径）。例如，WITH m.id 是错误的，可能会引发 INVALID_EXPRESSION 错误，而 WITH m.id AS m_id 是正确的，因为它为表达式 m.id 指定了别名 m_id。
  • WITH 中变量的可见性约束如下。
    • 若 WITH/RETURN 子句中包含 DISTINCT 或聚合函数，则子句仅传递 WITH/RETURN 中的变量/别名。
    • 若 WITH/RETURN 子句中不包含 DISTINCT 或聚合函数，则前一句的变量可被 ORDER BY 和 WHERE 子句使用。
    • 若 WITH/RETURN 子句中已指定别名，则只有别名可在 ORDER BY 和 WHERE 子句中使用，原始名称不可见。

计算中间结果​

在 WITH 子句中可以定义计算表达式，以计算中间结果。
示例
查找所有通过“like”边连接的“person”点，计算每个人 10 年后的年龄，并返回这些人的名字以及他们喜欢的人 10 年后的平均年龄。命令如下：

MATCH (m:person)-[e:like]->(n:person)
WITH 
    m.age + 10 AS m_ten_years_later,
    n.age + 10 AS n_ten_years_later,
    m.name AS m_name,
    n.name AS n_name
RETURN m_name, avg(n_ten_years_later);

返回结果示例如下：

+--------+------------------------+
| m_name | AVG(n_ten_years_later) |
+========+========================+
| Mary   | 32                     |
+--------+------------------------+
| Xiaoli | 32                     |
+--------+------------------------+
| John1  | 37                     |
+--------+------------------------+

聚合中间结果​

在 WITH 子句中可以进行聚合计算，以获取中间结果。
示例
查找所有通过“like”边连接的“person”点，计算他们 10 年后的年龄以及他们喜欢的人 10 年后的平均年龄，并返回 2 个结果。命令如下：

MATCH (m:person)-[e:like]->(n:person)
WITH
    m.name as m_name,
    m.age + 10 as m_ten_years_later,
    avg(n.age + 10) as avg_n_ten_years_later
RETURN m_name, m_ten_years_later, avg_n_ten_years_later
LIMIT 2;

返回结果示例如下：

+--------+-------------------+-----------------------+
| m_name | m_ten_years_later | avg_n_ten_years_later |
+========+===================+=======================+
| Xiaoli | 40                | 32                    |
+--------+-------------------+-----------------------+
| John1  | 40                | 37                    |
+--------+-------------------+-----------------------+

去重中间结果​

在 WITH 子句中使用 DISTINCT 关键字来确保中间结果的唯一性，避免重复数据对后续查询结果造成干扰。
示例
查找所有通过“like”边连接的“person”点，并返回 2 个他们去重后的名字。命令如下：

MATCH (m:person)-[e:like]->(n:person)
WITH DISTINCT m.name AS m_name, n.name AS n_name
RETURN m_name, n_name
LIMIT 2;

返回结果示例如下：

+--------+--------+
| m_name | n_name |
+========+========+
| Mary   | Jerry  |
+--------+--------+
| John1  | Mary   |
+--------+--------+

返回中间结果​

使用 WITH 子句返回中间结果，以便在后续的查询中重复使用这些结果。
示例
查找所有通过“like”边连接的“person”点，并返回 2 个他们去重后的名字。命令如下：

MATCH (m:person)-[e:like]->(n:person)
WITH DISTINCT m.name AS m_name, n.name AS n_name
LIMIT 2
RETURN m_name, n_name;

返回结果示例如下：

+--------+--------+
| m_name | n_name |
+========+========+
| Xiaoli | Jerry  |
+--------+--------+
| John1  | Mary   |
+--------+--------+

中间结果排序​

使用 WITH 子句可以对中间结果进行排序。通过指定排序条件，您可以按照特定的顺序获取中间结果。
示例
查找所有通过“like”边连接的“person”点，并按照他们的名字进行排序，返回前 2 个去重后的名字。命令如下：

MATCH (n:person)-[e:like]->(m:person)
WITH DISTINCT m.name AS name
ORDER BY name
LIMIT 2
RETURN name;

返回结果示例如下：

+-------+
| name  |
+=======+
| John  |
+-------+
| Mary  |
+-------+

过滤聚合结果​

在 WITH 子句中支持使用 WHERE 条件子句来过滤掉某些不符合条件的聚合结果。
示例
查找所有通过“like”边连接的“person”点，计算每个人喜欢的其他人的数量，返回喜欢人数超过 2 的人的名字和喜欢人数，并按照名字和喜欢人数进行排序。命令如下：

MATCH (m:person)-[e:like]->(n:person)
WITH m.name AS m_name, count(n) AS count_n
WHERE count_n > 2
RETURN m_name, count_n
ORDER BY m_name, count_n;

返回结果示例如下：

+--------+---------+
| m_name | count_n |
+========+=========+
| Mary   | 3       |
+--------+---------+

WHERE​

WHERE 是 MATCH 语句的子句，为 MATCH 语句添加约束或过滤查询结果。

基本用法​

  • 逻辑运算

    可以在 WHERE 子句中使用布尔运算符 AND、OR、XOR 和 NOT 等。

    示例
    在当前图中找到所有名为“John”或者年龄小于 45 且名字既不是“Mary”，也不是“Zhangwu”而是名字为“Zhangsan”的点，并返回这些点的名称和年龄。命令如下：

     MATCH (n:person)  
     WHERE (n.name = 'John' OR (n.age < 45 AND n.name = 'Zhangsan')) AND NOT (n.name = 'Mary' OR n.name = 'Zhangwu')  
     RETURN n.name, n.age;

    返回结果示例如下：

    +--------------+-------+
    | n.name       | n.age |
    +==============+=======+
    | John         | 30    |
    +--------------+-------+
    | Zhangsan     | 40    |
    +--------------+-------+

  • 过滤点属性

    过滤点属性时，请在 WHERE 关键字后添加过滤条件。

    示例
    返回“person”点类型中所有“age > 18”的点数据的名称和年龄，命令如下：

    MATCH (n:person)
    WHERE n.age > 18
    RETURN n.name, n.age;

    返回结果示例如下：

    +--------------+-------+
    | n.name       | n.age |
    +==============+=======+
    | Zhangsan     | 40    |
    +--------------+-------+
    | Mary         | 22    |
    +--------------+-------+
    | John         | 30    |
    +--------------+-------+

字符串匹配​

STARTS WITH 和 ENDS WITH 可以匹配字符串的前缀和后缀。如要进行子字符串搜索，可以使用 CONTAINS 子句。
字符串匹配时，请注意区分字符串的大小写。

  • 使用 STARTS WITH 进行前缀字符串搜索

    在字符串的前缀部分执行区分大小写的匹配查询时，可以使用 STARTS WITH 来优化查询。

    示例
    在当前图中，返回 “person”点类型中，姓名是以 “J” 为首的人物的 id。命令如下：

    MATCH (a:person) 
    WHERE a.name STARTS WITH 'J' 
    RETURN a.id;

    返回结果示例如下：

    +------+
    | a.id |
    +======+
    | 1    |
    +------+

  • 使用 ENDS WITH 进行后缀字符串搜索

    在字符串的后缀部分执行区分大小写的匹配查询时，可以使用 ENDS WITH 来优化查询。

    示例
    在当前图中，返回 “person”点类型中，姓名是以 “y” 为结尾的人物的 id。命令如下：

    MATCH (a:person)  
    WHERE a.name ENDS WITH 'y'  
    RETURN a.id;

    返回结果示例如下：

    +------+
    | a.id |
    +======+
    | 2    |
    +------+

  • 使用 CONTAINS 进行子字符串搜索

    使用 CONTAINS 匹配字符串中是否包含某个字符串。

    示例
    在当前图中，返回 “person”点类型中，姓名中包含 “y” 的人物姓名。命令如下：

    MATCH (a:person) 
    WHERE a.name CONTAINS 'y' 
    RETURN a.name;

    返回结果示例如下：

    +---------+
    | a.name  |
    +=========+
    | Mary    |
    +---------+

IN 表达式过滤​

IN 运算符可用于检查列表中是否存在某个元素。
IN 左右两侧只能为同种数据类型，右边的列表也只能为同种数据类型的常量。

示例
在当前图中，查找“person”点类型中，名为“John”和“Mary”的点，并返回这些点的姓名和出生年份。命令如下：

MATCH (a:person)
WHERE a.name IN ['John','Mary']
RETURN a.name, a.age;

返回结果示例如下：

+----------+-------+
| a.name   | a.age |
+==========+=======+
| John     | 30    |
+----------+-------+
| Mary     | 22    |
+----------+-------+

is [not] null 表达式过滤​

一般用于判断属性中值是否为 null。

示例 1
在当前图中，查找“book”点类型中，name 属性值为空的点，并返回这些点的 id。命令如下：

MATCH (n:book)
WHERE n.name IS NULL 
RETURN n.id;

返回结果示例如下：

+---------+
| n.id    |
+=========+
| 2       |
+---------+

示例 2
在当前图中，查找“book”点类型中，name 属性值不为空的点，并返回这些点的 id。命令如下：

MATCH (n:book)
WHERE n.name IS NOT NULL 
RETURN n.id;

返回结果示例如下：

+---------+
| n.id    |
+=========+
| 1       |
+---------+

范围过滤（比较表达式）​

  • 简单范围过滤

    在特定范围内查找一定元素时，可以使用不等操作符“<”、“<=”、“>=”、“>”等。

    示例
    在当前图中，返回年龄大于或等于 18 的点，命令如下：

    MATCH (n)
    WHERE n.age >= 18
    RETURN n;

    返回结果示例如下：

    +----------------------------------------------------------------------------------------------+
    | n                                                                                            |
    +==============================================================================================+
    | vid: [_oid: 36990974643142658, label: person], properties: [36990974643142658, 3, Jerry, 22] |
    +----------------------------------------------------------------------------------------------+
    | vid: [_oid: 36990974643142657, label: person], properties: [36990974643142657, 2, Mary, 25]  |
    +----------------------------------------------------------------------------------------------+
    | vid: [_oid: 36990974638948352, label: person], properties: [36990974638948352, 1, John, 30]  |
    +----------------------------------------------------------------------------------------------+

  • 复合范围过滤

    使用多个不等式构建查询范围。

    示例
    在当前图中，返回年龄大于或等于 18 且小于 30 的点，命令如下：

    MATCH (n)
    WHERE n.age >= 18 and n.age < 30
    RETURN n;

    返回结果示例如下：

    +----------------------------------------------------------------------------------------------+
    | n                                                                                            |
    +==============================================================================================+
    | vid: [_oid: 36990974643142658, label: person], properties: [36990974643142658, 3, Jerry, 22] |
    +----------------------------------------------------------------------------------------------+
    | vid: [_oid: 36990974643142657, label: person], properties: [36990974643142657, 2, Mary, 25]  |
    +----------------------------------------------------------------------------------------------+

  • 其他

    在 WHERE 子句中使用计算表达式和函数。

    示例 1
    在当前图中，查找 id为“1”且age为“30”的“person”点类型中的点，或是 creation_date 为“2019”的“movie”点类型中的点，并返回这些点的名称和 id 属性。命令如下：

    MATCH (m:person|movie) 
    WHERE
    type(m) = "person" and m.id = 1 and m.age =30
    OR type(m) = "movie" and m.creation_date = 2019
    RETURN m.name,m.id;

    返回结果示例如下：

    +----------+------+
    | m.name   | m.id |
    +==========+======+
    | John     | 1    |
    +----------+------+
    | 电影2     | 2   |
    +----------+------+

    示例 2
    在当前图的“person”点类型中查找所有 id 属性大于“1”的点，并返回这些点的名称和 id 属性。命令如下：

    MATCH (m:person) 
    WHERE id(m) > 1
    RETURN m.name,m.id;

    返回结果示例如下：

    +--------------+------+
    | m.name       | m.id |
    +==============+======+
    | Zhangwu      | 4    |
    +--------------+------+
    | Zhangsan     | 3    |
    +--------------+------+
    | Mary         | 2    |
    +--------------+------+

路径表达式过滤​

路径表达式过滤用于检查给定路径是否在当前图中至少存在一次。

语法

WHERE [NOT] <path_pattern> [AND <expression>]...

详细说明

  • <path_pattern>：定义路径模式的表达式，通常采用 (a)-[f]-(b) 的格式。在 WHERE 子句中，只能存在一个路径模式表达式，且该表达式与其他 WHERE 子句的过滤表达式之间仅支持使用 AND 逻辑运算符。
  • <expression>：除 <path_pattern> 外的其他 WHERE 子句的过滤表达式。

示例 1
在当前图中，查询名为“Jhon”的人喜欢的人员，命令如下：

MATCH (b:person) 
WHERE (a:person{name:'John'})-[:like]->(b:person) 
RETURN b;

返回结果示例如下：

+---------------------------------------------------------------------------------------------+
| b                                                                                           |
+=============================================================================================+
| vid: [_oid: 36990974643142657, label: person], properties: [36990974643142657, 2, Mary, 25] |
+---------------------------------------------------------------------------------------------+

示例 2
在当前图中，查询名为"John"的人喜欢的人员中不喜欢"Jerry"的人员，命令如下：

MATCH (r:person{name:'John'})-[:like]->(a:person)   
WHERE  NOT (a:person)-[:like]->(b:person {name: "Jerry"})  
RETURN r.name, a.name;

返回结果示例如下：

+--------+--------+
| r.name | a.name |
+========+========+
| John   | Mary   |
+--------+--------+

ORDER BY​

ORDER BY 是在 RETURN 或 WITH 后的子句，它可以对输出结果进行排序并指定相应的排序方式。
目前 ORDER BY 只能对属性进行排序，暂不支持对属性的别名进行排序。

  • 根据属性排序

    ORDER BY 用于对输出结果进行排序，默认按照升序进行排序。

    示例