GQL 语法汇总¶

本文盘点了 GQL 中最常用的语句与命令，方便快速查阅。

Note

本文中的语句与命令主要基于电影数据集。为了简洁起见，在多数数据查询语句中省略了 USE movie 子句。

数据定义语句 ¶

Schema ¶

语句	描述
`CREATE SCHEMA IF NOT EXISTS /movie`	创建 Schema。
`DROP SCHEMA IF EXISTS /movie`	销毁 Schema。

图类型 ¶

语句	描述
''' CREATE GRAPH TYPE IF NOT EXISTS movie_type AS { NODE Actor (LABEL Person {id INT64, name STRING, birthDate DATE, PRIMARY KEY (id)}) , NODE Director (LABEL Person {id INT64, name STRING, birthDate DATE, PRIMARY KEY (id)}), NODE `User` (LABEL Person {id INT64 PRIMARY KEY}), NODE Movie (LABEL Movie {id INT64 PRIMARY KEY, name STRING}), NODE Genre (LABEL Genre {id INT64 PRIMARY KEY, name STRING}), EDGE Act (Actor)-[:Act]->(Movie), EDGE Direct (Director)-[:Direct]->(Movie), EDGE Watch (`User`)-[:Watch {rate FLOAT}]->(Movie), EDGE WithGenre (Movie)-[:WithGenre]->(Genre) } '''	创建每个点类型均使用一个属性作为主键的图类型。
''' CREATE GRAPH TYPE IF NOT EXISTS social_network AS { NODE Person (LABEL Person {id INT64 PRIMARY KEY, name STRING}), NODE Company (LABEL Company {id INT64 PRIMARY KEY, name STRING}), EDGE WorkAt (Person)-[:WorkAt {`from` DATE, to DATE, MULTIEDGE KEY ()}]->(Company), EDGE Friend (Person)-[:Friend {since DATE MULTIEDGE KEY }]->(Person) } '''	创建边类型均使用一个属性作为多边键的图类型。
`''' CREATE GRAPH TYPE IF NOT EXISTS social_network_2 AS { NODE Person (LABEL Person {id INT64 PRIMARY KEY, name STRING DEFAULT 'unknown', age INT32 DEFAULT 0}), NODE Company (LABEL Company {id INT64 PRIMARY KEY, name STRING}) } '''`	创建点类型的属性带有默认值的图类型。
''' CREATE GRAPH TYPE IF NOT EXISTS primary_key_multi_properties AS { NODE Person (LABEL Person {id INT64, name STRING, PRIMARY KEY (id, name)}), EDGE Know (Person)-[:`Like` {`from` DATE, to DATE, MULTIEDGE KEY (`from`,to)}]->(Person) } '''	创建主键和多边键分别由多个属性组成的图类型。
`CREATE GRAPH TYPE IF NOT EXISTS empty_graph_type AS {}`	创建空图类型。
`DROP GRAPH TYPE movie_type`	销毁图类型。
`''' ALTER GRAPH TYPE movie_type { ADD NODE TYPE Company (LABEL Company {id INT PRIMARY KEY, name STRING}), ADD EDGE TYPE Serve (Director)-[LABEL Serve{start_year INT, end_year INT}]->(Company) } '''`	添加点类型和边类型。
`''' ALTER GRAPH TYPE movie_type { DROP NODE TYPE Company, DROP EDGE TYPE Serve } '''`	删除点类型和边类型。
`''' ALTER GRAPH TYPE movie_type { RENAME NODE TYPE Actor TO Actor_renamed, RENAME EDGE TYPE Act TO Act_renamed } '''`	重命名点类型和边类型。
''' ALTER GRAPH TYPE movie_type { ALTER NODE TYPE `User` ADD LABELS Male&Above30, ALTER EDGE TYPE Watch ADD LABELS InCinema&AtHome } '''	为点类型和边类型添加标签。
''' ALTER GRAPH TYPE movie_type { ALTER NODE TYPE `User` DROP LABELS Male&Above30, ALTER EDGE TYPE Watch DROP LABELS InCinema&AtHome } '''	为点类型和边类型删除标签。
''' ALTER GRAPH TYPE movie_type { ALTER NODE TYPE `User` ADD PROPERTIES {email STRING, age INT64}, ALTER EDGE TYPE Watch ADD PROPERTIES {`count` INT64, platform STRING} } '''	为点类型和边类型添加属性。
''' ALTER GRAPH TYPE movie_type { ALTER NODE TYPE `User` DROP PROPERTIES {email, age}, ALTER EDGE TYPE Watch DROP PROPERTIES {`count`, platform} } '''	为点类型和边类型删除属性。
''' ALTER GRAPH TYPE movie_type { ALTER NODE TYPE Director RENAME PROPERTIES {birthDate TO birth, name TO lastName }, ALTER EDGE TYPE Watch RENAME PROPERTIES {`rate` TO rating} } '''	重命名点类型和边类型的属性。
`''' ALTER GRAPH TYPE movie_type { ALTER NODE TYPE Director MODIFY PROPERTIES {name STRING DEFAULT "Alex", birthDate DATE DEFAULT date("2016-09-20") }, ALTER EDGE TYPE Watch MODIFY PROPERTIES {rate FLOAT DEFAULT 4.5} } '''`	修改点类型和边类型的属性。
`RENAME GRAPH TYPE movie_type TO movie_type_renamed`	重命名图类型。

图 ¶

语句	描述
`CREATE GRAPH IF NOT EXISTS movie TYPED movie_type`	创建图。
`DROP GRAPH movie`	销毁图。
`RENAME GRAPH movie TO movie_renamed`	重命名图。

临时图 ¶

语句描述

CREATE TEMPORARY GRAPH IF NOT EXISTS #movie_temporary_graph AS COPY OF movie

基于现有图创建临时图。

CREATE TEMPORARY GRAPH IF NOT EXISTS #movie_temporary_graph_3 AS COPY OF GRAPH { USE movie MATCH (v) RETURN v }

基于子图创建临时图。

DROP TEMPORARY GRAPH IF EXISTS #movie_temporary_graph

销毁临时图。

索引 ¶

语句	描述
`USE movie CREATE NORMAL INDEX IF NOT EXISTS idx_actor_age ON NODE Actor ( birthDate ASC )`	在点类型上创建普通索引。
`USE movie CREATE NORMAL INDEX IF NOT EXISTS idx_watch_rating ON EDGE Watch ( rate DESC )`	在边类型上创建普通索引。
`''' USE ann_test_graph CREATE VECTOR INDEX ann_node_ivf_l2 ON NODE N1&N2::vec1 OPTIONS {DIM: 3, METRIC: L2, TYPE: IVF, NLIST: 10, TRAINSIZE: 4 } '''`	基于度量`L2`，在两个点类型上创建 IVF 向量索引。
`''' USE ann_test_graph CREATE VECTOR INDEX ann_edge_hnsw_ip ON EDGE E1::vec1 OPTIONS {DIM: 3, METRIC: IP, TYPE: HNSW, MAXDEGREE: 3, EFCONSTRUCTION: 6, CAPACITY: 500 '''`	基于度量`IP`，在一个边类型上创建 HNSW 向量索引。
`USE my_graph CREATE SPATIAL INDEX IF NOT EXISTS idx_gnode_g ON NODE Person(any_geo, s2_max_level = 30, s2_max_cells = 8)`	在点类型上基于地理空间类型的属性创建空间索引。
`USE my_graph CREATE SPATIAL INDEX IF NOT EXISTS idx_gedge_g ON EDGE GEdge(company_location, s2_max_level = 30, s2_max_cells = 8)`	在边类型上基于地理空间类型的属性创建空间索引。
`USE movie CREATE FULLTEXT INDEX IF NOT EXISTS ft_movie ON NODE Movie(name)`	在点类型上创建全文索引。
`USE movie DROP INDEX IF EXISTS idx_actor_age`	销毁点类型上的索引。
`USE movie DROP INDEX IF EXISTS idx_watch_rating`	销毁边类型上的索引。

TTL ¶

语句描述

USE movie CREATE TTL ON EDGE Watch(ttl_test) duration({days:1, hours:2, minutes:3, seconds:4, milliseconds:5, microseconds:6})

为边类型设置 TTL 时长。

USE movie DROP TTL ON EDGE Watch

删除边类型的 TTL 时长。

USE movie ALTER TTL ON EDGE Watch(ttl_test) duration({seconds:4, milliseconds:5, microseconds:6})

修改边类型的 TTL 时长。

过程 ¶

语句	描述
`CREATE PROCEDURE test(a INT, b STRING) RETURNS (x INT, y STRING) AS { RETURN a, b }`	创建一个 UDP。
`CREATE OR REPLACE PROCEDURE test1() RETURNS ret INT COMMENT 'test function 1' AS { RETURN 2 }`	创建或替换一个 UDP。
`DROP PROCEDURE IF EXISTS test(INT, STRING)`	销毁一个 UDP。
`ALTER PROCEDURE test(INT, STRING) COMMENT 'test_comment'`	修改一个 UDP 的描述。
`ALTER PROCEDURE test(INT, STRING) RENAME TO test44`	修改一个 UDP 的名称。

数据操作语句 ¶

INSERT ¶

语句	描述
`''' INSERT (@Director{id:11, name:"Alice", birthDate:date("1990-01-01")}), (TYPED Actor{id:22, name:"Bob", birthDate:date("1990-01-02")}) '''`	基于点类型插入点。若发现冲突，则语句执行失败并报告错误，不会插入任何图元素。
`INSERT OR REPLACE (@Director{id:11, name:"Alice2"})`	使用`INSERT OR REPLACE`时，如果图元素不存在，则插入该元素；如果已存在，则替换该元素。
`''' INSERT OR IGNORE (@Director{id:11, name:"Alice3", birthDate:date("1990-06-30")}), (@Director{id:12, name:"Carol", birthDate:date("1991-01-01")}) '''`	使用`INSERT OR IGNORE`时，如果图元素不存在，则插入该元素；如果已存在，则忽略本次写入，保留原有数据，不报错。本例中，已有的`id:11`点保持不变，尚不存在的`id:12`点正常插入。
`INSERT OR UPDATE (@Director{id:11, name:"Alice4", birthDate:date("1990-12-31")})`	使用`INSERT OR UPDATE`时，如果图元素不存在，则插入该元素；如果已存在，则更新该元素。
`''' INSERT (:Movie{id:10000,name:"movie"}), (IS Genre{id:11000,name:"genre"}) '''`	指定标签插入点。
`INSERT (@Movie{id:10002,name:NULL})`	插入带有`NULL`属性值的点。
`''' MATCH (n:Movie{id:10000}), (m@User{id:1}) INSERT (n)<-[:Watch{rate:5}]-(m) '''`	基于已存在的点插入边。
`INSERT (@Actor{id:200000,name:"actor", birthDate:date("1990-01-01")}) -[@Act]-> (@Movie{id:10003,name:"movie1"})`	同时插入新的点和边。
`''' MATCH (n@Movie{id:10000}) INSERT (n)<-[@Watch{rate:5}]-(@User{id:11002}) '''`	基于已存在的点插入一个点和一条边。
`''' MATCH (n@User{id:1}) INSERT (n)-[@Watch{rate:5}]->(m@Movie{id:10004,name:"movie2"}), (m)-[@WithGenre]->(@Genre{id:11003,name:"genre3"}) '''`	基于已存在的点插入多个点和边。
`''' TABLE t { actor_id, movie_id, movie_name } = ( 2, 20001, 'Movie1' ), ( 3, 20002, 'Movie2' ), ( 4, 20003, 'Movie3' ) USE movie FOR re IN t MATCH (a@Actor) WHERE a.id = re.actor_id INSERT (a)-[@Act]->(@Movie {id: re.movie_id, name: re.movie_name}) '''`	使用表变量批量插入点和边。

