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 da Apache TinkerPop implementazione.
Neptune implementa alcuni passaggi di Gremlin in modo nativo nel suo motore e utilizza Apache TinkerPop Implementazione di Gremlin per elaborarne altri (vedi Supporto nativo dei passaggi Gremlin in Amazon Neptune).
Per alcuni esempi concreti di queste differenze di implementazione mostrate nella console Gremlin e in Amazon Neptune, consulta la sezione Utilizzo di Gremlin per accedere ai dati dei grafici in Amazon Neptune del Quick Start.
Argomenti
Standard applicabili per Gremlin
La lingua Gremlin è definita da Apache TinkerPop Documentazione
e Apache TinkerPop implementazione di Gremlin anziché mediante una specifica formale. Per i formati numerici, Gremlin segue lo standard IEEE 754 (IEEE 754-2019 - Standard IEEE per Floating-Point Aritmetica
. Per ulteriori informazioni, consulta anche Pagina Wikipedia IEEE 754 ).
Variabili e parametri negli script
Per quanto riguarda le variabili previncolate, l'oggetto di attraversamento g è Pre-bound in Neptune, e il graph l'oggetto non è supportato.
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
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 per 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 a TinkerPopè Gremlin Server quando 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. Perché la grammatica ANTLR è un componente più recente di 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 TinkerPopè gremlin-language Grammatica ANTLR. Lo fa non eseguire un GremlinGroovyScriptEngine (come alcuni TinkerPop-based Le implementazioni di Gremlin Server sì), 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 Endpoint REST di Gremlin, il Consolle Gremlin, o tramite TinkerPop driver linguistici (ad esempio, client di script del driver Java
È importante non confondere il linguaggio Gremlin stesso con lo zucchero sintattico o le funzioni generiche di qualsiasi linguaggio di programmazione che potresti aver visto racchiudendo esempi di Gremlin altrove. Dove tale codice appare in TinkerPop tutorial o esempi online, dipende da un runtime Groovy o Java che Neptune non fornisce.
Tutto ciò che è contenuto in questa sezione si applica agli invii di Gremlin con stringhe di testo. Gli invii di bytecode GLV (Gremlin Language Variant) creati in un linguaggio host come Java, Python o .NET non sono soggetti a questi vincoli, perché l'host-language traversal builder produce bytecode che il motore di Neptune consuma direttamente.
Cosa può contenere uno script
-
Tutte le query devono iniziare con
g, l'oggetto di attraversamento. -
È possibile inviare più traversate in un unico invio separato da un punto e virgola (
;) o un carattere di nuova riga (\n). Ogni affermazione diversa dall'ultima deve terminare con un.iterate()passaggio da eseguire; vengono restituiti solo i dati dell'attraversamento finale.
Riferimento TinkerPop valori di enumerazione
Dove a TinkerPop il valore di enumerazione è previsto come argomento graduale (ad esempio, una cardinalità su property() o un ordine su by()), usa i valori abbreviati riconosciuti dalla grammatica ANTLR. Neptune non risolve nomi di classi Java completamente qualificati in questa posizione, ad esempio, org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single non è accettato; usa single invece.
La tabella seguente elenca i valori abbreviati consentiti e quelli sottostanti TinkerPop classe a cui appartiene ciascuno.
| Valori consentiti | Classe |
|---|---|
id, key, label, value |
|
T.id, T.key, T.label, T.value |
|
set, single |
org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality |
asc, desc, shuffle |
|
Order.asc, Order.desc, Order.shuffle |
|
global, local |
|
Scope.global, Scope.local |
|
all, first, last, mixed |
|
normSack |
org.apache.tinkerpop.gremlin.process.traversal.SackFunctions.Barrier |
addAll, and, assign, div,
max, min, minus, mult,
or, sum, sumLong |
|
keys, values |
|
BOTH, IN, OUT |
|
any, none, unproductive |
org.apache.tinkerpop.gremlin.process.traversal.step.TraversalOptionParent.Pick |
Cosa non può contenere uno script
I seguenti sono non supportati nelle query Gremlin con stringhe di testo su Neptune, perché si basano sul supporto del runtime Groovy o Java che Neptune non fornisce:
-
Dichiarazioni Groovy che non iniziano con
g. Questo include:Espressioni aritmetiche come
1 + 1Chiamate di sistema come
System.nanoTime()Dichiarazioni di variabili come
x = 1; g.V(x)
-
Chiamate a metodi o librerie Java diverse dalle API Gremlin supportate. Ad esempio,
java.lang.*,Date()eg.V().tryNext().orElseGet(...)non sono consentite. -
Metodi Gremlin che accettano un tipo Java come argomento. Questi sono raggiungibili solo da un JVM-language host, non da un invio di stringhe di testo. Esempi:
org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.program(org.apache.tinkerpop.gremlin.process.computer.VertexProgram)org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.sideEffect(java.util.function.Consumer)org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.from(org.apache.tinkerpop.gremlin.structure.Vertex)org.apache.tinkerpop.gremlin.process.traversal.dsl.graph.GraphTraversal.to(org.apache.tinkerpop.gremlin.structure.Vertex)
Ad esempio, il seguente attraversamento non può essere inviato come stringa di testo:
g.V().addE('something').from(__.V().next()).to(__.V().next()).
Proprietà sugli elementi
A partire dalla versione 1.5.0.0 del motore Amazon Neptune, puoi utilizzare materializeProperties bandiera, introdotta in TinkerPop 3.7.0, per controllare se la query restituisce proprietà sugli elementi (vertici e bordi) nel risultato. Per ulteriori informazioni, vedere Proprietà degli elementi
Si imposta la bandiera su una traversata utilizzando il with() fase di configurazione:
g.with('materializeProperties', 'all')restituisce elementi con le loro proprietà incluse in linea nel risultato.g.with('materializeProperties', 'tokens')restituisce gli elementi solo come riferimenti (ovvero, solo con i loroidelabele nessuna proprietà).
Quando il flag non è impostato in modo esplicito, il comportamento predefinito dipende dal serializzatore utilizzato dalla richiesta, non dal metodo di trasporto o di invio:
Le richieste GraphSon (come le richieste HTTP e basate su script) restituiscono per impostazione predefinita proprietà, il che equivale a
all.GraphBinary richieste (come i moderni client Gremlin Language Variant (GLV) come
gremlin-pythonegremlin-javaoltre un WebSocket) per impostazione predefinita restituisce solo i riferimenti, il che equivale atokens.
È possibile sovrascrivere entrambe le impostazioni predefinite impostando materializeProperties contrassegnare esplicitamente con with() passo, come mostrato in precedenza.
Neptune non accetta null, Map, o UUID valori come valori delle proprietà dei vertici o degli spigoli. Set-i valori delle proprietà di cardinalità sono supportati (vedere Cardinalità delle proprietà dei vertici), ma i valori delle proprietà che sono essi stessi insiemi, ossia una singola proprietà il cui valore è un insieme di elementi annidati, non sono supportati.
Meta-properties
Neptune non supporta le meta-proprietà, ovvero le proprietà sulle proprietà. Tentativo di associare una proprietà a un'altra proprietà tramite TinkerPopè VertexProperty.property(...) L'API non mantiene il valore annidato.
Ordinamento di vertici, bordi e proprietà
Neptune non mantiene l'ordine di inserimento per vertici, bordi o proprietà. Ordine di iterazione per V(), E(), e l'enumerazione delle proprietà è determinata da un hash interno dell'elemento (id, key, value) tupla.
Questo comportamento non è esclusivo di Neptune. L'Apache TinkerPop la specifica non richiede ai provider di imporre l'ordine di inserimento per vertici, bordi o proprietà, quindi la maggior parte dei database a grafo si comporta allo stesso modo. Potresti riscontrare l'aspettativa di un ordine di inserimento preservato dai grafici in memoria come TinkerGraph che lo preservano.
Se l'applicazione richiede un ordine di iterazione deterministico, applicane uno esplicito order() passo con una stalla by() modulatore (ad esempio order().by(id) o order().by('name')) anziché affidarsi all'ordine di inserimento.
Offset data/ora
Neptune rappresenta internamente i valori di data e ora come istanti: UTC-based punti nel tempo. Quando asDate() oppure un passaggio data/ora correlato viene applicato a una stringa con un offset di fuso orario (ad esempio, '2024-01-15T10:30:00+05:00'), l'offset viene normalizzato in UTC e le informazioni di offset originali non vengono conservate nel risultato di andata e ritorno.
Sessioni
Le sessioni in Neptune hanno una durata limitata di soli 10 minuti. Vedi Sessioni basate su script Gremlin e il TinkerPop Riferimento alla sessione
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.
Si applica solo ai metodi dove invii la query Gremlin come stringa di testo (vedi Transazioni Gremlin).
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.
Il comando Load di Neptune richiede che tutti gli ID siano specificati utilizzando il campo ~id nel formato CSV di Neptune.
User-supplied ID
User-supplied Gli ID sono ammessi in Neptune Gremlin con le seguenti clausole.
Gli ID forniti sono facoltativi.
Sono supportati solo i vertici e gli edge.
È supportato solo il tipo
String.
Per creare un nuovo vertice con un ID personalizzato, utilizza la fase property con la parola chiave id: g.addV().property(id, 'customid').
Non mettere tra virgolette la parola chiave id. Si riferisce a T.id.
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à, vedere Vertice
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à.
Modifica della cardinalità di una proprietà del vertice da single a set attraverso property(set, ...) non rimuove il valore a cardinalità singola esistente. Il valore singolo rimane nel set di proprietà insieme a qualsiasi nuovo valore impostato. Per sostituire un valore singolo esistente, elimina prima la proprietà con properties(...).drop() prima di applicare il nuovo valore set-cardinality.
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").
Il delimitatore :: è riservato solo a quest'uso. Non è possibile specificare più etichette nella fase hasLabel. Ad esempio, hasLabel("Label1::Label2") non corrisponde a nulla.
Caratteri escape
Neptune risolve tutti i caratteri escape come descritto nella sezione Escape dei caratteri speciali
Serializzazione
Neptune supporta le serializzazioni seguenti in base al tipo MIME richiesto.
Con Neptune, puoi usare molti dei serializzatori che TinkerPop offre, con supporto per le varie versioni e configurazioni di GraphsON e GraphBinary. Consulta la tabella seguente per i serializzatori attualmente supportati. Nonostante siano presenti molte opzioni, la guida da utilizzare è semplice:
-
Se stai usando Apache TinkerPop driver, preferite l'impostazione predefinita per il driver senza specificarne uno esplicitamente. A meno che non si abbia un motivo molto specifico per farlo, probabilmente non è necessario specificare il serializzatore nell'inizializzazione del driver. In generale, l'impostazione predefinita utilizzata dai driver è
application/vnd.graphbinary-v1.0. -
Se ti connetti a Neptune tramite HTTP, dai la priorità all'uso di
application/vnd.gremlin-v3.0+json;types=falsepoiché i tipi incorporati nella versione alternativa di GraphsON 3 ne rendono complicato il funzionamento. -
Il
application/vnd.graphbinary-v1.0-stringdè generalmente utile solo se usato insieme a Console Gremlin poiché converte tutti i risultati in una rappresentazione di stringa per una semplice visualizzazione. -
I formati rimanenti rimangono presenti per motivi precedenti e in genere non devono essere utilizzati con i driver senza una chiara causa.
| Tipo MIME | Serializzazione | Configurazione |
|
GraphSONUntypedMessageSerializerV1 |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1] |
|
GraphSONMessageSerializerV2 |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV2] |
|
GraphSONUntypedMessageSerializerV2 |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV2] |
|
GraphSONMessageSerializerV3 |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3] |
|
GraphSONUntypedMessageSerializerV3 |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3] |
|
GraphSONUntypedMessageSerializerV3 |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1] |
|
GraphBinaryMessageSerializerV1 |
|
|
GraphBinaryMessageSerializerV1 |
serializeResultToString: true |
|
GraphSONMessageSerializerGremlinV1 |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1] |
|
GraphSONMessageSerializerV2 (funziona solo con WebSockets) |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV2] |
|
GraphSONMessageSerializerV3 |
|
|
GraphSONMessageSerializerV3 |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3] |
|
GraphBinaryMessageSerializerV1 |
|
La tabella dei serializzatori mostrata qui si riferisce alla denominazione a partire da TinkerPop 3.7.0. Se desideri saperne di più su questa modifica, consulta la TinkerPop documentazione sull'aggiornamento
Passaggi Lambda
Neptune non supporta i passaggi Lambda.
Passaggi Gremlin non supportati
Neptune non supporta i passaggi Gremlin seguenti:
Il passaggio io( )
Gremlin è supportata solo parzialmente in Neptune. Puoi usarlo in un contesto di lettura, come in g.io("https://example.com/data/my-graph.graphml").read(), ma non puoi usarlo per scrivere. Per leggere un file archiviato come oggetto Amazon S3, genera prima un URL prefirmato. Quindi passa l'URL HTTPS ag.io(). Per ulteriori informazioni sugli URL prefirmati, consulta Scarica e carica oggetti con URL prefirmati nel Guida per l'utente di Amazon S3.
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 Neptune per grafico caratteristiche
Le caratteristiche del grafo Neptune, se supportate, sono le stesse di quelle restituite dal comando graph.features().
| Caratteristica del grafo | Abilitata? |
|---|---|
Transactions |
true |
ThreadedTransactions |
false |
Computer |
false |
Persistence |
true |
ConcurrentAccess |
true |
Supporto di Neptune delle funzionalità della variabile
| Caratteristica della variabile | Abilitata? |
|---|---|
Variables |
false |
SerializableValues |
false |
UniformListValues |
false |
BooleanArrayValues |
false |
DoubleArrayValues |
false |
IntegerArrayValues |
false |
StringArrayValues |
false |
BooleanValues |
false |
ByteValues |
false |
DoubleValues |
false |
FloatValues |
false |
IntegerValues |
false |
LongValues |
false |
MapValues |
false |
MixedListValues |
false |
StringValues |
false |
ByteArrayValues |
false |
FloatArrayValues |
false |
LongArrayValues |
false |
Supporto di Neptune delle caratteristiche del vertice
| Caratteristica del vertice | Abilitata? |
|---|---|
MetaProperties |
false |
DuplicateMultiProperties |
false |
AddVertices |
true |
RemoveVertices |
true |
MultiProperties |
true |
UserSuppliedIds |
true |
AddProperty |
true |
RemoveProperty |
true |
NumericIds |
false |
StringIds |
true |
UuidIds |
false |
CustomIds |
false |
AnyIds |
false |
Supporto di Neptune delle caratteristiche della proprietà del vertice
| Caratteristica della proprietà del vertice | Abilitata? |
|---|---|
UserSuppliedIds |
false |
AddProperty |
true |
RemoveProperty |
true |
NumericIds |
true |
StringIds |
true |
UuidIds |
false |
CustomIds |
false |
AnyIds |
false |
Properties |
true |
SerializableValues |
false |
| UniformListValues | false |
BooleanArrayValues |
false |
DoubleArrayValues |
false |
IntegerArrayValues |
false |
StringArrayValues |
false |
BooleanValues |
true |
ByteValues |
true |
DoubleValues |
true |
FloatValues |
true |
IntegerValues |
true |
LongValues |
true |
MapValues |
false |
MixedListValues |
false |
StringValues |
true |
ByteArrayValues |
false |
FloatArrayValues |
false |
LongArrayValues |
false |
Supporto di Neptune delle caratteristiche dell'arco
| Caratteristica dell'arco | Abilitata? |
|---|---|
AddEdges |
true |
RemoveEdges |
true |
UserSuppliedIds |
true |
AddProperty |
true |
RemoveProperty |
true |
NumericIds |
false |
StringIds |
true |
UuidIds |
false |
CustomIds |
false |
AnyIds |
false |
Supporto di Neptune delle caratteristiche della proprietà dell'arco
| Caratteristica della proprietà dell'arco | Abilitata? |
|---|---|
Properties |
true |
SerializableValues |
false |
UniformListValues |
false |
BooleanArrayValues |
false |
DoubleArrayValues |
false |
IntegerArrayValues |
false |
StringArrayValues |
false |
BooleanValues |
true |
ByteValues |
true |
DoubleValues |
true |
FloatValues |
true |
IntegerValues |
true |
LongValues |
true |
MapValues |
false |
MixedListValues |
false |
StringValues |
true |
ByteArrayValues |
false |
FloatArrayValues |
false |
LongArrayValues |
false |