KR20010066737A - A concurrency control method for high-dimensional index structures - Google Patents

Abstract

PURPOSE: A method for controlling a consistency of a higher-order index structure is provided to increase the performance of a search by obtaining a latch of a common mode in case that a search operation is performed, thereby preventing a delay from being generated from an insertion to a node or a lock of a deletion operation. CONSTITUTION: A route node is stored in a queue(910). A common lock is obtained(912). It is judged whether the queue is empty(914). In case that the queue isn't empty, a node is picked out from the queue and set as a current node(916). In case that the queue is empty, a lock to a reinsertion node is released. In addition, a search is terminated(938). It is judged whether a level of the current node is lower than a present level(918). A common latch is obtained(928). It is judged whether the current node is a terminal(930). In case that the current node isn't the terminal, child nodes in a range of question are put in(932). The common latch is released(936).

Description

A concurrency control method for high-dimensional index structures

The present invention relates to a method for controlling concurrency of a database. In particular, an existing high-dimensional index structure (R * -tree, SS-tree, which performs reinsertion of some objects in a node when the capacity of the node is exceeded and overflow occurs. TV-Tree, X-Tree, CIR-Tree). More specifically, the present invention relates to a technique for searching for objects deleted from any node of the index tree for reinsertion during a reinsertion operation.

Over the last few years, similarity search based on multidimensional feature vectors has been a very important task in the database field. Its applications range from geographic information systems to medical data storage systems to multimedia database systems. One of the most important problems of this similarity search is how to efficiently find queries and similar objects among numerous multidimensional data. In order to solve this problem, researches on multidimensional index structures have been actively conducted, and as a result, Grid File, Multi-level Grid File, R-Tree, R * -Tree, TV-Tree, X-Tree, SS-Tree, Many index structures have been proposed, such as SR-Tree, CIR-Tree and Hybrid-Tree. In order for existing multidimensional index structures to be used in actual applications, a multi-user environment in which multiple users can insert and search simultaneously must be considered. In other words, there should be an appropriate concurrency control algorithm for the index structure.

Most index structures are represented in tree form (hereinafter referred to as index tree). Each component of an index tree is called a node, and they form an index tree in a hierarchical structure. The index tree is composed of operations such as inserting and deleting objects, and the inserted objects are inserted by nodes according to a predetermined rule.

In addition, only a certain number of objects can be inserted into each node of the index tree, and when the capacity is exceeded, the node overflows. At this time, some objects in the overflowed node can be selected and reinserted into the index tree one by one to improve performance.

On the other hand, the study on the concurrency control method for the conventional index structure is mainly about the B-tree targeting the one-dimensional data, the concurrency control method for the R-tree which is an index structure for managing high-dimensional data This began to be studied some time ago.

The concurrency control algorithms for the existing multidimensional index structures can be classified into two methods, one based on the locking coupling technique and the other based on the link technique. Lock concurrency-based concurrency control algorithms acquire locks on the next node to visit before releasing the lock of the current node when traversing the tree. In addition, when performing node splitting or reflecting a minimum bounding region (MBR) change to a higher node, locks on all nodes participating in the change should be obtained. This method results in a decrease in concurrency performance because a transaction must hold a lock on multiple nodes at the same time during a search or insert operation.

In order to solve this problem, a concurrency control algorithm based on link technique has been proposed. From these conventional studies, the concurrency control method using the link method rather than the lock coupling method has proved to be superior in performance. The concurrency control algorithm based on the link technique does not need to perform lock combining. That is, only one node needs to acquire a lock while traversing the tree. However, it is still necessary to acquire locks on multiple nodes at the same time when performing a minimum boundary change or partition operation.

The basic concept of the linking scheme is to connect all nodes of each level through the right link so that the partition of the lower node that is not reflected in the upper node can be compensated for without compromising the lock even during the search operation. In R ^LINK -Tree, due to structural differences between R-Tree and B-Tree, the linking technique of B ^LINK -Tree has been modified and supplemented. In this process, the node serial number was introduced and assigned to each node, and the structure of the entry was changed from <MBR, Child_Page> to <MBR, Child_Page, NSN>. The node serial number is incremented when a node is newly created. Each node is assigned a unique node serial number. When a node is split, it assigns the node serial number of the old node to the new node and the new node serial number to the existing node. The newly created node is always located to the right of the existing node. Therefore, the search operation can determine whether the child node is split when traversing the tree with this node serial number. That is, the search processor that stores the node serial number recorded in the parent node's entry <MBR, Child_Page, NSN> is right if the actual node serial number of the child node (Child_Page) corresponding to the entry is larger than the stored value. Go to. When you meet the nodes with the node serial number that you remember while moving, it stops moving to the side and proceeds to the lower node again.