SET ¶

语句	描述
`MATCH (v@Actor{name:"Mark Hamill"}) SET v.name="Mark Hamill2"`	更新点的单个属性。
`MATCH (v@Actor{name:"Mark Hamill"}) SET v.name="Mark Hamill2", v.birthDate=date("1951-09-26")`	更新点的多个属性。
MATCH(v1@`User`{id:414})-[e@Watch]->(v2@Movie{name:"Star Trek: The Motion Picture"}) SET e.rate=4.0	更新边的单个属性。
`''' TABLE t { id, new_name } = ( 10001, 'Alice_renamed' ), ( 10002, 'Bob_renamed' ), ( 10003, 'Charlie_renamed' ) USE movie FOR re IN t MATCH (a@Actor) WHERE a.id = re.id SET a.name = re.new_name '''`	使用表变量批量更新点。

DELETE ¶

语句	描述
`MATCH (a@Actor{id:10000}) DELETE a`	删除点。
`''' MATCH (a@Actor{name:"Mila Parély"})-[e@Act]->(b@Movie{name:"Beauty and the Beast"}) DELETE e '''`	删除边。
`''' MATCH (a@Actor{name:"Nane Germon"})-[e@Act]->(b@Movie{name:"Beauty and the Beast"}) DELETE a, e '''`	删除点和边。
`''' MATCH (a@Actor{name:"Josette Day"}) DETACH DELETE a '''`	使用`DETACH DELETE`删除点和所有与之连接的边。
`MATCH (a) DETACH DELETE a`	使用`DETACH DELETE`删除所有点和边。
`''' TABLE t { id } = ( 10001 ), ( 10002 ), ( 10003 ) USE movie FOR re IN t MATCH (a@Actor) WHERE a.id = re.id DETACH DELETE a '''`	使用表变量批量删除点。

数据查询语句 ¶

MATCH ¶

语句	描述
`MATCH (v) RETURN v LIMIT 5`	用点变量匹配点。
`MATCH (v:Person) RETURN v LIMIT 5`	用标签匹配点。
`VALUE s = "Person" MATCH (v:s) WHERE v.id = 1 RETURN v.id, type(v)`	用变量标签匹配点。
`''' MATCH (v:Person) WHERE v.birthDate > date("1990-01-20") RETURN v LIMIT 5 '''`	用 WHERE 子句匹配点。
`MATCH (v {id:199}) RETURN v`	用点属性匹配点。
`MATCH (v@Actor) RETURN v LIMIT 5`	用单个点类型匹配点。
`VALUE s = "Director" MATCH (v@[s,"User"]) WHERE v.id = 1 RETURN v.id, type(v)`	用变量点类型匹配点。
`MATCH (v@[Actor,Director]) RETURN v LIMIT 5`	用多个点类型匹配点。
`MATCH ()-[e]->() RETURN e LIMIT 5`	用边变量匹配边。
`MATCH ()-[e:Act]->() RETURN e LIMIT 5`	用标签匹配边。
`VALUE et = "Direct" MATCH (src:Person)-[e:et]->(dst) WHERE src.id = 1 RETURN type(src), type(e), type(dst)`	用变量标签匹配边。
`MATCH ()-[e:Watch]->() WHERE e.rate > 4 RETURN e LIMIT 5`	用 WHERE 子句匹配边。
`MATCH ()-[e {rate: 4}]->() RETURN e LIMIT 5`	用边属性匹配边。
`MATCH ()-[e@Watch]->() RETURN e LIMIT 5`	用单个边类型匹配边。
`VALUE et = "Direct" MATCH (src:Person)-[e@et]->(dst) WHERE src.id = 1 RETURN type(src), type(e), type(dst)`	用变量边类型匹配边。
`MATCH ()-[e@[Direct,Watch]]->() RETURN e LIMIT 5`	用多个边类型匹配边。
`MATCH (a:Genre)<-[e:WithGenre]-(b:Movie) RETURN a LIMIT 3`	匹配入边。
`MATCH (a:Person)~[e:Act]~(b:Movie) RETURN e LIMIT 3`	匹配无向边。
`MATCH (a:Genre)<~[e:WithGenre]~(b:Movie) RETURN a,b LIMIT 3`	匹配无向边和入边。
`MATCH (a:Movie)<-[e]->(b) RETURN a,b,e LIMIT 3`	匹配出边和入边。
`MATCH (a:Movie)-[e]-(b) RETURN e,a,b LIMIT 3`	匹配任意方向的边。
`MATCH (a{id:1})-[e]->{1,2}(b:Genre) RETURN labels(a)`	用量化边模式匹配变长路径。
`MATCH (v1)-[e:Watch]->(v2) RETURN v1,v2 LIMIT 3`	用简单路径模式匹配。
`MATCH (v1)-[e1]->(v2)-[e2]->(v3:Genre) RETURN v3 LIMIT 5`	用复杂路径模式匹配。
`MATCH (a{id:1})(()-[e]->()){1,2}(b:Genre) RETURN labels(a)`	用量化路径模式匹配变长路径。
`MATCH p = (a{id:1})((n)-[e]->(m WHERE m.id > 1000)){1,2}(b:Genre) RETURN p`	匹配变长路径并返回路径。
`MATCH p = TRAIL (a@Actor)-[e:Act]->{1,3}(b:Movie) RETURN p LIMIT 3`	匹配不含重复边的路径。
`MATCH p = ACYCLIC (a@Actor)-[e:Act]->{1,3}(b:Movie) RETURN p LIMIT 3`	匹配不含重复点的路径。
`MATCH p = ALL (a@Actor{id:134060})-[e:Act]-{1,3}(b:Movie) RETURN p`	匹配所有满足条件的两个点之间的所有路径。
`MATCH p= ANY 2 (a@Actor{id:134060})-[e:Act]-{1,3}(b:Movie) RETURN p`	匹配所有满足条件的两个点之间的任意两条路径。
`MATCH p = ALL SHORTEST (a@Actor{id:134060})-[e:Act]-{1,3}(b:Movie) RETURN p`	匹配所有满足条件的两个点之间的所有最短路径。
`MATCH p= ANY SHORTEST (a@Actor{id:134060})-[e:Act]-{1,3}(b:Movie) RETURN p`	匹配所有满足条件的两个点之间的任意一条最短路径。
`MATCH p= SHORTEST 2 (a@Actor{id:134060})-[e:Act]-{1,3}(b:Movie) RETURN p`	匹配所有满足条件的两个点之间的任意两条最短路径。
`''' MATCH (a@Actor),(b@Movie) WHERE EXISTS {(a)-[:Act]->(b)} RETURN a.name, b.name LIMIT 3 '''`	匹配多种点模式。
`''' MATCH ()-[e1:Watch]->(b), (c)-[e2:WithGenre]->() WHERE b.id = c.id AND e1.rate >= 4 RETURN DISTINCT b.name, e1.rate LIMIT 5 '''`	匹配多种边模式。
`MATCH p1 = (a:Person{id:5498})-[e1:Act]->(b), p2= (b)-[e2:WithGenre]->(d) RETURN p1, p2`	匹配多种路径模式。
`OPTIONAL MATCH (v:NotExistLabel) RETURN v`	指定 OPTIONAL 关键字进行可选匹配。
`''' MATCH (b:Genre{id:87}) OPTIONAL MATCH p = (a:Movie{id:2000})-[e]->(b) RETURN b, p '''`	同时使用普通匹配和可选匹配。

FILTER ¶

语句描述

FOR i IN LIST[1, 2, 3] FILTER i>2 RETURN i

过滤 FOR 语句的结果。

'''
MATCH (v:Person) FILTER v.birthDate > date("1990-01-20") 
RETURN v ORDER BY v.birthDate LIMIT 3
'''

过滤 MATCH 语句的结果。

'''
CALL show_graphs() YIELD name 
FILTER name = "movie" RETURN *
'''

过滤 CALL 语句的结果。

LET ¶

语句	描述
`''' LET a = 1 + 2, b = 3 + 4 LET c = a + b RETURN a, b, c '''`	使用表达式定义变量。
`''' MATCH (v@Actor) WHERE v.id = 199 LET a = v.name, b = upper(a) RETURN b '''`	使用点属性定义变量。
`LET a = VALUE { USE movie MATCH (v@Actor) WHERE v.id = 199 RETURN v.name LIMIT 1 } RETURN a`	使用子查询定义变量。
`''' LET a = 199 RETURN a NEXT USE movie MATCH (v WHERE v.id = a) RETURN v '''`	在后续语句中使用变量。

FOR ¶

语句	描述
`LET l = list[1, 2, 3] FOR e IN l RETURN e`	展开一个列表。
`''' LET ll = list[list[1, 2, 3], list[4, 5, 6]] FOR l IN ll FOR e IN l RETURN e '''`	展开一个嵌套列表。
`''' LET l1 = list[1, 2, 3], l2 = list[4, 5, 6] FOR e1 IN l1 FOR e2 IN l2 RETURN e1, e2 '''`	展开两个列表。
`''' MATCH p = (v@Actor)-[]->(f@Movie{name:"Wilbur Wants to Kill Himself"})-[]->(g@Genre) LET sz = length(p), vid = v.id, l = range(1, length(p)) FOR e IN l RETURN DISTINCT sz, vid, l, e ORDER BY vid LIMIT 6 '''`	展开一个使用`range`函数生成的列表。
`''' LET l1 = list[1, 2, 3], l2 = trim(list[4, 5, 6, 7], 2) FOR e IN l1 \|\| l2 RETURN e '''`	展开两个由`\|\|`连接的列表。
`''' TABLE t { id, name, birthDate } = ( 10001, 'Alice', DATE '1990-01-01' ), ( 10002, 'Bob', DATE '1991-02-02' ), ( 10003, 'Charlie', DATE '1992-03-03' ) FOR e IN t RETURN e.id, e.name, e.birthDate '''`	展开表格。
`''' LET l=list[10, 20, 30] FOR e IN l WITH ORDINALITY idx RETURN e, idx '''`	展开列表并返回从 1 开始的索引。
`''' FOR i IN range(1, 10239) WITH OFFSET idx RETURN i, idx ORDER BY i ASC LIMIT 5 '''`	展开列表并返回从 0 开始的索引。

分页 ¶

