Firestore附近GeoQuery失效：仅返回单维度范围结果的解决方法求助

Hey there, I’ve dealt with this exact Firestore geoquery issue before using that common single-axis range approach—let’s walk through how to fix it properly.

The Root of the Problem #

The code you’re using only filters on either latitude or longitude (depending on your whereField call), so it’s pulling back a long, narrow slice of points instead of a bounded rectangular area that approximates your target circle. To get actual nearby points, we need to filter both axes first, then refine with a precise distance calculation.

Step-by-Step Solution #

Here’s the updated code that fixes the issue, with explanations along the way:

1. Full Query with Dual-Axis Range Filter

First, we’ll query for all points within a rectangular boundary around your target coordinates (this requires a Firestore composite index, which Firestore will prompt you to create if you don’t have it):

func getDocumentNearBy(latitude: Double, longitude: Double, distance: Double) {
    // Convert distance (miles) to approximate latitude/longitude degree ranges
    let latPerMile = 0.0144927536231884 // ~1 mile in latitude degrees
    // Adjust longitude range based on target latitude (since longitude degrees shrink near poles)
    let lonPerMile = 0.0181818181818182 * cos(latitude * .pi / 180.0)
    
    // Calculate min/max bounds for both axes
    let minLat = latitude - (latPerMile * distance)
    let maxLat = latitude + (latPerMile * distance)
    let minLon = longitude - (lonPerMile * distance)
    let maxLon = longitude + (lonPerMile * distance)
    
    // Query Firestore for points within the rectangular bounds
    let nearbyQuery = Firestore.firestore()
        .collection("your_collection_name") // Replace with your actual collection name
        .whereField("lat", isGreaterThanOrEqualTo: minLat)
        .whereField("lat", isLessThanOrEqualTo: maxLat)
        .whereField("lon", isGreaterThanOrEqualTo: minLon)
        .whereField("lon", isLessThanOrEqualTo: maxLon)
    
    nearbyQuery.getDocuments { snapshot, error in
        guard let snapshot = snapshot, error == nil else {
            print("Error fetching docs: \(error!.localizedDescription)")
            return
        }
        
        // 2. Refine results with precise spherical distance calculation
        let validNearbyDocs = snapshot.documents.filter { doc in
            guard let docLat = doc["lat"] as? Double,
                  let docLon = doc["lon"] as? Double else {
                return false // Skip docs missing lat/lon fields
            }
            // Check if the point is within the actual target distance
            return self.calculateSphericalDistance(from: (latitude, longitude), to: (docLat, docLon)) <= distance
        }
        
        // Handle your final results here
        print("Found \(validNearbyDocs.count) valid nearby documents:")
        validNearbyDocs.forEach { print($0.data()) }
    }
}

2. Add a Precise Distance Calculator

We use the Haversine formula to calculate the actual spherical distance between two coordinates (since Earth isn’t flat!):

// Calculates distance between two coordinates in miles
func calculateSphericalDistance(from start: (lat: Double, lon: Double), to end: (lat: Double, lon: Double)) -> Double {
    let earthRadiusMiles = 3956.0
    let dLat = (end.lat - start.lat) * .pi / 180.0
    let dLon = (end.lon - start.lon) * .pi / 180.0
    
    let a = sin(dLat/2) * sin(dLat/2) +
            cos(start.lat * .pi / 180.0) * cos(end.lat * .pi / 180.0) *
            sin(dLon/2) * sin(dLon/2)
    let c = 2 * atan2(sqrt(a), sqrt(1 - a))
    
    return earthRadiusMiles * c
}

Key Notes #

• Composite Index Requirement: When you run this query for the first time, Firestore will log an error with a direct link to create the required composite index (for lat and lon ranges). Just click the link and follow the prompts—it’s fully automatic.
• Why the Two-Step Process?: Firestore doesn’t support native circular geoqueries, so we first use a rectangle to narrow down results (reducing the number of docs we need to process client-side), then filter to get only points within the actual circle.
• Improved Longitude Accuracy: The lonPerMile calculation adjusts for the target latitude, so the rectangular bounds are more tightly aligned with your target circle, cutting down on unnecessary docs to filter.

For Larger Datasets #

If you’re working with thousands of documents, consider using GeoHashes to optimize the initial query. GeoHashes encode coordinates into strings, so you can query for nearby GeoHash prefixes to get a smaller set of candidate docs before filtering by distance.

内容的提问来源于stack exchange，提问作者Calonca