This method has some disadvantages. First, when a transaction performs operations that change the tree structure (node split and minimum boundary change), locks must be held on more than one level of nodes at the same time, which causes the I / O when the search operation proceeds to the next node. May be delayed over time. Second, as the data structure representing the entry is changed to <MBR, Child_Page, NSN>, additional information of the node serial number decreases the storage space utilization and reduces the fan out of non-terminal nodes. .

An improved method solves the problem of wasting storage space by adding the node serial number to the data structure of the entry pointed out as a problem in the above method. As with R ^LINK -Tree, the improved method also assigns a node serial number to each node, places a right link to check for partitioning, and determines how far along the right link to traverse. However, unlike R ^LINK -Tree, it is proposed a method of determining the division of a lower node without recording the node serial number of the lower node in the entry of the non-terminal node. This is done by assigning a node serial number using the global counter.

When a node is partitioned, the node is given the node serial number value of the original node and the original node is assigned a new node serial number value. At this time, the tree traversal operation remembers the value of the global counter when visiting a node and compares the value of the global counter remembered when visiting a lower node with the node serial number of the current node. It determines that the partition is not reflected in the upper node, and moves along the right link. When a node encounters a node with a node serial number smaller than the global counter value it remembers, it stops moving to the neighbor node and continues to traverse to the lower node. This method also has a problem. When using the global counter, when dividing a node, it is necessary to acquire a lock on the parent node and proceed with partitioning before partitioning the current node. In addition, for recovery purposes, a lock is held on all nodes participating in the partition until the partition is finished. This may delay the search operation for a longer time.

Accordingly, an object of the present invention is to provide a method of preventing the problem of deteriorating storage efficiency by including a node serial number in an entry of a terminal node using a log serial number as a global counter, and deleting an entry from a tree for reinsertion. Is stored in a specific node (reinsertion node) so that the search operation can refer to it.

It is still another object of the present invention to provide a method in which a lock on an index node does not affect the search operation at all by using a latch and a lock.

In addition, another object of the present invention is to provide a high search performance because no delay occurs due to locking of an insert or delete operation to a node because only a latch of a shared mode is obtained to a node to be accessed when a search operation is performed.

1 is a diagram illustrating a tree structure showing a problem of path loss when an insert, delete, and reinsert operation is simultaneously performed according to the present invention.

2 is a diagram showing the configuration of a subroutine constituting an insert operation according to the present invention;

3 is a flow chart illustrating the operation of an insert operation in accordance with the present invention.

4 is a flow chart illustrating the operation of a find node (FindNode) that is one of the subroutines of an insert operation according to the present invention.

FIG. 5 is a flowchart illustrating the operation of an operation (TreatOverflow) for handling the overflow of a node which is one of the subroutines of an insert operation according to the present invention. FIG.

6 is a flow chart illustrating the operation of an operation Reinsert for reinsertion, which is one of the subroutines of an insert operation in accordance with the present invention.

7 is a flow chart illustrating the operation of Split, which splits a node which is one of the subroutines of an insert operation in accordance with the present invention.

8 is a diagram illustrating a tree structure for explaining a process of requesting a conditional exclusive lock to a parent node in a path stack during a overflow operation in a non-terminal node according to the present invention.

9 is a flow chart illustrating the operation of a Search operation in accordance with the present invention.

10 is a flowchart illustrating the operation of the delete operation.

<Explanation of symbols for the main parts of the drawings>

200... Module of insert operation

In order to achieve the above object, according to an embodiment of the present invention, storing the root node in a queue; Obtaining a shared lock on the reinsert node; Determining whether the queue is empty and taking one node from the queue as the current node if it is not empty, and if the queue is empty, unlocking the reinsert node and ending the search; Acquiring a shared latch at the current node, selecting subqueues in the query range, and enqueuing; A concurrency controlled search method is provided which comprises returning to performing the step of determining whether the queue is empty.

According to an embodiment of the present invention, a first step of finding a terminal node to insert a new entry; Determining whether an overflow occurs when an entry is inserted into the found terminal node; As a result of the determination of the determination step, if overflow occurs, a tree lock is obtained, the node overflow of the terminal node to be inserted is processed, the tree lock is released, and as a result of the determination of the determination step, the insertion is not performed. Inserting a new entry into the terminal node to be performed, and if the minimum boundary region is changed due to the insertion, acquiring the tree lock, propagating the change of the minimum boundary region to the upper side, and then releasing the tree lock. Provide a method.