语句	描述
`''' FOR i IN LIST[3, 2, 5, 4, 1] ORDER BY i ASC OFFSET 1 LIMIT 3 RETURN i '''`	使用`ORDER BY`、`OFFSET`和`LIMIT`进行分页。
`''' FOR i IN LIST[3, 2, 5, 4, 1] RETURN i OFFSET 1 LIMIT 3 '''`	在`RETURN`语句后执行分页。

RETURN ¶

语句	描述
`MATCH (v:Person WHERE v.id = 107224) RETURN *`	返回所有结果。
`MATCH (v:Person WHERE v.id = 107224) RETURN v.id, v.name, v.birthDate`	返回点的多个属性。
`MATCH (v:Person WHERE v.id = 107224) RETURN v.id AS id, v.name AS name, v.birthDate AS birthDate`	返回点的多个属性并指定别名。
`''' MATCH (v:Movie WHERE v.id = 172)<-[e:Watch]-() RETURN v.name AS movie, avg(e.rate) AS average_score GROUP BY movie '''`	返回聚合计算后的结果。
`MATCH (m:Movie)-[e:WithGenre]->(g:Genre) RETURN DISTINCT g.name AS Category LIMIT 5`	返回去重后的结果。

最终输出语句 ¶

语句描述

'''
MATCH (u@User)-[w:Watch]->(m:Movie)  
RETURN DISTINCT w.rate AS rate 
ORDER BY rate ASC OFFSET 2 Limit 4
'''

返回唯一结果并对结果进行分页。

MATCH (v) FINISH

结束 MATCH 语句且不返回数据。

'''
{MATCH (v:Person) 
CALL {MATCH (t) WHERE t.id = v.id FINISH} 
RETURN v.id AS a LIMIT 5}
'''

结束内联过程。

CALL ¶

语句	描述
`CALL show_graphs() RETURN *`	调用一个命名过程。
`''' OPTIONAL CALL show_graphs() YIELD name AS gn CALL version() YIELD version AS v RETURN gn, v '''`	使用`OPTIONAL`关键字调用一个命名过程。
`''' LET x = 10, y = 20 CALL { LET z = 30 RETURN x + y AS sum_xy, z * 2 AS double_z } RETURN * '''`	调用一个内联过程进行计算。
`''' LET a = 1, b = 2 OPTIONAL CALL { MATCH (v:Movie{id:1}) RETURN v.id AS id } RETURN * '''`	使用`OPTIONAL`关键字调用一个内联过程。

线性查询 ¶

语句	描述
`FOR i IN LIST[1, 2, 3] FILTER WHERE i>1 RETURN i OFFSET 1`	执行包含`FOR`、`FILTER`、`RETURN`和`OFFSET`语句的线性查询。
''' MATCH (v@`User`{id: 123})-[e:Watch]->(m:Movie) FILTER WHERE e.rate > 3 RETURN m.name AS movie, e.rate AS rate ORDER BY rate DESC '''	执行包含`MATCH`、`FILTER`、`RETURN`和`ORDER BY`语句的线性查询。

复合查询 ¶

语句描述

'''
FOR i IN LIST[4,1,2,3,3] RETURN i UNION 
FOR i IN LIST[11,2,2,22,33,33] RETURN i ORDER BY i OFFSET 1 LIMIT 2
'''

使用UNION操作符组合两个查询结果。

'''
MATCH (v)-[:Watch]->(@Movie{id: 473}) RETURN v  EXCEPT  
MATCH (v)-[:Watch]->(@Movie{id: 648}) RETURN v
'''

使用EXCEPT操作符组合两个查询结果。

'''   
MATCH (v)-[:Watch]->(@Movie{id: 473}) RETURN v  INTERSECT  
MATCH (v)-[:Watch]->(@Movie{id: 648}) RETURN v
'''

使用INTERSECT操作符组合两个查询结果。

导入导出语句¶

IMPORT ¶

语句	描述
`''' USE #movie_import IMPORT INTO GRAPH { GRAPH FROM NEBULA { FORMAT: "NEBULA", PATH: "nebula://root:<password>@<graph_host>:<graph_port>?graph=movie&schema=/default_schema" } } '''`	从悦数图数据库开发版导入完整图到临时图。
''' USE #movie_import_2 IMPORT INTO GRAPH { NODE (v@Actor{id:id, name:name}) FROM NEBULA { FORMAT: "NEBULA", PATH: "nebula://root:<password>@<graph_host>:<graph_port>?graph=movie&node_type=Actor" }, NODE (v@Movie{id:id, name:name}) FROM NEBULA { FORMAT: "NEBULA", PATH: "nebula://root:<password>@<graph_host>:<graph_port>?graph=movie&node_type=Movie" }, EDGE (id:id)-[e@Act{}]->(id:id) FROM NEBULA { FORMAT: "NEBULA", PATH: "nebula://root:<password>@<graph_host>:<graph_port>?graph=movie&edge_type=Act" } } '''	从悦数图数据库开发版导入特定点和边到临时图。
`''' USE #pagerank_graph IMPORT INTO GRAPH { NODE (v@Person {id: u_id, name: u_name}) FROM DATAFILE { PATH: "file:///tmp/test/pagerank_node.csv", FORMAT: "CSV", DELIMITER: ',' }, EDGE (id: src_id, name: src_name)-[e@Knows{}]->(id: dst_id, name: dst_name) FROM DATAFILE { PATH: "file:///tmp/test/pagerank_edge.csv", FORMAT: "CSV", DELIMITER: ',' } } OPTIONS {PRIMARY_KEY_AS_NODE_ID:false} '''`	直接从 CSV 文件导入数据到临时图。
`''' FILE node_file { id INT } = DATAFILE { PATH:"file:///tmp/test/wcc_node.csv", FORMAT:"CSV" } FILE edge_file { src INT, dst INT } = DATAFILE { PATH:"file:///tmp/test/wcc_edge.csv", FORMAT:"CSV" } USE #wcc_graph IMPORT INTO GRAPH { NODE (v@Person {id: id}) FROM node_file, EDGE (id: src)-[e@Knows{}]->(id: dst) FROM edge_file } '''`	使用文件变量从 CSV 文件导入数据到临时图。

EXPORT ¶

Statement Description

'''
USE #movie_temporary_graph { 
   FILE f { nodes STRING, edges STRING } = DATAFILE {PATH:"file:///tmp/test", FORMAT:"CSV", INCLUDE_HEADER: true} 
   MATCH (v@`User`)-[e]-(m@Movie) WHERE e.rate = 5.0 AND v.id > 605 
   PER PATH { 
       EXPORT v, e INTO f
   } 
}
'''

将点和边导出到 CSV 文件。

'''
USE #movie_temporary_graph { 
   FILE f { user_id INT, rate DOUBLE, movie_name STRING } = DATAFILE {PATH:"file:///tmp/test", FORMAT:"CSV", INCLUDE_HEADER: true} 
   MATCH (v@`User`)-[e]-(m@Movie) WHERE e.rate = 5.0 AND v.id > 605 
   PER PATH { 
       EXPORT v.id, e.rate, m.name INTO f
   } 
}
'''

将点和边的属性导出到 CSV 文件。

'''
USE #movie_temporary_graph { 
   NODE VALUE a MaxAgg<INT> = 280000
   NODE VALUE b MinAgg<INT> = 280000
   TABLE t TYPED TABLE { original_id INT, maxed_id INT, mined_id INT } 
   MATCH (v@Actor) WHERE v.id > 271940 
   PER NODE (v) { 
       SET v.@a += v.id 
       SET v.@b += v.id
   } 
   MATCH (v@Actor) WHERE v.id > 271940 
   PER NODE (v) { 
       EXPORT v.id, v.@a, v.@b INTO t
   } 
   FOR r IN t 
   RETURN r.original_id AS original_id, r.maxed_id AS maxed_id, r.mined_id AS mined_id 
}
'''

将点绑定的聚合值导出到表格中。

服务端编程语句 ¶

匹配计算语句 ¶

语句描述

'''
USE #match_compute_movie {
  /* ====== 声明 ====== */
  VALUE source_id = 1                          // 用于相似度计算的源用户 ID
  VALUE source_edges    SumAgg<INT64> = 0      // 源用户喜欢的电影
  VALUE topk_similarity TopKAgg<5, similarity DOUBLE DESC, id INT DESC>  // 前 5 位相似用户
  NODE VALUE target_edges SumAgg<INT64> = 0    // 每个用户喜欢的电影
  NODE VALUE intersection SumAgg<INT64> = 0    // 与源用户的共同喜欢的电影
  VALUE v_set ACTIVE_SET                       // 源用户喜欢的电影

  /* ====== 步骤 1：统计用户电影偏好 ====== */
  // 统计所有用户喜欢的电影
  MATCH (u@User)-[e:Watch]->(m:Movie)
  PER PATH {
    SET u.@target_edges += 1                  // 每个用户的电影计数递增
  }

  /* ====== 步骤 2：收集源用户数据 ====== */
  // 处理源用户的偏好
  MATCH (u@User)-[:Watch]->(m:Movie) 
  WHERE u.id = source_id  // 筛选源用户
  PER NODE (u) {
    SET @source_edges += u.@target_edges     // 存储源用户的电影计数
  }
  FINALLY { SET v_set = m }                      // 用源用户的电影填充活动集

  /* ====== 步骤 3：计算用户相似度 ====== */
  // 查找源用户与其他用户的共同喜欢电影
  MATCH (m:Movie)<-[:Watch]-(t@User)
  WHERE t.id <> source_id AND m IN v_set                  // 排除源用户，使用源用户的电影作为起点
  PER PATH {
    SET t.@intersection += 1                 // 统计共同电影
  }
  PER NODE (t) {
    // 计算源用户和其他用户的共同喜欢电影的并集
    VALUE union_size = t.@target_edges + @source_edges - t.@intersection

    IF union_size <> 0 THEN {
      VALUE similarity = CAST(t.@intersection AS DOUBLE) / union_size

      // 存储到前 k 聚合器
      SET @topk_similarity += RECORD{
        similarity: similarity, 
        id: t.id
      }
    }
  }

  /* ====== 步骤 4：返回结果 ====== */
  // 输出前 5 位相似用户
  FOR r IN @topk_similarity
    RETURN r.id AS user_id, 
          ROUND(r.similarity, 5) AS jaccard_similarity
}
'''

基于用户的电影偏好计算用户之间的 Jaccard 相似度。

变量操作语句 ¶

