Source: https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/overview/cheat-sheet/
Documentation version: v5.3.2

# GQL 语法汇总

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

Note

本文中的语句与命令主要基于[电影数据集](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/overview/example-dataset/)。为了简洁起见，在多数数据查询语句中省略了 [USE movie](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/clauses/use-graph/) 子句。

## [数据定义语句](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/ddl/)

### [Schema](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/ddl/schema/create/)

 | 语句 | 描述
 | 

````
CREATE SCHEMA IF NOT EXISTS /movie
````

 |  创建 Schema。 
 | 

````
DROP SCHEMA IF EXISTS /movie
````

 |  销毁 Schema。 

### [图类型](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/ddl/graph-type/create/)

 | 语句 | 描述
 | 

````
'''
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
````

 |  重命名图类型。 

### [图](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/ddl/graph/create/)

 | 语句 | 描述
 | 

````
CREATE GRAPH IF NOT EXISTS movie TYPED movie_type
````

 |  创建图。 
 | 

````
DROP GRAPH movie
````

 |  销毁图。 
 | 

````
RENAME GRAPH movie TO movie_renamed
````

 |  重命名图。 

### [临时图](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/ddl/graph-projection/create/)

 | 语句 | 描述
 | 

````
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
````

 |  销毁临时图。 

### [索引](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/ddl/index/create/)

 | 语句 | 描述
 | 

````
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](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/ddl/ttl/create/)

 | 语句 | 描述
 | 

````
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 时长。 

### [过程](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/procedures/)

 | 语句 | 描述
 | 

````
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 的名称。 

## [数据操作语句](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dml/)

### [INSERT](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dml/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](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dml/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](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dml/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
'''   
````

 |  使用表变量批量删除点。 

## [数据查询语句](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/)

### [MATCH](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/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](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/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](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/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](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/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 开始的索引。

### [分页](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/order-by-page/)

 | 语句 | 描述
 | 

````
'''
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](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/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
````

 | 返回去重后的结果。

### [最终输出语句](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/primitive-result/)

 | 语句 | 描述
 | 

````
'''
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](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/procedures/)

 | 语句 | 描述
 | 

````
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`关键字调用一个内联过程。

### [线性查询](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/linear-query/)

 | 语句 | 描述
 | 

````
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`语句的线性查询。

### [复合查询](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/composite-query/)

 | 语句 | 描述
 | 

````
'''
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`操作符组合两个查询结果。

### [最近邻查询](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/nearest-neighbor/)

 | 语句 | 描述
 | 

````
'''
USE ann_test_graph 
MATCH (v:N1|N2) 
ORDER BY euclidean(v.vec1, VECTOR<3,float>([1.0, 2.0, 3.0])) ASC
LIMIT 3 
RETURN v.id AS vid, labels(v) AS vlabel, v.vec1 AS vec1, euclidean(v.vec1, VECTOR<3,float>([1.0, 2.0, 3.0])) AS distance
'''   
````

 | 执行 KNN 搜索并根据欧几里得距离查找 3 个最近邻。
 | 

````
'''
USE ann_test_graph 
MATCH (v:N1|N2) 
ORDER BY euclidean(v.vec1, VECTOR<3,float>([1.0, 2.0, 3.0])) ASC
APPROXIMATE 
LIMIT 3 
OPTIONS {TYPE: IVF, NPROBE: 256} 
RETURN v.id AS vid, labels(v) AS vlabel, v.vec1 AS vec1, euclidean(v.vec1, VECTOR<3,float>([1.0, 2.0, 3.0])) AS distance
'''   
````

 | 执行 ANN 搜索并根据欧几里得距离查找 3 个最近邻。

## 导入导出语句

### [IMPORT](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/in-out/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](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/in-out/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 
}
'''
````

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

## [服务端编程语句](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/server-prog/)

### [匹配计算语句](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/match-compute/)

 | 语句 | 描述
 | 

