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.

Extensiones de OpenCypher en Amazon Neptune

Amazon Neptune es compatible con la versión 9 de referencia de la especificación OpenCypher. Consulte Amazon Neptune para Conformidad con las especificaciones de OpenCypher en Amazon Neptune obtener más información. Además, Amazon Neptune es compatible con las funciones que se indican aquí. A menos que se mencionen versiones específicas, las funciones están disponibles en Neptune Database y Neptune Analytics.

La función join() específica de Neptune

Disponible en Neptune Database y Neptune Analytics.

Neptune implementa una función join() que no está presente en la especificación de openCypher. Crea un literal de cadena a partir de una lista de literales de cadena y un delimitador de cadenas. Adopta dos argumentos:

Ejemplo:

join(["abc", "def", "ghi"], ", ")    // Returns "abc, def, ghi"

La función removeKeyFromMap() específica de Neptune

Disponible en Neptune Database y Neptune Analytics.

Neptune implementa una función removeKeyFromMap() que no está presente en la especificación de openCypher. Elimina una clave específica de un mapa y devuelve el nuevo mapa resultante.

La función toma dos argumentos:

La función removeKeyFromMap() resulta especialmente útil en situaciones en las que se desean establecer valores para un nodo o una relación presentando una lista de mapas. Por ejemplo:

UNWIND [{`~id`: 'id1', name: 'john'}, {`~id`: 'id2', name: 'jim'}] as val
CREATE (n {`~id`: val.`~id`})
SET n = removeKeyFromMap(val, '~id')

Valores de identificadores personalizados para las propiedades de los nodos y las relaciones

Disponible en Neptune Database 1.2.0.2 y versiones posteriores y en Neptune Analytics.

A partir de la versión 1.2.0.2 del motor, Neptune ha ampliado la especificación de openCypher para que pueda especificar los valores id para los nodos y las relaciones en las cláusulas CREATE, MERGE y MATCH. Esto le permite asignar cadenas fáciles de usar en lugar de generadas por el sistema para identificar nodos y UUIDs relaciones.

En Neptune Analytics, los valores de identificación personalizados no están disponibles para los bordes.

A continuación, tenemos un ejemplo que muestra cómo crear nodos y relaciones con identificadores personalizados:

CREATE (n {`~id`: 'fromNode', name: 'john'})
  -[:knows {`~id`: 'john-knows->jim', since: 2020}]
  ->(m {`~id`: 'toNode', name: 'jim'})

Si intenta crear un identificador personalizado que ya esté en uso, Neptune mostrará un error DuplicateDataException.

A continuación, se muestra un ejemplo del uso de un identificador personalizado en una cláusula MATCH:

MATCH (n {`~id`: 'id1'})
RETURN n

A continuación, se muestra un ejemplo del uso de la personalización IDs en una MERGE cláusula:

MATCH (n {name: 'john'}), (m {name: 'jim'})
MERGE (n)-[r {`~id`: 'john->jim'}]->(m)
RETURN r

Qué hacer si actualmente utiliza ~id como propiedad

Con la versión 1.2.0.2 del motor, la clave ~id de las cláusulas de openCypher ahora se trata como id y no como una propiedad. Esto significa que si tiene una propiedad denominada ~id, es imposible acceder a ella.

Si utiliza una propiedad ~id, lo que debe hacer antes de actualizarla a la versión del motor 1.2.0.2 o posterior es migrar primero la propiedad ~id existente a una nueva clave de propiedad y, a continuación, eliminar la propiedad ~id. Por ejemplo, la siguiente consulta:

MATCH (n)
WHERE exists(n.`~id`)
SET n.newId = n.`~id`
REMOVE n.`~id`

Se debe hacer lo mismo con cualquier relación en los datos que tenga una propiedad ~id.

También tendrá que cambiar las consultas que esté utilizando que hagan referencia a una propiedad ~id. Por ejemplo, esta consulta:

MATCH (n)
WHERE n.`~id` = 'some-value'
RETURN n

...se convertiría en esto:

MATCH (n)
WHERE n.newId = 'some-value'
RETURN n

Soporte de subconsultas CALL en Neptune

