Query Patterns - SPARQLqueries

Building Blocks for Complex Queries

After mastering SPARQL syntax, the next step is learning reusable patterns that solve recurring problems. These patterns are the "design patterns" of SPARQL — proven solutions you can adapt to many situations.

This chapter covers:

Hierarchy traversal — Navigate class hierarchies and transitive relationships
Entity linking — Connect entities across identifiers and datasets
Ranking & scoring — Order results by computed relevance
Deduplication — Handle multiple values and remove duplicates cleanly
Optimization — Make queries faster and more efficient
Debugging — Diagnose and fix query problems

Pattern Topics

🌳

Hierarchy Traversal

Navigate class and property hierarchies using property paths. Query transitive relationships.

Intermediate P279, P31

Learn Hierarchies

🔗

Entity Linking

Connect entities using external IDs, sameAs links, and cross-dataset identifiers.

Intermediate External IDs

Link Entities

🏆

Ranking & Scoring

Compute relevance scores and rank results. Weight multiple factors for better ordering.

Advanced Scoring

Rank Results

🧹

Deduplication

Handle multi-valued properties cleanly. Remove duplicates and aggregate values.

Intermediate Data quality

Deduplicate

⚡

Optimization

Write faster queries. Understand query planning, use hints, and avoid common pitfalls.

Advanced Performance

Optimize

🔍

Debugging

Diagnose query problems. Debug empty results, timeouts, and unexpected output.

Intermediate Troubleshooting

Debug Queries

Essential Patterns

Pattern 1: Instance-of with Subclass Traversal

Find All Museums (Including Subtypes)

Run ↗

SELECT ?museum ?museumLabel ?type ?typeLabel
WHERE {
  # Match museums AND all subclasses of museum
  ?museum wdt:P31/wdt:P279* wd:Q33506 .  # museum

  # Get the specific type
  ?museum wdt:P31 ?type .

  SERVICE wikibase:label {
    bd:serviceParam wikibase:language "en" .
  }
}
LIMIT 20

Pattern wdt:P31/wdt:P279* — The "instance of subclass" pattern

Pattern 2: SAMPLE for Multi-Valued Properties

Get One Value Per Entity

Run ↗

SELECT ?lang ?langLabel
       (SAMPLE(?paradigmLabel) AS ?oneParadigm)
       (COUNT(?paradigm) AS ?paradigmCount)
WHERE {
  ?lang wdt:P31 wd:Q9143 ;
        wdt:P3966 ?paradigm .
  SERVICE wikibase:label {
    bd:serviceParam wikibase:language "en" .
  }
}
GROUP BY ?lang ?langLabel
ORDER BY DESC(?paradigmCount)
LIMIT 20

Pattern SAMPLE() — Pick one arbitrary value from a group

Pattern 3: Concatenate Multiple Values

Combine All Values into One Cell

Run ↗

SELECT ?lang ?langLabel
       (GROUP_CONCAT(DISTINCT ?paradigmLabel; SEPARATOR=", ") AS ?paradigms)
WHERE {
  ?lang wdt:P31 wd:Q9143 ;
        wdt:P3966 ?paradigm .
  SERVICE wikibase:label {
    bd:serviceParam wikibase:language "en" .
  }
}
GROUP BY ?lang ?langLabel
LIMIT 20

Pattern GROUP_CONCAT — Combine multiple values into a list

Pattern 4: Ranking by Computed Score

Rank Languages by "Popularity" Score

Run ↗

SELECT ?lang ?langLabel ?sitelinks ?statements
       (?sitelinks * 2 + ?statements AS ?score)
WHERE {
  ?lang wdt:P31 wd:Q9143 ;
        wikibase:sitelinks ?sitelinks ;
        wikibase:statements ?statements .
  SERVICE wikibase:label {
    bd:serviceParam wikibase:language "en" .
  }
}
ORDER BY DESC(?score)
LIMIT 20

Pattern Computed scores using wikibase:sitelinks + statements

Anti-Patterns to Avoid

Anti-Pattern	Problem	Better Approach
`SELECT *`	Returns all variables, including internal ones	Explicitly list needed variables
Unbound `wdt:P279*`	Can traverse entire class hierarchy (slow)	Always start from a specific entity
Missing `LIMIT`	May return millions of rows	Always add LIMIT during development
Cartesian products	Unrelated patterns multiply results	Ensure patterns share variables
`FILTER(STR(?x) = "...")`	String comparison is slow	Use direct entity references
Multiple `OPTIONAL`s	Each OPTIONAL can multiply results	Use SAMPLE or GROUP_CONCAT

Quick Optimization Tips

Put most selective patterns first — Reduce result set early
Use LIMIT during development — Test with small result sets
Avoid regex when possible — Use CONTAINS or STRSTARTS instead
Filter early — Move FILTER clauses as close to the pattern as possible
Use property paths wisely — Limit depth with {1,5} syntax
Check query plan — Use EXPLAIN (where available) to understand execution
Consider subqueries — Break complex queries into smaller pieces

Continue Learning

🌐

← Multilingual

Query across languages and scripts.

Go Back

📘

Start Over →

Review the basics or explore examples.

Basic Queries