As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá. # 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](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf). 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](access-graph-opencypher-extensions.md). **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](migration-compatibility.md) e [Reformular consultas do Cypher para serem executadas no openCypher no Neptune](migration-opencypher-rewrites.md) 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](access-graph-opencypher-extensions.md#opencypher-compliance-custom-ids) 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](access-graph-opencypher-extensions.md#opencypher-compliance-custom-ids) em consultas `CREATE`. + `DELETE` + `SET` + `REMOVE` + `MERGE`: o Neptune é compatível com [valores de ID personalizados](access-graph-opencypher-extensions.md#opencypher-compliance-custom-ids) 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](https://docs.aws.amazon.com//neptune/latest/userguide/engine-releases-1.3.2.0.html) do mecanismo. Consulte [Dicas de consultas](https://docs.aws.amazon.com//neptune/latest/userguide/opencypher-query-hints.html) 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 `<=` 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). ## 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()`](access-graph-opencypher-extensions.md#opencypher-compliance-join-function) (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()`](access-graph-opencypher-extensions.md#opencypher-compliance-join-function) (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 da implementação do openCypher específicos do Neptune 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](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf) ### Avaliações de caminho de comprimento variável (VLP) no 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](https://s3.amazonaws.com/artifacts.opencypher.org/openCypher9.pdf) especifica que cada borda deve ser percorrida no máximo uma vez por solução. Pois VLPs, a implementação do Neptune se desvia da especificação OpenCypher, 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.` ### 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 `"`*date*`T`*time*`"` 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](features-lab-mode.md#labmode-extended-datetime-support). + 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"} ] } ``` + Support para um subconjunto maior de formatos de ISO8601 data e hora. 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: + \$1/-HH:mm + \$1/-HHmm + \$1/-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 \$114: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 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 ``` ### Propriedades de vários valores 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.