KR20020004301A - Method of Nearest Query Processing using the Spherical Pyramid-Technique - Google Patents

Abstract

PURPOSE: A method for processing nearest query is provided to index high-dimensional data efficiently and to process a question of a spherical type used for similar search efficiently. CONSTITUTION: A nearest query process method comprises dividing a d-dimensional data space into 2d spherical pyramids(11), dividing the divided spherical pyramids into spherical segments(13), calculating the shortest distance between a query point and the spherical pyramid so as to be inserted in an order queue according to ascending power, extracting the first element of the order queue, calculating the shortest distance between a spherical segment in the spherical pyramid and the query point when the first extracted element is a spherical pyramid, to insert the spherical segment in the queue again, and returning an object to a result of the nearest query when the first extracted element is the object.

Description

Method of Nearest Query Processing using the Spherical Pyramid-Technique}

The present invention relates to a method for processing a nearest neighbor query using a spherical pyramid technique that searches an object nearest to a query using a spherical pyramid technique that spatially divides a d-dimensional space into 2d spherical pyramids and indexes high-dimensional data. It is about.

Algorithms for processing the nearest or k-nearest queries have been studied by the necessity in the fields of GIS application, pattern recognition, document retrieval, and learning theory. This algorithm was developed to find the most similar objects to the query objects for point or arbitrary spatial objects in d-dimensional vector space, and most of them are based on a certain spatial data structure. For example, there are k-d tree-based algorithms, quad-tree-based algorithms, and R-tree-based algorithms. Most of these algorithms can be naturally applied to other spatial data structures through modification.

Roussopoulos and Kelley have proposed an algorithm to search k objects that are most similar to the query point (query object) using the branch & bound algorithm on R-tree using mindist and minmaxdist. The basic idea behind the algorithm is to search the R-tree in a depth-first manner, keeping candidate objects in the Active Branch List. The algorithm starts with k already determined. In other words, since k is already determined in advance, there is a disadvantage that if the user wants to get the (k + 1) th object, the algorithm must be restarted from the beginning (N. Roussopoulos, S. Kelley, F. Vincent. " Nearest Neighbor Queries "Proc. ACM SIGMOD, San Jose, CA, pages 71-79, 1995.).

Hjaltason and Samet proposed an incremental nearest neighbor query processing algorithm to get the query results one by one according to the user's request, rather than determining k values beforehand. In a spatial database, users make a lot of `distance browsing 'requests to get the query objects and the closest objects one by one. Incremental nearest neighbor algorithms are designed for this application. The algorithm uses a priority queue to always ensure that the object closest to the query object is at the front of the queue, returning the element at the beginning of the queue whenever the user wants to display the closest objects in turn as the query result. . Thus, the user can always get as many objects as they want without having to restart the algorithm from scratch. In other words, after retrieving k objects, we can return the next object left in the rank queue without having to restart the algorithm from the beginning to get the (k + 1) th object.

