Cláusulas Operadores Expressões Funções Diferenças do openCypher no Neptune

Conformidade com especificações do openCypher no Amazon Neptune

A versão do Amazon Neptune do openCypher geralmente é compatível com as cláusulas, a sintaxe, as expressões, as funções e os operadores definidos na especificação atual do openCypher, que é a Cypher Query Language Reference versão 9. As limitações e as diferenças na compatibilidade do Neptune com o openCypher estão descritas abaixo.

O Amazon Neptune também oferece suporte a vários recursos além do escopo da especificação do openCypher. Para mais detalhes, consulte Extensões do openCypher no Amazon Neptune.

nota

A implementação atual do Neo4j do Cypher contém funcionalidades que não estão contidas na especificação do openCypher mencionada acima. Se você estiver migrando o código Cypher atual para o Neptune, consulte Compatibilidade do Neptune com o Neo4j e Reformular consultas do Cypher para serem executadas no openCypher no Neptune para obter mais informações.

Compatibilidade com cláusulas do openCypher no Neptune

O Neptune é compatível com as seguintes cláusulas, exceto conforme observado:

MATCH: compatível, exceto shortestPath() e allShortestPaths() no momento.
OPTIONAL MATCH
MANDATORY MATCH: no momento, não é compatível no Neptune. No entanto, o Neptune é compatível com valores de ID personalizados em consultas MATCH.
RETURN: compatível, exceto quando usado com valores não estáticos para SKIP ou LIMIT. Por exemplo, o seguinte não funciona no momento:
```
MATCH (n)
RETURN n LIMIT toInteger(rand())    // Does NOT work!
```
WITH: compatível, exceto quando usado com valores não estáticos para SKIP ou LIMIT. Por exemplo, o seguinte não funciona no momento:
```
MATCH (n)
WITH n SKIP toInteger(rand())
WITH count() AS count
RETURN count > 0 AS nonEmpty    // Does NOT work!
```
UNWIND
WHERE
ORDER BY
SKIP
LIMIT
CREATE: o Neptune permite criar valores de ID personalizados em consultas CREATE.
DELETE
SET
REMOVE
MERGE: o Neptune é compatível com valores de ID personalizados em consultas MERGE.
CALL[YIELD...]: no momento, não é compatível no Neptune.
UNION, UNION ALL: consultas somente leitura são compatíveis, mas consultas de mutação não são aceitas no momento.
USING: USING é compatível com a versão 1.3.2.0 do mecanismo. Consulte Dicas de consultas para obter mais informações.

Compatibilidade com operadores do openCypher no Neptune

O Neptune é compatível com os seguintes operadores, exceto conforme observado:

Operadores gerais

DISTINCT
O operador . para acessar as propriedades de um mapa literal aninhado.

Operadores matemáticos

O operador de adição +.
O operador de subtração -.
O operador de multiplicação *.
O operador de divisão /.
O operador de divisão de módulo %.
O operador de ^ exponenciação. is NOT supported

Operadores de comparação

O operador de adição =.
O operador de desigualdade <>.
O operador < menor que é compatível, exceto quando um dos argumentos é um caminho, uma lista ou um mapa.
O operador > maior que é compatível, exceto quando um dos argumentos é um caminho, uma lista ou um mapa.
O operador <= menor ou igual a é compatível, exceto quando um dos argumentos é um caminho, uma lista ou um mapa.
O operador >= maior ou igual a é compatível, exceto quando um dos argumentos é um caminho, uma lista ou um mapa.
IS NULL
IS NOT NULL
STARTS WITH será compatível se os dados pesquisados forem uma string.
ENDS WITH será compatível se os dados pesquisados forem uma string.
CONTAINS será compatível se os dados pesquisados forem uma string.

Operadores booleanos

AND
OR
XOR
NOT

Operadores de string

O operador de concatenação +.

Operadores List

O operador de concatenação +.
IN (confere a presença de um item em uma lista).

Compatibilidade com expressões do openCypher no Neptune

O Neptune é compatível com as seguintes expressões, exceto conforme observado:

CASE
No momento, a expressão [] não é compatível com o Neptune para acessar chaves de propriedade calculadas dinamicamente em um nó, um relacionamento ou um mapa. Por exemplo, o seguinte não funciona:
```
MATCH (n)
WITH [5, n, {key: 'value'}] AS list
RETURN list[1].name
```

Compatibilidade com funções do openCypher no Neptune

O Neptune é compatível com as seguintes funções, exceto conforme observado:

Funções de predicado

exists()

Funções escalares

coalesce()
endNode()
epochmillis()
head()
id()
last()
length()
randomUUID()
properties()
removeKeyFromMap
size(): esse método sobrecarregado atualmente só funciona para expressões de padrões, listas e strings.
startNode()
timestamp()
toBoolean()
toFloat()
toInteger()
type()

Agregar funções

avg()
collect()
count()
max()
min()
percentileDisc()
stDev()
percentileCont()
stDevP()
sum()

Listar as funções

