Acceleration method for BTree batch deletion in database and related products

Abstract

The invention provides an acceleration method for BTree batch deletion in a database and a related product. The acceleration method for BTree batch deletion in the database comprises the following steps: receiving a BTree batch deletion request; converting the key value range corresponding to the batch deletion request into an interval set and inserting the interval set into an interval tree; and when key value query is carried out on the BTree, querying the interval tree and returning a corresponding query result. According to the scheme, invalid traversal and random I / O operation can be reduced; and the BTree batch deletion performance is obviously improved.

Description

Technical Field

[0001] This invention relates to the field of database technology, and in particular to a method and related products for accelerating batch deletion of B-trees in a database. Background Technology

[0002] B-trees, as self-balancing multi-way search trees, allow each node to store multiple key-value pairs and pointers to its child nodes. This structure makes it suitable for disk storage because it reduces the tree's height, thus requiring fewer disk I / O operations per query and improving efficiency. B-trees support both sequential and random access, which is helpful for reading contiguous blocks of data. In database systems, B-trees are widely used for efficient data storage and retrieval, supporting efficient inserts, point queries, and range queries.

[0003] However, when faced with batch deletion scenarios, the advantages of B-trees become disadvantages because the number of keys to be deleted is large and they are relatively scattered. The current common practice is to query and locate the keys to be deleted one by one before deleting them, or to traverse the leaf nodes in the B-tree to find the keys to be deleted and delete them.

[0004] Regarding deletion by deletion, firstly, the deletion operation requires traversing the path from the root to the leaves, querying layer by layer. For a tall B-tree, this can mean a lot of disk I / O operations, especially with large amounts of data. Since only one key-value pair can be deleted at a time, batch deletion requires this logic for each key-value pair, leading to a large amount of random I / O and a degraded overall performance. Secondly, deletion may cause nodes to merge or split. When handling large-scale deletions, frequent adjustments to the internal node structure are needed, which can increase system overhead. For example, if multiple leaf nodes are deleted, pointers to higher-level nodes may need to be updated, increasing the complexity and time of the operation. Furthermore, B-tree design optimizations prioritize insertion and query operations, with relatively less optimization for batch deletion operations. Therefore, the performance of traditional B-trees is affected when deleting large amounts of data.

[0005] Regarding traversal deletion, instead of querying each record one by one, it sequentially traverses the leaf nodes of the B-tree, reads all data blocks of the B-tree, and deletes the key-value pairs to be deleted one by one. Although this operation is sequential I / O, the amount of data read is relatively large, which is inefficient when dealing with batch deletion. Summary of the Invention

[0006] One object of the present invention is to provide a method for accelerating the batch deletion of B-trees in a database that can solve any of the above-mentioned problems.

[0007] A further objective of this invention is to reduce invalid traversals and random I / O operations.

[0008] Another further objective of this invention is to significantly improve the performance of B-Tree bulk deletion.

[0009] Specifically, the present invention provides a method for accelerating batch deletion of B-trees in a database, comprising: receiving batch deletion requests for B-trees; converting the key-value range corresponding to the batch deletion request into an interval set and inserting it into an interval tree; and when performing key-value queries on B-trees, first querying the interval tree and returning the corresponding query results.

[0010] Optionally, the key-value query includes: equality query, and when performing an equality query in BTree, the step of first querying the interval tree and returning the corresponding query result includes: determining whether the key value corresponding to the equality query exists in the interval tree; and if so, determining that the key value corresponding to the equality query has been deleted and directly returning the query result.

[0011] Optionally, if no key value corresponding to the equality query exists in the interval tree, query the key value corresponding to the equality query in the BTree and return the query result.

[0012] Optionally, the key-value query includes a range query, and when performing a range query in B-tree, the step of first querying the interval tree and returning the corresponding query result includes: determining whether there is a deleted interval in the interval tree that corresponds to the key-value range of the B-tree range query; and if so, skipping the deleted interval in the leaf node of the B-tree corresponding to the range query and querying and returning the query result.

[0013] Optionally, if no deleted interval exists in the interval tree, the corresponding leaf node is traversed to query the BTree range and the query result is returned.

