Come espandere in modo ricorsivo i nodi vuoti nella query del costrutto SPARQL?

Question

Probabilmente c'è una risposta facile a questo, ma non riesco nemmeno a capire come formulare la query di Google per trovarlo.

Sto scrivendo query di costruzione SPARQL su un set di dati che include nodi vuoti. Quindi, se faccio una query come

CONSTRUCT {?x ?y ?z .} WHERE {?x ?y ?z .}

Poi uno dei miei risultati potrebbero essere:

nm:John nm:owns _:Node

che è un problema se tutti i

_:Node nm:has nm:Hats

le triple non ottengono in qualche modo il risultato della query (perché alcuni parser che sto usando come rdf alla lib per Python non piacciono davvero i bnodes pendenti).

C'è un modo per scrivere la mia query COSTRUZIONE originale per aggiungere in modo ricorsivo tutte le triple associate a qualsiasi risultato di bnode in modo tale che nessun bnode venga lasciato penzolare nel mio nuovo grafico?

Answer 1

La ricorsione non è possibile. Il più vicino a cui riesco a pensare è SPARQL 1.1 property paths (nota: quella versione è scaduta) ma i test di bnode non sono disponibili (afaik).

Si potrebbe semplicemente rimuovere le dichiarazioni con le bnodes finali:

CONSTRUCT {?x ?y ?z .} WHERE 
{ 
    ?x ?y ?z . 
    FILTER (!isBlank(?z)) 
} 

o tentare la fortuna recupero il bit successivo:

CONSTRUCT {?x ?y ?z . ?z ?w ?v } WHERE 
{ 
    ?x ?y ?z . 
    OPTIONAL { 
    ?z ?w ?v 
    FILTER (isBlank(?z) && !isBlank(?v)) 
    } 
} 

(che ultima query è piuttosto punire, btw)

Forse starai meglio con DESCRIBE, che salterà spesso i bnodi.

Answer 2

Come suggerisce l'utente205512, eseguire tale operazione in modo ricorsivo non è possibile e, come indicato, utilizzando facoltativo (s) per scendere a livelli arbitrari verso i dati, non è fattibile su database di dimensioni non banali.

Gli stessi Bnodi sono localmente con ambito, sul set di risultati o sul file. Non vi è alcuna garanzia che un BNode si ottenga dall'analisi o da un set di risultati sia lo stesso ID utilizzato nel database (sebbene alcuni database lo garantiscano per i risultati della query). Inoltre, una query come "select? S where {? S? P _: bnodeid1}" è la stessa cosa di "select? Where {? S? P? O}" - nota che bnode è trattato come variabile in quel caso , non come "la cosa con l'id" bnodeid1 "" Questa stranezza del design rende difficile la ricerca di bnodes, quindi se si ha il controllo dei dati, suggerirei di non usarli. Non è difficile generare nomi per cose che sarebbero altrimenti bnodes, e le risorse con nome v. Bnodes non aumenteranno il sovraccarico durante l'interrogazione.

Questo non aiuta a recedere e ad afferrare i dati, ma per questo, non consiglio di fare queste domande generali; non si adattano bene e di solito restituiscono più di quanto desideriate o di cui avete bisogno. Ti suggerirei di fare più domande dirette. La tua query di costrutto originale ridurrà il contenuto dell'intero database, generalmente non è quello che desideri.

Infine, mentre descrivere può essere utile, non esiste un'implementazione standard; la specifica SPARQL non definisce alcun comportamento particolare, quindi ciò che viene restituito è lasciato al fornitore del database e può essere diverso. Ciò può rendere il tuo codice meno portabile se pensi di provare diversi database con la tua applicazione. Se vuoi un comportamento specifico fuori descrizione, è meglio implementarlo tu stesso. Fare qualcosa come la descrizione limitata concessa per una risorsa è un pezzo di codice facile, anche se puoi incontrare qualche mal di testa attorno a Bnodes.

Answer 3

Per quanto riguarda il funzionamento con la libreria RDF.rb di Ruby, che consente le query SPARQL con metodi di convenienza significativi sugli oggetti RDF :: Graph, i seguenti devono espandere i nodi vuoti.

rdf_type = RDF::SCHEMA.Person # for example 
rdf.query([nil, RDF.type, rdf_type]).each_subject do |subject| 
    g = RDF::Graph.new 
    rdf.query([subject, nil, nil]) do |s,p,o| 
    g << [s,p,o] 
    g << rdf_expand_blank_nodes(o) if o.node? 
    end 
end 

def rdf_expand_blank_nodes(object) 
    g = RDF::Graph.new 
    if object.node? 
    rdf.query([object, nil, nil]) do |s,p,o| 
     g << [s,p,o] 
     g << rdf_expand_blank_nodes(o) if o.node? 
    end 
    end 
    g 
end