Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

add whitespace #1250

Merged
merged 1 commit into from
Nov 24, 2021
Merged

add whitespace #1250

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
86 changes: 42 additions & 44 deletions docs-2.0/3.ngql-guide/7.general-query-statements/2.match.md
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -2,9 +2,9 @@

`MATCH`语句提供基于模式（pattern）匹配的搜索功能。

一个`MATCH`语句定义了一个[搜索模式](../1.nGQL-overview/3.graph-patterns.md)，用该模式匹配存储在Nebula Graph中的数据，然后用`RETURN`子句检索数据。
一个`MATCH`语句定义了一个 [搜索模式](../1.nGQL-overview/3.graph-patterns.md)，用该模式匹配存储在 Nebula Graph 中的数据，然后用`RETURN`子句检索数据。

本文示例使用测试数据集[basketballplayer](../1.nGQL-overview/1.overview.md#basketballplayer)进行演示。
本文示例使用测试数据集 [basketballplayer](../1.nGQL-overview/1.overview.md#basketballplayer) 进行演示。

## 语法

Expand All @@ -14,36 +14,36 @@
MATCH <pattern> [<WHERE clause>] RETURN <output>;
```

## MATCH工作流程
## MATCH 工作流程

1. `MATCH`语句使用原生索引查找起始点或边，起始点或边可以在模式的任何位置。即一个有效的`MATCH`语句，**必须有一个属性、Tag或Edge type已经创建索引，或者在`WHERE`子句中用id()函数指定了特定点的VID**。如何创建索引，请参见[创建原生索引](../14.native-index-statements/1.create-native-index.md)。
1. `MATCH`语句使用原生索引查找起始点或边，起始点或边可以在模式的任何位置。即一个有效的`MATCH`语句，**必须有一个属性、Tag 或 Edge type 已经创建索引，或者在`WHERE`子句中用 id() 函数指定了特定点的 VID**。如何创建索引，请参见 [创建原生索引](../14.native-index-statements/1.create-native-index.md)。

2. `MATCH`语句在模式中搜索，寻找匹配的边或点。

!!! note

`MATCH`语句采用的路径类型是`trail`，即遍历时只有点可以重复，边不可以重复。详情请参见[路径](../../1.introduction/2.1.path.md)。
`MATCH`语句采用的路径类型是`trail`，即遍历时只有点可以重复，边不可以重复。详情请参见 [路径](../../1.introduction/2.1.path.md)。

3. `MATCH`语句根据`RETURN`子句检索数据。

## openCypher兼容性
## openCypher 兼容性

- nGQL不支持遍历所有点和边，例如`MATCH (v) RETURN v`。但是，建立相应Tag的索引后，可以遍历对应Tag的所有点，例如`MATCH (v:T1) RETURN v`。
- nGQL 不支持遍历所有点和边，例如`MATCH (v) RETURN v`。但是，建立相应 Tag 的索引后，可以遍历对应 Tag 的所有点，例如`MATCH (v:T1) RETURN v`。

- WHERE子句内不支持图模式。
- WHERE 子句内不支持图模式。

## 使用模式（pattern）

### 前提条件

请确保`MATCH`语句有至少一个索引可用，或者其中指定了VID。如果需要创建索引，但是已经有相关的点、边或属性，用户必须在创建索引后重建索引，索引才能生效。
请确保`MATCH`语句有至少一个索引可用，或者其中指定了 VID。如果需要创建索引，但是已经有相关的点、边或属性，用户必须在创建索引后重建索引，索引才能生效。

!!! caution

索引会导致写性能大幅降低（降低90%甚至更多）。请**不要随意**在生产环境中使用索引，除非很清楚使用索引对业务的影响。
索引会导致写性能大幅降低（降低 90%甚至更多）。请**不要随意**在生产环境中使用索引，除非很清楚使用索引对业务的影响。

```ngql
# 在Tag player的name属性和Edge type follow上创建索引。
# 在 Tag player 的 name 属性和 Edge type follow 上创建索引。
nebula> CREATE TAG INDEX IF NOT EXISTS name ON player(name(20));
nebula> CREATE EDGE INDEX IF NOT EXISTS follow_index on follow();

Expand All @@ -62,7 +62,6 @@ nebula> REBUILD EDGE INDEX follow_index;
| 122 |
+------------+


# 确认重建索引成功。
nebula> SHOW JOB 121;
+----------------+---------------------+------------+----------------------------+----------------------------+
Expand Down Expand Up @@ -95,7 +94,7 @@ nebula> SHOW JOB 122;

匹配 Tag 的前提是 Tag 本身有索引或者 Tag 的某个属性有索引，否则，用户无法基于该 Tag 执行 `MATCH` 语句。

用户可以在点的右侧用`:<tag_name>`表示模式中的Tag。
用户可以在点的右侧用`:<tag_name>`表示模式中的 Tag。

```ngql
nebula> MATCH (v:player) \
Expand All @@ -115,10 +114,10 @@ nebula> MATCH (v:player) \

匹配点的属性的前提是 Tag 本身有对应属性的索引，否则，用户无法执行 `MATCH` 语句匹配该属性。

用户可以在Tag的右侧用`{<prop_name>: <prop_value>}`表示模式中点的属性。
用户可以在 Tag 的右侧用`{<prop_name>: <prop_value>}`表示模式中点的属性。

```ngql
# 使用属性name搜索匹配的点。
# 使用属性 name 搜索匹配的点。
nebula> MATCH (v:player{name:"Tim Duncan"}) \
RETURN v;
+----------------------------------------------------+
Expand All @@ -141,13 +140,13 @@ nebula> MATCH (v:player) \
+----------------------------------------------------+
```

!!! compatibility "openCypher兼容性"
!!! compatibility "openCypher 兼容性"

在openCypher 9中，`=`是相等运算符，在nGQL中，`==`是相等运算符，`=`是赋值运算符。
在 openCypher 9 中，`=`是相等运算符，在 nGQL 中，`==`是相等运算符，`=`是赋值运算符。

### 匹配点ID
### 匹配点 ID

用户可以使用点ID去匹配点。`id()`函数可以检索点的ID。
用户可以使用点 ID 去匹配点。`id()`函数可以检索点的 ID。

```ngql
nebula> MATCH (v) \
Expand All @@ -160,7 +159,7 @@ nebula> MATCH (v) \
+-----------------------------------------------------+
```

要匹配多个点的ID，可以用`WHERE id(v) IN [vid_list]`。
要匹配多个点的 ID，可以用`WHERE id(v) IN [vid_list]`。

```ngql
nebula> MATCH (v:player { name: 'Tim Duncan' })--(v2) \
Expand All @@ -170,7 +169,6 @@ nebula> MATCH (v:player { name: 'Tim Duncan' })--(v2) \
| v2 |
+-----------------------------------------------------------+
| ("player101" :player{age: 36, name: "Tony Parker"}) |
| ("player101" :player{age: 36, name: "Tony Parker"}) |
| ("player102" :player{age: 33, name: "LaMarcus Aldridge"}) |
+-----------------------------------------------------------+
```
Expand All @@ -181,7 +179,7 @@ nebula> MATCH (v:player { name: 'Tim Duncan' })--(v2) \

!!! compatibility "历史版本兼容性"

在nGQL 1.x中，`--`符号用于行内注释，在nGQL 2.x中，`--`符号表示出边或入边，不再用于注释。
在 nGQL 1.x 中，`--`符号用于行内注释，在 nGQL 2.x 中，`--`符号表示出边或入边，不再用于注释。

```ngql
nebula> MATCH (v:player{name:"Tim Duncan"})--(v2) \
Expand All @@ -199,7 +197,7 @@ nebula> MATCH (v:player{name:"Tim Duncan"})--(v2) \
用户可以在`--`符号上增加`<`或`>`符号指定边的方向。

```ngql
# -->表示边从v开始，指向v2。对于点v来说是出边，对于点v2来说是入边。
# -->表示边从 v 开始，指向 v2。对于点 v 来说是出边，对于点 v2 来说是入边。
nebula> MATCH (v:player{name:"Tim Duncan"})-->(v2) \
RETURN v2.name AS Name;
+-----------------+
Expand Down Expand Up @@ -255,9 +253,9 @@ nebula> MATCH p=(v:player{name:"Tim Duncan"})-->(v2) \
+--------------------------------------------------------------------------------------------------------------------------------------+
```

!!! compatibility "openCypher兼容性"
!!! compatibility "openCypher 兼容性"

在nGQL中，`@`符号表示边的rank，在openCypher中，没有rank概念。
在 nGQL 中，`@`符号表示边的 rank，在 openCypher 中，没有 rank 概念。

### 匹配边

Expand All @@ -275,9 +273,9 @@ nebula> MATCH (v:player{name:"Tim Duncan"})-[e]-(v2) \
...
```

### 匹配Edge type
### 匹配 Edge type

和点一样，用户可以用`:<edge_type>`表示模式中的Edge type，例如`-[e:follow]-`。
和点一样，用户可以用`:<edge_type>`表示模式中的 Edge type，例如`-[e:follow]-`。

```ngql
nebula> MATCH ()-[e:follow]-() \
Expand All @@ -297,7 +295,7 @@ nebula> MATCH ()-[e:follow]-() \

匹配边的属性的前提是 Edge type 本身有对应属性的索引，否则，用户无法执行 `MATCH` 语句匹配该属性。

用户可以用`{<prop_name>: <prop_value>}`表示模式中Edge type的属性，例如`[e:follow{likeness:95}]`。
用户可以用`{<prop_name>: <prop_value>}`表示模式中 Edge type 的属性，例如`[e:follow{likeness:95}]`。

```ngql
nebula> MATCH (v:player{name:"Tim Duncan"})-[e:follow{degree:95}]->(v2) \
Expand All @@ -310,9 +308,9 @@ nebula> MATCH (v:player{name:"Tim Duncan"})-[e:follow{degree:95}]->(v2) \
+--------------------------------------------------------+
```

### 匹配多个Edge type
### 匹配多个 Edge type

使用`|`可以匹配多个Edge type，例如`[e:follow|:serve]`。第一个Edge type前的英文冒号（:）不可省略，后续Edge type前的英文冒号可以省略，例如`[e:follow|serve]`。
使用`|`可以匹配多个 Edge type，例如`[e:follow|:serve]`。第一个 Edge type 前的英文冒号（:）不可省略，后续 Edge type 前的英文冒号可以省略，例如`[e:follow|serve]`。

```ngql
nebula> MATCH (v:player{name:"Tim Duncan"})-[e:follow|:serve]->(v2) \
Expand Down Expand Up @@ -358,7 +356,7 @@ nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow*2]->(v2) \
+-----------------------------------------------------------+
```

如果`hop`为0，模式会匹配路径上的起始点。
如果`hop`为 0，模式会匹配路径上的起始点。

```ngql
nebula> MATCH (v:player{name:"Tim Duncan"}) -[*0]-> (v2) \
Expand All @@ -376,12 +374,12 @@ nebula> MATCH (v:player{name:"Tim Duncan"}) -[*0]-> (v2) \

|参数|说明|
|:---|:---|
|`minHop`|可选项。表示路径的最小长度。`minHop`必须是一个非负整数，默认值为1。|
|`minHop`|可选项。表示路径的最小长度。`minHop`必须是一个非负整数，默认值为 1。|
|`maxHop`|必选项。表示路径的最大长度。`maxHop`必须是一个非负整数，没有默认值。|

!!! compatibility "openCypher兼容性"
!!! compatibility "openCypher 兼容性"

在openCypher中，`maxHop`是可选项，默认为无穷大。当没有设置时，`..`可以省略。在nGQL中，`maxHop`是必选项，而且`..`不可以省略。
在 openCypher 中，`maxHop`是可选项，默认为无穷大。当没有设置时，`..`可以省略。在 nGQL 中，`maxHop`是必选项，而且`..`不可以省略。

```ngql
nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow*1..3]->(v2) \
Expand Down Expand Up @@ -425,9 +423,9 @@ nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow*0..3]->(v2:player) \
+-----------------------------------------------------------+-----------+
```

### 匹配多个Edge type的变长路径
### 匹配多个 Edge type 的变长路径

用户可以在变长或定长模式中指定多个Edge type。`hop`、`minHop`和`maxHop`对所有Edge type都生效。
用户可以在变长或定长模式中指定多个 Edge type。`hop`、`minHop`和`maxHop`对所有 Edge type 都生效。

```ngql
nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e:follow|serve*2]->(v2) \
Expand Down Expand Up @@ -469,9 +467,9 @@ nebula> MATCH (v:player{name:"Tim Duncan"})-[e]->(v2) \
+-----------------------------------------------------------------------+
```

### 检索点ID
### 检索点 ID

使用`id()`函数检索点ID。
使用`id()`函数检索点 ID。

```ngql
nebula> MATCH (v:player{name:"Tim Duncan"}) \
Expand All @@ -483,9 +481,9 @@ nebula> MATCH (v:player{name:"Tim Duncan"}) \
+-------------+
```

### 检索Tag
### 检索 Tag

使用`labels()`函数检索点上的Tag列表。
使用`labels()`函数检索点上的 Tag 列表。

```ngql
nebula> MATCH (v:player{name:"Tim Duncan"}) \
Expand All @@ -497,7 +495,7 @@ nebula> MATCH (v:player{name:"Tim Duncan"}) \
+------------+
```

检索列表`labels(v)`中的第N个元素，可以使用`labels(v)[n-1]`。例如下面示例使用`labels(v)[0]`检索第一个元素。
检索列表`labels(v)`中的第 N 个元素，可以使用`labels(v)[n-1]`。例如下面示例使用`labels(v)[0]`检索第一个元素。

```ngql
nebula> MATCH (v:player{name:"Tim Duncan"}) \
Expand Down Expand Up @@ -551,9 +549,9 @@ nebula> MATCH p=(v:player{name:"Tim Duncan"})-[]->(v2) \
+----------------------------------+
```

### 检索Edge type
### 检索 Edge type

使用`type()`函数检索匹配的Edge type。
使用`type()`函数检索匹配的 Edge type。

```ngql
nebula> MATCH p=(v:player{name:"Tim Duncan"})-[e]->() \
Expand Down Expand Up @@ -640,4 +638,4 @@ nebula> MATCH p=(v:player{name:"Tim Duncan"})-[*..2]->(v2) \

!!! Performance

Nebula Graph中`MATCH`语句的性能和资源占用得到了优化，但对性能要求较高时，仍建议使用 `GO`, `LOOKUP`, `|` 和 `FETCH` 等来替代`MATCH`。
Nebula Graph 中`MATCH`语句的性能和资源占用得到了优化，但对性能要求较高时，仍建议使用 `GO`, `LOOKUP`, `|` 和 `FETCH` 等来替代`MATCH`。
Loading