Disponible en Neptune Database 1.4.1.0 y versiones posteriores y en Neptune Analytics.

Amazon Neptune admite CALL subconsultas. Una CALL subconsulta es una parte de la consulta principal que se ejecuta en un ámbito aislado para cada entrada de la subconsulta. CALL

Por ejemplo, supongamos que un gráfico contiene datos sobre las personas, sus amigos y las ciudades en las que vivieron. Podemos recuperar las dos ciudades más grandes en las que vivía cada amigo de una persona mediante una CALL subconsulta:

MATCH (person:Person)-[:knows]->(friend) 
CALL { 
  WITH friend 
  MATCH (friend)-[:lived_in]->(city) 
  RETURN city 
  ORDER BY city.population DESC
  LIMIT 2 
} 
RETURN person, friend, city

En este ejemplo, la parte interna de la consulta CALL { ... } se ejecuta para cada una de las partes friend que coinciden con la cláusula MATCH anterior. Cuando se ejecuta la consulta interna, LIMIT las cláusulas ORDER y corresponden a las ciudades en las que vivió un amigo específico, por lo que obtenemos (como máximo) dos ciudades por amigo.

Todas las cláusulas de consulta están disponibles dentro de CALL las subconsultas. Esto también incluye las CALL subconsultas anidadas. Existen algunas restricciones para la primera WITH cláusula y las variables emitidas, que se explican a continuación.

Alcance de las variables dentro de la subconsulta CALL

La cláusula inicial WITH debe importar las variables de las cláusulas anteriores a la CALL subconsulta que se utilizan en ella. A diferencia de WITH las cláusulas normales, solo puede contener una lista de variables, pero no permite la creación de alias y no se puede usar junto conDISTINCT,ORDER BY, WHERESKIP, o. LIMIT

Variables devueltas por la subconsulta CALL

Las variables que se emiten desde la CALL subconsulta se especifican con la cláusula finalRETURN. Tenga en cuenta que las variables emitidas no pueden superponerse con las variables anteriores a la CALL subconsulta.

Limitaciones

Por el momento, no se admiten las actualizaciones dentro de una CALL subconsulta.

Funciones OpenCypher de Neptune

Disponible en Neptune Database 1.4.1.0 y versiones posteriores y en Neptune Analytics.

textIndexOf

textIndexOf(text :: STRING, lookup :: STRING, from = 0 :: INTEGER?, to = -1 :: INTEGER?) :: (INTEGER?)

Devuelve el índice de la primera aparición lookup en el rango que va desde el desfase text inicial from (incluido) hasta el desfase (exclusivo). to Si to es -1, el rango continúa hasta el final detext. La indexación se basa en cero y se expresa en valores escalares Unicode (puntos de código no sustitutos).

RETURN textIndexOf('Amazon Neptune', 'e')
{
  "results": [{
      "textIndexOf('Amazon Neptune', 'e')": 8
    }]
}

collToSet

collToSet(values :: LIST OF ANY?) :: (LIST? OF ANY?)

Devuelve una nueva lista que contiene solo los elementos únicos de la lista original. Se mantiene el orden de la lista original (por ejemplo, [1, 6, 5, 1, 5] devuelve[1, 6, 5]).

RETURN collToSet([1, 6, 5, 1, 1, 5])
{
  "results": [{
      "collToSet([1, 6, 5, 1, 1, 5])": [1, 6, 5]
    }]
}

CollSubtract

collSubtract(first :: LIST OF ANY?, second :: LIST OF ANY?) :: (LIST? OF ANY?)

Devuelve una nueva lista que contiene todos los elementos únicos de los que se first excluyen. second

RETURN collSubtract([2, 5, 1, 0], [1, 5])
{
  "results": [{
      "collSubtract([2, 5, 1, 0], [1, 5])": [0, 2]
    }]
}

CollIntersection

collIntersection(first :: LIST? OF ANY?, second :: LIST? OF ANY?) :: (LIST? OF ANY?)

Devuelve una nueva lista que contiene todos los elementos únicos de la intersección de first ysecond.

RETURN collIntersection([2, 5, 1, 0], [1, 5])
{
  "results": [{
      "collIntersection([2, 5, 1, 0], [1, 5])": [1, 5]
    }]
}

