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
Conformità agli standard Gremlin

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 dei 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)
+ [

## Vertice e spigolo IDs
](#feature-gremlin-differences-vertex-edge-ids)
+ [

## Fornito dall'utente IDs
](#feature-gremlin-differences-user-supplied-ids)
+ [

## Proprietà Vertex IDs
](#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
Standard applicabili
+ 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 Floating-Point Arithmetic](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
Variabili e parametri

Per quanto riguarda le variabili pre-bound, l'oggetto di attraversamento `g` è pre-bound in Neptune e l'oggetto `graph` 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](https://tinkerpop.apache.org/docs/current/reference/#parameterized-scripts) (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. 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<Result> results = client.submit(query).all().get();
```

## TinkerPop enumerazioni
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.Cardinalità](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.Barriera](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.Scegli](https://tinkerpop.apache.org/javadocs/current/full/org/apache/tinkerpop/gremlin/process/traversal/Pick.html) | 

## Codice Java
Codice Java

Neptune non supporta chiamate a metodi definiti da chiamate arbitrarie a Java o a librerie Java diverse da quelle supportate da Gremlin. APIs Ad esempio, `java.lang.*`, `Date()`e `g.V().tryNext().orElseGet()` non sono consentite.

## Proprietà degli elementi
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
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
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
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)).

## Vertice e spigolo IDs
Vertice e spigolo IDs

Neptune Gremlin Vertex e Edge devono essere di tipo. IDs `String` Queste stringhe di ID supportano i caratteri Unicode e non possono superare i 55 MB di dimensione.

 IDs I dati forniti dall'utente sono supportati, ma sono opzionali in caso di utilizzo 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 UUIDs non sono conformi allo standard RFC, quindi se avete bisogno di uno standard UUIDs dovreste generarli esternamente e fornirli quando aggiungete vertici o spigoli.

**Nota**  
Il comando `Load` Neptune richiede che tu IDs fornisca, utilizzando **il** campo \$1id nel formato Neptune CSV.

## Fornito dall'utente IDs
Fornito dall'utente IDs

I prodotti forniti dall'utente IDs sono consentiti in Neptune Gremlin con le seguenti condizioni.
+  IDs I prodotti forniti sono opzionali.
+ 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 i vertici IDs devono essere unici e tutti gli spigoli IDs devono essere unici. 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
```

## Proprietà Vertex IDs
Proprietà Vertex IDs

 IDs Le proprietà Vertex vengono generate automaticamente e possono essere visualizzate come numeri positivi o negativi quando vengono richieste.

## Cardinalità delle proprietà dei vertici
Cardinalità

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](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...-) nel Gremlin. JavaDoc

## Aggiornamento della proprietà di un vertice
Aggiornamento di una proprietà

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
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
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
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
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
Passaggi Lambda

Neptune non supporta i passaggi Lambda.

## Metodi Gremlin non supportati
Metodi 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
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
Caratteristiche del grafo Gremlin

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 delle funzionalità di `graph`
Funzionalità di `graph`

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
Caratteristiche 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
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
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
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
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 |