Graph Database Branch Threading for Query Performance
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Applications face difficulties in optimizing data storage and retrieval in relational databases due to the lack of knowledge about the underlying relational model, leading to suboptimal query performance and degraded user experience, especially when dealing with complex relationships.
Innovation Solution
A graph database is employed, utilizing a tree-based structure with a base version and branched versions to efficiently store and retrieve data, allowing for optimal query performance without requiring knowledge of the relational model, through the use of (subject, predicate, object) triples and an index for efficient edge lookup.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If a relational database is used with complex relationships, then data can be organized in tables with rows and columns, but query performance degrades due to the need to perform multiple queries and joins
Solution Approach 1:
The patent creates a graph database that copies and transforms data from the relational database into a graph structure with nodes and edges. This copy allows applications to query complex relationships efficiently using graph traversal algorithms, while the original relational database remains unchanged. The graph database serves as an optimized view specifically for relationship queries.
Solution Approach 2:
The patent changes the fundamental parameters of data organization from tabular (relational) to graphical (nodes and edges). By representing entities as nodes and relationships as edges, the system enables direct traversal of complex relationships without requiring multiple SQL joins, thus improving query performance for relationship-intensive applications.
2Ease of operation
If data is stored in a key-value store to allow application-friendly access, then applications can access data as objects in memory, but it becomes difficult to optimize and extract complicated relationships
Solution Approach 1:
The patent segments the data storage system into two distinct components: a key-value store for application-friendly data access and a graph database for optimized relationship queries. Each component serves its specific purpose, allowing the system to maintain ease of operation while also enabling query optimization for complex relationships.
Solution Approach 2:
The graph database acts as an intermediary between the key-value store and applications that need to query complex relationships. It receives data from the key-value store, organizes it into an optimized graph structure, and provides efficient query capabilities for relationship-intensive operations without requiring applications to directly manage the underlying data structure.
3Reliability
If multiple versions of graph data are maintained for testing and validation, then changes can be validated without affecting source data, but storage and memory usage increases
Solution Approach 1:
The patent implements a versioning system where graph versions are nested within a tree structure. Each version can contain only the changes (deltas) from its parent version rather than complete copies of the entire graph. This nested structure allows multiple versions to be maintained with minimal storage overhead, as each version reuses the parent's data and only stores the differences.
Solution Approach 2:
The versioning system allows temporary storage of multiple graph versions during testing and validation, with the ability to discard test versions after validation is complete. The system recovers and maintains only the necessary versions, optimizing storage usage while preserving data integrity during the testing process.
Data Source
AI summary
The disclosed embodiments provide a system for processing queries of a graph database storing a graph, wherein the graph comprises a set of edges defined by a first linkage, a second linkage, and a third linkage. During operation, the system maintains the base version of an index of the graph database. Upon branching a version of the graph database from a first offset representing a virtual time in the base version of the graph database, the system creates a branched version of the index from a second offset corresponding to the virtual time in the base version of the index. The system then processes queries of the graph database based on the offsets and references from the branched version of the index to the base version of the index.