Prise en charge des étapes Gremlin natives dans Amazon Neptune

Le moteur Amazon Neptune n'offre actuellement pas de prise en charge native complète pour toutes les étapes Gremlin, comme expliqué dans Réglage des requêtes Gremlin. La prise en charge actuelle se divise en quatre catégories :

• Étapes Gremlin qui peuvent toujours être converties en opérations natives du moteur Neptune

• Étapes Gremlin qui peuvent être converties en opérations natives du moteur Neptune dans certains cas

• Étapes Gremlin qui sont jamais converties en opérations natives du moteur Neptune

• Étapes Gremlin qui ne sont pas du tout prises en charge dans Neptune

Étapes Gremlin qui peuvent toujours être converties en opérations natives du moteur Neptune

De nombreuses étapes Gremlin peuvent être converties en opérations natives du moteur Neptune tant qu'elles répondent aux conditions suivantes :

• Elles ne sont pas précédées dans la requête d'une étape qui ne peut pas être convertie.

• Leur étape parent, le cas échéant, peut être convertie.

• Toutes leurs traversées enfants, le cas échéant, peuvent être converties.

Les étapes Gremlin suivantes sont toujours converties en opérations natives du moteur Neptune si elles répondent à ces conditions :

• and( )

• as( )

• count( )

• E( )

• emit( )

• explain( )

• group( )

• groupCount( )

• has( )

• identity( )

• is( )

• key( )

• label( )

• limit( )

• local( )

• loops( )

• not( )

• or( )

• profile( )

• properties( )

• subgraph( )

• until( )

• V( )

• value( )

• valueMap( )

• values( )

Étapes Gremlin qui peuvent être converties en opérations natives du moteur Neptune dans certains cas

Certaines étapes Gremlin peuvent être converties en opérations natives du moteur Neptune dans certaines situations, mais pas dans d'autres :

• addE( ) : l'étape addE() peut généralement être convertie en une opération native du moteur Neptune, à moins qu'elle ne soit immédiatement suivie d'une étape property() contenant une traversée en tant que clé.

• addV( ) : l'étape addV() peut généralement être convertie en une opération native du moteur Neptune, à moins qu'elle ne soit immédiatement suivie d'une étape property() contenant une traversée en tant que clé ou à moins que plusieurs étiquettes ne soient attribuées.

• aggregate( ) : l'étape aggregate() peut généralement être convertie en une opération native du moteur Neptune, sauf si elle est utilisée dans une traversée ou une sous-traversée secondaire, ou à moins que la valeur stockée ne soit autre qu'un sommet, une arête, un ID, une étiquette ou une valeur de propriété.

  Dans l'exemple ci-dessous, l'étape aggregate() n'est pas convertie, car elle est utilisée dans une traversée enfant :

  g.V().has('code','ANC').as('a')
       .project('flights').by(select('a')
       .outE().aggregate('x'))

  Dans cet exemple, l'étape aggregate() n'est pas convertie, car ce qui est stocké est une valeur min() :

  g.V().has('code','ANC').outE().aggregate('x').by(values('dist').min())

• barrier( ) : l'étape barrier() peut généralement être convertie en une opération native du moteur Neptune, sauf si l'étape qui la suit n'est pas convertie.

• cap( ) : le seul cas où l'étape cap() est convertie est lorsqu'elle est combinée à l'étape unfold() pour renvoyer une version dépliée d'un agrégat de valeurs de sommet, d'arête, d'ID ou de propriété. Dans cet exemple, cap() sera converti, car il est suivi de .unfold() :

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

  Toutefois, si vous supprimez .unfold(), cap() ne sera pas converti :

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

• coalesce () — Le seul cas où l'coalesce()étape est convertie est lorsqu'elle suit le modèle Upsert recommandé sur la TinkerPop page des recettes. Les autres modèles coalesce() ne sont pas autorisés. La conversion est limitée au cas où toutes les traversées enfants peuvent être converties, où elles génèremt toutes le même type de sortie (sommet, arête, ID, valeur, clé ou étiquette), où elles mènent toutes à un nouvel élément et où elles ne contiennent pas l'étape repeat().

• constant( ) : l'étape constant() n'est actuellement convertie que si elle est utilisée dans une partie sack().by() d'une traversée pour attribuer une valeur de constante, comme ceci :

  g.V().has('code','ANC').sack(assign).by(constant(10)).out().limit(2)

• cyclicPath( ) : l'étape cyclicPath() peut généralement être convertie en opération native du moteur Neptune, sauf si l'étape est utilisée avec des modulateurs by(), from() ou to(). Dans les requêtes suivantes, par exemple, cyclicPath() n'est pas converti :

  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( ) : l'étape drop() peut généralement être convertie en opération native du moteur Neptune, sauf si l'étape est utilisée dans une étape sideEffect() ou optional().