[0014] Optionally, the accelerated method for batch deletion of B-trees in the database also includes: delaying the merging of the interval tree and B-trees when a preset condition is triggered, wherein the preset condition includes: manual command or scanning of the leaf nodes of the B-tree.

[0015] Optionally, when the preset condition is a manual command, the steps of delaying the merging of the interval tree and the B-tree include: physically deleting the key values ​​corresponding to all deleted intervals in the interval tree in the B-tree; and clearing the interval tree after the physical deletion of the key values ​​corresponding to all deleted intervals is completed.

[0016] Optionally, when the preset condition is to scan the leaf nodes of the B-tree, the step of delaying the merging of the interval tree and the B-tree includes: during the scanning of the leaf nodes of the B-tree, locating the deleted intervals in the interval tree that overlap with the key value range of the currently scanned leaf nodes; physically deleting the key values ​​corresponding to the overlapping deleted intervals in the B-tree; and after the physical deletion of the key values ​​corresponding to the overlapping deleted intervals is completed, deleting the overlapping deleted intervals in the interval tree.

[0017] According to another aspect of the present invention, a computer-readable storage medium is also provided, on which a computer program is stored, wherein the computer program, when executed by a processor, implements the steps of the accelerated method for batch deletion of B-trees in the database as described above.

[0018] According to another aspect of the present invention, a computer program product is also provided, comprising a computer program, characterized in that, when executed by a processor, the computer program implements the steps of the accelerated method for batch deletion of B-trees in the database as described above.

[0019] The accelerated method for batch deletion of B-trees in the database of the present invention receives batch deletion requests from B-trees, converts the key-value range corresponding to the batch deletion requests into an interval set and inserts it into an interval tree. When performing key-value queries in B-trees, the interval tree is queried first and the corresponding query results are returned, which can reduce invalid traversal and random I / O operations.

[0020] Furthermore, the accelerated method for batch deletion of B-trees in the database of the present invention reduces the time spent on multiple queries of B-trees to the time spent on a single insertion of an interval tree. Since the interval tree merges multiple key values, only one record needs to be inserted, thus significantly improving the performance of batch deletion of consecutive key values.

[0021] The above and other objects, advantages and features of the present invention will become more apparent to those skilled in the art from the following detailed description of specific embodiments of the invention in conjunction with the accompanying drawings. Attached Figure Description

[0022] The following sections will describe some specific embodiments of the invention in detail by way of example and not limitation, with reference to the accompanying drawings. The same reference numerals in the drawings denote the same or similar parts or portions. Those skilled in the art should understand that these drawings are not necessarily drawn to scale. In the drawings: Figure 1 This is a schematic flowchart of a method for accelerating the batch deletion of B-trees in a database according to an embodiment of the present invention; Figure 2 This is a detailed flowchart of a method for accelerating the batch deletion of B-trees in a database according to an embodiment of the present invention; Figure 3 This is a schematic diagram of a computer program product according to an embodiment of the present invention; Figure 4 This is a schematic diagram of a computer-readable storage medium according to an embodiment of the present invention; and Figure 5 This is a schematic diagram of a computer device according to an embodiment of the present invention. Detailed Implementation

[0023] Those skilled in the art should understand that the embodiments described below are merely a part of the embodiments of the present invention, and not all of the embodiments of the present invention. These partial embodiments are intended to explain the technical principles of the present invention and are not intended to limit the scope of protection of the present invention. Based on the embodiments provided by the present invention, all other embodiments obtained by those skilled in the art without creative effort should still fall within the scope of protection of the present invention.

[0024] It should be noted that the logic and / or steps represented in the flowchart or otherwise described herein, for example, can be considered as a sequenced list of executable instructions for implementing logical functions, and can be specifically implemented in any computer-readable medium for use by, or in conjunction with, an instruction execution system, apparatus or device (such as a computer-based system, a processor-included system or other system that can fetch and execute instructions from, an instruction execution system, apparatus or device).

[0025] The method for accelerating B-tree batch deletion in the database in this embodiment can reduce invalid traversal and random I / O operations, and significantly improve the performance of B-tree batch deletion. Figure 1 This is a schematic flowchart of a method for accelerating batch deletion of B-trees in a database according to an embodiment of the present invention, as shown below. Figure 1 As shown, methods to accelerate B-tree bulk deletion in a database generally include the following steps: Step S102: Receive B-tree bulk deletion requests.

