Geospatial queries basics in MongoDB - Interactive Code Practice

Practice - 5 Tasks

1fill in blank

easy

Complete the code to find documents near a point using $near.

MongoDB

db.places.find({ location: { $near: { $geometry: { type: "Point", coordinates: [1] } } } })

Drag options to blanks, or click blank then click option'

A40, -70

B[40, -70]

C{40, -70}

D["40", "-70"]

Attempts:

3 left

💡 Hint

Common Mistakes

Using strings instead of numbers for coordinates.

Using curly braces instead of square brackets.

Not wrapping coordinates in an array.

The coordinates must be an array of numbers representing longitude and latitude.

2fill in blank

medium

Complete the code to find documents within a polygon using $geoWithin.

MongoDB

db.parks.find({ area: { $geoWithin: { $geometry: { type: "Polygon", coordinates: [1] } } } })

Drag options to blanks, or click blank then click option'

A{[0,0],[3,6],[6,1],[0,0]}

B[[0,0],[3,6],[6,1],[0,0]]

C[[[0,0],[3,6],[6,1],[0,0]]]

D[0,0,3,6,6,1,0,0]

Attempts:

3 left

💡 Hint

Common Mistakes

Using single array instead of nested arrays for polygon coordinates.

Not closing the polygon by repeating the first point at the end.

Using curly braces instead of square brackets.

The coordinates for a polygon must be an array of linear rings, so an array inside an array.

3fill in blank

hard

Fix the error in the query to find documents near a point with max distance.

MongoDB

db.stores.find({ location: { $near: { $geometry: { type: "Point", coordinates: [ -73.97, 40.77 ] }, $maxDistance: [1] } } })

Drag options to blanks, or click blank then click option'

A1000

B"1000"

C[1000]

D{1000}

Attempts:

3 left

💡 Hint

Common Mistakes

Using a string instead of a number for $maxDistance.

Using an array or object instead of a number.

Omitting $maxDistance or placing it incorrectly.

The $maxDistance value must be a number, not a string or array.

4fill in blank

hard

Fill both blanks to find documents within a circle using $geoWithin and $centerSphere.

MongoDB

db.locations.find({ position: { $geoWithin: { $centerSphere: [ [1], [2] ] } } })

Drag options to blanks, or click blank then click option'

A[ -73.97, 40.77 ]

B40.77

C0.01

D[ -73.97, 40.77, 0.01 ]

Attempts:

3 left

💡 Hint

Common Mistakes

Putting the radius inside the coordinates array.

Using latitude before longitude in coordinates.

Using degrees instead of radians for radius.

The first blank is the center point as an array of coordinates. The second blank is the radius in radians.

5fill in blank

hard

Fill all three blanks to find documents near a point with min and max distance.

MongoDB

db.places.find({ location: { $near: { $geometry: { type: "Point", coordinates: [1] }, $minDistance: [2], $maxDistance: [3] } } })

Drag options to blanks, or click blank then click option'

A[ -73.97, 40.77 ]

B500

C2000

D[ 40.77, -73.97 ]

Attempts:

3 left

💡 Hint

Common Mistakes

Swapping latitude and longitude in coordinates.

Using strings instead of numbers for distances.

Omitting $minDistance or $maxDistance.

The coordinates must be longitude then latitude. $minDistance and $maxDistance are numbers in meters.

Practice

1. What does the $near operator do in MongoDB geospatial queries?

easy

A. Finds documents with locations closest to a specified point

B. Deletes documents within a certain distance

C. Updates documents with new coordinates

D. Sorts documents alphabetically by location name

Solution

1. Step 1: Understand the purpose of $near

   The $near operator is used to find documents that are geographically close to a given point.

2. Step 2: Compare options with $near functionality

   Only Finds documents with locations closest to a specified point correctly describes finding documents near a location. Other options describe unrelated actions.

3. Final Answer:

   Finds documents with locations closest to a specified point -> Option A

4. Quick Check:

   $near = Finds nearby points [OK]

Hint: Remember: $near finds closest points to a location [OK]

Common Mistakes:

• Thinking $near deletes or updates documents
• Confusing $near with sorting operators
• Assuming $near works without a geospatial index

2. Which of the following is the correct syntax to find documents near a point using $near in MongoDB?

easy

A. { location: { $near: { $geometry: { type: 'Point', coordinates: [-70, 40] } } } }

B. { location: { $near: { $geometry: { type: 'Point', coordinates: [40, -70] } } } }

C. { location: { $near: { $geometry: { type: 'Point', coordinates: [70, 40] } } } }

D. { location: { $near: { $geometry: { type: 'Point', coordinates: [-40, 70] } } } }

Solution

1. Step 1: Recall coordinate order in MongoDB

   Coordinates must be in [longitude, latitude] order, so longitude comes first.

