Object Relational Mapping Consistency via Bi-directional Pointers
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Current object-oriented languages lack tools to manage relational data consistently, leading to inconsistencies between database and memory environments, particularly during CRUD operations, and inefficiencies in object relational mapping systems due to resource consumption and complex sequencing of commands.
Innovation Solution
The introduction of a prescriptive programming model using specific collection classes for entity sets and entity refs, which provide bi-directionally consistent pointers to maintain object graph fidelity, allowing for consistent navigation between database and memory environments, and a tracking component to optimize change detection and resource usage.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Ease of operation
If objects are retrieved from database and converted to memory objects, then data access becomes simpler, but consistency between database and memory environments is lost
Solution Approach 1:
The patent introduces an intermediary layer (object-relational mapping framework) that mediates between the database environment and memory environment. This framework includes change tracking mechanisms and persistence listeners that automatically synchronize objects between database and memory, resolving the consistency issue while maintaining data access simplicity.
Solution Approach 2:
The patent implements feedback mechanisms through change tracking components that monitor modifications to memory objects and automatically generate corresponding database updates. This closed-loop feedback system ensures consistency is maintained without requiring manual intervention, allowing objects to be modified in memory while automatically reflecting changes in the database.
2Reliability
If copies of objects are created for change tracking, then consistency can be maintained, but resource consumption increases
Solution Approach 1:
The patent extracts only the essential change information from full object copies, maintaining minimal representations of objects for tracking purposes. Instead of copying entire objects, the system tracks only the changes (insertions, updates, deletions) and uses this extracted information for persistence operations, significantly reducing memory consumption while maintaining consistency.
Solution Approach 2:
The patent applies partial action by creating copies only when necessary (upon database retrieval) and only retaining the minimal information needed for change tracking. The system avoids excessive copying by using incremental change tracking mechanisms that update only modified objects rather than replicating the entire object graph.
3Measurement precision
If all objects are copied for later comparison during persist operations, then change detection is accurate, but computing resources are consumed
Solution Approach 1:
The patent performs preliminary action by establishing change tracking mechanisms at the time of object retrieval from the database. Change listeners are registered and monitoring begins immediately, so when objects are modified, changes are already tracked and ready for persistence operations. This eliminates the need for costly full-object comparisons during persist operations.
Solution Approach 2:
The patent uses selective copying by creating shallow copies of objects only when necessary for change tracking, rather than deep copies of entire object graphs. The system copies only the essential object references and uses identity-based tracking to determine changes, reducing the computational overhead of copying while maintaining accurate change detection.
Data Source
AI summary
Systems and methods that enable consistent navigation (for a database and memory environment) in object relational mapping. This typically ensures fidelity of object graph via restrictions on collections of persistent objects (e.g., entity sets, entity refs . . . ). Moreover, a tracking component can detect changes as they occur, and only a copy of the objects that have changed can be created, to optimize operation.