[0026] Step S104: Convert the key-value range corresponding to the batch deletion request into a range set and insert it into the range tree.

[0027] In step S106, when performing a key-value query in BTree, the interval tree is queried first and the corresponding query results are returned.

[0028] It should be noted that the B-tree in this embodiment is a self-balancing, multi-way search tree with branching paths, widely used in databases and file systems for efficient storage and retrieval of large amounts of data. The interval tree is a dynamic collection data structure used to store and manage interval data, supporting efficient interval queries, insertions, and deletions. Specifically, the interval tree uses [start, end] interval storage keys, enabling efficient handling of overlapping and containment queries. Its advantages include small storage space and the ability to quickly find overlapping intervals within a given range.

[0029] Specifically, step S102 receives a batch deletion request for BTree, for example, by performing deletion via BETWEEN AND.

[0030] The key-value query in step S106 can include an equality query. When performing an equality query in the B-tree, the step of first querying the interval tree and returning the corresponding query result can include: determining whether the key-value corresponding to the equality query exists in the interval tree; and if so, determining that the key-value corresponding to the equality query has been deleted and directly returning the query result. Furthermore, if the key-value corresponding to the equality query does not exist in the interval tree, querying the key-value corresponding to the equality query in the B-tree and returning the query result.

[0031] The key-value query in step S106 may further include a range query. When performing a range query on the B-tree, the step of first querying the interval tree and returning the corresponding query result may include: determining whether a deleted interval exists in the interval tree corresponding to the key-value range of the B-tree range query; and if so, skipping the deleted interval in the leaf nodes of the B-tree corresponding to the range query and returning the query result. Furthermore, if no deleted interval exists in the interval tree, traversing the leaf nodes corresponding to the B-tree range query and returning the query result.

[0032] Specifically, the accelerated method for batch deletion of B-trees in the database in this embodiment may further include: delaying the merging of the interval tree and the B-tree when a preset condition is triggered, wherein the preset condition includes: manual command or scanning of the leaf nodes of the B-tree.

[0033] When the preset condition is manual command, the steps for delayed merging of the interval tree and B-tree may include: physically deleting the key values ​​corresponding to all deleted intervals in the interval tree in the B-tree; and clearing the interval tree after the physical deletion of the key values ​​corresponding to all deleted intervals is completed.

[0034] When the preset condition is to scan the leaf nodes of the B-tree, the steps of delaying the merging of the interval tree and the B-tree may include: during the scanning of the leaf nodes of the B-tree, locating the deleted intervals in the interval tree that overlap with the key value range of the currently scanned leaf nodes; physically deleting the key values ​​corresponding to the overlapping deleted intervals in the B-tree; and after the physical deletion of the key values ​​corresponding to the overlapping deleted intervals is completed, deleting the overlapping deleted intervals in the interval tree.

[0035] In this embodiment, by receiving batch deletion requests from B-trees, the key-value range corresponding to the batch deletion requests is converted into a set of intervals and inserted into an interval tree. When performing key-value queries in B-trees, the interval tree is queried first and the corresponding query results are returned, which can reduce invalid traversal and random I / O operations. The time consumed by multiple queries in B-trees is reduced to the time consumed by one insertion in the interval tree. Since the interval tree merges multiple key-values, only one record needs to be inserted, so the performance of batch deletion of consecutive key-values ​​is significantly improved.

[0036] Figure 2 This is a detailed flowchart of a method for accelerating batch deletion of B-trees in a database according to an embodiment of the present invention. Figure 2 As shown, the scheduling module coordinates the three major processes of batch deletion, query, and delayed merging. The left side corresponds to the interval tree construction step, the middle part corresponds to the interval tree usage step, and the right side corresponds to the delayed merging step.

[0037] The batch deletion process on the left mainly involves identifying the batch deletion requests, generating the key-value ranges to be deleted, inserting these ranges into the interval tree, and then returning without manipulating the B-tree. Specifically, it involves constructing the interval tree, receiving batch deletion requests (e.g., using BETWEEN AND), converting the batch deletion key-value ranges into interval sets, and inserting them into the interval tree.

