Transcript Slide 1

Semantic Web
Andrejs Lesovskis
Publishing on the Web
Making information available
without knowing the eventual use;
reuse, collaboration;
reproduction of results.
Also, there are:
Economic issues;
DRM, copyright and licensing
issues;
...
Publishing on the Semantic Web
•
Data Access
 SPARQL
•
Information
organisation
 OWL, RDFS,
SKOS
•
Information format
 RDF
•
Identification
 URIs
•
Serialization
 XML
Publishing via a query service on the web
SPARQL Protocol and RDF Query Language
What is SPARQL?
SPARQL
is the query language of the Semantic
Web,
stays for SPARQL Protocol and RDF
Query Language.
SPARQL 1.1 Protocol became a W3C
recommendation on March 21, 2013.
This protocol was developed by the W3C
SPARQL Working Group, part of the
Semantic Web Activity.
Motivation
Having RDF data available is not enough
Need tools to process, transform, and
reason with the information
Need a way to store the RDF data and
interact with it
Are existing storage systems appropriate
to store RDF data?
Are existing query languages appropriate
to query RDF data?
Why SPARQL?
SPARQL allows to:
Pull values from structured and semistructured data represented in RDF;
Explore RDF data by querying unknown
relationships;
Perform complex joins of disparate RDF
repositories in a single query;
Transform RDF data from one
vocabulary to another;
Develop
higher-level
cross-platform
application.
Anatomy of a SPARQL query
Declare prefix
shortcuts
(optional)
Define the
dataset
(optional)
Query
modifiers
(optional)
PREFIX foo: <…>
PREFIX bar: <…>
…
SELECT …
FROM <…>
FROM NAMED <…>
WHERE {
…
}
ORDER BY …
LIMIT …
OFFSET …
Query result
clause
Triple patterns
Basic patterns
A basic pattern is a set of triple
patterns, all of which must be matched.
In this case matches the graph means
find a set of bindings such that the
substitution of variables for values
creates a subgraph that is in the set of
triples making up the graph.
SPARQL query forms
SELECT,
CONSTRUCT,
ASK,
DESCRIBE.
SELECT query
SPARQL’ SELECT is rather similar to
SELECT from SQL.
The SELECT form of results returns
variables and their bindings directly.
It combines the operations of
projecting the required variables with
introducing new variable bindings
into a query solution.
SELECT query example
PREFIX skos: <http://www.w3.org/2004/02/skos/core#>
PREFIX dbpedia2: <http://dbpedia.org/property/>
SELECT ?presName, ?birthday, ?startDate
WHERE
{
?presName skos:subject
<http://dbpedia.org/resource/Category:Presidents
_of_the_United_States>;
dbpedia2:birth ?birthday;
dbpedia2:presidentStart ?startDate.
}
SELECT with OPTIONAL
SELECT with multiple OPTIONAL
CONSTRUCT query
The CONSTRUCT query form returns a
single RDF graph specified by a graph
template.
The result is an RDF graph formed by
taking each query solution in the
solution sequence, substituting for the
variables in the graph template, and
combining the triples into a single RDF
graph by set union.
CONSTRUCT example
@prefix :
<http://www.snee.com/ns/demo#> .
:jane :hasParent :gene .
:gene :hasParent :pat ;
:gender :female .
:joan :hasParent :pat ;
:gender :female .
:pat :gender :male .
:mike :hasParent :joan .
CONSTRUCT example (cont.)
PREFIX : <http://www.snee.com/ns/demo#>
CONSTRUCT
{ ?p :hasGrandfather ?g . }
WHERE {
?p
:hasParent ?parent .
?parent :hasParent ?g .
?g
:gender :male . }
CONSTRUCT example (cont.)
@prefix :
<http://www.snee.com/ns/demo#> .
:jane
:hasGrandfather :pat .
:mike
:hasGrandfather :pat .
ASK query
Applications can use the ASK form to
test whether or not a query pattern
has a solution. No information is
returned about the possible query
solutions, just whether or not a
solution exists.
ASK query example
@prefix foaf:
<http://xmlns.com/foaf/0.1/> .
_:a foaf:name
"Alice" .
_:a
foaf:homepage
<http://work.example.org/alice/> .
_:b foaf:name
_:b foaf:mbox
.
"Bob" .
<mailto:[email protected]>
PREFIX foaf: <http://xmlns.com/foaf/0.1/>
ASK { ?x foaf:name "Alice" }
DESCRIBE query
The DESCRIBE form returns a single
result RDF graph containing RDF data
about resources.
This data is not prescribed by a
SPARQL query, where the query client
would need to know the structure of the
RDF in the data source, but, instead, is
determined by the SPARQL query
processor.
Some SPARQL endpoint don’t support
this type of queries.
PREFIX ent: <http://org.example.com/employees#>
DESCRIBE ?x WHERE { ?x ent:employeeId "1234" }
@prefix foaf: <http://xmlns.com/foaf/0.1/> .
@prefix vcard: <http://www.w3.org/2001/vcard-rdf/3.0> .
@prefix exOrg: <http://org.example.com/employees#> .
@prefix rdf: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>.
@prefix owl: <http://www.w3.org/2002/07/owl#>
_:a
exOrg:employeeId
"1234" ;
foaf:mbox_sha1sum "ABCD1234" ;
vcard:N
[ vcard:Family
"Smith" ;
vcard:Given
"John" ] .
foaf:mbox_sha1sum rdf:type owl:InverseFunctionalProperty .
SPARQL query result formats
XML,
JSON (JavaScript Object Notation),
RDF,
HTML.
JavaScript Object Notation
JSON (JavaScript Object Notation) is
a
text-based,
lightweight
datainterchange format.
It's easy to read and write for humans
and to parse and generate for
machines.
JSON was originally specified by
Douglas Crockford, and is described
in RFC 4627.
JavaScript Object Notation
{
"firstName": "John",
"lastName" : "Smith",
"age"
: 25,
"address" :
{
"streetAddress": "21 2nd Street",
"city"
: "New York",
"state"
: "NY",
"postalCode" : "10021"
},
…
}
A RDF Graph Modeling Movies
movie:Genre
movie:Movie
rdf:type
rdf:type
movie:Comedy
movie:Romance
rdf:type
movie:genre
movie:genre
movie1
movie:year
movie:Role
“1990”
movie:title
“Edward
ScissorHands”
movie:hasPart
“Edward
ScissorHands”
rdf:type
r1
movie:playedBy
movie:characterName
actor1
Example Query 1
Select the movies that has a character
called “Edward Scissorhands”
PREFIX movie: <http://example.org/movies/>
SELECT DISTINCT ?x ?t
WHERE {
?x movie:title ?t ;
movie:hasPart ?y .
?y movie:characterName ?z .
FILTER (?z = “Edward Scissorhands”@en)
}
Example Query 1
PREFIX movie: <http://example.org/movies/>
SELECT DISTINCT ?x ?t
WHERE {
?x movie:title ?t ;
movie:hasPart ?y .
?y movie:characterName ?z .
FILTER (?z = “Edward
Scissorhands”@en)
}
Note the use of “;” This allows to create triples referring to the
previous triple pattern (extended version would be ?x
movie:hasPart ?y)
Note as well the use of the language speciation in the filter @en
Example Query 2
Create a graph of actors and relate them to the movies
they play in (through a new ‘playsInMovie’ relation).
PREFIX movie: <http://example.org/movies/>
PREFIX foaf:
<http://xmlns.com/foaf/0.1/>
CONSTRUCT {
?x foaf:firstName ?fname.
?x foaf:lastName ?lname.
?x movie:playInMovie ?m
}
WHERE {
?m movie:title ?t ;
movie:hasPart ?y .
?y movie:playedBy ?x .
?x foaf:firstName ?fname.
?x foaf:lastName ?lname.
}
Example Query 3
Find all movies which share at least one
genre with “Gone with the Wind”
PREFIX movie: <http://example.org/movies/>
SELECT DISTINCT ?x2 ?t2
WHERE {
?x1 movie:title ?t1.
?x1 movie:genre ?g1.
?x2 movie:genre ?g2.
?x2 movie:title ?t2.
FILTER (?t1 = “Gone with the Wind”@en &&
?x1!=?x2 && ?g1=?g2)
}
SPARQL and reasoning
OWL, RDFS, application, rules
:x rdf:type :C .
:C rdfs:subClassOf :D .
PREFIX rdf:
<http://www.w3.org/1999/02/22-rdfsyntax-ns#>
SELECT ?type
WHERE
{
?x rdf:type ?type .
}
-------| type |
========
| :C
|
| :D
|
--------
Thank you!