Hash Pointer Checking for Hierarchical Database Consistency
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional hash check functions in hierarchical databases, such as IBM IMS, are ineffective in checking the consistency of pointers when they have n-to-one relationships with target segments, as they cannot identify which pointer or relative byte address is incorrect, limiting their ability to verify consistency in parent-child relationships.
Innovation Solution
A system and method that reads segment information, determines the type of each segment and pointer, extracts parent and twin pointers, and calculates hash values from storage location addresses and pointer values to identify consistency errors, allowing for effective hash checks even in n-to-one relationships by combining these values using binomial operations.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Speed
If a conventional hash check function compares the sum of pointer values with the sum of relative byte addresses, then checking speed is improved, but the ability to check consistency in n-to-one pointer relationships deteriorates
Solution Approach 1:
The patent segments the hash check process into two distinct phases: a first hash check that compares the sum of pointer values with the sum of relative byte addresses for fast checking, and a second hash check that specifically handles n-to-one relationships by comparing parent pointers with child pointers. This segmentation allows the system to maintain high checking speed while reliably detecting inconsistencies in complex pointer relationships.
Solution Approach 2:
The patent introduces an intermediary mechanism (the second hash check process) that mediates between the fast but incomplete first hash check and the requirement for comprehensive consistency verification. This intermediary step specifically addresses n-to-one relationships by extracting and comparing parent pointers with their corresponding child pointers, ensuring reliable consistency checking without sacrificing the speed advantage of the initial hash check.
2Measurement precision
If direct comparison of pointer values with relative byte addresses is performed, then measurement precision is improved, but productivity deteriorates
Solution Approach 1:
The patent divides the consistency checking process into two segments: a first hash check that provides fast but less precise checking by comparing sums, and a second hash check that provides precise checking for n-to-one relationships by directly comparing parent and child pointers. This segmentation enables the system to achieve high measurement precision where needed while maintaining overall productivity through the efficient first check.
Solution Approach 2:
The patent applies partial action by implementing the precise direct comparison method (second hash check) only for the specific case of n-to-one relationships, rather than applying it universally to all pointer checks. This selective approach ensures high measurement precision for complex relationships while avoiding the productivity loss that would result from applying the more time-consuming method to all cases.
3Device complexity
If the number of pointers and target segments are required to be the same for hash check effectiveness, then device complexity is reduced, but adaptability deteriorates
Solution Approach 1:
The patent makes the hash check function universal by designing it to handle both one-to-one relationships (through the first hash check) and n-to-one relationships (through the second hash check). The determination unit automatically identifies the relationship type and applies the appropriate checking method, allowing a single hash check function to adapt to various pointer relationship scenarios without increasing overall system complexity.
Solution Approach 2:
The patent introduces dynamics into the hash check function by making it adaptable to different pointer relationship types. The determination unit dynamically identifies whether a relationship is one-to-one or n-to-one and selectively applies the appropriate checking methodology. This dynamic adaptation allows the system to handle diverse relationship types effectively while maintaining manageable complexity through automated relationship type identification.
Data Source
AI summary
A method of checking consistency of pointers in a hierarchical database includes reading segment information recorded on the hierarchical database and determining a type of each segment and pointer included in each segment. The method also includes extracting parent pointers and twin pointers from child segments and extracting a child pointer from the parent segment. The method also includes calculating a first hash value by a combination of a storage location address of the parent segment and a value of the child pointer and a combination of the values of the parent pointers and the twin pointers included in the child segments, and a second hash value from a combination of storage location addresses of the child segments and the values of the parent pointers included in the child segments. The method further includes indicating a consistency error when the first hash value and the second hash value differ.