[0038] The process for querying key-value pairs in the middle section involves first searching the interval tree. If the queried key-value pair exists in the interval tree, it is considered a deleted key-value pair and returned directly. If it does not exist in the interval tree, a B-tree query is performed, and the result is returned. Specifically, to implement the use of the interval tree, equality queries first query the interval tree; if the key-value pair exists in the interval tree, it is determined to be a deleted key. For range queries, based on the key-value pair of the leaf node, the deleted interval is retrieved from the interval tree, and the deleted interval is skipped at the leaf node for further querying.

[0039] The delayed merge process on the right, when triggered by preset conditions, involves traversing the interval tree during the merge, querying the key-value pairs within it in the B-tree, and physically deleting them until the interval tree is empty, at which point the merge is complete. Specifically, to implement delayed merging of the interval tree and B-tree, a manual command is used to physically delete the ranges in the interval tree from the B-tree, simultaneously deleting the interval tree itself. During the scanning of leaf nodes, the key-value pairs of the deleted intervals in the interval tree are physically deleted, and the nodes in the interval tree are also deleted.

[0040] Specifically, the preset conditions for triggering delayed merging can be divided into active triggering and automatic triggering. Active triggering includes triggers initiated by the user / system, such as manual command triggering. Automatic triggering includes triggers automatically determined by the system based on the status, such as B-tree leaf node scanning triggering, triggering after batch deletion, and triggering when the system is idle.

[0041] It is important to emphasize that the solution in this embodiment implements a collaborative design of the interval tree and B-tree, as well as a delayed merging strategy. The collaborative design of the interval tree and B-tree includes: using the interval tree as an auxiliary index in the B-tree to store deleted key values, transforming B-tree batch deletions into interval tree insertions. When querying the B-tree, the query first checks the interval tree; if a match is found in the interval tree, it is determined to be a deleted key, and there is no need to query the B-tree again. The delayed merging strategy includes: when merging is triggered under preset conditions, the key value intervals in the interval tree are physically deleted from the B-tree, and the interval tree is cleared.

[0042] In this embodiment, a range tree is used to manage the range of deleted key values. When deleting a range in the B-tree, a new range is inserted into the range tree. When querying the B-tree, the range tree is used to quickly determine whether the key value has been deleted. This method improves the performance of batch deletion. However, for queries that exist, the range tree needs to be queried first and then the B-tree, which incurs some performance overhead. To minimize this overhead, the range tree and B-tree need to be continuously merged. The key values ​​in the range tree range are physically deleted in the B-tree. When a preset condition triggers the merging, the range tree and B-tree are merged with a delay.

[0043] The solution in this embodiment reduces the time spent on multiple B-tree queries to the time spent on a single insertion in a range tree. Specifically, the time complexity of multiple B-tree queries is: M*O(log N) + H*IO, where M is the number of keys to be deleted, H is the height of the B-tree, and IO is the disk read time; the time complexity of inserting a record in a range tree is: O(log N). Since the range tree merges multiple keys, only one record needs to be inserted, thus significantly improving the performance of batch deletion of consecutive keys.

[0044] It should be noted that in some other embodiments, a Bloom filter can be used instead of a range tree. A Bloom filter can use multiple hash functions to map key-value pairs to a single value, performing fast NOT determination with minimal memory and constant time. When the deleted key-value pairs are too scattered to form continuous ranges, using a Bloom filter can quickly determine whether a key-value pair has not been deleted with minimal memory usage. If it has not been deleted, a B-tree query can be performed, which can also improve the performance of batch deletion.

[0045] The flowcharts provided in the above embodiments are not intended to indicate that the operations of the method will be performed in any particular order, or that all operations of the method are included in all every case. Furthermore, the method may include additional operations. Within the scope of the technical concept provided by the methods in the above embodiments, additional variations can be made to the above methods.

[0046] This embodiment also provides a computer program product, a computer-readable storage medium, and a computer device. Figure 3 This is a schematic diagram of a computer program product 500 according to an embodiment of the present invention. Figure 4 This is a schematic diagram of a computer-readable storage medium 300 according to an embodiment of the present invention. Figure 5 This is a schematic diagram of a computer device 400 according to an embodiment of the present invention.

