Inverted Index Dependency Tracking for Database Function Cache Invalidation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
In large-scale server systems, managing dependencies between data objects in a database system is inefficient, particularly when changes occur, leading to time-consuming and computationally expensive invalidation processes due to the need to iterate through all functions to identify and invalidate dependent objects.
Innovation Solution
The use of inverted index-based dependency tracking mechanisms, such as data type-dependency inverted indexes and inverted function-dependency lists, allows for efficient identification and invalidation of dependent functions by mapping data types and functions, reducing the overhead of invalidation processes.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If traditional dependency tracking methods are used to manage data objects in a database system, then all functions can be tracked for dependency relationships, but the invalidation process becomes time-consuming and computationally expensive due to the need to iterate through all functions
Solution Approach 1:
The patent segments the function set into multiple groups or categories, and maintains separate dependency tracking structures for each group. When invalidation is needed, the system only needs to traverse the relevant segment rather than all functions, significantly reducing the time and computational resources required while maintaining complete dependency tracking within each segment.
Solution Approach 2:
The patent introduces an intermediary data structure (such as a dependency graph or index structure) that mediates between the stored procedures and the dependency tracking mechanism. This intermediary structure pre-organizes dependency relationships, allowing the system to quickly identify and invalidate only the affected procedures without iterating through all functions, thus resolving the contradiction between complete tracking and fast invalidation.
2Reliability
If traditional dependency tracking methods are used to manage data objects in a database system, then all functions can be tracked for dependency relationships, but the computational resources required for invalidation processes increase significantly
Solution Approach 1:
By segmenting the function set and maintaining separate dependency tracking structures for each segment, the system reduces the computational scope during invalidation operations. Only the relevant segment needs to be processed, significantly lowering CPU usage and computational resources while maintaining complete dependency tracking within each segment.
Solution Approach 2:
The patent performs preliminary organization of dependency relationships by pre-building index structures or dependency graphs when procedures are created or modified. This preliminary action stores dependency information in an optimized format, so that during invalidation operations, the system can quickly retrieve and process only the necessary information without performing expensive computations, thus reducing computational resource consumption.
3Productivity
If the function cache stores procedural language functions in shared memory for efficient execution, then database connections can execute the same functions from cache, but managing dependencies and invalidating affected functions becomes complex and resource-intensive
Solution Approach 1:
The patent segments the function cache into multiple groups or categories based on dependency relationships or function characteristics. Each segment has its own dependency tracking structure, which simplifies the management of dependencies within each group. When invalidation is needed, only the affected segment needs to be processed, reducing the overall complexity of dependency management while maintaining efficient function execution from the cache.
Solution Approach 2:
The patent introduces an intermediary dependency management layer between the function cache and the database connections. This intermediary layer pre-organizes dependency relationships and provides simplified interfaces for tracking and invalidating dependencies. It abstracts the complex dependency management operations, making them easier to handle while preserving the efficiency benefits of storing functions in shared memory cache.
4Productivity
If the function cache stores procedural language functions in shared memory for efficient execution, then database connections can execute the same functions from cache, but the invalidation process becomes computationally expensive when changes occur
Solution Approach 1:
By segmenting the function cache and maintaining separate dependency tracking structures for each segment, the system reduces the computational scope during invalidation operations. Only the relevant segment needs to be processed, significantly lowering CPU power and computational resources required for invalidation while maintaining efficient function execution from the cache segments.
Solution Approach 2:
The patent performs preliminary organization of dependency relationships by pre-building index structures or dependency graphs when procedures are created or modified in the cache. This preliminary action stores dependency information in an optimized format, so that during invalidation operations, the system can quickly retrieve and process only the necessary information without performing expensive computations, thus reducing computational power requirements while preserving cache execution efficiency.
Data Source
AI summary
Techniques are disclosed relating to managing dependencies between shared data objects in a database system. In various embodiments, a data storage system may maintain a function cache that is operable to store functions that are accessible to one or more applications hosted by a server system. In response to a request to invalidate a first data type utilized by one or more of these functions, various embodiments may include accessing an inverted index that specifies a mapping between data types and corresponding functions, stored in the function cache, which depend on those data types. Using the inverted index, various embodiments include identifying a set of functions that depend on the first data type and invalidating the set of functions in the function cache such that the set of functions are no longer accessible by the applications.