KR100282640B1 - A database management method using partitioned minimum bounding rectangle - Google Patents

Abstract

The present invention relates to a database management method for a recent application field in which a large amount of complex spatial objects must be processed using a minimum boundary rectangle (MBR) approximating an irregularly shaped spatial object, A first step of dividing the MBR area into two sub-objects by dividing the sub-objects into a plurality of sub-objects, a second step of generating a sub-divided minimum bounding box (DMBR) for each of the sub-objects calculated through the first step, A third step of repeatedly shifting each coordinate axis alternately until the DMBR satisfies the constraint condition represented by the AOD, and a fourth step of dividing the DMBR again when the size of the DMBR exceeds a certain threshold value A method of managing a database using a partitioned minimum bounding rectangle is provided. The MBR of an object satisfies a given constraint The number of components through to repeatedly divided into two sub-object is allowed to make a compromise between the optimum value in the number and complexity of the components can be adjusted by the user to select a given constraint to.

In addition, since the existing spatial index structure is expanded to efficiently utilize the present invention, candidate objects that do not satisfy the query condition can be quickly removed, and the efficiency of the query processing can be improved.

Description

A database management method using a partitioned minimum bounding rectangle (Decomposed Minimum Bounding Rectangle)

The present invention efficiently analyzes complex spatial objects required in recent application fields such as geographic information system (GIS), computer-aided design (CAD), and multimedia database (MMDB) And more particularly to a database management system using a divided minimum bounding rectangle (DMBR).

In general, a database management system (DBMS) is a program package for efficiently managing and managing a large amount of databases, including a query language, an index structure, and a storage system.

Currently, existing commercial DBMSs are designed to handle simple data types such as integers, real numbers, or strings. A typical prior art is Korean Patent Application No. 93-26018 (titled: Variable Length Key and Duplicate Key An extended B + -tree operation method).

However, as a problem with the above-described prior art, it is required in recent complex application fields such as GIS, CAD, and MMDB to handle complex spatial objects (objects describing the geometric topography or topographic outline) as well as these simple data types Therefore, the conventional DBMS has a limitation that it is not suitable for the application field of complex spatial objects.

Accordingly, in order to overcome the limitations of the prior art, that is, in order to efficiently process complex spatial objects required in recent application fields, many techniques have been studied so far, and these techniques can be roughly divided into two methods.

The first approach is to approximate an irregular complex space object with a minimum bounding rectangle (MBR), and the second is to approximate a space object with a more accurate approximation than MBR, such as a convex polygon.

A filtering-refinement method and an object transformation method can be considered as a representative method for implementing the MBR method, which is a first scheme for approximating a complex spatial object.

First, among the methods for implementing the MBR method, the query processing in the filtering-refining method is divided into a filtering step and a refining step. In the first filtering step, all objects are reduced to a set of candidate objects using the MBR, In the second stage, the refinement step, the candidate objects are precisely researched to detect the final objects.

Although the filtering-refinement method described above has an advantage in that it can quickly remove objects that do not satisfy the query by using the existing spatial indexing technique, the simple square-shaped MBR has a limitation in accurately representing a complex spatial object have. Moreover, because of inaccurate approximations, this approach may contain many unnecessary candidate objects (i.e., false hits) that do not satisfy the query condition. As a result, even the wrong hit is transferred to an unnecessarily expensive purification step.

Second, among the methods for implementing the MBR method, the object transformation method is a method of transforming a k-dimensional spatial object into a one-dimensional bit string (prior art: Korea Patent Application No. 96-65570 Index structure, and its insertion, deletion, and search method), or simplifying k-dimensional spatial objects into k-dimensional sections and then converting the sections into 2k-dimensional point objects. However, in spite of this transformation, it also introduces the problem that the spatial object can not be precisely approximated because it is fundamentally an MBR method based on a simple rectangle which has a limitation to accurately represent a virtual complex spatial object.

On the other hand, more accurate approximation methods than MBR have been proposed as a second method to solve the problem of the MBR method described above for processing a complex spatial object. Among them, there is a convex approximation method of approximating a space object by convex polygons and an object decomposition method of approximating a space object by dividing them. to be.

However, since the convex approximation method requires more parameters than the MBR, it requires a more complex spatial indexing technique. Moreover, using only one approximation can not reduce the complexity of the spatial object. This implies that expensive geometric space calculations should be applied to complex spatial objects.

