Graph Query Processing Using Hybrid Relational and Graph Engines
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing graph database query processing technologies face inefficiencies in handling large and complex attributed graphs, particularly in executing recursive operations and traversing graph topologies, which leads to high memory consumption and performance issues when querying large datasets.
Innovation Solution
The proposed solution involves a graph query processing technique that decomposes queries into sub-components, utilizing a hybrid engine implementation with relational and memory-based components to optimize query execution, leveraging relational database systems for pattern matching and graph engines for reachability and shortest path queries, and employing a G-SPARQL query language to efficiently process complex queries across attributed graphs.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If a single query execution engine is used to process graph queries, then the system architecture is simple, but query processing performance is slow and memory consumption is high when handling large and complex attributed graphs
Solution Approach 1:
The patent divides the query execution system into multiple specialized engines: a relational database engine for pattern matching operations and a graph engine for reachability and shortest path queries. Each engine is optimized for specific types of operations, allowing parallel processing and improving overall query performance while managing complexity through functional segmentation
Solution Approach 2:
The system implements a universal query processing framework that can handle multiple types of graph operations (pattern matching, reachability, shortest path) through a unified query language (G-SPARQL) and query decomposition mechanism, allowing a single system to perform diverse functions using multiple specialized engines
2Adaptability or versatility
If recursive operations and graph topology traversal are implemented in existing graph databases, then query functionality is complete, but memory consumption increases significantly
Solution Approach 1:
The patent replaces the traditional in-memory graph traversal approach with a hybrid architecture that uses relational database systems for pattern matching operations. This substitution leverages the disk-based storage and optimized query execution of relational databases, significantly reducing memory consumption while maintaining complete query functionality through the graph engine for topology-specific operations
3Adaptability or versatility
If graph databases are used to model large data sets, then data representation capability is sufficient, but query execution time increases
Solution Approach 1:
The patent segments the query execution process into distinct phases handled by specialized engines: pattern matching is delegated to the relational database engine which can efficiently handle large datasets using optimized join algorithms, while the graph engine focuses on topology-specific operations. This segmentation parallelizes processing and reduces overall query execution time
Solution Approach 2:
The patent introduces a query decomposition layer that acts as an intermediary between the user query and the execution engines. This layer translates G-SPARQL queries into separate sub-queries for the relational and graph engines, coordinating their execution and combining results, thereby optimizing the interaction between different engine types and reducing execution time
Data Source
AI summary
Graph queries are processed using a plurality of independent query execution engines. A graph query submitted to a graph database which is modeled by an attributed graph is received. The graph query is decomposed into a plurality of query components. For each of the query components, a one of the query execution engines that is available to process the query component is identified, a sub-query representing the query component is generated, the sub-query is sent to the identified query execution engine for processing, and results for the sub-query are received from the identified query execution engine. The results received are then combined to generate a response to the graph query.


