ConceptDBISAI-written · not yet proofread

SPARQL Query Structure

A basic SPARQL query `SELECT <variables> WHERE { <triples> }` is a graph pattern of triples with variables; its result is a table with one row per assignment of values to the variables such that all query triples exist in the knowledge graph.

Know these firstRDF Triple

Definition

SPARQL (SPARQL Protocol And RDF Query Language) is the standard query language for RDF data (W3C standard, freely available). A basic query has the form

SELECT ?v1 ... ?vk WHERE {
  s1 p1 o1 .
  ...
  sn pn on .
}

where each query triple $s_i\ p_i\ o_i$ has at every position either a fixed IRI/literal or a variable (?name). The result is a table with one column per selected variable $?v_1, \dots, ?v_k$ and one row for each assignment of values to all variables of the query such that every query triple, with the variables replaced by their values, is a triple of the knowledge graph.

Properties#

Graph pattern. The query triples form a small graph with variables at some nodes or edges. Answering the query means finding all matches of this pattern in the large KG; each distinct match is one assignment (one row).
Joins are implicit. Using the same variable in several triples is the join; there is no explicit join condition.

Syntax elements:

Element	Syntax	Meaning
variable	`?name`	bound to values during matching
fixed entity / predicate	`<Entity>`, or prefixed `wd:Q42`, `wdt:P31`	a known IRI
literal	`"1980"`, `"Honolulu"@en`	a fixed value
query triple	`s p o .`	one constraint; triples are separated by `.` (the last `.` before `}` is optional)
`SELECT *`		selects all variables

Modifiers (as in SQL):

PREFIX wd: <http://www.wikidata.org/entity/> abbreviates long IRIs.
FILTER (condition) keeps only rows satisfying the condition, e.g. FILTER (LANG(?name) = "en") for English labels, FILTER (?a != ?b).
ORDER BY DESC(?x) / ASC(?x), LIMIT k; note that DESC/ASC is written like a function of the sort key.

Differences to SQL:

	SPARQL	SQL
data	one big “table” of triples (but: named graphs)	many tables, `FROM` clause
main instrument	triples with variables	`FROM` + `WHERE` conditions
join	same variable in several triples	explicit equality conditions (Join)
`SELECT` list	no commas: `SELECT ?a ?b`	commas: `SELECT a, b`
sort order	`DESC(?var)`	`var DESC`

Expressiveness. Basic SPARQL and SQL are essentially equivalent; basic queries translate mechanically (SPARQL to SQL Translation).

Example#

All people born in Honolulu with their English names and birth dates, youngest first:

PREFIX wd: <http://www.wikidata.org/entity/>
PREFIX wdt: <http://www.wikidata.org/prop/direct/>
PREFIX rdfs: <http://www.w3.org/2000/01/rdf-schema#>
SELECT ?person ?person_name ?date_of_birth WHERE {
  ?person wdt:P19 wd:Q18094 .            # place of birth: Honolulu
  ?person wdt:P569 ?date_of_birth .      # date of birth
  ?person rdfs:label ?person_name .
  FILTER (LANG(?person_name) = "en")
}
ORDER BY DESC(?date_of_birth) LIMIT 100

Married couples who acted in the same film (?film and ?person1/?person2 are the shared variables, i.e. the joins):

SELECT ?person1 ?person2 ?film WHERE {
  ?person1 <acted_in>   ?film .
  ?person2 <acted_in>   ?film .
  ?person1 <married_to> ?person2 .
}

Simplest case: SELECT ?person ?occ WHERE { ?person <born_in> <Ulm> . ?person <occupation> ?occ . } returns each person born in Ulm with each of their occupations.

Sources#

Slides 07, p. 12 (SPARQL), p. 13 (basic queries), p. 14 (graph patterns), pp. 15–16 (PREFIX, FILTER, ORDER BY, LIMIT), p. 17 (SPARQL vs. SQL)
DBIS_VL07 > SPARQL, DBIS_VL07 > Basic queries, DBIS_VL07 > Queries as graph patterns, DBIS_VL07 > PREFIX, FILTER, ORDER BY, LIMIT, DBIS_VL07 > Differences between SPARQL and SQL
Exams: DBIS Exam WS1819 (not published) (Task 6.1), DBIS Exam WS2122 (not published) (Task 3.1), DBIS Exam WS2223 (not published) (Task 5), DBIS Exam WS2324 (not published) (Task 3.1)

Connections

Prerequisites know first1

RDF Triple

Mentioned in inline links9

SPARQL to SQL Translation
Let the triples be stored in one table triples(subject, predicate, object) and let SELECT ?v1 … ?vs WHERE { T1 . … . Tk } be a basic SPARQL query with $k$ query triples. The equivalent SQL query is built as follows: §
VL07 – Knowledge Graphs, SPARQL, SPARQL to SQL
A basic query has the form SELECT <variables> WHERE { <triples> }, where each triple may have variables (?name) at some positions (SPARQL Query Structure). §
SPARQL Query Structure — SELECT … WHERE { triples with variables }, PREFIX, FILTER, ORDER BY/LIMIT; queries as graph patterns §
SPARQL and Knowledge Graphs
SPARQL Query Structure — SELECT … WHERE { triples with variables }, PREFIX, FILTER, ORDER BY, LIMIT §
Triples → patterns. A KG is a set of triples; a SPARQL query is a small graph of triples with variables, and its result table lists all matches in the KG. A variable shared by two triples is a join. §
Optional Graph PatternADIS
Let $R$ be the result table of the patterns before OPTIONAL { P } in a SPARQL WHERE clause, and let $P$ be a group of triples (possibly with a FILTER). For each row $r \in R$ : §
Property PathADIS
In a SPARQL query triple s P o, the predicate position may hold a property path $P$ instead of a single predicate. The triple then matches every pair of nodes $(s, o)$ in the knowledge graph that are connected by a directed path whose sequ… §
SPARQL AggregationADIS
Let $R$ be the result table of a SPARQL WHERE clause and $g_1, \dots, g_m$ variables of it. The query §
SPARQL BINDADIS
Inside a SPARQL WHERE clause, §
VL01 – Overview, RDF & SPARQL, more SPARQLADIS
A SPARQL query is a set of triples with variables. Its result is a table with one row per assignment to the variables such that all query triples exist, i.e. one row per match of the small query graph in the large KG (Slides 12–13). §
FILTER (LANG(?person_name) = “en”) keeps only English labels of people born in Honolulu (SPARQL Query Structure) (Slide 16). §
Advanced SPARQLADIS
Basics from DBIS, used throughout: RDF Triple, SPARQL Query Structure (patterns, FILTER, LANG), Wikidata Prefix System, Ordering (ORDER BY, LIMIT). §
Every construct is an operation on the result table. A basic pattern produces one row per match (SPARQL Query Structure). Each construct then changes either the set of rows or the set of columns, and keeping track of that is what makes a q… §

Search in these mentions →