W3C home > Mailing lists > Public > semantic-web@w3.org > February 2010

Re: Querying OWL Ontologies with OWL Syntax

From: Kendall Clark <kendall@clarkparsia.com>
Date: Mon, 22 Feb 2010 11:49:02 -0500
Message-ID: <1fc9c2ff1002220849o3814d37cg86710537ba55737f@mail.gmail.com>
To: "Michael Lang(Jr.)" <michaelallenlang@gmail.com>
Cc: Fernando Silva Parreiras <parreiras@uni-koblenz.de>, semantic-web@w3.org, "Mike Lang Sr." <mlang@revelytix.com>, Bob Scanlon <rscanlon@revelytix.com>
On Mon, Feb 22, 2010 at 11:24 AM, Michael Lang(Jr.)
<michaelallenlang@gmail.com> wrote:
> At Revelytix, we have not run into a lot of use cases where an OWL query
> language (which I think is what Sergio is describing), however we are fairly
> certain that we will in the near future.  While I'm sure that Mark and
> Sergio have done good work, we try our best to use standards wherever
> possible.
> Does anyone know if the W3C has plans to create an OWL query language or to
> add native OWL support to SPARQL?

SPARQL is the query language for OWL according to W3C. But that means
writing SPARQL queries against the RDF-level serialization of OWL
axioms, which makes for terrible queries to write by hand. OWL users
hate this because the RDF serialization of OWL can be really grotty.

There (minimally) are two solutions to this:

1. generate queries from something else programmatically -- fine,
people who can do this already are
2. add some OWL syntactic sugar to a SPARQL engine

The new SPARQL WG is working documents ("entailment regimes") that
extend SPARQL to OWL semantically; but they've declined, alas, to
address the syntactic issues, so that's not likely to be standardized
this time around. Maybe later or in some other standards body.

What Fernando and others have done with SPARQLAS is to add a
pre-processor that translates OWL Functional Syntax into RDF triples,
which are then processed by an OWL-aware SPARQL engine -- he mentions
Pellet, but the approach would work with other systems, too.

We've been working on the same problem for Pellet's forthcoming 2.1
release (due 31 March) and we're using Manchester Syntax instead of
OWL Functional; but it's the same basic approach; it's briefly
described here:

Finally, even if users don't know or care about OWL, as our approach
shows, that's not really an issue here. OWL sugar for SPARQL just
means that anyone can write (or generate) queries that are (for some
use cases) more appropriately abstracted from underlying data details,
which (again, for some use cases) is a very good thing, indeed.

This approach is generalizable across all sorts of OWL-level
inference; for example, datatype reasoning. We've got some prototype
code where Pellet's datatype reasoner is integrated with the SPARQL
query engine, so that a user can query, say, for some unit or quantity
irrespective of how that unit or quantity is stored in the underlying
system (meters, feet, blah blah) and if the reasoner can do
auto-conversions (between compatible dimensions, for example),
everything Just Works.

Kendall Clark
Received on Monday, 22 February 2010 16:49:54 UTC

This archive was generated by hypermail 2.3.1 : Wednesday, 7 January 2015 15:49:55 UTC