Graph Query Engine Super Node Caching
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing graph query processing techniques are inefficient due to high execution time, memory usage, and energy consumption when dealing with super nodes in large graphs, as they often require extensive indexing and frequent revisitation of vertices, which is impractical and costly, especially in dynamic graph environments.
Innovation Solution
Implementing a caching mechanism that stores neighbor vertices of super nodes with excessive degrees, allowing for quick retrieval during graph traversal, thereby reducing the need for repeated database access and minimizing the cost of revisiting super nodes.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Loss of time
If traditional graph query processing is used without caching, then memory usage and execution time are high when dealing with super nodes, but implementing caching requires additional memory space and complexity
Solution Approach 1:
The patent pre-identifies super nodes in the graph before query execution and pre-loads their neighbor vertices into cache memory. This preliminary action ensures that when queries traverse through super nodes, the neighbor information is already available in cache, eliminating the need for repeated database access and significantly reducing execution time.
Solution Approach 2:
The patent applies caching selectively only to super nodes (nodes with degree exceeding a threshold) rather than all nodes in the graph. This local quality approach focuses computational resources on the specific subset of nodes that cause performance bottlenecks, reducing overall system complexity while achieving significant speedup for query processing.
2Speed
If indices are created over graph data to facilitate rapid access, then query speed improves, but memory space requirements and index building time increase significantly
Solution Approach 1:
The patent extracts only the neighbor vertex information of super nodes from the full graph data and stores it in cache memory. This extraction approach avoids creating comprehensive indices over the entire graph, reducing memory space requirements while still providing rapid access to the critical neighbor information needed for query traversal.
Solution Approach 2:
Instead of indexing all graph data, the patent takes a partial action by indexing only the neighbor vertices of super nodes. This partial indexing strategy provides sufficient speedup for query processing while keeping memory space requirements manageable, avoiding the excessive resource consumption of full graph indexing.
3Adaptability or versatility
If comprehensive indices are created for all possible predicate types, then query flexibility improves, but index building time and memory consumption become impractical
Solution Approach 1:
The patent creates a universal cache structure for super node neighbors that can serve multiple query types and predicates. Instead of creating separate indices for each predicate type, the cached neighbor information provides a multi-functional foundation that supports various query operations, maintaining flexibility while avoiding redundant index building.
4Reliability
If graph data is frequently mutated, then data freshness improves, but maintaining indices becomes expensive and time-consuming
Solution Approach 1:
The patent implements a dynamic caching strategy where the cache is automatically updated when graph mutations occur. The system dynamically identifies which super nodes are affected by mutations and updates only their neighbor caches, rather than maintaining static comprehensive indices. This dynamic approach maintains data freshness while minimizing the overhead of cache maintenance.
Data Source
AI summary
Techniques herein accelerate graph querying by caching neighbor vertices (NVs) of super-node vertices. In an embodiment, a computer receives a graph query (GQ) to extract result paths from a graph in a database. The GQ has a sequence of query vertices (QVs) and a sequence of query edges (QEs). The computer successively traverses each QE and QV to detect paths of the graph that match the GQ. Traversing each QE and QV entails retrieving NVs of a current graph vertex (CGV) of a current traversal path. If the CGV is a key in a cache whose keys are graph vertices having an excessive degree, then the computer retrieves NVs from the cache. Otherwise, the computer retrieves NVs from the database. If the degree is excessive, and the CGV is not a key in the cache, then the computer stores, into the cache, the CGV as a key for the NVs.