Querying a Known Resource in SPARQL: Finding Iron Man's Name

  

So far, we've seen how SPARQL can retrieve data from an RDF graph using variables. Now let's make things a little more interesting by querying a specific resource that we already know exists in the graph.

 

Suppose we want to answer a simple question "What is Iron Man's name? ". At first glance, that may sound trivial, but it introduces one of the most fundamental SPARQL patterns, starting from a known node and traversing a relationship to retrieve a value.

 

The Data in our Marvel dataset, the superhero resource is defined as follows:

 

:Iron_Man a :Superhero ;

    :name "Iron Man" .

 

Here:

 

·      :Iron_Man is the subject (the resource we're interested in)

·      :name is the predicate

·      "Iron Man" is the object (a literal value)

 

Visually, the graph looks like this:

:Iron_Man  ── :name ──►  "Iron Man"

   

Our goal is to start at the :Iron_Man node and retrieve the value connected through the :name relationship.

 

1. Writing the SPARQL Query

 

PREFIX : <http://example.org/marvel/> 

SELECT ?n 
WHERE { 
  :Iron_Man :name ?n . 
}

   

1.1 Understanding the Query

PREFIX Declaration

 

PREFIX : <http://example.org/marvel/>

   

The colon (:) is a shorthand for our namespace. Instead of writing "<http://example.org/marvel/Iron_Man>", we can simply write ":Iron_Man", which makes queries much easier to read.

 

SELECT Clause

The SELECT clause specifies the variables we want returned in the result set. In this case, we want the value stored in the variable ?n.

 

SELECT ?n

   

WHERE Clause

 

WHERE {
    :Iron_Man :name ?n .
}

   

This pattern is almost identical to Turtle syntax. We're saying:

 

·      Start at the resource :Iron_Man

·      Follow the :name relationship

·      Capture whatever value is found into the variable ?n

 

Notice that the only difference from Turtle is that we've replaced the literal value with a variable ?n.

 

1.2 Query Pattern vs RDF Triple

The RDF triple:

 

:Iron_Man :name "Iron Man" .

becomes the SPARQL pattern:

:Iron_Man :name ?n .

SPARQL attempts to match this pattern against the graph and binds any matching value to the variable.

 

In our example, the variable ?n is bound to the literal value "Iron Man", which is returned as the query result.

 

Why This Matters?

Although this example is simple, it demonstrates a powerful concept:

 

·      Start from a known resource.

·      Traverse one or more relationships.

·      Retrieve information connected to that resource.

 

This "one-hop traversal" pattern forms the foundation of many SPARQL queries. As your graph grows, you'll use the same approach to navigate multiple hops and answer increasingly complex questions.

 

For example:

·      Who portrays Iron Man?

·      Which team does Tony Stark belong to?

·      Which movies does Tony Stark appear in?

·      Which villains have the Avengers fought against?

 

All of these queries build upon the same principle introduced here, matching graph patterns and binding values to variables.

 

SPARQL may look different from SQL, but once you recognize that a query pattern is simply an RDF triple with variables, reading and writing queries becomes much more intuitive.

 

Previous                                                    Next                                                    Home