According to another embodiment of the present invention, there is provided a structure readable by a data processing apparatus, the function of storing a root node in a queue; Obtaining a shared lock on the reinsert node; Determining whether the queue is empty and taking one node from the queue as the current node if it is not empty, and if the queue is empty, unlocking the reinsert node and ending the search; Acquiring a shared latch at the current node, selecting subqueues in the query range, and enqueuing; A storage medium for recording a program capable of realizing a function of returning to the step of determining whether the queue is empty is provided.

According to still another embodiment of the present invention, there is provided an apparatus, which has a structure readable by a data processing apparatus, the function of finding a terminal node into which a new entry is to be inserted; Determining whether an overflow occurs when an entry is inserted into the found terminal node; A function of processing a node overflow of the terminal node to be inserted and releasing the tree lock after acquiring a tree lock when the overflow occurs as a result of the determination of the determination function; And if it is determined that the overflow does not occur, a new entry is inserted into the terminal node to be inserted. If the minimum boundary region is changed due to the insertion, a tree lock is acquired and the change of the minimum boundary region is propagated upward. A computer readable storage medium having recorded thereon a program for realizing a function of releasing a tree lock is provided.

Recently proposed high-dimensional index structures (R * -tree, TV-tree, X-tree, SS-tree, CIR-tree) select some of the entries included in the node when it overflows to improve performance. Reinsert them into the index tree one by one. At this time, the entries selected for reinsertion are actually deleted from the index tree, and the entries during reinsertion cannot be searched. In general, the reinsertion time is very long and will cause serious errors if the reinserted objects cannot be navigated during this time.

The present invention relates to an effective concurrency control method for a high-dimensional index structure. In order to enable retrieval of entries to be reinserted even during a reinsert operation, the reinsert node after storing the deleted entries in the reinsert node Search by allowing to search.

The present invention is based on the link technique used in the R ^LINK -tree. In other words, by using a method of assigning a node serial number using a global counter, a logical serial number is included in an entry of a non-terminal node, thereby preventing a problem of reducing storage efficiency. However, the present invention provides a method of using a log serial number as a global counter unlike the existing method. The log serial number is monotonically increasing like the logical serial number and never decreases.

In the R ^LINK -tree using the existing linking technique, when performing an insert or delete operation that changes the structure of the tree, the structure of the R-tree family must lock the index node to ensure the tree consistency. Because, if you do not lock the index node, the insert or delete operation in the subtree that is the root node of the node where the reinsert operation is performed attempts to change the minimum boundary area information due to the insertion or deletion as it goes up the tree. This is because the path can be lost.

In the present invention, in order to solve the path loss problem, a lock and a latch are mixed with an index node. A latch on a node of an index structure is intended to synchronize the multiple transactions (or processes) when accessing a node of the index structure and to ensure physical consistency of the node. In the present invention, a shared lock is obtained at all nodes passing through the tree to insert and delete nodes, and the shared lock is released at the end of the transaction. Subsequently, if a reinsertion occurs while attempting to change the minimum boundary area due to insertion or deletion while going up the tree, a path loss problem may occur. Accordingly, in the present invention, in order to prevent the loss of the path due to the reinsertion, it is required to acquire the exclusive mode lock (hereinafter exclusive lock) to the node to be reinserted before the reinsertion occurs, and when the exclusive lock is not obtained, the reinsertion is performed. Perform the split without doing In the present invention, the lock on the index node does not affect the search operation at all. In the present invention, since the search operation acquires only the latch of the shared mode (hereinafter referred to as the shared latch) to the node to which the node tries to access, there is no delay due to the lock of the insert or delete operation on the index node. In the present invention, the locking on the index node middle root node has a special meaning. The root lock is used to implement a tree lock. The concurrency control technique provided by the present invention performs an overflow processing operation (including a reinsert operation or a division operation) or a minimum boundary area change operation in series. At this time, the tree lock is used as a method of performing them in series. In other words, a transaction causes the node to overflow during the execution of the insert operation and first acquires the tree lock in the write mode. Acquiring the tree lock causes other transactions to wait while the transaction is being executed, even if the overflow occurs or the minimum boundary is changed. Other insert operations that do not cause overflow can be performed without acquiring a tree lock, and search operations can also be performed.

The present invention provides a reinsert operation with concurrency controlled using a reinsert node. Stores entries deleted from the tree for reinsertion in a given area so that the search operation can refer to them. In the present invention, deleted entries are stored in a specific node (reinsertion node), and the search operation can refer to this. In the present invention, only one reinsert node is allocated to each index structure. This is because an overflow processing operation or a minimum boundary area change operation that can occur at the same time is limited to one. That is, because the number of re-insertion operations that can occur at the same time is limited to one.

In the present invention, a transaction performing an insert operation is guaranteed to hold a latch only at a node of at most one level. Although the logical serial number is assigned to the node using the global counter, the tree lock does not need to acquire the latch in advance in the parent node because the partition and the minimum boundary area change operation are limited to one at the same time. This prevents the long delay time during the search operation.

