Supporto nativo dei passaggi Gremlin in Amazon Neptune

Il motore Amazon Neptune attualmente non dispone del supporto nativo completo di tutti i passaggi Gremlin, come spiegato in Ottimizzazione di query Gremlin. Il supporto attuale si divide in quattro categorie:

• Passaggi Gremlin che possono sempre essere convertiti in operazioni native del motore Neptune

• Passaggi Gremlin che possono essere convertiti in operazioni native del motore Neptune in alcuni casi

• Passaggi Gremlin che non vengono mai convertiti in operazioni native del motore Neptune

• Passaggi Gremlin che non sono affatto supportati in Neptune

Passaggi Gremlin che possono sempre essere convertiti in operazioni native del motore Neptune

Molti passaggi Gremlin possono essere convertiti in operazioni native del motore Neptune purché soddisfino le seguenti condizioni:

• Non devono essere preceduti nella query da un passaggio che non possa essere convertito.

• Il relativo passaggio padre, se presente, deve poter essere convertito.

• Tutti i relativi attraversamenti figlio, se presenti, devono poter essere convertiti.

I seguenti passaggi Gremlin vengono sempre convertiti in operazioni native del motore Neptune se soddisfino queste condizioni:

• and( )

• as( )

• count( )

• E( )

• emit( )

• explain( )

• group( )

• groupCount( )

• identity( )

• is( )

• key( )

• label( )

• limit( )

• local( )

• loops( )

• not( )

• or( )

• profile( )

• properties( )

• subgraph( )

• until( )

• V( )

• value

• valueMap( )

• values( )

Passaggi Gremlin che possono essere convertiti in operazioni native del motore Neptune in alcuni casi

Alcuni passaggi Gremlin possono essere convertiti in operazioni native del motore Neptune in alcune situazioni ma non in altre:

• addE( ): il passaggio addE() può generalmente essere convertito in un'operazione nativa del motore Neptune, a meno che non sia immediatamente seguito da un passaggio property() contenente un attraversamento come chiave.

• addV( ): il passaggio addV() può generalmente essere convertito in un'operazione nativa del motore Neptune, a meno che non sia immediatamente seguito da un passaggio property() contenente un attraversamento come chiave o a meno che non vengano assegnate più etichette.

• aggregate( ): il passaggio aggregate() può generalmente essere convertito in un'operazione nativa del motore Neptune, a meno che il passaggio non venga utilizzato in un attraversamento figlio o sottoattraversamento oppure a meno che il valore archiviato non sia qualcosa di diverso da un valore di vertice, arco, ID, etichetta o proprietà.

  Nell'esempio seguente, aggregate() non viene convertito perché viene utilizzato in un attraversamento figlio:

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

  In questo esempio, aggregate() non viene convertito perché ciò che viene archiviato è il valore min() di un valore:

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

• barrier( ): il passaggio barrier() può generalmente essere convertito in un'operazione nativa del motore Neptune, a meno che il passaggio successivo non venga convertito.

• cap( ): l'unico caso in cui il passaggio cap() viene convertito è quando viene combinato con il passaggio unfold() per restituire una versione espansa di un aggregato di valori di vertice, arco, ID o proprietà. In questo esempio, cap() verrà convertito perché è seguito da .unfold():

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

  Tuttavia, se si rimuove .unfold(), cap() non verrà convertito:

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

• coalesce () — L'unico caso in cui il coalesce() passaggio viene convertito è quando segue lo schema Upsert consigliato nella pagina delle TinkerPop ricette. Altri modelli coalesce() non sono consentiti. La conversione è limitata al caso in cui tutti gli attraversamenti figlio possano essere convertiti, producano tutti lo stesso tipo di output (vertice, arco, ID, valore, chiave o etichetta), attraversino tutti un nuovo elemento e non contengano il passaggio repeat().

• constant( ): il passaggio constant() viene attualmente convertito solo se viene utilizzato all'interno di una parte sack().by() di un attraversamento per assegnare un valore costante, come questo:

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

• cyclicPath( ): il passaggio cyclicPath() può generalmente essere convertito in un'operazione nativa del motore Neptune, a meno che il passaggio non venga utilizzato con i modulatori by(), from() o to(). Nelle seguenti query, ad esempio, cyclicPath() non viene convertito:

  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( ): il passaggio drop() può generalmente essere convertito in un'operazione nativa del motore Neptune, a meno che il passaggio non venga utilizzato all'interno di un passaggio sideEffect() o optional().

• fold () — Ci sono solo due situazioni in cui il passaggio fold () può essere convertito, vale a dire quando viene utilizzato nel pattern Upsert consigliato nella pagina delle TinkerPop ricette e quando viene utilizzato in un contesto come questo: group().by()

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

