SENG-42273 · Semantic Web & Ontology

Learn SPARQL

The W3C standard query language for retrieving and manipulating data stored in RDF format. Master RDF querying with hands-on examples.

10 Lessons 4 Hours Beginner Friendly W3C Standard

What is SPARQL?

SPARQL (SPARQL Protocol and RDF Query Language) is the standard query language for retrieving and manipulating data stored in RDF format. Developed by the W3C, it's the cornerstone of the Semantic Web.

Think of SPARQL as SQL for linked data — but instead of querying tables, you query graphs of interconnected information.

Understanding RDF Triples

RDF data is stored as triples: Subject → Predicate → Object. This forms the fundamental building block of all SPARQL queries.

<http://example.com/John>  <http://example.com/hasCar>  <http://example.com/Car1>
        ↑ Subject                        ↑ Predicate                    ↑ Object

"John has a car named Car1"

Subject

The resource being described

Predicate

The property or relationship

Object

The value or related resource

Part I — SPARQL Fundamentals

Core syntax, SELECT queries, and pattern matching

Query Syntax Basics

Structure and Components

01

PREFIX declarations
Query structure overview
Variable naming (?var)
URI syntax and shortcuts

SELECT Statement

Retrieving Data

02

Basic SELECT syntax
Selecting specific variables
SELECT * vs SELECT ?var
Aliasing with AS

WHERE Clause

Pattern Matching

03

Triple patterns
Matching graph data
Multiple patterns
Pattern syntax rules

FILTER Clause

Refining Results

04

Comparison operators
REGEX pattern matching
Logical operators (&&, ||)
Built-in functions

Part II — Intermediate Techniques

OPTIONAL, UNION, and result modifiers

OPTIONAL Patterns

Handling Missing Data

05

OPTIONAL syntax
Partial matches
Unbound variables
OPTIONAL vs required

UNION Queries

Combining Patterns

06

UNION syntax
Alternative patterns
UNION vs OPTIONAL
Multiple UNIONs

Result Modifiers

Sorting & Pagination

07

ORDER BY (ASC/DESC)
LIMIT and OFFSET
DISTINCT keyword
Pagination patterns

Part III — Advanced Topics

Aggregations, endpoints, and best practices

Aggregate Functions

COUNT, SUM, AVG

08

COUNT, SUM, AVG, MIN, MAX
GROUP BY clause
HAVING filter
Aggregate expressions

SPARQL Endpoints

Public Data Sources

09

What are endpoints?
DBpedia, Wikidata
HTTP protocol
Result formats

Best Practices

Tips & Optimization

10

Query optimization
Common mistakes
Performance tips
Real-world examples

Recommended Learning Path

Week 1–2Master SELECT, WHERE, and basic triple patterns. Practice with simple queries.

Week 3–4Learn FILTER, OPTIONAL, and UNION. Handle complex data scenarios.

Week 5–6Explore aggregations, endpoints, and real-world datasets like DBpedia.

SPARQL Tutorials

SELECT Statement

The SELECT statement retrieves data from an RDF dataset. Variables (starting with ?) represent the data you want to return.

PREFIX ex: <http://example.com/>

SELECT ?person ?car
WHERE {
  ?person ex:hasCar ?car .
}

Key Points

PREFIX defines namespace shortcuts
SELECT lists variables to return
WHERE contains triple patterns to match
Each triple pattern ends with a period (.)

Try It

?person	?car
ex:John	ex:Tesla_Model3
ex:Mary	ex:BMW_X5
ex:Bob	ex:Honda_Civic

FILTER Clause

The FILTER clause allows you to specify conditions that results must meet. Use comparison operators, regex, and logical operators.

PREFIX ex: <http://example.com/>

SELECT ?car ?price
WHERE {
  ?car ex:hasPrice ?price .
  FILTER (?price > 30000)
}

Equality

=, !=

Comparison

<, >, <=, >=

Logical

&&, ||, !

REGEX

Pattern matching

-- String pattern matching
FILTER (REGEX(?name, "John", "i"))

-- Multiple conditions
FILTER (?price > 1000 && ?price < 5000)

-- Check if bound
FILTER (BOUND(?email))

Try It