Next, preferred embodiments of the present invention will be described in detail with reference to the accompanying drawings.

1 illustrates a tree structure showing a problem of path loss that occurs when insert, delete, and reinsert operations according to the present invention are performed at the same time.

Referring to FIG. 1, a path loss occurs in transactions T1, T2, and T3. In transaction T1, a new entry is inserted into node P4, and the node P2 is accessed to modify the entry for node P4. In transaction T2, the entry for the node P4 is deleted while performing the reinsert operation on the node P2. In transaction T1, the entry is lost for node P4 at node P2, and the path is lost.

2 shows a configuration of an insert operation according to the present invention.

Referring to FIG. 2, the insert operation 300 includes a findNode 400, a overflowover 500, a reinsert 600, a split 700, and a reinsert. It consists of SplitAll and Minimum Boundary Area Change (FixMBR) operations during an insert operation.

The findNode operation 400 functions to find an appropriate node where an entry to be inserted is to be located. The overflow processing 500 performs a function of determining whether to perform a split or a reinsert operation when a node overflows. The reinsert operation 600 is a function that is called when the overflow generated in the overflowover operation 500 is to be processed by reinsertion. This function selects and deletes reinsert entries from the overflowed node and inserts them into the index tree. The SplitAll operation in the reinsert operation is the same as the Split operation 700 except that a lock is not allocated by treating a split when the overflow occurs during the reinsertion. The reason why the lock is not allocated in the splitAll operation during the reinsert operation is that the lock is already acquired because the operation occurs during the reinsert operation.

3 is a flow chart illustrating the operation of an Insert operation in accordance with the present invention.

Referring to FIG. 3, the Insert algorithm begins by finding a terminal node to insert a new entry (FindNode) 310. In step 312, it is determined whether there is enough space to insert an entry in the newly found terminal node. If there is not enough space in the newly found terminal node as a result of the determination, a tree lock is acquired in step 314 and overflow processing is performed in step 316 (TreatOverflow). Then, after unlocking the tree in step 318, all the nodes obtained in step 334 are unlocked. If there is enough space to insert an entry in the newly found terminal node, the following processing is performed. In step 320, a new entry is inserted into the terminal node. In step 322, it is determined whether the minimum boundary area of the terminal node has changed. If the minimum boundary area has been changed, the tree lock is acquired in step 324, the exclusive latch of the terminal node is released in step 326, the minimum boundary area change is performed in step 328 (FixMBR), and the tree lock is released in step 330. In step 334, all the nodes obtained in the lock are released and the insertion operation is terminated. If the minimum boundary area has not been changed, after releasing the exclusive latch of the terminal node in step 332, all locks acquired in step 334 are released and the insertion operation is terminated.

4 is a flowchart illustrating a method (FindNode) 400 for finding a terminal node into which a new entry is to be inserted.

Referring to FIG. 4, the method provides a method of finding a child node most appropriate for an entry to be newly inserted in a current node CurNode. In step 410, the current node is set as a root node, and a shared latch is obtained at the current node. In step 412, after finding the most appropriate child node to insert an entry in the current node, in step 414, the shared latch of the current node is released. In step 416, it is determined whether the level of the child node is the same as the target level to be found. If the determination result is the same, the exclusive latch and the exclusive lock are obtained at the child node in step 418. If the determination result is not the same, the sharing latch and the sharing lock is acquired at the child node in step 420. In step 422, it is determined whether the logical serial number of the child node is greater than the log serial number of the current node. As a result of the determination, if there is a partition that is not reflected to the upper side, a more appropriate node among the divided nodes is selected while following the right link of the child node in step 424, and the exclusive node is selected after the node selected in step 426 is a child node. Acquire exclusive locks or shared latches and shared locks. The mode of acquiring the latch and the lock is the same as the determination result of step 416. In step 428, it is determined whether the level of the child node is the same as the target level. If the determination is not the same, in step 430, the child node is put in the path stack, in step 432, the current node is set as the child node, and the process returns to step 412. If the result of the determination of step 428 is the same, the child node and the path stack are returned in step 432. All nodes except the root node included in the path stack returned as a result of performing the find node operation 400 are locked. That is, the terminal node is locked in the write mode, and the non-terminal node is locked in the shared mode. In addition, the terminal node is subjected to exclusive latch.

FIG. 5 is a flowchart illustrating an operation of an operation (TreatOverflow) for handling overflow of a node which is one of subroutines of an insert operation according to the present invention.

Referring to FIG. 5, the overflow processing operation 500 provides a method of processing when a node does not have free space to accommodate a new entry.

