# Nearest Neighbors

### Nearest Neighbors

Hi Folks,

Spatial users often want to find the object nearest a given point.  This operation, usually referred to as nearest neighbor search, is remarkably common in many areas of computer science.  In general, we may wish to find not only the nearest, but the k-nearest neighbors.

How can we accomplish this with SQL Server?  Here we’ll look at finding the single nearest neighbor; the extension to k-nearest neighbors is relatively straight forward.

First, let's examine the naive method for accomplishing this: simply order the table by distance and restrict the results.  For all of these examples, we’ll assume a table T with a spatial column g, as well as a parameter @x containing the search point:

`SELECT TOP(1) *`
`FROM T `
`ORDER BY g.STDistance(@x) ASC`

This solution certainly has simplicity on its side, but consider the work that needs to be done.  The entire table must be scanned, and the distance of each to the search point must be calculated.  Ouch.

We could conceivably improve on this by restricting our search space to to the immediate region around the target point:

`DECLARE @region geography = @x.STBuffer(10000)`
` `
`SELECT TOP(1) *`
`FROM T `
`WHERE g.Filter(@region) = 1`
`ORDER BY g.STDistance(@x) ASC`

But this solution requires that we know our data very well: if there are no rows in the region, then we will fail to find the nearest neighbor; if there are too many, then we will again be left with a rather inefficient query.

How do we escape this morass?  We can do so by starting with a very small region---so small that we can be certain not to encounter too many results---and then keep enlarging it until we find something.  Doing this with a loop is not hard, but Steven Hemingray showed me how to do this with entirely declarative syntax:

`DECLARE @start FLOAT = 1000; `
` `
`WITH NearestPoints AS`
`(`
`   SELECT TOP(1) WITH TIES *,  T.g.STDistance(@x) AS dist`
`   FROM Numbers JOIN T WITH(INDEX(spatial_index)) `
`   ON T.g.STDistance(@x) < @start*POWER(2,Numbers.n)`
`   ORDER BY n`
`)`
`SELECT TOP(1) * FROM NearestPoints`
`ORDER BY n, dist`

This requires some explanation.  First, the @start parameter gives the initial region to search.  I’ve chosen one kilometer, but this can be adjusted downward if your data is very dense.  Second, you’ll notice that we make use of a Numbers table, which just contains the numbers 1 through n.  This  just contains a long list of integers, which is is useful in many situations.

The inner query examines a set of exponentially-expanding regions.  The ORDER BY clause along with the TOP(1) allows the query to stop as soon as it finds the smallest non-empty region.  The WITH TIES statement makes sure that all of the objects in that region will be in the result set.

Once the inner query returns a list of potential results, the outer query examines them to find which is actually nearest.  With this approach, we can select a start area small enough to keep the cost low in dense data, but also be guaranteed to find a distant nearest neighbor.

Incidentally, if you don’t already have a numbers table, you can create one quite quickly with some mildly-black magic like this:

`SELECT TOP 100000 IDENTITY(int,1,1) AS n `
`INTO numbers `
`FROM MASTER..spt_values a, MASTER..spt_values b`
` `
`CREATE UNIQUE CLUSTERED INDEX idx_1 ON numbers(n)`

This isn’t a particularly pretty solution, but to proactively answer a question, we didn’t add a method for this primarily because we ran out of time.  Look for something more built-in the next go around.

Cheers,
-Isaac

• I have a table with name, geom, type that have streets (linestrings)

I try to get the nearest 10 streets, but sometimes the same street have various records, how I can group by same name and make a union of the geom (the various linestrings on one) ? any help will be greatly appreciated (sorry me bad english)

Page 2 of 2 (16 items) 12