Hybrid Reactive Rule Engine for Relational and Graph Reasoning
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional rule engines require time-consuming and resource-intensive flattening of objects represented by graph-like data structures before they can be processed, limiting their efficiency in handling hierarchical relationships.
Innovation Solution
A hybrid reactive rule engine that supports both relational and object-oriented models, allowing objects represented by object-oriented models to propagate through the network without flattening, using join and from nodes to interpret hierarchical relationships directly.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If objects represented by graph-like data structures are input into traditional rule engines, then the rule engine can process objects with hierarchical relationships, but the objects must be flattened which is time and resource consuming
Solution Approach 1:
The rule engine is segmented into multiple specialized engines: a relational rule engine for flat data structures and a graph rule engine for hierarchical data structures. Each engine is optimized for its specific data type, eliminating the need to flatten graph objects while maintaining the ability to process both relational and hierarchical relationships efficiently
Solution Approach 2:
A hybrid rule engine acts as an intermediary layer that receives objects in their native format (either relational or graph-like), determines the appropriate engine to use, and routes the processing accordingly. This mediator eliminates the need for time-consuming flattening operations while maintaining compatibility with traditional rule engines
2Ease of operation
If objects are flattened to be processed by conventional rule engines, then processing can be performed using traditional relational models, but the flattening process consumes significant time and resources
Solution Approach 1:
The system dynamically selects between relational and graph rule engines based on the input object type. The hybrid rule engine automatically determines whether to use traditional relational processing or graph-based processing, optimizing performance for each case without requiring manual intervention or object transformation
Solution Approach 2:
The rule engine changes its operational parameters based on the input data structure. When receiving graph-like objects, the system switches to graph rule engine mode with appropriate algorithms for hierarchical processing. When receiving flat objects, it uses traditional relational rule engine mode, thereby adapting processing efficiency to the data type
Data Source
AI summary
A processing device executing a rule engine receives a first object. The processing device determines whether the first object is represented by a relational model or an object-oriented model. The first object is determined to be represented by the relational model responsive to the first object lacking a reference to a nested object. The first object is determined to be represented by the object-oriented model responsive to the first object including a reference to a nested object. If the first object is represented by the relational model, a join is performed between the first object and a second object based on a relationship between the objects using a first node. If the first object is represented by the object-oriented model, an expression of the first object is evaluated to navigate to a third object that is a first nested object of the first object using a second node.