[0047] Computer program product 500 includes computer program 310, which, when executed by processor 410, implements the steps of the accelerated B-tree bulk deletion method in the database according to any of the above embodiments. Computer-readable storage medium 300 stores the computer program 310 thereon, which, when executed by processor 410, implements the steps of the accelerated B-tree bulk deletion method in the database according to any of the above embodiments. Computer device 400 may include memory 420, processor 410, and computer program 310 stored in memory 420 and running on processor 410.

[0048] The computer program 310 used to perform the operations of the present invention may be assembly instructions, instruction set architecture (ISA) instructions, machine instructions, machine-related instructions, microcode, firmware instructions, status setting data, integrated circuit configuration data, or source code or object code written in any combination of one or more programming languages ​​and procedural programming languages.

[0049] Computer program 310 may execute entirely on the user's computer, partially on the user's computer, as a standalone software package, partially on the user's computer and partially on a remote computer, or entirely on a remote computer or server. In the latter case, the remote computer may be connected to the user's computer via any type of network, including a local area network (LAN) or a wide area network (WAN), or may be connected to an external computer (e.g., via the Internet using an Internet service provider).

[0050] In some embodiments, in order to perform aspects of the present invention, electronic circuits including, for example, programmable logic circuits, field-programmable gate arrays (FPGAs) or programmable logic arrays (PLAs) can execute computer-readable program instructions to personalize the electronic circuits by utilizing state information of computer-readable program instructions.

[0051] For the purposes of this embodiment, computer program product 500 is a related product containing computer program 310. For the purposes of this embodiment, computer-readable storage medium 300 is a tangible device capable of holding and storing computer program 310, and can be any device capable of containing, storing, communicating, propagating or transmitting computer program 310 for use by or in conjunction with an instruction execution system, apparatus or device.

[0052] More specific examples (a non-exhaustive list) of computer-readable storage media 300 include the following: portable computer disks, hard disks, random access memory (RAM), read-only memory (ROM), erasable programmable read-only memory (EPROM or flash memory), static random access memory (SRAM), portable optical disc read-only memory (CD-ROM), digital multifunction disc (DVD), memory sticks, floppy disks, mechanical encoding devices, and any suitable combination of the foregoing.

[0053] Computer device 400 may include memory 420, processor 410, and computer program 310 stored on memory 420 and running on processor 410. When processor 410 executes computer program 310, it implements the steps of the accelerated method for bulk deletion of B-trees in the database according to any of the above embodiments.

[0054] It should be noted that the logic and / or steps represented in the flowchart or otherwise described herein, for example, can be considered as a sequenced list of executable instructions for implementing logical functions, and can be specifically implemented in any machine-readable storage medium for use by, or in conjunction with, instruction execution systems, apparatuses or devices (such as computer-based systems, processor-based systems or other systems that can fetch and execute instructions from, or instruction execution systems, apparatuses or devices).

[0055] It should be understood that various parts of the present invention can be implemented using hardware, software, firmware, or a combination thereof. In the above embodiments, multiple steps or methods can be implemented using software or firmware stored in memory and executed by a suitable instruction execution system.

[0056] Computer device 400 can be, for example, a server, desktop computer, laptop computer, tablet computer, or smartphone. In some examples, computer device 400 can be a cloud computing node. Computer device 400 can be described in the general context of computer system executable instructions (such as program modules) executed by a computer system. Typically, program modules can include routines, programs, object programs, components, logic, data structures, etc., that perform specific tasks or implement specific abstract data types. Computer device 400 can be implemented in a distributed cloud computing environment where tasks are performed by remote processing devices linked through a communication network. In a distributed cloud computing environment, program modules can reside on local or remote computing system storage media, including storage devices.

[0057] Computer device 400 may include a processor 410 adapted to execute stored instructions and a memory 420 that provides temporary storage space for the operation of instructions during operation. The processor 410 may be a single-core processor, a multi-core processor, a computing cluster, or any other configuration. The memory 420 may include random access memory (RAM), read-only memory, flash memory, or any other suitable storage system.

