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 os padrões SPARQL no Amazon Neptune Depois de listar os padrões SPARQL aplicáveis, as seções a seguir fornecem detalhes específicos sobre como a implementação do SPARQL no Neptune se estende ou diverge desses padrões. **Topics** + [Padrões aplicáveis do SPARQL](#feature-sparql-applicable-standards) + [Prefixos de namespace padrão no SPARQL no Neptune](#sparql-default-prefixes) + [Gráfico padrão e gráficos nomeados do SPARQL](#sparql-default-graph) + [XPath Funções do construtor SPARQL suportadas pelo Neptune](#access-graph-sparql-xpath-constructors) + [IRI de base padrão para consultas e atualizações](#opencypher-compliance-default-iri) + [Valores xsd:dateTime no Neptune](#access-graph-sparql-xsd-date-time) + [Tratar valores de ponto flutuante especiais do Neptune](#feature-overview-special-values-comparisons) + [Limitação de valores de comprimento arbitrário do Neptune](#feature-overview-arbitrary-length-values) + [O Neptune estende a comparação “igual a” no SPARQL](#feature-overview-sparql-not-equal) + [Manipulação de Out-of-Range literais em Neptune SPARQL](#feature-overview-sparql-out-of-range) O Amazon Neptune está em conformidade com os padrões a seguir na implementação da linguagem de consulta de grafos SPARQL. ## Padrões aplicáveis do SPARQL + O SPARQL é definido pela recomendação W3C [SPARQL 1.1 Query Language](https://www.w3.org/TR/sparql11-query/) de 21 de março de 2013. + O protocolo de atualização e a linguagem de consulta do SPARQL são definidos pela especificação W3C [SPARQL 1.1 Update](https://www.w3.org/TR/sparql11-update/). + Para formatos numéricos, o SPARQL segue a especificação [W3C XML Schema Definition Language (XSD) 1.1 Part 2: Datatypes](https://www.w3.org/TR/xmlschema11-2/), consistente com a especificação IEEE 754 ([IEEE 754-2019 - IEEE Standard for Floating-Point Arithmetic](https://standards.ieee.org/content/ieee-standards/en/standard/754-2019.html). Para obter mais informações, consulte também a [página IEEE 754 da Wikipédia](https://en.wikipedia.org/wiki/IEEE_754)). No entanto, os recursos que foram apresentados após a versão `IEEE 754-1985` não estão incluídos na especificação. ## Prefixos de namespace padrão no SPARQL no Neptune O Neptune define os prefixos a seguir por padrão para uso em consultas do SPARQL. Para obter mais informações, consulte [Nomes prefixados](https://www.w3.org/TR/sparql11-query/#prefNames) na especificação do SPARQL. + `rdf`  – `http://www.w3.org/1999/02/22-rdf-syntax-ns#` + `rdfs` – `http://www.w3.org/2000/01/rdf-schema#` + `owl`  – `http://www.w3.org/2002/07/owl#` + `xsd`  – `http://www.w3.org/2001/XMLSchema#` ## Gráfico padrão e gráficos nomeados do SPARQL O Amazon Neptune associa cada triplo a um grafo nomeado. O gráfico padrão é definido como a união de todos os gráficos nomeados. **Gráfico padrão para consultas** Se você enviar uma consulta do SPARQL sem especificar explicitamente um gráfico por meio da palavra-chave `GRAPH` ou construções como `FROM NAMED`, o Neptune sempre considerará todos os trios em sua instância de banco de dados. Por exemplo, a seguinte consulta gera todos os triplos de um endpoint do SPARQL no Neptune: `SELECT * WHERE { ?s ?p ?o }` Trios que aparecem em mais de um gráfico são retornados somente uma vez. Para obter informações sobre a especificação de gráfico padrão, consulte a seção [Dataset do RDF](https://www.w3.org/TR/sparql11-query/#rdfDataset) da especificação do SPARQL 1.1 Query Language. **Especificar o gráfico nomeado para carregamentos, inserções ou atualizações** Se você não especificar um grafo nomeado ao carregar, inserir ou atualizar triplos, o Neptune usará o grafo nomeado fallback definido pelo URI `http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph`. Ao emitir uma solicitação `Load` do Neptune usando um formato baseado em triplos, é possível especificar o grafo nomeado a ser usado para todos os triplos com o parâmetro `parserConfiguration: namedGraphUri`. Para obter mais informações sobre a sintaxe do comando `Load`, consulte [Comando do carregador do Neptune](load-api-reference-load.md). **Importante** Se você não usar esse parâmetro e não especificar um gráfico nomeado, o URI de fallback será usado: `http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph`. Esse gráfico nomeado de fallback também será usado se você carregar trios por meio de `SPARQL UPDATE` sem fornecer explicitamente um destino de gráfico nomeado. Você pode usar o formato com base em quads, N-Quads, para especificar um gráfico nomeado para cada trio no banco de dados. **nota** O uso de N-Quads permite que você deixe o gráfico nomeado em branco. Nesse caso, `http://aws.amazon.com/neptune/vocab/v01/DefaultNamedGraph` é usado. Você pode substituir o gráfico padrão nomeado para N-Quads usando a opção de configuração do analisador `namedGraphUri`. ## XPath Funções do construtor SPARQL suportadas pelo Neptune O padrão SPARQL permite que os mecanismos SPARQL suportem um conjunto extensível de funções de XPath construtor. No momento, o Neptune é compatível com as seguintes funções de construtor, nas quais o prefixo `xsd` é definido como `http://www.w3.org/2001/XMLSchema#`: + `xsd:boolean` + `xsd:integer` + `xsd:double` + `xsd:float` + `xsd:decimal` + `xsd:long` + `xsd:unsignedLong` ## IRI de base padrão para consultas e atualizações Como um cluster do Neptune tem vários endpoints diferentes, usar a URL de solicitação de uma consulta ou atualização como IRI base pode levar a resultados inesperados na resolução relativa. IRIs A partir da [versão 1.2.1.0 do mecanismo](engine-releases-1.2.1.0.md), o Neptune usará `http://aws.amazon.com/neptune/default/` como IRI base se um IRI de base explícito não fizer parte da solicitação. Na seguinte solicitação, o IRI de base faz parte da solicitação: ``` BASE INSERT DATA { "n1" } BASE SELECT * { ?p ?o } ``` E o resultado seria: ``` ?p ?o http://example.org/default/id n1 ``` No entanto, nesta solicitação, nenhum IRI de base está incluído: ``` INSERT DATA { "n1" } SELECT * { ?p ?o } ``` Nesse caso, o resultado seria: ``` ?p ?o http://aws.amazon.com/neptune/default/id n1 ``` ## Valores xsd:dateTime no Neptune Por motivos de desempenho, o Neptune sempre date/time armazena valores como Tempo Universal Coordenado (UTC). Isso torna as comparações diretas muito eficientes. Também significa que se você inserir um valor `dateTime` que determine um fuso horário específico, o Neptune converterá o valor em UTC e descartará as informações de fuso horário. Depois, quando o valor `dateTime` for recuperado mais tarde, ele será expresso em UTC, não no fuso horário original, que não poderá mais ser determinado. ## Tratar valores de ponto flutuante especiais do Neptune O Neptune trata os valores de ponto flutuante especiais no SPARQL da forma a seguir. ### Tratamento de NaN em SPARQL no Neptune No Neptune, o SPARQL pode aceitar um valor de `NaN` em uma consulta. Não há distinção entre valores de `NaN` de sinalização e silenciosos. O Neptune trata todos os valores `NaN` como silenciosos. Semanticamente, não é possível realizar uma comparação com um `NaN`, pois nada é maior que, menor que, nem igual a um `NaN`. Isso significa que um valor de `NaN` em um lado de uma comparação, teoricamente, nunca corresponde a *nada* do outro lado. No entanto, a [especificação XSD](https://www.w3.org/TR/xmlschema-2/#double) trata dois valores `xsd:double` ou `xsd:float` `NaN` como iguais. O Neptune aplica isso ao filtro `IN`, para o operador igual em expressões de filtro e para a semântica de correspondência exata (com `NaN` na posição do objeto para um padrão triplo). ### Tratar valores infinitos do SPARQL no Neptune No Neptune, o SPARQL pode aceitar um valor de `INF` ou `-INF` em uma consulta. O `INF` compara com outros valores numéricos superiores e o `-INF` compara com outros valores numéricos inferiores. Dois valores INF com sinais correspondentes são comparados como iguais, independentemente do tipo (por exemplo, um `-INF` flutuante compara como igual a um `-INF` duplo). Claro, não é possível realizar uma comparação com um `NaN`, pois nada é maior que, menor que, nem igual a um `NaN`. ### Tratar zero negativo do SPARQL no Neptune O Neptune normaliza um valor de zero negativo para um zero sem sinal. Você pode usar valores de zero negativo em uma consulta, mas eles não são registrados dessa forma no banco de dados, pois são comparados como iguais a zeros sem sinal. ## Limitação de valores de comprimento arbitrário do Neptune O Neptune limita o tamanho do armazenamento de valores inteiros XSD, de ponto flutuante e decimais no SPARQL a 64 bits. O uso de valores maiores gera um erro `InvalidNumericDataException`. ## O Neptune estende a comparação “igual a” no SPARQL O padrão do SPARQL define uma lógica ternária para expressões de valor, nas quais uma expressão de valor pode ser avaliada como `true`, `false` ou `error`. A semântica padrão para a igualdade de termos, conforme definido na [especificação SPARQL 1.1](https://www.w3.org/TR/sparql11-query/#func-RDFterm-equal), que se aplica às comparações `=` e`!=` em condições de `FILTER`, produz um `error` ao comparar tipo de dados que não são explicitamente compatíveis na [tabela de operadores](https://www.w3.org/TR/sparql11-query/#OperatorMapping) da especificação. Esse comportamento pode levar a resultados não intuitivos, conforme o exemplo a seguir. Dados: ``` "127.0.0.1"^^ ``` Consulta 1: ``` SELECT * WHERE { ?o . FILTER(?o = "127.0.0.2"^^) } ``` Consulta 2: ``` SELECT * WHERE { ?o . FILTER(?o != "127.0.0.2"^^) } ``` Com a semântica SPARQL padrão usada pelo Neptune antes da versão 1.0.2.1, as duas consultas gerariam o resultado vazio. O motivo é que `?o = "127.0.0.2"^^` quando avaliado para `?o := "127.0.0.1"^^` gera um `error` em vez de `false`, porque não há regras de comparação explícitas especificadas para o tipo de dados personalizado ``. Como resultado, a versão negada na segunda consulta também gera um `error`. Em ambas as consultas, o `error` faz com que a solução candidata seja filtrada. A partir da versão 1.0.2.1, o Neptune ampliou o operador de desigualdade do SPARQL de acordo com a especificação. Consulte a seção [SPARQL 1.1 section on operator extensibility](https://www.w3.org/TR/sparql11-query/#operatorExtensibility), que permite que os mecanismos definam regras adicionais sobre como comparar tipos de dados internos definidos pelos usuários e não comparáveis. Ao usar essa opção, o Neptune trata uma comparação entre dois tipos de dados que não estão explicitamente definidos na tabela de mapeamento do operador como `true`, se os valores literais e os tipos de dados forem sintaticamente iguais, e falsos, caso não sejam. Um `error` não será produzido nesses casos. Ao usar essas nova semânticas, a segunda consulta retornaria um `"127.0.0.1"^^` em vez de um resultado vazio. ## Manipulação de Out-of-Range literais em Neptune SPARQL A semântica XSD define cada tipo numérico com o espaço de valor, exceto `integer` e `decimal`. Essas definições limitam todos os tipos a um intervalo de valores. Por exemplo, um intervalo de `xsd:byte` é de -128 a \$1127, inclusivo. Qualquer valor fora desse intervalo é considerado inválido. Se você tentar atribuir um valor literal fora do espaço de valor de um tipo (por exemplo, se tentar definir an `xsd:byte` como um valor literal de 999), Netuno aceitará o valor como está, sem arredondá-lo ou truncá-lo. out-of-range Mas ele não continua como um valor numérico, porque o tipo determinado não pode representá-lo. Ou seja, o Neptune aceita `"999"^^xsd:byte` mesmo estando fora do intervalo de valores `xsd:byte` definido. No entanto, após o valor continuar no banco de dados, ele poderá ser usado somente na semântica de correspondência exata, em uma posição do objeto de um padrão triplo. Nenhum filtro de intervalo pode ser executado nele porque out-of-range os literais não são tratados como valores numéricos. A especificação SPARQL 1.1 define [operadores de intervalo](https://www.w3.org/TR/sparql11-query/#OperatorMapping) no formato `numeric`*-operator-*`numeric`, `string`*-operator-*`string`, `literal`*-operator-*`literal`, e assim em diante. O Neptune não pode executar um operador de comparação de intervalo como `invalid-literal`*-operator-*`numeric-value`.