join() (concatena strings em uma lista em uma única string).
keys()
labels()
nodes()
range()
relationships()
reverse()
tail()

Funções matemáticas: numéricas.

abs()
ceil()
floor()
rand()
round()
sign()

Funções matemáticas: logarítmicas.

e()
exp()
log()
log10()
sqrt()

Funções matemáticas: trigonométricas.

acos()
asin()
atan()
atan2()
cos()
cot()
degrees()
pi()
radians()
sin()
tan()

Funções de string

join() (concatena strings em uma lista em uma única string).
left()
lTrim()
replace()
reverse()
right()
rTrim()
split()
substring()
toLower()
toString()
toUpper()
trim()

User-defined funções

User-defined functionsatualmente não são compatíveis com o Neptune.

Neptune-specific Detalhes da implementação do OpenCypher

As seções a seguir descrevem as maneiras pelas quais a implementação do openCypher no Neptune pode diferir ou ir além da especificação do openCypher

Variable-length avaliações de caminho (VLP) em Neptune

As avaliações de caminho de comprimento variável (VLP) descobrem caminhos entre os nós no grafo. O comprimento do caminho pode ser irrestrito em uma consulta. Para evitar ciclos, a especificação do openCypher especifica que cada borda deve ser percorrida no máximo uma vez por solução.

Para VLPs, a implementação do Neptune se desvia da especificação do openCypher, pois só é compatível com valores constantes para filtros de igualdade de propriedades. Considere a seguinte consulta:

MATCH (x)-[:route*1..2 {dist:33, code:x.name}]->(y) return x,y

Como o valor do filtro de igualdade de propriedade x.name não é uma constante, essa consulta gera uma UnsupportedOperationException com a mensagem: Property predicate over variable-length relationships with non-constant expression is not supported in this release.

Compatibilidade temporal na implementação do Neptune openCypher (banco de dados 1.3.1.0 do Neptune e versões anteriores)

No momento, o Neptune oferece compatibilidade limitada para funções temporais no openCypher. Ele é compatível com o tipo de dados DateTime para tipos temporais.

A função datetime() pode ser usada para obter a data e a hora UTC atuais da seguinte forma:


RETURN  datetime() as res

Os valores de data e hora podem ser analisados a partir de strings em um formato "dateTtime" em que a data e a hora são expressas em uma das seguintes formas compatíveis:

Formatos de data suportados

yyyy-MM-dd
yyyyMMdd
yyyy-MM
yyyy-DDD
yyyyDDD
yyyy

Formatos de hora compatíveis

HH:mm:ssZ
HHmmssZ
HH:mm:ssZ
HH:mmZ
HHmmZ
HHZ
HHmmss
HH:mm:ss
HH:mm
HHmm
HH

Por exemplo:


RETURN datetime('2022-01-01T00:01')      // or another example:
RETURN datetime('2022T0001')

Observe que todos os date/time valores no Neptune OpenCypher são armazenados e recuperados como valores UTC.

O openCypher no Neptune usa um relógio statement, o que significa que o mesmo instante no tempo é usado durante toda a duração de uma consulta. Uma consulta diferente na mesma transação pode usar um instante diferente no tempo.

O Neptune não é compatível com o uso de uma função em uma chamada para datetime(). Por exemplo, o seguinte não funcionará:


CREATE (:n {date:datetime(tostring(2021))})  // ---> NOT ALLOWED!

O Neptune é compatível com a função epochmillis() que converte uma datetime em epochmillis. Por exemplo:


MATCH (n) RETURN epochMillis(n.someDateTime)
1698972364782

No momento, o Neptune não é compatível com outras funções e operações em objetos DateTime, como adição e subtração.

Compatibilidade temporal na implementação do Neptune openCypher (Neptune Analytics e banco de dados do Neptune 1.3.2.0 e superior)

A seguinte funcionalidade de data e hora OpenCypher se aplica ao Neptune Analytics. Como alternativa, você pode usar o parâmetro do modo de laboratório DatetimeMillisecond=enabled para habilitar a funcionalidade de data e hora a seguir na versão 1.3.2.0 e superior do mecanismo do Neptune. Para obter mais detalhes sobre como usar essa funcionalidade no modo de laboratório, consulte Suporte estendido para data e hora.

Compatibilidade para milissegundos. O literal de data e hora sempre será retornado com milissegundos, mesmo que os milissegundos sejam 0. (O comportamento anterior era truncar os milissegundos.)


CREATE (:event {time: datetime('2024-04-01T23:59:59Z')})

# Returning the date returns with 000 suffixed representing milliseconds
MATCH(n:event)
RETURN n.time as datetime

{
  "results" : [ {
    "n" : {
      "~id" : "0fe88f7f-a9d9-470a-bbf2-fd6dd5bf1a7d",
      "~entityType" : "node",
      "~labels" : [ "event" ],
      "~properties" : {
        "time" : "2024-04-01T23:59:59.000Z"
      }
    }
  } ]
}

