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

Conformità agli standard Gremlin in Amazon Neptune

Le sezioni seguenti forniscono una panoramica dell'implementazione Neptune di Gremlin e di come si differenzia dall'implementazione di Apache. TinkerPop

Neptune implementa alcuni passaggi di Gremlin in modo nativo nel suo motore e utilizza l'implementazione di Apache Gremlin per elaborarne altri (vedi). TinkerPop Supporto nativo dei passaggi Gremlin in Amazon Neptune

Standard applicabili per Gremlin

Variabili e parametri negli script

Per quanto riguarda le variabili preassociate, l'oggetto di attraversamento g è Pre-bound in Neptune e l'oggetto non è supportato. graph

Sebbene Neptune non supporti le variabili Gremlin o la parametrizzazione negli script, spesso si possono trovare in Internet script di esempio per Gremlin Server che contengono dichiarazioni di variabili, come ad esempio:

String query = "x = 1; g.V(x)";
List<Result> results = client.submit(query).all().get();

Esistono anche molti esempi che utilizzano la parametrizzazione (o le associazioni) quando si inviano le query, come ad esempio:

Map<String,Object> params = new HashMap<>();
params.put("x",1);
String query = "g.V(x)";
List<Result> results = client.submit(query).all().get();

Gli esempi di parametri sono in genere associati ad avvisi relativi alle penalizzazioni in termini di prestazioni in caso di mancata parametrizzazione quando possibile. Ci sono moltissimi esempi di questo tipo TinkerPop che potreste incontrare e sembrano tutti abbastanza convincenti sulla necessità di parametrizzare.

Tuttavia, sia la funzionalità di dichiarazione delle variabili che la funzionalità di parametrizzazione (insieme agli avvisi) si applicano solo al server Gremlin quando TinkerPop utilizza il. GremlinGroovyScriptEngine Non si applicano quando Gremlin Server utilizza la grammatica ANTLR gremlin-language di Gremlin per analizzare le query. La grammatica ANTLR non supporta né le dichiarazioni di variabili né la parametrizzazione, quindi quando si utilizza ANTLR, non ci si deve preoccupare di non riuscire a parametrizzare. Poiché la grammatica ANTLR è una componente più recente TinkerPop, i contenuti meno recenti che potresti trovare su Internet generalmente non riflettono questa distinzione.

Neptune utilizza la grammatica ANTLR nel motore di elaborazione delle query anziché GremlinGroovyScriptEngine, quindi non supporta le variabili, la parametrizzazione o la proprietà bindings. Di conseguenza, i problemi relativi alla mancata parametrizzazione non si applicano a Neptune. Utilizzando Neptune, è perfettamente sicuro inviare semplicemente la query così com'è, dove normalmente si parametrizza. Di conseguenza, l'esempio precedente può essere semplificato senza alcuna penalizzazione delle prestazioni come segue:

String query = "g.V(1)";
List<Result> results = client.submit(query).all().get();

Esecuzione di uno script

Il motore Gremlin di Neptune analizza le query utilizzando la grammatica ANTLR. TinkerPop gremlin-language Non esegue un GremlinGroovyScriptEngine (come fanno alcune implementazioni di TinkerPop-based Gremlin Server), quindi gli script inviati a Neptune devono contenere solo il linguaggio Gremlin, non codice Groovy o Java arbitrario.

Gli script possono essere inviati a Neptune in diversi modi, ad esempio tramite l'endpoint REST Gremlin, la console Gremlin o tramite driver di linguaggio (ad esempio, il client di script del driver Java). TinkerPop https://tinkerpop.apache.org/docs/current/reference/#gremlin-java-scripts I vincoli descritti in questa sezione si applicano a tutti questi percorsi di invio delle stringhe di testo.

È importante non confondere il linguaggio Gremlin stesso con lo zucchero sintattico o le funzioni generiche di qualsiasi linguaggio di programmazione che potresti aver visto racchiudere esempi di Gremlin altrove. Se tale codice appare nei TinkerPop tutorial o negli esempi online, dipende da un runtime Groovy o Java che Neptune non fornisce.

Cosa può contenere uno script

Riferimento TinkerPop ai valori di enumerazione

Se è previsto un valore di TinkerPop enumerazione come argomento graduale (ad esempio, una cardinalità attiva property() o un ordine attivoby()), utilizzate i valori in forma abbreviata riconosciuti dalla grammatica ANTLR. Neptune non risolve nomi di classi Java completamente qualificati in questa posizione: ad esempio, non è accettato; usa invece. org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single single

La tabella seguente elenca i valori abbreviati consentiti e la TinkerPop classe sottostante a cui ciascuno appartiene.

Cosa non può contenere uno script

I seguenti non sono supportati nelle query Gremlin con stringhe di testo su Neptune, poiché si basano sul supporto del runtime Groovy o Java che Neptune non fornisce:

Proprietà sugli elementi

Neptune non supporta il materializeProperties flag introdotto in TinkerPop 3.7.0 per restituire proprietà sugli elementi. Di conseguenza, Neptune continuerà a restituire solo vertici o bordi come riferimenti con solo i loro e. id label

Sessioni

Le sessioni in Neptune hanno una durata limitata di soli 10 minuti. Per ulteriori Sessioni basate su script Gremlin informazioni, vedere TinkerPop Session Reference.

Transazioni

