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. Il supporto attuale si divide in quattro categorie:
Nella versione 1.5.0.0 e successive del motore Neptune, DFE supporta nativamente la maggior parte delle fasi di Gremlin. Se usi la release del motore 1.5.0.0 o successiva, vedi Versione del motore Neptune 1.5.0.0 e successive per l'attuale copertura delle fasi del DFE. Il supporto nativo per le fasi del motore descritto di seguito si applica ai carichi di lavoro che non utilizzano DFE.
TinkerPop 3.8.0 ha modificato il comportamento di diversi passaggi. Le note in questa pagina descrivono ogni modifica accanto alla voce interessata. I punti salienti sono:
Le
store()passo e ilaggregate(Scope)sovraccarico (ad esempio,aggregate(local)) sono stati rimossi. Usaaggregate(global)(impostazione predefinita) per l'accumulo globale, olocal(aggregate())se è necessaria l'aggregazione in ambito locale.Il
choose()il passaggio ora corrisponde solo alla prima opzione corrispondente, i traverse che non corrispondono ad alcuna opzione vengono passati automaticamente eoption(Traversal, v)la variante è stata rimossa. Una nuovaPick.unproductiveIl token è disponibile per la gestione di traverse che non producono risultati.Il
valueMap(),propertyMap(),groupCount(),dedup(),sack(),sample(), eaggregate()i passaggi ora generano un errore se più di unoby()il modulatore è fornito.Interno
repeat(),cap()einject()non sono più consentiti. Prova qualsiasirepeat()che utilizza questi passaggi prima dell'aggiornamento alla 3.8.0.Il
none()il passaggio è stato rinominato indiscard(). Una nuova fase del filtro dei predicati,none(P), riutilizza ilnonenomina e rilascia i traverse che corrispondono al predicato.
Per ulteriori informazioni, consulta la TinkerPop documentazione sull'aggiornamento 3.8.0
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:
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 passaggioproperty()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 passaggioproperty()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à.Neptune 1.5.0.0: store () e aggregate (Scope) rimossiIl
store()passo e ilaggregate(Scope)sovraccarico (ad esempio,aggregate(local)) sono stati rimossi in TinkerPop 3.8.0. Query Neptune esistenti che utilizzano l'impostazione predefinitaaggregate()il modulo continua a funzionare. Per indicazioni sulla migrazione, consulta la nota a livello di pagina nella parte superiore di questa pagina.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 passaggiounfold()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') fondersi ()
— L'unico caso in cui coalesce()il passaggio viene convertito quando segue il Schema Upsertconsigliato su TinkerPop pagina delle 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 modulatoriby(),from()oto(). 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 passaggiosideEffect() ooptional().-
piega ()
— Ci sono solo due situazioni in cui il passo fold () può essere convertito, vale a dire quando viene utilizzato nel Schema Upsert consigliato su TinkerPop pagina delle ricette e quando viene utilizzato in un group().by()contesto come questo:g.V().has('code','ANC').out().group().by().by(values('code', 'city').fold()) -
ha ()
— Il passaggio has () può essere generalmente convertito in un'operazione nativa del motore Neptune a condizione che le query con T utilizzino il predicatoP.eq`,`P.neq`o`P.contains`. Aspettatevi variazioni di `has () `che implicano la conversione anche di quelle istanze di `P` 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() -
Unisci ()
— Il mergeE()il passaggio può essere convertito in un funzionamento nativo del motore Neptune se i parametri (la condizione di unione,onCreateeonMatch) sono costanti (onull, una costanteMap, oselect()di unMap). Tutti gli esempi in ribaltare i bordi può essere convertito. -
unisci V ()
— La fase mergeV () può essere convertita in un'operazione nativa del motore Neptune se i parametri (la condizione di unione, onCreateeonMatch) sono costanti (onull, una costanteMap, oselect()di unMap). Tutti gli esempi in innalzamento dei vertici può essere convertito. -
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 disack()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 istruzioniby()che segueproject()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 passaggiorepeat(), come in questo caso:g.V().has('code','ANC').repeat(out().repeat(out()).times(2)).times(2)Neptune 1.5.0.0: restrizioni repeat ()A partire da TinkerPop 3.8.0,
cap()einject()non sono più ammessi all'interno di unrepeat()attraversamento. Ripeti il test su qualsiasirepeat()traversata che utilizzacap()oinject()prima di effettuare l'upgrade. -
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,minemax.-
Se
sack()viene utilizzato all'interno di un passaggiowhere()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.-
apri ()
— Il unfold()il passaggio può essere convertito in un funzionamento nativo del motore Neptune solo quando viene utilizzato in Schema Upsertconsigliato su TinkerPop pagina delle ricette e quando viene utilizzato insieme a cap()in questo modo: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,withinewithout.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.
Il choose() il comportamento dei passaggi è cambiato in TinkerPop 3.8.0. Per indicazioni sulla migrazione, consulta la nota a livello di pagina nella parte superiore di questa pagina.
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.
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().