?car	?price
ex:Tesla_Model3	45000
ex:BMW_X5	65000
ex:Mercedes_C300	42000

OPTIONAL Clause

OPTIONAL patterns are matched if possible. If they don't match, the query still returns results with unbound variables.

SELECT ?person ?car ?color
WHERE {
  ?person ex:hasCar ?car .
  OPTIONAL {
    ?car ex:hasColor ?color .
  }
}

When to Use OPTIONAL

When data might be missing for some results
To include additional info without excluding results
For enriching results with supplementary data

Try It

?person	?car	?color
ex:John	ex:Tesla	Red
ex:Mary	ex:BMW	(unbound)
ex:Bob	ex:Honda	Blue

UNION Clause

UNION combines results from multiple patterns. It's like an OR operation — matches either pattern.

SELECT ?person ?vehicle
WHERE {
  { ?person ex:hasCar ?vehicle . }
  UNION
  { ?person ex:hasBike ?vehicle . }
}

UNION vs OPTIONAL

UNION	OPTIONAL
Match A OR B	Match A, and B if possible
Alternative paths	Enhancement of results
Separate result sets	Extended existing results

Try It

?person	?vehicle
ex:John	ex:Tesla (car)
ex:John	ex:Trek (bike)
ex:Mary	ex:BMW (car)
ex:Bob	ex:Schwinn (bike)

Result Modifiers

Control how results are sorted, limited, and paginated using ORDER BY, LIMIT, OFFSET, and DISTINCT.

ORDER BY

Sort results ASC/DESC

LIMIT

Max results to return

OFFSET

Skip N results

DISTINCT

Remove duplicates

PREFIX ex: <http://example.com/>

SELECT DISTINCT ?person ?age
WHERE {
  ?person ex:hasAge ?age .
}
ORDER BY DESC(?age)
LIMIT 10
OFFSET 5

Pagination Pattern

Page	LIMIT	OFFSET
Page 1	10	0
Page 2	10	10
Page 3	10	20
Page N	10	(N-1) × 10

Try It

?person	?age
ex:Alice	65
ex:Bob	52
ex:Carol	45
ex:David	38
ex:Eve	29

Aggregate Functions

SPARQL supports aggregation functions like COUNT, SUM, AVG, MIN, and MAX.

Function	Purpose	Example
`COUNT(?x)`	Count results	Total cars
`SUM(?x)`	Sum values	Total price
`AVG(?x)`	Average	Avg price
`MIN(?x)`	Minimum	Cheapest
`MAX(?x)`	Maximum	Most expensive

SELECT ?brand
       (COUNT(?car) AS ?count)
       (AVG(?price) AS ?avgPrice)
WHERE {
  ?car ex:hasBrand ?brand .
  ?car ex:hasPrice ?price .
}
GROUP BY ?brand
HAVING (COUNT(?car) > 2)

Try It

?brand	?count	?avgPrice
Tesla	3	52000
BMW	2	58000
Honda	5	28000

SPARQL Endpoints

A SPARQL endpoint is a web service that provides access to an RDF dataset. You send queries via HTTP and receive results in JSON, XML, or CSV.

DBpedia

Wikipedia structured data

https://dbpedia.org/sparql

Wikidata

Wikimedia knowledge base

https://query.wikidata.org/

UniProt

Protein database

https://sparql.uniprot.org/

LinkedGeoData

OpenStreetMap data

http://linkedgeodata.org/sparql

PREFIX dbo: <http://dbpedia.org/ontology/>
PREFIX dbr: <http://dbpedia.org/resource/>

SELECT ?city ?population
WHERE {
  ?city rdf:type dbo:City .
  ?city dbo:country dbr:United_States .
  ?city dbo:populationTotal ?population .
}
ORDER BY DESC(?population)
LIMIT 10

HTTP Access

Send queries via HTTP GET or POST
Results available in JSON, XML, CSV formats
Use Accept header to specify format
URL-encode your query parameter

Try It

?city	?population
dbr:New_York_City	8336817
dbr:Los_Angeles	3979576
dbr:Chicago	2693976
dbr:Houston	2320268
dbr:Phoenix,_Arizona	1680992

Best Practices & Optimization