On the other hand, object segmentation, which divides complex spatial objects into simple components such as trapezoids, not only improves the accuracy of the approximation but also simplifies spatial objects. However, a large number of calculated components act as a burden on the query processing. More seriously, the more complicated the spatial object is, the more elements are generated from the object, the faster the processing becomes difficult, An increase in storage space is a problem.

In order to solve the above problems, an object of the present invention is to provide a method and an apparatus for calculating an outer boundary of a specific object, dividing a half of the outer boundary, And a database management system using the divided bounding rectangles, which improves the performance of spatial queries.

Figs. 1A to 1C are diagrams for explaining a case where a divided minimum bounding rectangle is applied. Fig.

FIGS. 2A and 2B are views showing an example of a minimum bounding rectangle calculated in FIGS. 1A to 1C and a data structure thereof

FIG. 3 is a flowchart illustrating an operation sequence of a data structure of a partitioned minimum bounding box method

4 is an exemplary diagram showing an index structure of a partitioned minimum bounding rectangle method;

FIG. 5 is a flowchart illustrating an example of an operation sequence

6A and 6B are diagrams illustrating an example of inspecting a spatial object including a query point

7 is a diagram illustrating an example of performing an area query refinement step

FIG. 8 is a flowchart illustrating an example of an operation sequence showing an area query process

9 is a diagram illustrating an example of performing a plane-sweep technique

10 is a flowchart illustrating an example of an operation sequence of a spatial join query process

According to an aspect of the present invention, there is provided a database management method for an application domain that handles complex spatial objects with a minimum bounding rectangle (MBR) approximating an atypical spatial object, A second step of generating a divided minimum bounding rectangle (DMBR) for each of the subobjects calculated through the first step; A third step of repeatedly shifting each coordinate axis alternately until the constraint expressed by Accuracy of the Decomposition is satisfied, and a fourth step of dividing the DMBR again when the size exceeds a certain threshold value .

According to another aspect of the present invention, an object cutting line is selected when dividing a spatial object in the first process. In the first process, an object cutting line is selected. A second step of selecting a smallest y (or x) coordinate value among the cut lines when a plurality of sub-objects are calculated and selecting the smallest y (or x) coordinate value as an object cutting line; In the third process, the process in which the restriction condition is managed by the parameter g, i.e., AOD (g) 2- ^g There is one compromised value between the number of divided components and the accuracy of the approximation. The actual experiment shows that when the parameter g is 3, the performance Is maximized.

According to another aspect of the present invention, there is provided a method of managing a database using a partitioned minimum bounding rectangle, the method comprising: storing results generated in each partitioning step into a DR-tree (Decomposed Rectangle tree); The DR-tree consists of an intermediate node and a leaf node. In the intermediate node, the DMBR of the sub-object is stored. The leaf node includes the identifier of the component and the DMBR. The object identifier of the leaf node indicates the related component and; We use the 'Divide and Conquer' technique to construct the DR-tree, the array p, which represents an object as input, and the boolean variable d, which causes the vertical or horizontal splitting line to change alternately when splitting the object And then one DR-tree is created as a result.

According to another aspect of the present invention, there is provided a method for managing a circular object, the method comprising: combining an index structure for structuring divided elements into an existing index structure capable of efficiently managing circular objects; The first part of the index structure uses the R * -tree as an index structure to store circular objects without modification, and the second part uses DR-tree to store the partitioned components; And has a two-stage index structure in which a new spatial object is inserted into the index structure in two steps (application of a partitioning algorithm and application of an R * -tree insertion algorithm).

According to another aspect of the present invention, there is provided a two-level index structure, wherein the spatial query processing is divided into a point query, an area query, and a spatial join query, and the point query processing is performed prior to performing the refinement step, Using the DMBRs of the tree to quickly remove many false hits and performing refinement steps only on the simple components filtered by the DMBRs and using the R * Searching all the record identifiers, reading the DR-tree indicated by these identifiers into the main memory, and examining each node from the root node, and if the examined node is not a leaf node, Checking whether the query node includes a query point, and if so, calling the algorithm recursively for the left and right child nodes, In this paper, we propose a method to check whether a DMBR node stored in a leaf node includes a query point, if the node is a leaf node.