语句	描述
`''' USE #movie_temporary_graph { VALUE a INT = 1 VALUE b INT = 1 VALUE c INT = 1 SET a = a + 1 SET b = a + 2 SET c = b + 3 RETURN a, b, c } '''`	为原始值变量赋值。
`''' USE #movie_temporary_graph { VALUE a SumAgg<INT> = 0 VALUE b MaxAgg<DOUBLE> = 0.0 VALUE c OrAgg = false SET @a = 10 SET @b = 20.5 SET @c = true RETURN @a, @b, @c } '''`	为全局聚合值变量赋值。
`''' USE #movie_temporary_graph { NODE VALUE a ListAgg<INT> MATCH (v@Actor) WHERE v.id > 271940 PER NODE (v) { SET v.@a = LIST[v.id] LOG_INFO("ID_List: ", v.@a) } } '''`	为点绑定聚合值变量赋值。
`''' USE #movie_temporary_graph { VALUE active_set ACTIVE_SET VALUE list_id ListAgg<INT64> MATCH (a@Actor) WHERE a.id IN [31, 8252] PER NODE (a) { // 将匹配到的点的唯一标识符（UID）添加到列表中 SET @list_id += element_id(a) } // 将点的 UID 列表赋值给活动集变量 SET active_set = @list_id MATCH (a) WHERE a IN active_set PER NODE (a) { LOG_INFO("Actor Name: ", a.name) } } '''`	为活动集变量赋值。
`''' USE #movie_temporary_graph { VALUE global_avg AvgAgg<INT> SET @global_avg += 3 // Average: 3.0 (Total: 3, Count: 1) SET @global_avg += 7 // Average: 5.0 (Total: 10, Count: 2) SET @global_avg += 5 // Average: 5.0 (Total: 15, Count: 3) LOG_INFO("@global_avg: ",@global_avg) } '''`	将值聚合到全局聚合值变量中。
`''' USE #movie_temporary_graph { NODE VALUE node_avg AvgAgg<DOUBLE> MATCH (a@User WHERE a.id IN [1,3,4])-[w@Watch]->(b@Movie) PER PATH { // 累加用户对观看电影的评分并计算平均值 SET a.@node_avg += w.rate } PER NODE (a) { LOG_INFO("a.id: ",a.id, " a.@node_avg: ",a.@node_avg) } } '''`	将值聚合到点绑定聚合值变量中。
`''' USE #movie_temporary_graph { VALUE global_set_1 SetAgg<INT> SET @global_set_1 += 3 // set: {3} SET @global_set_1 += 7 // set: {3, 7} SET @global_set_1 += 3 // set: {3, 7} (duplicate ignored) SET @global_set_1 += 5 // set: {3, 7, 5} LOG_INFO("@global_set_1: ", @global_set_1) SET @global_set_1.clear() // set: {} LOG_INFO("@global_set_1: ", @global_set_1) } '''`	调用聚合值变量的成员函数。

控制流语句 ¶

语句	描述
`''' VALUE i INT = 0 WHILE i < 5 THEN { SET i = i + 1 } RETURN i '''`	使用`WHILE`循环重复执行一段语句块。
`''' VALUE i INT = 4 IF i < 3 THEN { SET i = i + 1 } ELSEIF i < 5 THEN { SET i = i + 2 } ELSE { SET i = i - 1 } RETURN i '''`	使用`IF-ELSEIF-ELSE`语句有条件地执行一段语句块。
`''' VALUE i INT = 0 WHILE i < 5 THEN { IF i = 3 THEN { BREAK } SET i = i + 1 } RETURN i '''`	使用`BREAK`语句退出循环。
`''' VALUE i INT = 0 WHILE i < 5 THEN { IF i < 3 THEN { SET i = i + 1 CONTINUE } ELSE { SET i = i + 1 } } RETURN i '''`	使用`CONTINUE`语句跳过当前迭代中剩余的语句并进入下一次迭代。

日志语句 ¶

语句	描述
`''' USE #movie_temporary_graph { VALUE w SumAgg<INT> = 0 MATCH ()-[e:Watch]-() PER PATH { SET @w += 1 } LOG_INFO("Finish Iteration") LOG_WARN("Final w: ", @w) RETURN @w AS watch_count } '''`	在查询执行时记录信息和告警消息。

语句块 ¶

语句描述

'''
MATCH (a@Actor{id:2}) RETURN a 
NEXT INSERT (a)-[r@Act{}]->(b@Movie{id:2})
'''

同时包含数据查询和数据操作语句的语句块。

'''
MATCH (actor@Actor)-[:Act]-(movie@Movie), 
(director@Director)-[:Direct]->(movie), (audience@`User`)-[:Watch]->(movie) 
RETURN DISTINCT audience, movie LIMIT 10 
NEXT LET valid=1 
RETURN sum(valid) AS audienceCount, movie GROUP BY movie
'''

包含多个数据查询语句的语句块。

子句¶

USE ¶

语句	描述
`''' USE movie MATCH (n:Person WHERE n.id = 107224) RETURN n.name '''`	在查询语句中声明一个工作图。
`''' USE movie MATCH (n:Movie WHERE n.id = 363) RETURN n.name AS movie_name UNION USE movie_2 MATCH (n:Movie WHERE n.id = 302) RETURN n.name AS movie_name '''`	在复合查询语句中声明多个工作图。
''' USE movie MATCH (n@`User` WHERE n.id = 599)-[]->(m:Movie) RETURN n.id AS audience, m.name AS movie, VALUE { USE movie MATCH (c:Movie)<-[e:Watch]-() WHERE c.name =m.name RETURN avg(e.rate) AS average_rate GROUP BY () } AS average_rate ORDER BY average_rate DESC LIMIT 10 '''	在嵌套查询语句中多次声明一个工作图。
`''' USE movie INSERT (:Movie{id:10000,name:"movie"}), (IS Genre{id:11000,name:"genre"}) '''`	在数据操作语句中声明工作图。

WHERE ¶

语句描述

'''
MATCH (v:Movie)<-[e:Watch]-(u@`User`)
WHERE e.rate > 3 
RETURN v.name AS movie, u.id AS audience, e.rate AS rate 
LIMIT 10
'''

使用一个条件过滤。

'''
MATCH (v:Movie)<-[e:Watch]-(u@`User`)
WHERE e.rate > 2 AND u.id = 100 
RETURN v.name AS movie, e.rate AS rate 
LIMIT 10
'''

使用多个条件过滤。

YIELD ¶

语句	描述
`''' CALL show_graphs() YIELD graph_type, name AS graph_name RETURN graph_type, graph_name '''`	选择并重命名列。

GROUP BY ¶

语句	描述
`''' FOR i IN LIST[1,2,3,4,2,2] RETURN i, i+1 AS i_1, i+2 AS i_2, count(*) GROUP BY i '''`	基于单列分组。
`''' MATCH (a@Actor WHERE a.birthDate=date("1971-01-01")) RETURN a.birthDate as birthday, count(*) AS num GROUP BY birthday '''`	基于带别名的列分组。
`''' MATCH (a@Actor) RETURN a.birthDate as birthday, a.name as name, count(*) AS num GROUP BY birthday, name LIMIT 10 '''`	基于多列分组。
`''' FOR i in LIST[1,2,3,4,2,2] RETURN count(*), sum(i) GROUP BY () '''`	将所有行作为一个组。

ORDER BY ¶

语句	描述
`''' MATCH (v@Actor WHERE v.birthDate > date("1990-01-15")) ORDER BY v.birthDate ASC RETURN v.name, v.birthDate LIMIT 10 '''`	使用`ASC`按升序排序。
`''' MATCH (v@Actor WHERE v.birthDate > date("1990-01-15")) ORDER BY v.birthDate DESC RETURN v.name, v.birthDate LIMIT 10 '''`	使用`DESC`按降序排序。
`''' MATCH (v@Actor) ORDER BY v.birthDate DESC NULLS FIRST RETURN DISTINCT v.birthDate AS birthday LIMIT 10 '''`	使用`NULLS FIRST`将`null`值排在最前面。当使用`DESC`时，默认使用`NULLS LAST`。
`''' MATCH (v@Actor WHERE v.birthDate >= date("1971-01-01")) ORDER BY v.birthDate ASC, v.id DESC RETURN v.name, v.birthDate, v.id LIMIT 10 '''`	多列排序。返回结果先根据第一个排序键排序。如果这个键的取值相同，返回结果将根据第二个排序键进一步排序。此过程会继续进行，直到所有的排序键都应用完毕。

LIMIT ¶

语句	描述
`MATCH (v:Person) LIMIT 3 RETURN v.id`	指定返回行数的上限。如果此上限大于或等于总行数，则返回所有行。否则，返回的行数不超过此上限。

OFFSET ¶

语句	描述
`MATCH (v@Actor WHERE v.birthDate > date("1990-01-15")) OFFSET 3 ORDER BY v.birthDate RETURN v.id`	返回结果中跳过一定数量的行。如果此数量大于总行数，则返回空结果。

SAMPLE ¶

语句描述

'''
USE movie 
MATCH (v1{id: 18})<-[e SAMPLE RIGHT FIRST_FETCH 2 ]-(v2)
RETURN labels(v1) AS anchor_labels,
       v1.id AS anchor_business_id,
       type(e) AS edge_type,
       count(*) AS sampled_count
'''

采样前 2 条边。

'''
USE movie
MATCH (v1{id: 18})<-[e SAMPLE RIGHT RANDOM 10% ]->(v2)
RETURN labels(v1) AS anchor_labels,
       v1.id AS anchor_business_id,
       type(e) AS edge_type,
       count(*) AS sampled_count
'''

随机采样 10% 的边。

'''
USE movie 
MATCH p = (v1@Genre{id: 18})<-[e SAMPLE RIGHT UNIQUE_NEIGHBOR 2]-{1,2}(v2)
RETURN length(p) AS hops,
       transform(nodes(p), n -> n.id) AS node_business_ids,
       transform(e, edge -> type(edge)) AS edge_types
'''

随机采样 2 条连接唯一邻点的边。

函数¶

数学函数 ¶

语句	描述
`RETURN abs(3) AS intAbs, abs(-3.3) AS floatAbs`	函数`abs()`返回一个数的绝对值。
`RETURN mod(7,3) AS m`	函数`mod()`返回除法运算的余数。
`RETURN floor(1.3)`	函数`floor()`返回小于或等于给定数的最大整数或小数（小数部分为`0`）。
`RETURN ceil(1.3) AS a` `RETURN ceiling(1.3) AS a`	函数`ceil()`或`ceiling()`返回大于或等于给定数的最小整数或小数（小数部分为`0`）。
`RETURN round(4.5) AS a, round(4.55, 1) AS b, round(45, -1) AS c`	函数`round()`基于给定的精度对一个数进行四舍五入。
`RETURN exp(1)`	函数`exp()`返回自然底数`e`的指定次幂。
`RETURN sign(-0.34)`	函数`sign()`接受一个浮点数或整数作为输入，根据输入数值的正负性返回一个特定的整数值。
`RETURN pi()`	函数`pi()`返回数学常数`pi`。
`RETURN sqrt(3)`	函数`sqrt()`返回一个数的平方根。
`RETURN power(3,4)`	函数`power()`返回一个数的幂次运算结果。
`RETURN isnan(cosh(28))`	函数`isnan()`用于检查给定的数是否是 NaN，是则返回`true`，否则返回`false`。
`RETURN rand() AS r`	函数`rand()`返回一个从`0`（含）到`1`（不含）范围内的随机浮点数。
`RETURN rand_geo(0.5) AS r` `RETURN rand_geometric(0.5) AS r`	`rand_geo()`是`rand_geometric()`的别名，两者功能相同，均返回几何分布中第一次成功之前的失败次数。
`RETURN log(7,7)`	函数`log()`返回一个数在特定底数下的对数值。
`RETURN log10(10)`	函数`log10()`返回一个数在以 10 为底数下的对数值。
`RETURN ln(271801.0/99990)`	函数`ln()`返回一个数在自然底数`e`下的对数值。
`RETURN sin(radians(90)) AS a`	函数`sin()`返回一个数的正弦值。
`RETURN cos(0) AS a`	函数`cos()`返回一个数的余弦值。
`RETURN tan(0.25 * radians(180)) AS a`	函数`tan()`返回一个数的正切值。
`RETURN cot(0.25 * radians(180)) AS a`	函数`cot()`返回一个数的余切值。
`RETURN sinh(radians(180)) AS a`	函数`sinh()`返回一个数的双曲正弦值。
`RETURN cosh(radians(180)) AS a`	函数`cosh()`返回一个数的双曲余弦值。
`RETURN tanh(1)`	函数`tanh()`返回一个数的双曲正切值。
`RETURN asin(radians(180))`	函数`asin()`返回一个数的反正弦值。
`RETURN acos(radians(0))`	函数`acos()`返回一个数的反余弦值。
`RETURN atan(radians(180))`	函数`atan()`返回一个数的反正切值。
`RETURN haversin(radians(0))`	函数`haversin()`返回一个数的半正矢值。

