sw 4

• This slide set is associated with a lecture on Semantic Web technologies at RWTH Aachen University.
• The slides are based on work by Andreas Harth and Lars Heling, adapted by Lars Gleim
• The material is licensed under Creative Commons Attribution 4.0 International.

Introduction to Querying RDF with SPARQL

• The lecture explores how to access and query descriptions of things using SPARQL
• RDF triples are how to read/write Resource Description Framework
• Data published according to Linked Data Principles can be accessed
• How to write/evaluate queries on RDF datasets is covered this chapter

SPARQL

• Introduction
• Structure of SPARQL Queries
• Basic Graph Patterns
• Group Graph Patterns
• Filters, Functions and Modifiers
• RDF Datasets and Named Graphs
• Querying RDF Data on the Web

Linked Data Stack

• SPARQL sits at the Query layer, working with OWL ontologies and RIF rules
• It uses RDF-Schema for data structure and RDF for data interchange
• Relies on XML and URI, supported by Unicode

Querying RDF Data

• The central question is how to retrieve data from a dataset
• Queries retrieve relevant data
• In relational databases, tuples are stored in tables (relations)
• SQL(Structured Query Language) is the standard language

SPARQL Details

• SPARQL (SPARQL Protocol And RDF Query Language) is specified by W3C
• The current version is SPARQL 1.1, released in March 2013
• There are eleven SPARQL Recommendations covering:
  • Syntax and semantics of queries over RDF
  • Protocol to pose queries against a SPARQL endpoint
  • How to retrieve results, various serializations of query results, entailment regimes, update language, and federated query

SPARQL Query Structure

• SPARQL query structure includes prefix declarations, query type, graph pattern, and query modifiers.
• Prefixes are declared using the PREFIX keyword to make queries more readable by shortening URIs.
• Example:

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

• The query type specifies what kind of data to retrieve (SELECT ?x ?y), and the dataset definition indicates where the data comes from (FROM ...).
• The graph pattern is defined in the WHERE clause, where triple patterns are specified to match against the RDF data. ?x a ?y
• Query modifiers such as ORDER BY ?y can be used to sort the results.

Components of SPARQL Queries

• Queries include prefix definitions, dataset specifications, and the query pattern with triple patterns
• Prefix definitions use the PREFIX keyword to introduce CURIEs.
• CURIE syntax in SPARQL is slightly different from Turtle syntax: the final period is omitted, and there's no "@" at the beginning.
• The SELECT form returns variables, ASK returns a boolean, DESCRIBE returns a graph describing a resource, and CONSTRUCT returns a graph based on a template.
• Variables act as placeholders and are prefixed with “?” or “$”. To select all variables, use SELECT *.
• The FROM or FROM NAMED keywords specify the dataset.
• They indicate where to find the data.
• FROM clause specifies graphs for the endpoint to consider; if omitted, the default graph is used
• The dataset selection, using FROM or FROM NAMED, specifies the dataset and indicates the sources for matching data.
• Sequence modifiers such as ORDER BY change the result order, LIMIT and OFFSET select chunks of results, and DISTINCT removes duplicates.

Prefixes in SPARQL

• Prefixes are syntactic sugar to improve query readability.
• They allow the replacement of long URIs with shorter, prefixed names within the query.
• For example:

PREFIX dc: <http://example.org/base/>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>

• This makes it possible to write :Tim instead of <http://example.com/base/Tim> and foaf:knows instead of <http://xmlns.com/foaf/0.1/knows>.

Basic Graph Patterns

• Building block of SPRAQL is triple patterns
• Similar to RDF triples but with variables (specified with ? or $)
• Basic Graph Pattern (BGP) contains several triple patterns.
• BGPs can be specified using Turtle syntax and represent a conjunction of triple patterns.
• Variables can be used in the subject, predicate, or object position
• Evaluation involves pattern matching against the RDF graph, where variables are bound to resources that satisfy the pattern.
• The solution sequence of the WHERE clause contains solution mappings even for variables not specified in the SELECT clause.
• Blank nodes in BGPs are treated similarly to variables, but one may not specify blank nodes in the query form
• When used in a CONSTRUCT statement, for each mapping a new blank node is created

Triple Pattern Examples

