[
Lists Home |
Date Index |
Thread Index
]
At 01:23 PM 8/22/2003, lbradshaw@dbex.com wrote:
>I am saying I have not seen a proof that XML supports, or can be
>engineered to support, the Relational Model.
XML is not relational - it uses a different model. The Relational Model
does not support XML either. Computer science generally does allow for the
existence of more than one model.
There are two query languages that you may be interested in. SQL/XML is an
extension of SQL that allows XML to be created as the result of a
relational query. Oracle and DataDirect have both added extensions to allow
relational data to be updated from XML. This is a simple way to add XML
support to relational databases without dramatic changes to the underlying
infrastructure.
The Working Drafts for SQL/XML are here:
(<ftp://sqlstandards.org/SC32/WG3/Progression_Documents/Informal_working_drafts/>ftp://sqlstandards.org/SC32/WG3/Progression_Documents/Informal_working_drafts/)
Here are two ACM articles by Jim Melton and Andrew Eisenberg that make an
easier introduction:
(<http://www.acm.org/sigmod/record/issues/0109/standards.pdf>http://www.acm.org/sigmod/record/issues/0109/standards.pdf),
(http://www.acm.org/sigmod/record/issues/0206/standard.pdf).
XQuery is an XML-centric query language that does have formal semantics. If
you look at the people associated with the development of XQuery, you will
find quite a few people with extensive background in relational databases,
including Don Chamberlin, who invented SQL together with Ray Boyce, and Jim
Melton, the current editor of SQL. If you look at the papers at any
academic database conference these days, you will find work on algebras for
XQuery, optimizing XQuery, using XML views of relational data, etc. Of
course, XQuery *is* new, and the first XQuery-based systems may not be as
highly optimized as the current SQL systems, which have been around a lot
longer.
The XQuery specs can be found at (http://www.w3.org/xml/query.html). To get
a feel for the language per se, start with the use cases
(http://www.w3.org/TR/xquery-use-cases/). You may be particulary interested
in the Data Model (http://www.w3.org/TR/xpath-datamodel/) and the Formal
Semantics: (http://www.w3.org/TR/xquery-semantics/).
>For the sake of clarity, let me try to summarize in just a few lines in
>just one post:
>
>1) One reason the Relational Model was developed was to reduce coding and
>design efforts required throughout the application life cycle, while
>offering as much flexibility and reliability as possible.
>2) Data based applications developed using the Relational Model, which are
>well engineered and designed, will feature lower cost over time with
>greater flexibility. One rule of thumb is that maintenance costs will be
>less than 1/100th of the development (or all pre-production costs).
>3) XML applications are all data based applications, whether you call
>documents data as a structured formatted element, or data as a set or
>group of elements. IE there are no XML applications that do not contain or
>process data elements.
>4) Rigorous, scientific proofs exist, and are easily found, for adherence
>to the Relational Model (RM). Saying that something supports SQL does not
>say it can implement or adhere to RM, because SQL support does not require
>RM compliance or support per se.
>5) I have seen nothing better than RM for improving software application
>reliability, flexibility, maintainability and lowering software system
>costs overall. If something better exists, as a methodology with
>scientific proofs, I would dearly like to see it.
>
>So. My point is that I have not seen a rigorous, scientific proof for RM
>via XML or any XML tool set.
SQL databases have clearly been a huge breakthrough for practical computing
environments. The pure RM, as you imply, has never been implemented, and
purists like to lament that fact. Perhaps it would have been wonderful if
it had been implemented, perhaps the failure to convince companies to
implement it despite campaigning for it over the course of 25 years
indicates that there may be a reason it was never implemented by the major
relational database companies.
As for rigorous, scientific proof, it is important to be clear what
constitutes proof and what it constitutes proof of. Relational databases
are what people had before XML. People have now gone to XML for many
classes of applications, especially document-oriented applications or those
that exchange structured information across the Internet. Do you have any
rigorous, scientific proof that the RM can improve anything for these
applications compared to XML?
There is plenty of good research behind XML query systems based on SQL/XML
or XQuery. For a good algebra, you may want to look at:
TAX: A Tree Algebra for XML (2001)
by H. V. Jagadish, Laks V. S. Lakshmanan, Divesh Srivastava, et al.
Citeseer is down right now, but I would look at the 12 papers that cite
this as well.
>This leads me to conclude that a very high probability, almost a
>certainty, exists that any XML application will endure the specific issues
>which RM was designed to resolve. Especially large scale data based
>applications featuring significant or exclusive XML usage.
I think it would be silly to assume that the SQL/XML people working as part
of the SQL standards process have not heard of the relational model, and it
just so happens that the XQuery people have heard of it too. I do not come
from the relational world, but many of us do. So far, your argument is
basically that the relational model is tried and true, and XML is not based
on it. That's all true. But are you saying that software should never be
allowed to use any other model?
>As a Software Engineer, someone who majored in Computer Science, I have
>grave concerns about applications already deployed, or in development,
>that make significant usage of XML.
Most of the advantages you claim above for the RM are actually advantages
of implemented SQL systems in use today. We have 30 years of experience
with these systems, they have been optimized over the years, and they work.
As you say, they are not pure RM systems. If you scrounge around on
citeseer, you will see that a lot of research is being done, but it seems
that a lot of what you want is actual performance and productivity, which
you measure on working systems rather than models.
The first XQuery systems will not be based on 30 years of experience, but
they will be based on many years of theory. Many of them will be
translating XQuery directly to and from SQL, using an XML view of a
relational database. The performance of these systems will depend on the
quality of the generated SQL. Others will use native XML persistent
storage, with associated indexes. Some will do a combination of the two.
Jonathan
|
