Conformidade com os padrões do Gremlin no Amazon Neptune

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

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 o grafo no Amazon Neptune do Quick Start.

Padrões aplicáveis para Gremlin

• A linguagem Gremlin é definida pela TinkerPop documentação do Apache 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 - IEEE Standard for Floating-Point Arithmetic. Para obter mais informações, consulte também a página do IEEE 754 na Wikipédia).

Variáveis e parâmetros em scripts

No que diz respeito às variáveis pré-vinculadas, o objeto de percurso g é pré-vinculado no Neptune, e o objeto graph não é compatível.

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

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
T.id, T.key, T.label, T.value	org.apache.tinkerpop.gremlin.structure.T
set, single	org.apache.tinkerpop.gremlin.structure. VertexProperty.Cardinalidade
asc, desc, shuffle	org.apache.tinkerpop.gremlin.process.traversal.Order
Order.asc, Order.desc, Order.shuffle	org.apache.tinkerpop.gremlin.process.traversal.Order
global, local	org.apache.tinkerpop.gremlin.process.traversal.Scope
Scope.global, Scope.local	org.apache.tinkerpop.gremlin.process.traversal.Scope
all, first, last, mixed	org.apache.tinkerpop.gremlin.process.traversal.Pop
normSack	org.apache.tinkerpop.gremlin.process.traversal. SackFunctions.Barreira
addAll, and, assign, div, max, min, minus, mult, or, sum, sumLong	org.apache.tinkerpop.gremlin.process.traversal.Operator
keys, values	org.apache.tinkerpop.gremlin.structure.Column
BOTH, IN, OUT	org.apache.tinkerpop.gremlin.structure.Direction
any, none	org.apache.tinkerpop.gremlin.process.traversal.step. TraversalOptionParent.Pick

Código Java

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 dos elementos

Neptune não suporta materializeProperties o sinalizador que foi introduzido TinkerPop na versão 3.7.0 para retornar propriedades em elementos. Como resultado, Netuno ainda retornará apenas vértices ou arestas como referências apenas com sua mão. id label

Execução do script

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

As sessões no Neptune se limitam a apenas dez minutos de duração. Consulte Sessões baseadas em script do Gremlin a Referência da TinkerPop sessão para obter mais informações.

Transações

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).

IDs de vértice e de borda

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.

Os IDs fornecidos pelo usuário são compatíveis, mas são opcionais em 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.

IDs fornecidos pelo usuário

Os IDs fornecidos pelo usuário são permitidos no Gremlin do Neptune com as condições a seguir.

• 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

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

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.

Não há suporte ao List. Para obter mais informações sobre a cardinalidade da propriedade, consulte o tópico Vertex no Gremlin. JavaDoc

Atualizar uma propriedade de vértice

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

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

O Neptune resolve todos os caracteres de escape, conforme descrito na seção Escaping Special Characters da documentação da linguagem Apache Groovy.

Limitações do Groovy

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

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

Tipo MIME	Serialização	Configuração
application/vnd.gremlin-v1.0+gryo	GryoMessageSerializerV1	ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1]
application/vnd.gremlin-v1.0+gryo-stringd	GryoMessageSerializerV1	serializeResultToString: true}
application/vnd.gremlin-v3.0+gryo	GryoMessageSerializerV3	ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3]
application/vnd.gremlin-v3.0+gryo-stringd	GryoMessageSerializerV3	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

Embora o Neptune ofereça suporte a esses diferentes tipos de serializadores, a orientação para seu uso é bastante direta. Se você estiver se conectando ao Neptune via HTTP, priorize o uso application/vnd.gremlin-v3.0+json;types=false de, pois os tipos incorporados na versão alternativa do GraphSon 3 dificultam o trabalho. Se você estiver usando TinkerPop drivers Apache, provavelmente não precisará fazer nenhuma escolha, pois usaria o padrão deapplication/vnd.graphbinary-v1.0. Os formatos restantes permanecem presentes por motivos legados.

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. O suporte à serialização Gryo foi descontinuado na versão 3.4.3 e foi 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 para o driver GraphBinary ou atualizá-lo.

Etapas do Lambda

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

Métodos do Gremlin não compatíveis

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

O Neptune não é compatível com as seguintes etapas de Gremlin:

• A Etapa io( ) 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 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.

Compatibilidade do Neptune com atributos do graph

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	verdadeiro
ConcurrentAccess	verdadeiro

Compatibilidade do Neptune com atributos de variável

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

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

Compatibilidade do Neptune com atributos de propriedade do vértice

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

Compatibilidade do Neptune com atributos de borda

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

Compatibilidade do Neptune com atributos de propriedade de borda

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