In order to accomplish the above object, an area query processing step includes a step of determining whether DMBRs are crossed in the query window after the relevant DR-tree is transferred to the main memory before immediately applying the refinement step to the filtered objects The inspection process and the refinement process are sequentially scanned by the geometric calculation algorithm until an intersection is detected along the object boundary, and if the intersection is not detected up to the last segment, the object is regarded as not intersecting the query window A step of determining whether intersecting inspection is actually required while scanning the boundary line of the object, a region inspecting process of examining whether both end points of the line segment are located in the upper, lower, left, and right regions of the window, Select an endpoint, and if this endpoint is in the left area of the window, It is to include a process of checking whether the intersection with the left edge of the window.

In order to achieve the above object, an additional feature of the present invention is to find all record identifiers having an MBR intersecting with a query window using an R * -tree search algorithm, and to use DR-trees indicated by these identifiers as main memory Checking each node from the root node after reading it; If the node to be examined is not a leaf node, checking whether the rectangular coordinates stored in the node are included by the window and returning Oid if included, or checking whether the node overlaps the window; Recursively invoking the algorithm on the left and right child nodes if the node overlaps the window; Checking whether the examined node is a leaf node, whether the DMBR coordinates stored in the node are included by the window, returning Oid if included, and checking if the node overlaps the window; Checking if the segment exists in the window for each segment of the component if the node overlaps the window, returning Oid if present, and otherwise applying a region check; If it is not simply determined by the area check, apply a cross check, returning Oid if one intersection is detected, and otherwise taking the next line segment.

In order to improve the efficiency of the purification step, the spatial join processing step is performed in order to improve the performance of the expensive purification step by performing one more continuous filtering step in order to achieve the above object. A step of performing a refinement step on intersecting components after eliminating as many objects as possible, and a refinement step performed by a plane-sweep technique. And performing the inspection by limiting only the users.

In order to achieve the above object, an additional feature of the present invention is to find all record identifiers in which MBRs of two spatial objects intersect using an R-tree join algorithm, and read two DR-trees indicated by these identifiers into a main memory And if the two nodes to be examined are both leaf nodes, first remove the lines that are not in the intersecting area where the DMBRs stored in the nodes are overlapped with each other, If an intersection is found by applying the sweep technique, the process of returning these Oids is performed. If one node is a leaf node and the other node is not a leaf node, the left and right child nodes of a leaf node In the process of invoking the algorithm recursively, and if both nodes are not leaf nodes, the left and right child And recursively invoking the algorithm for the nodes.

First, the technical idea to be applied in the present invention will be briefly described. In the DMBR method of the present invention, half of the MBR area surrounding an object is divided into two sub-objects. Then, MBR (called DMBR) is generated for each subobject. This segmentation process is repeatedly performed with each coordinate axis alternating until the DMBRs meet the given constraints. The constraint is expressed by the AOD, which means that the size of the DMBR will be subdivided if it exceeds a certain threshold. The threshold value is managed by the parameter g. That is, AOD (g) means that DMBRs larger than 2- ^g of the MBR region are divided again.

Hereinafter, preferred embodiments according to the present invention will be described with reference to the accompanying drawings.

1A to 1C show an example of applying the DMBR method according to the present invention. FIG. 1A shows a spatial object approximated by MBR. Assuming that the threshold is 25% of the MBR area (ie, AOD (2)), the object is first separated into two subobjects by the middle vertical coordinate axes.

After that, a DMBR is generated for each sub-object as shown in FIG. 1B. The DMBR of the sub-object on the left is smaller than 2 ^-2 of the MBR region, whereas the DMBR of the sub-object on the right is larger than 2 ^-2 of the MBR region.

Therefore, as shown in FIG. 1 (c), the right sub-object is divided by the middle horizontal coordinate axes. The iterative partitioning then stops. Because now all DMBRs are smaller than 2 ^-2 in the MBR area.

At this time, the DMBR method has to deal with various cases different from those shown in FIG. 1. Since a plurality of sub-objects can be calculated when one object is divided, Systematic techniques are needed.

The DMBR method also has one parameter, g, that can appropriately adjust the number of components and the accuracy of the approximation. When the value of the parameter is low, the number of components can be minimized, but the accuracy of the approximation is relatively poor. On the other hand, the accuracy of the approximation improves when the value of the parameter is high. However, it can be observed that the number of components increases greatly. From these observations it can be inferred that there may be one compromised value between the number of components and the accuracy of the approximation.