2. Step 2: Check each option's coordinate order

   { location: { $near: { $geometry: { type: 'Point', coordinates: [-70, 40] } } } } uses [-70, 40], which is [longitude, latitude]. Others have latitude first or wrong signs.

3. Final Answer:

   { location: { $near: { $geometry: { type: 'Point', coordinates: [-70, 40] } } } } -> Option A

4. Quick Check:

   Coordinates = [longitude, latitude] [OK]

Hint: Coordinates always [longitude, latitude] in MongoDB [OK]

Common Mistakes:

• Swapping latitude and longitude order
• Using positive latitude as longitude
• Forgetting to use $geometry inside $near

3. Given a collection with a 2dsphere index on location, what will this query return?

{ location: { $near: { $geometry: { type: 'Point', coordinates: [-73.97, 40.77] }, $maxDistance: 500 } } }

medium

A. All documents regardless of location

B. Documents with locations within 500 meters of [-73.97, 40.77]

C. Documents with locations more than 500 meters away

D. Documents with locations exactly at [-73.97, 40.77]

Solution

1. Step 1: Understand $near with $maxDistance

   The query finds documents near the point within the maximum distance specified (500 meters).

2. Step 2: Interpret the query result

   It returns documents whose location is within 500 meters of the given coordinates, not exactly at or beyond that distance.

3. Final Answer:

   Documents with locations within 500 meters of [-73.97, 40.77] -> Option B

4. Quick Check:

   $near + $maxDistance = nearby points within distance [OK]

Hint: Use $maxDistance to limit how far results can be [OK]

Common Mistakes:

• Thinking $maxDistance means exact match
• Assuming it returns points beyond maxDistance
• Ignoring the need for a 2dsphere index

4. You run this query but get an error:

{ location: { $near: { $geometry: { type: 'Point', coordinates: [40.77, -73.97] } } } }

What is the most likely cause?

medium

A. Coordinates are in wrong order; should be [longitude, latitude]

B. Missing $maxDistance parameter

C. The location field is not indexed with 2dsphere

D. The type should be 'Polygon' instead of 'Point'

Solution

1. Step 1: Requirements for $near with $geometry

   The $near operator with $geometry requires a 2dsphere index on the location field.

2. Step 2: Identify the most likely error cause

   Without a 2dsphere index, MongoDB throws an error for geospatial queries like $near. Coordinate order affects results but does not cause an error.

3. Final Answer:

   The location field is not indexed with 2dsphere -> Option C

4. Quick Check:

   $near requires 2dsphere index [OK]

Hint: Always put longitude before latitude in coordinates [OK]

Common Mistakes:

• Swapping latitude and longitude
• Assuming $maxDistance is required
• Confusing geometry types

5. You want to find all restaurants within 1 km of a user's location stored as { type: 'Point', coordinates: [-122.42, 37.77] }. Which query correctly finds these restaurants assuming a 2dsphere index on location?

hard

A. { location: { $near: { $geometry: { type: 'Point', coordinates: [-122.42, 37.77] }, $minDistance: 1000 } } }

B. { location: { $geoWithin: { $centerSphere: [[-122.42, 37.77], 1] } } }

C. { location: { $nearSphere: { $geometry: { type: 'Point', coordinates: [37.77, -122.42] }, $maxDistance: 1000 } } }

D. { location: { $near: { $geometry: { type: 'Point', coordinates: [-122.42, 37.77] }, $maxDistance: 1000 } } }

Solution

1. Step 1: Identify correct coordinate order and operator

   Coordinates must be [longitude, latitude], so [-122.42, 37.77] is correct. The $near operator with $maxDistance finds points within distance.

2. Step 2: Evaluate each option

   { location: { $near: { $geometry: { type: 'Point', coordinates: [-122.42, 37.77] }, $maxDistance: 1000 } } } uses correct coordinates and $near with $maxDistance 1000 meters (1 km). { location: { $geoWithin: { $centerSphere: [[-122.42, 37.77], 1] } } } uses $geoWithin with radius in radians, not meters. { location: { $nearSphere: { $geometry: { type: 'Point', coordinates: [37.77, -122.42] }, $maxDistance: 1000 } } } swaps coordinates. { location: { $near: { $geometry: { type: 'Point', coordinates: [-122.42, 37.77] }, $minDistance: 1000 } } } uses $minDistance which finds points farther than 1 km, not within.

3. Final Answer:

   { location: { $near: { $geometry: { type: 'Point', coordinates: [-122.42, 37.77] }, $maxDistance: 1000 } } } -> Option D

4. Quick Check:

   $near + $maxDistance + correct coords = find nearby points [OK]

Hint: Use $near with $maxDistance and correct coords for nearby search [OK]

Common Mistakes:

• Swapping latitude and longitude
• Using $minDistance instead of $maxDistance
• Confusing meters with radians in $geoWithin