Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà. # 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](gremlin-traversal-tuning.md). Il supporto attuale si divide in quattro categorie: + [Passaggi Gremlin che possono sempre essere convertiti in operazioni native del motore Neptune](#gremlin-steps-always) + [Passaggi Gremlin che possono essere convertiti in operazioni native del motore Neptune in alcuni casi](#gremlin-steps-sometimes) + [Passaggi Gremlin che non vengono mai convertiti in operazioni native del motore Neptune](#gremlin-steps-never) + [Passaggi Gremlin che non sono affatto supportati in Neptune](#neptune-gremlin-steps-unsupported) ## 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( )](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) ## 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( )](http://tinkerpop.apache.org/docs/current/reference/#addedge-step): 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( )](http://tinkerpop.apache.org/docs/current/reference/#addvertex-step): 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( )](http://tinkerpop.apache.org/docs/current/reference/#store-step): 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( )](http://tinkerpop.apache.org/docs/current/reference/#barrier-step): il passaggio `barrier()` può generalmente essere convertito in un'operazione nativa del motore Neptune, a meno che il passaggio successivo non venga convertito. + [cap( )](http://tinkerpop.apache.org/docs/current/reference/#cap-step): 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 ()](http://tinkerpop.apache.org/docs/current/reference/#coalesce-step) [— L'unico caso in cui il `coalesce()` passaggio viene convertito è quando segue lo [schema Upsert](http://tinkerpop.apache.org/docs/current/recipes/#element-existence) consigliato nella pagina delle TinkerPop ricette.](http://tinkerpop.apache.org/docs/current/recipes/) 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( )](http://tinkerpop.apache.org/docs/current/reference/#constant-step): 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( )](http://tinkerpop.apache.org/docs/current/reference/#cyclicpath-step): 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( )](http://tinkerpop.apache.org/docs/current/reference/#drop-step): 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 ()](http://tinkerpop.apache.org/docs/current/reference/#fold-step) — Ci sono solo due situazioni in cui il passaggio fold () può essere convertito, vale a dire quando viene utilizzato nel [pattern Upsert](http://tinkerpop.apache.org/docs/current/recipes/#element-existence) consigliato nella [pagina delle TinkerPop ricette](http://tinkerpop.apache.org/docs/current/recipes/) 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 ()](http://tinkerpop.apache.org/docs/current/reference/#has-step) — 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( )](http://tinkerpop.apache.org/docs/current/reference/#id-step): 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 ()](https://tinkerpop.apache.org/docs/current/reference/#mergeedge-step) — Il `mergeE()` passo può essere convertito in un funzionamento del motore Neptune nativo se i parametri (la condizione di unione, `onCreate` e`onMatch`) sono costanti (una costante o `null` di a). `Map` `select()` `Map` Tutti gli esempi di ribaltamento degli spigoli possono essere [convertiti](https://docs.aws.amazon.com//neptune/latest/userguide/gremlin-efficient-upserts.html#gremlin-upserts-edges). + [mergeV ()](https://tinkerpop.apache.org/docs/current/reference/#mergevertex-step) — La fase mergeV () può essere convertita in un funzionamento nativo del motore Neptune se i parametri (la condizione di unione, `onCreate` and`onMatch`) sono costanti (una costante o `null` di un). `Map` `select()` `Map` [Tutti gli esempi di vertici di ribaltamento possono essere convertiti.](https://docs.aws.amazon.com//neptune/latest/userguide/gremlin-efficient-upserts.html#gremlin-upserts-vertices) + [order( )](http://tinkerpop.apache.org/docs/current/reference/#order-step): 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( )](http://tinkerpop.apache.org/docs/current/reference/#project-step): 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( )](http://tinkerpop.apache.org/docs/current/reference/#range-step): il passaggio `range()` viene convertito solo quando il limite inferiore dell'intervallo in questione è zero (ad esempio, `range(0,3)`). + [repeat( )](http://tinkerpop.apache.org/docs/current/reference/#repeat-step): 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( )](http://tinkerpop.apache.org/docs/current/reference/#sack-step): 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( )](http://tinkerpop.apache.org/docs/current/reference/#sum-step): 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( )](http://tinkerpop.apache.org/docs/current/reference/#union-step): 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 ()](http://tinkerpop.apache.org/docs/current/reference/#unfold-step) — Il `unfold()` passaggio può essere convertito in un funzionamento del motore Neptune nativo solo quando viene utilizzato nel pattern [Upsert consigliato nella](http://tinkerpop.apache.org/docs/current/recipes/#element-existence) pagina [TinkerPopdelle ricette](http://tinkerpop.apache.org/docs/current/recipes/) e quando viene utilizzato insieme a questo: `cap()` ``` g.V().has('airport','country','IE').aggregate('airport').limit(2) .cap('airport').unfold() ``` + [where( )](http://tinkerpop.apache.org/docs/current/reference/#where-step): 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( )](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) ## 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( )](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) 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()`.