In step 510, it is determined whether the current node is the root node. If it is determined that the root node is the root node, the root split is performed in step 534, and in step 536, the entry made to perform the split is inserted and terminated. If the determination result is not the root node, in step 512, a conditional exclusive lock is requested to the current node. In step 514, it is determined whether the current node has obtained the exclusive lock. If the exclusive lock is obtained as a result of the determination, the reinsert operation 600 is called at step 518, and if not, the split operation 700 is called at step 516. In the case of the terminal node, when the find node operation (FindNode) operation 400 is performed, an exclusive lock is obtained in the terminal node, so that all overflows lead to reinsertion. In the non-terminal node, when another transaction performs an insert or delete operation in the subtree having the non-terminal node as the root node, the non-terminal node performs partitioning without performing reinsertion. If the reinsert operation 600 is called, the next operation is determined according to how the reinsert operation 600 ends. First, in step 520, it is determined whether the current node is a terminal node, and if it is a terminal node, the exclusive latch of the current node is released, and if it is a non-terminal node, the exclusive lock of the current node is released. If the overflow occurs in the current node in the reinsert operation 600, the process ends. If the current node overflows and Split is performed, in step 524, a parent node is read from the path stack. In step 526, it is checked whether there is free space for inserting a divided entry in the parent node. If there is no free space to reflect the division in the parent node, in step 528, the current node is set as the parent node, and then the flow returns to the beginning of the overflow processing operation 500 (step 510), and reinsertion or division is performed. Determine. If there is sufficient free space to reflect the division in the parent node, insert the divided entry in the parent node in step 530, perform a minimum boundary area change operation on the ancestor node in step 532, and in step 536 Insert and exit the entry that caused the overflow to perform the split.

If the split operation 700 is called because the lock is not acquired on the current node in step 514, the parent node is read from the path stack in step 524, and the following operation 526 is performed to reflect the split result. .

6 is a flowchart illustrating an operation of a reinsert operation, which is one operation of an insert operation according to the present invention.

Referring to FIG. 6, the reinsert operation 600 first requests conditional exclusive locks to the reinsert nodes allocated to the index structure one by one in step 610, and then performs reinsertion when the exclusive lock is obtained as a result of the request. If not, in step 612, the exclusive latch is released to the current node, and an unconditional exclusive lock is requested to the current node to acquire it, and then the exclusive latch is acquired to the current node and reinsertion is performed.

In step 614, the reinsertion entry is selected, deleted from the current node, and the deleted entries are recorded in the reinsertion node. At this time, the first record of the reinsert node is calculated and stored at the level where the current reinsert occurs, the identifier of the node, and the minimum boundary area of the reinsert entry. In step 616, the number of the deleted reinsert entries is recorded in the current node. The number serves as a counter for inserting the deleted reinsert entries into the index tree one by one. In step 618, the exclusive latch of the reinsert node and the current node is released. In step 620, the changed minimum boundary area of the current node is reflected to the ancestor node (that is, calling the FixMBR operation). When this is done, insert reinsert entries into the index tree one by one. In step 622, it is determined whether all deleted entries have been inserted into the index tree. The determination can be made by determining whether the reinsertion entry number field value of the current node is zero. If all of the entries are inserted as a result of the determination, in step 640, the exclusive lock of the reinsert node is released, and then the reinsertion operation 600 is terminated. If all the entries are not inserted as a result of the determination, the operation FindFindNode is called in step 624 to find an appropriate node for the entry to be inserted. In step 626, it is determined whether there is enough space to insert an entry in the found page. If there is enough space after the determination, an entry is inserted into the node found in step 628, and the change of the minimum boundary area is reflected in the ancestor node in step 630. In step 632, the reinsertion entry count of the current node is decreased by one, and then the flow returns to step 622 to determine completion of the reinsertion. If there is not enough space as a result of the determination of step 626, it is determined whether the node found in step 634 is the current node that is undergoing the reinsert operation. If it is determined in step 634 that the current node is split, the current node is split, and the exclusive lock of the reinsert node is released and then terminated. If it is determined in step 634 that the node is not the current node, the node found in step 636 is divided, the partition is reflected upward (FixMBR), and then an entry is inserted, and the process returns to step 622 to determine whether reinsertion is completed.

7 is a flowchart illustrating an operation of splitting a node which is one of subroutines of an insert operation according to the present invention.

