Relational Query Slicing via Spool Operators
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Relational data servers face performance issues when processing complex queries due to resource bottlenecks, leading to delays and potential server crashes, as they struggle to manage the evaluation of queries involving large records or complex operations without unduly impacting other concurrent queries.
Innovation Solution
The implementation of automated query rewriting techniques that partition complex relational queries into smaller query slices, each executed within a defined duration threshold, using spool operators and temporary relations to manage resource utilization and maintain query consistency.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If complex relational queries are evaluated in an unbroken sequence, then query processing completeness is improved, but server resource availability deteriorates
Solution Approach 1:
The patent divides complex relational queries into smaller query slices that can be executed independently and in parallel. Each query slice represents a subset of the original query operations, allowing the server to process multiple slices concurrently across different cores, thus maintaining query completeness while improving resource availability and throughput.
2Adaptability or versatility
If query complexity increases, then query functionality is improved, but processing time increases
Solution Approach 1:
Complex queries are segmented into multiple query slices that can be processed in parallel. This segmentation allows the server to execute different parts of complex queries simultaneously on multiple cores, reducing the overall processing time while maintaining the full functionality of the original complex query.
Solution Approach 2:
The system performs preliminary analysis of complex queries to identify suitable segmentation points and execution strategies before actual query execution. This preliminary action includes estimating query complexity, determining optimal slice divisions, and preparing execution plans, which enables more efficient processing of complex queries without losing functionality.
3Speed
If more computing resources are allocated to a single complex query, then query processing speed is improved, but concurrent query processing deteriorates
Solution Approach 1:
By segmenting complex queries into smaller slices, the system can distribute these slices across multiple cores for parallel processing. This allows each slice to receive adequate computing resources for fast execution while the overall system maintains high concurrent query processing capacity through efficient resource utilization across multiple processing units.
Solution Approach 2:
The patent merges multiple query slices from different complex queries across multiple cores, creating a consolidated execution plan that optimizes resource utilization. This merging approach allows the system to process multiple slices in parallel while maintaining efficient use of computing resources, thereby improving both individual slice speed and overall concurrent processing productivity.
Data Source
AI summary
A relational database server may concurrently execute many relational queries, but a complex relational query may cause performance delays in the fulfillment of other relational queries. Instead, the relational database server may generate a query plan for the relational query, and may endeavor to partition the relational query between a spool operator and a scan operator into two or more query slices, where each query slice may be executed within a query slice threshold. Many alternative candidate query plans may be considered, such as inserting spool and scan operators after various operators and parameterizing operators in order to partition the records of a relation into two or more ranges based on an attribute of the relation. A large search space of candidate query plans may be reviewed in order to select a query plan that respects the query slice threshold while efficiently executing the logic of the relational query.