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 seguenti sezioni forniscono una panoramica dell'implementazione di 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 TinkerPop Apache Gremlin per elaborarne altri (vedi). [Supporto nativo dei passaggi Gremlin in Amazon Neptune](gremlin-step-support.md)
**Nota**
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 grafici in Amazon Neptune](get-started-graph-gremlin.md) del Quick Start.
**Topics**
+ [Standard applicabili per Gremlin](#feature-gremlin-applicable-standards)
+ [Variabili e parametri negli script](#feature-gremlin-differences-variables)
+ [TinkerPop enumerazioni](#feature-gremlin-differences-tinkerpop)
+ [Codice Java](#feature-gremlin-differences-java)
+ [Proprietà degli elementi](#feature-gremlin-differences-properties-on-elements)
+ [Esecuzione di uno script](#feature-gremlin-differences-script)
+ [Sessioni](#feature-gremlin-differences-sessions)
+ [Transazioni](#feature-gremlin-differences-transactions)
+ [ID dei vertici e degli archi](#feature-gremlin-differences-vertex-edge-ids)
+ [User-supplied ID](#feature-gremlin-differences-user-supplied-ids)
+ [ID di proprietà dei vertici](#feature-gremlin-differences-vertex-property-ids)
+ [Cardinalità delle proprietà dei vertici](#feature-gremlin-differences-vertex-property-cardinality)
+ [Aggiornamento della proprietà di un vertice](#feature-gremlin-differences-vertex-property-update)
+ [Etichette](#feature-gremlin-differences-labels)
+ [Caratteri escape](#feature-gremlin-differences-escapes)
+ [Limitazioni Groovy](#feature-gremlin-differences-groovy)
+ [Serializzazione](#feature-gremlin-differences-serialization)
+ [Passaggi Lambda](#feature-gremlin-differences-lambda)
+ [Metodi Gremlin non supportati](#feature-gremlin-differences-unsupported-methods)
+ [Passaggi Gremlin non supportati](#feature-gremlin-differences-unsupported-steps)
+ [Caratteristiche del grafo Gremlin in Neptune](#gremlin-api-reference-features)
## Standard applicabili per Gremlin
+ Il linguaggio Gremlin è definito da [Apache TinkerPop Documentation e dall'implementazione Apache](http://tinkerpop.apache.org/docs/current/reference/) di Gremlin piuttosto che da una specifica formale. TinkerPop
+ [Per i formati numerici, Gremlin segue lo standard IEEE 754 (IEEE 754-2019 - IEEE Standard for Arithmetic). Floating-Point ](https://standards.ieee.org/content/ieee-standards/en/standard/754-2019.html) [Per ulteriori informazioni, consulta anche la pagina IEEE 754 di Wikipedia).](https://en.wikipedia.org/wiki/IEEE_754)
## Variabili e parametri negli script
Per quanto riguarda le variabili preassociate, l'oggetto di attraversamento si trova `g` in Pre-bound 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 results = client.submit(query).all().get();
```
Esistono anche molti esempi che utilizzano la [parametrizzazione](https://tinkerpop.apache.org/docs/current/reference/#parameterized-scripts) (o le associazioni) quando si inviano le query, come ad esempio:
```
Map params = new HashMap<>();
params.put("x",1);
String query = "g.V(x)";
List 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. Di esempi simili ce ne sono moltissimi, e tutti sembrano abbastanza convincenti sulla necessità di parametrizzare. TinkerPop
Tuttavia, sia la funzionalità di dichiarazione delle variabili che la funzionalità di parametrizzazione (insieme agli avvisi) si applicano al Gremlin Server solo 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 è un componente più recente di TinkerPop, i contenuti meno recenti che potresti incontrare 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 results = client.submit(query).all().get();
```
## TinkerPop enumerazioni
Neptune non supporta nomi di classe completi per i valori di enumerazione. Ad esempio, devi usare `single` e non `org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single` nella richiesta Groovy.
Il tipo di enumerazione è determinato dal tipo di parametro.
La tabella seguente mostra i valori di enumerazione consentiti e il relativo nome completo. TinkerPop
| Valori consentiti | Classe |
| --- |--- |
| id, key, label, value | [org.apache.tinkerpop.gremlin.structure.T](https://tinkerpop.apache.org/javadocs/current/core/org/apache/tinkerpop/gremlin/structure/T.html) |
| T.id, T.key, T.label, T.value | [org.apache.tinkerpop.gremlin.structure.T](https://tinkerpop.apache.org/javadocs/current/core/org/apache/tinkerpop/gremlin/structure/T.html) |
| set, single | [org.apache.tinkerpop.gremlin.structure. VertexProperty.Cardinality](https://tinkerpop.apache.org/javadocs/current/core/org/apache/tinkerpop/gremlin/structure/VertexProperty.Cardinality.html) |
| asc, desc, shuffle | [org.apache.tinkerpop.gremlin.process.traversal.Order](https://tinkerpop.apache.org/javadocs/3.7.2/full/org/apache/tinkerpop/gremlin/process/traversal/Order.html) |
| Order.asc, Order.desc, Order.shuffle | [org.apache.tinkerpop.gremlin.process.traversal.Order](https://tinkerpop.apache.org/javadocs/3.7.2/full/org/apache/tinkerpop/gremlin/process/traversal/Order.html) |
| global, local | [org.apache.tinkerpop.gremlin.process.traversal.Scope](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/process/traversal/Scope.html) |
| Scope.global, Scope.local | [org.apache.tinkerpop.gremlin.process.traversal.Scope](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/process/traversal/Scope.html) |
| all, first, last, mixed | [org.apache.tinkerpop.gremlin.process.traversal.Pop](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/process/traversal/Pop.html) |
| normSack | [org.apache.tinkerpop.gremlin.process.traversal. SackFunctions.Barrier](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/process/traversal/SackFunctions.Barrier.html) |
| addAll, and, assign, div, max, min, minus, mult, or, sum, sumLong | [org.apache.tinkerpop.gremlin.process.traversal.Operator](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/process/traversal/Operator.html) |
| keys, values | [org.apache.tinkerpop.gremlin.structure.Column](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/structure/Column.html) |
| BOTH, IN, OUT | [org.apache.tinkerpop.gremlin.structure.Direction](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/structure/Direction.html) |
| any, none | [org.apache.tinkerpop.gremlin.process.traversal.step. TraversalOptionParent.Pick](https://tinkerpop.apache.org/javadocs/current/full/org/apache/tinkerpop/gremlin/process/traversal/Pick.html) |
## Codice Java
Neptune non supporta le chiamate ai metodi definite da chiamate arbitrarie Java o libreria Java diverse da quelle API Gremlin supportate. Ad esempio, `java.lang.*`, `Date()`e `g.V().tryNext().orElseGet()` non sono consentite.
## Proprietà degli elementi
Neptune non supporta `materializeProperties` il flag introdotto TinkerPop nella 3.7.0 per restituire proprietà sugli elementi. Di conseguenza, Neptune continuerà a restituire solo vertici o spigoli come riferimenti con la sola e. `id` `label`
## Esecuzione di uno script
Tutte le query devono iniziare con `g`, l'oggetto di attraversamento.
In Invii query stringa, possono essere emessi più attraversamenti separati da un punto e virgola (`;`) o un carattere nuova riga (`\n`). Per essere eseguita, ogni istruzione diversa dall'ultima deve terminare con una fase `.iterate()`. Vengono restituiti solo i dati di attraversamento finali. Nota che ciò non si applica agli invii di query ByteCode GLV.
## Sessioni
Le sessioni in Neptune hanno una durata limitata di soli 10 minuti. Per ulteriori informazioni, consulta [Sessioni basate su script Gremlin](access-graph-gremlin-sessions.md) il [riferimento alla TinkerPop sessione](https://tinkerpop.apache.org/docs/current/reference/#console-sessions).
## 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.
**Importante**
Si applica ***solo*** ai metodi dove invii la query Gremlin come ***stringa di testo*** (vedi [Transazioni Gremlin](access-graph-gremlin-transactions.md)).
## 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.
**Nota**
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 disposizioni.
+ 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')`.
**Nota**
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](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/structure/VertexProperty.Cardinality.html).
`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")`.
**Importante**
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]( http://groovy-lang.org/syntax.html#_escaping_special_characters) della documentazione Apache Groovy Language.
## Limitazioni Groovy
Neptune non supporta i comandi Groovy che non iniziano con `g`. Questo include la matematica (ad esempio: `1+1`), le chiamate di sistema (ad esempio: `System.nanoTime()`) e le definizioni delle variabili (ad esempio: `1+1`).
**Importante**
Neptune non supporta nomi di classe completi. Ad esempio, devi usare `single` e non `org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single` nella richiesta Groovy.
## Serializzazione
Neptune supporta le serializzazioni seguenti in base al tipo MIME richiesto.
Neptune espone tutti i serializzatori TinkerPop che lo fanno, con il supporto per le varie versioni e configurazioni di GraphSon e. GraphBinary Nonostante siano presenti molte opzioni, la guida da utilizzare è semplice:
+ Se utilizzi driver Apache, preferisci l'impostazione predefinita per il TinkerPop driver senza specificarne uno in modo esplicito. A meno che non abbiate 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 `application/vnd.gremlin-v3.0+json;types=false` di poiché i tipi incorporati nella versione alternativa di GraphSon 3 lo rendono complicato da usare.
+ In genere `application/vnd.graphbinary-v1.0-stringd` è utile solo se usato insieme a [Gremlin Console](https://docs.aws.amazon.com//neptune/latest/userguide/access-graph-gremlin-console.html) in quanto converte tutti i risultati in una rappresentazione di stringa per una semplice visualizzazione.
+ I formati rimanenti rimangono presenti per ragioni obsolete e in genere non dovrebbero essere utilizzati con i driver senza una chiara causa.
| | | |
| --- |--- |--- |
| Tipo MIME | Serializzazione | Configurazione |
| `application/vnd.gremlin-v1.0+json` | GraphSONMessageSerializerV1 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1] |
| `application/vnd.gremlin-v1.0+json;types=false` | GraphSONUntypedMessageSerializerV1 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1] |
| `application/vnd.gremlin-v2.0+json` | GraphSONMessageSerializerV2 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV2] |
| `application/vnd.gremlin-v2.0+json;types=false` | GraphSONUntypedMessageSerializerV2 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV2] |
| `application/vnd.gremlin-v3.0+json` | GraphSONMessageSerializerV3 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3] |
| `application/vnd.gremlin-v3.0+json;types=false` | GraphSONUntypedMessageSerializerV3 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3] |
| `application/json` | GraphSONUntypedMessageSerializerV3 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1] |
| `application/vnd.graphbinary-v1.0` | GraphBinaryMessageSerializerV1 | |
| `application/vnd.graphbinary-v1.0-stringd` | GraphBinaryMessageSerializerV1 | serializeResultToString: true |
| `application/vnd.gremlin-v1.0+json` | GraphSONMessageSerializerGremlinV1 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1] |
| `application/vnd.gremlin-v2.0+json` | GraphSONMessageSerializerV2(funziona solo con WebSockets) | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV2] |
| `application/vnd.gremlin-v3.0+json` | `GraphSONMessageSerializerV3` | |
| `application/json` | GraphSONMessageSerializerV3 | ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3] |
| `application/vnd.graphbinary-v1.0` | GraphBinaryMessageSerializerV1 | |
**Nota**
La tabella dei serializzatori mostrata qui si riferisce alla denominazione a partire dalla versione 3.7.0. TinkerPop [Se desideri saperne di più su questa modifica, consulta la documentazione di aggiornamento. TinkerPop ](https://tinkerpop.apache.org/docs/current/upgrade/#_serializer_renaming) Il supporto per la serializzazione Gryo era obsoleto nella versione 3.4.3 ed è stato rimosso ufficialmente nella versione 3.6.0. Se state usando Gryo in modo esplicito o su una versione del driver che lo utilizza di default, allora dovreste passare al driver o aggiornarlo. GraphBinary
## Passaggi Lambda
Neptune non supporta i passaggi Lambda.
## Metodi Gremlin non supportati
Neptune non supporta i metodi Gremlin seguenti:
+ `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, l'attraversamento seguente non è consentito: `g.V().addE('something').from(__.V().next()).to(__.V().next())`.
**Importante**
Si applica ***solo*** ai metodi dove invii la query Gremlin come ***stringa di testo***.
## Passaggi Gremlin non supportati
Neptune non supporta i passaggi Gremlin seguenti:
+ Il [passaggio io( )](http://tinkerpop.apache.org/docs/3.7.2/reference/#io-step) Gremlin è supportata solo parzialmente in Neptune. Può essere usata in un contesto di lettura, come in `g.io({{(url)}}).read()`, ma non in un contesto di scrittura.
## 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()`.
|
|
| 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 |