Print

Print


Folks,

I've been watching this discussion with some interest, and I'd like
to throw in an "off the wall" suggestion.

The fundamental model of Dublin Code style metadata boils down to
the following:

  1)  A record is an unordered set of tuples called elements.

  2)  An element consists of an element name, a value, and optional
      encoding scheme qualifier and an optional language qualifier.

  3)  A (full) element name consists of a prefix, a name and an
      optional refinement.

A metadata record is typically expected to conform to a schema.
This schema is a set of rules that say whether a record is valid
or invalid.  For a valid record, the schema typically also says
what the elements "mean".  At the syntactic level, a schema typically
specifies:

  *  the set of element names that are recognized
  *  the set of qualifiers allowed for each element,
  *  the syntax (or vocabulary) of the values for each allowed
     combination of element name / qualifier, and
  *  the cardinality of the elements in a record.

[In some cases, there are other more complex syntactic rules; e.g.
AGLS and ANZLIC / ANZMETA spring to mind.]

In SRU/SRW (and other XML-based metadata protocols like OAI PMH), the
conventional way of encoding records is to design an XML schema that
(more or less) expresses the syntax rules of the metadata schema. Each
standard metadata schema, and each site-specific tailoring ends up with
its own XML schema.  Unless implementors are sophisticated ... and
diligent ... metadata interchange is lossy at best, and problematic at
worst.

But there is an alternative.

Instead of having the XML schema reflect the metadata schema, make it
reflect JUST the fundamental model of metadata.  Thus, instead mapping
(say) a "DC.Date.created" metadata element to an XML element like:

   <dc:date.created>2001-01-01</dc:date.created>

it might be represented as:

   <element id="DC.Date.created" encoding="ISO8601">2001-01-01</element>

An XML encoding of a metadata record consists of a sequence of these XML
elements, together with the identifier for the record's nominal metadata
schema.

This approach allows you to transfer any metadata record that meshes
with Dublin Core's underlying model of metadata.  It is up to the server
to decide which metadata elements to send, and it is up to the client to
decide what to do with any received elements that it doesn't understand.
 Filtering of elements and mapping of element names / encodings / values
could occur at either end.  On the client side it may be advisable to
validate the final records against the client's understanding of the
metadata schema.

[For the record, this is the approach that we (DSTC) take in our HotMeta
/ MetaSuite software.  Our "REG" record format allows any metadata
record to be encoded, regardless of the record's metadata schema.  On
the client side, we typically filter the elements of the decoded record,
then validate it against the appropriate metadata schema.  We don't do
any server side mapping or filtering yet, but that is an option for the
future.]

-- Steve

+----------------------------------+----------------------------------------
| Stephen Crawley                  | HotMeta Project Leader
| Level 7, GP South Building (78)  | Distributed Systems Technology CRC
| Staff House Road                 | Tel   : +61 7 3365 4310
| The University of Queensland     | Fax   : +61 7 3365 4311
| Queensland 4072                  | Email : [log in to unmask]
| Australia                        | WWW   : http://www.dstc.edu.au
|                                  | DSTC is the Australian W3C Office
+----------------------------------+----------------------------------------