Advanced Data Access Technologies has discovered and perfected the previously unsolvable ANSI SQL native XML integration solution. It enables relational data to integrate completely and seamlessly with all forms of hierarchical data such as native XML and hierarchical legacy data. This includes thecomplete and controlled hierarchical joining or linking of multi-leg structures into larger hierarchical structures, the direct access and processing of native XML at a full hierarchical level, and the non procedural processing of advanced XML operations. These advanced XML operations include: node promotion, fragment processing, structural transformation, variable structure processing, and shared and duplicate element use.
In many cases, nonprocedural query languages like our SQL hierarchical processing can automatically perform extremely complex hierarchical semantic processing that is impractical for XML query languages which must specify the complex processing semantics procedurally.Nonprocedural languages like SQL automatically utilize the vast amount of naturally occurring hierarchical semantics to perform this semantically complex operation.
Advanced Data Access Technologies has developed, prototyped, and patented the technology to enable a breakthrough next generation ANSI SQL product as described on our Product page. Such an advanced product is possible, and could become the de facto ANSI SQL native XML integration solution. This technology could place this product at the gateway to the Internet opening additional opportunities.
This product's qualifications for success are right on the mark: its interface (syntax and semantics) is: ANSI standard, nonproprietary SQL, fully integrates with native XML at a hierarchical level automatically utilizing XML's hierarchical semantics, supports joining XML structured documents with full hierarchical control, and it fully and accurately supports hierarchical query semantics on the most complex multi-leg hierarchical structures.
Our ANSI SQL native XML integration product will support all the capabilities mentioned above and offer other powerful solutions and capabilities not thought possible with SQL-based products. These advanced capabilities extend to the nonprocedural processing of irregular hierarchical structures made possible with semistructured XML data, and will help future proof this product.
This product will also go far beyond the ideal solution by seamlessly replacing SQL's standard relational engine with a hierarchical engine. This is possible with this technology because SQL is operating at a full hierarchical level. This will eliminate the main bottlenecks experienced by the relational engine’s flattening of hierarchical data. These bottlenecks are caused by the huge memory requirements produced by the relational engine's Cartesian product exploding data replications, and their additional processing requirements.
With all the above capabilities in place, this product will be able to elevate the hierarchical processing and XML integration capabilities beyond the capabilities of the underlying databases and data sources, and enable a continuous hierarchical processing with SQL.
The basic problem with SQL integration of native XML is that SQL was designed to process flat relational data while XML is hierarchically structured. This disparity produces a large impedance mismatch. This is an invalid assumption, SQL can process hierarchical data, and actually process it at a full hierarchical level. The standard ANSI SQL Outer Join operation can perform powerful hierarchical data modeling and structure processing.
The SQL-92 standard includes support for the Outer Join operation which can preserve row data that has no matching row data to join with. With the "Left" Outer Join, this preserving of data is preserved on the left table argument but not the right. This basic operation is hierarchical in nature and allows SQL to perform hierarchical processing and optimization.
Each join operation has its own associated ON clause to unambiguously specify the exact join (linkage) criteria and can be used to control variable structure creation allowed in XML. By stringing Left Outer Joins together, an entire multi-leg hierarchical structure can be defined that precisely follows the operational definition of hierarchical processing. This SQL data modeling can be generated automatically from hierarchical structure metadata sources such as XML DTDs and Schemas or even COBOL copybooks.
The Left Outer Join syntax is used to model hierarchical structures and the associated Left Outer Join semantics precisely define the resulting hierarchical operation. This actually extends SQL's natural processing model to a hierarchical tree structure where tables are the nodes in the multi-legged hierarchical structure being processed.
This Outer Join data modeling of hierarchical structures can be placed in standard SQL views which themseves can also be outer joined into a larger hierarchical structure whose resulting (combined) outer join syntax models the combined structure. The power of these structured SQL views is very significant for making hierarchical processing user friendly through data structure abstraction and reuse.
These hierarchical views can also be dynamically optimized, bypassing the access of unnecessary legs of the structure based on which data fields were specified when the query was invoked. This also means that each structure only requires one view making hierarchical processing even more user friendly while making it more efficient.
With the Outer Join data modeling described above, the relational Cartesian product model of processing performs hierarchically. This is because it is carrying out the hierarchical operation defined in the Outer Join semantics. SQL is a general purpose data processor language that is basically controlled by the relationships between the data. Defining these data relationships hierarchically in SQL naturally produces hierarchical structure processing and results because the relational engine is operating as a hierarchical tree model. Hierarchical processing is just a subset of relational processing.
Our patent seamlessly extends this natural SQL hierarchical processing capability to physical hierarchical structures such as XML and legacy data. Please see our list of publications for documents and those document pointers at the bottom of this page that will further describe and provide proof of this natural SQL hierarchical processing capability.
The outer join defines and models hierarchical structures and its semantics specify how they are processed. When operating hierarchically (when all the data has been defined hierarchically) outerjoins do not have to be processed relationally by performing joins, they can be performed hierarchically avoiding all the efficiency problems of relational joins. So multiple outer joins are not necessarily inefficient.
Achieving Full Native XML Integration
Based on the above SQL hierarchical data modeling and structure processing capabilities, the mechanism to implement total seamless SQL native XML integration is to enable the hierarchical outer join definition of XML documents at the SQL view level. With this in place, XML hierarchically structured views and their materialized data (down to the specific data item) can be directly and seamlessly accessed, and hierarchically processed. This gives full SQL access and operational capabilities to the native XML data located by URL, file or local or remote table/column address. No special SQL/XML operation is needed to process the XML data.
The transparent XML access means that dynamically selected data from native XML documents can be used to naturally update relational tables with standard SQL update commands. This advanced hierarchical processing extends to the hierarchical SQL joining of these XML structures with other hierarchical structured views. These hierarchical structured views hierarchically model XML, legacy data, or relational data, and specify the internal or external locations of this data. The URL's for modeled XML can be specified at execution in the FROM clause. This is truly the Holy Grail of SQL-based XML integration.
Our ANSI SQL native XML integration technology is in two parts. The first is the Outer Join Data Modeling methodology that naturally and automatically raises SQL's processing to a full hierarchical processing level. The second part is a patented technology that can seamlessly extend this natural hierarchical processing to native XML and legacy input and output data. This extension technology can also be used in the relational engine to naturally and seamlessly support hierarchical optimizations and value added features that are based on the hierarchical processing capability.
These two technology parts can also be used to transparently power a hierarchical engine instead of a relational engine to greatly increase the hierarchical processing efficiency and capabilities, producing a linear scalability for memory usage and processing.
The SQL user or developer operates naturally and seamlessly on hierarchical structures specified in SQL views that define logical relational or physical XML hierarchical structures. These hierarchical views model hierarchical structures naturally in SQL by using the standard Left Outer Join syntax in a simple but disciplined way (enforcing logic and increasing accuracy) that enables their associated semantics to perform hierarchical processing. These structured SQL views can be defined by the user directly or created with the help of a GUI or generated automatically from meta data sources such as DTDs, XML Schemas, or COBOL FDs.
These structured views can be hierarchically joined by using the standard Left Outer Join operation in the same data modeling fashion used to build the data structures. The final hierarchical result identified by all the views modeled into one unified hierarchical structure is returned as a relational rowset unless the user requests XML Output. This will produce a structured XML document automatically based on the SQL modeled hierarchical structure. This is possible because row sets created by outer joins can reflect the variable multi dimensional data structure because of the null values inserted which preserve the column locations.
SQL Native XML Integration Technology
As stated above, our ANSI SQL native XML integration technology is divided into two parts. There is the methodology for coding standard SQL so that it defines hierarchical relationships which naturally cause SQL's processing to be hierarchical. The relational engine and the input and output procedures of SQL are not aware that this hierarchical processing is actually taking place or what the hierarchical structure being modeled and processed looks like. The other part of our SQL-based native XML technology is our patented procedure for dynamically extracting the hierarchical meta data from the hierarchical structures defined by structured views used in the SQL specification and their expanded unified virtual view.
With this valuable meta data information which reflects real-time data modeling, the input and output procedures can be enhanced to seamlessly navigate and access hierarchical data structures such as XML. The relational engine can be enhanced to seamlessly extend and improve its hierarchical processing capabilities to implement hierarchical optimizations and extended value added capabilities and functions based on knowledge of the dynamically defined virtual hierarchical structure being processed.
Summary of Technology Features
Unique Advanced Capabilities of Our Technology
·ANSI SQL standard, no XML centric syntax needed, no risk
·Seamless and transparent native XML access and integration
·Automatically utilizes hierarchical semantics in native XML data
·Automatically produces hierarchical result as rowset or structured XML
·Supports full hierarchical and dynamic joining of hierarchical structures
·Supports advanced and distributed hierarchical processing capabilities
·Avoids common SQL/XML integration CPU and memory bottlenecks
·All SQL features operate on native XML dynamically with no limitations
·Result is both valid hierarchically and relationally insuring tightest integration
·Since hierarchical result is relationally accurate, it is also mathematically sound
·Data modeling makes SQL Hierarchical queries easier and more accurate
·Hierarchical views expand into a single unified and heterogeneous SQL view
·Heterogeneous data sources take part consistently in hierarchical operations
Our Significant Technology Findings
·Hierarchical processing is a valid subset of relational processing
·Complete and flexible hierarchical data modeling in SQL is possible
·Hierarchical processing optimizations also apply to relational processing
·Variable hierarchical structures and their processing in SQL are possible
·Hierarchical physical structure transformation is possible in SQL
·Linking below the root of the lower joined structure is possible and useful
·Relational engine can be transparently replaced with a hierarchical engine