Compatibilidad nativa con pasos de Gremlin en Amazon Neptune - Amazon Neptune
Convertidos siempreSe convierten a vecesNo se convierten nuncaNo se admiten en absoluto

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. 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

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:

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( ): 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( ): 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( ): 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( ): 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( ): 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 (): el único caso en el que el coalesce() paso se convierte es cuando sigue el patrón Upsert recomendado en la página de recetas. TinkerPop 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( ): 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() — Por lo general, el cyclicPath() paso se puede convertir en una operación nativa del motor de Neptuno, a menos que el paso se utilice con by()from(), o to() moduladores. 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( ): 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 (): solo hay dos situaciones en las que se puede convertir el paso fold (), a saber, cuando se usa con el patrón Upsert recomendado en la página de TinkerPop recetas y cuando se usa en un group().by() contexto como este:

    g.V().has('code','ANC').out().group().by().by(values('code', 'city').fold())

  • id( ): el paso id() se convierte a menos que se utilice en una propiedad, como esta:

    g.V().has('code','ANC').properties('code').id()

  • mergeE (): el mergeE() paso se puede convertir en una operación nativa del motor de Neptuno si los parámetros (la condición de fusión, onCreate onMatch y) son constantes (nulluna Map constante select() o de Map a). Todos los ejemplos de aristas ascendentes se pueden convertir.

  • mergeV (): el paso mergeV () se puede convertir en una operación nativa del motor de Neptuno si los parámetros (la condición de fusión, el onCreate yonMatch) son constantes (una constante o null una). Map select() Map Todos los ejemplos de vértices ascendentes se pueden convertir.

  • order( ): 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( ): 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( ): el paso range() solo se convierte cuando el extremo inferior del rango en cuestión es cero (por ejemplo, range(0,3)).

  • repeat( ): 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(): 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( ): 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( ): 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 (): el unfold() paso solo se puede convertir en una operación nativa del motor de Neptuno cuando se usa con el patrón Upsert recomendado en TinkerPopla página de recetas y cuando se usa junto con esto: cap()

    g.V().has('airport','country','IE').aggregate('airport').limit(2)
     .cap('airport').unfold()

  • where( ): 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.

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.

En realidad, el io() paso es parcialmente compatible, ya que se puede utilizar de a pero no read() de aURL. write()