Can XML be Saved from Itself, Or is History Doomed to Repeat
XML and its use with databases has not really taken off with as much success as its other uses. We can draw some conclusions from this by examining the huge success of SQL relational databases and the only moderate success of Object technology. SQL relational databases became a huge success quickly because they were based on a mathematically based technology and it was standardized. On the other hand, object technology was not based solidly on any one principled technology which caused each vendor to implement their own implementation with no consistency across industry solutions. Users were understandably standoffish by these nonstandard solutions that were not backed by solid proven or principled technology.
With this flashback, we can we see parallels with XML's use in databases and things that should have been performed differently. Relational technology was based on a mathematically proven technology. Relational technology was also implemented using a standard implementation of SQL. With this going for Relational technology and SQL's industry standard implementation of it, it would have been surprising if it had not been hugely successful. SQL with relational technology was the only sensible choice in town.
The standardized specification for XML's external format was accepted by the industry almost immediately and it became hugely successful out of the gate because of all of the advantage it achieved as a universal format language. Unfortunately the XML specification does not say one word on how this powerful hierarchical data format is to be processed. This leaves not only the computer language implementation up for grabs, but also the underlying operational implementation. Because of this, no XML underlying database implementation today is based solidly on a principled technology. What happened to Object technology is happening all over again with each vendor having their own language and a less than scientific implementation. There is not even a standard definition today that covers what correct hierarchical processing is.
So where does this leave XML database use today? XML database customers may be holding off using XML in critical and production applications, waiting for a standard XML solution with an easier to use more mathematically accurate and principled foundation. Another reason might be the lack of decision support usage, since multi-leg queries are difficult to procedurally specify accurately, especially in an ad hoc usage. Surprisingly a proven hierarchical processing solution has been around even before relational technology, which was discarded because at that time it was not compatible with relational processing.
But now with the advent of XML hierarchical structures and ANSI SQL's inherent ability to process them (as described on this site), there is no reason not to support nonprocedural full nonlinear (multi-leg) hierarchical processing directly in SQL. Which is what our patented SQL for XML SQLfX® product now in Beta accomplishes. Not only is it more powerful than today's linearly restricted XML processing, but it is also based solidly on a full nonlinear hierarchically principled foundation which is significantly more user friendly and easier to use. For these reasons, it can deliver a very improved ROI.