According to the present invention, when the parameter g is 3, the performance is maximized. YJ Lee, SJ Lee, and CW Chung, "Object Decomposition for Spatial Query Processing," International Journal of Information Technology, Volume 3, Number 1, pp. 35-62 , World Scientific Publishing Company, June 1997)

To efficiently implement the DMBR method, the results generated at each partitioning step are stored in a 2-dimensional binary tree called a DR-tree.

In the DMBR method, a binary tree is a suitable structure because an object is repeatedly divided into two sub-objects precisely. The DR-tree stored on the hard disk is entirely moved to the main memory when a refinement step for that object is required. The structure of the DR-tree is similar to the LSD-tree. The difference is that the partition of the LSD-tree is half (half) of the whole, whereas the partition of the DR-tree is indicated by the DMBR. The DR-tree consists of a leaf node and an intermediate node. The leaf node includes a component identifier and a DMBR, and the intermediate node stores the DMBR of the sub-object.

FIGs. 2A and 2B illustrate the structure of a DR-tree using the results of FIG. 1, FIG. 2A shows DMBRs calculated by the DMBR method, and FIG. 2B shows DR-trees related thereto.

The tree consists of three leaf nodes and two intermediate nodes. The rectangles efcg, ibjk, and lmgn denote the DMBR stored in the leaf node, and the rectangles hbgd and abcd are the minimum bounding rectangles including the rectangles in the child nodes. The object identifier of the leaf node indicates the associated component.

The algorithm for constructing the DR-tree is as shown in FIG.

This algorithm uses the 'Divide and Conquer' technique. If we take an array p that represents an object as input and a boolean variable d that causes the vertical or horizontal splitting line to change alternately when splitting the object, then performing this algorithm will result in a single DR-tree being created do. Describing the algorithm execution process in detail,

First, in step S101, the coordinate value of the MBR or DMBR of the input object is searched from the array p. At this time, if the MBR is MBR, the area of the MBR is calculated in step S102, the area is set as the DMBR area, and a root node thereof is initialized to make one DR-tree.

However, in the case of the DMBR, only the DMBR area is calculated through the process of step S103.

Then, in step S104, it is determined whether the DMBR area is larger than MBR area / 2 ^g and the number of vertexes of p is larger than the number of vertexes of circular object / 2 ^g . If it is determined that the DMBR area satisfies the condition, the process proceeds to step S105. In step S105, one middle vertical (or horizontal) dividing line is created. In step S106, the following is performed for each line segment in the array p.

If it is determined in step S107 whether or not the line segment defined in step S106 exists on the left (or above) the intermediate division line, the process proceeds to step S108 and both end points of the line segment are added to the array p1.

If it is determined that the line segment defined in step S107 does not exist on the left (or above) the middle dividing line, the process proceeds to step S109 to determine whether the defined line segment exists on the right (or below) the middle dividing line. , The flow advances to step S110 to add both end points of the segment to the array p2.

If the condition is not satisfied at step S109, it is determined at step S111 whether the line segment defined by the intersection is intersected with the intermediate division line. If intersection points are found, the process proceeds to step S112 and the intersection points are added to the arrays p1 and p2.

After the processes from step S106 to step S112 are performed, the process proceeds to step S113 to check whether or not the line segments of all the objects are completed. If it is determined that the line segments have not been completed, the process returns to step S106, do.

On the other hand, if it is determined in step S113 that the execution is completed, the DR-tree is constructed, that is, the DMBR coordinates related to the array p1 move to the left node of the current node in step S114, and in step S115 The DMBR coordinates associated with array p2 move into the right node of the current node.

If two arrays representing two separated subobjects are generated, the boolean variable d is set so that the next division is performed alternately with respect to the vertical and horizontal division lines (S116), and for each of the separated objects, The algorithm is recursively called so that the next segmentation is performed (S120, S130).

On the other hand, if the DMBR area is not larger than the MBR area / 2 ^g or the number of vertices of p (the number of vertexes of the circular object) / 2 ^g in step S104, the program is terminated and the generated DR-tree is returned.

In the object segmentation method described above, the ability to quickly refer to a set of elements related to spatial queries is very important. This requires an efficient index structure to organize the set of components. The DMBR method extends the existing index structure. In other words, it combines the index structure that can structure the divided elements into the existing index structure that can efficiently manage the circular objects. The most widely used R * - tree is selected as the existing index structure. The partitioned components are stored in the DR-tree.