Referring to FIG. 7, the split operation 700 first allocates a new node NewNode and obtains an exclusive latch in step 710. In step 712, it is determined whether the current node is divided as a terminal node. As a result of the determination, if it is a terminal node, an exclusive lock is obtained at the new node in step 714. In step 716, an entry to be moved from the current node to a new node is selected, inserted into the new node, and deleted from the current node. In step 718, the logical serial number of the current node is assigned to the logical serial number of the new node. In step 720, the log serial number (LSN) of the new node is assigned to the logical serial number of the current node. In step 722, a new node is connected to the next node of the current node. In step 724, the exclusive lock and exclusive latch of the current node and the new node are released and then terminated.

FIG. 8 illustrates a tree structure illustrating a process 800 of requesting conditional exclusive lock to a parent node in a path stack during an overflow operation in a non-terminal node according to the present invention.

Referring to FIG. 8, in the request for exclusive lock 800, when the exclusive lock is obtained, the exclusive lock is reinserted, otherwise the split is performed.

The T1, T2, and T3 are all transactions for inserting an entry. First, T1 arrives at node N3 via node N5 to insert an entry. At this time, N5 acquires a shared lock, and N3 acquires an exclusive lock. T2 and T3 also follow N5 and N1 respectively through N5 to insert an entry. At this time, like T1, T2 and T3 continuously acquire a shared lock in N5. Thereafter, overflow occurs while T1 inserts an entry into N3, acquires a tree lock, reinserts it, and then divides N3. Again, overflow occurs in the process of reflecting this to the upper node N5, and a conditional exclusive lock is requested to N5 to perform reinsertion. However, since T2 and T3 have already acquired the shared lock, they do not obtain the exclusive lock and perform the split. Partitioning is performed and T1 unlocks the tree and ends. Afterwards, T3 inserts an entry into N1 and the minimum boundary area (MBR) is changed to request a tree lock to reflect this to the upper node. A little earlier than this, T2 overflows in the process of inserting an entry into N2 to acquire a tree lock and perform reinsertion. Perform reinsertion and split N2 again. In the process of reflecting this to N5 ', overflow occurs again in N5' and requests N5 for conditional exclusive lock. However, since T3 still holds the shared lock at N5, it does not perform reinsertion and performs partitioning. If T3 requests a conditional exclusive lock on N5 'in this situation, T3 will acquire it and perform reinsertion on N5'. However, this may cause a loss of path in the process of reflecting the minimum boundary region changed by N2 to the upper node.

9 is a flow chart illustrating the operation of a search operation 900 for a range query in accordance with the present invention.

Referring to FIG. 9, the search operation 900 maintains a shared latch only at a node at one level during execution, and detects a division of a lower node of a currently visited node using a link technique.

In step 910, the root node is assigned a level at the first current level CurLevel, and the root node is inserted into the queue. Both the range query or the K-proximity query acquire a shared lock on the reinsert node before starting the search. This is to prevent changes to the reinsert node during the search. If a change is made to the reinsert node during the search, the reinsert entries are excluded from the search. This is to prevent this. Therefore, in step 912, a shared lock is requested to the reinsertion node to obtain this. In step 914, it is determined whether the queue is empty. If the queue is empty as a result of the determination of step 914, the lock is released and the result set is returned. If the queue is not empty as a result of the determination of step 914, a node is taken out of the queue as a current node in step 916, and a shared latch is obtained. To match the level to the level of the current node, follow these steps: In step 918, the level of the current node is compared with the magnitude of the value of the current level (CurLevel). As a result of the comparison, if the level value of the current node is smaller than the current level value, in step 920, the level value of the current node is assigned to the current level, and in step 922, it is determined whether the current level is equal to the level where the current reinsertion occurs. If it is the same, in step 924, after the shared latch is obtained to the reinsert node, the entries of the reinsert node in the query range are inserted into the result set if the current node is the terminal and queued to the non-terminal, and the shared latch is released to the reinsert node. . In step 928, a shared latch is acquired at the current node. In step 930, it is determined whether the current node is a terminal node or a leaf node. If it is determined that the terminal node is not the terminal node, in step 932, the child nodes in the query range are enqueued at the current node. In the case where the determination result is a terminal node, in step 934, entries of the terminal node within the query range from the current node are included in the search result set.

In step 936, the shared latch of the current node (CurNode) is released, and the process returns to step 914 again.

After storing the child node's entry and the parent node's log serial number together in the queue, and later inserting an entry in steps 932/934, the partition is detected by comparing the node's current node's logical serial number and the parent node's log serial number. If you follow the right link, you can search for entries included in the partition that is not reflected above.

10 is a flowchart illustrating the operation of the delete operation 1000.

