Graph Database Query Concatenation for Complex Relationship Extraction
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Applications face difficulties in efficiently extracting complicated relationships from databases like relational databases and key-value stores due to lack of knowledge about the underlying relational model, leading to suboptimal query performance and degraded user experience.
Innovation Solution
The system employs a graph database that translates initial queries into edge queries, representing compound relationships using hub nodes hidden from users, allowing direct extraction of desired information without joining intermediate results, thereby reducing computation time and memory requirements.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If a relational database is used with multiple queries to extract complicated relationships, then data can be organized into tables with rows and columns, but query performance degrades due to the need to perform sets of queries and join results
Solution Approach 1:
The patent segments the complicated relationship extraction task into multiple simple key-value queries. Each query retrieves a specific portion of the relationship data independently, and the results are then combined in the application layer. This avoids the performance degradation of traditional SQL joins while maintaining the ability to extract complex relationships.
Solution Approach 2:
The patent introduces an intermediary layer (the application logic) that sits between the key-value store and the final result. This intermediary performs the combination of multiple simple query results to produce the equivalent of a complex relationship extraction, thereby avoiding the need for optimized join operations in the database layer.
2Productivity
If an object-relational mapper is used to provide application knowledge about the relational model, then query generation improves, but system complexity increases due to the difficulty of generating and maintaining the mapper
Solution Approach 1:
The patent extracts the complexity of the relational model knowledge from the database layer and relocates it to the application layer. Instead of maintaining an object-relational mapper in the database system, the application directly manages the key-value queries and result combinations, thereby eliminating the need for complex mapper maintenance while preserving query generation capabilities.
Solution Approach 2:
The application serves itself by directly constructing and executing key-value queries without relying on an external object-relational mapper. The application has direct knowledge of the data structure and can generate appropriate queries autonomously, eliminating the intermediary mapper layer and reducing overall system complexity.
3Ease of operation
If a key-value store is used to allow applications to access data as objects in memory, then data access consistency improves, but query optimization becomes difficult requiring multiple queries
Solution Approach 1:
The patent segments the complex relationship extraction into multiple simple key-value queries that can be executed independently and efficiently. Each query targets a specific key or set of keys, allowing the key-value store to optimize each individual query while maintaining overall query efficiency through the combination of results.
Data Source
AI summary
In order to request desired information from a graph database, a system executes a query against the graph database. The graph database may store a graph that includes nodes, edges between the nodes, and predicates to represent and store data with index-free adjacency. Moreover, the query may identify a first edge associated with a predicate that specifies one or more of the nodes in the graph. In response to the query, the system receives a result that includes a subset of the graph. Then, the system may use the result of the query in a concatenated set of queries. In particular, the system may execute a second query against the subset of the graph. Furthermore, in response to the second query, the system may receive a second result that includes a second subset of the graph.