From bc781284ffc6224676aad4653e2f2e7992063203 Mon Sep 17 00:00:00 2001 From: Abby <78209557+abby-cyber@users.noreply.github.com> Date: Sat, 19 Aug 2023 12:20:18 +0800 Subject: [PATCH 1/5] new doc INNER JOIN --- .../8.clauses-and-options/joins.md | 64 +++++++++++++++++++ mkdocs.yml | 1 + 2 files changed, 65 insertions(+) create mode 100644 docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md diff --git a/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md b/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md new file mode 100644 index 00000000000..486e43bcf2d --- /dev/null +++ b/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md @@ -0,0 +1,64 @@ +# INNER JOIN + +`INNER JOIN`是一种连接查询，用于将两个表关联在一起，只返回在两个表中都存在的行。在 NebulaGraph 中，`INNER JOIN`子句可以用来在两个表格之间进行连接查询，以获取更加复杂的查询结果。 + +## openCypher 兼容性 + +`INNER JOIN`子句仅适用于原生 nGQL 语法。 + +## 语法 + +```ngql +YIELD +FROM INNER JOIN ON +``` + +## 使用说明 + +- 必须使用`YIELD`子句指定返回的列，并且`YIELD`子句放置在`INNER JOIN`子句之前。 +- `INNER JOIN`子句必须包含`ON`子句，`ON`子句指定了连接条件。连接条件只支持等值连接（即`==`）。 +- ``和``是要连接的两个表，两表名不能相同。 +- 可以使用自定义变量来指定表格名。详情参见[使用自定义变量](../3.ngql-guide/4.variable-and-composite-queries/2.user-defined-variables.md)。 + +## 使用示例 + +示例一：结合`LOOKUP`和`GO`子句，查找名为`Tony Parker`的球员和他的朋友之间的`like`关系。 + +1. 先查找名为`Tony Parker`的球员的ID。 +2. 再查找名为`Tony Parker`和`Manu Ginobili`的球员之间是否存在`like`关系，如果存在，则将两个球员的 ID 和`like`关系返回。 +3. 最后的将两次查询的结果合并在一起，以便获取最终的结果。 + +```ngql +nebula> $a = LOOKUP ON player WHERE player.name == 'Tony Parker' YIELD id(vertex) as dst, vertex AS v; \ + $b = GO FROM 'Tony Parker', 'Manu Ginobili' OVER like YIELD id($^) as src, id($$) as vid, edge AS e2; \ + YIELD $b.vid AS vid, $a.v AS v, $b.e2 AS e2 FROM $a INNER JOIN $b ON $a.dst == $b.src; +``` + +示例二：结合`LOOKUP`和`FETCH PROP`子句，查找名为`Tony Parker`的球员和他的朋友之间的`like`关系。 + +1. 通过以下查询在'player'表中查找名为'Tony Parker'的球员：LOOKUP ON player WHERE player.name == 'Tony Parker' YIELD id(vertex) as src, vertex AS v。该查询将返回一个包含Tony Parker的顶点ID（src）和该顶点的所有属性（v）的结果。 +2. 使用以下查询在'like'边缘上查找名为'Tony Parker'的球员和名为'Tim Duncan'的球员之间的关系：FETCH PROP ON like 'Tony Parker'->'Tim Duncan' YIELD src(edge) as src, edge as e。该查询将返回一个包含如上边缘的起始点(src)和边缘本身的属性(e)的结果。 +3. 使用 INNER JOIN 子句将第一步和第二步的查询结果联接在一起，以便检索统一结果，包括源点 （src）、源点的属性（v）和找到的like边缘（e）。YIELD $a.src AS src, $a.v AS v, $b.e AS e FROM $a INNER JOIN $b ON $a.src == $b.src。最终的结果是一个包含查询结果的表，其中包括来自两个查询的所有变量（src、v和e）。 + +```ngql +nebula> $a = LOOKUP ON player WHERE player.name == 'Tony Parker' YIELD id(vertex) as src, vertex AS v; \ + $b = FETCH PROP ON like 'Tony Parker'->'Tim Duncan' YIELD src(edge) as src, edge as e; \ + YIELD $a.src AS src, $a.v AS v, $b.e AS e FROM $a INNER JOIN $b ON $a.src == $b.src; +``` + +示例三：结合`LOOKUP`、`GO`和`FIND PATH`子句，查找名为`Tony Parker`的球员和他的朋友之间的`like`关系。 + +1. 通过名为'Tony Parker'的球员的名称查找他的ID和属性。 +2. 从刚才查找到的球员ID开始，向like关系方向前进2到5步，并查找所有满足条件的目标顶点（满足条件的目标顶点的年龄大于30）。 +3. 查找所有从a到b之间的路径，并在查询结果中列出路径和目标终点。 +4. 查找从b到a的最短路径，并在查询结果中列出路径和起始点。 +5. 将第三步和第四步的结果合并，并从两个结果中选择所需的列作为最终结果。具体地，将第三步中找到的从A到B的路径存储在变量$c.forwardPath中，将第二步找到的目标节点的ID存储在变量$c.end中，将第四步中的从B到A的路径存储在变量$d.backwordPath中。最后，从$c和$d中选择需要的列列出最终结果。 + +```ngql +nebula> $a = LOOKUP ON player WHERE player.name == 'Tony Parker' YIELD id(vertex) as src, vertex AS v; \ + $b = GO 2 TO 5 STEPS FROM $a.src OVER like WHERE $$.player.age > 30 YIELD id($$) AS dst; \ + $c = (FIND ALL PATH FROM $a.src TO $b.dst OVER like YIELD path AS p | YIELD $-.p AS forward, id(endNode($-.p)) AS dst); \ + $d = (FIND SHORTEST PATH FROM $c.dst TO $a.src OVER like YIELD path AS p | YIELD $-.p AS p, id(startNode($-.p)) AS src); \ + YIELD $c.forward AS forwardPath, $c.dst AS end, $d.p AS backwordPath FROM $c INNER JOIN $d ON $c.dst == $d.src; +``` + \ No newline at end of file diff --git a/mkdocs.yml b/mkdocs.yml index 9b5f96a74ab..ae78bafe14e 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -505,6 +505,7 @@ nav: - YIELD: 3.ngql-guide/8.clauses-and-options/yield.md - WITH: 3.ngql-guide/8.clauses-and-options/with.md - UNWIND: 3.ngql-guide/8.clauses-and-options/unwind.md + - INNER JOIN: 3.ngql-guide/8.clauses-and-options/joins.md - 图空间语句: - CREATE SPACE: 3.ngql-guide/9.space-statements/1.create-space.md From 294fd763e6578c706a529f85cf488fd25c60b892 Mon Sep 17 00:00:00 2001 From: Abby <78209557+abby-cyber@users.noreply.github.com> Date: Mon, 21 Aug 2023 12:01:49 +0800 Subject: [PATCH 2/5] Update joins.md --- .../8.clauses-and-options/joins.md | 24 ++++--------------- 1 file changed, 5 insertions(+), 19 deletions(-) diff --git a/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md b/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md index 486e43bcf2d..035c433295f 100644 --- a/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md +++ b/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md @@ -15,18 +15,14 @@ FROM INNER JOIN ON ## 使用说明 -- 必须使用`YIELD`子句指定返回的列，并且`YIELD`子句放置在`INNER JOIN`子句之前。 +- 必须使用`YIELD`子句指定返回的列，并且`YIELD`子句需放置在`INNER JOIN`子句之前。 - `INNER JOIN`子句必须包含`ON`子句，`ON`子句指定了连接条件。连接条件只支持等值连接（即`==`）。 - ``和``是要连接的两个表，两表名不能相同。 - 可以使用自定义变量来指定表格名。详情参见[使用自定义变量](../3.ngql-guide/4.variable-and-composite-queries/2.user-defined-variables.md)。 ## 使用示例 -示例一：结合`LOOKUP`和`GO`子句，查找名为`Tony Parker`的球员和他的朋友之间的`like`关系。 - -1. 先查找名为`Tony Parker`的球员的ID。 -2. 再查找名为`Tony Parker`和`Manu Ginobili`的球员之间是否存在`like`关系，如果存在，则将两个球员的 ID 和`like`关系返回。 -3. 最后的将两次查询的结果合并在一起，以便获取最终的结果。 +示例一：结合`LOOKUP`和`GO`子句，使用`INNER JOIN`获取`Tony Parker`的球员和他的朋友之间关系的信息。 ```ngql nebula> $a = LOOKUP ON player WHERE player.name == 'Tony Parker' YIELD id(vertex) as dst, vertex AS v; \ @@ -34,11 +30,7 @@ nebula> $a = LOOKUP ON player WHERE player.name == 'Tony Parker' YIELD id(vertex YIELD $b.vid AS vid, $a.v AS v, $b.e2 AS e2 FROM $a INNER JOIN $b ON $a.dst == $b.src; ``` -示例二：结合`LOOKUP`和`FETCH PROP`子句，查找名为`Tony Parker`的球员和他的朋友之间的`like`关系。 - -1. 通过以下查询在'player'表中查找名为'Tony Parker'的球员：LOOKUP ON player WHERE player.name == 'Tony Parker' YIELD id(vertex) as src, vertex AS v。该查询将返回一个包含Tony Parker的顶点ID（src）和该顶点的所有属性（v）的结果。 -2. 使用以下查询在'like'边缘上查找名为'Tony Parker'的球员和名为'Tim Duncan'的球员之间的关系：FETCH PROP ON like 'Tony Parker'->'Tim Duncan' YIELD src(edge) as src, edge as e。该查询将返回一个包含如上边缘的起始点(src)和边缘本身的属性(e)的结果。 -3. 使用 INNER JOIN 子句将第一步和第二步的查询结果联接在一起，以便检索统一结果，包括源点 （src）、源点的属性（v）和找到的like边缘（e）。YIELD $a.src AS src, $a.v AS v, $b.e AS e FROM $a INNER JOIN $b ON $a.src == $b.src。最终的结果是一个包含查询结果的表，其中包括来自两个查询的所有变量（src、v和e）。 +示例二：结合`LOOKUP`和`FETCH PROP`子句，使用`INNER JOIN`获取`Tony Parker`和`Tim Duncan`之间的关系的信息。 ```ngql nebula> $a = LOOKUP ON player WHERE player.name == 'Tony Parker' YIELD id(vertex) as src, vertex AS v; \ @@ -46,19 +38,13 @@ nebula> $a = LOOKUP ON player WHERE player.name == 'Tony Parker' YIELD id(vertex YIELD $a.src AS src, $a.v AS v, $b.e AS e FROM $a INNER JOIN $b ON $a.src == $b.src; ``` -示例三：结合`LOOKUP`、`GO`和`FIND PATH`子句，查找名为`Tony Parker`的球员和他的朋友之间的`like`关系。 - -1. 通过名为'Tony Parker'的球员的名称查找他的ID和属性。 -2. 从刚才查找到的球员ID开始，向like关系方向前进2到5步，并查找所有满足条件的目标顶点（满足条件的目标顶点的年龄大于30）。 -3. 查找所有从a到b之间的路径，并在查询结果中列出路径和目标终点。 -4. 查找从b到a的最短路径，并在查询结果中列出路径和起始点。 -5. 将第三步和第四步的结果合并，并从两个结果中选择所需的列作为最终结果。具体地，将第三步中找到的从A到B的路径存储在变量$c.forwardPath中，将第二步找到的目标节点的ID存储在变量$c.end中，将第四步中的从B到A的路径存储在变量$d.backwordPath中。最后，从$c和$d中选择需要的列列出最终结果。 +示例三：结合`LOOKUP`、`GO`和`FIND PATH`子句，查找和`Tony Parker`之间有特定关系的其他球员，以及这些球员和`Tony Parker`之间的最短路径。 ```ngql nebula> $a = LOOKUP ON player WHERE player.name == 'Tony Parker' YIELD id(vertex) as src, vertex AS v; \ $b = GO 2 TO 5 STEPS FROM $a.src OVER like WHERE $$.player.age > 30 YIELD id($$) AS dst; \ $c = (FIND ALL PATH FROM $a.src TO $b.dst OVER like YIELD path AS p | YIELD $-.p AS forward, id(endNode($-.p)) AS dst); \ $d = (FIND SHORTEST PATH FROM $c.dst TO $a.src OVER like YIELD path AS p | YIELD $-.p AS p, id(startNode($-.p)) AS src); \ - YIELD $c.forward AS forwardPath, $c.dst AS end, $d.p AS backwordPath FROM $c INNER JOIN $d ON $c.dst == $d.src; + YIELD $c.forward AS forwardPath, $c.dst AS end, $d.p AS backwordPath FROM $c INNER JOIN $d ON $c.dst == $d.src; ``` \ No newline at end of file From d709cf41574880c8a6ef89a48d1365c28a14cd85 Mon Sep 17 00:00:00 2001 From: "abby.huang" <78209557+abby-cyber@users.noreply.github.com> Date: Mon, 21 Aug 2023 14:19:23 +0800 Subject: [PATCH 3/5] Update docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md Co-authored-by: cooper-lzy <78672629+cooper-lzy@users.noreply.github.com> --- docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md b/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md index 035c433295f..7bcca7cefe6 100644 --- a/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md +++ b/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md @@ -1,6 +1,6 @@ # INNER JOIN -`INNER JOIN`是一种连接查询，用于将两个表关联在一起，只返回在两个表中都存在的行。在 NebulaGraph 中，`INNER JOIN`子句可以用来在两个表格之间进行连接查询，以获取更加复杂的查询结果。 +`INNER JOIN`是一种连接查询，用于将两个表关联在一起，只返回在两个表中都存在的行。在{{nebula.name}}中，`INNER JOIN`子句可以用来在两个表之间进行连接查询，以获取更加复杂的查询结果。 ## openCypher 兼容性 From 60f16d687e5946892d2fd3b33d7d9d8d5fdc35e0 Mon Sep 17 00:00:00 2001 From: Abby <78209557+abby-cyber@users.noreply.github.com> Date: Mon, 21 Aug 2023 17:54:18 +0800 Subject: [PATCH 4/5] Update joins.md --- .../8.clauses-and-options/joins.md | 56 +++++++++++++++---- 1 file changed, 45 insertions(+), 11 deletions(-) diff --git a/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md b/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md index 035c433295f..5156f88b172 100644 --- a/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md +++ b/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md @@ -1,6 +1,6 @@ # INNER JOIN -`INNER JOIN`是一种连接查询，用于将两个表关联在一起，只返回在两个表中都存在的行。在 NebulaGraph 中，`INNER JOIN`子句可以用来在两个表格之间进行连接查询，以获取更加复杂的查询结果。 +`INNER JOIN`是一种连接查询。它基于两个表之间的共同列值进行匹配，并返回满足条件的记录。`INNER JOIN`通常用于根据关联列的值来创建一个包含两个表的结果集。在{{nebula.name}}中，`INNER JOIN`子句可以用来在两个表之间进行连接查询，以获取更加复杂的查询结果。 ## openCypher 兼容性 @@ -16,35 +16,69 @@ FROM INNER JOIN ON ## 使用说明 - 必须使用`YIELD`子句指定返回的列，并且`YIELD`子句需放置在`INNER JOIN`子句之前。 -- `INNER JOIN`子句必须包含`ON`子句，`ON`子句指定了连接条件。连接条件只支持等值连接（即`==`）。 +- `INNER JOIN`子句必须包含`ON`子句，`ON`子句指定了连接条件，并且连接条件只支持等值连接（即`==`）。 - ``和``是要连接的两个表，两表名不能相同。 -- 可以使用自定义变量来指定表格名。详情参见[使用自定义变量](../3.ngql-guide/4.variable-and-composite-queries/2.user-defined-variables.md)。 +- 使用自定义变量来指定表格名。详情参见[使用自定义变量](../3.ngql-guide/4.variable-and-composite-queries/2.user-defined-variables.md)。 +- 在 3.6.0 版本之前的 nGQL 语法中，只有`GO`语句支持使用`INNER JOIN`子句。在 3.6.0 版本及之后的 nGQL 语法中，`FETCH`、`LOOKUP`、`FIND PATH`和`GET SUBGRAPH`语句都可使用`INNER JOIN`子句。 ## 使用示例 -示例一：结合`LOOKUP`和`GO`子句，使用`INNER JOIN`获取`Tony Parker`的球员和他的朋友之间关系的信息。 +以下示例介绍如何通过`INNER JOIN`关联 nGQL 语句中的两个查询结果。 + +示例一：通过`INNER JOIN`将第一个`LOOKUP`查询中的结果`dst`列（`Tony Parker`的 ID `player101`）和第二个`GO`查询中的结果`src`列（`player101`和`player125`两个 ID）进行匹配。匹配的结果集为两个查询结果中`dst`和`src`列都包含的`player101`，基于这个`player101`匹配的结果，然后通过`YIELD $b.vid AS vid, $a.v AS v, $b.e2 AS e2`返回最终查询结果。 ```ngql nebula> $a = LOOKUP ON player WHERE player.name == 'Tony Parker' YIELD id(vertex) as dst, vertex AS v; \ - $b = GO FROM 'Tony Parker', 'Manu Ginobili' OVER like YIELD id($^) as src, id($$) as vid, edge AS e2; \ + $b = GO FROM 'player101', 'player125' OVER follow YIELD id($^) as src, id($$) as vid, edge AS e2; \ YIELD $b.vid AS vid, $a.v AS v, $b.e2 AS e2 FROM $a INNER JOIN $b ON $a.dst == $b.src; ++-------------+-----------------------------------------------------+----------------------------------------------------+ +| vid | v | e2 | ++-------------+-----------------------------------------------------+----------------------------------------------------+ +| "player100" | ("player101" :player{age: 36, name: "Tony Parker"}) | [:follow "player101"->"player100" @0 {degree: 95}] | +| "player102" | ("player101" :player{age: 36, name: "Tony Parker"}) | [:follow "player101"->"player102" @0 {degree: 90}] | +| "player125" | ("player101" :player{age: 36, name: "Tony Parker"}) | [:follow "player101"->"player125" @0 {degree: 95}] | ++-------------+-----------------------------------------------------+----------------------------------------------------+ ``` -示例二：结合`LOOKUP`和`FETCH PROP`子句，使用`INNER JOIN`获取`Tony Parker`和`Tim Duncan`之间的关系的信息。 +示例二：通过`INNER JOIN`将第一个`LOOKUP`查询中的结果`src`列（`Tony Parker`的 ID `player101`）和第二个`FETCH`查询中的结果`src`列（`player101`到`player100`的起点 ID `player101`）进行匹配。匹配的结果集为都包含的`player101`，基于这个`player101`匹配的结果，然后通过`YIELD $a.src AS src, $a.v AS v, $b.e AS e`返回最终查询结果。 ```ngql nebula> $a = LOOKUP ON player WHERE player.name == 'Tony Parker' YIELD id(vertex) as src, vertex AS v; \ - $b = FETCH PROP ON like 'Tony Parker'->'Tim Duncan' YIELD src(edge) as src, edge as e; \ + $b = FETCH PROP ON follow 'player101'->'player100' YIELD src(edge) as src, edge as e; \ YIELD $a.src AS src, $a.v AS v, $b.e AS e FROM $a INNER JOIN $b ON $a.src == $b.src; ++-------------+-----------------------------------------------------+----------------------------------------------------+ +| src | v | e | ++-------------+-----------------------------------------------------+----------------------------------------------------+ +| "player101" | ("player101" :player{age: 36, name: "Tony Parker"}) | [:follow "player101"->"player100" @0 {degree: 95}] | ++-------------+-----------------------------------------------------+----------------------------------------------------+ ``` -示例三：结合`LOOKUP`、`GO`和`FIND PATH`子句，查找和`Tony Parker`之间有特定关系的其他球员，以及这些球员和`Tony Parker`之间的最短路径。 +示例三：使用`INNER JOIN`关联`LOOKUP`、`GO`和`FIND PATH`子句的查询的过程示例步骤： + +1. 通过`LOOKUP ON`语句，先对`player`表进行查询，找到名为`Tony Parker`的球员顶点，并将其 ID 和属性存储到`$a.src`和`v`列中。 +2. 再通过`GO`查找从`$a.src`节点出发经过`follow`边往外走 2-5 步的球员节点，其中要求这些节点对应的`player`点年龄大于 30 岁，返回这些节点的 ID，并将它们存储在`$b.dst`列中。 +3. 然后通过`FIND ALL PATH`语句，查找从`$a.src`到`$b.dst`的沿`follow`所有路径，并返回路径`$c.p`以及路径中的终点`$c.dst`。 +4. 最后通过`FIND SHORTEST PATH`语句，查找从`$c.dst`到`$a.src`的最短路径，并返回路径`$d.p`和路径起点`$d.src`。 +5. 使用`INNER JOIN`将 3 和 4 中得到的结果联接起来，匹配`$c.dst`和`$d.src`列，为每个联接匹配的记录返回`YIELD $c.forward AS forwardPath, $c.dst AS end, $d.p AS backwordPath`。 + ```ngql nebula> $a = LOOKUP ON player WHERE player.name == 'Tony Parker' YIELD id(vertex) as src, vertex AS v; \ - $b = GO 2 TO 5 STEPS FROM $a.src OVER like WHERE $$.player.age > 30 YIELD id($$) AS dst; \ - $c = (FIND ALL PATH FROM $a.src TO $b.dst OVER like YIELD path AS p | YIELD $-.p AS forward, id(endNode($-.p)) AS dst); \ - $d = (FIND SHORTEST PATH FROM $c.dst TO $a.src OVER like YIELD path AS p | YIELD $-.p AS p, id(startNode($-.p)) AS src); \ + $b = GO 2 TO 5 STEPS FROM $a.src OVER follow WHERE $$.player.age > 30 YIELD id($$) AS dst; \ + $c = (FIND ALL PATH FROM $a.src TO $b.dst OVER follow YIELD path AS p | YIELD $-.p AS forward, id(endNode($-.p)) AS dst); \ + $d = (FIND SHORTEST PATH FROM $c.dst TO $a.src OVER follow YIELD path AS p | YIELD $-.p AS p, id(startNode($-.p)) AS src); \ YIELD $c.forward AS forwardPath, $c.dst AS end, $d.p AS backwordPath FROM $c INNER JOIN $d ON $c.dst == $d.src; ++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------+-----------------------------------------------------------------------------+ +| forwardPath | end | backwordPath | ++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------+-----------------------------------------------------------------------------+ +| <("player101")-[:follow@0 {}]->("player102")> | "player102" | <("player102")-[:follow@0 {}]->("player101")> | +| <("player101")-[:follow@0 {}]->("player100")-[:follow@0 {}]->("player101")-[:follow@0 {}]->("player102")> | "player102" | <("player102")-[:follow@0 {}]->("player101")> | +| <("player101")-[:follow@0 {}]->("player125")> | "player125" | <("player125")-[:follow@0 {}]->("player100")-[:follow@0 {}]->("player101")> | +| <("player101")-[:follow@0 {}]->("player100")-[:follow@0 {}]->("player125")> | "player125" | <("player125")-[:follow@0 {}]->("player100")-[:follow@0 {}]->("player101")> | +| <("player101")-[:follow@0 {}]->("player100")-[:follow@0 {}]->("player101")-[:follow@0 {}]->("player125")> | "player125" | <("player125")-[:follow@0 {}]->("player100")-[:follow@0 {}]->("player101")> | +| <("player101")-[:follow@0 {}]->("player102")-[:follow@0 {}]->("player100")-[:follow@0 {}]->("player125")> | "player125" | <("player125")-[:follow@0 {}]->("player100")-[:follow@0 {}]->("player101")> | +| <("player101")-[:follow@0 {}]->("player102")-[:follow@0 {}]->("player101")-[:follow@0 {}]->("player125")> | "player125" | <("player125")-[:follow@0 {}]->("player100")-[:follow@0 {}]->("player101")> | +... ++-----------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------+-----------------------------------------------------------------------------+ ``` \ No newline at end of file From 5ce30ae902206b1d2dd20678db29a120a31a426e Mon Sep 17 00:00:00 2001 From: Abby <78209557+abby-cyber@users.noreply.github.com> Date: Mon, 21 Aug 2023 18:45:47 +0800 Subject: [PATCH 5/5] Update joins.md --- docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md | 10 +++++++--- 1 file changed, 7 insertions(+), 3 deletions(-) diff --git a/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md b/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md index 5156f88b172..7415a4d43f8 100644 --- a/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md +++ b/docs-2.0/3.ngql-guide/8.clauses-and-options/joins.md @@ -1,6 +1,10 @@ # INNER JOIN -`INNER JOIN`是一种连接查询。它基于两个表之间的共同列值进行匹配，并返回满足条件的记录。`INNER JOIN`通常用于根据关联列的值来创建一个包含两个表的结果集。在{{nebula.name}}中，`INNER JOIN`子句可以用来在两个表之间进行连接查询，以获取更加复杂的查询结果。 +`INNER JOIN`是一种连接查询。它基于两个表之间的共同列值进行匹配，并返回满足条件的记录。`INNER JOIN`通常用于根据关联列的值来创建一个包含两个表的结果集。在{{nebula.name}}中，可以显示地使用`INNER JOIN`子句在两个表之间进行连接查询，以获取更加复杂的查询结果。 + +!!! note + + 在 nGQL 语句中，`GO`的多跳查询隐式地使用了`INNER JOIN`子句。例如，`GO 1 TO 2 STEPS FROM "player101" OVER follow YIELD $$.player.name AS name, $$.player.age AS age`语句中，`GO`子句隐式地使用了`INNER JOIN`子句，将从`player101`出发沿`follow`边第一步查询的结果列和第二步查询的起点列进行匹配，然后基于匹配结果返回`name`和`age`。 ## openCypher 兼容性 @@ -16,10 +20,10 @@ FROM INNER JOIN ON ## 使用说明 - 必须使用`YIELD`子句指定返回的列，并且`YIELD`子句需放置在`INNER JOIN`子句之前。 +- 使用`FROM`子句指定要连接的两个表。 - `INNER JOIN`子句必须包含`ON`子句，`ON`子句指定了连接条件，并且连接条件只支持等值连接（即`==`）。 - ``和``是要连接的两个表，两表名不能相同。 -- 使用自定义变量来指定表格名。详情参见[使用自定义变量](../3.ngql-guide/4.variable-and-composite-queries/2.user-defined-variables.md)。 -- 在 3.6.0 版本之前的 nGQL 语法中，只有`GO`语句支持使用`INNER JOIN`子句。在 3.6.0 版本及之后的 nGQL 语法中，`FETCH`、`LOOKUP`、`FIND PATH`和`GET SUBGRAPH`语句都可使用`INNER JOIN`子句。 +- 使用自定义变量来指定表名。详情参见[使用自定义变量](../3.ngql-guide/4.variable-and-composite-queries/2.user-defined-variables.md)。 ## 使用示例