Write efficient, readable, and maintainable SPARQL queries with these proven techniques.

Performance Tips

Tip	Why It Helps
`LIMIT` during development	Prevents timeout on large datasets
Use `rdf:type` early	Narrows search space quickly
Be specific with patterns	Reduces matching candidates
Avoid `SELECT *`	Returns only needed data
Put restrictive filters early	Eliminates rows sooner

Slow Query

SELECT *
WHERE { ?s ?p ?o }
No type restriction
Returns everything!

Fast Query

SELECT ?name
?x rdf:type ex:Person
Specific variables
Limited scope

Query Organization

Structure your queries logically for readability and maintainability:

# 1. PREFIX declarations at the top
PREFIX ex: <http://example.com/>
PREFIX rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>

# 2. SELECT with only needed variables
SELECT ?name ?age ?email

WHERE {
  # 3. Most restrictive patterns first
  ?person rdf:type ex:Employee .
  ?person ex:department ex:Engineering .

  # 4. Required patterns
  ?person ex:name ?name .
  ?person ex:age ?age .

  # 5. FILTER after related patterns
  FILTER (?age >= 25)

  # 6. OPTIONAL patterns last
  OPTIONAL { ?person ex:email ?email }
}

# 7. Modifiers at the end
ORDER BY ?name
LIMIT 100

Common Mistakes to Avoid

Missing period (.) at end of triple patterns
Case sensitivity issues (URIs are case-sensitive!)
Forgetting PREFIX declarations
Not using LIMIT on large/unknown datasets
Confusing OPTIONAL with UNION
Using = instead of pattern matching

Debugging Tips

Start simple, add complexity gradually
Test each pattern addition before moving on
Use LIMIT 1 to verify patterns match
Check variable spelling (case matters)
Verify URIs exist in the dataset

Optimized Query Example

?name	?age	?email
Alice Smith	32	[email protected]
Bob Johnson	28	[email protected]
Carol White	45	(unbound)
David Brown	38	[email protected]

SPARQL Cheat Sheet

Keywords Reference

Keyword	Purpose	Example
`PREFIX`	Define namespace shortcuts	`PREFIX ex: <…>`
`SELECT`	Specify variables to return	`SELECT ?name ?age`
`WHERE`	Define triple patterns	`WHERE { ?s ?p ?o }`
`FILTER`	Add conditions	`FILTER (?age > 18)`
`OPTIONAL`	Match if possible	`OPTIONAL { ?x ex:e ?e }`
`UNION`	Combine alternatives	`{ … } UNION { … }`
`ORDER BY`	Sort results	`ORDER BY DESC(?p)`
`GROUP BY`	Group for aggregation	`GROUP BY ?brand`
`HAVING`	Filter groups	`HAVING (COUNT(?x) > 5)`
`LIMIT`	Limit result count	`LIMIT 10`
`OFFSET`	Skip results	`OFFSET 20`
`DISTINCT`	Remove duplicates	`SELECT DISTINCT ?n`

Functions Reference

Function	Type	Description
`COUNT(?x)`	Aggregate	Count number of values
`SUM(?x)`	Aggregate	Sum of numeric values
`AVG(?x)`	Aggregate	Average of values
`MIN(?x)`	Aggregate	Minimum value
`MAX(?x)`	Aggregate	Maximum value
`REGEX(?s, p)`	String	Pattern matching
`STR(?x)`	String	Convert to string
`LANG(?x)`	String	Get language tag
`BOUND(?x)`	Test	Check if variable bound
`isURI(?x)`	Test	Check if value is URI

Common Mistakes

Missing period at end of triple patterns
Case sensitivity issues (URIs are case-sensitive)
Forgetting PREFIX declarations
Not using LIMIT on large datasets
Confusing OPTIONAL with UNION

Best Practices

Always use LIMIT during development
Be specific — more patterns = faster queries
Use rdf:type early to narrow results
Only SELECT variables you need
Put restrictive filters early

SPARQL Playground

Interactive Query Editor

Try Real Endpoints

Practice with actual SPARQL endpoints to query real-world data:

DBpedia SPARQL

Query Wikipedia's structured data

Try it live →

Wikidata Query

Explore the knowledge base

Try it live →