聚合函数 ¶

语句	描述
`''' MATCH (v1)-[e:Watch]->(v2 {id:199}) RETURN avg(e.rate) AS rate, v2.name AS movie GROUP BY movie '''`	函数`avg()`返回一组值的平均值。
`''' MATCH (v1)-[e:Watch]->(v2 {id:1}) ORDER BY e.rate ASC RETURN collect(e.rate) AS rate_collect, v2.name AS movie GROUP BY movie '''`	函数`collect()`将一组值聚合到一个列表中。函数`collect_list()`与函数`collect()`的作用是一致的。
`''' MATCH (v1)-[e:Watch]->(v2 {id:199}) RETURN count(e.rate) AS rate_count, v2.name AS movie GROUP BY movie '''`	函数`count()`返回一组值的数量。
`''' MATCH (v1)-[e:Watch]->(v2 {id:199}) RETURN max(e.rate) AS rate_max, v2.name AS movie GROUP BY movie '''`	函数`max()`返回一组值中的最大值。
`''' MATCH (v1)-[e:Watch]->(v2 {id:199}) RETURN min(e.rate) AS rate_min, v2.name AS movie GROUP BY movie '''`	函数`min()`返回一组值中的最小值。
`''' MATCH (v1)-[e:Watch]->(v2 {id:199}) RETURN sum(e.rate) AS rate_sum, v2.name AS movie GROUP BY movie '''`	函数`sum()`返回一组值的总和。
`''' MATCH (v1)-[e:Watch]->(v2 {id:199}) RETURN stddev_pop(e.rate) AS rate_stddev_pop, v2.name AS movie GROUP BY movie '''`	函数`stddev_pop()`返回一组值的总体标准偏差。
`''' MATCH (v1)-[e:Watch]->(v2 {id:199}) RETURN stddev_samp(e.rate) AS rate_stddev_samp, v2.name AS movie GROUP BY movie '''`	函数`stddev_samp()`返回一组值的样本标准偏差。
`''' MATCH (v1)-[e:Watch]->(v2 {id:199}) RETURN percentile_cont(e.rate, 0.5) AS r_percentile_cont, v2.name AS movie GROUP BY movie '''`	函数`percentile_cont()`接受一个 0 到 1 之间的百分位数，并返回在排序后的一组数据中对应该百分位数的位置的插值。
`''' MATCH (v1)-[e:Watch]->(v2 {id:199}) RETURN percentile_disc(e.rate, 0.5) AS r_percentile_disc, v2.name AS movie GROUP BY movie '''`	函数`percentile_disc()`接受一个 0 到 1 之间的百分位数，并返回在排序后的一组数据中最接近指定百分位数的实际值，而不是插值。
`MATCH (v@Actor) RETURN any_value(v) AS rr GROUP BY ()`	函数`any_value()`从一组值中返回任意一个值。

关于聚合表达式的更多信息，请参见聚合表达式。

字符串函数 ¶

语句	描述
`RETURN substring("abcdef", 1, 2) AS substr`	函数`substring()`返回字符串的子串。
`RETURN fmt('hello %s %s', 'my', 'world') AS a`	函数`fmt()`格式化指定的值并插入字符串的占位符中。
`RETURN left("abcdef", 3) AS substr`	函数`left()`返回字符串左侧指定长度的字符。
`RETURN right("abcdef", 3) AS substr`	函数`right()`返回字符串右侧指定长度的字符。
`RETURN upper("abCDef") AS a`	函数`upper()`将字符串中的所有字符转换为大写形式。
`RETURN lower("abCDef") AS a`	函数`lower()`将字符串中的所有字符转换为小写形式。
`RETURN trim('_' FROM "__abc__") AS a`	函数`trim()`返回去除左侧、右侧或两侧的指定字符串后的字符串。
`RETURN ltrim('aabbccdd', 'abc') AS a`	函数`ltrim()`返回去除左侧指定字符后的字符串。
`RETURN rtrim('aabbccdd', 'cd') AS a`	函数`rtrim()`返回去除右侧字符后的字符串。
`RETURN length('nebula graph') AS l`	函数`length()`返回字符串中的字符数。
`RETURN contains('nebula graph', 'nebula') AS c`	如果在字符串中找到指定的子字符串，函数`contains()`返回`true`。
`RETURN like("hello, world", "hello, wo%") AS v` `RETURN "hello, world" LIKE "hello, wo%" AS v`	如果字符串与指定模式匹配，函数`like()`返回`true`。
`RETURN regexp_like("hello\n, world", "HELLO.*", 'inx') AS v`	如果字符串匹配指定的正则表达式，函数`regexp_like()`返回`true`。
`RETURN split("a,b,c", ",") AS result`	函数`split()`使用指定的正则表达式作为分隔符，将字符串拆分成子字符串列表。
`RETURN md5("Hello World") AS hash`	函数`md5()`返回字符串的 MD5 哈希值。
`RETURN index_of("a数据库✅bcadabad书ad", "ad") AS res`	函数`index_of()`返回指定子字符串在目标字符串中第一次出现的起始位置。
`RETURN indexes_of("a数据库✅bcadabad书ad", "ad") AS res`	函数`indexes_of()`返回目标字符串中指定子字符串的所有起始位置列表。
`RETURN to_literal(-12) AS a`	函数`to_literal()`返回输入值的字符串表示形式。

时间函数 ¶

语句	描述
RETURN date('2022-01-02') AS `date`	函数`date()`将字符串解析为日期。
`RETURN local_datetime("2012-03-04T05:06:07.0890", "%Y-%m-%dT%H:%M:%S") AS localdatetime`	函数`local_datetime()`将字符串解析为本地日期时间。
`RETURN zoned_datetime("2012-03-04ZONE05:06:07.123 AT -02:00", "%Y-%m-%dZONE%H:%M:%S AT %Ez") AS zoneddatetime`	函数`zoned_datetime()`将字符串解析为带时区的日期时间，并返回带会话时区的日期时间。
`RETURN zoned_time("05:06:07.123 AT -02:00", "%H:%M:%S AT %Ez") AS zonedtime`	函数`zoned_time()`将字符串解析为带时区的时间，并返回带会话时区的时间。
`RETURN local_time("05:06:07.123", "%H:%M:%S") AS localtime`	函数`local_time()`将字符串解析为本地时间。
`RETURN CURRENT_TIME AS now_time`	`CURRENT_TIME`是关键字形式的零参函数，返回当前会话时区下的当前带时区的时间。
`RETURN CURRENT_TIMESTAMP AS now_ts`	`CURRENT_TIMESTAMP`是关键字形式的零参函数，返回当前会话时区下的当前带时区的日期时间。
`RETURN from_epoch(1333670400000*1000) AS dt`	函数`from_epoch()`将微秒级 Unix 时间戳转换为带时区的日期时间。
`RETURN to_epoch(zoned_datetime("2012-04-06T08:00:00.000+08")) AS epoch`	函数`to_epoch()`将带时区的日期时间转化为微秒级 Unix 时间戳。
`RETURN duration({days:1, hours:2, minutes:3, seconds:4, milliseconds:5, microseconds:6}) AS a`	函数`duration()`将指定的映射类型的值解析为时间段，并返回符合 ISO 8601 标准的格式为`P[nY][nM][nD]T[nH][nM][fS]`的字符串。
`RETURN duration_between(local_datetime("2024-05-31T06:07:08.0900"), local_datetime("2024-5-1T01:02:03.0400")) AS a`	函数`duration_between()`计算两个时间点之间的时间段，并以字符串形式返回时间段。

时间点和时间段之间的运算 ¶

语句	描述
`RETURN date("2024-05-30") + duration({years: 1000, months: 10}) AS a`	日期中添加时间段。
`RETURN date("2022-04-30") - duration({years: 2, months: 2}) AS a`	日期中减去时间段。
`RETURN local_datetime("2024-05-31T01:05:05.0500") - duration({hours: 3, minutes: 3, seconds: 3, microseconds: 30000}) AS a`	本地日期时间中减去时间段（小于一天）。
`RETURN local_datetime("2021-02-28T03:03:03.0000") - duration({days: 365}) AS a`	本地日期时间中减去时间段（大于一天）。

列表函数 ¶

语句	描述
''' MATCH p=(m@Movie)<-[e:Watch]-(n@`User`) LET a = nodes(p) RETURN length(a) AS len LIMIT 3 '''	函数`length()`返回列表中元素的数量。
`RETURN cardinality([2,2,3]) AS a`	函数`cardinality()`返回列表或记录中元素的数量。
''' MATCH p=(m@Movie)<-[e:Watch]-(n@`User`) LET a = nodes(p) RETURN head(a) LIMIT 3 '''	函数`head()`返回列表中的第一个元素。
''' MATCH p=(m@Movie)<-[e:Watch]-(n@`User`) LET a = nodes(p) RETURN tail(a) LIMIT 3 '''	函数`tail()`去除列表中的第一个元素。
''' MATCH p=(m@Movie)<-[e:Watch]-(n@`User`) LET a = nodes(p) RETURN back(a) LIMIT 3 '''	函数`back()`返回列表中的最后一个元素。
`RETURN range(-3,2) AS l`	函数`range()`返回一个从`start`值到`end`值的整数列表，其中，任意两个连续值之间的差值称为步长`step`，是一个常量。
`''' LET input = range(1,6) RETURN list_slice(input, 0, 3, 2) AS a '''`	函数`list_slice()`返回一个从`start`值到`end`值的列表切片。
`RETURN trim([1,2,3,4], 2) AS a`	函数`trim()`从列表末尾去除指定数量的元素后返回列表。
`RETURN zip([1,2,3],[4,5,6]) AS res`	函数`zip()`将两个列表中对应位置的元素配对成列表，然后将这些列表组合成一个新的列表。
`RETURN list_distinct([1,2,3,2,1,3,1,2,null]) AS res`	函数`list_distinct()`从输入列表中移除重复值，然后返回一个新的列表。
`RETURN list_except([1,2,3,4,5],[3,4,4,4,4,4,null]) AS res`	函数`list_except()`返回存在于列表 x 中但不存在于列表 y 中的元素组成的列表，并移除结果中的重复值。
`RETURN list_intersect([null,1,2,3],[2,3,null,4]) AS res`	函数`list_intersect()`返回列表 x 和列表 y 的交集元素组成的列表，并移除结果中的重复值。
`RETURN list_join([1,null,3], ",") AS res`	函数`list_join()`使用指定的分隔符连接输入列表中的元素，可以使用可选字符串替换列表中的 NULL 值。
`RETURN list_max([-5,-3,-1,0,1,3,5]) AS res`	函数`list_max()`返回输入列表中的最大值。如果列表中包含 NULL 值，则返回 NULL。
`RETURN list_min([-5,-3,-1,0,1,3,5]) AS res`	函数`list_min()`返回输入列表中的最小值。如果列表中包含 NULL 值，则返回 NULL。
`RETURN list_union([1,2,3],[3,4,5]) AS res`	函数`list_union()`返回列表 x 和列表 y 的并集元素组成的列表，并移除结果中的重复值。
`RETURN list_sort([3,1,null,2,null]) AS res`	函数`list_sort()`返回按升序排序后的列表。
`RETURN list_sum([1,2,3,4,5]) AS res`	函数`list_sum()`返回列表中所有非 NULL 元素的总和。如果列表中没有非 NULL 元素，则返回 0.0。
`RETURN remove_nulls([1,2,null,3,null,4]) AS res`	函数`remove_nulls()`从输入列表中移除所有 NULL 值。