Funciones de clasificación

En las siguientes secciones se definen las funciones para ordenar las colecciones. Estas funciones utilizan argumentos de config mapa (en algunos casos son opcionales) o una lista de varios mapas de este tipo, que definen la clave de clasificación o la dirección de clasificación:

{ key: STRING, order: STRING }

Este key es un mapa o una propiedad de nodo cuyo valor se usará para ordenar. orderes "" o asc "desc" (no distingue entre mayúsculas y minúsculas) para especificar una ordenación ascendente o descendente, respectivamente. De forma predeterminada, la clasificación se realizará en orden ascendente.

CollSort

collSort(coll :: LIST OF ANY, config :: MAP?) :: (LIST? OF ANY?)

Devuelve una nueva lista ordenada que contiene los elementos de la lista de coll entrada.

RETURN collSort([5, 3, 1], {order: 'asc'})
{
  "results": [{
      "collSort([5, 3, 1])": [1, 3, 5]
    }]
}

collSortMaps

collSortMaps(coll :: LIST OF MAP, config :: MAP) :: (LIST? OF ANY?)

Devuelve una lista de mapas ordenados por el valor de la key propiedad especificada.

RETURN collSortMaps([{name: 'Alice', age: 25}, {name: 'Bob', age: 35}, {name: 'Charlie', age: 18}], {key: 'age', order: 'desc'})
{
  "results": [{
      "x": [{
          "age": 35,
          "name": "Bob"
        }, {
          "age": 25,
          "name": "Alice"
        }, {
          "age": 18,
          "name": "Charlie"
        }]
    }]
}

collSortMulti

collSortMulti(coll :: LIST OF MAP?, 
configs = [] :: LIST OF MAP, 
limit = -1 :: INTEGER?, 
skip = 0 :: INTEGER?) :: (LIST? OF ANY?)

Devuelve una lista de mapas ordenados por el valor de las key propiedades especificadas, aplicando opcionalmente limitar y omitir.

RETURN collSortMulti([{name: 'Alice', age: 25}, {name: 'Bob', age: 35}, {name: 'Charlie', age: 18}], [{key: 'age', order: 'desc'}, {key:'name'}]) as x
{
  "results": [{
      "x": [{
          "age": 35,
          "name": "Bob"
        }, {
          "age": 25,
          "name": "Alice"
        }, {
          "age": 18,
          "name": "Charlie"
        }]
    }]
}

collSortNodes

collSortNodes(coll :: LIST OF NODE, config :: MAP) :: (LIST? OF NODE?)

Devuelve una versión ordenada de la lista de coll entrada, que ordena los elementos del nodo por los valores de sus key propiedades respectivas.

create (n:person {name: 'Alice', age: 23}), (m:person {name: 'Eve', age: 21}), (o:person {name:'Bob', age:25})
{"results":[]}

match (n:person) with collect(n) as people return collSortNodes(people, {key: 'name', order: 'desc'})
{
  "results": [{
      "collSortNodes(people, 'name')": [{
          "~id": "e599240a-8c23-4337-8aa8-f603c8fb5488",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 21,
            "name": "Eve"
          }
        }, {
          "~id": "8a6ef785-59e3-4a0b-a0ff-389655a9c4e6",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 25,
            "name": "Bob"
          }
        }, {
          "~id": "466bc826-f47f-452c-8a27-6b7bdf7ae9b4",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 23,
            "name": "Alice"
          }
        }]
    }]
}

match (n:person) with collect(n) as people return collSortNodes(people, {key: 'age'})
{
  "results": [{
      "collSortNodes(people, '^age')": [{
          "~id": "e599240a-8c23-4337-8aa8-f603c8fb5488",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 21,
            "name": "Eve"
          }
        }, {
          "~id": "466bc826-f47f-452c-8a27-6b7bdf7ae9b4",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 23,
            "name": "Alice"
          }
        }, {
          "~id": "8a6ef785-59e3-4a0b-a0ff-389655a9c4e6",
          "~entityType": "node",
          "~labels": ["person"],
          "~properties": {
            "age": 25,
            "name": "Bob"
          }
        }]
    }]
}