XML Query Optimization via Branch Elimination
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for executing XML queries over XML views that use aggregate set operators, such as UNION ALL, are inefficient due to the need for functional evaluation of underlying data containers, leading to suboptimal performance and resource utilization.
Innovation Solution
The proposed solution involves an elimination-based optimization technique that merges queries with structural information from underlying data containers, pushes down expressions to individual data containers, and performs branch elimination to transform queries into a distributive form, allowing for efficient execution on relational or object-relational constructs.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If functional evaluation of underlying data containers is performed for XML queries over UNION ALL views, then query correctness is maintained, but query execution efficiency deteriorates
Solution Approach 1:
The patent segments the UNION ALL view into its constituent base views and further segments the query evaluation into separate evaluations for each base view. By dividing the query execution into independent segments that operate on individual base views, the system avoids the inefficiency of functional evaluation while maintaining correctness through systematic combination of results.
Solution Approach 2:
The patent performs preliminary actions by evaluating queries against each base view separately before combining results. The system pre-processes each base view independently, pushing down expressions to individual data containers, and then combines the pre-evaluated results. This preliminary segmentation and evaluation approach eliminates the need for inefficient functional evaluation of the entire UNION ALL view.
2Adaptability or versatility
If queries are executed over UNION ALL views using existing methods, then comprehensive data coverage is achieved, but computational complexity increases
Solution Approach 1:
The patent segments the complex UNION ALL view evaluation into simpler sub-queries against individual base views. Each base view is processed separately with its own execution plan, reducing the computational complexity of any single evaluation while maintaining comprehensive data coverage through systematic combination of all base view results.
Solution Approach 2:
The patent applies local quality by optimizing each base view evaluation individually rather than applying a uniform complex evaluation strategy to the entire UNION ALL view. The system pushes down expressions to individual data containers and tailors the evaluation approach to each base view's specific characteristics, reducing overall computational complexity while achieving complete data coverage.
3Productivity
If expression pushdown optimization is applied to UNION ALL views, then query execution speed improves, but implementation complexity increases
Solution Approach 1:
The patent segments the expression pushdown process into separate operations for each base view. Rather than implementing a complex unified pushdown mechanism for the entire UNION ALL view, the system applies pushdown optimization independently to each base view's query, simplifying the implementation while achieving significant execution speed improvements.
Solution Approach 2:
The patent performs expression pushdown as a preliminary action during query transformation, before execution. By pushing down expressions to individual data containers in advance and transforming queries into distributive form, the system prepares optimized execution plans that improve query execution speed without requiring complex runtime evaluation mechanisms.
Data Source
AI summary
Optimization is provided for database statements involving XML data, e.g., XPath and XQuery, which operate over views that use aggregate set operators, e.g., UNION ALL. As part of a “view merge” stage of query transformation, the query that operates over the view is merged with a query that defines the view. One or more expressions (e.g., operators, predicates, virtual table constructs) from the query that operates over the view are then “pushed down” to operate on the individual underlying XML data constructs. “Branch elimination” is performed based on the structure of the view and the query acting over the view, based on which it is possible to determine whether any of the sub-queries, if executed, would result in the return of zero rows. If so, then such branches are eliminated from the transformed query, leaving a reduced set of data containers on which to execute the query.