MATCH¶
MATCH
语句提供基于模式(Pattern)匹配的搜索功能,其通过定义一个或多个模式,允许在 NebulaGraph 中查找与模式匹配的数据。在检索到匹配的数据后,用户可以使用 RETURN 子句将其作为结果返回。
在本文中,我们将使用名为 basketballplayer 的测试数据集来演示 MATCH 语句的使用。
语法¶
MATCH
语句的语法相较于其他查询语句(如GO
和LOOKUP
)更具灵活性。在进行查询时,MATCH
语句使用的路径类型是trail
,这意味着点可以重复出现,但边不能重复。
MATCH
语法的基本结构如下:
MATCH <pattern> [<clause_1>] RETURN <output> [<clause_2>];
pattern
:MATCH
语句支持匹配一个或多个模式,多个模式之间用英文逗号(,)分隔。例如(a)-[]->(b),(c)-[]->(d)
。Pattern 的详细说明请参见模式。
clause_1
:支持WHERE
、WITH
、UNWIND
、OPTIONAL MATCH
子句,也可以使用MATCH
作为子句。
output
:定义需要返回输出结果的列表名称。可以使用AS
设置列表的别名。
clause_2
:支持ORDER BY
、LIMIT
子句。
历史版本兼容性
- 从 3.5.0 版本开始,
MATCH
语句支持全表扫描,即在不使用任何索引或者过滤条件的情况下可遍历图中点或边。在此之前的版本中,MATCH 语句在某些情况下需要索引才能执行查询或者需要使用LIMIT
限制输出结果数量。 - 从 3.0.0 版本开始,为了区别不同 Tag 的属性,返回属性时必须额外指定 Tag 名称。即从
RETURN <变量名>.<属性名>
改为RETURN <变量名>.<Tag名>.<属性名>
。
使用说明¶
- 尽量避免执行全表扫描,因为这可能导致查询性能下降;并且如果在进行全表扫描时内存不足,可能会导致查询失败,系统会提示报错。建议使用具有过滤条件或指定 Tag、边类型的查询,例如
MATCH (v:player) RETURN v.player.name AS Name
语句中的v:player
和v.player.name
。
- 可为 Tag、Edge type 或 Tag、Edge type 的某个属性创建索引,以提高查询性能。例如,用户可以为
player
Tag 创建索引,或者为player
Tag 的name
属性创建索引。有关索引的使用及注意事项,请参见使用索引必读。
- 目前 MATCH 语句无法查询到悬挂边。
使用模式¶
匹配点¶
用户可以在一对括号中使用自定义变量来表示模式中的点。例如(v)
。
# 匹配全图空间中的任意 3 个点
nebula> MATCH (v) \
RETURN v \
LIMIT 3;
+-----------------------------------------------------------+
| v |
+-----------------------------------------------------------+
| ("player102" :player{age: 33, name: "LaMarcus Aldridge"}) |
| ("player106" :player{age: 25, name: "Kyle Anderson"}) |
| ("player115" :player{age: 40, name: "Kobe Bryant"}) |
+-----------------------------------------------------------+
匹配 Tag¶
历史版本兼容性
在 NebulaGraph 3.0.0 之前,匹配 Tag 的前提是 Tag 本身有索引或者 Tag 的某个属性有索引,否则,用户无法基于该 Tag 执行MATCH
语句。从 NebulaGraph 3.0.0 开始,匹配 Tag 可以不创建索引,但需要使用LIMIT
限制输出结果数量。从 NebulaGraph 3.5.0 开始,MATCH
语句支持全表扫描,无需为 Tag 或 Tag 的某个属性创建索引,或者使用LIMIT
限制输出结果数量,即可执行MATCH
语句。
用户可以在点的右侧用:<tag_name>
表示模式中的 Tag。
# 匹配全图空间中所有 Tag 为 player 的点
nebula> MATCH (v:player) \
RETURN v;
+-----------------------------------------------------------+
| v |
+-----------------------------------------------------------+
| ("player102" :player{age: 33, name: "LaMarcus Aldridge"}) |
| ("player106" :player{age: 25, name: "Kyle Anderson"}) |
| ("player115" :player{age: 40, name: "Kobe Bryant"}) |
...
需要匹配拥有多个 Tag 的点,可以用英文冒号(:)。
# 创建包含 name 属性和 age 属性的 Tag actor。
nebula> CREATE TAG actor (name string, age int);
# 插入 Tag actor 到点 player100。
nebula> INSERT VERTEX actor(name, age) VALUES "player100":("Tim Duncan", 42);
# 匹配 Tag 为 player 和 actor 的点。
nebula> MATCH (v:player:actor) \
RETURN v;
+----------------------------------------------------------------------------------------+
| v |
+----------------------------------------------------------------------------------------+
| ("player100" :actor{age: 42, name: "Tim Duncan"} :player{age: 42, name: "Tim Duncan"}) |
+----------------------------------------------------------------------------------------+
匹配点的属性¶
用户可以在 Tag 的右侧用{<prop_name>: <prop_value>}
表示模式中点的属性。
# 使用属性 name 搜索匹配的点。
nebula> MATCH (v:player{name:"Tim Duncan"}) \
RETURN v;
+----------------------------------------------------+
| v |
+----------------------------------------------------+
| ("player100" :player{age: 42, name: "Tim Duncan"}) |
+----------------------------------------------------+
使用WHERE
子句也可以实现相同的操作:
# 查找类型为 player,名字为 Tim Duncan 的点。
nebula> MATCH (v:player) \
WHERE v.player.name == "Tim Duncan" \
RETURN v;
+----------------------------------------------------+
| v |
+----------------------------------------------------+
| ("player100" :player{age: 42, name: "Tim Duncan"}) |
+----------------------------------------------------+
openCypher 兼容性
在 openCypher 9 中,=
是相等运算符,在 nGQL 中,==
是相等运算符,=
是赋值运算符。
使用WHERE
子句直接匹配点的属性。
# 匹配属性中值等于 Tim Duncan 的点。
nebula> MATCH (v) \
WITH v, properties(v) as props, keys(properties(v)) as kk \
WHERE [i in kk where props[i] == "Tim Duncan"] \
RETURN v;
+----------------------------------------------------+
| v |
+----------------------------------------------------+
| ("player100" :player{age: 42, name: "Tim Duncan"}) |
+----------------------------------------------------+
# 匹配 name 属性值存在于 names 列表内的起点,并返回起点和终点的数据。
nebula> WITH ['Tim Duncan', 'Yao Ming'] AS names \
MATCH (v1:player)-->(v2:player) \
WHERE v1.player.name in names \
RETURN v1, v2;
+----------------------------------------------------+----------------------------------------------------------+
| v1 | v2 |
+----------------------------------------------------+----------------------------------------------------------+
| ("player133" :player{age: 38, name: "Yao Ming"}) | ("player114" :player{age: 39, name: "Tracy McGrady"}) |
| ("player133" :player{age: 38, name: "Yao Ming"}) | ("player144" :player{age: 47, name: "Shaquille O'Neal"}) |
| ("player100" :player{age: 42, name: "Tim Duncan"}) | ("player101" :player{age: 36, name: "Tony Parker"}) |
| ("player100" :player{age: 42, name: "Tim Duncan"}) | ("player125" :player{age: 41, name: "Manu Ginobili"}) |
+----------------------------------------------------+----------------------------------------------------------+
匹配点 ID¶
用户可以使用点 ID 去匹配点。id()
函数可以检索点的 ID。
# 查找 ID 为 “player101” 的点。(注:ID 全局唯一)。
nebula> MATCH (v) \
WHERE id(v) == 'player101' \
RETURN v;
+-----------------------------------------------------+
| v |
+-----------------------------------------------------+
| ("player101" :player{age: 36, name: "Tony Parker"}) |
+-----------------------------------------------------+
要匹配多个点的 ID,可以用WHERE id(v) IN [vid_list]
或者WHERE id(v) IN {vid_list}
。
# 查找与 `Tim Duncan` 直接相连的点,并且这些点的 ID 必须是 `player101` 或 `player102`。
nebula> MATCH (v:player { name: 'Tim Duncan' })--(v2) \
WHERE id(v2) IN ["player101", "player102"] \
RETURN v2;
+-----------------------------------------------------------+
| v2 |
+-----------------------------------------------------------+
| ("player101" :player{age: 36, name: "Tony Parker"}) |
| ("player101" :player{age: 36, name: "Tony Parker"}) |
| ("player102" :player{age: 33, name: "LaMarcus Aldridge"}) |
+-----------------------------------------------------------+
# 查找 ID 为 player100 和 player101 的点,并返回 name 属性。
nebula> MATCH (v) WHERE id(v) IN {"player100", "player101"} \
RETURN v.player.name AS name;
+---------------+
| name |
+---------------+
| "Tony Parker" |
| "Tim Duncan" |
+---------------+
匹配连接的点¶
用户可以使用--
符号表示两个方向的边,并匹配这些边连接的点。
历史版本兼容性
在 nGQL 1.x 中,--
符号用于行内注释,从 nGQL 2.x 起,--
符号表示出边或入边,不再用于注释。
# name 属性值为 Tim Duncan 的点为 v,与 v 相连接的点为 v2,查找 v2 并返回其 name 属性值。
nebula> MATCH (v:player{name:"Tim Duncan"})--(v2:player) \
RETURN v2.player.name AS Name;
+---------------------+
| Name |
+---------------------+
| "Manu Ginobili" |
| "Manu Ginobili" |
| "Dejounte Murray" |
...
用户可以在--
符号上增加<
或>
符号指定边的方向。
# `-->` 表示边从 v 开始,指向 v2。对于点 v 来说是出边,对于点 v2 来说是入边。
nebula> MATCH (v:player{name:"Tim Duncan"})-->(v2:player) \
RETURN v2.player.name AS Name;
+-----------------+
| Name |
+-----------------+
| "Tony Parker" |
| "Manu Ginobili" |
+-----------------+
如果需要判断目标点,可以使用CASE
表达式。
# name 属性值为 Tim Duncan 的点为 v,与 v 相连接的点为 v2,查找 v2 并判断,如果 v2.team.name 的值不为空则返回 v2.team.name 属性值,如果 v2.player.name 的值不为空则返回 v2.player.name 属性值。
nebula> MATCH (v:player{name:"Tim Duncan"})--(v2) \
RETURN \
CASE WHEN v2.team.name IS NOT NULL \
THEN v2.team.name \
WHEN v2.player.name IS NOT NULL \
THEN v2.player.name END AS Name;
+---------------------+
| Name |
+---------------------+
| "Manu Ginobili" |
| "Manu Ginobili" |
| "Spurs" |
| "Dejounte Murray" |
...
如果需要扩展模式,可以增加更多点和边。
# name 属性值为 Tim Duncan 的点为 v,指向点 v2,点 v3 也指向点 v2,返回 v3 的 name 属性值。
nebula> MATCH (v:player{name:"Tim Duncan"})-->(v2)<--(v3) \
RETURN v3.player.name AS Name;
+---------------------+
| Name |
+---------------------+
| "Dejounte Murray" |
| "LaMarcus Aldridge" |
| "Marco Belinelli" |
...
如果不需要引用点,可以省略括号中表示点的变量。
# 查找 name 属性值为 Tim Duncan 的点 v, 点 v3 与 v 指向同一个点,返回 v3 的 name 属性值。
nebula> MATCH (v:player{name:"Tim Duncan"})-->()<--(v3) \
RETURN v3.player.name AS Name;
+---------------------+
| Name |
+---------------------+
| "Dejounte Murray" |
| "LaMarcus Aldridge" |
| "Marco Belinelli" |
...
匹配路径¶
连接起来的点和边构成了路径。用户可以使用自定义变量命名路径。
# 设置路径 p,其模式为 name 属性值为 Tim Duncan 的点 v 指向相邻的点 v2。返回所有符合条件的路径。
nebula> MATCH p=(v:player{name:"Tim Duncan"})-->(v2) \
RETURN p;
+--------------------------------------------------------------------------------------------------------------------------------------+
| p |
+--------------------------------------------------------------------------------------------------------------------------------------+
| <("player100" :player{age: 42, name: "Tim Duncan"})-[:serve@0 {end_year: 2016, start_year: 1997}]->("team204" :team{name: "Spurs"})> |
| <("player100" :player{age: 42, name: "Tim Duncan"})-[:follow@0 {degree: 95}]->("player101" :player{age: 36, name: "Tony Parker"})> |
| <("player100" :player{age: 42, name: "Tim Duncan"})-[:follow@0 {degree: 95}]->("player125" :player{age: 41, name: "Manu Ginobili"})> |
+--------------------------------------------------------------------------------------------------------------------------------------+
openCypher 兼容性
在 nGQL 中,@
符号表示边的 rank,在 openCypher 中,没有 rank 概念。
匹配边¶
# 匹配对应边并返回 3 条数据。
nebula> MATCH ()<-[e]-() \
RETURN e \
LIMIT 3;
+----------------------------------------------------+
| e |
+----------------------------------------------------+
| [:follow "player101"->"player102" @0 {degree: 90}] |
| [:follow "player103"->"player102" @0 {degree: 70}] |
| [:follow "player135"->"player102" @0 {degree: 80}] |
+----------------------------------------------------+
匹配 Edge type¶
和点一样,用户可以用:<edge_type>
表示模式中的 Edge type,例如-[e:follow]-
。
历史版本兼容性
在 NebulaGraph 3.0.0 之前,匹配 Edge Type 的前提是 Edge Type 本身有对应属性的索引,否则,用户无法基于 Edge Type 执行 MATCH
语句。从 NebulaGraph 3.0.0 开始,匹配 Edge Type 可以不创建索引,但需要使用 LIMIT
限制输出结果数量,并且必须指定边的方向。从 NebulaGraph 3.5.0 开始,无需为 Edge Type 创建索引或者使用LIMIT
限制输出结果数量,即可使用MATCH
语句匹配边。
# 匹配所有 edge type 为 follow 的边。
nebula> MATCH ()-[e:follow]->() \
RETURN e;
+----------------------------------------------------+
| e |
+----------------------------------------------------+
| [:follow "player102"->"player100" @0 {degree: 75}] |
| [:follow "player102"->"player101" @0 {degree: 75}] |
| [:follow "player129"->"player116" @0 {degree: 90}] |
...
匹配边的属性¶
用户可以用{<prop_name>: <prop_value>}
表示模式中 Edge type 的属性,例如[e:follow{likeness:95}]
。
nebula> MATCH (v:player{name:"Tim Duncan"})-[e:follow{degree:95}]->(v2) \
RETURN e;
+--------------------------------------------------------+
| e |
+--------------------------------------------------------+
| [:follow "player100"->"player101" @0 {degree: 95}] |
| [:follow "player100"->"player125" @0 {degree: 95}] |
+--------------------------------------------------------+
使用WHERE
子句直接匹配边的属性。
nebula> MATCH ()-[e]->() \
WITH e, properties(e) as props, keys(properties(e)) as kk \
WHERE [i in kk where props[i] == 90] \
RETURN e;
+----------------------------------------------------+
| e |
+----------------------------------------------------+
| [:follow "player125"->"player100" @0 {degree: 90}] |
| [:follow "player140"->"player114" @0 {degree: 90}] |
| [:follow "player133"->"player144" @0 {degree: 90}] |
| [:follow "player133"->"player114" @0 {degree: 90}] |
...
+----------------------------------------------------+
匹配多个 Edge type¶
使用|
可以匹配多个 Edge type,例如[e:follow|:serve]
。第一个 Edge type 前的英文冒号(:)不可省略,后续 Edge type 前的英文冒号可以省略,例如[e:follow|serve]
。
nebula> MATCH (v:player{name:"Tim Duncan"})-[e:follow|:serve]->(v2) \
RETURN e;
+---------------------------------------------------------------------------+
| e |
+---------------------------------------------------------------------------+
| [:follow "player100"->"player101" @0 {degree: 95}] |
| [:follow "player100"->"player125" @0 {degree: 95}] |
| [:serve "player100"->"team204" @0 {end_year: 2016, start_year: 1997}] |
+---------------------------------------------------------------------------+
匹配多条边¶
用户可以扩展模式,匹配路径中的多条边。
nebula> MATCH (v:player{name:"Tim Duncan"})-[]->(v2)<-[e:serve]-(v3) \
RETURN v2, v3;
+----------------------------------+-----------------------------------------------------------+
| v2 | v3 |
+----------------------------------+-----------------------------------------------------------+
| ("team204" :team{name: "Spurs"}) | ("player104" :player{age: 32, name: "Marco Belinelli"}) |
| ("team204" :team{name: "Spurs"}) | ("player101" :player{age: 36, name: "Tony Parker"}) |
| ("team204" :team{name: "Spurs"}) | ("player102" :player{age: 33, name: "LaMarcus Aldridge"}) |
...
匹配定长路径¶
用户可以在模式中使用:<edge_type>*<hop>
匹配定长路径。hop
必须是一个非负整数。
nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow*2]->(v2) \
RETURN DISTINCT v2 AS Friends;
+-----------------------------------------------------------+
| Friends |
+-----------------------------------------------------------+
| ("player100" :player{age: 42, name: "Tim Duncan"}) |
| ("player125" :player{age: 41, name: "Manu Ginobili"}) |
| ("player102" :player{age: 33, name: "LaMarcus Aldridge"}) |
+-----------------------------------------------------------+
如果hop
为 0,模式会匹配路径上的起始点。
nebula> MATCH (v:player{name:"Tim Duncan"}) -[*0]-> (v2) \
RETURN v2;
+----------------------------------------------------+
| v2 |
+----------------------------------------------------+
| ("player100" :player{age: 42, name: "Tim Duncan"}) |
+----------------------------------------------------+
Note
在对匹配的多跳边进行过滤时,如对-[e:follow*2]->
中的e
进行过滤,此时的e
不再是单条边的数据类型,而是一个包含多条边的列表,例如:
以下语句可以运行但是没有返回数据,因为e
是一个列表,没有.degree
的属性。
nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow*2]->(v2) \
WHERE e.degree > 1 \
RETURN DISTINCT v2 AS Friends;
nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow*2]->(v2) \
WHERE ALL(e_ in e WHERE e_.degree > 0) \
RETURN DISTINCT v2 AS Friends;
nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow*2]->(v2) \
WHERE e[0].degree > 98 \
RETURN DISTINCT v2 AS Friends;
匹配变长路径¶
用户可以在模式中使用:<edge_type>*[minHop..maxHop]
匹配变长路径。
Caution
如果未设置 maxHop
可能会导致 graph 服务 OOM,请谨慎执行该命令。
参数 | 说明 |
---|---|
minHop |
可选项。表示路径的最小长度。minHop 必须是一个非负整数,默认值为 1。 |
maxHop |
可选项。表示路径的最大长度。maxHop 必须是一个非负整数,默认值为无穷大。 |
如果未指定minHop
和maxHop
,仅设置了:<edge_type>*
,则二者都应用默认值,即minHop
为 1,maxHop
为无穷大。
nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow*]->(v2) \
RETURN v2 AS Friends;
+-----------------------------------------------------------+
| Friends |
+-----------------------------------------------------------+
| ("player125" :player{age: 41, name: "Manu Ginobili"}) |
| ("player101" :player{age: 36, name: "Tony Parker"}) |
...
nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow*1..3]->(v2) \
RETURN v2 AS Friends;
+-----------------------------------------------------------+
| Friends |
+-----------------------------------------------------------+
| ("player101" :player{age: 36, name: "Tony Parker"}) |
| ("player125" :player{age: 41, name: "Manu Ginobili"}) |
| ("player100" :player{age: 42, name: "Tim Duncan"}) |
...
nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow*1..]->(v2) \
RETURN v2 AS Friends;
+-----------------------------------------------------------+
| Friends |
+-----------------------------------------------------------+
| ("player125" :player{age: 41, name: "Manu Ginobili"}) |
| ("player101" :player{age: 36, name: "Tony Parker"}) |
| ("player100" :player{age: 42, name: "Tim Duncan"}) |
...
用户可以使用DISTINCT
关键字聚合重复结果。
nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow*1..3]->(v2:player) \
RETURN DISTINCT v2 AS Friends, count(v2);
+-----------------------------------------------------------+-----------+
| Friends | count(v2) |
+-----------------------------------------------------------+-----------+
| ("player102" :player{age: 33, name: "LaMarcus Aldridge"}) | 1 |
| ("player100" :player{age: 42, name: "Tim Duncan"}) | 4 |
| ("player101" :player{age: 36, name: "Tony Parker"}) | 3 |
| ("player125" :player{age: 41, name: "Manu Ginobili"}) | 3 |
+-----------------------------------------------------------+-----------+
如果minHop
为0
,模式会匹配路径上的起始点。例如,与上个示例相比,下面的示例设置minHop
为0
。此时,因为表示"Tim Duncan"
的点是路径的起始点,所以它在结果集中的计数为 5,比在上个示例的结果中多计一次。
nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow*0..3]->(v2:player) \
RETURN DISTINCT v2 AS Friends, count(v2);
+-----------------------------------------------------------+-----------+
| Friends | count(v2) |
+-----------------------------------------------------------+-----------+
| ("player102" :player{age: 33, name: "LaMarcus Aldridge"}) | 1 |
| ("player100" :player{age: 42, name: "Tim Duncan"}) | 5 |
| ("player125" :player{age: 41, name: "Manu Ginobili"}) | 3 |
| ("player101" :player{age: 36, name: "Tony Parker"}) | 3 |
+-----------------------------------------------------------+-----------+
Note
当在模式中使用变量e
匹配定长或者变长路径时,例如-[e:follow*0..3]->
,不支持在其他模式中引用e
。例如,不支持以下语句:
nebula> MATCH (v:player)-[e:like*1..3]->(n) \
WHERE (n)-[e*1..4]->(:player) \
RETURN v;
匹配多个 Edge type 的变长路径¶
用户可以在变长或定长模式中指定多个 Edge type。hop
、minHop
和maxHop
对所有 Edge type 都生效。
nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow|serve*2]->(v2) \
RETURN DISTINCT v2;
+-----------------------------------------------------------+
| v2 |
+-----------------------------------------------------------+
| ("team204" :team{name: "Spurs"}) |
| ("player100" :player{age: 42, name: "Tim Duncan"}) |
| ("team215" :team{name: "Hornets"}) |
| ("player125" :player{age: 41, name: "Manu Ginobili"}) |
| ("player102" :player{age: 33, name: "LaMarcus Aldridge"}) |
+-----------------------------------------------------------+
匹配多个模式¶
用户可以用英文逗号(,)分隔多个模式。
nebula> CREATE TAG INDEX IF NOT EXISTS team_index ON team(name(20));
nebula> REBUILD TAG INDEX team_index;
nebula> MATCH (v1:player{name:"Tim Duncan"}), (v2:team{name:"Spurs"}) \
RETURN v1,v2;
+----------------------------------------------------+----------------------------------+
| v1 | v2 |
+----------------------------------------------------+----------------------------------+
| ("player100" :player{age: 42, name: "Tim Duncan"}) | ("team204" :team{name: "Spurs"}) |
+----------------------------------------------------+----------------------------------+
匹配最短路径¶
用户可以使用allShortestPaths
返回起始点到目标点的所有最短路径。
nebula> MATCH p = allShortestPaths((a:player{name:"Tim Duncan"})-[e*..5]-(b:player{name:"Tony Parker"})) \
RETURN p;
+------------------------------------------------------------------------------------------------------------------------------------+
| p |
+------------------------------------------------------------------------------------------------------------------------------------+
| <("player100" :player{age: 42, name: "Tim Duncan"})<-[:follow@0 {degree: 95}]-("player101" :player{age: 36, name: "Tony Parker"})> |
| <("player100" :player{age: 42, name: "Tim Duncan"})-[:follow@0 {degree: 95}]->("player101" :player{age: 36, name: "Tony Parker"})> |
+------------------------------------------------------------------------------------------------------------------------------------+
用户可以使用shortestPath
返回起始点到目标点的任意一条最短路径。
nebula> MATCH p = shortestPath((a:player{name:"Tim Duncan"})-[e*..5]-(b:player{name:"Tony Parker"})) \
RETURN p;
+------------------------------------------------------------------------------------------------------------------------------------+
| p |
+------------------------------------------------------------------------------------------------------------------------------------+
| <("player100" :player{age: 42, name: "Tim Duncan"})<-[:follow@0 {degree: 95}]-("player101" :player{age: 36, name: "Tony Parker"})> |
+------------------------------------------------------------------------------------------------------------------------------------+
多MATCH检索¶
不同的模式有不同的筛选条件时,可以使用多MATCH
,会返回模式完全匹配的行。
nebula> MATCH (m)-[]->(n) WHERE id(m)=="player100" \
MATCH (n)-[]->(l) WHERE id(n)=="player125" \
RETURN id(m),id(n),id(l);
+-------------+-------------+-------------+
| id(m) | id(n) | id(l) |
+-------------+-------------+-------------+
| "player100" | "player125" | "team204" |
| "player100" | "player125" | "player100" |
+-------------+-------------+-------------+
OPTIONAL MATCH检索¶
Caution
NebulaGraph 3.8.0 中MATCH
语句的性能和资源占用得到了优化.但对性能要求较高时,仍建议使用 GO
, LOOKUP
, |
和 FETCH
等来替代MATCH
。