Database Change Accumulation via Side File

Resolve Bottlenecks,
Find Innovative SolutionsGenerate Solutions

Solution Overview

Problem

Conventional database management approaches face challenges in efficiently updating and maintaining databases due to frequent changes, leading to prolonged freezing of the source version, which inconveniences customers by halting or slowing down enterprise applications.

Innovation Solution

A database management system that accumulates changes in a 'side file' during the creation of a new data structure, allowing these changes to be applied later, ensuring the source version can catch up without extensive downtime by bounding the size of the side file and applying changes incrementally.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If the source version is frozen to apply changes to the offline version, then the offline version can catch up with the source version, but the source version must be taken offline for a relatively long period of time, inconveniencing customers

Engineering Contradiction:

Improvedata consistencyVSAvoiddowntime

Core Design Contradiction:

ReliabilityVSLoss of time

Solution Approach 1:

The patent applies preliminary action by pre-capturing snapshots of the source data structure at multiple points in time before the catch-up operation. This allows the system to have ready-to-use baseline versions that can be quickly applied when needed, eliminating the need to recreate snapshots during the freeze period and significantly reducing downtime while ensuring data consistency.

Inventive Principle:

Principle #10Preliminary action

2Loss of time

If changes are accumulated in a side file and applied incrementally, then the side file size is bounded and catch-up time is reduced, but the system complexity increases due to change tracking and file management

Engineering Contradiction:

Improvecatch-up timeVSAvoidsystem complexity

Core Design Contradiction:

Loss of timeVSDevice complexity

Solution Approach 1:

The patent introduces a side file as an intermediary component that stores captured changes separately from the main data structure. This mediator allows changes to be accumulated, tracked, and applied incrementally without directly modifying the source or target data structures during the catch-up process, simplifying the overall complexity by providing a dedicated buffer zone for change management.

Inventive Principle:

Principle #24Intermediary (Mediator)

Solution Approach 2:

The patent segments the change management process into distinct phases: capturing changes in the side file, tracking them separately, and applying them incrementally to the offline version. This segmentation allows each component to be optimized independently and enables parallel processing, reducing catch-up time while keeping system complexity manageable through modular design.

Inventive Principle:

Principle #1Segmentation

3Adaptability or versatility

If multiple snapshots are captured at different points in time, then the ability to rollback to any previous version is improved, but the storage requirements and processing overhead increase

Engineering Contradiction:

Improverollback capabilityVSAvoidstorage space

Core Design Contradiction:

Adaptability or versatilityVSQuantity of substance

Solution Approach 1:

The patent implements a nested snapshot structure where snapshots are organized in a hierarchical manner, with each snapshot containing references to previous snapshots rather than complete duplicates. This nesting allows the system to maintain multiple version points for rollback capability while significantly reducing storage requirements by sharing common data between nested snapshot layers.

Inventive Principle:

Principle #7Nested doll (Nesting)

Data Source

PatentUS8027955B2Database management using a file to accumulate changes

Publication Date: 2011.09.27 MICROSOFT TECHNOLOGY LICENSING LLC

AI summary

Database management is described. A source data structure is copied to create a new data structure. Changes to the source data structure that occur during and after creation of the new data structure are accumulated in a file before they are added to the new data structure. Changes included in the file are subsequently applied to the second data structure.