Append-only B-tree Cursor Bottom-up Construction

Resolve Bottlenecks,
Find Innovative Solutions
Generate Solutions

Solution Overview

Problem

Existing algorithms for building balanced b-trees are resource-intensive and time-consuming due to the need for frequent comparisons and rebalancing operations, which can lead to inefficient use of memory and increased input/output costs.

Innovation Solution

Implement a 'bottom-up' approach by pre-sorting data and relaxing the requirement for nodes to be at least half full, allowing nodes to be filled to capacity before adding new elements, and using evicted data elements to create new nodes for balancing, thereby reducing the need for comparisons and unnecessary data movement.

Engineering Contradictions & Design Principles

VSEngineering Contradiction Analysis

1Reliability

If existing algorithms are used to build balanced b-trees with frequent comparisons and rebalancing operations, then the tree structure maintains balance and order, but the time and resource costs increase significantly

Engineering Contradiction:
Improvetree balance maintenanceVSAvoidconstruction time
Core Design Contradiction:
ReliabilityVSLoss of time

Solution Approach 1:

The patent applies preliminary action by pre-sorting the input data before inserting it into the b-tree. This allows the data to be organized in the correct order before insertion, eliminating the need for frequent comparisons and rebalancing operations during construction. The pre-sorted data is then inserted in a bottom-up manner, significantly reducing construction time while maintaining tree balance.

Inventive Principle:
Principle #10Preliminary action

Solution Approach 2:

The patent inverts the traditional top-down insertion approach by using a bottom-up insertion method. Instead of inserting data from the root and maintaining balance at each level, the algorithm inserts data at leaf levels first and then promotes nodes upward, naturally maintaining balance without requiring frequent rebalancing operations.

Inventive Principle:
Principle #13The other way round (Inversion)

2Reliability

If nodes are required to be at least half full during b-tree construction, then the tree maintains balance, but unnecessary data movement and node splitting occur

Engineering Contradiction:
Improvetree balanceVSAvoidnode management complexity
Core Design Contradiction:
ReliabilityVSDevice complexity

Solution Approach 1:

The patent changes the parameter for node fill requirement from the traditional 'at least half full' constraint to allowing nodes to be filled to capacity. This parameter change eliminates the need for unnecessary node splitting and data movement during construction, as nodes can accept data until completely full before promoting to parent nodes, thereby simplifying node management while maintaining balance.

Inventive Principle:
Principle #35Parameter changes

3Manufacturing precision

If frequent comparisons are performed during b-tree construction, then the correct insertion position is found, but resource consumption increases

Engineering Contradiction:
Improveinsertion position accuracyVSAvoidresource consumption
Core Design Contradiction:
Manufacturing precisionVSUse of energy by moving object

Solution Approach 1:

The patent applies preliminary action by pre-sorting the input data before insertion. This preliminary organization of data eliminates the need for frequent comparisons during insertion, as data is already arranged in the correct order. The bottom-up insertion method further reduces comparisons by inserting data at leaf levels where position is determined by pre-sorted order rather than comparing with existing nodes.

Inventive Principle:
Principle #10Preliminary action

Data Source

PatentUS9594786B2Append-only b-tree cursor
Publication Date: 2017.03.14 SYBASE INC
  • US9594786B2 patent drawing
  • US9594786B2 patent drawing
  • US9594786B2 patent drawing

AI summary

Existing algorithms to build balanced tree structures (“b-trees”) compare a data element (e.g., a key) to be inserted with the data elements that have already been inserted to find the correct position to insert the data element. Additionally, the algorithms balance and/or rebalance the b-tree when any individual node gets over-filled. As part of this balancing, data elements stored in the various nodes are moved to other nodes. These operations can incur both time and resource costs. We propose an algorithm to build a b-tree in a bottom up manner and a technique to modify trees built using the aforementioned algorithm so that they are balanced. We also propose a method to allow for adding more data into the thus-built b-tree as long as it follows a certain set of pre-conditions.