Hjaltason and Samet show that the k-nearest query processing algorithm is more efficient than the k-nearest query processing algorithm on the R * -tree even when the gradual nearest algorithm is used (Gisli R. Hjaltason, Hanan Samet. Browsing in Spatial Databases. "ACM Transaction on Database Systems, 24 (2), pages 265-318, 1999.).

However, this algorithm is also inefficient for high dimensional data. This is because the spatial data structure called R-tree is not efficient in high dimensional space, rather than the problem of the algorithm itself.

Similar search has emerged as one of the important search techniques in database systems. This is a technique of converting specific data into a single point in high dimensional space and indexing and searching using a multidimensional index structure. The most popular application of this retrieval technique is content-based multimedia information retrieval. Content-based multimedia information retrieval is a technique of extracting feature data estimated from content from multimedia data and searching based on it. In general, feature data extracted from multimedia data is represented in a high-dimensional vector form (S. Berchtold, DA Keim, and H.-P. Kriegel. "The X-tree: An Indexing Structure for High-Dimensional Data". Proc. 22nd Int. Conf. On Very Large Database, pages 28-39, September 1996 .: S. Berchtold, D. Keim, H.-P. Kriegel, and T. Seidl. "Fast Nearest Neighbor Search in High-Dimensional Spaces". Proc. 14th Int. Conf on Data Engineering, Orlando, 1998.).

In addition, these applications use k-nearest and spherical domain queries to retrieve the objects most similar to the query objects among the objects stored in the database (DA White, and R. Jain. "Similarity Indexing with the SS-tree ". Proc. 12th Int. Conf on Data Engineering, pages 516-523, 1996.).

A k-nearest query is a search for k objects most similar to a query object, and a spherical domain query is a method for searching all objects that satisfy a certain similarity tolerance with the query object. In order to support efficient similarity search, an index structure that can efficiently index high-dimensional data and an algorithm that can efficiently process similar queries on the index structure are essential.

However, according to the above-described prior art, any index structure that provides an efficient index for low or medium dimensional data does not provide an efficient index for high dimensional data.

The present invention addresses the limitations and problems of the prior art, and proposes a spherical pyramid technique as an algorithm capable of efficiently indexing high-dimensional data and efficiently processing spherical queries that are frequently used for similar searches. .

Furthermore, the present invention proposes an algorithm for k-nearest query processing that retrieves k-objects most similar to query objects using a spherical pyramid technique.

This results in a more efficient effect in terms of page access times, CPU usage time, and overall response time than the incremental k-nearest query processing method implemented on R * -tree and X-tree.

1 is an illustration of a spatial partitioning method of the spherical pyramid technique.

Figure 2 is an exemplary view showing the distance between the number determination process and the existing points of the spherical pyramid.

3 is an exemplary diagram of a spherical pyramid in which ten objects exist in two-dimensional space.

4 illustrates an example of the minimum distance between a query point and adjacent spherical pyramids.

5A, 5B, and 5C are exemplary diagrams illustrating a minimum distance (MINDIST) between a query point and a spherical piece.

6 is an algorithm 1 for processing a gradual nearest neighbor query.

7A, 7B, and 7C are graphs showing page access counts, CPU usage time graphs, and overall response time graphs according to database dimensions.

8A, 8B, and 8C are graphs showing page access counts, CPU usage time graphs, and total response time graphs according to database sizes.

9A, 9B, and 9C are examples of using actual data, showing page access count graphs, CPU usage time graphs, and overall response time graphs.

*** Explanation of main parts of drawing ***

10. Data Space Center Points 11. Spherical Pyramids

12. Spherical plane in dimension (d-1) 13. Spherical piece

31. Nearest point 41. Point of inquiry

The nearest query processing method using the spherical pyramid method according to the present invention comprises: a first step of dividing a d-dimensional data space into 2d spherical pyramids; Dividing the divided spherical pyramid into spherical pieces again; A third step of calculating a minimum distance between a query point and the spherical pyramid and inserting it into the ranking queue in ascending order; If the first element of the rank queue is extracted and the extracted first element is a spherical pyramid, the minimum distance between the spherical fragment and the query point in the spherical pyramid is calculated, and the spherical fragment is reinserted into the queue. If the first element is a spherical fragment, the distance between the object and the query point in the spherical fragment is calculated, and the object is reinserted into the queue. If the extracted first element is the object, the object is returned as the result of the nearest query. Step 4; characterized by including.

In the third and fourth steps, a specially defined equation may be applied to calculate the distance between the query point and each spherical pyramid or spherical piece.

Hereinafter, the present invention will be described in detail with reference to equations and drawings. However, these equations and drawings are for illustrative purposes only and the present invention is not limited thereto.

1.Spherical Pyramid Technique

The spherical pyramid technique transforms d-dimensional points into one-dimensional values, storing and accessing one-dimensional values using an efficient one-dimensional index structure such as B + -tree. This conversion is done in two steps.

In the first step, we divide the d-dimensional data space into 2d rectangular pyramids. That is, the space is divided into 2d spherical pyramids having the center point (0.5, 0.5, ..., 0.5) as the upper point and the (d-1) -dimensional spherical plane. The second stage divides into several bounding slices centered on the top point of each single spherical pyramid. This spherical piece corresponds to one page of the B + -tree.

1 and 2 illustrate a spatial division method of the spherical pyramid technique in two-dimensional space. In FIG. 1, one spherical pyramid 11 is divided into four spherical pieces 13. First, it is divided into four spherical pyramids 11 in two-dimensional space, and each spherical pyramid has the center point 10 of the space as the upper point and one curve 12 as the basis. This can be extended equally in the d-dimensional, and since the d-dimensional sphere has 2d (d-1) -dimensional spherical planes, 2d spherical pyramids can be obtained. In the d-dimension, the base becomes a (d-1) -dimensional spherical plane, not a curve. In the second step, each spherical pyramid is divided into several spherical pieces 13 with their top points centered.

Equations 1 and 2 correspond to the first and second steps of the spatial partitioning strategy of the spherical pyramid technique.

That is, in Equation 1, the point v of the d-dimensional is defined to exist in the spherical pyramid sp _i .

And, given the d-dimensional point v, the distance of the point v is defined as in Equation 2 below.

That is, as shown in FIG. 2, first, a number of a spherical pyramid to which a point v belongs is determined by using Equation 1. Then, the position of the point v is determined by the equation (2).

Finally, Equation 3 below uses the equations 1 and 2 to determine the d-dimensional point v as a one-dimensional value. Convert to

That is, given d-dimensional point v, sp _i is a spherical pyramid to which point v obtained by Equation 1 belongs, and d _v is the distance of point v obtained by Equation 2, The spherical pyramid value of is defined as in Equation 3.

For example, given the two-dimensional point v = (0.4, 0.8), by definition 1 the point v belongs to sp _{(1 + 2)} because j _max is 1 and v ₁ (= 0.8) is greater than 0.5. . Further, according to equation (2), the distance from the center to the point v is Becomes Thus, the spherical pyramid value of point v is given by )