Neptune apre una nuova transazione all'inizio di ogni attraversamento Gremlin e chiude la transazione dopo il completamento dell'attraversamento. La transazione viene ripristinata quando si verifica un errore.

Una singola transazione include più istruzioni separate da un punto e virgola (;) o un carattere nuova riga (\n). Ogni istruzione diversa dall'ultima deve terminare con una fase next() da eseguire. Vengono restituiti solo i dati di attraversamento finali.

La logica di transazione manuale che utilizza tx.commit() e tx.rollback() non è supportata.

ID dei vertici e degli archi

Gli ID dei vertici e degli archi in Neptune Gremlin devono essere di tipo String. Queste stringhe di ID supportano i caratteri Unicode e non possono superare i 55 MB di dimensione.

User-supplied Gli ID sono supportati, ma sono opzionali nell'uso normale. Se non si fornisce un ID quando si aggiunge un vertice o un arco, Neptune genera un UUID e lo converte in una stringa, in un formato simile al seguente: "48af8178-50ce-971a-fc41-8c9a954cea62". Questi UUID non sono conformi allo standard RFC, quindi se sono necessari UUID standard occorre generarli esternamente e fornirli quando si aggiungono vertici o archi.

User-supplied ID

User-supplied Gli ID sono ammessi in Neptune Gremlin con le seguenti clausole.

Per creare un nuovo vertice con un ID personalizzato, utilizza la fase property con la parola chiave id: g.addV().property(id, 'customid').

Tutti gli ID dei vertici e degli edge devono essere univoci. Tuttavia, Neptune consente che un vertice e un arco abbiano lo stesso ID.

Se si tenta di creare un nuovo vertice utilizzando g.addV() e un vertice con tale ID esiste già, l'operazione non va a buon fine. Fa eccezione il caso in cui si specifica una nuova etichetta per il vertice; in tal caso l'operazione viene eseguita correttamente, ma aggiunge al vertice esistente la nuova etichetta e le eventuali proprietà aggiuntive specificate. Nessun elemento viene sovrascritto. Non viene creato un nuovo vertice. L'ID del vertice non cambia e rimane univoco.

Ad esempio, i comandi della console Gremlin riportato di seguito, hanno esito positivo:

gremlin> g.addV('label1').property(id, 'customid')
gremlin> g.addV('label2').property(id, 'customid')
gremlin> g.V('customid').label()
==>label1::label2

ID di proprietà dei vertici

Gli ID di proprietà dei vertici sono generati automaticamente e possono comparire come numeri positivi o negativi quando richiesto.

Cardinalità delle proprietà dei vertici

Neptune supporta la cardinalità di un insieme e la cardinalità singola. Se non è specificato, è impostata la cardinalità di un insieme. In questo modo, se imposti un valore di proprietà, questo aggiunge un nuovo valore alla proprietà, ma solo se non compare già nell'insieme dei valori. Questo è il valore di enumerazione Gremlin di Set.

List non è supportato. Per ulteriori informazioni sulla cardinalità delle proprietà, consultate l'argomento Vertex nel Gremlin. https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/structure/Vertex.html#property-org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality-java.lang.String-V-java.lang.Object...- JavaDoc

Aggiornamento della proprietà di un vertice

Per aggiornare un valore di proprietà senza aggiungere un ulteriore valore all'insieme dei valori, specificare la cardinalità single nella fase property.

g.V('exampleid01').property(single, 'age', 25)

Questo consente di rimuovere tutti i valori esistenti della proprietà.

Etichette

Neptune supporta più etichette per un vertice. Quando crei un'etichetta, puoi specificare più etichette separandole con ::. Ad esempio, g.addV("Label1::Label2::Label3") aggiunge un vertice con tre etichette diverse. La fase hasLabel corrisponde a questo vertice con una qualsiasi delle tre etichette: hasLabel("Label1") , hasLabel("Label2") e hasLabel("Label3").

Caratteri escape

Neptune risolve tutti i caratteri escape come descritto nella sezione Escape dei caratteri speciali della documentazione Apache Groovy Language.

Serializzazione

Neptune supporta le serializzazioni seguenti in base al tipo MIME richiesto.

Con Neptune, puoi utilizzare molti dei serializzatori TinkerPop offerti, con supporto per le varie versioni e configurazioni di GraphsON e. GraphBinary Vedi la seguente tabella per i serializzatori attualmente supportati. Nonostante siano presenti molte opzioni, la guida da utilizzare è semplice:

Passaggi Lambda

Neptune non supporta i passaggi Lambda.

Passaggi Gremlin non supportati

Neptune non supporta i passaggi Gremlin seguenti:

Caratteristiche del grafo Gremlin in Neptune

L'implementazione di Gremlin in Neptune non espone l'oggetto graph. Le tabelle seguenti elencano le caratteristiche di Gremlin e indicano se Neptune le supporta o meno.

Supporto di Neptune per le funzionalità grafiche

Le caratteristiche del grafo Neptune, se supportate, sono le stesse di quelle restituite dal comando graph.features().

Supporto di Neptune delle funzionalità della variabile

Supporto di Neptune delle caratteristiche del vertice

Supporto di Neptune delle caratteristiche della proprietà del vertice

Supporto di Neptune delle caratteristiche dell'arco

Supporto di Neptune delle caratteristiche della proprietà dell'arco