• For a given dataset, example queries might be:
  • SELECT ?x WHERE {:Aachen :name ?x} which retrieves the name of Aachen. Result: "Aachen".
  • SELECT ?x WHERE {:Aachen :locatedIn ?x} which retrieves where Aachen is located. Result: :Germany.
  • SELECT ?country ?name WHERE {:Aachen :locatedIn ?country; :name ?name} gives both the country and its name. Result: :Germany "Aachen".
  • SELECT ?countryName WHERE {:Aachen :locatedIn ?country. ?country :name ?countryName} resolves the country name. Result: "Germany".

Matching Resources and Literals

• SPARQL matches resources by character, either with a prefix or a full URI.
• Case sensitivity is important
• Percent encoding is critical (e.g., myns:John%20Doe != myns:John Doe).
• Literals need to match exactly and can have datatypes (xsd:int, xsd:date) and language tags (@en, @de).
• Exact matching is required unless the SPARQL engine knows how to interpret the datatype

Solution Mappings

• During query evaluation, RDF terms bind the variables to RDF terms with constants (URIs, blank nodes, or literals) via substitutions
• Syntax for solution mappings is μ(?var) = value
• Value represents the binding (solution) for the variable

Solution Representation

• Solution mappings are also in table form
• Solution order:
  • Ω = {µ₁(?borough) = : Pankow
  • µ₁(?berlin) = : Berlin
  • µ₂(?borough) = : Neukoelln
  • µ₂(?berlin) = : Berlin}

Group Graph Patterns

• Allow more control over the structure and logic of query patterns.
• Queries can specify the source graph for triple patterns and use operators such as OPTIONAL and UNION

Named Graphs and Graph Patterns

• Named graphs provide more control over which graphs a triple is sourced from
• A graph graph pattern example:

FROM NAMED <http://example.org/citites.ttl>
WHERE { GRAPH ?g { ?city :name “Berlin”. } }

• would return the graph and city where the city name is Berlin.

Operators for Group Graph Patterns

• Using OPTIONAL allows for left-join like queries, useful for incomplete data.
• For example, retrieving the capital of Germany and optionally its population

?x :capital :Germany .
OPTIONAL { ?x :population ?y . }

• Using UNION specifies disjunctions of triple patterns, which allows querying across differing data structures.
• Retrieving population figures for either Neukölln or Pankow.

{ :Neukoelln :population ?y . }
UNION
{ :Pankow :population ?y . }

Optional Examples

• For a sample dataset, one can formulate queries using optional patterns.
• For instance:

SELECT ?name ?zip {?city :name ?name. ?city :zip ?zip}

• Would return only cities for which a zip code is listed
• Conversely:

SELECT ?name ?zip {?city : name ?name. OPTIONAL {?city :zip ?zip}}

• would include all cities, listing zip codes when available.

Union Examples

For a given set of city data, queries with UNION can combine results from different properties:

• SELECT ?name WHERE {?city a :City. ?city :name ?name} retrieves the names of cities with :name. Results: "Aachen" and "Berlin".

SELECT ?name WHERE {?city a :City. {?city :name ?name} UNION {?city rdfs:label ?name}}

• This combines city names from :name and rdfs:label, returning "Aachen", "Berlin", and "Köln".

Projection

• Variable inclusion/exclusion is possible
• Example:

SELECT * WHERE {.....}

• Includes all variables mentioned in graph pattern
• Only specific variables can be included
• For example: SELECT ?s ?o WHERE {?s ?p ?o}
• Duplicates can be eliminated with SELECT DISTINCT

Filters, Functions, and Modifiers

• Used in conjunction with the WHERE clause
• They are specified, most prominently, using Literal values and the FILTER keyword
• Filters operate on graph patterns and test values, primarily restricting literal values through string comparison, regular expressions, and numeric comparators
• The evaluate to true, false or type error.
• The result of a filter is True/False or Error
• Type/language checks happen
• Operators for filter expressions include <, =, >, <=, >=, !=, usable on numeric types, strings, xsd:dateTime and xsd:boolean and operators +, -, *, /
• AND (&&), OR (||), NOT (!) are how filter expressions can be combined

Numeric Filtering, Logical Operator and String Filtering Examples

Given some data:

:Aachen : population 250000
: Aachen :name "Aachen"@en
:Berlin :population 3500000.
A SELECT query with a numeric filter:
SELECT ?city WHERE {?city : population ?p FILTER (?p>1000000)} 

