Every ANSI SQL Processor Contains a Powerful Hierarchical Engine
Put Yours to Use for Navigationless Transparent Native XML Integration
ANSI SQL Hierarchical Processor
It may seem amazing or even impossible that every ANSI SQL processor at the level of SQL-92 or above contains a powerful full nonlinear (multi-leg) hierarchical processor. This inherent hierarchical processor can process multi-leg hierarchical queries against full nonlinear hierarchical structures. This SQL hierarchical processing naturally supports advanced high level conceptual processing operations such as hierarchical joining of hierarchical structures, hierarchical fragment processing, and structure transformations. This includes all the basic lower level hierarchical processing operations and their principles such as hierarchical data preservation.
Hierarchical processing in SQL does not require anything new to learn, or new data format to use. Standard SQL is used the same way it is used today. Define your relationships and specify your nonprocedural SQL query with SELECT, FROM and WHERE statements. The only difference is that relationships are limited to hierarchical joins that model hierarchical data structures. No real surprise here. This is how relational databases were meant to operate, define your data structures and the relational engine does the rest. SQL-92 introduced the capability to model hierarchical structures with Left Outer Joins. But the collective relational mindset in the SQL/XML industry has prevented the industry from recognizing the possibility of hierarchical structure processing in SQL until now with our breakthrough product.
Our patented SQL for XML SQLfX® product knows how to recognize hierarchical processing in SQL and how to interpret its results in the relational result set. It fully leverages this incredibly powerful inherent capability to support platform-neutral transparent and hierarchically correct native XML Integration.
Less is More
Restricting relationships to pure hierarchical ones allows the powerful natural hierarchical principles to be isolated in their pure state which enables them to be carried out correctly hierarchically. No new hierarchical concepts presented here either. Powerful pre-relational hierarchical processors had very successfully utilized these same hierarchical principles in processing their hierarchical databases with powerful hierarchical query languages. SQL utilizes these very same hierarchical principles automatically by following the associated semantics of the Left Outer Join syntax that models hierarchical structures. This may seem too simple a process to achieve full nonlinear (multi-leg) hierarchical processing automatically. This is very true, there are many very powerful and advanced operations performed naturally in ANSI SQL hierarchical query processing not covered here. These powerful inherent operations and how they function automatically are described fully in our Nonlinear Hierarchical Processing Tutorial.
What is Missing: SQLfX®
Unfortunately, even though ANSI SQL can perform complex hierarchical processing today, the relational engine is not aware that this processing is taking place. So this capability is not being recognized and utilized today. This is where our patented SQL for XML SQLfX® middleware product comes to the rescue. It sits on top of your SQL processor and knows how to interface with your processor's Input and Output to fully enable and utilize its powerful hierarchical processing capabilities to add native nonlinear XML support transparently. In addition, our SQLfX® middleware product user interface remains ANSI SQL standard and nonprocedural with no database navigation or user structure knowledge needed.
Your Free Nonlinear Hierarchical Engine Is Sitting on a Goldmine of Semantic Fuel
Every node in a multi-leg relational structure is related to every other node in the structure with its own usable semantics. Unlike today's XML linear hierarchical data processors, nonlinear processors also utilize the semantics that exist naturally between all combinations of legs. This freely available semantic information fuels nonlinear hierarchical processing engines with meta information to process complex structures without requiring user procedural direction or knowledge of the structure.
Single Universal Global View
The global hierarchical semantic knowledge mentioned above allows your SQL nonlinear processor to nonprocedurally process any single or multiple leg SQL query posed of it. This query processing is based on the semantic understanding of the entire hierarchical structure. This allows the very powerful concept of a single (universal) view that can be used to process any query contained in the global view. Multiple views of the same hierarchical structure are no longer necessary. Multiple views are not user friendly requiring the user to remember each sub view of the structure. In addition, it is not reasonably possible to have a sub view tailored for each possible use. A single global view used with nonlinear processors removes all of these problems. Users are no longer burdened with having to know the hierarchical structure and where the data exists in the structure.
Smaller views were often used for optimization purposes to eliminate unnecessary access to portions of the structure unnecessary for a particular query. Nonlinear hierarchical processing can optimize each query at runtime to eliminate any path or portions of dangling paths that are not necessary to the query being processed. This eliminates the overhead of global views and insures each query is fully hierarchically optimized. SQLfX® makes this dynamically optimized single view possible. These single views are usually defining a physical structure. This does not preclude them or smaller views from being joined dynamically into larger logical views which are also hierarchically optimized in their entire virtual form.
Accurate Hierarchical Results
What makes nonlinear hierarchical processing so special besides its advanced capabilities is that they require very complex processing across their legs. This is what nonlinear hierarchical processing is all about. A nonlinear query that references two different legs requires that the two legs be coordinated correctly to produce the correct results. This coordination process uses Lowest Common Ancestor (LCA) logic to perform this coordination, otherwise the result is not meaningful. Amazingly, relational SQL processors perform this "LCA Query" processing automatically by naturally following the hierarchical structure semantics (especially in the relational Cartesian processing). This ensures all nonlinear hierarchical queries are hierarchically accurate. XML processors today, including XQuery, do not perform this complex LCA processing automatically. This basically limits them to linear (single path) processing for practicality reasons associated with writing complex procedural code.
Dynamically Increases the Value of Your Data
The processing of multi-leg queries dynamically increases the value of the database data for each specific query use. These multi-leg queries as described above require the utilization of the natural semantics that exist between the referenced legs. This utilization of additional semantics that are applicable to the query being processed adds additional information needed to derive the result than just the explicit information in the database alone. A simple example is a query that accesses a data item from one leg based on data from another leg. This query requires coordination logic which is carrying out the semantics between the two legs involved. This process has increased the value of the data contained in the context of the internally complex multi-leg query. This is also a good example of the single view concept described above since the user specifying this internally complex query does not need to know the structure making it a simple query to specify.
Why Go Out of the Box When the Solution is In the Box
All of the other SQL native XML integration solutions have had to go outside of the SQL box to support SQL native XML integration. Even going out of the box still has not solved the SQL/XML integration problem caused by the empedance mismatch of relational (flat) and hierarchical (structured) data. All of these solutions are proprietary, involve procedural XML centric solutions, and do not process the data hierarchically. Processing XML data and outputting XML without hierarchically processing it has a significant chance of producing undetected incorrect hierarchical results
SQLfX® uses a powerful and previously proven solution that is already in the SQL box. Every other SQL/XML industry solution is utilizing the lowest common denominator approach of flattening XML data to integrate it with SQL's flat relational data. SQLfX® uses SQL's inherent nonlinear hierarchical processing that is already in the box. With this breakthrough solution, the relational data is elevated using standard SQL to a hierarchical level to seamlessly integrate it with XML. This seamless method also preserves the goldmine of hierarchical structure semantics present in the structure of the data being processed. This free semantic information is immediately utilized automatically by the nonlinear hierarchical processing that is occurring inherently in standard SQL to automate XML hierarchical processing. SQLfX® is the only SQL/XML solution based on a solid hierarchically principled technology, performing hierarchically from input, through processing, to output.
While this does fully solve the SQL/XML integration problem, there are also many additional capabilities that are also gained. The inherent nonlinear hierarchical processing enables the XML integration to be transparent, fully integrated naturally, and ANSI SQL standard. This keeps the SQL processor operating fully nonprocedural and dynamically if necessary. This means that the user does not need to know the data structure or perform any database navigation. In addition, full multi-leg queries are supported, further enhancing the fact that the user does not need to know the structure. These are all capabilities not available today from the other SQL/XML integration solutions and significantly increase ROI.
SQLfX® Increases Customer ROI by Eliminating:
1) Risk (no proprietary, non standard or XML centric solution) 2) Overhead (no additional coders or coding, no maintenance) 3) Time-to-market (no training time, no switching SQL processor) 4) Cost-of-Ownership (no training cost, no data conversion)