Why are some of the classes in my ontolgoy not being returned in my SPARQL query?

Question

I'm rather confused about why I'm receiving too little results (256 expected, 224 returned). When I run the code below, everything returns exactly as I want it, except that I miss all the classes in my ontology which lie at the highest level, or one below the highest level. I don't understand where I'm being too "strict" in my query so that these classes are not being returned in the table. They also all have parent classes (whether that be the topmost class "top concept" of the ontology, or something like an enumeration type class, either way, the leaf should still be found. Would be thankful for tips or pointers where my code might be inadvertently filtering out those classes.

SELECT DISTINCT ?leaf ?parentclasses
WHERE {
GRAPH <>
#a leaf is the lowest level class: A class that does not have a subclass
{
    {
        {
            #I want anything which is a class
            {
                ?leaf rdf:type owl:Class.
            }
            #i also want the subclass of any superclass if that exists
            {
                ?leaf rdfs:subClassOf ?superclass .
            }
            #squeezed to specific section of OTL.
            filter strstarts(str(?leaf), "URIgoeshere")
            #Only keep the results that do not have a preflabel
            OPTIONAL {
                ?leaf skos:prefLabel ?subclasslabel.
                
            }
            #make sure the subclasslabel is in dutch
            #filter( langMatches(lang(?subclasslabel),"nl") )
            
            #give me the label of the superclass
            OPTIONAL {
                ?superclass skos:prefLabel ?superclasslabel.
            }
            #make sure it's in dutch
            FILTER (lang(?superclasslabel) = "nl")
            #if it exists, give me also the superclass of the superclass creating a supersuperclass
            {
                ?superclass rdfs:subClassOf ?supersuperclass.
                #give me the label of the supersuperclass
                OPTIONAL {
                    ?supersuperclass skos:prefLabel ?supersuperclasslabel.
                }
                #make sure it's in dutch
                FILTER (lang(?supersuperclasslabel) = "nl")
                #keep the leafs that are NOT The values whereby the subclass is not empty. (double negative for removing leafs where the subclass has a subclass below it)
                FILTER NOT EXISTS {
                    ?subclass rdfs:subClassOf ?leaf 
                    FILTER (?subclass != owl:Nothing ) 
                }
                #concatenate the two parentclass variables into one    
                BIND(concat(str(?superclasslabel), str("-"), str(?supersuperclasslabel) ) as ?parentclasses) 
            }
        }
    }
}

}

Here is a ttl file with the same structure as my database: https://file.io/jjwkAWbK4jrF

it would be easier to help if you provide some data (proper full RDF in N-Triples, Turtle or whatever such that one can load it) - just a small part of it would be enough, and then just say which result is missing. — UninformedUser, Jan 28 '21 at 15:24
and something like "if it exists" should be put into an OPTIONAL pattern. For example, you're doing `?superclass rdfs:subClassOf ?supersuperclass.`, but this will lead to an empty result if there is no such superclass. — UninformedUser, Jan 28 '21 at 15:29
I'm also a bit lost, what is your query really supposed to do? I mean, in your query you get leaf classes, but in your question you're talking about "highest level" classes - something which you do not retrieve with a hard-coded subclass chain length — UninformedUser, Jan 28 '21 at 15:30
So, in a quest to get you a dataset to query (i can't share my own, it's sensitive) i created a dummy dataset with the same structure. Now comes the fun, of course the query works now. So this may have something to do with my dataset rather than my query. The query I'm looking to write should return all the leaf classes - so the classes that can be instantiated, and in a second column, return the two levels of classes above those classes. Since some leafclasses are positioned still quite high in the system, they might only have owl:thing as superclass. I'll upload my example dataset. — Robin, Jan 29 '21 at 08:51
In my example dataset you will find a number of objects that should be returned with the query. Obj2, obj1.2, obj1.3, obj1.4.1.1, obj1.4.2.1.1.1, obj1.4.2.1.2, obj1.4.2.2, obj1.4.2.3, obj1.4.3 and obj1.1 — Robin, Jan 29 '21 at 08:58

score 1 · Accepted Answer · answered Jan 29 '21 at 12:25

Below is my end solution to my problem. It was more complicated than I expected, but it works.

The problem was that these classes that didn't have a parent class were not being accepted by the query. With some union cases this could be covered for 0 parent classes, 1 parent class or 2 parent classes.

SELECT DISTINCT ?leaf ?parentclasses
WHERE {
GRAPH <>
#a leaf is the lowest level class: A class that does not have a subclass
{{{{{
                    
                   
                    
        #I want anything which is a class
        {?leaf rdf:type owl:Class.}
                    
#squeezed 
        filter strstarts(str(?leaf), "graph")           
        #keep the leafs that are NOT The values whereby the subclass is not empty. 
 (double negative for removing leafs where the subclass has a subclass below it)
            FILTER NOT EXISTS {?subclass rdfs:subClassOf ?leaf 
            FILTER (?subclass != owl:Nothing ) }
 }              
                {
         {?leaf rdfs:subClassOf ?superclass .}
               
 #grab dutch label if available
optional {
?superclass skos:prefLabel ?superclassnllabel .
filter( langMatches(lang(?superclassnllabel),"nl") )
}

# take either as the label, but dutch over empty
                bind( coalesce( ?superclassnllabel, replace(str(? 
superclass),"^[^#]*#", "" ) ) as ?superclasslabel )
            
                {
                    
                {?superclass rdfs:subClassOf ?supersuperclass.}
                

        #grab dutch label if available
 
?supersuperclass skos:prefLabel ?supersuperclassnllabel .
                    filter( langMatches(lang(?supersuperclassnllabel),"nl") )



 # take either as the label, but dutch over empty
                    bind( coalesce( ?supersuperclassnllabel, replace(str(? 
 supersuperclass),"^[^#]*#", "" ) ) as ?supersuperclasslabel )
                BIND(concat(str(?superclasslabel), str(" - "), str(? 
supersuperclasslabel) ) as ?parentclasses)
                }
                union
                {
                    
                    {?superclass ?p ?o.filter(!isblank(?superclass))}
                    FILTER NOT EXISTS {?superclass rdfs:subClassOf ?supersuperclass}
                        BIND(concat(str(?superclasslabel), str(" - "), str("Top 
Concept") ) as ?parentclasses) 
                #concatenate the two parentclass variables into one    
                
                }


        
            }
            }
            
            union
            {
                   #figure this out, WHY IS IT HERE? 
                {?leaf rdf:type owl:Class .filter(!isblank(?leaf))}
                FILTER strstarts(str(?leaf), "graph") 
                FILTER NOT EXISTS {?leaf rdfs:subClassOf ?superclass}
                FILTER NOT EXISTS {?subclass rdfs:subClassOf ?leaf 
                FILTER (?subclass != owl:Nothing ) }
                BIND (str("Top Class")  as ?parentclasses )
                   
                
                }

            }}}}

Why are some of the classes in my ontolgoy not being returned in my SPARQL query?

1 Answers1