SeRQL

March 29, 2008 by Diego

Index:

Introduction
URIs, literals and variables
Path expressions
Select and construct queries
Examples SeRQL queries

Introduction

SeRQL ("Sesame RDF Query Language", pronounced "circle") is a new RDF/RDFS query language that is currently being developed by Aduna as part of Sesame. It combines the best features of other (query) languages (RQL, RDQL, N-Triples, N3) and adds some of its own. This document briefly shows some of the features, .fter reading through this document one should be able to write SeRQL queries.

Some of SeRQL's most important features are:

Graph transformation.
RDF Schema support.
XML Schema datatype support.
Expressive path expression syntax.
Optional path matching.

URIs, literals and variables

URIs and literals are the basic building blocks of RDF. For a query language like SeRQL, variables are added to this list. The following sections will show how to write these down in SeRQL.

Variables

Variables are identified by names. These names must start with a letter or an underscore ('_') and can be followed by zero or more letters, numbers, underscores, dashes ('-') or dots ('.'). Examples variable names are:

Var1

			_var2

			unwise.var-name_isnt-it

SeRQL reserved words: 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.

Keywords in SeRQL are all case-insensitive, this in contrast to variable names; these are case-sensitive.

URIs

There are two ways to write down URIs in SeRQL: either as full URIs or as abbreviated URIs. Full URIs must be surrounded with "<" and ">". Examples of this are:

<http://www.openrdf.org/index.html>

			<http://www.w3.org/1999/02/22-rdf-syntax-ns#type>

			<mailto:sesame@openrdf.org>

			<file:///C:\rdffiles\test.rdf>

SeRQL allows one to use abbreviated URIs (or QNames).

sesame:index.html

			rdf:type

			foaf:Person

Literals

RDF literals consist of three parts: a label, a language tag, and a datatype. The notation of literals in SeRQL has been modelled after their notation in N-Triples; Example literals are:

"foo"

			"foo"@en

			"<foo/>"^^<http://www.w3.org/1999/02/22-rdf-syntax-ns#XMLLiteral>

The SeRQL notation for abbreviated URIs can also be used. When the prefix rdf is mapped to the namespace http://www.w3.org/1999/02/22-rdf-syntax-ns#, the last example literal could also have been written down like:

"<foo/>"^^rdf:XMLLiteral

Path expressions

One of the most prominent parts of SeRQL are path expressions. Path expressions are expressions that match specific paths through an RDF graph.

Basic path expressions

Imagine that we want to query an RDF graph for persons who work for companies that are IT companies. Querying for this information comes down to finding the following pattern in the RDF graph (gray nodes denote variables):

Figure 1. A basic path expression

The SeRQL notation for path expressions resembles the picture above; it is written down as:

{Person} ex:worksFor {Company} rdf:type {ex:ITCompany}

The parts surrounded by curly brackets represent the nodes in the RDF graph, the parts between these nodes represent the edges in the graph. The direction of the arcs (properties) in SeRQL path expressions is always from left to right.

In SeRQL queries, multiple path expressions can be specified by seperating them with commas. For example, the path expression show before can also be written down as two smaller path expressions:

{Person} ex:worksFor {Company},

          {Company} rdf:type {ex:ITCompany}

Select- and construct queries

A SeRQL query is typically built up from one to six clauses. For select queries these clauses are: SELECT, FROM, WHERE, LIMIT, OFFSET and USING NAMESPACE. One might recognize the first five clauses from SQL, but their usage is slightly different.

Select queries

Return tables of values, or sets of variable-value bindings. Which values are returned can be specified in the select clause. One can specify variables and/or values in the select clause, seperated by commas. The following example query returns all URIs of classes:

SELECT C

            FROM {C} rdf:type {rdfs:Class}

Construct queries

Construct queries return RDF graphs as set of triples. The triples that a query should return can be specified in the construct clause using the previously explained path expressions. The following is an example construct query:

CONSTRUCT {Parent} ex:hasChild {Child}

            FROM {Child} ex:hasParent {Parent}

            USING NAMESPACE

                ex = <http://example.org/things#>

Example SeRQL queries

Query 1

Description: Find all papers that are about "RDF" and about "Querying", and their authors.

SELECT

               Author, Paper

            FROM

               {Paper} rdf:type {foo:Paper};

                       ex:keyword {"RDF", "Querying"};

                       dc:author {Author}

            USING NAMESPACE

               dc = <http://purl.org/dc/elements/1.0/>,

               ex = <http://example.org/things#>

Depicted as a graph, this query searches through the RDF graph for all subgraphs matching the following template:

Figure 2. Path expression for query 1

Path expression for query 1

Query 2

Description: Find all artefacts whose English title contains the string "night" and the museum where they are exhibited. The artefact must have been created by someone with first name "Rembrandt". The artefact and museum should both be represented by their titles.

SELECT DISTINCT

               label(ArtefactTitle), MuseumName

            FROM

               {Artefact} arts:created_by {} arts:first_name {"Rembrandt"},

               {Artefact} arts:exhibited {} dc:title {MuseumName},

               {Artefact} dc:title {ArtefactTitle}

            WHERE

               isLiteral(ArtefactTitle) AND

               lang(ArtefactTitle) = "en" AND

               label(ArtefactTitle) LIKE "*night*"

            USING NAMESPACE

               dc   = <http://purl.org/dc/elements/1.0/>,

               arts = <http://example.org/arts/>

Again, depicted as a subgraph template:

Figure 3. Path expression for query 2

Path expression for query 2
Note that this figure only shows the path expressions from the from clause. The where clause poses additional constraints on the values of the variables which can't be as easily depicted graphically.