Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Conformidad con los estándares de Gremlin en Amazon Neptune
<a name="access-graph-gremlin-differences"></a>

Las siguientes secciones proporcionan una descripción general de la implementación de Gremlin en Neptune y en qué se diferencia de la implementación de Apache. TinkerPop 

Neptune implementa algunos pasos de Gremlin de forma nativa en su motor y usa la implementación de Apache TinkerPop Gremlin para procesar otros (consulte). [Compatibilidad nativa con pasos de Gremlin en Amazon Neptune](gremlin-step-support.md)

**nota**  
Para ver algunos ejemplos concretos de estas diferencias de implementación que se muestran en la consola de Gremlin y Amazon Neptune, consulte la sección [Uso de Gremlin para acceder a datos de gráficos en Amazon Neptune](get-started-graph-gremlin.md) del inicio rápido.

**Topics**
+ [Estándares aplicables de Gremlin](#feature-gremlin-applicable-standards)
+ [Variables y parámetros en los scripts](#feature-gremlin-differences-variables)
+ [TinkerPop enumeraciones](#feature-gremlin-differences-tinkerpop)
+ [Código Java](#feature-gremlin-differences-java)
+ [Propiedades de los elementos](#feature-gremlin-differences-properties-on-elements)
+ [Ejecución de scripts](#feature-gremlin-differences-script)
+ [Sesiones](#feature-gremlin-differences-sessions)
+ [Transacciones](#feature-gremlin-differences-transactions)
+ [Identificador de vértice y borde](#feature-gremlin-differences-vertex-edge-ids)
+ [User-supplied IDs](#feature-gremlin-differences-user-supplied-ids)
+ [Identificadores de propiedades de vértice](#feature-gremlin-differences-vertex-property-ids)
+ [Cardinalidad de las propiedades de vértice](#feature-gremlin-differences-vertex-property-cardinality)
+ [Actualización de una propiedad de vértice](#feature-gremlin-differences-vertex-property-update)
+ [Etiquetas](#feature-gremlin-differences-labels)
+ [Caracteres de escape](#feature-gremlin-differences-escapes)
+ [Limitaciones de Groovy](#feature-gremlin-differences-groovy)
+ [Serialización](#feature-gremlin-differences-serialization)
+ [Pasos de Lambda](#feature-gremlin-differences-lambda)
+ [Métodos de Gremlin no admitidos](#feature-gremlin-differences-unsupported-methods)
+ [Pasos de Gremlin no admitidos](#feature-gremlin-differences-unsupported-steps)
+ [Características de gráficos de Gremlin en Neptune](#gremlin-api-reference-features)

## Estándares aplicables de Gremlin
<a name="feature-gremlin-applicable-standards"></a>
+ El lenguaje Gremlin se define en la [ TinkerPop documentación de Apache y en la TinkerPop implementación de Gremlin en Apache](http://tinkerpop.apache.org/docs/current/reference/), más que en una especificación formal.
+ Para los formatos numéricos, Gremlin sigue el estándar IEEE 754 (IEEE [754-2019 - Estándar IEEE de aritmética](https://standards.ieee.org/content/ieee-standards/en/standard/754-2019.html)). Floating-Point [Para obtener más información, consulte también la página de Wikipedia (IEEE 754).](https://en.wikipedia.org/wiki/IEEE_754)

## Variables y parámetros en los scripts
<a name="feature-gremlin-differences-variables"></a>

En lo que respecta a las variables preenlazadas, el objeto transversal `g` está en Pre-bound Neptune y el `graph` objeto no es compatible.

Aunque Neptune no admite variables de Gremlin ni la parametrización en los scripts, a menudo encontrará en Internet ejemplos de scripts del servidor de Gremlin que contienen declaraciones de variables, como:

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

También hay muchos ejemplos que utilizan la [parametrización](https://tinkerpop.apache.org/docs/current/reference/#parameterized-scripts) (o enlaces) al enviar consultas, como:

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

Los ejemplos de parámetros suelen estar asociados a advertencias sobre penalizaciones en el rendimiento si no se parametriza cuando es posible. Puede encontrar muchos ejemplos de este tipo, y todos parecen bastante convincentes en cuanto TinkerPop a la necesidad de parametrizar.

Sin embargo, tanto la función de declaración de variables como la función de parametrización (junto con las advertencias) solo se aplican al servidor Gremlin cuando se utiliza TinkerPop el. `GremlinGroovyScriptEngine` No se aplican cuando el servidor de Gremlin utiliza la gramática ANTLR `gremlin-language` de Gremlin para analizar las consultas. La gramática de ANTLR no admite ni las declaraciones de variables ni la parametrización, por lo que cuando utilice ANTLR, no tiene que preocuparse por no poder parametrizar. Como la gramática del ANTLR es un componente más reciente TinkerPop, el contenido más antiguo que puedas encontrar en Internet no suele reflejar esta distinción.

Neptune utiliza la gramática de ANTLR en su motor de procesamiento de consultas en lugar del `GremlinGroovyScriptEngine`, por lo que no admite variables, parametrización ni la propiedad `bindings`. Como resultado, los problemas relacionados con la falta de parametrización no se aplican en Neptune. Con Neptune, es perfectamente seguro enviar la consulta tal cual, cuando lo normal sería parametrizarla. Como resultado, el ejemplo anterior se puede simplificar sin ninguna penalización en el rendimiento de la siguiente manera:

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

## TinkerPop enumeraciones
<a name="feature-gremlin-differences-tinkerpop"></a>

Neptune no admite nombres completos de clase para los valores de enumeración. Por ejemplo, debe utilizar `single` y no `org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single` en la solicitud de Groovy.

El tipo de enumeración viene determinado por el tipo de parámetro.

La siguiente tabla muestra los valores de enumeración permitidos y el nombre TinkerPop completo correspondiente.

| Valores permitidos | Clase | 
| --- |--- |
| 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) | 

## Código Java
<a name="feature-gremlin-differences-java"></a>

Neptune no admite las llamadas a métodos que se definen mediante llamadas arbitrarias a Java o a bibliotecas de Java, aparte de las API de Gremlin admitidas. Por ejemplo `java.lang.*`, `Date()` y `g.V().tryNext().orElseGet()` no se permiten.

## Propiedades de los elementos
<a name="feature-gremlin-differences-properties-on-elements"></a>

 Neptune no admite la `materializeProperties` bandera que se introdujo en la TinkerPop versión 3.7.0 para devolver las propiedades de los elementos. Como resultado, Neptune seguirá devolviendo únicamente vértices o bordes como referencias solo con su `id` y `label`.

## Ejecución de scripts
<a name="feature-gremlin-differences-script"></a>

Todas las consultas debe comenzar por `g`, el objeto de recorrido. 

En los envíos de consulta de cadena, se pueden emitir varios recorridos separados por punto y coma (`;`) o por un carácter de nueva línea (`\n`). Para ejecutarse, todas las instrucciones, aparte de la última, deben finalizar con un paso `.iterate()`. Solo se devuelven los datos del recorrido final. Tenga en cuenta que esto no se aplica a los envíos de consultas de GLV ByteCode .

## Sesiones
<a name="feature-gremlin-differences-sessions"></a>

Las sesiones en Neptune se limitan a una duración de 10 minutos. Consulte [Sesiones basadas en scripts de Gremlin](access-graph-gremlin-sessions.md) la [referencia de la TinkerPop sesión](https://tinkerpop.apache.org/docs/current/reference/#console-sessions) para obtener más información.

## Transacciones
<a name="feature-gremlin-differences-transactions"></a>

Neptune abre una nueva transacción al principio de cada recorrido de Gremlin y la cierra una vez que este se completa correctamente. La transacción se revierte si se produce un error. 

 Varias instrucciones separadas por punto y coma (`;`) o por un carácter de nueva línea (`\n`) se incluyen en una sola transacción. Todas las instrucciones, aparte de la última, deben finalizar con un paso `next()` para ejecutarse. Solo se devuelven los datos del recorrido final.

No se admite la lógica de transacción manual que utiliza `tx.commit()` y `tx.rollback()`.

**importante**  
Esto ***solo*** se aplica a aquellos casos en los que envíe la consulta de Gremlin como una ***cadena de texto*** (consulte [Transacciones de Gremlin](access-graph-gremlin-transactions.md)).

## Identificador de vértice y borde
<a name="feature-gremlin-differences-vertex-edge-ids"></a>

Los identificadores de vértice y borde de Gremlin en Neptune deben ser de tipo `String`. Estas cadenas de identificación admiten caracteres Unicode y su tamaño no puede superar los 55 MB.

User-supplied Se admiten los ID, pero son opcionales en el uso normal. Si no proporciona un identificador cuando añade un vértice o un borde, Neptune genera un UUID y lo convierte en una cadena, de una forma parecida a esta: `"48af8178-50ce-971a-fc41-8c9a954cea62"`. Estos UUID no cumplen el estándar RFC, por lo que si necesita UUID estándar, debe generarlos externamente y proporcionarlos cuando añada vértices o bordes.

**nota**  
Sin embargo, el comando `Load` de Neptune requiere que proporcione identificadores mediante el campo **\~id** en formato CSV de Neptune.

## User-supplied IDs
<a name="feature-gremlin-differences-user-supplied-ids"></a>

User-supplied Las identificaciones están permitidas en Neptune Gremlin con las siguientes estipulaciones.
+ Los ID proporcionados son opcionales.
+ Solo se admiten vértices y bordes.
+ Solo se admite el tipo `String`.

Para crear un vértice con un ID personalizado, utilice el paso `property` con la palabra clave `id`: `g.addV().property(id, 'customid')`.

**nota**  
 No añada comillas alrededor de la palabra clave `id`. Hace referencia a `T.id`.

Todos los identificadores de vértice deben ser únicos y todos los identificadores de borde deben ser únicos. Sin embargo, Neptune permite que un vértice y un borde tengan el mismo identificador.

Si intenta crear un vértice con `g.addV()` y ya existe un vértice con ese ID, la operación dará error. La excepción a esta norma es que, si especifica una nueva etiqueta para el vértice, la operación se completará correctamente, pero añadirá la nueva etiqueta y las propiedades adicionales especificadas al vértice existente. No se sobrescribirá ninguna. No se creará un nuevo vértice. El ID del vértice no cambia y continúa siendo único.

Por ejemplo, los siguientes comandos de la consola de Gremlin se ejecutan correctamente:

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

## Identificadores de propiedades de vértice
<a name="feature-gremlin-differences-vertex-property-ids"></a>

Los ID de propiedades de vértice se generan automáticamente y pueden aparecer como números positivos o negativos al realizar consultas.

## Cardinalidad de las propiedades de vértice
<a name="feature-gremlin-differences-vertex-property-cardinality"></a>

Neptune admite la cardinalidad en conjuntos y la cardinalidad simple. Si no se especifica, se selecciona la cardinalidad en conjuntos. Esto significa que si establece un valor de propiedad, añade un nuevo valor a la propiedad, pero solo si este no aparece en el conjunto de valores. Este es el valor de enumeración de Gremlin de [Set (Establecer)](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/structure/VertexProperty.Cardinality.html). 

`List` no se admite. Para obtener más información sobre la cardinalidad de las propiedades, consulte el tema [Vértices en el 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

## Actualización de una propiedad de vértice
<a name="feature-gremlin-differences-vertex-property-update"></a>

Para actualizar un valor de propiedad sin añadir un valor al conjunto de valores, especifique la cardinalidad `single` en el paso `property`.

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

Esto elimina todos los valores existentes para la propiedad.

## Etiquetas
<a name="feature-gremlin-differences-labels"></a>

Neptune admite varias etiquetas para un vértice. Al crear una etiqueta, puede especificar varias si las separa mediante `::`. Por ejemplo, `g.addV("Label1::Label2::Label3")` añade un vértice con tres etiquetas distintas. El paso `hasLabel` busca coincidencias de este vértice con cualquiera de esas tres etiquetas: `hasLabel("Label1")` `hasLabel("Label2")` y `hasLabel("Label3")`. 

**importante**  
El delimitador `::` está reservado solo para este uso. No se pueden especificar varias etiquetas en el paso `hasLabel`. Por ejemplo, `hasLabel("Label1::Label2")` no tiene ninguna coincidencia.

## Caracteres de escape
<a name="feature-gremlin-differences-escapes"></a>

Neptune resuelve todos los caracteres de escape tal y como se describe en la sección [Escaping Special Characters]( http://groovy-lang.org/syntax.html#_escaping_special_characters) de la documentación del lenguaje Apache Groovy.

## Limitaciones de Groovy
<a name="feature-gremlin-differences-groovy"></a>

Neptune no admite los comandos de Groovy que no empiezan por `g`. Esto incluye expresiones matemáticas (por ejemplo, `1+1`), llamadas al sistema (por ejemplo, `System.nanoTime()`) y definiciones de variable (por ejemplo, `1+1`).

**importante**  
Neptune no admite nombres completos de clase. Por ejemplo, debe utilizar `single` y no `org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single` en la solicitud de Groovy.

## Serialización
<a name="feature-gremlin-differences-serialization"></a>

Neptune admite las siguientes serializaciones en función del tipo MIME solicitado.

 Neptune expone todos los serializadores que lo TinkerPop hacen, con soporte para las distintas versiones y configuraciones de GraphSon y. GraphBinary A pesar de que son muchas las opciones disponibles, las instrucciones sobre cuál utilizar son muy sencillas: 
+  Si utiliza TinkerPop controladores Apache, prefiera el controlador predeterminado sin especificar ninguno de forma explícita. A menos que tenga una razón muy específica para hacerlo, es probable que no necesite especificar el serializador en la inicialización del controlador. En general, el valor predeterminado que utilizan los controladores es `application/vnd.graphbinary-v1.0`. 
+  Si se conecta a Neptune a través de HTTP, priorice el uso de `application/vnd.gremlin-v3.0+json;types=false`, ya que los tipos incrustados en la versión alternativa de GraphSON 3 dificultan el trabajo. 
+  Por lo general, `application/vnd.graphbinary-v1.0-stringd` solo es útil cuando se usa junto con la [Consola de Gremlin](https://docs.aws.amazon.com//neptune/latest/userguide/access-graph-gremlin-console.html), ya que convierte todos los resultados en una representación de cadena para facilitar su visualización. 
+  Los demás formatos se mantienen por motivos de compatibilidad con las versiones anteriores y, por lo general, no deben usarse con controladores a menos que existe una causa clara para ello. 

|  |  |  | 
| --- |--- |--- |
| Tipo MIME | Serialización | Configuración | 
| `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(solo funciona 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 tabla de serializadores que se muestra aquí se refiere a la nomenclatura a partir de TinkerPop la versión 3.7.0. [Si desea obtener más información sobre este cambio, consulte la TinkerPop documentación de actualización.](https://tinkerpop.apache.org/docs/current/upgrade/#_serializer_renaming) La compatibilidad con la serialización de Gyro quedó obsoleto en la versión 3.4.3 y se eliminó oficialmente en la versión 3.6.0. Si utilizas Gryo de forma explícita o utilizas una versión de controlador que lo utiliza de forma predeterminada, deberías cambiar a tu controlador GraphBinary o actualizarlo. 

## Pasos de Lambda
<a name="feature-gremlin-differences-lambda"></a>

Neptune no admite los pasos de Lambda.

## Métodos de Gremlin no admitidos
<a name="feature-gremlin-differences-unsupported-methods"></a>

Neptune no admite los siguientes métodos de Gremlin:
+ `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)`

Por ejemplo, el recorrido siguiente no está permitido: `g.V().addE('something').from(__.V().next()).to(__.V().next())`.

**importante**  
Esto ***solo*** se aplica a aquellos casos en los que envíe la consulta de Gremlin como una ***cadena de texto***.

## Pasos de Gremlin no admitidos
<a name="feature-gremlin-differences-unsupported-steps"></a>

Neptune no admite los siguientes pasos de Gremlin:
+ El [paso io()](http://tinkerpop.apache.org/docs/3.7.2/reference/#io-step) de Gremlin solo se admite parcialmente en Neptune. Se puede usar en un contexto de lectura, como en `g.io({{(url)}}).read()`, pero no para escribir.

## Características de gráficos de Gremlin en Neptune
<a name="gremlin-api-reference-features"></a>

La implementación de Gremlin en Neptune no expone el objeto `graph`. Las siguientes tablas muestran las características de Gremlin e indican si Neptune las admite o no.

### `Soporte de Neptune para funciones gráficas`
<a name="gremlin-api-graph-features"></a>

Las características de gráficos, si se admiten, son las mismas que devolvería el comando `graph.features()`.


| 
| 
| Característica de gráfico | ¿Habilitada? | 
| --- |--- |
| Transactions |  true | 
| ThreadedTransactions |  false | 
| Computer |  false | 
| Persistence |  true | 
| ConcurrentAccess |  true | 

### Compatibilidad de Neptune con características de variables
<a name="gremlin-api-variable-features"></a>


| 
| 
| Característica de variable | ¿Habilitada? | 
| --- |--- |
| 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 | 

### Compatibilidad de Neptune con características de vértices
<a name="gremlin-api-vertex-features"></a>


| 
| 
| Característica de vértice | ¿Habilitada? | 
| --- |--- |
| 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 | 

### Compatibilidad de Neptune con características de propiedades de vértices
<a name="gremlin-api-vertex-property-features"></a>


| 
| 
| Característica de propiedad de vértice | ¿Habilitada? | 
| --- |--- |
| 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 | 

### Compatibilidad de Neptune con características de bordes
<a name="gremlin-api-edge-features"></a>


| 
| 
| Característica de borde | ¿Habilitada? | 
| --- |--- |
| AddEdges |  true | 
| RemoveEdges |  true | 
| UserSuppliedIds |  true | 
| AddProperty |  true | 
| RemoveProperty |  true | 
| NumericIds |  false | 
| StringIds |  true | 
| UuidIds |  false | 
| CustomIds |  false | 
| AnyIds |  false | 

### Compatibilidad de Neptune con características de propiedades de bordes
<a name="gremlin-api-edge-property-features"></a>


| 
| 
| Característica de propiedad de borde | ¿Habilitada? | 
| --- |--- |
| 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 |