will return :Berlin. Applying logical operators to the filter. For example, given:

:Aachen : population 250000
:Aachen :name "Aachen"@en
:Berlin :population 3500000.
 A select query with a logical operator
SELECT ?city where {?city :name ?n; : population ?p. FILTER (str(?n)="Aachen" && ?p>500000)}

returns NULL. But:

SELECT ?city where {?city :name ?n; : population ?p.FILTER (str(?n)="Aachen" || ?p>500000)}	A SELECT query with a logical operator: SELECT ?city where {?city :name ?n; : population ?p. FILTER (str(?n)="Aachen" || ?p>500000)}

returns :Aachen and :Berlin. For a string match filter is the following example is applicable:

SELECT ?city WHERE {?city  :name ?name. FILTER (str(?name) = "Berlin")}

will result in

:Berlin	A SELECT query with a string match is: SELECT ?city WHERE {?city :name ?name.
FILTER (contains(?name, "erlin"))}
: Berlin

Functions in SPARQL

• Can be used within the filter expression
• Example functions can use as follows:
  • STR(L U) return the simple literal/lexical form of a literal or the codepoint representation of an URI
  • LANG(L) returns simple literal where the language teg of a literal is provided
• How to set WHERE language

WHERE {
	?borough :borough :Berlin ;
       :name   ?name .
       FILTER(lang(?name) = “en”)
	)
}

Aggregate Functions

• Aggregate functions similar to SQL include min, max, avg, sum, and count, and were introduced with SPARQL 1.1.
• It’s necessary to `Group by groups the results accordingly, necessary for projection

Modifying the Result Set

• Sequence modifiers are used to edit the solution mapping; four modifiers:
  • Modifiers include ORDER BY, which sorts results (ASC or DESC), LIMIT (specifies a number of results to be returned), OFFSET (starts after a number), and SELECT DISTINCT (only returns unique solutions).

RDF Datasets

• Information may be spread over documents
• Therefore, several documents should be addressable in a query

Multiple Graphs

• SPARQL handles multiple graphs with different data sources via FROM
• All graphs specified in FROM clause are combined to a default graph
• SPARQL handles multiple named graphs via FROM NAMED and accesses them via GRAPH
• To identify the triples belonging to a graph data extents th triple model to quadruples

Querying RDF Data on the Web Overview

• The query methods are:
  • Link traversal engines for dereferencing resources,
  • SPARQL endpoints that execute SPARQL queries, and
  • Federated SPARQL endpoint engines for combining results from multiple endpoints.

Link Traversal Engines

• Dereference information resources with RDF descriptions and parse

PREFIX dbr:<http://dbpedia.org/resource/> PREFIX dbo:<http://dbpedia.org/ontology/> SELECT ?x {dbr:India dbo: capital ?x}

• In this case, you must dereference the informaiton resources for RDF descriptions dbo: percentageOfAreawater
• Followed by evaluation of the triple pattern

SPARQL EndPoints (2)

• Servers that can execute SPARQL queries
• Many SPARQL end points are on the web, including DBpedia

Federated SPARQL EndPoint (3)

• Enables SPARQL queries to executes against a set of end points
• Manual specification of an end point via service clause Example:

PREFIX foaf:<http://xmlns.com/foaf/0.1/> PREFIX geonames:<http://www.geonames.org/ontology#> SELECT ?name ?location WHERE {SERVICE <http://lmdb.org/sparql>	{?artist foaf:based_near ?location}
        {?location geonames:parentFeature  ?germany SERVICE <http://dbpedia.org/sparql>    ?germany geonames:name 'Federal Republic of Germany}}

Review: Linked Data and SPARQL

• triple patterns query RDF graphs,

• SPARQL queries include prefix declarations, specify ask, select, describe or construct, variable patterns, FROM/FROM Named for data sets, Basic Graph Pattern (UNION, OPTIONAL, FILTER), ORDER BY, LIMIT, DISTINCT.

• Learning Goals*

• Understand how to query RDF datasets using SPARQL, including writing basic graph pattern queries, use FROM and GRAPH clauses, and correctly apply UNION. You should also know how to use BIND as well as FILTER, how to handle typed literals, and use LIMIT and OFFSET

• Be able to find all cities that do NOT have a state associated. Using a combination of not, bound and optional