Re: elqraps and hello

Sorry Ashok,

I wasn't trying to make your life harder! It's just that the problem you are
tackling is part of a broad class of related problems that are perennial in
application development when bridging between complex systems. The most
widely encountered is in Object Relational Mapping systems, but there are
plenty of others.

For example, mapping the instance data in one ontology onto instances in
another ontology is another example. If the ontologies don't have simple one
to one mappings between their classes or properties, then there *must* be a
need for a generalized version of the owl:sameAs or
owl:equivalentClassrelations. I guess that is the problem I'd like to
see you solving. And I
don't think it's actually that much more difficult than what you're about to
embark on anyway. All I'm really asking you to do is not hard-code it to the
relational domain. If you think of a relational database as a kind of
old-skool way of representing an ontology, then you could cheerfully get
away with terminology like 'class' and 'property' instead of 'table' and

As I see it, the mapping problem you have to solve has the following facets:

      *Reference Mapping*: Creating conventions for referring to databases,
schemas, table, columns, SPs etc using URIs. Do you create a URI scheme for
referring to the parts of a database?
e.g., urn:db://SomeUser@MYDB.Somewhere/MyTable/SomeColumn

      *Structure Mapping*: Database models are seldom going to match the
ontological domain. You need to allow the data model and the ontology to
diverge. That means that you must cope with *denormalization* and a lack of
explicit support for *inheritance*. There are several possible ways to do
this in the relational domain that trade off performance against space.

      *Type Mapping*: Creating a type transformation between types on a
given DB platform and in an ontology. This is complicated when there is no
natural type to translate into and out of (the case if you're using XML
Schema to define your own data types).

      *Query Mapping*: Mapping SPARQL[/Update] queries onto SQL commands.
The old dynamic SQL versus SPs debate (that still rages)? If you solve the
above three, this may become easy.

As you can see, these mapping problems apply equally to problems like
ontology-to-ontology mapping, mashups, mapping between objects within the
object domain, data extraction and portability.

If you create general-purpose mapping for each of the above then you'd solve
the problem for rdb2rdf, but you might also solve the *whole class* of
problems en passant. As an example of what I'm driving at, consider the case
of reference mapping (which seems to me to be the key to allowing your work
to be applicable elsewhere). Rather than define mappings in specific terms
of 'Table Name' or 'Column Name' you could create a URI scheme to reference
subparts of a database. In so doing you then can extend the mapping system
to anything that you can reference by a URI (such as a property or class in
another ontology).

WRT Type Mapping: the obvious approach might be to use a look-up table
matching types into and out of some canonical type representation. That
works if you're confined to just one domain. But when you get out of that
one domain, primitive types will proliferate, and you need some other
strategy. I don't think you can get out of solving this anyway! I'm not sure
what the general-purpose declarative solution to this one is. I suppose a
scheme like the SPARQL/XQuery/XPath type casting mechanism might work?

Provided you have a scheme for referencing the sub-parts of a thing, you
should be able to use it with a general purpose mapping table, so that one
falls quite easily. Again, I figure that's something you'll have to solve
Andrew Matthews

On 3/7/08, ashok malhotra <> wrote:
> Possibly!  I want to start with a more limited scope to increase our
> chances of getting
> done in a reasonable amount of time.  If you have proposals for a more
> general mapping,
> I'm sure the group would be happy to listen.
> Ashok
> Andrew Matthews wrote:
> > Hi,
> >
> >
> >
> > Wouldn't it make more sense for this group to focus on a more generic
> > model of mapping one structure onto another?
> >
> >
> >
> > The benefit  being that you could then not only devise an ontology
> > that covers mapping from the ontological domain to the relational, but
> > also onto the object oriented domain. The tasks are essentially the
> > same: providing a mapping from one structure or function to another
> > structure.
> >
> >
> >
> > There are plenty of other areas where a general solution might be
> > useful. Front-end data-binding and mashups come to mind.
> >
> > Regards,
> >
> > Andrew Matthews
> --
> All the best, Ashok


    Andrew Matthews

Received on Friday, 7 March 2008 01:18:29 UTC