[0058] The processor 410 can be connected via a system interconnect (e.g., PCI, PCI-Express, etc.) to an I / O interface (input / output interface) suitable for connecting the computer device 400 to one or more I / O devices (input / output devices). I / O devices may include, for example, a keyboard and indicating devices, where indicating devices may include a touchpad or touchscreen, etc. I / O devices may be built into the computer device 400 or may be external devices connected to the computing device.

[0059] The processor 410 may also be linked via a system interconnect to a display interface suitable for connecting the computer device 400 to a display device. The display device may include a display screen as a built-in component of the computer device 400. The display device may also include an external computer monitor, television, or projector connected to the computer device 400. Furthermore, a network interface controller (NIC) may be adapted to connect the computer device 400 to a network via a system interconnect. In some embodiments, the NIC may use any suitable interface or protocol (such as an Internet Minicomputer System Interface) to transmit data. The network may be a cellular network, a radio network, a wide area network (WAN), a local area network (LAN), or the Internet, etc. Remote devices may connect to the computing device via the network.

[0060] Therefore, those skilled in the art should recognize that although numerous exemplary embodiments of the present invention have been shown and described in detail herein, many other variations or modifications conforming to the principles of the present invention can be directly determined or derived from the disclosure of the present invention without departing from the spirit and scope of the invention. Thus, the scope of the present invention should be understood and construed as covering all such other variations or modifications.

Claims

1. A method for accelerating batch deletion of B-trees in a database, comprising: Receive the batch deletion request for the B-tree; Convert the key-value range corresponding to the batch deletion request into a range set and insert it into the range tree; as well as When performing a key-value query on the BTree, the interval tree is queried first and the corresponding query results are returned.

2. The method according to claim 1, wherein, The key-value query includes an equality query, and when performing the equality query on the BTree, the step of first querying the interval tree and returning the corresponding query result includes: Determine whether the key value corresponding to the equality query exists in the interval tree; and If so, determine that the key value corresponding to the equality query has been deleted and directly return the query result.

3. The method according to claim 2, wherein, If the key value corresponding to the equality query does not exist in the interval tree, query the key value corresponding to the equality query in the BTree and return the query result.

4. The method according to claim 1, wherein, The key-value query includes a range query, and when performing the range query on the BTree, the step of first querying the interval tree and returning the corresponding query result includes: Determine whether there exists a deleted interval in the interval tree that corresponds to the key value range of the B-tree range query; and If so, skip the deleted interval in the leaf node corresponding to the BTree and the range query, perform the query, and return the query result.

5. The method according to claim 4, wherein, If the deleted interval does not exist in the interval tree, the leaf nodes corresponding to the BTree range are traversed to perform the query and the query result is returned.

6. The method according to claim 1, further comprising: When a preset condition is triggered, the interval tree and the B-tree are merged with a delay, wherein the preset condition includes: a manual command or scanning of the leaf nodes of the B-tree.

7. The method according to claim 6, wherein, When the preset condition is a manual command, the step of performing a delayed merging of the interval tree and the B-tree includes: Physically delete the key values ​​corresponding to all deleted intervals in the interval tree within the BTree; and After all the key values ​​corresponding to the deleted intervals have been physically deleted, the interval tree is cleared.

8. The method according to claim 6, wherein, When the preset condition is to scan the leaf nodes of the B-tree, the step of delaying the merging of the interval tree and the B-tree includes: During the scanning of the leaf nodes of the BTree, the deleted intervals in the interval tree that overlap with the key value range of the currently scanned leaf node are located. The key values ​​corresponding to the overlapping deleted intervals are physically deleted in the BTree; and After the physical deletion of the key values ​​corresponding to the overlapping deleted intervals is completed, the overlapping deleted intervals in the interval tree are deleted.

9. A computer-readable storage medium having a computer program stored thereon, the computer program being executed by a processor to implement the steps of the accelerated method for bulk deletion of B-trees in a database as described in any one of claims 1 to 8.

10. A computer program product, comprising a computer program, characterized in that, When executed by a processor, the computer program implements the steps of the accelerated method for bulk deletion of B-trees in the database as described in any one of claims 1 to 8.

Images