As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.

# Conformidade com os padrões do Gremlin no Amazon Neptune
<a name="access-graph-gremlin-differences"></a>

As seções a seguir fornecem uma visão geral da implementação do Gremlin no Neptune e como ela difere da implementação do Apache. TinkerPop 

O Neptune implementa algumas etapas do Gremlin nativamente em seu mecanismo e usa a implementação do TinkerPop Apache Gremlin para processar outras (consulte). [Suporte nativo para etapas do Gremlin no Amazon Neptune](gremlin-step-support.md)

**nota**  
Para obter exemplos concretos dessas diferenças de implementação mostradas no console do Gremlin e no Amazon Neptune, consulte a seção [Usar o Gremlin para acessar os dados de grafo no Amazon Neptune](get-started-graph-gremlin.md) do Quick Start.

**Topics**
+ [Padrões aplicáveis para Gremlin](#feature-gremlin-applicable-standards)
+ [Variáveis e parâmetros em scripts](#feature-gremlin-differences-variables)
+ [TinkerPop enumerações](#feature-gremlin-differences-tinkerpop)
+ [Código Java](#feature-gremlin-differences-java)
+ [Propriedades em elementos](#feature-gremlin-differences-properties-on-elements)
+ [Execução do script](#feature-gremlin-differences-script)
+ [Sessões](#feature-gremlin-differences-sessions)
+ [Transações](#feature-gremlin-differences-transactions)
+ [IDs de vértice e de borda](#feature-gremlin-differences-vertex-edge-ids)
+ [User-supplied IDs](#feature-gremlin-differences-user-supplied-ids)
+ [IDs de propriedades de vértice](#feature-gremlin-differences-vertex-property-ids)
+ [Cardinalidade de propriedades de vértice](#feature-gremlin-differences-vertex-property-cardinality)
+ [Atualizar uma propriedade de vértice](#feature-gremlin-differences-vertex-property-update)
+ [Rótulos](#feature-gremlin-differences-labels)
+ [Caracteres de escape](#feature-gremlin-differences-escapes)
+ [Limitações do Groovy](#feature-gremlin-differences-groovy)
+ [Serialização](#feature-gremlin-differences-serialization)
+ [Etapas do Lambda](#feature-gremlin-differences-lambda)
+ [Métodos do Gremlin não compatíveis](#feature-gremlin-differences-unsupported-methods)
+ [Etapas do Gremlin não compatíveis](#feature-gremlin-differences-unsupported-steps)
+ [Atributos do grafo do Gremlin no Neptune](#gremlin-api-reference-features)

## Padrões aplicáveis para Gremlin
<a name="feature-gremlin-applicable-standards"></a>
+ A linguagem Gremlin é definida pela [ TinkerPop documentação do Apache](http://tinkerpop.apache.org/docs/current/reference/) e pela TinkerPop implementação do Gremlin pelo Apache, e não por uma especificação formal.
+ Para formatos numéricos, o Gremlin segue o padrão IEEE 754 (IEEE 754-2019 - Padrão [IEEE](https://standards.ieee.org/content/ieee-standards/en/standard/754-2019.html) para Aritmética). Floating-Point Para obter mais informações, consulte também a [página IEEE 754 da Wikipedia](https://en.wikipedia.org/wiki/IEEE_754)).

## Variáveis e parâmetros em scripts
<a name="feature-gremlin-differences-variables"></a>

No que diz respeito às variáveis pré-vinculadas, o objeto de travessia está `g` em Pre-bound Netuno e o objeto não é suportado. `graph`

Embora o Neptune não seja compatível com variáveis do Gremlin nem com a parametrização em scripts, é possível encontrar exemplos de scripts para o Gremlin Server na Internet que contêm declarações de variáveis, como:

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

Também há muitos exemplos que usam [parametrização](https://tinkerpop.apache.org/docs/current/reference/#parameterized-scripts) (ou vinculações) ao 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();
```

Os exemplos de parâmetro geralmente são associados a avisos sobre penalidades de desempenho por não parametrizar quando possível. Você pode encontrar muitos exemplos desse tipo, e todos parecem bastante convincentes sobre a necessidade de parametrizar. TinkerPop 

No entanto, tanto o recurso de declaração de variáveis quanto o recurso de parametrização (junto com os avisos) só se aplicam ao Gremlin Server quando TinkerPop ele está usando o. `GremlinGroovyScriptEngine` Eles não se aplicam quando o Gremlin Server usa a gramática `gremlin-language` ANTLR do Gremlin para analisar consultas. A gramática ANTLR não aceita declarações de variáveis nem parametrização, portanto, ao usar o ANTLR, você não precisa se preocupar em deixar de parametrizar. Como a gramática ANTLR é um componente mais recente TinkerPop, o conteúdo mais antigo que você pode encontrar na Internet geralmente não reflete essa distinção.

O Neptune usa a gramática ANTLR no mecanismo de processamento de consultas em vez do `GremlinGroovyScriptEngine`, portanto, não é compatível com variáveis, parametrização nem com a propriedade `bindings`. Como resultado, os problemas relacionados à falha na parametrização não se aplicam ao Neptune. Usando o Neptune, é perfeitamente seguro simplesmente enviar a consulta como está, onde normalmente seria parametrizada. Como resultado, o exemplo anterior pode ser simplificado sem penalidades de desempenho da seguinte forma:

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

## TinkerPop enumerações
<a name="feature-gremlin-differences-tinkerpop"></a>

O Neptune não é compatível com nomes de classes totalmente qualificados para valores de enumeração. Por exemplo, você deve usar `single` e não `org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single` na solicitação do Groovy.

O tipo de enumeração é determinado pelo tipo do parâmetro.

A tabela a seguir mostra os valores de enumeração permitidos e o nome TinkerPop totalmente qualificado relacionado.

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

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

O Neptune não é compatível com chamadas para métodos definidos por chamadas arbitrárias do Java ou da biblioteca Java que não sejam as APIs do Gremlin compatíveis. Por exemplo `java.lang.*`, `Date()` e `g.V().tryNext().orElseGet()` não são permitidos.

## Propriedades em elementos
<a name="feature-gremlin-differences-properties-on-elements"></a>

 Neptune não suporta `materializeProperties` o sinalizador que foi introduzido TinkerPop na versão 3.7.0 para retornar propriedades em elementos. Como resultado, o Neptune retornará somente vértices ou bordas como referências com somente seu `id` e `label`.

## Execução do script
<a name="feature-gremlin-differences-script"></a>

Todas as consultas devem começar com `g`, o objeto de percurso. 

Em envios de consulta de string, é possível emitir vários percursos separados por ponto-e-vírgula (`;`) ou um caractere de nova linha (`\n`). Para ser executada, cada instrução que não seja a última deve terminar com uma etapa `.iterate()`. Somente os dados de percurso final são retornados. Observe que isso não se aplica aos envios de ByteCode consultas GLV.

## Sessões
<a name="feature-gremlin-differences-sessions"></a>

As sessões no Neptune se limitam a apenas dez minutos de duração. Consulte [Sessões baseadas em script do Gremlin](access-graph-gremlin-sessions.md) a [Referência da TinkerPop sessão](https://tinkerpop.apache.org/docs/current/reference/#console-sessions) para obter mais informações.

## Transações
<a name="feature-gremlin-differences-transactions"></a>

O Neptune abre uma nova transação no início de cada percurso do Gremlin e fecha a transação após a conclusão bem-sucedida do percurso. A operação é revertida quando há um erro. 

 Várias instruções separadas por um ponto-e-vírgula (`;`) ou um caractere de nova linha (`\n`) são incluídos em uma única transação. Cada instrução diferente da última deve terminar com uma etapa `next()` a ser executada. Somente os dados de percurso final são retornados.

A lógica da transação manual que usa `tx.commit()` e `tx.rollback()` não é compatível.

**Importante**  
Isso se aplica ***somente*** a métodos nos quais você envia a consulta do Gremlin como uma ***string de texto*** (consulte [Transações do Gremlin](access-graph-gremlin-transactions.md)).

## IDs de vértice e de borda
<a name="feature-gremlin-differences-vertex-edge-ids"></a>

Os IDs de vértice e borda do Gremlin no Neptune devem ser do tipo `String`. Essas strings de ID são compatíveis com caracteres Unicode e não podem exceder 55 MB de tamanho.

User-supplied Os IDs são suportados, mas são opcionais no uso normal. Se você não fornecer um ID ao adicionar um vértice ou uma borda, o Neptune vai gerar um UUID e convertê-lo em uma string, da seguinte forma: `"48af8178-50ce-971a-fc41-8c9a954cea62"`. Esses UUIDs não estão em conformidade com o padrão RFC, portanto, se você precisar de UUIDs padrão, deverá gerá-los externamente e fornecê-los ao adicionar vértices ou bordas.

**nota**  
O comando `Load` do Neptune exige que você forneça IDs usando o campo **\~id;** no formato CSV do Neptune.

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

User-supplied Os IDs são permitidos no Neptune Gremlin com as seguintes estipulações.
+ Os IDs fornecidos são opcionais.
+ Somente vértices e pontos são compatíveis.
+ Somente o tipo `String` é compatível.

Para criar um novo vértice com um ID personalizado, use a etapa `property` com a palavra-chave `id`: `g.addV().property(id, 'customid')`.

**nota**  
 Não coloque aspas em torno da palavra-chave `id`. Ela se refere a `T.id`.

Todos os IDs de vértice devem ser exclusivos, e todos os IDs de presença devem ser exclusivos. O Neptune, no entanto, permite que um vértice e uma borda tenham o mesmo ID.

Se você tentar criar um novo vértice usando o `g.addV()` e já existir um vértice com esse ID, haverá falha na operação. A exceção para isso é que, se você especificar um novo rótulo para o vértice, a operação terá êxito, mas adiciona o novo rótulo e quaisquer propriedades adicionais especificadas ao vértice existente. Nada é substituído. Um novo vértice não é criado. O ID do vértice não altera e permanece exclusivo.

Por exemplo, os comandos a seguir do Gremlin Console serão bem-sucedidos:

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

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

Os IDs de propriedades de vértice são gerados automaticamente e podem ser exibidos como números positivos ou negativos quando consultados.

## Cardinalidade de propriedades de vértice
<a name="feature-gremlin-differences-vertex-property-cardinality"></a>

O Neptune é compatível com a cardinalidade set e a cardinalidade single. Se não estiver especificado, a cardinalidade set será selecionada. Isso significa que, se você definir um valor para a propriedade, um novo valor será adicionado à propriedade, mas somente se ela ainda estiver exibida no conjunto de valores. Esse é o valor da enumeração do Gremlin de [Set](https://tinkerpop.apache.org/javadocs/3.7.2/core/org/apache/tinkerpop/gremlin/structure/VertexProperty.Cardinality.html). 

Não há suporte ao `List`. Para obter mais informações sobre a cardinalidade da propriedade, consulte o tópico [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...-) no Gremlin. JavaDoc

## Atualizar uma propriedade de vértice
<a name="feature-gremlin-differences-vertex-property-update"></a>

Para atualizar o valor de uma propriedade sem adicionar mais um valor ao conjunto de valores, especifique cardinalidade `single` na etapa `property`.

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

Isso remove todos os valores existentes da propriedade.

## Rótulos
<a name="feature-gremlin-differences-labels"></a>

O Neptune é compatível com vários rótulos para um vértice. Quando cria um rótulo, você pode especificar vários rótulos separados com `::`. Por exemplo, `g.addV("Label1::Label2::Label3")` adiciona um vértice com três diferentes rótulos. A etapa `hasLabel` corresponde esse vértice com qualquer um destes três rótulos: `hasLabel("Label1")`, `hasLabel("Label2")` e `hasLabel("Label3")`. 

**Importante**  
O delimitador `::` é reservado somente para esse uso. Você não pode especificar vários rótulos na etapa `hasLabel`. Por exemplo, `hasLabel("Label1::Label2")` não corresponde a nada.

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

O Neptune resolve todos os caracteres de escape, conforme descrito na seção [Escaping Special Characters]( http://groovy-lang.org/syntax.html#_escaping_special_characters) da documentação da linguagem Apache Groovy.

## Limitações do Groovy
<a name="feature-gremlin-differences-groovy"></a>

O Neptune não é compatível com comandos do Groovy que não começam com `g`. Isso inclui matemática (por exemplo: `1+1`), chamadas do sistema (por exemplo: `System.nanoTime()`) e definições das variáveis (por exemplo: `1+1`).

**Importante**  
O Neptune não é compatível com nomes de classes totalmente qualificados. Por exemplo, você deve usar `single` e não `org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single` na solicitação do Groovy.

## Serialização
<a name="feature-gremlin-differences-serialization"></a>

O Neptune é compatível com as serializações a seguir com base no tipo MIME solicitado.

 O Neptune expõe todos os serializadores TinkerPop que o fazem, com suporte para as várias versões e configurações do GraphSon e. GraphBinary Apesar de haver muitas opções presentes, a orientação sobre qual usar é simples: 
+  Se você estiver usando TinkerPop drivers Apache, prefira o padrão para o driver sem especificar um explicitamente. A menos que você tenha um motivo muito específico, provavelmente não precisará especificar o serializador na inicialização do driver. Em geral, o padrão usado pelos drivers é `application/vnd.graphbinary-v1.0`. 
+  Se você estiver se conectando ao Neptune via HTTP, priorize usar `application/vnd.gremlin-v3.0+json;types=false`, pois os tipos incorporados na versão alternativa do GraphSON 3 dificultam o trabalho. 
+  Geralmente, `application/vnd.graphbinary-v1.0-stringd` só é útil quando usado em conjunto com o [Gremlin Console](https://docs.aws.amazon.com//neptune/latest/userguide/access-graph-gremlin-console.html), pois converte todos os resultados em uma representação de string para exibição simples. 
+  Os formatos restantes permanecem presentes por motivos de legado e normalmente não devem ser usados com drivers sem motivo claro. 

|  |  |  | 
| --- |--- |--- |
| Tipo MIME | Serialização | Configuração | 
| `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(só funciona com 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**  
 A tabela do serializador mostrada aqui se refere à nomenclatura a partir da versão 3.7.0. TinkerPop Se você quiser saber mais sobre essa mudança, consulte a [documentação de TinkerPop atualização](https://tinkerpop.apache.org/docs/current/upgrade/#_serializer_renaming). O suporte à serialização Gryo foi descontinuado na versão 3.4.3 e oficialmente removido na versão 3.6.0. Se você estiver usando explicitamente o Gryo ou em uma versão de driver que o usa por padrão, você deve mudar GraphBinary ou atualizar seu driver. 

## Etapas do Lambda
<a name="feature-gremlin-differences-lambda"></a>

O Neptune não é compatível com as etapas do Lambda.

## Métodos do Gremlin não compatíveis
<a name="feature-gremlin-differences-unsupported-methods"></a>

O Neptune não é compatível com os seguintes métodos do 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 exemplo, a seguinte travessia não é permitida: `g.V().addE('something').from(__.V().next()).to(__.V().next())`

**Importante**  
Isso se aplica ***somente*** a métodos onde você envia a consulta Gremlin como uma ***string de texto***.

## Etapas do Gremlin não compatíveis
<a name="feature-gremlin-differences-unsupported-steps"></a>

O Neptune não é compatível com as seguintes etapas de Gremlin:
+ A [Etapa io( )](http://tinkerpop.apache.org/docs/3.7.2/reference/#io-step) do Gremlin é compatível apenas parcialmente com o Neptune. Ela pode ser usada em um contexto de leitura, como em `g.io({{(url)}}).read()`, mas não para escrever.

## Atributos do grafo do Gremlin no Neptune
<a name="gremlin-api-reference-features"></a>

A implementação do Gremlin no Neptune não expõe o objeto `graph`. As tabelas a seguir listam os atributos do Gremlin e indicam se o Neptune é compatível ou não com eles.

### `Suporte do Neptune para recursos gráficos`
<a name="gremlin-api-graph-features"></a>

Os atributos de grafo do Neptune, quando compatíveis, são os mesmos que seriam gerados pelo comando `graph.features()`.


| 
| 
| Atributo do grafo | Habilitado? | 
| --- |--- |
| Transactions |  verdadeiro | 
| ThreadedTransactions |  false | 
| Computer |  false | 
| Persistence |  true | 
| ConcurrentAccess |  true | 

### Compatibilidade do Neptune com atributos de variável
<a name="gremlin-api-variable-features"></a>


| 
| 
| Atributo de variável | Habilitado? | 
| --- |--- |
| 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 | 

### Compatibilidade do Neptune com atributos do vértice
<a name="gremlin-api-vertex-features"></a>


| 
| 
| Atributo de vértice | Habilitado? | 
| --- |--- |
| MetaProperties |  false | 
| DuplicateMultiProperties |  false | 
| AddVertices |  true | 
| RemoveVertices |  true | 
| MultiProperties |  true | 
| UserSuppliedIds |  true | 
| AddProperty |  true | 
| RemoveProperty |  verdadeiro | 
| NumericIds |  false | 
| StringIds |  verdadeiro | 
| UuidIds |  false | 
| CustomIds |  false | 
| AnyIds |  false | 

### Compatibilidade do Neptune com atributos de propriedade do vértice
<a name="gremlin-api-vertex-property-features"></a>


| 
| 
| Atributo de propriedade de vértice | Habilitado? | 
| --- |--- |
| UserSuppliedIds |  false | 
| AddProperty |  true | 
| RemoveProperty |  true | 
| NumericIds |  true | 
| StringIds |  verdadeiro | 
| UuidIds |  false | 
| CustomIds |  false | 
| AnyIds |  false | 
| Properties |  verdadeiro | 
| SerializableValues |  false | 
|  UniformListValues |  false | 
| BooleanArrayValues |  false | 
| DoubleArrayValues |  false | 
| IntegerArrayValues |  false | 
| StringArrayValues |  false | 
| BooleanValues |  true | 
| ByteValues |  true | 
| DoubleValues |  true | 
| FloatValues |  true | 
| IntegerValues |  true | 
| LongValues |  verdadeiro | 
| MapValues |  false | 
| MixedListValues |  false | 
| StringValues |  verdadeiro | 
| ByteArrayValues |  false | 
| FloatArrayValues |  false | 
| LongArrayValues |  false | 

### Compatibilidade do Neptune com atributos de borda
<a name="gremlin-api-edge-features"></a>


| 
| 
| Atributo de borda | Habilitado? | 
| --- |--- |
| AddEdges |  true | 
| RemoveEdges |  true | 
| UserSuppliedIds |  true | 
| AddProperty |  true | 
| RemoveProperty |  verdadeiro | 
| NumericIds |  false | 
| StringIds |  verdadeiro | 
| UuidIds |  false | 
| CustomIds |  false | 
| AnyIds |  false | 

### Compatibilidade do Neptune com atributos de propriedade de borda
<a name="gremlin-api-edge-property-features"></a>


| 
| 
| Atributo de propriedade de borda | Habilitado? | 
| --- |--- |
| Properties |  verdadeiro | 
| SerializableValues |  false | 
| UniformListValues |  false | 
| BooleanArrayValues |  false | 
| DoubleArrayValues |  false | 
| IntegerArrayValues |  false | 
| StringArrayValues |  false | 
| BooleanValues |  true | 
| ByteValues |  true | 
| DoubleValues |  true | 
| FloatValues |  true | 
| IntegerValues |  true | 
| LongValues |  verdadeiro | 
| MapValues |  false | 
| MixedListValues |  false | 
| StringValues |  verdadeiro | 
| ByteArrayValues |  false | 
| FloatArrayValues |  false | 
| LongArrayValues |  false |