````
'''
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 相似度。

### [变量操作语句](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/set/)

 | 语句 | 描述
 | 

````
'''
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)
}
'''

````

 | 调用聚合值变量的成员函数。

### [控制流语句](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/control-flow/)

 | 语句 | 描述
 | 

````
'''
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`语句跳过当前迭代中剩余的语句并进入下一次迭代。

### [日志语句](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/log/)

 | 语句 | 描述
 | 

````
'''
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 
}
'''

````

 | 在查询执行时记录信息和告警消息。

## [语句块](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/statement-block/)

 | 语句 | 描述
 | 

````
'''
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](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/clauses/use-graph/)

 | 语句 | 描述
 | 

````
'''
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](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/clauses/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](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/clauses/yield/)

 | 语句 | 描述
 | 

````
'''
CALL show_graphs() YIELD graph_type, name AS graph_name 
RETURN graph_type, graph_name
'''   
````

 |  选择并重命名列。 

### [GROUP BY](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/clauses/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](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/clauses/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](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/clauses/limit/)

 | 语句 | 描述
 | 

````
MATCH (v:Person) LIMIT 3 RETURN v.id
````

 |  指定返回行数的上限。如果此上限大于或等于总行数，则返回所有行。否则，返回的行数不超过此上限。 

### [OFFSET](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/clauses/offset/)

 | 语句 | 描述
 | 

````
MATCH (v@Actor WHERE v.birthDate > date("1990-01-15")) OFFSET 3 ORDER BY v.birthDate RETURN v.id
````

 |  返回结果中跳过一定数量的行。如果此数量大于总行数，则返回空结果。 

### [SAMPLE](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/dql/clauses/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 条连接唯一邻点的边。 

## 函数

### [数学函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/math/)

 | 语句 | 描述
 | 

````
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()`返回一个数的半正矢值。 

### [聚合函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/aggregate/)

 | 语句 | 描述
 | 

````
'''
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()`从一组值中返回任意一个值。

关于聚合表达式的更多信息，请参见[聚合表达式](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/overview/cheat-sheet/#_27)。

### [字符串函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/string/)

 | 语句 | 描述
 | 

````
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()`返回输入值的字符串表示形式。

### [时间函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/temporal/)

 | 语句 | 描述
 | 

````
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()`计算两个时间点之间的时间段，并以字符串形式返回时间段。

#### [时间点和时间段之间的运算](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/temporal/#_30)

 | 语句 | 描述
 | 

````
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
````

 | 本地日期时间中减去时间段（大于一天）。

### [列表函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/list/)

 | 语句 | 描述
 | 

````
'''
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 值。

### [表格函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/table/)

 | 语句 | 描述
 | 

````
'''
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
'''   
````

 | 遍历子表格中的行。

### [集合函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/set/)

 | 语句 | 描述
 | 

````
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 值。

### [映射函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/map/)

 | 语句 | 描述
 | 

````
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 的键值对。

### [图函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/graph/)

 | 语句 | 描述
 | 

````
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()`返回图元素所属的元素类型的名称。

### [匿名函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/lambda/)

 | 语句 | 描述
 | 

````
'''
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()`将一个匿名表达式应用于列表中的每个元素，进行累积计算，并返回一个值。

