I haven't had the time to deal with RDF yet.
> P.S. This underlying premise of this posting is that if middleware is
> intended to let everything talk to everything, then there is an immediate
> division of labor: middleware experts can continue to create middleware and
> people like myself with SQL tables can continue to create SQL tables safe
> in the knowledge that the middleware will take care of interoperating with
> my tables.
Concerning your footnote, I think it is right to some limit.
You can use your knowledge of creating ERM tables while others work
on the implementation of the domain layer BELONGING to it.
I mean, domain (= middle) layer and database have a much stronger
dependency than for example a userinterface and domain layer.
OODBMS are even implemented within the domain layer. They just store
the objects used by the domain layer as they are - as objects.
RDBMS exist outside the domain layer but their goal to store the data of
the domain layer makes them dependent on the domain object structure.
It wouldn't make sense if some people created an OO model with objects
having certain attributes and you created your tables which represented
completely different entities=objects with attributes spread all differently.
Did you read my mail on layers?
A datainterface layer between the domain and RDBMS could take the task
to "translate" some dataaccess actions between those two. But only to
some extent. It is difficult enough to map an OO model onto an ERM having
a similar structure.
Here are some mapping rules in short:
class = entity
attribute = attribute
method = ??
association (role/aggregation/composition) = association
inheritance = is-a-association
Example:
2 entities (tables) "Man" and "Women" have an m:n relationship which is
represented by a third table "Marriage".
In the domain (OO) model, you would have three classes (for each table) and
an association from Man to Marriage and from Women to Marriage.
So, you could work on what you say you can do the best - ER modelling.
However, I would recommend you to find some people working on the domain
and synchronize with their model's structure. Otherwise, you do the same work
like them, only that you are designing an entity-relationship model while
they use OO.
Christian