Compatibilidade para chamar a função datetime() em propriedades armazenadas ou resultados intermediários. Por exemplo, as consultas a seguir não eram possíveis antes desse recurso.

Datetime() em propriedades:


// Create node with property 'time' stored as string
CREATE (:event {time: '2024-04-01T23:59:59Z'})

// Match and return this property as datetime
MATCH(n:event)
RETURN datetime(n.time) as datetime

Datetime () em resultados intermediários:


// Parse datetime from parameter
UNWIND $list as myDate
RETURN datetime(myDate) as d

Agora também é possível salvar as propriedades de data e hora criadas nos casos mencionados acima.

Como salvar a data e hora da propriedade de string de uma propriedade para outra:


// Create node with property 'time' stored as string
CREATE (:event {time: '2024-04-01T23:59:59Z', name: 'crash'})

// Match and update the same property to datetime type
MATCH(n:event {name: 'crash'})
SET n.time = datetime(n.time)

// Match and update another node's property
MATCH(e:event {name: 'crash'})
MATCH(n:server {name: e.servername})
SET n.time = datetime(e.time)

Criar nós em lote a partir de um parâmetro com uma propriedade de data e hora:


// Batch create from parameter
UNWIND $list as events
CREATE (n:crash) {time: datetime(events.time)}
// Parameter value
{
  "x":[
    {"time":"2024-01-01T23:59:29", "name":"crash1"},
    {"time":"2023-01-01T00:00:00Z", "name":"crash2"}
  ]
}

Compatibilidade para um subconjunto maior de formatos de data e hora em ISO8601. Consulte abaixo.

Formatos com suporte

O formato de um valor de data e hora é [Date]T[Time][Timezone], em que T é o separador. Se um fuso horário explícito não for fornecido, o UTC (Z) será considerado o padrão.

Fuso horário

Os formatos de fuso horário compatíveis são:

+/-HH:mm
+/-HHmm
+/-HH

A presença de um fuso horário em uma string de data e hora é opcional. Caso a diferença de fuso horário seja 0, Z pode ser usado em vez do postfix de fuso horário acima para indicar a hora em UTC. O intervalo compatível de um fuso horário é de -14:00 a +14:00.

Data

Se nenhum fuso horário estiver presente ou se o fuso horário for UTC (Z), os formatos de data compatíveis serão os seguintes:

nota

DDD se refere a uma data ordinal, que representa um dia do ano de 001 a 365 (366 em anos bissextos). Por exemplo, 2024-002 representa 2 de janeiro de 2024.

yyyy-MM-dd
yyyyMMdd
yyyy-MM
yyyyMM
yyyy-DDD
yyyyDDD
yyyy

Se um fuso horário diferente de Z for escolhido, os formatos de data compatíveis serão limitados ao seguinte:

yyyy-MM-dd
yyyy-DDD
yyyyDDD

O intervalo compatível para datas é de 1400-01-01 até 9999-12-31.

Hora

Se nenhum fuso horário estiver presente ou se ele for UTC (Z), os formatos de hora compatíveis serão os seguintes:

HH:mm:ss.SSS
HH:mm:ss
HHmmss.SSS
HHmmss
HH:mm
HHmm
HH

Se um fuso horário diferente de Z for escolhido, os formatos de hora compatíveis serão limitados ao seguinte:

HH:mm:ss
HH:mm:ss.SSS

Diferenças na semântica da linguagem openCypher do Neptune

O Neptune representa IDs de nós e relacionamentos como strings em vez de números inteiros. O ID é igual ao ID fornecido pelo carregador de dados. Se houver um namespace para a coluna, o namespace mais o ID. Consequentemente, a função id gera uma string em vez de um número inteiro.

O tipo de dados INTEGER é limitado a 64 bits. Ao converter valores de ponto flutuante ou string maiores em um número inteiro usando a função TOINTEGER, valores negativos são truncados em LLONG_MIN e valores positivos são truncados em LLONG_MAX.

Por exemplo:


RETURN TOINTEGER(2^100)
>  9223372036854775807

RETURN TOINTEGER(-1 * 2^100)
>  -9223372036854775808

Multi-valued propriedades

Embora o openCypher CREATE não crie propriedades de vários valores, elas podem existir em dados criados usando o Gremlin (banco de dados do Neptune) ou ao carregar dados (banco de dados do Neptune e Neptune Analytics). Se o openCypher do Neptune encontrar uma propriedade de vários valores, um dos valores será escolhido arbitrariamente, criando um resultado não determinístico.

Tratar valores NaN

O tratamento do Neptune da comparação dos valores das propriedades NaN é indefinido. Confiar nessas comparações pode resultar em resultados inesperados ou não determinísticos.

Atenção O Javascript está desativado ou não está disponível no seu navegador.

Para usar a documentação da AWS, o Javascript deve estar ativado. Consulte as páginas de Ajuda do navegador para obter instruções.

Convenções do documento

Conformidade com padrões do SPARQL

Modelo de dados de grafo