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
Las siguientes secciones proporcionan una descripción general de la implementación de Gremlin en Neptune y en qué se diferencia de la de Apache TinkerPop implementación.
Neptune implementa algunos pasos de Gremlin de forma nativa en su motor y usa Apache TinkerPop Implementación de Gremlin para procesar otros (consulte Compatibilidad nativa con pasos de Gremlin en Amazon Neptune).
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 del inicio rápido.
Temas
Estándares aplicables de Gremlin
El idioma Gremlin se define por apache TinkerPop Documentación
y el Apache TinkerPop implementación de Gremlin en lugar de mediante una especificación formal. Para los formatos numéricos, Gremlin sigue el estándar IEEE 754 (IEEE 754-2019: estándar IEEE para Floating-Point Aritmética
. Para obtener más información, consulte también el Página IEEE 754 de Wikipedia ).
Variables y parámetros en los scripts
En lo que respecta a las variables predelimitadas, el objeto transversal g es Pre-bound en Neptuno, y el graph el 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
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. Hay muchísimos ejemplos de este tipo para TinkerPop que puede encontrar, y todos parecen bastante convincentes en cuanto 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 a TinkerPopes Gremlin Server cuando usa 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. Porque la gramática ANTLR es un componente más nuevo de TinkerPop, el contenido antiguo que puede 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();
Ejecución de scripts
El motor Gremlin de Neptune analiza las consultas mediante TinkerPopes gremlin-language Gramática ANTLR. Lo hace no ejecutar un GremlinGroovyScriptEngine (como algunos TinkerPop-based Los despliegues de Gremlin Server sí), por lo que los scripts enviados a Neptune deben contener únicamente el lenguaje Gremlin, no código Groovy o Java arbitrario.
Los scripts se pueden enviar a Neptune de varias maneras, por ejemplo, a través del Punto final REST de Gremlin, el Consola Gremlin, o mediante TinkerPop controladores lingüísticos (por ejemplo, el cliente de scripts del controlador Java
Es importante no confundir el lenguaje Gremlin en sí mismo con el contenido sintáctico o las funciones de uso general de cualquier lenguaje de programación que hayas visto empaquetar ejemplos de Gremlin en otros lugares. Dónde aparece dicho código en TinkerPop tutoriales o ejemplos en línea, depende del tiempo de ejecución de Groovy o Java que Neptune no proporcione.
Todo lo contenido en esta sección se aplica a los envíos con cadenas de texto de Gremlin. Los envíos de código de bytes GLV (variante del lenguaje Gremlin) creados en un lenguaje anfitrión como Java, Python o.NET no están sujetos a estas restricciones, ya que el generador transversal del idioma anfitrión produce código de bytes que el motor de Neptune consume directamente.
Qué puede contener un script
-
Todas las consultas debe comenzar por
g, el objeto de recorrido. -
Se pueden emitir varios recorridos en una sola presentación separados por un punto y coma (
;) o un carácter de nueva línea (\n). Toda declaración que no sea la última debe terminar con un.iterate()paso a ejecutar; solo se devuelven los datos del recorrido final.
Referenciando TinkerPop valores de enumeración
¿Dónde un TinkerPop Se espera un valor de enumeración como argumento escalonado (por ejemplo, una cardinalidad en property() o un pedido de by()), utilice los valores abreviados reconocidos por la gramática ANTLR. Neptune no resuelve nombres de clases Java completamente calificados en esta posición; por ejemplo, org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality.single no se acepta; utilice single en su lugar.
En la siguiente tabla se enumeran los valores abreviados permitidos y los valores subyacentes TinkerPop clase a la que pertenece cada uno.
| Valores permitidos | Clase |
|---|---|
id, key, label, value |
|
T.id, T.key, T.label, T.value |
|
set, single |
org.apache.tinkerpop.gremlin.structure.VertexProperty.Cardinality |
asc, desc, shuffle |
|
Order.asc, Order.desc, Order.shuffle |
|
global, local |
|
Scope.global, Scope.local |
|
all, first, last, mixed |
|
normSack |
org.apache.tinkerpop.gremlin.process.traversal.SackFunctions.Barrier |
addAll, and, assign, div,
max, min, minus, mult,
or, sum, sumLong |
|
keys, values |
|
BOTH, IN, OUT |
|
any, none, unproductive |
org.apache.tinkerpop.gremlin.process.traversal.step.TraversalOptionParent.Pick |
Lo que no puede contener un script
Los siguientes son no se admiten en las consultas de cadenas de texto de Gremlin a Neptune, porque dependen de la compatibilidad con Groovy o Java en tiempo de ejecución que Neptune no proporciona:
-
Declaraciones de Groovy que no comienzan por
g. Esto incluye:Expresiones aritméticas como
1 + 1Llamadas al sistema como
System.nanoTime()Declaraciones de variables como
x = 1; g.V(x)
-
Llamadas a métodos o bibliotecas de Java distintas de las API de Gremlin compatibles. Por ejemplo
java.lang.*,Date()yg.V().tryNext().orElseGet(...)no se permiten. -
Métodos de Gremlin que toman un tipo de Java como argumento. Solo se puede acceder a ellos desde un JVM-language anfitrión, no desde una cadena de texto enviada. Ejemplos:
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 siguiente recorrido no se puede enviar como cadena de texto:
g.V().addE('something').from(__.V().next()).to(__.V().next()).
Propiedades de los elementos
A partir de la versión 1.5.0.0 del motor Amazon Neptune, puede utilizar materializeProperties bandera, introducida en TinkerPop 3.7.0, para controlar si la consulta devuelve propiedades sobre los elementos (vértices y bordes) del resultado. Para obtener más información, consulte Propiedades de los elementos
Colocas la bandera en un recorrido utilizando el with() paso de configuración:
g.with('materializeProperties', 'all')devuelve elementos con sus propiedades incluidas en línea en el resultado.g.with('materializeProperties', 'tokens')devuelve los elementos solo como referencias (es decir, solo con susidylabel, y sin propiedades).
Cuando el indicador no se establece de forma explícita, el comportamiento predeterminado depende del serializador que utilice la solicitud, no del método de transporte o envío:
Las solicitudes de GraphSon (como las solicitudes HTTP y las basadas en scripts) devuelven propiedades de forma predeterminada, lo que equivale a
all.GraphBinary solicitudes (como los clientes modernos de Gremlin Language Variant (GLV) como
gremlin-pythonygremlin-javamás de un WebSocket) por defecto devuelve solo referencias, lo que equivale atokens.
Puede anular cualquiera de los valores predeterminados configurando el materializeProperties marca explícitamente con el with() paso, como se ha mostrado anteriormente.
Neptuno no acepta null, Map, o UUID valores como valores de propiedades de vértices o aristas. Set-Se admiten los valores de las propiedades de cardinalidad (consulte Cardinalidad de las propiedades de vértice), pero no se admiten los valores de propiedad que son en sí mismos conjuntos (una propiedad única cuyo valor es un conjunto de elementos anidados).
Meta-properties
Neptuno no admite las metapropiedades, es decir, las propiedades de las propiedades. Intentar adjuntar una propiedad a otra propiedad mediante TinkerPopes VertexProperty.property(...) La API no conserva el valor anidado.
Ordenación de vértices, aristas y propiedades
Neptuno no conserva el orden de inserción de los vértices, las aristas o las propiedades. Orden de iteración para V(), E(), y la enumeración de propiedades se determina mediante un hash interno del elemento (id, key, value) tupla.
Este comportamiento no es exclusivo de Neptuno. El apache TinkerPop La especificación no requiere que los proveedores impongan el orden de inserción de los vértices, los bordes o las propiedades, por lo que la mayoría de las bases de datos de gráficos se comportan de la misma manera. Es posible que los gráficos en memoria esperen conservar el orden de inserción, como TinkerGraph que lo preservan.
Si su aplicación requiere un orden de iteración determinista, aplique un orden de iteración explícito order() paso con un estable by() modulador (por ejemplo, order().by(id) o order().by('name')) en lugar de basarse en el orden de inserción.
Compensaciones de fecha y hora
Neptuno representa internamente los valores de fecha y hora como instantes: UTC-based puntos en el tiempo. ¿Cuándo asDate() o se aplica un paso de fecha y hora relacionado a una cadena que contiene un desfase de zona horaria (por ejemplo, '2024-01-15T10:30:00+05:00'), el desfase se normaliza a UTC y la información de desfase original no se conserva en el resultado de ida y vuelta.
Sesiones
Las sesiones en Neptune se limitan a una duración de 10 minutos. Consulte Sesiones basadas en scripts de Gremlin y el TinkerPop Referencia de la sesión
Transacciones
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().
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).
Identificador de vértice y borde
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 Los identificadores son compatibles, pero son opcionales en condiciones de 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.
Sin embargo, el comando Load de Neptune requiere que proporcione identificadores mediante el campo ~id en formato CSV de Neptune.
User-supplied Identificaciones
User-supplied Se permiten identificaciones 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').
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
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
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)
List no se admite. Para obtener más información sobre la cardinalidad de las propiedades, consulte la Vértice
Actualización de una propiedad de vértice
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.
Cambiar la cardinalidad de una propiedad de vértice de single a set por property(set, ...) no elimina el valor de cardinalidad única existente. El valor único permanece en el conjunto de propiedades junto con cualquier valor establecido nuevo. Para reemplazar un valor único existente, borre primero la propiedad con properties(...).drop() antes de aplicar el nuevo valor de cardinalidad establecido.
Etiquetas
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").
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
Neptune resuelve todos los caracteres de escape tal y como se describe en la sección Escaping Special Characters
Serialización
Neptune admite las siguientes serializaciones en función del tipo MIME solicitado.
Con Neptune, puede usar muchos de los serializadores que TinkerPop ofertas, con soporte para las distintas versiones y configuraciones de GraphSon y GraphBinary. Consulte la siguiente tabla para ver los serializadores compatibles actualmente. A pesar de que son muchas las opciones disponibles, las instrucciones sobre cuál utilizar son muy sencillas:
-
Si utiliza Apache TinkerPop controladores, prefiera el predeterminado para el controlador sin especificar uno 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-stringdsolo es útil cuando se usa junto con la Consola de Gremlin, 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 |
|
GraphSONUntypedMessageSerializerV1 |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1] |
|
GraphSONMessageSerializerV2 |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV2] |
|
GraphSONUntypedMessageSerializerV2 |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV2] |
|
GraphSONMessageSerializerV3 |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3] |
|
GraphSONUntypedMessageSerializerV3 |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3] |
|
GraphSONUntypedMessageSerializerV3 |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1] |
|
GraphBinaryMessageSerializerV1 |
|
|
GraphBinaryMessageSerializerV1 |
serializeResultToString: true |
|
GraphSONMessageSerializerGremlinV1 |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV1] |
|
GraphSONMessageSerializerV2 (solo funciona con WebSockets) |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV2] |
|
GraphSONMessageSerializerV3 |
|
|
GraphSONMessageSerializerV3 |
ioRegistries: [org.apache.tinkerpop.gremlin.tinkergraph.structure.TinkerIoRegistryV3] |
|
GraphBinaryMessageSerializerV1 |
|
La tabla de serialización que se muestra aquí se refiere a la denominación a partir de TinkerPop 3.7.0. Si desea obtener más información sobre este cambio, consulte el TinkerPop documentación de actualización
Pasos de Lambda
Neptune no admite los pasos de Lambda.
Pasos de Gremlin no admitidos
Neptune no admite los siguientes pasos de Gremlin:
El paso io()
de Gremlin solo se admite parcialmente en Neptune. Puede usarlo en un contexto de lectura, como en g.io("https://example.com/data/my-graph.graphml").read(), pero no se puede usar para escribir. Para leer un archivo que almacene como un objeto de Amazon S3, genere primero una URL prefirmada. A continuación, pase esa URL HTTPS ag.io(). Para obtener más información sobre las URL prefirmadas, consulte Descarga y carga objetos con URL prefirmadas en el Guía del usuario de Amazon S3.
Características de gráficos de Gremlin en Neptune
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 grafico características
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
| 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
| 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
| 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
| 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
| 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 |