As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # Suporte nativo para etapas do Gremlin no Amazon Neptune No momento, o mecanismo do Amazon Neptune não tem suporte nativo completo para todas as etapas do Gremlin, conforme explicado em [Ajustar consultas do Gremlin](gremlin-traversal-tuning.md). O suporte atual se divide em quatro categorias: + [Etapas do Gremlin que sempre podem ser convertidas em operações nativas do mecanismo do Neptune](#gremlin-steps-always) + [Etapas do Gremlin que sempre podem ser convertidas em operações nativas do mecanismo do Neptune em alguns casos](#gremlin-steps-sometimes) + [Etapas do Gremlin que nunca são convertidas em operações nativas do mecanismo do Neptune](#gremlin-steps-never) + [Etapas do Gremlin não compatíveis com o Neptune](#neptune-gremlin-steps-unsupported) ## Etapas do Gremlin que sempre podem ser convertidas em operações nativas do mecanismo do Neptune Muitas etapas do Gremlin podem ser convertidas em operações nativas do mecanismo do Neptune, desde que atendam às seguintes condições: + Elas não são precedidas na consulta por uma etapa que não pode ser convertida. + A etapa principal, se houver, pode ser convertida. + Todos os percursos secundários, se houver, podem ser convertidos. As seguintes etapas do Gremlin podem ser convertidas em operações nativas do mecanismo do Neptune se elas atenderem a essas condições: + [and( )](http://tinkerpop.apache.org/docs/current/reference/#and-step) + [as( )](http://tinkerpop.apache.org/docs/current/reference/#as-step) + [count( )](http://tinkerpop.apache.org/docs/current/reference/#count-step) + [E( )](http://tinkerpop.apache.org/docs/current/reference/#graph-step) + [emit( )](http://tinkerpop.apache.org/docs/current/reference/#emit-step) + [explain( )](http://tinkerpop.apache.org/docs/current/reference/#explain-step) + [group( )](http://tinkerpop.apache.org/docs/current/reference/#group-step) + [groupCount( )](http://tinkerpop.apache.org/docs/current/reference/#groupcount-step) + [identity( )](http://tinkerpop.apache.org/docs/current/reference/#identity-step) + [is( )](http://tinkerpop.apache.org/docs/current/reference/#is-step) + [key( )](http://tinkerpop.apache.org/docs/current/reference/#key-step) + [label( )](http://tinkerpop.apache.org/docs/current/reference/#label-step) + [limit( )](http://tinkerpop.apache.org/docs/current/reference/#limit-step) + [local( )](http://tinkerpop.apache.org/docs/current/reference/#local-step) + [loops( )](http://tinkerpop.apache.org/docs/current/reference/#loops-step) + [not( )](http://tinkerpop.apache.org/docs/current/reference/#not-step) + [or( )](http://tinkerpop.apache.org/docs/current/reference/#or-step) + [profile( )](http://tinkerpop.apache.org/docs/current/reference/#profile-step) + [properties( )](http://tinkerpop.apache.org/docs/current/reference/#properties-step) + [subgraph( )](http://tinkerpop.apache.org/docs/current/reference/#subgraph-step) + [until( )](http://tinkerpop.apache.org/docs/current/reference/#until-step) + [V( )](http://tinkerpop.apache.org/docs/current/reference/#graph-step) + [value( )](http://tinkerpop.apache.org/docs/current/reference/#value-step) + [valueMap( )](http://tinkerpop.apache.org/docs/current/reference/#valuemap-step) + [values( )](http://tinkerpop.apache.org/docs/current/reference/#values-step) ## Etapas do Gremlin que sempre podem ser convertidas em operações nativas do mecanismo do Neptune em alguns casos Algumas etapas do Gremlin podem ser convertidas em operações nativas do mecanismo do Neptune em algumas situações, mas não em outras: + [addE ()](http://tinkerpop.apache.org/docs/current/reference/#addedge-step): a etapa `addE()` geralmente pode ser convertida em uma operação nativa do mecanismo do Neptune, a menos que seja imediatamente seguida por uma etapa `property()` que contenha um percurso como chave. + [addV ()](http://tinkerpop.apache.org/docs/current/reference/#addvertex-step): a etapa `addV()` geralmente pode ser convertida em uma operação nativa do mecanismo do Neptune, a menos que seja imediatamente seguida por uma etapa `property()` que contenham um percurso como chave ou vários rótulos sejam atribuídos. + [aggregate ()](http://tinkerpop.apache.org/docs/current/reference/#store-step): a etapa `aggregate()` geralmente pode ser convertida em uma operação nativa do mecanismo do Neptune, a menos que a etapa seja usada em um percurso secundário ou subpercurso, ou a menos que o valor armazenado seja algo diferente de um vértice, uma borda, um ID, um rótulo ou um valor de propriedade. No exemplo abaixo, `aggregate()` não é convertido porque está sendo usado em um percurso secundário: ``` g.V().has('code','ANC').as('a') .project('flights').by(select('a') .outE().aggregate('x')) ``` Nesse exemplo, aggregate() não é convertido porque o item armazenado é o `min()` de um valor: ``` g.V().has('code','ANC').outE().aggregate('x').by(values('dist').min()) ``` + [barrier( )](http://tinkerpop.apache.org/docs/current/reference/#barrier-step): a etapa `barrier()` geralmente pode ser convertida em uma operação nativa do mecanismo do Neptune, a menos que a etapa seguinte não seja convertida. + [cap( )](http://tinkerpop.apache.org/docs/current/reference/#cap-step): o único caso em que a etapa `cap()` é convertida é quando ela é combinada com a etapa `unfold()` para gerar uma versão desdobrada de um agregado de valores de vértice, borda, ID ou propriedade. Neste exemplo, `cap()` será convertido porque é seguido por `.unfold()`: ``` g.V().has('airport','country','IE').aggregate('airport').limit(2) .cap('airport').unfold() ``` No entanto, se você remover o `.unfold()`, `cap()` não será convertido: ``` g.V().has('airport','country','IE').aggregate('airport').limit(2) .cap('airport') ``` + [coalesce ()](http://tinkerpop.apache.org/docs/current/reference/#coalesce-step) [— O único caso em que a `coalesce()` etapa é convertida é quando ela segue o [padrão Upsert](http://tinkerpop.apache.org/docs/current/recipes/#element-existence) recomendado na página de receitas. TinkerPop ](http://tinkerpop.apache.org/docs/current/recipes/) Outros padrões coalesce() não são permitidos. A conversão é limitada ao caso em que todos os percursos secundários podem ser convertidos, todos eles produzem o mesmo tipo de saída (vértice, borda, ID, valor, chave ou rótulo), percorrem um novo elemento e não contêm a etapa `repeat()`. + [constant( )](http://tinkerpop.apache.org/docs/current/reference/#constant-step): a etapa constant() no momento só será convertida se for usada em uma parte `sack().by()` de um percurso para atribuir um valor constante, como este: ``` g.V().has('code','ANC').sack(assign).by(constant(10)).out().limit(2) ``` + [cyclicPath( )](http://tinkerpop.apache.org/docs/current/reference/#cyclicpath-step): em geral, a etapa `cyclicPath()` pode ser convertida em uma operação nativa do mecanismo do Neptune, a menos que ela seja usada com moduladores `by()`, `from()` ou `to()`. Nas seguintes consultas, por exemplo, `cyclicPath()` não é convertida: ``` 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( )](http://tinkerpop.apache.org/docs/current/reference/#drop-step): em geral, a etapa `drop()` pode ser convertida em uma operação nativa do mecanismo do Neptune, a menos que ela seja usada dentro de uma etapa `sideEffect(` ou `optional()`. + [fold ()](http://tinkerpop.apache.org/docs/current/reference/#fold-step) — Existem apenas duas situações em que a etapa fold () pode ser convertida, a saber, quando é usada no [padrão Upsert](http://tinkerpop.apache.org/docs/current/recipes/#element-existence) recomendado na [página de TinkerPop receitas](http://tinkerpop.apache.org/docs/current/recipes/) e quando é usada em um `group().by()` contexto como este: ``` g.V().has('code','ANC').out().group().by().by(values('code', 'city').fold()) ``` + [has()](http://tinkerpop.apache.org/docs/current/reference/#has-step): etapa has() geralmente pode ser convertida em uma operação nativa do mecanismo do Neptune, desde que as consultas com “T” usem o predicado “P.eq”, “P.neq” ou “P.contains”. Variações esperadas de has() implicam que essas instâncias de “P” também são convertidas em nativas, como “hasId('id1234')", que é equivalente a “has(eq, T.id, 'id1234')”. + [id( )](http://tinkerpop.apache.org/docs/current/reference/#id-step): a etapa `id()` é convertida, a menos que seja usada em uma propriedade, como esta: ``` g.V().has('code','ANC').properties('code').id() ``` + [mergeE()](https://tinkerpop.apache.org/docs/current/reference/#mergeedge-step): a etapa `mergeE()` pode ser convertida em uma operação de mecanismo nativa do Neptune se os parâmetros (a condição de merge, `onCreate` e `onMatch`) forem constantes (`null`, um `Map` constante, ou `select()` de um `Map`). Todos os exemplos em [bordas ascendentes](https://docs.aws.amazon.com//neptune/latest/userguide/gremlin-efficient-upserts.html#gremlin-upserts-edges) podem ser convertidos. + [mergeV()](https://tinkerpop.apache.org/docs/current/reference/#mergevertex-step): a etapa mergeV() pode ser convertida em uma operação de mecanismo nativa do Neptune se os parâmetros (a condição de merge, `onCreate` e `onMatch`) forem constantes (`null`, um `Map` constante, ou `select()` de um `Map`). Todos os exemplos em [vértices ascendentes](https://docs.aws.amazon.com//neptune/latest/userguide/gremlin-efficient-upserts.html#gremlin-upserts-vertices) podem ser convertidos. + [order( )](http://tinkerpop.apache.org/docs/current/reference/#order-step): em geral, a etapa `order()` pode ser convertida em uma operação nativa do mecanismo do Neptune, a menos que o seguinte seja verdadeiro: + A etapa `order()` está dentro de um percurso secundário aninhado, desta forma: ``` g.V().has('code','ANC').where(V().out().order().by(id)) ``` + A ordenação local está sendo usada, por exemplo, com `order(local)`. + Um comparador personalizado está sendo usado na modulação `by()` pela qual ordenar. Um exemplo é este uso de `sack()`: ``` g.withSack(0). V().has('code','ANC'). repeat(outE().sack(sum).by('dist').inV()).times(2).limit(10). order().by(sack()) ``` + Há várias ordenações no mesmo elemento. + [project( )](http://tinkerpop.apache.org/docs/current/reference/#project-step): em geral, a etapa `project()` pode ser convertida em uma operação nativa do mecanismo do Neptune, a menos que o número de declarações `by()` após a `project()` não corresponda ao número de rótulos especificado, como aqui: ``` g.V().has('code','ANC').project('x', 'y').by(id) ``` + [range( )](http://tinkerpop.apache.org/docs/current/reference/#range-step): a etapa `range()` só é convertida quando a extremidade inferior do intervalo em questão é zero (por exemplo, `range(0,3)`). + [repeat( )](http://tinkerpop.apache.org/docs/current/reference/#repeat-step): em geral, a etapa `repeat()` pode ser convertida em uma operação nativa do mecanismo do Neptune, a menos que esteja aninhada em outra etapa `repeat()`, da seguinte forma: ``` g.V().has('code','ANC').repeat(out().repeat(out()).times(2)).times(2) ``` + [sack( )](http://tinkerpop.apache.org/docs/current/reference/#sack-step): em geral, a etapa `sack()` pode ser convertida em uma operação nativa do mecanismo do Neptune, exceto nos seguintes casos: + Se um operador sack não numérico estiver sendo usado. + Se um operador sack numérico diferente de `+`, `-`, `mult`, `div`, `min` e `max` estiver sendo usado. + Se `sack()` for usado dentro de uma etapa `where()` para filtrar com base em um valor de sack, como aqui: ``` g.V().has('code','ANC').sack(assign).by(values('code')).where(sack().is('ANC')) ``` + [sum( )](http://tinkerpop.apache.org/docs/current/reference/#sum-step): em geral, a etapa `sum()` pode ser convertida em uma operação nativa do mecanismo do Neptune, mas não quando usada para calcular uma soma global, como esta: ``` g.V().has('code','ANC').outE('routes').values('dist').sum() ``` + [union( )](http://tinkerpop.apache.org/docs/current/reference/#union-step): a etapa `union()` pode ser convertida em uma operação nativa do mecanismo do Neptune, desde que seja a última etapa da consulta, exceto a etapa do terminal. + [unfold ()](http://tinkerpop.apache.org/docs/current/reference/#unfold-step) — A `unfold()` etapa só pode ser convertida em uma operação nativa do Neptune Engine quando usada [no padrão Upsert](http://tinkerpop.apache.org/docs/current/recipes/#element-existence) recomendado na TinkerPop página de [receitas](http://tinkerpop.apache.org/docs/current/recipes/) e quando usada junto com esta: `cap()` ``` g.V().has('airport','country','IE').aggregate('airport').limit(2) .cap('airport').unfold() ``` + [where( )](http://tinkerpop.apache.org/docs/current/reference/#where-step): em geral, a etapa `where()` pode ser convertida em uma operação nativa do mecanismo do Neptune, exceto nos seguintes casos: + Quando as modulações by() são usadas, desta forma: ``` g.V().hasLabel('airport').as('a') .where(gt('a')).by('runways') ``` + Quando operadores de comparação diferentes de `eq`, `neq`, `within` e `without` são usados. + Quando agregações fornecidas pelo usuário são usadas. ## Etapas do Gremlin que nunca são convertidas em operações nativas do mecanismo do Neptune As seguintes etapas do Gremlin são compatíveis com o Neptune, mas nunca são convertidas em operações nativas do mecanismo do Neptune. Em vez disso, elas são executadas pelo servidor do Gremlin. + [choose( )](http://tinkerpop.apache.org/docs/current/reference/#choose-step) + [coin( )](http://tinkerpop.apache.org/docs/current/reference/#coin-step) + [inject( )](http://tinkerpop.apache.org/docs/current/reference/#inject-step) + [match( )](http://tinkerpop.apache.org/docs/current/reference/#match-step) + [math( )](http://tinkerpop.apache.org/docs/current/reference/#math-step) + [max( )](http://tinkerpop.apache.org/docs/current/reference/#max-step) + [mean( )](http://tinkerpop.apache.org/docs/current/reference/#mean-step) + [min( )](http://tinkerpop.apache.org/docs/current/reference/#min-step) + [option( )](http://tinkerpop.apache.org/docs/current/reference/#option-step) + [optional( )](http://tinkerpop.apache.org/docs/current/reference/#optional-step) + [path( )](http://tinkerpop.apache.org/docs/current/reference/#path-step) + [propertyMap( )](http://tinkerpop.apache.org/docs/current/reference/#propertymap-step) + [sample( )](http://tinkerpop.apache.org/docs/current/reference/#sample-step) + [skip( )](http://tinkerpop.apache.org/docs/current/reference/#skip-step) + [tail( )](http://tinkerpop.apache.org/docs/current/reference/#tail-step) + [timeLimit( )](http://tinkerpop.apache.org/docs/current/reference/#timelimit-step) + [tree( )](http://tinkerpop.apache.org/docs/current/reference/#tree-step) ## Etapas do Gremlin não compatíveis com o Neptune As etapas do Gremlin a seguir não são de forma nenhuma compatíveis com o Neptune. Na maioria dos casos, o motivo disso é que elas exigem um `GraphComputer`, que não é aceito pelo Neptune no momento. + [connectedComponent( )](http://tinkerpop.apache.org/docs/current/reference/#connectedcomponent-step) + [io( )](http://tinkerpop.apache.org/docs/current/reference/#io-step) + [shortestPath( )](http://tinkerpop.apache.org/docs/current/reference/#shortestpath-step) + [withComputer( )](http://tinkerpop.apache.org/docs/current/reference/#with-step) + [pageRank( )](http://tinkerpop.apache.org/docs/current/reference/#pagerank-step) + [peerPressure( )](http://tinkerpop.apache.org/docs/current/reference/#peerpressure-step) + [program( )](http://tinkerpop.apache.org/docs/current/reference/#program-step) Na verdade, a etapa `io()` é parcialmente compatível, pois pode ser usada em `read()` partir de um URL, mas não em `write()`.