Database Framework for Efficient Large Result Set Retrieval
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing methods for handling large database result sets are inefficient, particularly when retrieving and displaying data, as they often require fetching all records and discarding unnecessary ones, leading to high database stress and inefficiency.
Innovation Solution
A framework that retrieves only primary keys initially and uses them to fetch specific data subsets, reducing database load and enabling efficient pagination, sorting, and caching for subsequent access.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If all database records are retrieved and sorted, then complete data is available for display, but database stress increases and efficiency decreases
Solution Approach 1:
The patent segments the data retrieval process into multiple phases: first retrieving only primary keys in a sorted manner, then retrieving full record data only for the specific page subset needed. This segmentation allows the system to maintain data completeness while dramatically reducing database stress by avoiding retrieval of all records when only a small subset is required.
Solution Approach 2:
The patent performs preliminary retrieval of primary keys with sorting before retrieving the actual record data. By establishing the sorted order and identifying which primary keys are needed for the current page first, the system prepares in advance to fetch only the necessary full records, thereby improving efficiency without sacrificing data completeness.
2Productivity
If only primary keys are retrieved initially, then database stress is reduced, but additional retrieval steps are required
Solution Approach 1:
The retrieval process is divided into distinct segments: a first query for primary keys with sorting, a subset operation to identify needed keys, and a second query for full record data. While this adds steps, each segment is simpler and more efficient than retrieving all records at once, and the framework automates these segments to manage complexity.
Solution Approach 2:
The patent introduces primary keys as an intermediary between the database and the application logic. Instead of directly retrieving and manipulating full records, the system uses primary keys as a intermediate representation that can be sorted, subset, and used to efficiently retrieve only the necessary full records, thereby reducing overall complexity.
3Adaptability or versatility
If data retrieval logic is scattered in JSPs and helper classes, then flexibility is maintained, but code maintenance difficulty increases
Solution Approach 1:
The patent merges scattered data retrieval logic into a unified framework that handles the two-phase retrieval process (primary keys then full records) in a centralized manner. This consolidation maintains flexibility through configurable parameters while significantly improving maintainability by eliminating duplicated logic across multiple JSPs and helper classes.
Solution Approach 2:
The framework creates a universal data retrieval mechanism that can serve multiple purposes: pagination, sorting, and subset retrieval. By designing the system to be multi-functional, it replaces multiple specialized code segments with a single versatile framework that maintains adaptability while reducing maintenance burden.
Data Source
AI summary
A computer-implemented technique for managing large results sets returned from a data request for a database. The technique comprises retrieving the primary keys responsive to the data request and sub-setting of the primary keys returned into at least one subset list. The data is then retrieved on a second pass of the database retrieving data from the database using the primary keys of the at least one subset list. Data retrieval is selectively repeated as required until all requested data has been retrieved. The technique is implemented within a framework. The framework comprises an interface defining a desired protocol of behaviour using common methods and an abstraction of the interface implementing the common methods as defined by the interface. Call back methods provide access to the framework by the primary keys.