Persistence Engine Entity Mapping for Object Efficiency
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
The existing technologies face inefficiencies in processing entity-based service operations on object-based persistence frameworks, particularly due to differences in data processing semantics between the user interface and backend layers, leading to inefficient communication and resource usage.
Innovation Solution
An engine within the persistence layer maps entities to objects, constructing a prepared object by determining the context and enriching the entity node with data from service calls, allowing for efficient execution of service operations while minimizing resource usage by reading only the necessary parts of the core object.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If the backend layer operates on the complete object structure with persistence calls triggered on the complete object, then data consistency is maintained, but processing efficiency deteriorates due to unnecessary data transmission and memory usage
Solution Approach 1:
The patent segments the complete object structure into entity nodes and other nodes. The service operation processing is divided into: (1) determining the entity node corresponding to the service operation, (2) constructing a prepared object containing only the entity node and necessary parent nodes, and (3) executing the service operation on the prepared object rather than the complete object. This segmentation maintains data consistency for the affected entity while reducing unnecessary data processing.
Solution Approach 2:
The patent extracts only the necessary entity node and relevant parent nodes from the complete object structure to create a prepared object. This extraction process removes unnecessary nodes and data from the processing scope, reducing memory usage and processing time while maintaining the integrity of the affected data through the context information that tracks the hierarchical path.
2Adaptability or versatility
If the UI layer sends and receives detached entity data, then communication flexibility is improved, but data processing semantics become inconsistent with the backend layer
Solution Approach 1:
The patent introduces an intermediary mapping mechanism that translates between entity-based UI layer operations and object-based backend layer operations. The service operation processing engine acts as a mediator that: (1) receives service operations in entity format from the UI layer, (2) maps entities to corresponding object nodes using context information, and (3) executes operations on the object structure while maintaining semantic consistency. This intermediary layer enables communication flexibility while resolving semantics inconsistency.
Solution Approach 2:
Instead of forcing the backend layer to adapt to entity-based semantics, the patent inverts the approach by making the UI layer operations adaptable to object-based semantics through the mapping mechanism. The service operation is translated from entity format to object node format before execution, allowing the backend to maintain its object-based structure while still supporting flexible UI communication.
3Loss of information
If the engine constructs a prepared object by reading the entire core object, then complete context information is obtained, but resource consumption increases
Solution Approach 1:
The patent applies partial action by reading only the necessary portion of the core object - specifically the entity node and its parent nodes in the hierarchical structure - rather than the entire object. The context information guides this partial reading process to ensure that all necessary context for the service operation is captured while minimizing resource consumption by excluding unnecessary nodes and data.
Data Source
AI summary
Entity-based service operation upon object-based persistence, is efficiently accomplished utilizing mapping between entities and stored objects. An engine within the persistence layer receives a service call referencing an interface entity. The engine determines a context of a core object in the persistence layer. Based upon the context, the engine constructs from the core object, a prepared object including an entity node. A path between the entity node and a root node of the prepared object may comprise context, or may be derived from only partially reading the core object to construct the prepared object. The engine enriches the entity node with entity data from the service call, to generate an applied object. Referencing the applied object as a parameter, the engine executes the service call on the core object. The engine maps the core object to a result object returned to the interface layer in response to the service call.