Cláusulas Operadores Expressões Funções Diferenças de Netuno openCypher

openCypher conformidade de especificações no Amazon Neptune

A versão do Amazon Neptune openCypher do geralmente suporta as cláusulas, operadores, expressões, funções e sintaxe definidas na pela especificação openCypher atual, que é a Cypher Query Language Reference Version 9. As limitações e diferenças no suporte do Neptune são descritas openCypher abaixo.

nota

A implementação atual do Neo4j do Cypher contém funcionalidades que não estão contidas na especificação mencionada acima. openCypher 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.

Support para openCypher cláusulas em Neptune

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

MATCH— Suportado, exceto que shortestPath() e allShortestPaths() não são suportadas atualmente.
OPTIONAL MATCH
MANDATORY MATCH — atualmente não é suportado 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...] — atualmente não é suportado 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 motor. Consulte Dicas de consulta para obter mais informações.

Support para openCypher operadores em 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 <= less-than-or-equal -to é suportado, exceto quando um dos argumentos é um caminho, uma lista ou um mapa.
O operador >= greater-than-or-equal -to é suportado, 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).

Support para openCypher expressões em 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
```

Support para openCypher funções 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()

Funções definidas pelo usuário

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

Detalhes de implementação específicos do Neptune openCypher

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

Avaliações de caminho de comprimento variável (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 openCypher especificação especifica que cada borda deve ser percorrida no máximo uma vez por solução.

PoisVLPs, a implementação do Neptune se desvia da openCypher especificação, pois só suporta 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.

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

Atualmente, o Neptune fornece suporte limitado para a função temporal em. openCypher Ele é compatível com o tipo de dados DateTime para tipos temporais.

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


RETURN  datetime() as res

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

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 valores de data/hora em Neptune openCypher são armazenados e recuperados como valores. UTC

openCypher Neptune usa statement um relógio, 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.

Suporte temporal na openCypher implementação do Neptune (Neptune Analytics e Neptune Database 1.3.2.0 e versões posteriores)

A seguinte funcionalidade de data e hora OpenCypher se aplica ao Neptune Analytics. Como alternativa, você pode usar o parâmetro labmode DatetimeMillisecond=enabled para ativar a seguinte funcionalidade de data e hora na versão 1.3.2.0 e superior do Neptune Engine. Para obter mais detalhes sobre o uso dessa funcionalidade no modo de laboratório, consulteSuporte estendido de data e hora.

Support para milissegundos. O literal de data e hora sempre será retornado com milissegundos, mesmo que milissegundos sejam 0. (O comportamento anterior era truncar 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"
      }
    }
  } ]
}

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

Datetime () sobre 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 relação aos 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.

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

Crie nós em lote a partir de um parâmetro com uma propriedade datetime:


// 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"}
  ]
}

Support para um subconjunto maior de ISO86 10 formatos de data e hora. Consulte abaixo.

Formatos com compatibilidade

O formato de um valor de data e hora é [Data] T [Hora] [Fuso horário], onde T é o separador. Se um fuso horário explícito não for fornecido, presume-se que UTC (Z) seja o padrão.

Fuso horário

Os formatos de fuso horário suportados 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 postfixo de fuso horário acima para indicar a hora. UTC O intervalo suportado de um fuso horário é de - 14:00 a + 14:00.

Data

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

nota

DDDrefere-se 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 suportados serão limitados ao seguinte:

yyyy-MM-dd
yyyy-DDD
yyyyDDD

O intervalo suportado para datas é de 1400-01-01 a 9999-12-31.

Tempo

Se nenhum fuso horário estiver presente ou se o fuso horário for UTC (Z), os formatos de horário suportados são:

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 horário suportados serão limitados ao seguinte:

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

Diferenças na semântica da linguagem openCypher Netuno

Netuno representa o nó e o IDs relacionamento como cadeias de caracteres 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

A função `join()` específica do Neptune

Neptune implementa join() uma função que não está presente na especificação. openCypher Ela cria uma string literal a partir de uma lista de literais de string e um delimitador de string. Usa dois argumentos:

O primeiro argumento é uma lista de literais de string.
O segundo argumento é a string delimitadora, que pode ser composta por zero, um ou mais de um caractere.

Exemplo:


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

A função `removeKeyFromMap()` específica do Neptune

Neptune implementa removeKeyFromMap() uma função que não está presente na especificação. openCypher Ela remove uma chave especificada de um mapa e gera o novo mapa resultante.

A função utiliza dois argumentos:

O primeiro argumento é o mapa do qual remover a chave.
O segundo argumento é a chave a ser removida do mapa.

A função removeKeyFromMap() é particularmente útil em situações em que você deseja definir valores para um nó ou um relacionamento desenrolando uma lista de mapas. Por exemplo:


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

Valores de ID personalizados para propriedades de nó e relacionamento

A partir da versão 1.2.0.2 do mecanismo, o Neptune estendeu a openCypher especificação para que agora você possa especificar id os valores dos nós e relacionamentos nas cláusulas, e. CREATE MERGE MATCH Isso permite que você atribua cadeias de caracteres fáceis de usar em vez de geradas pelo sistema UUIDs para identificar nós e relacionamentos.

Atenção

Essa extensão da openCypher especificação é incompatível com versões anteriores, porque agora ~id é considerada um nome de propriedade reservado. Se você já estiver usando ~id como propriedade em seus dados e consultas, precisará migrar a propriedade existente para uma nova chave de propriedade e remover a antiga. Consulte O que fazer se você estiver usando atualmente ~id como propriedade.

Aqui está um exemplo que mostra como criar nós e relacionamentos personalizadosIDS:


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

Se você tentar criar um ID personalizado que já esteja em uso, o Neptune gerará um erro DuplicateDataException.

Veja um exemplo do uso de um ID personalizado em uma cláusula MATCH:


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

Aqui está um exemplo de uso personalizado IDs em uma MERGE cláusula:


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

O que fazer se você estiver usando atualmente `~id` como propriedade

Com a versão 1.2.0.2 do mecanismo, a ~id chave nas openCypher cláusulas agora é tratada como, id em vez de como uma propriedade. Isso significa que, se você tiver uma propriedade denominada ~id, o acesso a ela se tornará impossível.

Se você estiver usando uma propriedade ~id, antes de realizar a atualização para a versão do mecanismo 1.2.0.2 ou superior, é necessário primeiro migrar a propriedade ~id existente para uma nova chave de propriedade e depois remover a propriedade ~id. Por exemplo, a consulta a seguir:

Cria uma nova propriedade chamada 'newId' para todos os nós,
copia o valor da propriedade '~id' para a propriedade 'newId',
e remove a propriedade “~id” dos dados


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

O mesmo precisa ser feito para qualquer relacionamento nos dados que tenha uma propriedade ~id.

Você também precisará alterar todas as consultas que estiver usando que façam referência a uma propriedade ~id. Por exemplo, esta consulta:


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

... mudaria para isto:


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

Outras diferenças entre openCypher Neptune e Cypher

O Neptune só TCP suporta conexões para o protocolo Bolt. WebSocketsconexões para Bolt não são suportadas.
openCypher Neptune remove o espaço em branco conforme definido pelo Unicode nas funções e. trim() ltrim() rtrim()
Em openCypher Netunotostring(, ) double não muda automaticamente para a notação E para valores grandes do duplo.
Embora openCypher CREATE não crie propriedades de vários valores, elas podem existir em dados criados usando o Gremlin. Se openCypher Netuno encontrar uma propriedade de vários valores, um dos valores será escolhido arbitrariamente, criando um resultado não determinístico.

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

SPARQLconformidade com os padrões

Modelo de dados de grafo

openCypher conformidade de especificações no Amazon Neptune

nota

Support para openCypher cláusulas em Neptune

Support para openCypher operadores em Neptune

Operadores gerais

Operadores matemáticos

Operadores de comparação

Operadores booleanos

Operadores de string

Operadores List

Support para openCypher expressões em Neptune

Support para openCypher funções no Neptune

Funções de predicado

Funções escalares

Agregar funções

Listar as funções

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

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

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

Funções de string

Detalhes de implementação específicos do Neptune openCypher

Avaliações de caminho de comprimento variável (VLP) em Neptune

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

Formatos de data suportados

Formatos de hora compatíveis

Suporte temporal na openCypher implementação do Neptune (Neptune Analytics e Neptune Database 1.3.2.0 e versões posteriores)

nota

Diferenças na semântica da linguagem openCypher Netuno

A função join() específica do Neptune

A função removeKeyFromMap() específica do Neptune

Valores de ID personalizados para propriedades de nó e relacionamento

Atenção

O que fazer se você estiver usando atualmente ~id como propriedade

Outras diferenças entre openCypher Neptune e Cypher

A função `join()` específica do Neptune

A função `removeKeyFromMap()` específica do Neptune

O que fazer se você estiver usando atualmente `~id` como propriedade