Optimistic Concurrency Control with Automatic Content Merge
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing optimistic concurrency control mechanisms are limited as they only prevent updates from overriding previous changes by rejecting the update request, leading to additional computing resource consumption due to repeated fetch-update cycles.
Innovation Solution
Implementing automatic content merging within the optimistic concurrency control mechanism to detect concurrency errors and merge concurrent updates from independent sources, allowing the merged update to be saved to the resource.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Reliability
If standard optimistic concurrency control is used to prevent updates from overriding previous changes, then data consistency is improved, but computing resource consumption increases due to rejected update requests requiring re-tries
Solution Approach 1:
The patent converts the harmful effect of concurrency conflicts (which traditionally cause update rejections and resource waste) into a beneficial automatic merging process. When concurrent updates are detected, the system automatically merges them using conflict resolution algorithms, transforming what was previously a failure condition into an opportunity to preserve multiple changes without requiring client re-tries.
Solution Approach 2:
The server acts as an intermediary between concurrent clients, receiving conflicting updates and automatically resolving them through merging algorithms. This intermediary process eliminates the need for clients to re-try failed updates, as the server handles the conflict resolution and ensures both updates are preserved in the final merged result.
2Reliability
If standard optimistic concurrency control rejects conflicting update requests, then data consistency is maintained, but productivity decreases due to repeated fetch-update cycles
Solution Approach 1:
The patent transforms the previously harmful concurrency conflict scenario into a beneficial automatic merging operation. Instead of rejecting conflicting updates and forcing clients through repeated fetch-update cycles, the system automatically merges the conflicts on the server side, preserving both updates and eliminating the need for re-tries, thereby significantly improving productivity.
Solution Approach 2:
The system performs preliminary conflict detection and automatic merging before the client would need to re-try the update. By proactively resolving conflicts on the server side, the system eliminates the need for repeated fetch-update cycles, improving overall processing efficiency while maintaining data consistency.
3Productivity
If automatic content merging is implemented in optimistic concurrency control, then productivity is improved by avoiding re-processing, but device complexity increases due to merging logic
Solution Approach 1:
The server implements an intermediary merging layer that automatically resolves concurrent updates using conflict detection and resolution algorithms. This centralized merging logic, while adding complexity to the server, eliminates the need for complex client-side re-try logic and manual conflict resolution, ultimately simplifying the overall system architecture while improving productivity.
Solution Approach 2:
The system implements self-service automatic merging where the server autonomously detects and resolves concurrency conflicts without requiring client intervention. This self-service approach consolidates the complexity within the server's merging logic, freeing clients from complex error handling and re-try mechanisms, thereby improving overall system productivity.
Data Source
AI summary
As described herein, a system, method, and computer program provide automatic content merging for an optimistic concurrency control mechanism. A concurrency error resulting from a first source requesting a first update to a resource concurrently with a second source requesting a second update to the resource is detected. Responsive to detecting the concurrency error, the first update and the second update are merged to form a merged update. The merged update is saved to the resource.


