Version Table Scheme for Database Version Space Access
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Traditional version space schemes using hash tables face issues such as increased search time due to hash collisions, scalability degradation, and high memory consumption, especially as the number of records with versions grows.
Innovation Solution
Implementing a version table scheme that uses multiple indirections via pointer lookups, where a version table is created for each page with cells corresponding to records, allowing direct access from the table space to the version space, and managing pointers to point to the latest and previous versions within the version space.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Speed
If a hash table is used to store version space entries, then version access can be implemented, but search time increases due to hash collisions as the number of records increases
Solution Approach 1:
The version table is segmented into multiple pages, with each page containing a fixed number of version entries. This segmentation allows the system to access versions by calculating direct offsets based on page numbers and entry positions within pages, eliminating hash collisions and reducing search time to constant time operations.
Solution Approach 2:
The patent introduces a version table as an intermediary data structure between the database records and the version space. This version table provides direct pointers to version entries, serving as a mediator that eliminates the need for hash table lookups and resolves the search time issue while maintaining version access functionality.
2Adaptability or versatility
If a hash table is used for version space management, then version storage is enabled, but scalability degrades due to mutex operations during insertion and removal
Solution Approach 1:
By dividing the version space into multiple pages with fixed-size entry arrays, the patent enables concurrent access to different pages without requiring global mutex operations. Each page can be independently accessed and modified, improving scalability by eliminating lock contentions that plague hash table implementations.
Solution Approach 2:
The version table structure is designed to be self-organizing, with entries automatically placed in appropriate page slots based on version creation order. This eliminates the need for complex mutex-based insertion and removal operations, as the structure naturally handles updates without requiring lock management.
3Reliability
If a hash table is used to reduce hash collisions, then a large number of hash buckets are allocated, but memory consumption increases significantly
Solution Approach 1:
The version table is divided into multiple pages, each containing a manageable array of version entries. This segmentation allows the system to allocate memory in fixed-size units based on actual version storage needs, rather than pre-allocating a large number of hash buckets. Memory is used efficiently by only allocating the necessary number of pages and entry slots.
Solution Approach 2:
Instead of using a large hash table structure that pre-allocates memory for all possible entries, the patent uses a compact version table that copies only the necessary version information into fixed-size page arrays. This copying approach eliminates the need for large pre-allocated hash bucket arrays, significantly reducing memory footprint while maintaining reliable version access.
Data Source
AI summary
Methods, systems, and computer-readable storage media for determining that a first transaction results in a first version of data stored in a page in a database system, the first version being stored in a version space and the data being stored in a table space, in response to the first version, providing a version table for the page, the version table including a set of cells each cell corresponding to a record in the page, setting a version table pointer of the page to point to the version table, and setting a version pointer of a first cell to point to the first version in the version space, the first cell corresponding to a record of the data in the page.