Static Row Identifier Partitioning for Concurrent Database Insertion
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Conventional databases experience significant performance degradation when multiple computing threads attempt to insert data simultaneously into the same table, leading to delays and reduced efficiency, especially as the number of threads exceeds eight.
Innovation Solution
The database employs statically partitioned and sub-partitioned row identifier spaces in a delta memory store, allowing concurrent insertion of data into sub-partitions, with each sub-fragment being selected based on availability and a database-wide value, enabling multiple computing threads to insert data independently without interfering with read operations.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Productivity
If multiple computing threads insert data into the same table simultaneously using traditional serial fashion, then database structure simplicity is maintained, but database performance significantly degrades when eight or more threads attempt insertion
Solution Approach 1:
The patent divides the row identifier space into multiple independently manageable partitions, each handled by a separate computing thread. This segmentation allows parallel insertion operations without threads conflicting over the same identifier range, thereby improving database insertion performance while maintaining manageable complexity through structured partition assignment
Solution Approach 2:
The patent introduces a new dimension to row identifier management by adding partition-level abstraction above the traditional flat row identifier space. This dimensional change enables concurrent access from multiple threads by operating at the partition level rather than the row level, resolving the performance degradation issue while keeping the underlying storage structure relatively simple
2Speed
If computing threads insert data in serial fashion one after another, then thread synchronization complexity is reduced, but insertion speed and database throughput significantly decrease
Solution Approach 1:
By segmenting the row identifier space into distinct partitions assigned to different computing threads, the patent enables simultaneous data insertion operations. Each thread operates independently on its assigned partition without requiring synchronization with other threads, thereby increasing insertion speed while avoiding the complexity of thread coordination protocols
Solution Approach 2:
Each computing thread autonomously selects and inserts data into rows within its assigned partition without requiring coordination or communication with other threads. This self-service approach eliminates synchronization overhead and complexity while maximizing insertion throughput through parallel execution
3Productivity
If the row identifier space is statically partitioned into sub-fragments for concurrent insertion, then parallel data insertion capability is improved, but memory store structure complexity increases
Solution Approach 1:
The patent segments the delta memory store into multiple sub-fragments corresponding to different partitions of the row identifier space. Each sub-fragment stores rows for a specific partition, enabling concurrent insertion operations across multiple threads while maintaining a structured and organized memory layout that balances complexity with performance benefits
Data Source
AI summary
The current subject matter describes static partitioning and sub-partitioning of a row identifier space associated with a table in a delta memory store of a database so as to allow data to be concurrently inserted into rows identified by the corresponding sub-partitions. A server system associated with the database can receive data to be inserted into a database. The server system can select a sub-fragment of a row identifier space identifying identifiers of rows stored in the database for the table. The sub-fragment can be selected based on a preference specified by an insert operation used for insertion of the data into the columnar database and on availability of the sub-fragment. The server system can insert the data in rows identified by the selected sub-fragment while other data is being concurrently inserted in rows identified by other one or more sub-fragments of the row identifier space.