Conformidade com os padrões SPARQL no Amazon Neptune - Amazon Neptune
Padrões aplicáveis do SPARQLPrefixos de namespace padrãoGráficos nomeados e padrãoConstrutores XPath do NeptuneIRI de base para consultasxsd:dateTimeValores de ponto flutuante especiaisValores de comprimento arbitrárioComportamento de “igual a”Literais fora do intervalo

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.

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

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 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 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.

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.

Funções de construtor XPath SPARQL compatíveis com o Neptune

O padrão SPARQL permite que os mecanismos SPARQL sejam compatíveis com um conjunto extensível de funções do construtor XPath. 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 o URL de solicitação de uma consulta ou atualização como IRI de base pode gerar resultados inesperados na resolução de IRIs relativos.

A partir da versão 1.2.1.0 do mecanismo, 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 <http://example.org/default/>
INSERT DATA { <node1> <id> "n1" }

BASE <http://example.org/default/>
SELECT * { <node1> ?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 { <node1> <id> "n1" }

SELECT * { <node1> ?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 armazena valores de data/hora 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 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 termo conforme definido na especificação SPARQL 1.1), que se aplica às comparações de = e != nas condições de FILTER, produz um error ao comparar os tipos de dados que não são explicitamente comparáveis na tabela de operadores na especificação.

Esse comportamento pode levar a resultados não intuitivos, conforme o exemplo a seguir.

Dados:

<http://example.com/Server/1> <http://example.com/ip> "127.0.0.1"^^<http://example.com/datatype/IPAddress>

Consulta 1:

SELECT * WHERE {
    <http://example.com/Server/1> <http://example.com/ip> ?o .
    FILTER(?o = "127.0.0.2"^^<http://example.com/datatype/IPAddress>)
}

Consulta 2:

SELECT * WHERE {
    <http://example.com/Server/1> <http://example.com/ip> ?o .
    FILTER(?o != "127.0.0.2"^^<http://example.com/datatype/IPAddress>)
}

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"^^<http://example.com/IPAddress> quando avaliado para ?o := "127.0.0.1"^^<http://example.com/IPAddress> gera um error em vez de false, porque não há regras de comparação explícitas especificadas para o tipo de dados personalizado <http://example.com/IPAddress>. 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, 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"^^<http://example.com/IPAddress> em vez de um resultado vazio.

Tratar literais fora do intervalo no SPARQL no Neptune

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 +127, 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 no formato numeric-operator-numeric, string-operator-string, literal-operator-literal, etc. O Neptune não pode executar um operador de comparação de intervalo como invalid-literal-operator-numeric-value.