As some of you will be aware, a little work has been going on to try
and map the Dublin Core (at least) and Warwick Framework (perhaps) into
various directory service type protocols. The hit list at the moment
is WHOIS++, LDAP, and genuine X.500. For convenience it would be
useful if we could use the same schema definition in both X.500 and
LDAP, which suggests that we define it in X.500 terms first. (Oh joy!)
OK, so Dublin Core in WHOIS++ is done quite trivially. More soon on
this front...
X.500/LDAP turn out to be a bit more difficult. The problem is that we
have to decide where (if anywhere) the scheme info goes. It seems that
there are two broad choices:
. it goes into the name of an attribute/value pair
. it goes into the value of an attribute/value pair
This problem, if it is a problem, stems from the attribute/value nature
of these protocols. Dublin Core gives us grief because it chucks in an
extra piece of information (scheme) or two (cf. Relation element) for
good measure. Fine for SGML. Bad news for attribute/value oriented
formats ?
In the X.500 world, if we defined an attribute name such as
schemeLCSH
I think we would have a problem. Why? Because in order to associate
any other scheme info with a particular X.500 attribute, it would be
necessary to define a new schema entry for the attribute name + scheme
combination. So, unless you can define all the schemes you're going to
need in advance, there's a painful schema update required each time you
want to add something new - e.g. say subjectMeSH
One could say
subjectScheme= DDC
subject= 813
(as we've done for WHOIS++)
but the only way to tightly bind these two pieces of information
together is to make them an object class (I think I'm using the right
terminology here). So, in order to create a "dublinCore" object, we
would need it to inherit its attributes from all thirteen object
classes associated with the thirteen Dublin Core elements.
Still with me ? OK...
If we discount having a separate attribute for the qualifier, or
merging it into the attribute name (actually (O)ID), this leaves us
with ugly constructions involving munging the scheme (etc) into the
value side of the attribute/value pair, e.g.
subject= (scheme=DDC) 813
or perhaps
subject= scheme=DDC $ 813
or
subject= DDC $ 813
and so on. These are attractive because we can introduce new schemes
(or other qualifying info) without having to change the "dublinCore"
schema, but I think they stop us from being able to do anything
particularly sensible with the qualifiers.
The positive side of this is that by bundling the whole Dublin Core
element into a single attribute/value pair, we can make the attributes
themselves "repeatable" in the schema definition, and so can carry
through the "all elements repeatable" part of the Dublin Core.
Is this approach just too horrid to contemplate, though ? Hmmm... It
does make the HTML encapsulation look positively elegant :-)
Martin
|