Dr. Alexandra I. Cristea
http://www.dcs.warwick.ac.uk/~acristea/
CS 253: Topics in Database Systems: C4
• Previously we looked at:– XML, and its query language(s) – RDF
• Next:– RDF query languages
RDF query languages
Proposals• SPARQL
– http://www.w3.org/TR/rdf-sparql-query/
• RDQL– http://www.w3.org/Submission/RDQL/
• RQL– http://139.91.183.30:9090/RDF/RQL/
• SeRQL– http://www.openrdf.org/doc/sesame/users/ch06.html
• Triple: – http://triple.semanticweb.org/
• N3: – http://www.w3.org/DesignIssues/Notation3
• Comparison of languages: – http://www.aifb.uni-karlsruhe.de/WBS/pha/rdf-query/rdfquery.pdf
SeRQL
Introduction SeRQL
• "Sesame RDF Query Language", pronounced "circle“
• new RDF/RDFS query language
• currently being developed by Aduna as part of Sesame. http://www.openrdf.org/
• It combines (best?) features of other (query) languages (RQL, RDQL, N-Triples, N3) and adds some of its own.
Sesame• open source RDF framework with support for
RDF Schema inferencing and querying. • Originally, it was developed by Aduna (then
known as Aidministrator) as a research prototype for the EU research project On-To-Knowledge.
• further developed and maintained by Aduna in cooperation with NLnet Foundation, developers from Ontotext, and a number of volunteer developers
SeRQL's features
• Graph transformation.
• RDF Schema support.
• XML Schema datatype support.
• Expressive path expression syntax.
• Optional path matching.
SeRQL basic building blocks
• RDF:– URIs, – literals and – variables URIs and literals
• variables
Variables• identified by names. • must start with a letter or an underscore ('_')
and can be followed by zero or more letters, numbers, underscores, dashes ('-') or dots ('.').
• Examples: Var1 _var2 unwise.var-name_isnt-it
• SeRQL keywords are not allowed to be used as variable names.
(reserved) Keywords
• Currently: select, construct, from, where, using,
namespace, true, false, not, and, or, like, label, lang, datatype, null, isresource, isliteral, sort, in, union, intersect, minus, exists, forall, distinct, limit, offset.
• case-insensitive, (unlike variable names).
URIs
• full URIs
• abbreviated URIs (QNames)
Full URIs
• must be surrounded with "<" and ">".
• Tend to be long (!!)
• Examples: <http://www.openrdf.org/index.html>
<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>
<mailto:[email protected]>
<file:///C:\rdffiles\test.rdf>
Abbreviated URIs (QNames)
• Components:
defined prefix (for the namespace) and a colon (“:”), then the URI part that is not a namespace
• Examples:sesame:index.html
rdf:type
foaf:Person
Literals
• Parts:– “label”, – language tag, and – datatype
• Examples:"foo"
"foo"@en"<foo/>"^^http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral
"<foo/>"^^rdf:XMLLiteral
Optional, mutually exclusive
Language tagLanguage tag
datatypedatatype
labellabel
Blank nodes
• RDF has a notion of blank nodes. – nodes that are not labelled with a URI or literal. – Interpretation (): "there exists a node such that..." – Blank nodes have internal identifiers
• Shortcut in SeRQL:_:bnode1
• Attention: problem of non-portability!!!
Path expressions
• expressions that match specific paths through an RDF graph
• usually, triples = path expressions of length 1
• in SeRQL: arbitrary length
Basic path expressions
• Query: – persons who work for (companies that are) IT
companies.
Original (possible) RDF:<?xml version=“1.0”?><rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns:foo="http://www.mycompany.smthg/company#"><rdf:Description about=“http://www.mycompany.smthg/company/Person”>
<foo:worksFor> rdf:resource=“http://www.mycompany.smthg/company/Company” </foo:worksFor>
</rdf:Description><rdf:Description about=“http://www.mycompany.smthg/company/Company”>
<rdf:type>rdf:resource=“http://www.mycompany.smthg/company/CompanySchema#ITCompany”</rdf:type>
</rdf:Description></rdf:RDF>
Basic path expressions• Query:
– persons who work for (companies that are) IT companies.
{Person} foo:worksFor {Company} rdf:type {foo:ITCompany}
Person Company <foo:ITCompany><foo:worksFor> <rdf:type>
Triple (length =1):
Multiple Path Expressions
• Separated with commas
• Example:
{Person} ex:worksFor {Company},{Company} rdf:type {ex:ITCompany}
Non-interesting nodes
• Can be left empty
• Examples: {Person} ex:worksFor {} rdf:type {ex:ITCompany}
{Painting} ex:painted_by {} ex:name {"Picasso"}
Path expression short cuts
• Multi-value nodes
• Branches
• Reified statements
Multi-valued nodes
• Multiple objects:
{subj1} pred1 {obj1, obj2, obj3}
• Multiple subjects:
{subj1, subj2, subj3} pred1 {obj1}
• Condition: disjoint !!
Branches
{subj1} pred1 {obj1};
pred2 {obj2}
Equivalent to:
{subj1} pred1 {obj1},
{subj1} pred2 {obj2}
Reified statements
• { {reifSubj} reifPred {reifObj} } pred {obj}
• Equivalent to:
• {_Statement} rdf:type {rdf:Statement}, {_Statement} rdf:subject {reifSubj}, {_Statement} rdf:predicate {reifPred}, {_Statement} rdf:object {reifObj}, {_Statement} pred {obj}
Optional Path Expressions
{Person} ex:name {Name};
ex:age {Age};
[ex:email {EmailAddress}]
Queries in SeRQL• Select queries:
– returning a table of values, or a set of variable-value bindings.
– SELECT, FROM, WHERE, LIMIT, OFFSET and USING NAMESPACE
• Construct queries:– returns a true RDF graph – CONSTRUCT, FROM, WHERE, LIMIT,
OFFSET and USING NAMESPACE
Select queries
• SELECT C FROM {C} rdf:type {rdfs:Class} – returns all URIs of classes
• SELECT DISTINCT *
FROM {Country1} ex:borders {} ex:borders {Country2}
USING NAMESPACE ex =<http://example.org/things#>
Construct queries• CONSTRUCT {Parent} ex:hasChild {Child}
FROM {Child} ex:hasParent {Parent}
USING NAMESPACE ex = <http://example.org/things#>
• CONSTRUCT *
FROM {SUB} rdfs:subClassOf {SUPER}– This query extracts all rdfs:subClassOf relations from an
RDF graph.
WHERE clause
• Optional;
• Specifies Boolean constraints
SELECT Country
FROM {Country} ex:population {Population}
WHERE Population < "1000000"^^xsd:positiveInteger
USING NAMESPACE ex = <http://example.org/things#>
Nested WHERE clauses• Query 1 (normal WHERE-clause):
SELECT Name, EmailAddress FROM {Person} foaf:name {Name}; [ex:email {EmailAddress}]WHERE EmailAddress LIKE "g*"
• Query 2 (nested WHERE-clause):SELECT Name, EmailAddress FROM {Person} foaf:name {Name}; [ex:email {EmailAddress} WHERE EmailAddress LIKE "g*"]
• at most one nested WHERE-clause per optional path expression, and at most one 'normal' WHERE-clause
Results WHERE queries• Query 1Name EmailAddressGiancarlo [email protected]
• Query 2 (nested WHERE)Name EmailAddressMichael Rubens Giancarlo "[email protected]"
LIKE operator
SELECT Country
FROM {Country} ex:name {Name}
WHERE Name LIKE “netherlands" IGNORE CASE
USING NAMESPACE ex = <http://example.org/things#>
Built-in predicates
• {X} serql:directSubClassOf {Y}
• {X} serql:directSubPropertyOf {Y}
• {X} serql:directType {Y}
Set combinatory operations
• Union
• Intersect
• Minus
Union
SELECT title
FROM {book} dc10:title {title}
UNION
SELECT title
FROM {book} dc11:title {title}
USING NAMESPACE
dc10 = <http://purl.org/dc/elements/1.0/>, dc11 = <http://purl.org/dc/elements/1.1/>
Intersect
SELECT creator
FROM {album} dc10:creator {creator}
INTERSECT
SELECT creator
FROM {album} dc11:creator {creator}
USING NAMESPACE
dc10 = <http://purl.org/dc/elements/1.0/>,
dc11 = <http://purl.org/dc/elements/1.1/>
Minus (difference)
SELECT title
FROM {album} dc10:title {title}
MINUS
SELECT title
FROM {album} dc10:title {title}; dc10:creator {creator}
WHERE creator like "Paul"
USING NAMESPACE
dc10 = <http://purl.org/dc/elements/1.0/>,
dc11 = <http://purl.org/dc/elements/1.1/>
NULL values
• SELECT *
• FROM {X} Y {Z}
• WHERE isLiteral(Z) AND datatype(L) = NULL – to check that a literal doesn't have a datatype;
Query Nesting
• IN
• ANY, ALL
• EXISTS
INSELECT name FROM {} rdf:type {ex:Person}; ex:name {name} WHERE name IN ( SELECT n FROM {} rdf:type {ex:Author}; ex:name {n} ) USING NAMESPACE ex = http://example.org/things#• retrieve all names of Persons, but only those
names that also appear as names of Authors.
ANY, ALL
SELECT highestValue FROM {node} ex:value {highestValue} WHERE highestValue >= ALL ( SELECT value FROM {} ex:value {value} ) USING NAMESPACE ex = <http://example.org/things#>
EXISTSSELECT name, hobby FROM {} rdf:type {ex:Person}; ex:name {name}; ex:hobby {hobby}WHERE EXISTS ( SELECT n FROM {} rdf:type {ex:Author}; ex:name {n}; ex:authorOf {} WHERE n = name ) USING NAMESPACE ex = <http://example.org/things#>
RDF Query Languages Conclusion• We have learned:
– There is a high competition for providing The RDF query language
– No standards as yet– We have looked in more details at one of them,
SeRQL, as it is an implementers’ language paired with an existing RDF repository tool, Sesame
– Many features in SeRQL remind us of SQL, thus learning threshold should be low
• Next:– OWL