使用 2d 索引查询地理空间

Proximity Queries¶

Proximity queries select the documents closest to the point specified in the query. To perform proximity queries you use either the find() method with the $near operator or you use the geoNear command.

The find() method with the $near operator returns 100 documents by default and sorts the results by distance. The $near operator uses the following form:

db.collection.find( { <location field>: { $near: [ x, y ] } } )

db.places.find( { loc: { $near: [ -70, 40 ] } } )

{ "_id" : ObjectId(" ... "), "loc" : [ -73, 39 ] }

The geoNear command returns more information than does the $near operator. The geoNear command can only return a single 16-megabyte result set. The geoNear command also offers additional operators, such as operators to query for maximum or spherical distance. For a list of operators, see geoNear.

Without additional operators, the geoNear command uses the following form:

db.runCommand( { geoNear: "[collection]", near: [ x, y ] } )

db.runCommand( { geoNear: "places", near: [ -74, 40.74 ] } )

Distance Queries¶

You can limit a proximity query to those documents that fall within a maximum distance of a point. You specify the maximum distance using the units specified by the coordinate system. For example, if the coordinate system uses meters, you specify maximum distance in meters.

To specify distance using the find() method, use $maxDistance operator. Use the following form:

db.collection.find( { <location field> : { $near : [ x , y ] , $maxDistance : <distance> } } )

To specify distance with the geoNear command, use the maxDistance option. Use the following form:

db.runCommand( { geoNear: "collection", near: [ x, y ], maxDistance: <distance> } )

Limit the Number of Results¶

By default, geospatial queries using find() method return 100 documents, sorted by distance. To limit the result when using the find() method, use the limit() method, as in the following prototype:

db.collection.find( { <location field>: { $near: [ x, y ] } } ).limit(<n>)

To limit the result set when using the geoNear command, use the num option. Use the following form:

db.runCommand( { geoNear: "collection", near: [ x, y ], num: z } )

To limit geospatial search results by distance, see Distance Queries.

db.collection.find( { <location field> :
                           { "$within" :
                             { <shape> : <shape dimensions> }
                           }
                    } )

Circles¶

To query for documents with coordinates inside the bounds of a circle, specify the center and the radius of the circle using the $within operator and $center option. Consider the following prototype query:

db.collection.find( { "field": { "$within": { "$center": [ center, radius ] } } } )

The following example query returns all documents that have coordinates that exist within the circle centered on [-74, 40.74] and with a radius of 10, using a geospatial index on the loc field:

db.places.find( { "loc": { "$within":
                            { "$center": [ [-74, 40.74], 10 ] }
                         }
                } )

The $within operator using $center is similar to using $maxDistance, but $center has different performance characteristics. MongoDB does not sort queries that use the $within operator are not sorted, unlike queries using the $near operator.

Rectangles¶

To query for documents with coordinates inside the bounds of a rectangle, specify the lower-left and upper-right corners of the rectangle using the $within operator and $box option. Consider the following prototype query:

db.collection.find( { "field": { "$within": { "$box": [ coordinate0, coordinate1 ] } } } )

The following query returns all documents that have coordinates that exist within the rectangle where the lower-left corner is at [ 0, 0 ] and the upper-right corner is at [ 3, 3 ], using a geospatial index on the loc field:

db.places.find( { "loc": { "$within": { "$box": [ [0, 0] , [3, 3] ] } } } )

Polygons¶

1.9 新版功能: Support for polygon queries.

To query for documents with coordinates inside of a polygon, specify the points of the polygon in an array, using the $within operator with the $polygon option. MongoDB automatically connects the last point in the array to the first point. Consider the following prototype query:

db.places.find({ "loc": { "$within": { "$polygon": [ points ] } } })

The following query returns all documents that have coordinates that exist within the polygon defined by [ [0,0], [3,3], [6,0] ]:

db.places.find({ "loc": { "$within": { "$polygon":
                                     [ [ 0,0], [3,3], [6,0] ] } } } )

db.collection.find( { <location field>: [ x, y ] } )

db.runCommand( { geoNear: "places",
                 near: [ -74, 40.74 ],
                 spherical: true,
                 distanceMultiplier: 3963.192
               }  )

{
   // [ ... ]
   "results" : [
      {
         "dis" : 73.46525170413567,
         "obj" : {
            "_id" : ObjectId( ... )
            "loc" : [
               -73,
               40
            ]
         }
      }
   ],
   "stats" : {
      // [ ... ]
      "avgDistance" : 0.01853688938212826,
      "maxDistance" : 0.01853714811400047
   },
   "ok" : 1
}

db.runCommand( { geoSearch: <collection>,
                 search: { <field>: <value> } } )

db.runCommand( { geoSearch: "places",
                 search: { type: "restaurant" },
                 near: [-74, 40.74] } )