关于匿名表达式的更多信息，请参见[匿名表达式](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/overview/cheat-sheet/#_37)。

### [向量函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/vector/)

 | 语句 | 描述
 | 

````
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()`返回给定向量的平方欧几里得范数。

#### [向量的算术运算](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/vector/#_2)

 | 语句 | 描述
 | 

````
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
````

 | 向量与数字的除法。

### [地理空间函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/geo/)

 | 语句 | 描述
 | 

````
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 列表。

### [全文索引函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/fulltext/)

 | 语句 | 描述
 | 

````
'''
USE movie 
MATCH (v@Movie) 
WHERE ftscore(v.name, 'Uncle') > 0 
RETURN v.name AS movie_name
'''   
````

 | 函数`ftscore()`返回存储在索引属性中的`STRING`值与给定查询字符串之间的相关性得分。

### [系统信息函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/functions/system/)

 | 语句 | 描述
 | 

````
RETURN typeof(1) AS a
````

 | 函数`typeof()`返回输入值的类型，支持普通值类型、图元素引用类型和表类型。

## 值表达式

### [聚合表达式](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/expressions/aggregate/)

 | 语句 | 描述
 | 

````
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 ()
````

 | 返回一部电影的所有评分和平均评分。

关于聚合函数的更多信息，请参见[聚合函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/overview/cheat-sheet/#_16)。

### [变量表达式](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/expressions/binding-variable/)

 | 语句 | 描述
 | 

````
LET a = 1, b = 2 RETURN a + b AS c
````

 | 定义变量并返回变量。
 | 

````
MATCH (a@`User`)-[e:Watch]->(b) RETURN a, e, b LIMIT 3
````

 | 返回点变量和边变量。

### [条件表达式](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/expressions/case/)

 | 语句 | 描述
 | 

````
'''
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`值。

### [常量表达式](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/expressions/constant/)

 | 语句 | 描述
 | 

````
'''
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
'''   
````

 | 返回不同类型的常量值。

### [构造表达式](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/expressions/construct/)

 | 语句 | 描述
 | 

````
RETURN LIST [1,2,3,4,5] AS l
````

 | 构造一个列表。
 | 

````
RETURN RECORD {a:1, b:true, c:"str literal"} AS record1
````

 | 构造一个记录。

### [函数表达式](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/expressions/function/)

 | 语句 | 描述
 | 

````
RETURN substring("abc", 1, 1) AS f2
````

 | 调用一个有多个入参的函数。
 | 

````
RETURN abs(-32.4) AS f1, substring("abc", 1, 1) AS f2
````

 | 调用多个函数。
 | 

````
RETURN date() AS currentDate
````

 | 调用一个无入参的函数。

完整的函数列表，请参见[函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/overview/cheat-sheet/#_13)。

### [逻辑表达式](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/expressions/logical/)

 | 语句 | 描述
 | 

````
RETURN true OR false AS a
````

 | 返回逻辑或的结果。
 | 

````
RETURN 1=2 AND 1=1 AS b
````

 | 返回逻辑与的结果。

### [属性表达式](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/expressions/property/)

 | 语句 | 描述
 | 

````
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
````

 | 获取点和边的属性。

### [子查询表达式](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/expressions/subquery/)

 | 语句 | 描述
 | 

````
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
````

 | 从子查询中返回布尔值。

### [类型转换表达式](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/expressions/cast/)

 | 语句 | 描述
 | 

````
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`类型的整数构成的记录。

### [匿名表达式](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/expressions/lambda/)

 | 语句 | 描述
 | 

````
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()`应用于一个列表。

关于匿名函数的更多信息，请参见[匿名函数](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/overview/cheat-sheet/#_23)。

## 谓词

### [比较谓词](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/predicates/comparison/)

 | 语句 | 描述
 | 

````
LET l1= 'w55', l2='e34' RETURN l1 > l2 AS a
````

 |  比较字符串。字符串的比较基于 [UCA](https://www.unicode.org/reports/tr10/) 算法。 
 | 

````
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 谓词](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/predicates/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 谓词](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/predicates/null/)

 | 语句 | 描述
 | 

````
LET a= null>10 RETURN a IS NULL AS a_is_null
````

 |  检查值是否为`null`。 

### [标签谓词](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/predicates/labeled/)

 | 语句 | 描述
 | 

````
'''
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 谓词](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/predicates/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 谓词](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/fe/predicates/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
'''   
````

 |  检查图元素列表中的所有图元素是否相同。 

## [性能调优](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/data-admin/tuning/)

 | 语句 | 描述
 | 

````
'''
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"`查看详细的优化后的执行计划。

## [数据库管理](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/data-admin/)

### 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 语句产生的所有警告。

## [会话](https://dev-docs.yueshu.com.cn/v5.3.2/database-gql-reference/sessions/)

 | 命令 | 描述
 | 

````
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 服务上所有活跃的会话。