Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés. # Compatibilidad nativa con pasos de Gremlin en Amazon Neptune El motor de Amazon Neptune actualmente no es totalmente compatible de forma nativa con todos los pasos de Gremlin, como se explica en [Ajuste de las consultas de Gremlin](gremlin-traversal-tuning.md). La compatibilidad actual se divide en cuatro categorías: + [Los pasos de Gremlin que siempre se pueden convertir en operaciones nativas del motor de Neptune](#gremlin-steps-always) + [Pasos de Gremlin que se pueden convertir en operaciones nativas del motor de Neptune en algunos casos](#gremlin-steps-sometimes) + [Pasos de Gremlin que nunca se convierten en operaciones nativas del motor de Neptune](#gremlin-steps-never) + [Pasos de Gremlin que Neptune no admite en absoluto](#neptune-gremlin-steps-unsupported) ## Los pasos de Gremlin que siempre se pueden convertir en operaciones nativas del motor de Neptune Muchos pasos de Gremlin se pueden convertir en operaciones nativas del motor de Neptune siempre que cumplan las siguientes condiciones: + En la consulta no van precedidos de ningún paso que no se pueda convertir. + Su paso principal, si lo hay, se puede convertir. + Todos sus recorridos secundarios, si los hay, se pueden convertir. Los siguientes pasos de Gremlin siempre se convierten en operaciones nativas del motor de Neptune si cumplen esas condiciones: + [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) ## Pasos de Gremlin que se pueden convertir en operaciones nativas del motor de Neptune en algunos casos Algunos pasos de Gremlin se pueden convertir en operaciones nativas del motor de Neptune en algunas situaciones, pero no en otras: + [addE( )](http://tinkerpop.apache.org/docs/current/reference/#addedge-step): el paso `addE()` generalmente se puede convertir en una operación nativa del motor de Neptune, a menos que vaya seguido inmediatamente de un paso `property()` que contenga un recorrido como clave. + [addV( )](http://tinkerpop.apache.org/docs/current/reference/#addvertex-step): el paso `addV()` generalmente se puede convertir en una operación nativa del motor de Neptune, a menos que vaya seguido inmediatamente de un paso `property()` que contenga un recorrido como clave, o a menos que se asignen varias etiquetas. + [aggregate( )](http://tinkerpop.apache.org/docs/current/reference/#store-step): el paso `aggregate()` generalmente se puede convertir en una operación nativa del motor de Neptune, a menos que el paso se utilice en un recorrido secundario o en un subrecorrido, o a menos que el valor que se esté almacenando no sea un vértice, un borde, un identificador, una etiqueta o un valor de propiedad. En el ejemplo siguiente, `aggregate()` no se convierte porque se utiliza en un recorrido secundario: ``` g.V().has('code','ANC').as('a') .project('flights').by(select('a') .outE().aggregate('x')) ``` En este ejemplo, aggregate( ) no se convierte porque lo que se almacena es el `min()` de un valor: ``` g.V().has('code','ANC').outE().aggregate('x').by(values('dist').min()) ``` + [barrier( )](http://tinkerpop.apache.org/docs/current/reference/#barrier-step): el paso `barrier()` generalmente se puede convertir en una operación nativa del motor de Neptune, a menos que el paso siguiente no se convierta. + [cap( )](http://tinkerpop.apache.org/docs/current/reference/#cap-step): el único caso en el que el paso `cap()` se convierte es cuando se combina con el paso `unfold()` para devolver una versión desplegada de un agregado de valores de vértice, borde, identificador o propiedad. En este ejemplo, `cap()` se convertirá porque va seguido de `.unfold()`. ``` g.V().has('airport','country','IE').aggregate('airport').limit(2) .cap('airport').unfold() ``` Sin embargo, si elimina `.unfold()`, `cap()` no se convertirá: ``` g.V().has('airport','country','IE').aggregate('airport').limit(2) .cap('airport') ``` + [coalesce ()](http://tinkerpop.apache.org/docs/current/reference/#coalesce-step)[: el único caso en el que el `coalesce()` paso se convierte es cuando sigue el [patrón Upsert](http://tinkerpop.apache.org/docs/current/recipes/#element-existence) recomendado en la página de recetas. TinkerPop ](http://tinkerpop.apache.org/docs/current/recipes/) No se permiten otros patrones de coalesce(). La conversión se limita al caso en el que todos los recorridos secundarios se pueden convertir, todos producen el mismo tipo que la salida (vértice, borde, identificador, valor, clave o etiqueta), todos se desplazan hacia un elemento nuevo y no contienen el paso `repeat()`. + [constant( )](http://tinkerpop.apache.org/docs/current/reference/#constant-step): actualmente, el paso constant() solo se convierte si se usa dentro de una parte de `sack().by()` de un recorrido para asignar un 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): el paso `cyclicPath()` generalmente se puede convertir en una operación nativa del motor de Neptune, a menos que el paso se utilice con moduladores `by()`, `from()` o `to()`. En las siguientes consultas, por ejemplo, `cyclicPath()` no se convierte: ``` 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): el paso `drop()` generalmente se puede convertir en una operación nativa del motor de Neptune, a menos que el paso se utilice dentro de un paso `sideEffect(` o `optional()`. + [fold ()](http://tinkerpop.apache.org/docs/current/reference/#fold-step): solo hay dos situaciones en las que se puede convertir el paso fold (), a saber, cuando se usa con el [patrón Upsert](http://tinkerpop.apache.org/docs/current/recipes/#element-existence) recomendado en la [página de TinkerPop recetas](http://tinkerpop.apache.org/docs/current/recipes/) y cuando se usa en un contexto como este: `group().by()` ``` g.V().has('code','ANC').out().group().by().by(values('code', 'city').fold()) ``` + [has ()](http://tinkerpop.apache.org/docs/current/reference/#has-step): el paso “has ()” generalmente se puede convertir en una operación nativa del motor de Neptune siempre que las consultas con “T” usen el predicado “P.eq”, “P.neq” o “P.contains”. Es de esperar que las variaciones de “has()” que implican que esas instancias de “P” también se conviertan en nativas, como “hasId (‘id1234’)”, que equivale a “has(eq, T.ID, ‘id1234’)”. + [id( )](http://tinkerpop.apache.org/docs/current/reference/#id-step): el paso `id()` se convierte a menos que se utilice en una propiedad, como esta: ``` g.V().has('code','ANC').properties('code').id() ``` + [mergeE()](https://tinkerpop.apache.org/docs/current/reference/#mergeedge-step): el paso `mergeE()` se puede convertir en una operación nativa del motor de Neptune si los parámetros (la condición merge, `onCreate` y `onMatch`) son constantes (ya sea `null`, un `Map` constante o `select()` de un `Map`). Todos los ejemplos de [bordes de actualización e inserción](https://docs.aws.amazon.com//neptune/latest/userguide/gremlin-efficient-upserts.html#gremlin-upserts-edges) se pueden convertir. + [mergeV()](https://tinkerpop.apache.org/docs/current/reference/#mergevertex-step): el paso mergeV () se puede convertir en una operación nativa del motor de Neptune si los parámetros (la condición merge, `onCreate` y `onMatch`) son constantes (ya sea `null`, un `Map` constante o `select()` de un `Map`). Todos los ejemplos de [bordes de actualización e inserción](https://docs.aws.amazon.com//neptune/latest/userguide/gremlin-efficient-upserts.html#gremlin-upserts-vertices) se pueden convertir. + [order( )](http://tinkerpop.apache.org/docs/current/reference/#order-step): el paso `order()` generalmente se puede convertir en una operación nativa del motor de Neptune, a menos que se produzca algo de lo siguiente: + El paso `order()` se encuentra dentro de un recorrido secundario anidado, como este: ``` g.V().has('code','ANC').where(V().out().order().by(id)) ``` + Se utilizan los pedidos locales, como por ejemplo con `order(local)`. + En la modulación `by()` se utiliza un comparador personalizado por el que ordenar. Un ejemplo es el uso de `sack()`: ``` g.withSack(0). V().has('code','ANC'). repeat(outE().sack(sum).by('dist').inV()).times(2).limit(10). order().by(sack()) ``` + Hay varias ordenaciones en el mismo elemento. + [project( )](http://tinkerpop.apache.org/docs/current/reference/#project-step): el paso `project()` generalmente se puede convertir en una operación nativa del motor de Neptune, a menos que el número de instrucciones de `by()` que siguen a `project()` no coincida con el número de etiquetas especificado, como aquí: ``` g.V().has('code','ANC').project('x', 'y').by(id) ``` + [range( )](http://tinkerpop.apache.org/docs/current/reference/#range-step): el paso `range()` solo se convierte cuando el extremo inferior del rango en cuestión es cero (por ejemplo, `range(0,3)`). + [repeat( )](http://tinkerpop.apache.org/docs/current/reference/#repeat-step): el paso `repeat()` generalmente se puede convertir en una operación nativa del motor de Neptune, a menos que esté anidado dentro de otro paso `repeat()`, como este: ``` g.V().has('code','ANC').repeat(out().repeat(out()).times(2)).times(2) ``` + [sack()](http://tinkerpop.apache.org/docs/current/reference/#sack-step): el paso `sack()` generalmente se puede convertir en una operación nativa del motor de Neptune, excepto en los siguientes casos: + Si se utiliza un operador sack no numérico. + Si se utiliza un operador sack numérico que no sea `+`, `-`, `mult`, `div`, `min` ni `max`. + Si `sack()` se usa dentro de un paso `where()` para filtrar en función del valor de sack, como se muestra a continuación: ``` g.V().has('code','ANC').sack(assign).by(values('code')).where(sack().is('ANC')) ``` + [sum( )](http://tinkerpop.apache.org/docs/current/reference/#sum-step): el paso `sum()` generalmente se puede convertir en una operación nativa del motor de Neptune, pero no cuando se usa para calcular una suma global, como esta: ``` g.V().has('code','ANC').outE('routes').values('dist').sum() ``` + [union( )](http://tinkerpop.apache.org/docs/current/reference/#union-step): el paso `union()` se puede convertir en una operación nativa del motor de Neptune siempre que sea el último paso de la consulta, aparte del paso terminal. + [unfold ()](http://tinkerpop.apache.org/docs/current/reference/#unfold-step): el `unfold()` paso solo se puede convertir en una operación nativa del motor de Neptuno cuando se usa con [el patrón Upsert](http://tinkerpop.apache.org/docs/current/recipes/#element-existence) recomendado en [TinkerPopla página de recetas](http://tinkerpop.apache.org/docs/current/recipes/) y cuando se usa junto con esto: `cap()` ``` g.V().has('airport','country','IE').aggregate('airport').limit(2) .cap('airport').unfold() ``` + [where( )](http://tinkerpop.apache.org/docs/current/reference/#where-step): el paso `where()` generalmente se puede convertir en una operación nativa del motor de Neptune, excepto en los siguientes casos: + Cuando se utilizan modulaciones by(), como esta: ``` g.V().hasLabel('airport').as('a') .where(gt('a')).by('runways') ``` + Cuando se utilizan operadores de comparación que no sean `eq`, `neq`, `within` y `without`. + Cuando se utilizan agregaciones proporcionadas por el usuario. ## Pasos de Gremlin que nunca se convierten en operaciones nativas del motor de Neptune Los siguientes pasos de Gremlin son compatibles con Neptune, pero nunca se convierten en operaciones nativas del motor de Neptune. En su lugar, los ejecuta el servidor de 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) ## Pasos de Gremlin que Neptune no admite en absoluto Los siguientes pasos de Gremlin no se admiten en absoluto en Neptune. En la mayoría de los casos, esto se debe a que requieren un `GraphComputer`, que Neptune no admite actualmente. + [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) En realidad, el paso `io()` se admite parcialmente, ya que se puede usar `read()` desde una URL, pero no para `write()`.