表格函数 ¶

语句描述

'''
TABLE result_table TYPED TABLE {i INT, j INT}
FOR i IN range(1, 100)
FOR j IN range(1, 100)
EXPORT i, j INTO result_table
FOR t IN table_split(result_table)
RETURN sum(size(t))
'''

拆分表格并统计总行数。

'''
TABLE result_table TYPED TABLE {i INT, j INT}
FOR i IN range(1, 5)
FOR j IN range(1, 5)
EXPORT i, j INTO result_table
FOR t IN table_split(result_table, cast(10 as UINT))
RETURN size(t)
'''

按指定大小拆分表格。

'''
TABLE result_table TYPED TABLE {i INT, j INT}
FOR i IN range(1, 3)
FOR j IN range(1, 3)
EXPORT i, j INTO result_table
FOR t IN table_split(result_table)
FOR r IN t
RETURN r.i as i, r.j as j
'''

遍历子表格中的行。

集合函数 ¶

语句	描述
`RETURN set_append(SET{1, 2, 3}, 4)`	函数`set_append()`向现有集合中追加一个新元素。
`RETURN set_union(SET{1, 2, 3}, SET{3, 4, 5})`	函数`set_union()`返回两个集合的并集。
`RETURN set_intersect(SET{1, 2, 3}, SET{2, 3, 4})`	函数`set_intersect()`返回两个集合的交集。
`RETURN set_except(SET{1, 2, 3}, SET{2, 3, 4})`	函数`set_except()`返回两个集合的差集。
`RETURN set_sum(SET{1.0M, 2M})`	函数`set_sum()`返回集合中数值元素的总和。
`RETURN set_max(SET{1, 2, 3.0M})`	函数`set_max()`返回集合中的最大值。
`RETURN set_min(SET{1, 2, 3.0M})`	函数`set_min()`返回集合中的最小值。
`RETURN set_filter(SET{1, 2, 3, null}, x -> x IS NOT NULL)`	函数`set_filter()`返回满足谓词条件的新集合。
`RETURN set_remove(SET{1, 2, 3}, 1)`	函数`set_remove()`从集合中移除指定元素。
`RETURN remove_nulls(SET{1, null, 2})`	函数`remove_nulls()`从集合中移除 NULL 值。

映射函数 ¶

语句	描述
`RETURN map_append(MAP{1:"a"}, 2, "b")`	函数`map_append()`向已有的映射追加一个新的键值对。
`RETURN map_replace(MAP{1:"old", 2:"b"}, 1, "new")`	函数`map_replace()`替换映射中指定键对应的值。
`RETURN element_at(MAP{1:"a", 2:"b"}, 1)`	函数`element_at()`返回映射中指定键对应的值。
`RETURN map_keys(MAP{1:"a", 2:"b"})`	函数`map_keys()`返回映射中的所有键。
`RETURN map_values(MAP{1:"a", 2:"b"})`	函数`map_values()`返回映射中的所有值。
`RETURN map_union(MAP{1:"a"}, MAP{2:"b"})`	函数`map_union()`返回两个映射的并集。
`RETURN map_intersect(MAP{1:"a", 2:"b"}, MAP{1:"a", 3:"c"})`	函数`map_intersect()`返回两个映射的交集。
`RETURN map_except(MAP{1:"a", 2:"b"}, MAP{2:"b"})`	函数`map_except()`返回两个映射的差集。
`RETURN map_filter(MAP{1:"a", 2:null, 3:"c"}, (k, v) -> v IS NOT NULL)`	函数`map_filter()`返回满足谓词条件的新映射。
`RETURN map_remove(MAP{1:"a", 2:"b"}, 1)`	函数`map_remove()`移除映射中指定键对应的键值对。
`RETURN remove_nulls(MAP{1:"a", 2:"b", null:null})`	函数`remove_nulls()`从映射中移除键和值都为 NULL 的键值对。

图函数 ¶

语句	描述
`MATCH (v@Actor) RETURN element_id(v) LIMIT 5`	函数`element_id()`返回图中点的唯一标识符。
`MATCH ()-[e]->() RETURN multiedge_id(e) AS e LIMIT 5`	函数`multiedge_id()`基于平行边的多边键，返回用于区分特定平行边的唯一标识符。若不存在平行边，则返回`0`。
`''' MATCH (v1)-[e:Watch]->(v2 {id:1}) ORDER BY e.rate ASC RETURN left_node_id(collect(e)) AS src_id '''`	函数`left_node_id()`返回给定路径中指定边左侧点的唯一标识符。
`''' MATCH (v1)-[e:Watch]->(v2 {id:1}) ORDER BY e.rate ASC RETURN right_node_id(collect(e)) AS src_id '''`	函数`right_node_id()`返回给定路径中指定边右侧点的唯一标识符。
MATCH p=(m@Movie)<-[e:Watch]-(n@`User`) RETURN nodes(p) LIMIT 5	函数`nodes()`以列表的形式返回路径中的所有点。
MATCH p=(m@Movie)<-[e:Watch]-(n@`User`) RETURN edges(p) AS p LIMIT 5 MATCH p=(m@Movie)<-[e:Watch]-(n@`User`) RETURN relationships(p) AS p LIMIT 5	函数`edges()`或`relationships()`以列表的形式返回路径中的所有边。
''' MATCH p=(v@Genre)-[e2]-(m@Movie)-[e1]-(n@`User`) RETURN length(p) LIMIT 2 '''	函数`length()`返回路径的长度。
`MATCH p=(a:Movie{name:"Unpromised Land"})-[e:WithGenre]->{1,2}(b:Genre) RETURN cardinality(p) AS a`	函数`cardinality()`返回路径中的元素数量。
`''' MATCH (v)-[e]->(m) WHERE v.id = 133 RETURN labels(m) AS m_labels, labels(e) AS e_labels '''`	函数`labels()`返回图元素的所有标签。
''' MATCH (v@Director)->(w@Movie), (n@Actor)->(m@Movie), (u@`User`)->(p@Movie) WHERE NOT all_different(w, m, p) RETURN element_id(w)=element_id(m) AS wm, element_id(w)=element_id(p) AS wp, element_id(m)=element_id(p) AS mp LIMIT 1 '''	如果列表中的所有图元素彼此不同，函数`all_different()`返回`true`。否则，返回`false`。
''' MATCH (v@Director{id:488})->(w@Movie), (n@Actor{id:9640})->(m@Movie), (u@`User`)->(p@Movie) WHERE SAME(w, m, p) RETURN w.name AS movie_name, v.name AS director, n.name AS actor LIMIT 3 '''	如果列表中的所有图元素都相同，函数`same()`返回`true`。否则，返回`false`。
`''' MATCH ()-[e]->() RETURN DISTINCT type(e) AS edge_types '''`	函数`type()`返回图元素所属的元素类型的名称。

匿名函数 ¶

语句	描述
''' MATCH p=(m:Movie)<-[e:Watch]-(n@`User`) RETURN transform(nodes(p), x -> x.id) AS a LIMIT 5 '''	函数`transform()`接受一个列表和一个匿名表达式，并返回一个转换后的新列表。
`RETURN filter(LIST[1, 2, 3], x -> x > 2) AS a`	函数`filter()`接受一个列表和一个匿名表达式，并返回一个过滤后的新列表，其中包含原始列表中满足匿名表达式的元素。
`RETURN reduce(range(1,3), 100, (state, item) -> state + item) AS a`	函数`reduce()`将一个匿名表达式应用于列表中的每个元素，进行累积计算，并返回一个值。

关于匿名表达式的更多信息，请参见匿名表达式。

向量函数 ¶

语句	描述
`RETURN euclidean(VECTOR<3,FLOAT>([1,2,3]), VECTOR<3,FLOAT>([4,5,6])) AS euclidean_distance`	函数`euclidean()`返回两个向量之间的欧几里得距离。
`RETURN inner_product(VECTOR<3,FLOAT>([1,2,3]), VECTOR<3,FLOAT>([4,5,6])) AS ip`	函数`inner_product()`返回两个向量的内积。
`RETURN cosine(VECTOR<3,FLOAT>([1,2,3]), VECTOR<3,FLOAT>([4,5,6])) AS cos`	函数`cosine()`返回两个向量的余弦相似度。
`LET x = VECTOR<3, FLOAT>([1.1, -2.2, 3.3]) RETURN abs(x) AS x`	函数`abs()`返回一个向量，其中每个元素是给定向量中对应元素的绝对值。
`LET x = VECTOR<3, FLOAT>([1.1, -2.2, 3.3]) RETURN abs2(x) AS x`	函数`abs2()`返回一个向量，其中每个元素是给定向量中对应元素的平方。
`LET x = VECTOR<3, FLOAT>([1.21,4.84,10.89]) RETURN sqrt(x) AS x`	函数`sqrt()`返回一个向量，其中每个元素是给定向量中对应元素的平方根。
`LET x = VECTOR<3, FLOAT>([64.0, 256.0, 16.0]) RETURN ln(x) AS x`	函数`ln()`返回一个向量，其中每个元素都是给定向量中对应元素在自然底数`e`下的对数值。
`LET x = VECTOR<3, FLOAT>([64.0, 256.0, 16.0]) RETURN log10(x) AS x`	函数`log10()`返回一个向量，其中每个元素是给定向量中对应元素以10为底数的对数。
`LET x = VECTOR<3, FLOAT>([1, 2, 3]) RETURN exp(x) AS x`	函数`exp()`返回一个向量，其中每个元素都是给定向量中对应元素为幂，底数为`e`的指数值。
`LET x = VECTOR<3, FLOAT>([1, 2, 3]) RETURN normalize(x) AS x`	函数`normalize()`返回一个归一化后的向量，即将向量的长度调整为 1，归一化后的向量方向与原向量相同。
`LET x = VECTOR<3, FLOAT>([10.1, 20.2, 30.3]) RETURN accum(x) AS z`	函数`accum()`返回给定向量内所有元素的总和。
`LET x = VECTOR<3, FLOAT>([1.1, 2.2, 3.3]) RETURN mean(x) AS z`	函数`mean()`返回给定向量内所有元素的平均值。
`LET x = VECTOR<3, FLOAT>([1.1, 2.2, 3.3]) RETURN prod(x) AS z`	函数`prod()`返回给定向量内所有元素的乘积。
`LET x = VECTOR<3, FLOAT>([1.1, 2.2, 3.3]) RETURN norm(x) AS z`	函数`norm()`返回给定向量的欧几里得范数。
`LET x = VECTOR<3, FLOAT>([1.1, 2.2, 3.3]) RETURN squared_norm(x) AS z`	函数`squared_norm()`返回给定向量的平方欧几里得范数。

