InfoWorld Test Center
When it comes to managing information exchanges across different
platforms and environments, XML is an irresistible option. It is an
open, accepted standard that runs on multiple platforms. It's also the
only data technology that clearly spells out data structures and
content, and it doesn't burden applications with proprietary database
technologies. As a result, XML makes data exchange easier and less
expensive than most other data formats.
Traditionally, allowing programmatic access to a database has required
that a developer be proficient with the underlying technical and
semantic paradigms typical of whatever information repository is being
used.
For example, relational databases hide data behind a proprietary format
that is accessible only if you include the proper API for that
database, such as an ODBC driver in your application. Furthermore, to
access data, developers must provide the correct coordinates such as
database, table, and field names. Allowing coding access to multiple
databases can complicate your application, which can add costs to your
project.
In comparison, XML is an open book. An XML data structure goes hand in
hand with an associated DTD (Document Type Definition), which spells
out both the data content and its naming conventions. Each piece of
data is thoroughly labeled according to the DTD and is therefore
understandable to your application. Moreover, it's generally easy to
convert data structures to XML, so your applications can rely on XML to
retrieve data from multiple sources.
But adopting XML sometimes means trading one set of problems for
another. One of the most serious limitations of XML is that it doesn't
have a data engine of its own. As a result, XML documents are often
stored in existing data repositories such as relational or object
databases. Most major database vendors provide extensions that let you
store and retrieve XML documents from their databases.
But this solution isn't perfect, either, because you suffer performance
hits when you use different data structures.
Properly defined indexes can make or break the responsiveness of a
relational database, but because XML organizes data in a hierarchical
model that doesn't translate easily into the relational paradigm, such
fine-tuning can be difficult when you're dealing with XML.
If this all sounds like de ja vu, you're right -- we've been down this
road before, most notably during the object vs. relational database
wars. The market produced some hybrids, such as the object-relational
database that offered the irresistible appeal of preserving companies'
investments in relational technology while adding object functionality.
Now a similar trend is developing in the XML world. Will relational
databases survive XML as they did objects? Probably, but innovations
such as the XML-specific DBMS present interesting options in
reconciling varied data structures.
Stay tuned.