And, the process of indexing by the spherical pyramid technique is simple. First, the d-dimensional point v is given and its spherical pyramid value (spv _v ) is determined, and then the point v is inserted into the B + -tree with this value as the key value of the B + -tree.

Then store the point v and the spherical pyramid value spv _v in the corresponding data page of the B + -tree. Updates and deletions can also be done using the B + -tree.

3 shows an example of a spherical pyramid in two-dimensional space. Suppose each sphere piece contains only one object. In FIG. 3, it can be seen that the query point q is present in the bounding slice BS ₄ on the spherical pyramid. As with most nearest query processing algorithms, the nearest query processing algorithm on the SPY-TEC first searches for objects in the data page to which the query point belongs. However, for efficient retrieval, it is necessary to measure the minimum distance between the query point and the spherical pyramid and the minimum distance between the query point and the spherical fragment. By ordering these distances, the number of pages visited unnecessarily in a search can be reduced.

2. Minimum distance between the quality point and the spherical pyramid

Equation 4 below is a theorem for the minimum distance between the query point and the spherical pyramid. In order to simplify the distance measurement process, only the case where the spherical pyramid number to which the query point belongs is smaller than the dimension d is described. Of course, if it is larger than the dimension d can be extended in a similar manner.

That is, given a query point (q = [q ₀ , q ₁ , ..., q _d-1 ]), if the spherical pyramid to which the query point belongs is sp _j (j <d), the query point and the sphere The minimum distance MINDIST (q, sp _i ) from the pyramid sp _i is defined as Equation 4 (Lemma 1).

In point mathematics, one point ([q ₀ , q ₁ , ..., q _d-1 ]) and one plane (k ₀ x ₀ + k ₁ x ₁ +, ..., k _d-1 x _d-1 Given C + 0), the minimum distance between this point and the plane is defined as the vertical line from point to plane.