Referring to FIG. 10, the performing of the delete operation 1000 first determines in which terminal node an entry to be deleted is located in step 1010, and then obtains an exclusive latch. If the terminal node in which the entry to be deleted exists is found, the entry to be deleted is deleted at step 1012. In step 1014, it is determined whether the remaining entries after the deletion of the terminal node are more than 20% or empty. If the determination result is 20% or more, the tree lock is acquired in step 1016, and the exclusive latch of the terminal node is released in step 1018. In step 1020, it is determined whether to become an empty node after deleting an entry. If the determination result is an empty node, in step 1022, the minimum boundary area for the current node of the upper node is converted to a negative number. The search operation excludes entries with this negative minimum boundary area from being searched. This is to prevent searching for empty nodes. In the case of the insert operation, in the find node operation 400, the negative minimum boundary area is changed to a positive value and considered as a node in which a new entry may be inserted. This gives the possibility that an empty node can be used again.

In addition, if more than 20% is left as a result of the determination of steps 1014 and 1020, the minimum boundary area changed due to deletion of an entry in the ancestor node is reflected in step 1024. In step 1026, the tree is unlocked and the delete operation ends.

If less than 20% is left as a result of the determination of step 1014, only the exclusive latch to the terminal node is terminated in step 1028 without reflecting the change of the minimum boundary area as an upper level.

The present invention is not limited to the above embodiments, and many variations are possible by those skilled in the art within the spirit of the present invention.

As described above, the method for controlling concurrency of a database according to the present invention uses a method of allocating a logical serial number using a log serial number as a global counter to reduce the storage efficiency by including a logical serial number in an entry of a non-terminal node. Prevent problems.

In addition, the concurrency control method of the database according to the present invention uses a combination of a latch and a lock, so that the lock on the index node has no influence on the search operation, and acquires only the latch of the shared mode to the node to be accessed when the search operation is performed. Since there is no delay caused by locking the insert or delete operation on the node, high search performance can be provided.

In addition, the method for controlling concurrency of a database according to the present invention keeps entries deleted from a tree for reinsertion in a specific node (reinsertion node) and allows the search operation to refer to them.

Claims (14)