• fold () — L'étape fold () ne peut être convertie que dans deux situations, à savoir lorsqu'elle est utilisée selon le modèle Upsert recommandé sur la page des TinkerPop recettes et lorsqu'elle est utilisée dans un group().by() contexte comme celui-ci :

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

• id( ) : l'étape id() est convertie sauf si elle est utilisée au niveau d'une propriété, comme ceci :

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

• order( ) : l'étape order() peut généralement être convertie en opération native du moteur Neptune, sauf si l'une des conditions suivantes est vraie :

  • L'étape order() se trouve dans une traversée enfant imbriquée, comme ceci :

    g.V().has('code','ANC').where(V().out().order().by(id))

  • L'ordre local est utilisé (par exemple, avec order(local)).

  • Un comparateur personnalisé est utilisé dans la modulation by() pour effectuer le tri. Voici un exemple de l'utilisation de sack() :

    g.withSack(0).
      V().has('code','ANC').
          repeat(outE().sack(sum).by('dist').inV()).times(2).limit(10).
          order().by(sack())

  • Il existe plusieurs ordres pour le même élément.

• project( ) : l'étape project() peut généralement être convertie en opération native du moteur Neptune, sauf si le nombre d'instructions by() qui suivent project() ne correspond pas au nombre d'étiquettes spécifié, comme ici :

  g.V().has('code','ANC').project('x', 'y').by(id)

• range( ) : l'étape range() n'est convertie que lorsque la limite inférieure de la plage en question est égale à zéro (par exemple, range(0,3)).

• repeat( ) : l'étape repeat() peut généralement être convertie en opération native du moteur Neptune, sauf si elle est imbriquée dans une autre étape repeat(), comme ceci :

  g.V().has('code','ANC').repeat(out().repeat(out()).times(2)).times(2)

• sack( ) : l'étape sack() peut généralement être convertie en opération native du moteur Neptune, sauf dans les cas suivants :

  • Si un opérateur sack non numérique est utilisé.

  • Si un opérateur sack non numérique autre que +, -, mult, div, min et max est utilisé.

  • Si sack() est utilisé dans une étape where() pour filtrer les données en fonction d'une valeur sack, comme ici :

    g.V().has('code','ANC').sack(assign).by(values('code')).where(sack().is('ANC'))

• sum( ) : l'étape sum() peut généralement être convertie en opération native du moteur Neptune, mais pas lorsqu'elle est utilisée pour calculer une somme globale, comme ceci :

  g.V().has('code','ANC').outE('routes').values('dist').sum()

• union( ) : l'étape union() peut être convertie en opération native du moteur Neptune tant qu'il s'agit de la dernière étape de la requête en dehors de l'étape terminale.

• unfold () — L'unfold()étape ne peut être convertie en une opération native du moteur Neptune que lorsqu'elle est utilisée selon le modèle Upsert recommandé sur TinkerPopla page des recettes, et lorsqu'elle est utilisée conjointement avec cap() ceci :

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

• where( ) : l'étape where() peut généralement être convertie en opération native du moteur Neptune, sauf dans les cas suivants :

  • Lorsque des modulations by() sont utilisées, comme ceci :

    g.V().hasLabel('airport').as('a')
         .where(gt('a')).by('runways')

  • Lorsque des opérateurs de comparaison autres que eq, neq, within et without sont utilisés.

  • Lorsque des agrégations fournies par l'utilisateur sont utilisées.

Étapes Gremlin qui sont jamais converties en opérations natives du moteur Neptune

Les étapes Gremlin suivantes sont prises en charge dans Neptune, mais ne sont jamais converties en opérations natives du moteur Neptune. Au lieu de cela, elles sont exécutées par le serveur Gremlin.

• choose( )

• coin( )

• inject( )

• match( )

• math( )

• max( )

• mean( )

• min( )

• option( )

• optional( )

• path( )

• propertyMap( )

• sample( )

• skip( )

• tail( )

• timeLimit( )

• tree( )

Étapes Gremlin qui ne sont pas du tout prises en charge dans Neptune

Les étapes Gremlin suivantes ne sont pas du tout prises en charge dans Neptune. Dans la plupart des cas, cela est dû au fait qu'elles nécessitent un GraphComputer, ce que Neptune ne prend pas en charge actuellement.

• connectedComponent( )

• io( )

• shortestPath( )

• withComputer( )

• pageRank( )

• peerPressure( )

• program( )

L'étape io() est partiellement prise en charge, dans la mesure où elle peut être utilisée pour effectuer une opération de type read() à partir d'une URL, mais pas une opération de type write().