Equation 4 may be proved using (i> d) and (i <d), respectively, using the distance equation.

First, if i = j, sp _i is the spherical pyramid to which the query point belongs. Therefore, MINDIST (q, sp _i ) = 0. If sp _i is the spherical pyramid opposite sp _{j that} the query point belongs to. Therefore, the minimum distance to the query point and the spherical pyramid sp _i is the upper point of sp _i , that is, the distance between the center point of space and the query point. Therefore, MINDIST (q, sp _i ) = d _q . Since the distance is based on unit space, the index k _n and the constant C of the distance equation have one of [-1, 0, 1].

If i <d, the equation on one side of the spherical pyramid sp _i adjacent to the query point, as in the two-dimensional space example of Fig. 4, becomes " k _j x _j + k _i x _i = 0 " (42). It is possible to extend the coherence even more than d-dimensional space. In the case of two-dimensional space, it is a straight line. In the case of d-dimensional space, it is a (d-1) -dimensional plane. This (d-1) -dimensional equation has the general characteristic that all indices except k _i and k _j are zero. At this time, k _j = 1 and k _i is −1 since i <d. Therefore, the minimum distance between the query point and the adjacent spherical pyramid sp _i is | q _j -q _i | / Becomes

Finally, if i> d, the equation on one side of the spherical pyramid sp _i adjacent to the query point is "k _j x _j + k _i x _i -1 = 0" (43).

At this time, k _j = 1 and k _i is 1 since i> d. Thus, the distance between the query point and the adjacent spherical pyramid sp _i is | q _j -q _i | / Becomes

3. Minimum distance between quality points and spherical pieces

Measuring the minimum distance between a query point and a spherical piece is more complicated than measuring the minimum distance between a query point and a spherical pyramid. It can be divided into spherical pieces that exist in the spherical pyramid to which the query point belongs, spherical pieces that are opposite, and spherical pieces that exist in the adjacent spherical pyramid.

Given a query point, the spherical pyramid to which the query point belongs is sp _j , and the minimum distance between the query point and the spherical fragments (BS _l ) in the spherical pyramid sp _i MINDIST (q, BS _l ) is given by Equation 5a To 5c (Lemma 2).

First, when the spherical fragment is present in the spherical pyramid to which the query point belongs (i = j), the minimum distance between the query point and the spherical fragment is expressed by Equation 5a.

Second, if the spherical fragment is in the spherical pyramid opposite the point of the query (| i-j | = d), the minimum distance is given by Equation 5b.

here, Is the distance from the point of quality to one side of the nearest spherical pyramid, With d _q One angle of a right triangle created by )to be.

Third, if the spherical piece exists in the spherical pyramid adjacent to the query point, the minimum distance is given by Equation 5c.

here, Is The length of the base of a right triangle, made by and d _q . min (BS _l ) is the smallest d _v value among the points belonging to the spherical fragment BS _l , and max (BS _l ) means the largest d _v value. Using min (BS _l ) and max (BS _l ), Equations 5a to 5c can be proved as follows.

First (Equation 5a): (1) If the query point is in BS _l , MINDIST (q, BS _l ) is zero because it must be less than or equal to the distance between the query point and any point in BS _l . . (2) If d _q > max (BS _l ), MINDIST (q, BS _l ) is the d _v of the point v farthest from the center among the points present in BS _l , i.e., max (BS _l ) and d _q . It makes a difference. (3) Finally, when d _q <min (BS _l ), MINDIST (q, BS _l ) is the d _v of the point v closest to the center among the points present in BS _l , that is, min (BS _l ) and d _q . 5A illustrates an example in which i = j in the two-dimensional space.

