Suporte nativo para etapas do Gremlin no Amazon Neptune - Amazon Neptune
Sempre convertidasÀs vezes convertidasNunca convertidasNão compatíveis

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. O suporte atual se divide em quatro categorias:

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:

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 (): 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 (): 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 (): 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( ): 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( ): 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 () — O único caso em que a coalesce() etapa é convertida é quando ela segue o padrão Upsert recomendado na página de receitas. TinkerPop 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( ): 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() — A cyclicPath() etapa geralmente pode ser convertida em uma operação nativa do motor Neptune, a menos que a etapa seja usada by() comfrom(), ou moduladores. 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( ): 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 () — Existem apenas duas situações em que a etapa fold () pode ser convertida, a saber, quando é usada no padrão Upsert recomendado na página de TinkerPop receitas e quando é usada em um group().by() contexto como este:

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

  • id( ): a etapa id() é convertida, a menos que seja usada em uma propriedade, como esta:

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

  • mergeE () — A mergeE() etapa pode ser convertida em uma operação nativa do Neptune Engine se os parâmetros (a condição de mesclagem, onCreate eonMatch) forem constantes (uma constante ou null de a). Map select() Map Todos os exemplos em bordas ascendentes podem ser convertidos.

  • mergeV () — A etapa mergeV () pode ser convertida em uma operação nativa do Neptune Engine se os parâmetros (a condição de mesclagem, o onCreate eonMatch) forem constantes (uma constante ou null de a). Map select() Map Todos os exemplos em vértices ascendentes podem ser convertidos.

  • order( ): 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( ): 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( ): a etapa range() só é convertida quando a extremidade inferior do intervalo em questão é zero (por exemplo, range(0,3)).

  • repeat( ): 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( ): 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( ): 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( ): 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 () — A unfold() etapa só pode ser convertida em uma operação nativa do Neptune Engine quando usada no padrão Upsert recomendado TinkerPopna página de receitas e quando usada junto com: cap()

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

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

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.

Na verdade, a io() etapa é parcialmente suportada, pois pode ser usada para read() partir de aURL, mas não parawrite().