Amazon Neptune 中的原生 Gremlin 步骤支持

如调整 Gremlin 查询中所述，Amazon Neptune 引擎目前并不完全原生支持所有 Gremlin 步骤。当前支持分为四类：

始终可以转换为原生 Neptune 引擎操作的 Gremlin 步骤
在某些情况下可以转换为原生 Neptune 引擎操作的 Gremlin 步骤
从不转换为原生 Neptune 引擎操作的 Gremlin 步骤
Neptune 中根本不支持的 Gremlin 步骤

始终可以转换为原生 Neptune 引擎操作的 Gremlin 步骤

只要满足以下条件，许多 Gremlin 步骤可以转换为原生 Neptune 引擎操作：

在查询中，它们前面没有无法转换的步骤。
它们的父步骤（如果有）可以转换。
它们的所有子遍历（如果有）都可以转换。

如果满足这些条件，以下 Gremlin 步骤将始终转换为原生 Neptune 引擎操作：

在某些情况下可以转换为原生 Neptune 引擎操作的 Gremlin 步骤

在某些情况下，一些 Gremlin 步骤可以转换为原生 Neptune 引擎操作，但在其它情况下则不可以：

addE( ) – addE() 步骤通常可以转换为原生 Neptune 引擎操作，除非紧随其后的是包含遍历作为键的 property() 步骤。
addV( ) – addV() 步骤通常可以转换为原生 Neptune 引擎操作，除非紧随其后的是包含遍历作为键的 property() 步骤，或者除非分配了多个标签。
aggregate( ) – aggregate() 步骤通常可以转换为原生 Neptune 引擎操作，除非该步骤用于子遍历，或者除非存储的值不是顶点、边缘、id、标签或属性值。