Second (Equation 5b), if | ij | = d, sp _i becomes the spherical pyramid opposite the spherical pyramid to which the query points belong. In this case, it is the minimum distance d _q and min (BS _l ) between the query point and the spherical piece, and the length of the base of the triangle. This can be found by the second law of cosine. First, the distance to one side of the adjacent spherical pyramid closest to the point of Let's say d _q Angle made by Is Becomes In addition, the angle of the top point of the spherical pyramid is always Since MINDIST (q, BS _l ) is based on the second law of cosine Becomes 5B shows an example in which | ij | = d as described above.

Third (Equation 5c), where sp _i is a spherical pyramid adjacent to the query point. The length of the base of the right triangle created by and d _q Say, , The minimum distance between BS _l and q is the vertical distance of sp _i from the query point q for the same reason as Becomes Meanwhile, > max (BS _l ), MINDIST (q, BS _l ) And | is the length of the hypotenuse of a right triangle created by -max (BS _l ) | And, <min (BS _l ) for the same reason And | is the length of the hypotenuse of a right triangle created by -min (BS _l ) |

4. Distance between query point and object

Distance (DIST) between the query point (q = [q ₀ , q ₁ , ..., q _d-1 ]) and one object (p = [p ₀ , p ₁ , ... p _d-1 ]) ) Is given by Equation 6 below to obtain the distance between two points.

Table 1 shows values obtained by using Equations 4 to 6 to calculate the distance between the query point q of FIG. 3, the minimum distance of each spherical pyramid SP, the spherical fragment BS, and the object OBJ. It is summarized.

5. Nearest Query Processing

And, using the above equations (4) to (5c), the algorithm for processing a gradual closest query is shown in FIG.

In lines 1 to 4 of Fig. 6 (Algorithm 1), the minimum distance between the query point and each spherical pyramid is calculated and inserted into the ranking queue using Equation 4 (Lemma 1). Then, lines 6 to 21 extract the first element of the queue until the queue is empty, and perform processing according to the element type. If the extracted element is a spherical pyramid, the minimum distance between the spherical pieces in the spherical pyramid and the query point is calculated and inserted into the queue again. If the type of the extracted element is a spherical fragment, the distance between the object and the query point in the spherical fragment is calculated and inserted into the queue again. If the last element extracted is an object, the object is returned as the result of the nearest query. Because the rank queue always has the element with the minimum distance at the front, the returned object will be the object closest to the query point.

The following shows the contents of the rank queue while Algorithm 1 of FIG. 6 is performed with respect to the example of FIG. 3.

1. Enqueue SP0 to SP3; [SP1,0], [SP2,4], [SP0,21], [SP3,33]

2. Dequeue SP1, enqueue BS3, BS4, BS5; [BS4,0], [BS5,2], [SP2,4], [BS3,14],

[SP0,21], [SP3,33]

3. Dequeue BS4, enqueue e ; [BS5,2], [SP2,4], [BS3,14], [ e , 19], [SP0,21],

[SP3,33]

4. Dequeue BS5, enqueue f ; [SP2,4], [ f , 12], [BS3,14], [ e , 19], [SP0,21],

[SP3,33]

5. Dequeue SP2, enqueue BS6, BS7; [BS7,4], [BS6,8], [ f , 12], [BS3,14], [ e , 19],

[SP0,21], [SP3,33]

6. Dequeue BS7, enqueue h ; [ h , 6], [BS6,8], [ f , 12], [BS3,14], [ e , 19],

[SP0,21], [SP3,33]

7.Dequeue h , report h as 1st nearest neighbor

Algorithm 1 of FIG. 6 begins by first measuring the distance between a query point and each spherical pyramid sp ₀ through sp ₃ and inserting it into a queue. The ranking queue of Algorithm 1 is always sorted in ascending order by distance, so that the spherical pyramid sp ₁ to which the query point belongs is at the front of the queue. Then, on line 7 of Algorithm 1 extracts the first element in the queue, and this is because older pyramid sp ₁ rectangular pieces that belong to sp ₁ BS _3, BS _4, inserted into the queue by measuring the distance from the query point with respect to the BS ₅ Done. Again, we extract BS ₄ and since it is a spherical piece, we insert all the objects in BS ₄ into the queue. In this case, only one object is assumed, so the object e is inserted into the queue. Algorithm 1 proceeds in this way, so that the object closest to the query point is at the front of the queue ( h in this example). The progressive nearest query processing algorithm can sequentially extract the nearest objects that the user wants using the rank queue.