向量的算术运算 ¶

语句	描述
`LET x = VECTOR<3, FLOAT>([10.1, 20.2, 30.3]), y = VECTOR<3, FLOAT>([2.2, 3.3, 4.4]) RETURN x + y AS z`	向量间的加法。
`LET x = VECTOR<3, FLOAT>([10.1, 20.2, 30.3]), y = VECTOR<3, FLOAT>([2.0, 3.0, 4.0]) RETURN x - y AS z`	向量间的减法。
`LET x = VECTOR<3, FLOAT>([1.1, 2.2, 3.3]) RETURN x + 1 AS x`	向量与数字的加法。
`LET x = VECTOR<3, FLOAT>([10.1, 2.2, 3.3]) RETURN x - 1 AS x`	向量与数字的减法。
`LET x = VECTOR<3, FLOAT>([1.1, 2.2, 3.3]) RETURN x * 2 AS x`	向量与数字的乘法。
`LET x = VECTOR<3, FLOAT>([1.1, 2.2, 3.3]) RETURN x / 2 AS x`	向量与数字的除法。

地理空间函数 ¶

语句	描述
`RETURN ST_Point(37.7749, -12.4194) AS point1`	函数`ST_Point()`基于给定的经度和纬度返回一个 Point。
`RETURN ST_GeogFromText('POINT(37.7749 -12.4194)') AS point1`	函数`ST_GeogFromText() / ST_GeogFromWKT()`返回给定的 WKT 字符串对应的地理空间值。
`RETURN ST_ASText(ST_Point(37.7749, -12.4194)) AS string_point`	函数`ST_ASText()`返回一个地理空间值对应的 WKT 字符串。
`RETURN ST_Centroid(ST_GeogFromText('POINT(37.7749 -12.4194)')) AS centroid1`	函数`ST_Centroid()`返回一个地理空间值的中心点，即形状的几何中心。
`RETURN ST_ISValid(ST_Point(37.7749, -124.4194)) AS isValidPoint`	函数`ST_ISValid()`返回`true`，如果给定的地理空间值有效，否则返回`false`。
`RETURN ST_Intersects(ST_GeogFromText('POINT(0 1)'), ST_GeogFromText('POLYGON((0 1, 1 2, 2 3, 0 1))')) AS v`	函数`ST_Intersects()`返回`true`，如果给定的两个地理空间值相交（共享至少一个公共点），否则返回`false`。
`RETURN ST_IntersectionPoints(ST_GeogFromText("LineString(0 1,1 0)"),ST_GeogFromText("LineString(0 0,1 1)")) AS v`	函数`ST_IntersectionPoints()`返回两个地理空间值边界交叉点的列表。
`RETURN ST_Covers(ST_GeogFromText('POLYGON((0 1, 1 2, 3 0, 0 1))'), ST_GeogFromText('POINT(1 1)')) AS v`	给定两个地理空间值`g1`和`g2`。如果`g1`完全包含`g2`（即`g2`的所有点位于`g1`的内部或边界上），函数`ST_Covers(g1,g2)`返回`true`，否则返回`false`。
`RETURN ST_CoveredBy(ST_GeogFromText('POLYGON((0 1, 1 2, 3 0, 0 1))'), ST_GeogFromText('POINT(1 1)')) AS v`	给定两个地理空间值`g1`和`g2`。如果`g2`完全包含`g1`（即`g1`的所有点位于`g2`的内部或边界上），函数`ST_CoveredBy(g1,g2)`返回`true`，否则返回`false`。
`RETURN ST_DWithin(ST_GeogFromText("Point(0 0)"),ST_GeogFromText("Point(10 10)"),20000000000) AS v`	函数`ST_DWithin()`返回`true`，如果地理空间值`g1`中至少一个点与`g2`中至少一个点之间的距离小于或等于给定的距离阈值，否则返回`false`。
`RETURN ST_Distance(ST_GeogFromText("Point(0 0)"),ST_GeogFromText("Point(10 10)")) AS distance`	函数`ST_Distance()`返回两个地理空间值之间的最短距离（以米为单位）。
`RETURN S2_CellIdFromPoint(ST_GeogFromText("Point(1 1)")) AS v`	函数`S2_CellIdFromPoint()`返回覆盖一个 Point 的 S2 单元 ID。
`RETURN S2_CoveringCellIds(ST_GeogFromText("POLYGON((0 1, 1 2, 2 3, 0 1))")) AS v`	函数`S2_CoveringCellIds()`返回覆盖一个地理空间值的 S2 单元 ID 列表。

全文索引函数 ¶

语句	描述
`''' USE movie MATCH (v@Movie) WHERE ftscore(v.name, 'Uncle') > 0 RETURN v.name AS movie_name '''`	函数`ftscore()`返回存储在索引属性中的`STRING`值与给定查询字符串之间的相关性得分。

系统信息函数 ¶

语句	描述
`RETURN typeof(1) AS a`	函数`typeof()`返回输入值的类型，支持普通值类型、图元素引用类型和表类型。

值表达式¶

聚合表达式 ¶

语句	描述
`FOR i in LIST [1,2,3,3,4,4] RETURN count(DISTINCT i), sum(ALL i) GROUP BY ()`	计算不同值的数量和所有值的总和。
`MATCH ()-[e:Watch]->(v@Movie {id: 473}) RETURN collect(e.rate), avg(e.rate) GROUP BY ()`	返回一部电影的所有评分和平均评分。

关于聚合函数的更多信息，请参见聚合函数。

变量表达式 ¶

语句	描述
`LET a = 1, b = 2 RETURN a + b AS c`	定义变量并返回变量。
MATCH (a@`User`)-[e:Watch]->(b) RETURN a, e, b LIMIT 3	返回点变量和边变量。

条件表达式 ¶

语句	描述
`''' FOR a IN LIST[1,2,3,4,5,6,7,8,9,10] RETURN CASE WHEN a<4 THEN false WHEN a>5 THEN true END AS case_value '''`	基于条件返回不同的值。
`RETURN coalesce(NULL, 1, 2, 3, 4, 5) AS a`	使用`coalesce`函数返回第一个非`NULL`值。

常量表达式 ¶

语句描述

'''
RETURN 1 AS num1, 
3.4 AS num2, 
true AS bool1, 
"str literal" AS str1, 
DATE '2024-01-01' AS temporal1, 
DURATION ({years:1, months:2}) AS duration1, 
LIST [2,3,4] AS list1, 
{a:1, b:true, c:"str literal"} AS record1, 
NULL AS null1
'''

返回不同类型的常量值。

构造表达式 ¶

语句	描述
`RETURN LIST [1,2,3,4,5] AS l`	构造一个列表。
`RETURN RECORD {a:1, b:true, c:"str literal"} AS record1`	构造一个记录。

函数表达式 ¶

语句	描述
`RETURN substring("abc", 1, 1) AS f2`	调用一个有多个入参的函数。
`RETURN abs(-32.4) AS f1, substring("abc", 1, 1) AS f2`	调用多个函数。
`RETURN date() AS currentDate`	调用一个无入参的函数。

完整的函数列表，请参见函数。

逻辑表达式 ¶

语句	描述
`RETURN true OR false AS a`	返回逻辑或的结果。
`RETURN 1=2 AND 1=1 AS b`	返回逻辑与的结果。

属性表达式 ¶

语句	描述
`LET r = RECORD {a:1, b:true, c:"str literal"} RETURN r.c`	获取记录的字段。
MATCH (v@`User`)-[e:Watch]->() RETURN v.id, e.rate LIMIT 3	获取点和边的属性。

子查询表达式 ¶

语句	描述
`RETURN VALUE {FOR i IN LIST [1,2,3,4] RETURN i ORDER BY i LIMIT 1} AS sub`	从子查询中返回单个值。
`RETURN EXISTS {USE movie MATCH (v@Actor) RETURN v} AS sub`	从子查询中返回布尔值。

类型转换表达式 ¶

语句	描述
`RETURN CAST (DATE "2012-03-04" AS STRING) AS a`	将时间值转换为字符串。
`RETURN CAST (NULL AS INT16) AS a`	将`null`值转换为`INT16`类型的整数。
`RETURN CAST ([1.4, 1.5] AS LIST<INT8>) AS a`	将列表中小数转换为`INT8`类型的整数。
`RETURN CAST ({p: LIST [1.4, 1.5]} AS RECORD {p LIST<INT32>}) AS a`	将由一列小数构成的记录转换为由一列`INT32`类型的整数构成的记录。

匿名表达式 ¶

语句	描述
`RETURN transform(LIST[1, 2, 3], x -> 2 * x + 1) AS a`	将匿名函数`transform()`应用于一个列表。
`RETURN filter(LIST[1, 2, 3, 4, 5], x -> x % 2 = 0) AS a`	将匿名函数`filter()`应用于一个列表。
`RETURN reduce(LIST[1, 2, 3, 4, 5], 0, (acc, x) -> acc + x) AS a`	将匿名函数`reduce()`应用于一个列表。

关于匿名函数的更多信息，请参见匿名函数。

谓词¶

比较谓词 ¶

