View a markdown version of this page

Supporto nativo dei passaggi Gremlin in Amazon Neptune - Amazon Neptune

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:

Nota

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.

Neptune 1.5.0.0: modifiche al comportamento dei passaggi

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 il aggregate(Scope) sovraccarico (ad esempio, aggregate(local)) sono stati rimossi. Usa aggregate(global) (impostazione predefinita) per l'accumulo globale, o local(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 e option(Traversal, v) la variante è stata rimossa. Una nuova Pick.unproductive Il token è disponibile per la gestione di traverse che non producono risultati.

  • Il valueMap(), propertyMap(), groupCount(), dedup(), sack(), sample(), e aggregate() i passaggi ora generano un errore se più di uno by() il modulatore è fornito.

  • Interno repeat(), cap() e inject() non sono più consentiti. Prova qualsiasi repeat() che utilizza questi passaggi prima dell'aggiornamento alla 3.8.0.

  • Il none() il passaggio è stato rinominato in discard(). Una nuova fase del filtro dei predicati, none(P), riutilizza il none nomina e rilascia i traverse che corrispondono al predicato.

Per ulteriori informazioni, consulta la TinkerPop documentazione sull'aggiornamento 3.8.0 su Apache TinkerPop sito web.

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 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à.

    Neptune 1.5.0.0: store () e aggregate (Scope) rimossi

    Il store() passo e il aggregate(Scope) sovraccarico (ad esempio, aggregate(local)) sono stati rimossi in TinkerPop 3.8.0. Query Neptune esistenti che utilizzano l'impostazione predefinita aggregate() 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 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')
  • fondersi () — L'unico caso in cui coalesce() il passaggio viene convertito quando segue il Schema Upsert consigliato 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 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().

  • 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 ricettee 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, onCreate e onMatch) sono costanti (o null, una costante Map, o select() di un Map). 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, onCreate e onMatch) sono costanti (o null, una costante Map, o select() di un Map). 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 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)
    Neptune 1.5.0.0: restrizioni repeat ()

    A partire da TinkerPop 3.8.0, cap() e inject() non sono più ammessi all'interno di un repeat() attraversamento. Ripeti il test su qualsiasi repeat() traversata che utilizza cap() o inject() 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, 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.

  • apri () — Il unfold() il passaggio può essere convertito in un funzionamento nativo del motore Neptune solo quando viene utilizzato in Schema Upsert consigliato su TinkerPop pagina delle ricettee 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, 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.

Neptune 1.5.0.0: modifica del comportamento del passaggio choose ()

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().