By controlling the number of objects returned to the nearest object in the while -loop of Algorithm 1, the existing k-nearest query can be processed simply.

Comparative Example

In order to show the efficiency of the nearest query processing using the spherical pyramid scheme, a comparative experiment between R * -tree and X-tree is presented as a comparative example.

For the fair experiment, we implemented a gradual nearest query processing algorithm on R * -tree and X-tree and modified the algorithm to process k-nearest query. All experiments were performed on a Sun Sparc 20 workstation with 128M of main memory and 10GB of auxiliary storage. The block size was 4096 bytes in all index structures and the block utilization was fixed at 65%.

Example 1 (comparative example using artificial data)

Artificially generated data are 20,000 to 100,000 evenly distributed data, and the dimension of each data is 4, 8, 12, 16, 20, 24.

In the first embodiment, the number of page accesses, the CPU usage time, and the overall query response time were measured to find 10 nearest objects (10-NN) while changing the dimension of the data. 100 randomly selected query points were used and all results are averaged over 100 query processing results.

7A-7C are graphs of the results of the first embodiment. In general, as the dimension of data increases, it can be seen that the nearest query processing using the spherical pyramid technique is more efficient than the existing R * -tree or X-tree. FIG. 7A shows the number of page accesses. It can be seen that R * -tree should access almost all internal nodes and terminal nodes in more than 12 dimensions. X-trees access fewer pages than R * -trees, but like R * -trees, you can see that most pages go higher up. The spherical pyramid technique also found that although the number of data page accesses increased linearly with increasing dimensions, there were always fewer than R * -trees or X-trees, especially in 24 dimensions, 34% more than R * -trees. There is a 31% improvement in performance over the tree. The closest query processing algorithm uses more distance-using functions (such as min * max distances in R * -trees) to compare, sort, and process the nodes, which results in more CPU usage than other types of query processing, such as joins. Takes [3].

7B shows the CPU usage time. Although the nearest query processing algorithm using the spherical pyramid technique seems to be complicated to measure the minimum distance between each spherical fragment and the query point, it is possible to easily check each case and measure the minimum distance through a simple comparison operation. On the other hand, in the case of R * -tree, the higher the space, the more overlap (overlap) between the region occurs and accordingly has a disadvantage that a lot of CPU time is used to compare and calculate the distance. However, the spherical pyramid technique does not have the burden of overlapping regions because it uses a spatial partitioning method without overlapping in structure. In the case of 24D, the CPU usage time is improved by 38% over R * -tree and 35% over X-tree.

Finally, Figure 7c shows the total query response time, which is almost the same as the number of page accesses or the CPU usage time. In 24D, 45% than R * -tree and 37% than X-tree. There is a degree of performance improvement.

Example 2 (comparative example using actual data)

This embodiment measures the change in performance while changing the size of the database. Dimensions were performed fixed to 16 dimensions. 8A to 8C show the results of the present embodiment, and the results were almost similar to those of the first embodiment. It can be seen that the nearest-neighbor query processing using spherical pyramid technique for the 16-dimensional 100,000 data is processed 47% faster than the R * -tree and 35% faster than the X-tree.

In this example, 100,000 16-dimensional Fourier points representing the area of the actual CAD object were used. The query object uses 100 16-dimensional Fourier points randomly selected from the actual data, and all results are averaged for 100 queries.

We increased the number of nearest objects (k) from 1 to 10 and measured the number of page accesses, CPU usage time, and overall response time needed for query processing.

9A-9C show the results of this example.

