SPARQL Query to second and third level with concat - sparql

[I have a Tree Structure with three levels currently I am able to get the first level data from the the query written below I am looking for a query that can help me to concat data for ?o and their respective ?s ?p and ?o and even drill down to third level if needed
I have tried it with construct query but want it in a specific format do trying it out with select and concat
construct{ ?CR ?p ?cOBJECT .}
where {
select ?CR ?p (group_concat(?o;separator=',') as ?cOBJECT)
where{ VALUES ?p {abc:hasPart abc:hasLog abc:Description abc:CRStatus abc:hasSB abc:hasTB}
?CR ?p ?o .
}
GROUP BY ?CR ?p
}

Related

SPARQL: How to get all triples with certain predicate where only one direction exists

I want to query all triples with a certain predicate p. The query should only return triples (s,p,o) where the other direction (o,p,s) does not exist.
How can I make such a query?

That's pretty easy:
SELECT ?s ?p ?o {
?s ?p ?o
MINUS { ?o ?p ?s }
}
FILTER NOT EXISTS instead of MINUS would also work. Replace ?p in the query with the desired predicate, or use something like FILTER (?p=ex:myPredicate) if you want ?p in the result.

Does SPARQL literals have a type?

I want to write a sparql query to extract all predicates from DBPedia that their subjects are Person and their objects are Date Literals.
This is my query:
SELECT ?o ?p ?d
from <http://dbpedia.org>
where{
?o <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://dbpedia.org/ontology/Person>.
?d <http://www.w3.org/1999/02/22-rdf-syntax-ns#type> <http://dbpedia.org/property/date>.
?o ?p ?d.
}
The query doesn't show any result and it seems that I have to define date literals in another way. I wonder to know what is the right way to define the type of literals.

Excluding triples based on substring

I have a graph created by sponging web pages. I'm trying to write a query to exclude all triples where the subject is a web page. I can get these triples simply by
FILTER (STRENDS((STR(?i)), "html"))
but what's the best way to exclude them. Basically I need all {?s ?p ?o} minus the subset {?i ?p ?o}.

This
SELECT *
{ ?s ?p ?o
FILTER ( ! STRENDS( STR(?s), "html") )
}
filters the outcome the pattern.

How to return all S->P->O triples from a starting resource to a specified path depth?

My goal is to graphically represent the S->P->O relations within a depth two edges from the specified resource, p:Person_1. I want all relations within that path length to be returned from my query as ?s, ?p, ?o for further processing in my graphical application.
I tried the first query below which gives me my first set of ?s ?p ?o with repeats, then ?p2, ?o2, ?p3, ?o3 as additional columns in the result. I want to bind ?p2 and ?p3 to ?p, ?o2 and ?o3 to ?o.
SELECT *
WHERE {
p:Person_1 ?p ?o .
BIND("p:Person_1" as ?s)
OPTIONAL{
?o ?p2 ?o2 .
}
OPTIONAL{
?o2 ?p3 ?o3 .
}
}
Then, based on How do I construct get the whole sub graph from a given resource in RDF Graph?, I tried using CONSTRUCT to return the graph.
PREFIX p: <http://www.example.org/person/>
PREFIX x: <example.org/foo/>
construct { ?s ?p ?o }
FROM <http://localhost:8890/MYGRAPH>
where { p:Person_1 (x:|!x:)* ?s .
?s ?p ?o .
}
I am using Virtuoso and I get the error:
Virtuoso 37000 Error SP031: SPARQL compiler: Variable ?_::trans_subj_9_3 in T_IN list is not a value from some triple
I could post-process the result from my first query but I want to learn how to do this correctly with SPARQL, preferably on Virtuoso.
Update after testing the advice from #AKSW :
Both CONSTRUCT and SELECT statements work with the pattern suggested.
CONSTRUCT { ?s ?p ?o }
FROM <http://localhost:8890/MYGRAPH>
where { p:Person_1 (x:foo|!x:bar)* ?s .
?s ?p ?o .
} LIMIT 100
and:
SELECT s ?p ?o
FROM <http://localhost:8890/MYGRAPH>
where { p:Person_1 (x:foo|!x:bar)* ?s .
?s ?p ?o .
} LIMIT 100
The SELECT results in several duplicates that cannot be removed using DISTINCT, which results in an error that I assume is due to the 'datatype' of some of the returned values.
Virtuoso 22023 Error SR066: Unsupported case in CONVERT (DATETIME -> IRI_ID)
It appears some post-SPARQL processing is in order.
This gets me most of the way there. Still hoping I can find a solution for SPARQL that is like Cypher's "number of hops away" :
OPTIONAL MATCH path=s-[*1..3]-(o)

Here is a SPARQL query that works in Virtuoso. Note the SPARQL W3C standard does not support this syntax and it will fail in other triplestores.
PREFIX p: <http://www.example.org/person/>
PREFIX x: <example.org/foo/>
# CONSTRUCT {?s ?p ?o} # If you wish to return the graph
SELECT ?s ?p ?o # To return the triples
FROM <http://localhost:8890/MYGRAPH>
where { p:Person_1 (x:foo|!x:bar){1,3} ?s .
?s ?p ?o .
}LIMIT 100
See also K. Idehen's wiki entry here: http://linkedwiki.com/exampleView.php?ex_id=141
And thanks to #Joshua Taylor for advice in the same area.

Working Drafts of SPARQL 1.1 Property Paths included the {n,m} operator for handling this issue, which was implemented (and will remain supported) in Virtuoso. Here's a tweak to #tim's response.
Live SPARQL Query Results Page using the DBpedia endpoint (which is a Virtuoso instance).
Live SPARQL Query Definition Page that opens up query source code in the default DBpedia query editor.
Actual Query Example:
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
SELECT DISTINCT ?s AS ?Entity
?o AS ?Category
WHERE {
?s rdf:type <http://dbpedia.org/ontology/AcademicJournal> ;
rdf:type{1,3} ?o
}
LIMIT 100

Should you be looking for LinkedIn-like presentation of Contact Networks and Degrees of Separation between individuals, here is an example using Virtuoso-specific SPARQL Extensions that solve this particular issue:
SELECT ?o AS ?WebID
((SELECT COUNT (*) WHERE {?o foaf:knows ?xx})) AS ?contact_network_size
?dist AS ?DegreeOfSeparation
<http://www.w3.org/People/Berners-Lee/card#i> AS ?knowee
WHERE
{
{
SELECT ?s ?o
WHERE
{
?s foaf:knows ?o
}
} OPTION (TRANSITIVE, t_distinct, t_in(?s), t_out(?o), t_min (1), t_max (4), t_step ('step_no') AS ?dist) .
FILTER (?s= <http://www.w3.org/People/Berners-Lee/card#i>)
FILTER (isIRI(?s) and isIRI(?o))
}
ORDER BY ?dist DESC (?contact_network_size)
LIMIT 500
Note: this approach is the only way (at the current time) to expose actual relational hops between entities in an Entity Relationship Graph that includes Transitive relations.
Live Link to Query Results
Live Link to Query Source Code

Bearing in mind that the r{n,m} operator was deprecated in the final SPARQL 1.1 (but will remain supported in Virtuoso), you can use r/r?/r? instead of r{1,3}, if you want to work strictly off the current spec:
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
SELECT DISTINCT ?s AS ?Entity
?o AS ?Category
WHERE {
?s rdf:type <http://dbpedia.org/ontology/AcademicJournal> ;
rdf:type / rdf:type? / rdf:type? ?o
}
LIMIT 100
Here's a live example, against the DBpedia instance hosted in Virtuoso.

SPARQL count number of relations at once

Is it possible to get, in a single query, a count of the number of multiple relations? e.g.
SELECT (COUNT(?friendid) as ?friends) (COUNT(?cousinid) as ?cousins) (COUNT(?sonid) as ?sons)
WHERE
{
ex:person1 ex:friendOf ?friendid .
ex:person1 ex:cousinOf ?cousinid .
ex:person1 ex:fatherOf ?sonid .
}
If a complex query with multiple queries is needed, is this -in theory, of course- supposed to be faster than executing different SELECTs?

Following query retrieves ALL the predicates and their numbers:
SELECT ?p (COUNT(?p) as ?pCount) WHERE { ex:person1 ?p ?o} GROUP BY ?p
This one restricts the predicates (AKSW's suggestion):
SELECT ?p (COUNT(?p) as ?pCount) WHERE { ex:person1 ?p ?o. VALUES (?p) {(:p1)}} GROUP BY ?p
Here is an example:
SELECT ?p (COUNT(?p) as ?pCount) WHERE
{
<http://dbpedia.org/resource/Category:Museums_in_Italy> ?p ?o .
VALUES (?p) {(skos:altLabel) (owl:sameAs)}
}
GROUP BY ?p
And here are the results:
Results