Accordingly, FIG. 4 is an illustration of a two-stage index structure that extends the existing index structure. The index structure is composed of two parts, the first part is the R * -tree used as an index structure for storing circular objects without modification. The second part uses DR-trees to store the partitioned components. The R * -tree consists of a leaf node and an intermediate node. The leaf node contains an identifier of the circular object, an MBR, and an address indicator for the DR-tree. The intermediate node contains the address indicator of the child node and the rectangular area of the child node. The DR-tree generated by Figure 4 is added to the associated leaf node of the R * -tree.

The process of inserting a new spatial object into the two-stage index structure is performed in two steps as follows.

Step 1: Apply the algorithm shown in FIG. 3 attached

First, after calculating MBR for a new object, the algorithm of FIG. 3 is applied, and DR-tree is generated by this algorithm. Since the DR-tree is continuously stored in the storage device and is transferred to the main memory when performing the refinement step, there is no need to construct a DR-tree in the main memory or to perform operations such as pointer conversion.

Step 2: Apply R * - tree insertion algorithm

The existing R * -tree insertion algorithm is used for R * -tree construction (not described for the R * -tree insertion algorithm (see N. Beckmann, H. P, Kriegel, R. Schneider, and B. Seeger, "The R * -tree: An Efficient and Robust Access Method for Points and Rectangles," Proceedings of the ACM SIGMOD International Conference on Management of Data, pp. 322-331, A new two-stage index structure is created.

The following describes the spatial query processing algorithms based on the DMBR method. Query processing of complex spatial objects is generally implemented by this two-stage strategy (filtering and refinement). Using the DMBR method for query processing improves the performance of the purification step in particular. The spatial queries described are point queries, domain queries, and spatial join queries.

Point query processing is to find all spatial objects containing the point with a given point as a key. First, in the filtering step, the search algorithm of the R * -tree is used. In order to find the object O including the query point P, the following Equation 1 must be satisfied.

The refinement phase of the existing R * - tree algorithm requires a very expensive search cost if the spatial objects are complex. Because MBR is an inaccurate approximation technique, and expensive geometric computation algorithms are needed to refine complex spatial objects. However, in the DMBR method, many erroneous hits can be quickly removed using DR-tree's DMBRs before performing the refinement step, yielding relatively simple components. That is, the purification step is performed only for the simple components filtered by the DMBRs.

Figure 5 shows the processing of point queries in a DR-tree.

First, as a precondition, the input is one DR-tree where node T is the root, and the output is one Oid containing P.

First, all the record identifiers including the query point P = (Px, Py) are searched using the search algorithm of the R * -tree, the DR-tree indicated by these identifiers is read into the main memory, (S201).

If the examined node T is not a leaf node, it is checked whether the rectangular coordinate stored in the node T includes a query point P (S202). If the node T includes the query point P in step S202, the algorithm proceeds to steps S203 and S204 to recursively call the left and right child nodes.

On the other hand, if the node T does not include the query point P in step S202, the algorithm goes out of the algorithm.

On the other hand, if the node examined in step S201 is a leaf node, step S205 is performed to check whether the DMBR coordinates stored in the node include the query point P. If it is determined in step S205 that the object is to be represented in step S205, the flow advances to step S206 to draw one auxiliary line between the query point and an arbitrary point outside the object, and then the number of points where the object boundary intersects the auxiliary line is obtained.

If the number of intersections is calculated through the above process, it is determined in step S207 whether the number of intersections is an odd number. In step S208, the inquiry point exists in the object and therefore an Oid value is returned. ≪ / RTI >

FIG. 6A shows an example of inspecting an object including a query point. In the special case, when the intersection is a vertex where two line segments meet, an exception is handled. FIG. 6B shows this case. That is, if the vertices opposite to the two line segments constituting the intersection point are on the same side with respect to the auxiliary line (x), the point is calculated as an even number.

On the other hand, an area query is to find all spatial objects that intersect a given query window. Similar to the point query, the filtering step of the region query is based on the R * - tree. In order for the query window Q to intersect with the object O, it must satisfy the following equation (2).

In the refinement step, all candidate objects are precisely re-examined to see whether they actually cross the query window. However, if the object's MBR is completely contained within the query window, it can be selected as a result object without having to perform the purification step. In this case, the following equation (3) is satisfied.

Conventional object segmentation techniques can be a large burden on query processing due to the many components that are computed. In order to eliminate such disadvantages, the present invention has developed a DMBR method capable of appropriately adjusting the number of components.

The DMBR method supports efficient refinement steps by selecting a trade-off between the number and complexity of the components. That is, before applying the refinement step directly on the filtered objects, the associated DR-tree is transferred to main memory. It then checks whether the DMBRs intersect the query window.

There are three cases of the test result: (1) an object that satisfies an area query, (2) an object that does not satisfy an area query, and (3) a candidate object.

The refinement step is performed only for the candidate object among these candidates. In general, the refinement step is sequentially scanned by a geometric computation algorithm until an intersection is detected along the object boundary. If an intersection is not detected up to the last line segment, the object is regarded as not intersecting the query window and the algorithm is terminated.

The refinement step algorithm of the area query can be further improved by the following technique. It first determines if an intersection check is required while scanning the boundary of the object. That is, it checks whether the line segments are completely contained in the window. If a line segment is included in the window, the object is determined as the final result and finishes the algorithm execution. If not, perform a region check.

For example, if the x coordinate boundaries of the query window are Q _{x, min} , Q _{x, max} and the y coordinate boundaries are Q _{y, min} , Q _{y, max} , e ₁ Have an y coordinate value greater than Q _{y, max} . It can be seen that it lies in the upper area of the window. This line segment is moved to the next segment without cross-checking. Similarly, no intersection check is required for line segments whose end points are Q _{y, min} below, Q _{x, min} left, Q _{x, max} right.

If both endpoints of the segment are not placed in the top, bottom, left, and right regions of the window, then the object may or may not be the final object intersected (eg, e ₅ , e ₇ In this case, e ₅ Only windows intersect). In this case, the algorithm chooses one endpoint outside the window in that segment. If this endpoint is in the left area of the window, check if this line segment intersects the left border of the window. For example, e ₅ , e ₇ It is cross-checked with this window boundary ac. Similarly, this cross-check is done when the endpoint is on the right, top, or bottom of the window.

FIG. 8 shows a process of processing an area query in the DR-tree.

First, we use the R * -tree search algorithm to find all record identifiers that have an MBR that intersects the query window Q = (Qx _{, min} , Qx _{, max} , _{Qy, min} , _{Qy, max} ).

Therefore, in step S301, the DR-tree indicated by these identifiers is read into the main memory, and then each node is examined from the root node. If it is determined in step S301 that the node is not a leaf node, the flow advances to step S302 to check whether the rectangular coordinates stored in the corresponding node are included in the window Q.

If it is determined to be included in step S302, the process proceeds to step S303 to return Oid. Otherwise, the process proceeds to step S304 to check whether or not the node overlaps the Q.

If it is determined through overlapping in step S304, the algorithm is recursively called for the left and right child nodes T. If the nodes do not overlap, the algorithm is exited.

If it is determined in step S301 that the node is a leaf node, the flow advances to step S307 to check whether the DMBR coordinates stored in the corresponding node are included in the window Q. If it is determined in step S307 that the DMBR coordinates stored in the node are included by the window Q, the flow advances to step S308 to return Oid. Otherwise, the flow advances to step S309 to check whether the node overlaps Q.

If it is determined in step S309 that the node overlaps Q, the flow advances to step S310 to check whether or not the corresponding line segment exists in the window Q with respect to each line segment of the component.

That is, if it is determined in step S310 that the line segment exists in the window Q, the process proceeds to step S311 and returns Oid. Otherwise, the process proceeds to step S312 to apply the area check. Thereafter, in step S313, it is determined whether it is simply determined by the area inspection, and if it is not easily determined, the process goes to step S314 to apply the cross check.

It is determined in step S315 whether or not an intersection is detected through the crossing inspection in step S314. If one intersection is detected, the process proceeds to step S316 to return Oid. Otherwise, the process proceeds to step S317 to take the next line segment.

This operation is repeatedly performed until it is determined through step S318 that the execution of all the line segments of all the components is completed.

In the DR-tree as described above, the spatial join query searches space objects satisfying the spatial operator for two or more sets of multiple objects. In the present invention, space cross joins are limited to two sets. In the present invention, an R-tree join algorithm proposed by Brinkhoff et al. Is used for the filtering step of the spatial join process (see T. Brinkhoff, HP Kriegel, and B. Seeger, "Efficient Processing of Spatial Joins Using R -Tree, " Proceedings of the ACM SIGMOD International Conference on Management of Data, pp. 237-246, 1993).

However, since the R-tree join algorithm can be performed only for the filtering step of the spatial join, the present invention extends the R-tree join algorithm to improve the efficiency of the refining step. The basic idea is to improve the performance of the expensive purification step by performing one more continuous filtration step. For example, as shown in FIG. 1A, after the filtration step is performed only with the MBR, the filtration step is performed with the MBR as shown in FIG. 1C rather than the purification step. Then, an additional filtration step is further performed once again using the DMBR, Lt; RTI ID = 0.0 > components. ≪ / RTI >

This technique can quickly remove many false hits and simply skip over subobjects that are not explicitly satisfied of the join condition among the candidate objects selected by the MBR. That is, after removing objects that do not satisfy the query by DMBRs as much as possible, the refinement step is performed on the intersecting components, and the refinement step is performed by the plane-sweep technique utilized in the field of computational geometry.

In the preprocessing step, the plane-sweep technique first aligns the vertices of the two objects according to the x-coordinate values. Then, as shown in FIG. 9, moving a vertical line (i.e., a sweep line) from left to right, a geometric comparison is performed to see if a pair of segments simultaneously intersecting the sweep line is actually intersected. Segments in the picture e ₃ , e ₄ The intersection is determined as the final result and the algorithm execution is terminated.

The above-described plane-sweep technique can also improve performance by using DMBRs. The DMBRs can perform the inspection only on the lines within the intersection area where the two DMBRs overlap each other. For example, e ₁ and e ₅ There is no need to perform a cross-check. Because they can never cross other lines.

FIG. 10 shows a spatial join query processing process in a DR-tree. First, we use the R-tree join algorithm to find all record identifiers where the MBRs of the two spatial objects O1 and O2 intersect. The two DR-trees indicated by these identifiers are read into main memory, and then checked from the root node. If the two nodes to be examined are not crossed (S401), the algorithm is exited. If both of the two nodes to be examined are leaf nodes (S402), the line segments that are not in the intersecting region where the DMBRs stored in the nodes overlap with each other are removed (S403). Then, the plane-sweep technique is applied (S404). If an intersection is found during the plane-sweep operation (S405), Oids are returned (S406). However, if one node is a leaf node and the other node is not a leaf node (S407, S409), the algorithm is recursively called for the left and right child nodes of the node other than the leaf node (S408, S410 ). If both nodes are not leaf nodes (S409), the algorithm is recursively called on the left and right child nodes of the two nodes (S411).

The database management system using the partitioned minimum bounding rectangle according to the present invention operates as described above. By dividing the MBR of an object repeatedly into two sub-objects until a given constraint is satisfied, Can be adjusted by a given constraint, allowing the user to select the optimal tradeoff between the number and complexity of the components.

In addition, since the existing spatial index structure is expanded to efficiently utilize the present invention, candidate objects that do not satisfy the query condition can be quickly removed, and the efficiency of the query processing can be improved.

Claims (9)

1. A method for managing a database of an application field which deals with a complex spatial object with a minimum bounding rectangle (MBR) approximating an irregular shaped spatial object, A first step of dividing a half of the MBR area surrounding the spatial object and calculating two sub-objects; A second step of generating a divided minimum bounding rectangle (DMBR) for each subobject generated through the first process; A third step of repeatedly shifting each coordinate axis alternately until the DMBRs satisfy a constraint condition expressed by Accuracy Of the Decomposition (AOD); And And a fourth step of dividing the DMBR when the size of the DMBR exceeds a certain threshold value. The method according to claim 1, The object cutting line is selected when dividing the spatial object in the first step, which can be solved simply by ignoring the intersection points when they are found at the outer point of the object; A second step of selecting the object having the smallest y (or x) coordinate value among the cutting lines when a plurality of sub-objects are calculated and selecting the object as the object cutting line; In the third step, the restriction condition is managed by the parameter g, i.e., AOD (g) 2- ^g There is one compromised value between the number of divided components and the accuracy of the approximation. The actual experiment shows that when the parameter g is 3, the performance Wherein the minimum bounding rectangle is maximized. The two subobjects are divided by dividing the MBR region around the spatial object, and the DMBRs for each subobject are shifted repeatedly while alternating between the coordinate axes until the constraint expressed by the AOD is satisfied. A method of managing a database using a partitioned minimum bounding rectangle including a process of re-partitioning when a size exceeds a certain threshold, Storing the results generated in each division step into a DR-tree (Decomposed Rectangle Tree); The DR-tree consists of an intermediate node and a leaf node. In the intermediate node, the DMBR of the sub-object is stored. The leaf node includes the identifier of the component and the DMBR. The object identifier of the leaf node indicates the related component and; We use the 'Divide and Conquer' technique to construct the DR-tree, the array p, which represents an object as input, and the boolean variable d, which causes the vertical or horizontal splitting line to change alternately when splitting the object And a DR-tree is generated as a result. The method of claim 3, Combining an index structure capable of structuring divided elements into an existing index structure capable of efficiently managing circular objects; The first part of the two-part index structure uses the R * -tree as an index structure for storing circular objects without modification, and the second part uses the DR-tree to store the partitioned components and; And a two-step index structure in which a new spatial object is inserted into the index structure by two steps (application of a partitioning algorithm and application of an R * -tree insertion algorithm). The first part of the two - stage index structure, which combines the existing index structure that can manage circular objects efficiently, and the index structure that can structure the divided elements, is an index structure for storing circular objects. The R * - tree And the second part is an index structure that uses DR-trees to store the partitioned components, Spatial query processing is divided into point query, domain query, and spatial join query, The point query processing includes using the DMBRs of the DR-tree to quickly remove many erroneous hits before performing the refinement step, and performing a refinement step only on the simple components filtered by the DMBRs; Searching all the record identifiers including the query point using the R * -tree search algorithm, reading the DR-tree indicated by these identifiers into main memory, and examining each node from the root node; Checking whether a rectangular coordinate stored in the node includes a query point if the node to be examined is not a leaf node, and recursively calling an algorithm for the left and right child nodes if the node includes the query point; Checking whether the node to be examined is a leaf node, whether the DMBR coordinates stored in the node include a query point, and if so, passing the dot inclusion object inspection process, or otherwise leaving the algorithm. Query processing algorithm. 6. The method of claim 5, The region query process includes the steps of checking whether the DMBRs cross the query window after the associated DR-tree is sent to the main memory before immediately applying the refinement step to the filtered objects; The refinement step is sequentially scanned until the intersection is detected along the object boundary by the geometric calculation algorithm, and if the intersection is not detected until the last line segment, the object is regarded as not intersecting the query window; Determining whether an intersection inspection is actually required while scanning a boundary line of the object; An area inspection process for examining whether both end points of a line segment are located in the upper, lower, left, and right regions of the window; Selecting an endpoint outside the window in the segment and inspecting if the endpoint intersects the left border of the window if the endpoint is in the left region of the window. The method according to claim 6, Using the R * -tree search algorithm to find all record identifiers that have an MBR intersecting the query window, reading the DR-tree pointed to by these identifiers into main memory and examining each node from the root node ; If the node to be examined is not a leaf node, checking whether the rectangular coordinates stored in the node are included by the window and returning Oid if included, or checking whether the node overlaps the window; Recursively invoking the algorithm on the left and right child nodes if the node overlaps the window; Checking whether the examined node is a leaf node, whether the DMBR coordinates stored in the node are included by the window, returning Oid if included, and checking if the node overlaps the window; Checking if the segment exists in the window for each segment of the component if the node overlaps the window, returning Oid if present, and otherwise applying a region check; If it is not simply determined by the region check, apply a cross check, returning Oid if one intersection is detected, and otherwise taking the next segment. 6. The method of claim 5, In order to improve the efficiency of the refinement phase, the spatial join process removes the objects that are not satisfied by the query by the DMBRs in order to improve the performance of the expensive refinement phase by performing one more continuous filtration step. Performing a purification step with respect to the sample; The method comprising the steps of: performing an inspection by limiting only the lines within the intersection area where two DMBRs overlap in a refinement step performed by a plane-sweep technique. 9. The method of claim 8, Searching all record identifiers in which MBRs of two spatial objects intersect with each other using an R-tree join algorithm, inserting two DR-trees indicated by these identifiers into main memory, and inspecting each node from a root node; If the two nodes to be examined are both leaf nodes, first remove the lines that are not in the intersection area where the DMBRs stored in the nodes are overlapped with each other, and if the intersection is found by applying the plane-sweep technique, ; Recursively calling the algorithm for left and right child nodes of a node other than a leaf node when one node is a leaf node and the other node is not a leaf node; And if the two nodes are not leaf nodes, recursively calling the algorithm for the left and right child nodes of the two nodes.