In-Memory Graph Indexing for Faster RDBMS Graph Algorithms
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing relational database management systems (RDBMS) face performance gaps and complexity issues when executing graph algorithms due to the lack of efficient graph index support, particularly for heterogeneous graph topologies, leading to increased latency and complexity in data management.
Innovation Solution
The solution involves generating on-the-fly graph indexes in memory within the RDBMS, using a compressed sparse row (CSR) representation to efficiently navigate graph elements, and integrating with existing index-based graph algorithm runtimes, allowing seamless execution of graph operations without pre-constructed indexes.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If graph indexes are pre-constructed in dedicated graph engines or graph databases, then graph algorithm performance is improved, but data management complexity and loading costs increase
Solution Approach 1:
The patent merges graph indexing capabilities with existing relational database management systems (RDBMS). By integrating graph algorithm support directly into the RDBMS, the system eliminates the need for separate graph engines or graph databases, thereby reducing data management complexity while maintaining graph algorithm performance through efficient in-memory graph representations.
Solution Approach 2:
The RDBMS is enhanced to perform both traditional relational database operations and graph algorithm execution. The system uses a unified in-memory graph representation that can be constructed from existing relational tables, allowing the same database system to handle both relational and graph query workloads without requiring separate specialized systems.
2Speed
If multiple Compressed Sparse Row (CSR) structures are used to model heterogeneous graph topologies, then graph navigation performance is improved, but memory consumption and index construction complexity increase
Solution Approach 1:
The patent segments the graph representation into multiple CSR structures, where each CSR corresponds to a specific graph topology or relationship type. This segmentation allows efficient graph navigation for heterogeneous topologies while keeping each individual CSR compact and manageable, balancing performance requirements with memory constraints.
3Device complexity
If graph indexes are constructed on-the-fly during algorithm execution, then data management complexity is reduced, but execution time and computational overhead increase
Solution Approach 1:
The system performs preliminary actions by constructing graph indexes in advance from existing relational table data, making them available for immediate use when graph algorithms are executed. This pre-construction approach eliminates the need for on-the-fly index building during algorithm execution, thereby reducing execution time while maintaining the simplicity of working with existing relational data structures.
Data Source
AI summary
In response to a user invoking a graph operation on a graph in an in-memory graph algorithm (IMGA) runtime in a relational database management system (RDBMS), the RDBMS generates a set of one or more graph indexes in memory. The graph is represented as one or more vertex tables and one or more edge tables. The RDBMS generates the set of one or more graph indexes by generating a mapping of each database table vertex identifier to a corresponding internal identifier. For each edge table of the one or more edge tables, the RDBMS generates a graph index data structure representing edges of the edge table. The graph index data structure represents each edge in the edge table as a source internal identifier and a destination internal identifier. The RDBMS can then execute the graph operation in the IMGA runtime using the set of one or more graph indexes.