• has () — La fase `has () `può generalmente essere convertita in un funzionamento nativo del motore Neptune a condizione che le interrogazioni con `T` utilizzino il predicato `p.EQ`, `P.neq` o `p.contains`. Aspettatevi variazioni di `has () `che implicano che anche quelle istanze di `P` vengano convertite in native, come `hasID ('id1234')` che è equivalente a `has (eq, T.id, 'id1234') `.

• id( ): il passaggio id() viene convertito a meno che non venga utilizzato su una proprietà, come in questo caso:

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

• mergEE () — Il mergeE() passo può essere convertito in un funzionamento del motore Neptune nativo se i parametri (la condizione di unione, onCreate eonMatch) sono costanti (una costante o null di a). Map select() Map Tutti gli esempi di ribaltamento degli spigoli possono essere convertiti.

• mergeV () — La fase mergeV () può essere convertita in un funzionamento nativo del motore Neptune se i parametri (la condizione di unione, onCreate andonMatch) sono costanti (una costante o null di un). Map select() Map Tutti gli esempi di vertici di ribaltamento possono essere convertiti.

• order( ): il passaggio order() può generalmente essere convertito in un'operazione nativa del motore Neptune, a meno che non si verifichi una delle seguenti condizioni:

  • Il passaggio order() si trova all'interno di un attraversamento figlio annidato, come questo:

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

  • Viene utilizzato l'ordinamento locale, come ad esempio con order(local).

  • Nella modulazione by() viene utilizzato un comparatore personalizzato per l'ordinamento. Un esempio è l'uso di sack() in questo modo:

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

  • Esistono più ordinamenti sullo stesso elemento.

• project( ): il passaggio project() può generalmente essere convertito in un'operazione nativa del motore Neptune, a meno che il numero di istruzioni by() che segue project() non corrisponda al numero di etichette specificate, come in questo caso:

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

• range( ): il passaggio range() viene convertito solo quando il limite inferiore dell'intervallo in questione è zero (ad esempio, range(0,3)).

• repeat( ): il passaggio repeat() può generalmente essere convertito in un'operazione nativa del motore Neptune, a meno che non sia annidato all'interno di un altro passaggio repeat(), come in questo caso:

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

• sack( ): il passaggio sack() può generalmente essere convertito in un'operazione nativa del motore Neptune, tranne nei casi seguenti:

  • Se viene utilizzato un operatore sack non numerico.

  • Se viene utilizzato un operatore sack numerico diverso da +, -, mult, div, min e max.

  • Se sack() viene utilizzato all'interno di un passaggio where() per filtrare in base a un valore sack, come in questo caso:

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

• sum( ): il passaggio sum() può generalmente essere convertito in un'operazione nativa del motore Neptune, ma non quando viene utilizzato per calcolare una somma globale, come in questo caso:

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

• union( ): il passaggio union() può essere convertito in un'operazione nativa del motore Neptune purché sia l'ultimo passaggio della query a parte il passaggio terminale.

• unfold () — Il unfold() passaggio può essere convertito in un funzionamento del motore Neptune nativo solo quando viene utilizzato nel pattern Upsert consigliato nella pagina TinkerPopdelle ricette e quando viene utilizzato insieme a questo: cap()

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

• where( ): il passaggio where() può generalmente essere convertito in un'operazione nativa del motore Neptune, tranne nei casi seguenti:

  • Quando vengono utilizzate le modulazioni by(), come in questo caso:

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

  • Quando vengono utilizzati operatori di confronto diversi da eq, neq, within e without.

  • Quando vengono utilizzate aggregazioni fornite dall'utente.

Passaggi Gremlin che non vengono mai convertiti in operazioni native del motore Neptune

I seguenti passaggi Gremlin sono supportati in Neptune ma non vengono mai convertiti in operazioni native del motore Neptune. Vengono invece eseguiti dal server Gremlin.

• choose( )

• coin( )

• inject( )

• match( )

• math( )

• max( )

• mean( )

• min( )

• option( )

• optional( )

• path( )

• propertyMap( )

• sample( )

• skip( )

• tail( )

• timeLimit( )

• tree( )

Passaggi Gremlin che non sono affatto supportati in Neptune

I seguenti passaggi Gremlin non sono affatto supportati in Neptune. Nella maggior parte dei casi ciò è dovuto al fatto che richiedono un oggetto GraphComputer, che Neptune attualmente non supporta.

• connectedComponent( )

• io( )

• shortestPath( )

• withComputer( )

• pageRank( )

• peerPressure( )

• program( )

Il passaggio io() è in realtà parzialmente supportato, in quanto può essere utilizzato per eseguire un passaggio read() da un URL ma non per eseguire un passaggio write().