Given a user's latitude and longitude, find nearby service providers and order them by distance.

My first approach was to calculate the distance using the Haversine formula. Later, I started looking at PostGIS.

I was curious about how much difference it would actually make, so I decided to put 1 million service providers into PostgreSQL and compare the two approaches.

This is not meant to be a proper benchmark of PostGIS. I just wanted to understand what was happening in my own application.

The Setup

The service_providers table has latitude, longitude and PostGIS column: location geography(Point, 4326).

I created a GiST index on it:

CREATE INDEX idx_service_providers_location_gist
ON service_providers
USING GIST (location);

I then generated 1 million test providers.

For the test, I used:

Providers:  1,000,000
Latitude:   12.7799
Longitude:  74.8625
Radius:     20 km

Approach 1: Haversine

The first query calculates the distance using the Haversine formula directly in PostgreSQL.

SELECT p.*,
       6371 * acos(
           cos(radians(:lat)) *
           cos(radians(p.latitude)) *
           cos(radians(p.longitude) - radians(:lon)) +
           sin(radians(:lat)) *
           sin(radians(p.latitude))
       ) AS distance
FROM service_providers p
WHERE p.deleted_at IS NULL
  AND p.is_active = true
  AND (
      6371 * acos(
          cos(radians(:lat)) *
          cos(radians(p.latitude)) *
          cos(radians(p.longitude) - radians(:lon)) +
          sin(radians(:lat)) *
          sin(radians(p.latitude))
      )
  ) <= :radius
ORDER BY distance ASC;

The idea is straightforward.

For every provider, calculate the distance from the user's location, keep the providers within 20 km, and sort them by distance. The important thing I wanted to see was how PostgreSQL would execute this query with 1 million rows.

Approach 2: PostGIS

For the second approach, I used the geography type and PostGIS functions.

The query was:

SELECT p.*,
       ST_Distance(
           p.location,
           ST_SetSRID(
               ST_MakePoint(:lon, :lat),
               4326
           )::geography
       ) AS distance
FROM service_providers p
WHERE p.deleted_at IS NULL
  AND p.is_active = true
  AND ST_DWithin(
      p.location,
      ST_SetSRID(
          ST_MakePoint(:lon, :lat),
          4326
      )::geography,
      :radius * 1000
  )
ORDER BY distance ASC;

The main difference here is ST_DWithin. Instead of calculating the distance for every provider and then checking the radius, the query can use the spatial index to narrow down the candidates.

Looking at EXPLAIN ANALYZE

I ran EXPLAIN (ANALYZE, BUFFERS) on the queries.

Haversine

Result

The important part of the execution plan was: Parallel Seq Scan on service_providers. PostgreSQL was scanning the table and evaluating the distance expression.

The query reported:

Rows Removed by Filter: 329504
Execution Time: 342.822 ms

PostGIS

Result

The PostGIS query used the spatial index:

Bitmap Index Scan on idx_service_providers_location_gist

The index scan produced: actual ... rows=15818. The query then performed the spatial filtering and distance calculation on those candidates.

Execution Time: 141.533 ms

Comparision

The results from this run were:

I don't want to make much of that number because this was one test on my machine and with my particular data distribution. I found the execution plan more useful than the number itself.

The part that caught my attention was the difference in the scan.

The Haversine query was doing:

1,000,000 rows -> Parallel sequential scan -> Calculate distance 
-> Filter -> Sort

The PostGIS query was doing something closer to:

1,000,000 rows -> GiST spatial index -> 15,818 candidate rows -> ST_DWithin -> ST_Distance -> Sort

The database already has information about where the providers are. It seemed reasonable to let the database use that information before doing the more expensive distance calculation.

A small detail I noticed

The two queries returned slightly different numbers of providers (11,489 vs 11,517) . The difference comes from the fact that the Haversine calculation and PostGIS geography distance calculation use different distance calculations. Since some points are close to the 20 km boundary, small differences can affect whether a point is included.