In the concurrency control method of a high dimensional index structure applied to a database, Storing the root node in a queue; Obtaining a shared lock on the reinsert node; Determining whether the queue is empty and taking one node from the queue as the current node if it is not empty, and if the queue is empty, unlocking the reinsert node and ending the search; And Acquiring a shared latch from the current node, selecting subnodes in the query range, placing the queue, and determining whether the queue is empty Simultaneous controlled search method comprising a The method of claim 1, To traverse the tree to search for entries that fall within the query scope, it determines whether the level is equal to the level of the node that is currently being reinserted as the level changes, while maintaining the level information about the node being accessed when traversing the tree. To search for reinsert nodes if same Concurrency-controlled search method further comprising. The method of claim 1, It determines whether the logical serial number with the log serial number of the lower node is larger than the expected logical serial number with the log serial number stored in the parent node. Step to choose Concurrency-controlled search method further comprising. The method of claim 1, Match the level to the current node so that the shared latch is always kept only on nodes at one level Simultaneous controlled search method further comprises. In the concurrency control method of a high dimensional index structure applied to a database, Finding a terminal node into which a new entry is to be inserted; Determining whether an overflow occurs when an entry is inserted into the found terminal node; As a result of the determination, when overflow occurs, acquiring a tree lock and processing a node overflow of the terminal node to be inserted, and then releasing the tree lock; And As a result of the determination, if no overflow occurs, a new entry is inserted into the terminal node to be inserted, and the tree boundary is obtained by checking whether the minimum boundary region has changed due to the insertion, propagating the change to the upper level, and then releasing the tree lock. step Concurrency-controlled insertion method comprising a. The method of claim 5, Finding the terminal node to insert the new entry, Determining whether a child node of the current node is a terminal node; Acquiring an exclusive lock and an exclusive latch on the child node if it is a terminal node; Acquiring a shared latch and a shared lock on the child node if it is a non-terminal node; Determining whether the logical serial number as the log serial number of the child node is greater than the expected logical serial number as the log serial number of the current node; As a result of determining whether it is larger than the expected logical serial number, if it is large, the latch and lock on the child node are released, and the right node of the child node is followed, and the appropriate node is selected among the divided nodes not reflected higher, and then latch and lock are performed. Obtaining; Determining whether a child node is a terminal node if it is not greater than a result of the determination of whether it is greater than the expected logical serial number; If it is determined that the child node is a terminal node, returning a path stack and a child node storing a path from a root node to the child node if the terminal node is a terminal node; And As a result of determining whether the child node is a terminal node, if the non-terminal node is a non-terminal node, returning to the step of determining whether the child node is the current node and performing the process again, and performing the step again. A method for finding a terminal node whose concurrency is controlled, characterized by The method of claim 5, Processing the node overflow, Determining whether the current node is a root node; As a result of determining whether the current node is a root node, performing a root split if the root node is requested and requesting conditional exclusive lock on the current node if the root node is not the root node; Determining whether the current node has obtained the exclusive lock as a result of requesting the conditional exclusive lock on the current node; Calling a reinsert function if the current node acquires an exclusive lock as a result of determining whether the current node has obtained an exclusive lock; And Calling a split function if the current node does not acquire the exclusive lock as a result of determining whether the current node has obtained the exclusive lock; The overflow handling method of which concurrency is controlled, characterized in that The method of claim 7, wherein Calling a split function because the exclusive lock is not obtained at the current node may include: Reading the parent node of the current node from the path stack and determining whether there is free space for inserting a divided entry in the parent node; As a result of determining whether there is free space for inserting the divided entry in the parent node, if there is no free space, the parent node is set as the current node, and the process returns to the step of determining whether the current node of claim 7 is the root node. Determining whether to reinsert or split again; And As a result of determining whether there is free space for inserting the divided entry in the parent node, if there is free space, inserting the divided entry in the parent node, reflecting the change of the minimum boundary area in the ancestor node, and ending the overflow process; Concurrency-controlled overflow processing method further comprising a. The method of claim 7, wherein Acquiring an exclusive lock on the current node and calling a reinsert function may include: Obtaining an exclusive lock on the reinsert node; Deleting the reinsert entry from the current node and storing the deleted entries in the reinsert node; Invoking a function for processing a minimum boundary region change operation that reflects a minimum boundary region changed in an ancestor node due to deletion of a reinsert entry in the current node; Inserting entries in a reinsert node into an index tree after processing the minimum boundary change operation; And After all the entries in the reinsert node have been inserted into the index tree, the reinsert operation is terminated, and if there are still entries to insert, finds the appropriate node to insert and inserts the entries in the reinsert node into the index tree. To go back and perform again And a concurrency controlled reinsert operation. The method of claim 9, After deleting the reinsert entry in the current node, storing the deleted entries in the reinsert node, And recording the number of deleted entries in the current node. The method of claim 9, After all the entries in the reinsert node have been inserted into the index tree, the reinsert operation is terminated, and if there are still entries to insert, finds the appropriate node to insert and inserts the entries in the reinsert node into the index tree. Returning to and performing again, Determining whether an overflow occurs in a node to be inserted in the process of finding and inserting the node to be inserted; Invoking an operation to split the node to be inserted when overflow occurs, as a result of determining whether the node to be inserted is overflowed in the process of finding and inserting the node to be inserted; As a result of determining whether or not overflow occurs in the node to be inserted in the process of finding and inserting the node to be inserted, if no overflow occurs, an entry stored in the reinsert node is inserted into the node to be inserted, and then If there is a change in the minimum boundary area (MBR), returning to the step of calling a function for processing the minimum boundary area change operation that reflects the changed minimum boundary area of the current node of claim 9 to the ancestor node, and then performs the step again. And a concurrency-controlled reinsert operation further comprising. The method according to claim 7 or 8, If the current node does not acquire the exclusive lock as a result of determining whether the exclusive lock has been acquired, calling the split function may include: Allocating a new node to obtain exclusive latch on the new node; Determining whether the new node is a terminal node; As a result of determining whether the new node is a terminal node, if the new node is a terminal node, obtaining an exclusive lock on the new node; Selecting an entry to be moved from the current node to be split to a new node to be split, inserting the entry into the new node and deleting the moved entry from the current node; Assigning the node serial number of the current node to the node serial number of the new node, and assigning the node serial number of the current node to the log serial number of the newly assigned node; And Terminating the partitioning operation after releasing exclusive latch and exclusive locking of the current node and the new node. A method for processing partitioned operations in which concurrency is controlled. In a database system with a processor, Storing the root node in a queue; Obtaining a shared lock on the reinsert node; Determining whether the queue is empty and taking one node from the queue as the current node if it is not empty, and if the queue is empty, unlocking the reinsert node and ending the search; And Acquiring a shared latch from the current node, selecting subnodes in the query range, placing it in a queue, and repeatedly performing the step of determining whether the queue is empty A computer-readable storage medium having recorded a program for realizing the problem. In a database system with a processor, Finding a terminal node into which a new entry is to be inserted; Determining whether an overflow occurs when an entry is inserted into the found terminal node; A function of acquiring a tree lock and processing a node overflow of the terminal node to be inserted and releasing the tree lock when overflow occurs; And As a result of the determination, if no overflow occurs, a new entry is inserted into the terminal node to be inserted, and the tree boundary is obtained by checking whether the minimum boundary region has changed due to the insertion, propagating the change to the upper level, and then releasing the tree lock. function A computer-readable storage medium having recorded a program for realizing the problem.