语句	描述
`LET l1= 'w55', l2='e34' RETURN l1 > l2 AS a`	比较字符串。字符串的比较基于 UCA 算法。
`RETURN (2>1) > (1>2) AS a, (2>1) <= (3>2) AS b`	比较布尔值。布尔值的比较基于`true`大于`false`的规则。
`''' RETURN null > (1>2) AS a, null >= 1 AS b, null < "String" AS c, null = LIST[1,2,3] AS d, null < local_datetime("2012-03-04T05:06:07.0890") AS e, null <> RECORD{} AS f '''`	比较`null`值。任何与`null`值的比较都返回`null`。
`LET l1= LIST[1,2,3], l2=LIST[1,2,3.5] RETURN l1 = l2 AS a`	比较两个列表。如果两个列表具有相同顺序的相同元素，则比较返回`true`，否则返回`false`。
`LET t1=local_datetime("2012-03-04T05:06:07.0890"), t2=local_datetime("2012-03-02T05:06:07.0") RETURN t1 > t2 AS a`	比较时间点值。时间点值的比较基于时间顺序。
`LET d1=duration({years:1, months:2}), d2=duration({years:1, months:3}) RETURN d1 < d2 AS a`	比较时间段值。时间段值的比较基于时间段长短。
`LET r1 = {a:1, b:true, c:"str"}, r2 = {a:1, c:"str", b:true} RETURN r1 = r2 AS a`	比较两个记录的字段名和值是否相同。如果两个记录具有相同字段和相同字段值，则比较返回`true`，否则返回`false`。
`''' MATCH (v1@Director)->(m1), (v2@Director)->(m2) WHERE m1.name = "Saw III" AND m2.name = "Saw IV" RETURN v1 = v2 AS a '''`	比较两个图元素是否相同。如果两个图元素相同，则比较返回`true`，否则返回`false`。
''' MATCH p1 = (m1@Movie)<-(u1@`User`), p2 = (m2@Movie)<-(u2@`User`) WHERE u1.id = u2.id RETURN p1 = p2 AS a, m1.name, m2.name LIMIT 5 '''	比较两个路径是否相同。如果两个路径相同，则比较返回`true`，否则返回`false`。

EXISTS 谓词 ¶

语句	描述
`RETURN EXISTS { (v WHERE v.id= 123 ) } AS a`	检查点模式是否存在。
`RETURN EXISTS ( ()-[e]->() WHERE e.id= 13423 ) AS b`	检查边模式是否存在。
RETURN EXISTS { MATCH (a@`User`)-[e:Watch]->(b) WHERE a.id = 123 RETURN e } AS c	检查子图的匹配是否成功。

NULL 谓词 ¶

语句	描述
`LET a= null>10 RETURN a IS NULL AS a_is_null`	检查值是否为`null`。

标签谓词 ¶

语句描述

'''
MATCH (v)-[e]->() 
WHERE v IS LABELED Person 
RETURN DISTINCT v.name AS name 
LIMIT 5
'''

使用IS LABELED来检查图元素是否具有特定的标签。

'''
MATCH (v)-[e]->() 
WHERE e:Act 
RETURN DISTINCT e AS `edge` 
LIMIT 5
'''

使用冒号:来检查图元素是否具有特定的标签。

'''
MATCH (v)-[e]->() 
WHERE v IS NOT LABELED Person 
RETURN DISTINCT v.name 
LIMIT 5
'''

使用IS NOT LABELED检查图元素是否不具备特定的标签。

ALL_DIFFERENT 谓词 ¶

语句描述

'''
MATCH (v@Director)->(w@Movie), (n@Actor)->(m@Movie), (u@`User`)->(p@Movie) 
WHERE NOT ALL_DIFFERENT(w, m, p) 
RETURN element_id(w)=element_id(m) AS wm, element_id(w)=element_id(p) AS wp, element_id(m)=element_id(p) AS mp 
LIMIT 1
'''

检查图元素列表中的所有图元素是否两两不同。

SAME 谓词 ¶

语句	描述
''' MATCH (v@Director{id:488})->(w@Movie), (n@Actor{id:9640})->(m@Movie), (u@`User`)->(p@Movie) WHERE SAME(w, m, p) RETURN w.name AS movie_name, v.name AS director, n.name AS actor LIMIT 3 '''	检查图元素列表中的所有图元素是否相同。

性能调优 ¶

语句	描述
`''' EXPLAIN format = "default" MATCH (a:Person)-[e]->(b@Movie) LIMIT 1 RETURN b '''`	指定选项`format = "default"`查看优化后的执行计划。
`''' EXPLAIN raw MATCH (a:Person)-[e]->(b@Movie) LIMIT 1 RETURN b '''`	指定`raw`查看未优化的逻辑计划。
`''' EXPLAIN format = "verbose" MATCH (a:Person)-[e]->(b@Movie) LIMIT 1 RETURN b '''`	指定选项`format = "verbose"`查看详细的优化执行计划。
`''' EXPLAIN raw format = "verbose" MATCH (a:Person)-[e]->(b@Movie) LIMIT 1 RETURN b '''`	指定`raw`和`format = "verbose"`查看未优化的详细逻辑计划。
`''' PROFILE format="default" MATCH (a:Person)-[e]->(b@Movie) LIMIT 1 RETURN b '''`	执行查询并指定选项`format = "default"`查看优化后的执行计划。
`''' PROFILE format= "verbose" MATCH (a:Person)-[e]->(b@Movie) LIMIT 1 RETURN b '''`	执行查询并指定选项`format = "verbose"`查看详细的优化后的执行计划。

数据库管理 ¶

SHOW¶

命令	描述
`SHOW ALL ROLES`	显示当前服务组中的所有角色。
`SHOW ALL INDEXES`	显示当前会话的 Schema 下的所有索引的信息。
`SHOW ALL WARNINGS`	显示当前服务组中执行 GQL 语句产生的所有警告。
`SHOW CONFIGS`	显示当前会话中 Graph 服务的所有运行时配置项。
`SHOW CONFIGS "192.168.8.129:9779"`	显示当前会话中指定 Storage 服务的所有运行时配置项。
`SHOW CONFIG session_idle_timeout_secs`	显示当前会话中连接的 Graph 服务的指定运行时配置项。
`SHOW CONFIG "192.168.8.129:9779" audit_log_enabled`	显示指定 Storage 服务的指定运行时的配置项。
`SHOW CREATE GRAPH movie`	显示创建特定图的语句。
`SHOW CREATE GRAPH TYPE movie_type`	显示创建特定图类型的语句。
`SHOW CREATE PROCEDURE test_proc`	显示创建特定过程的语句。
`SHOW CURRENT_SCHEMA`	显示当前会话的主 Schema。
`SHOW CURRENT_SESSION`	显示当前用户创建的会话。
`SHOW CURRENT_SESSION TIME FORMATS`	显示当前会话中的日期和时间格式。
`SHOW CURRENT_GRAPH`	显示当前会话中的图或临时图的信息。
`SHOW CURRENT_USER`	显示当前会话登录用户的信息。
`SHOW GLOBAL CONFIGS`	返回使用`GLOBAL SET`或`GLOBAL RESET`为服务组内所有 Graph 服务设置的配置项。
`SHOW GLOBAL CONFIGS STORAGE`	返回使用`GLOBAL SET`或`GLOBAL RESET`为服务组内所有 Storage 服务设置的配置项。
`SHOW FUNCTIONS`	显示当前 Catalog 中的所有函数。
SHOW FUNCTION `mod`	仅显示当前 Catalog 中与指定函数名匹配的函数。
`SHOW GRAPHS`	显示当前 Catalog 中的所有图。
`SHOW GRAPH TYPES`	显示当前 Catalog 中的所有图类型。
`Use movie SHOW INDEXES`	显示当前 Catalog 指定图中创建的索引。
`SHOW JOBS`	显示当前服务组中所有运行中的作业。
`SHOW JOB 10`	显示当前服务组中特定作业。
`SHOW LEADERS`	显示当前服务组中所有 Storage 服务上的 Leader 副本信息。
`SHOW OBJECTS`	显示当前用户拥有的资源对象信息。
`SHOW OBJECTS FOR USER user1`	显示特定用户拥有的资源对象信息。
`SHOW PARAMETERS`	显示当前会话中所有用户自定义的参数。
`SHOW PARTITIONS`	显示当前服务组中 Storage 服务上所有的分片。
`SHOW PEERS`	显示当前服务组中 Storage 服务上所有分片的副本的详细信息。
`SHOW PEERS LEADER`	显示当前服务组中 Storage 服务上所有 Leader 副本的详细信息。
`SHOW PLUGINS`	显示当前 Catalog 中加载的所有插件。
`SHOW PLUGIN log_rotate`	显示当前 Catalog 中加载的特定插件信息。
`SHOW PRIVILEGES FOR USER user1`	显示授予特定用户的权限。
`SHOW PRIVILEGES FOR ROLE role1`	显示包含在特定角色中的权限。
`SHOW PROCEDURES`	显示当前 Catalog 中的所有命名过程。
`SHOW PROCEDURE show_queries`	显示当前 Catalog 中特定命名过程的信息。
`SHOW QUERIES`	显示当前服务组中 Graph 服务上所有运行中的查询。
`SHOW ROLES`	显示授予当前用户的角色。
`SHOW ROLES FOR USER user1`	显示授予特定用户的角色。
`SHOW SCHEMAS`	显示当前 Catalog 中的所有 Schema。
`SHOW SERVICES`	显示当前服务组中的所有服务。
`SHOW SERVICE CONFIGS`	显示为当前连接的 Graph 服务设置的配置项。
`SHOW SERVICE CONFIGS "192.168.8.129:9779"`	显示为指定 Storage 服务设置的配置项。
`SHOW SERVICE GROUP`	显示当前所连接的 Graph 服务所属的服务组的相关信息。
`SHOW SERVICES META`	显示当前服务组中 Meta 服务的信息。
`SHOW SESSIONS`	显示当前服务组中 Graph 服务上所有活跃的会话。
`SHOW SESSION CONFIGS`	显示使用`SESSION SET`或者`SESSION RESET`为当前连接的会话设置的所有配置项。
`USE movie SHOW STATS`	显示指定图的统计信息。
`USE movie SHOW TTLS`	显示特定图的 TTL 设置信息。
`SHOW VERSION`	显示当前安装的悦数图数据库开发版的版本信息。
`SHOW VERSION VERBOSE`	显示当前安装的悦数图数据库开发版详细的版本信息。
`SHOW USERS`	显示受邀加入当前服务组的所有用户。
`SHOW WARNINGS`	显示当前会话中上一条 GQL 语句产生的警告。

DESCRIBE¶

命令	描述
`DESCRIBE GRAPH movie`	查看图信息
`DESCRIBE GRAPH TYPE movie_type`	查看图类型信息。
`DESCRIBE NODE TYPE Actor OF movie_type`	查看点类型信息。
`DESCRIBE EDGE TYPE Watch OF movie_type`	查看边类型信息。

KILL¶

命令	描述
`KILL QUERY "20231128_06303700005z3tjb"`	终止某个查询。
`KILL SESSION 1228399980662537`	终止某个会话。

CLEAR¶

命令	描述
`CLEAR WARNINGS`	清除当前服务组中执行 GQL 语句产生的特定警告。
`CLEAR ALL WARNINGS`	清除当前服务组中执行 GQL 语句产生的所有警告。

会话 ¶

命令	描述
`SESSION SET timezone = "America/New_York"`	设置会话配置项。
`SESSION SET VALUE $i_1 = 10, $i_2 = 20`	为当前会话设置参数。
`SESSION UNSET timezone`	取消当前会话中的时区设置。
`SESSION RESET timezone`	重置会话配置项。
`SESSION RESET $i_1, $i_2`	删除指定会话参数。
`SESSION CLOSE`	关闭当前会话。
`SHOW CURRENT_SESSION`	显示当前用户创建的会话。
`SHOW CURRENT_SESSION TIME FORMATS`	显示当前会话中的日期和时间格式。
`SHOW SESSIONS`	显示当前服务组中 Graph 服务上所有活跃的会话。