Fig. 9A shows the number of page accesses and the nearest query processing using the X-tree, R * -tree, and the spherical pyramid technique when k changes.

When k = 1, it was found that the nearest query processing algorithm using the spherical pyramid technique retrieves the object closest to the query object (ie, the query object itself) by accessing only one data page. However, the X-tree had to access 13.45 pages, and the R * -tree had to access 16.43 pages to process the query.

Also, when k = 3 or more, it can be seen that X-tree or R * -tree should access almost all data pages. Even in the case of spherical pyramids, if k = 3 or more, we must access more data pages than if k is 1 or 2, but we always access fewer data pages than X-tree or R * -tree. there was.

CPU usage time and overall query response time also tend to be similar to the number of page accesses. When k = 10, the nearest query processing algorithm using the spherical pyramid scheme is 67% more efficient than R * -tree and 60% more than X-tree in terms of overall query response time.

That is, compared to the embodiment using the artificial data, the nearest query processing algorithm using the spherical pyramid technique shows better performance in the actual data set than the uniformly distributed data set.

As described above, the present invention proposes a method for processing a gradual nearest neighbor query using a conventional spherical pyramid technique. In addition, through various embodiments, it can be seen that this method (algorithm) is more efficient than the conventional X-tree or R * -tree incremental nearest query processing algorithm. The spherical pyramid technique is simpler than other R * -tree-based index structures and can use the B + -tree as it is, so it can take advantage of the fast insertion, search, and deletion of B + -tree.

In addition, the spherical pyramid technique can be easily implemented using B + -tree on any type of database system currently used, and thus, the concurrency control or recovery technique can be used as it is.

Through the closest query processing method using the spherical pyramid method according to the present invention, it is possible to efficiently index high-dimensional data and process more efficiently spherical queries that are frequently used for similar searches. Furthermore, using the spherical pyramid scheme according to the present invention, the algorithm for k-nearest query processing that searches k-objects most similar to the query point (query object) can be performed more efficiently.

As described above, the closest query processing method using the spherical pyramid scheme according to the present invention has a higher number of page accesses and a CPU than the progressive k-nearest query processing method implemented on R * -tree and X-tree. In terms of usage time, overall response time, etc., it is more effective.

Claims (3)

a first step of dividing the d-dimensional data space into 2d spherical pyramids; Dividing the divided spherical pyramid into spherical pieces again; A third step of calculating a minimum distance between a query point and the spherical pyramid and inserting it into the ranking queue in ascending order; If the first element of the rank queue is extracted, and the extracted first element is a spherical pyramid, the minimum distance between the spherical fragment and the query point in the spherical pyramid is calculated, and the spherical fragment is reinserted into the rank queue. If the first element is a spherical fragment, the distance between the object and the query point in the spherical fragment is calculated, and the object is reinserted into the ranking queue. If the extracted first element is an object, the object is returned as the result of the nearest query. The fourth step of the; comprising, the nearest query processing method using the spherical pyramid technique. The method of claim 1, In the third step, the minimum distance between the query point (q) and the spherical pyramid (sp _i ) MINDIST (q, sp _i ), if sp _j (j <d) the spherical pyramid to which the query point belongs, The nearest query processing method using the spherical pyramid technique, which is defined as follows. The method according to claim 1 or 2, In the fourth step, the query point _{(q) (q, BS l} ) and the minimum distance from the rectangle pyramid spherical piece (BS _l) existing in the (sp _i) MINDIST is a rectangular pyramid belonging query point sp _j La when doing, If the spherical fragment is in the spherical pyramid to which the query point belongs (i = j), Same as If the spherical fragment is present in the spherical pyramid opposite the point of the vagina (| i-j | = d), Is the distance from the point of inquiry to one side of the nearest pyramid, With d _q One angle of a right triangle created by ), Same as If the spherical piece is in a spherical pyramid that is adjacent to the query point, The length of the base of a right triangle formed by and d _q When I say The nearest query processing method using the spherical pyramid technique, which is defined as follows.