在下面的示例中，未转换 aggregate()，因为它正在子遍历中使用：
```
g.V().has('code','ANC').as('a')
     .project('flights').by(select('a')
     .outE().aggregate('x'))
```
在此示例中，未转换 aggregate()，因为存储的内容是值的 min()：
```
g.V().has('code','ANC').outE().aggregate('x').by(values('dist').min())
```
barrier( ) – barrier() 步骤通常可以转换为原生 Neptune 引擎操作，除非其后的步骤未被转换。
cap( ) – 转换 cap() 步骤的唯一情况是当将它与 unfold() 步骤组合以返回顶点、边缘、id 或属性值聚合的展开版本时。在本例中，cap() 将进行转换，因为它后跟 .unfold()：
```
g.V().has('airport','country','IE').aggregate('airport').limit(2)
     .cap('airport').unfold()
```
但是，如果您移除 .unfold()，则不会转换 cap()：
```
g.V().has('airport','country','IE').aggregate('airport').limit(2)
     .cap('airport')
```
coalesce () — 转换coalesce()步骤的唯一情况是它遵循食谱页面上推荐的 Upsert 模式。TinkerPop 不允许使用其它 coalesce() 模式。转换仅限于以下情况：所有子遍历都可以转换，它们都生成与输出相同的类型（顶点、边缘、id、值、键或标签），它们都遍历到一个新元素，并且它们不包含步骤 repeat()。
constant( ) – 当前，只有在遍历的 sack().by() 部分中使用 constant() 步骤来分配常量值时，才会转换此步骤，如下所示：
```
g.V().has('code','ANC').sack(assign).by(constant(10)).out().limit(2)
```
cyclicPath( ) – cyclicPath() 步骤通常可以转换为原生 Neptune 引擎操作，除非该步骤与 by()、from() 或 to() 调制器结合使用。例如，在以下查询中，未转换 cyclicPath()：
```
g.V().has('code','ANC').as('a').out().out().cyclicPath().by('code')
g.V().has('code','ANC').as('a').out().out().cyclicPath().from('a')
g.V().has('code','ANC').as('a').out().out().cyclicPath().to('a')
```
drop( ) – drop() 步骤通常可以转换为原生 Neptune 引擎操作，除非在 sideEffect() 或 optional() 步骤中使用该步骤。
fold () — 只有两种情况可以转换 fold () 步骤，即在TinkerPop 食谱页面推荐的 Upsert 模式中使用它时，以及group().by()在这样的上下文中使用它时：
```
g.V().has('code','ANC').out().group().by().by(values('code', 'city').fold())
```
has () — 只要带有 “T” 的查询使用谓词 `p.eq`、`p.neq` 或 `p.contains`，`has () `步骤通常可以转换为原生 Neptune 引擎操作。预计 “has ()” 的变体意味着那些 “P” 的实例也要转换为原生实例，例如 `hasid ('id1234') `，它等同于 `has (eq，t.id，'id1234')`。
id( ) – 除非在属性上使用 id() 步骤，否则将转换该步骤，如下所示：
```
g.V().has('code','ANC').properties('code').id()
```
merGee () — 如果参数（合并条件，onMatch和）恒定（null常量select()或 a），则onCreate该mergeE()步骤可以转换为原生 Neptune 引擎操作。Map Map上移边缘中的所有示例都可以转换。
mergeV () — 如果参数（合并条件，onCreate和）恒定（常量或 null a），则可以将 mergeV (onMatch) 步骤转换为原生 Neptune 引擎操作。Map select() Map上置顶点中的所有示例都可以转换。
order( ) – order() 步骤通常可以转换为原生 Neptune 引擎操作，除非满足以下条件之一：
- order() 步骤位于嵌套的子遍历中，如下所示：
```
g.V().has('code','ANC').where(V().out().order().by(id))
```
- 正在使用本地排序，例如使用 order(local)。
- 正在 by() 调制中使用自定义比较器进行排序。一个例子是这样使用 sack()：
```
g.withSack(0).
  V().has('code','ANC').
      repeat(outE().sack(sum).by('dist').inV()).times(2).limit(10).
      order().by(sack())
```
- 同一个元素上有多个排序。
project( ) – project() 步骤通常可以转换为原生 Neptune 引擎操作，除非 project() 后面的 by() 语句数量与指定的标签数量不匹配，如下所示：
```
g.V().has('code','ANC').project('x', 'y').by(id)
```
range( ) - 只有当相关范围的下限为零（例如 range(0,3)）时，才会转换 range() 步骤。
repeat( ) – repeat() 步骤通常可以转换为原生 Neptune 引擎操作，除非它嵌套在另一个 repeat() 步骤中，如下所示：
```
g.V().has('code','ANC').repeat(out().repeat(out()).times(2)).times(2)
```
sack( ) – sack() 步骤通常可以转换为原生 Neptune 引擎操作，但以下情况除外：
- 如果使用的是非数字 sack 运算符。
- 如果使用的是 +、-、mult、div、min 和 max 以外的数字 sack 运算符。
- 如果在 where() 步骤中使用 sack() 来根据 sack 值进行筛选，如下所示：
```
g.V().has('code','ANC').sack(assign).by(values('code')).where(sack().is('ANC'))
```
sum( ) – sum() 步骤通常可以转换为原生 Neptune 引擎操作，但在用于计算全局求和时则不可转换，如下所示：
```
g.V().has('code','ANC').outE('routes').values('dist').sum()
```
union( ) – union() 步骤可以转换为原生 Neptune 引擎操作，只要它是查询中除最终步骤之外的最后一步。
unfold () — 只有在配方页面推荐的 Upsert 模式中使用该unfold()步骤时，以及将其与以下内容一起cap()使用时，才能将其转换为原生 Neptune 引擎操作：TinkerPop
```
g.V().has('airport','country','IE').aggregate('airport').limit(2)
     .cap('airport').unfold()
```
where( ) – where() 步骤通常可以转换为原生 Neptune 引擎操作，但以下情况除外：
- 当使用 by() 调制时，如下所示：
```
g.V().hasLabel('airport').as('a')
     .where(gt('a')).by('runways')
```
- 当使用 eq、neq、within 和 without 以外的比较运算符时。
- 当使用用户提供的聚合时。

从不转换为原生 Neptune 引擎操作的 Gremlin 步骤

Neptune 支持以下 Gremlin 步骤，但它们从不转换为原生 Neptune 引擎操作。相反，它们由 Gremlin 服务器执行。

Neptune 中根本不支持的 Gremlin 步骤

Neptune 根本不支持以下 Gremlin 步骤。在大多数情况下，这是因为它们需要 GraphComputer，而 Neptune 目前不支持。

实际上，io() 步骤得到了部分支持，因为它可以用来从 URL 进行 read()，但不用来 write()。

Javascript 在您的浏览器中被禁用或不可用。

要使用 Amazon Web Services 文档，必须启用 Javascript。请参阅浏览器的帮助页面以了解相关说明。

调整 Gremlin 查询

Gremlin 和 DFE