Geo-distance query

Geo-distance query

Matches geo_point and geo_shape values within a given distance of a geopoint.

Example

Assume the following documents are indexed:

  1. resp = client.indices.create(
  2.     index="my_locations",
  3.     mappings={
  4.         "properties": {
  5.             "pin": {
  6.                 "properties": {
  7.                     "location": {
  8.                         "type": "geo_point"
  9.                     }
  10.                 }
  11.             }
  12.         }
  13.     },
  14. )
  15. print(resp)
  17. resp1 = client.index(
  18.     index="my_locations",
  19.     id="1",
  20.     document={
  21.         "pin": {
  22.             "location": {
  23.                 "lat": 40.12,
  24.                 "lon": -71.34
  25.             }
  26.         }
  27.     },
  28. )
  29. print(resp1)
  31. resp2 = client.indices.create(
  32.     index="my_geoshapes",
  33.     mappings={
  34.         "properties": {
  35.             "pin": {
  36.                 "properties": {
  37.                     "location": {
  38.                         "type": "geo_shape"
  39.                     }
  40.                 }
  41.             }
  42.         }
  43.     },
  44. )
  45. print(resp2)
  47. resp3 = client.index(
  48.     index="my_geoshapes",
  49.     id="1",
  50.     document={
  51.         "pin": {
  52.             "location": {
  53.                 "type": "polygon",
  54.                 "coordinates": [
  55.                     [
  56.                         [
  57.                             13,
  58.                             51.5
  59.                         ],
  60.                         [
  61.                             15,
  62.                             51.5
  63.                         ],
  64.                         [
  65.                             15,
  66.                             54
  67.                         ],
  68.                         [
  69.                             13,
  70.                             54
  71.                         ],
  72.                         [
  73.                             13,
  74.                             51.5
  75.                         ]
  76.                     ]
  77.                 ]
  78.             }
  79.         }
  80.     },
  81. )
  82. print(resp3)
  1. response = client.indices.create(
  2.   index: 'my_locations',
  3.   body: {
  4.     mappings: {
  5.       properties: {
  6.         pin: {
  7.           properties: {
  8.             location: {
  9.               type: 'geo_point'
  10.             }
  11.           }
  12.         }
  13.       }
  14.     }
  15.   }
  16. )
  17. puts response
  19. response = client.index(
  20.   index: 'my_locations',
  21.   id: 1,
  22.   body: {
  23.     pin: {
  24.       location: {
  25.         lat: 40.12,
  26.         lon: -71.34
  27.       }
  28.     }
  29.   }
  30. )
  31. puts response
  33. response = client.indices.create(
  34.   index: 'my_geoshapes',
  35.   body: {
  36.     mappings: {
  37.       properties: {
  38.         pin: {
  39.           properties: {
  40.             location: {
  41.               type: 'geo_shape'
  42.             }
  43.           }
  44.         }
  45.       }
  46.     }
  47.   }
  48. )
  49. puts response
  51. response = client.index(
  52.   index: 'my_geoshapes',
  53.   id: 1,
  54.   body: {
  55.     pin: {
  56.       location: {
  57.         type: 'polygon',
  58.         coordinates: [
  59.           [
  60.             [
  61.               13,
  62.               51.5
  63.             ],
  64.             [
  65.               15,
  66.               51.5
  67.             ],
  68.             [
  69.               15,
  70.               54
  71.             ],
  72.             [
  73.               13,
  74.               54
  75.             ],
  76.             [
  77.               13,
  78.               51.5
  79.             ]
  80.           ]
  81.         ]
  82.       }
  83.     }
  84.   }
  85. )
  86. puts response
  1. const response = await client.indices.create({
  2.   index: "my_locations",
  3.   mappings: {
  4.     properties: {
  5.       pin: {
  6.         properties: {
  7.           location: {
  8.             type: "geo_point",
  9.           },
  10.         },
  11.       },
  12.     },
  13.   },
  14. });
  15. console.log(response);
  17. const response1 = await client.index({
  18.   index: "my_locations",
  19.   id: 1,
  20.   document: {
  21.     pin: {
  22.       location: {
  23.         lat: 40.12,
  24.         lon: -71.34,
  25.       },
  26.     },
  27.   },
  28. });
  29. console.log(response1);
  31. const response2 = await client.indices.create({
  32.   index: "my_geoshapes",
  33.   mappings: {
  34.     properties: {
  35.       pin: {
  36.         properties: {
  37.           location: {
  38.             type: "geo_shape",
  39.           },
  40.         },
  41.       },
  42.     },
  43.   },
  44. });
  45. console.log(response2);
  47. const response3 = await client.index({
  48.   index: "my_geoshapes",
  49.   id: 1,
  50.   document: {
  51.     pin: {
  52.       location: {
  53.         type: "polygon",
  54.         coordinates: [
  55.           [
  56.             [13, 51.5],
  57.             [15, 51.5],
  58.             [15, 54],
  59.             [13, 54],
  60.             [13, 51.5],
  61.           ],
  62.         ],
  63.       },
  64.     },
  65.   },
  66. });
  67. console.log(response3);
  1. PUT /my_locations
  2. {
  3.   "mappings": {
  4.     "properties": {
  5.       "pin": {
  6.         "properties": {
  7.           "location": {
  8.             "type": "geo_point"
  9.           }
  10.         }
  11.       }
  12.     }
  13.   }
  14. }
  16. PUT /my_locations/_doc/1
  17. {
  18.   "pin": {
  19.     "location": {
  20.       "lat": 40.12,
  21.       "lon": -71.34
  22.     }
  23.   }
  24. }
  26. PUT /my_geoshapes
  27. {
  28.   "mappings": {
  29.     "properties": {
  30.       "pin": {
  31.         "properties": {
  32.           "location": {
  33.             "type": "geo_shape"
  34.           }
  35.         }
  36.       }
  37.     }
  38.   }
  39. }
  41. PUT /my_geoshapes/_doc/1
  42. {
  43.   "pin": {
  44.     "location": {
  45.       "type" : "polygon",
  46.       "coordinates" : [[[13.0 ,51.5], [15.0, 51.5], [15.0, 54.0], [13.0, 54.0], [13.0 ,51.5]]]
  47.     }
  48.   }
  49. }

Use a geo_distance filter to match geo_point values within a specified distance of another geopoint:

  1. resp = client.search(
  2.     index="my_locations",
  3.     query={
  4.         "bool": {
  5.             "must": {
  6.                 "match_all": {}
  7.             },
  8.             "filter": {
  9.                 "geo_distance": {
  10.                     "distance": "200km",
  11.                     "pin.location": {
  12.                         "lat": 40,
  13.                         "lon": -70
  14.                     }
  15.                 }
  16.             }
  17.         }
  18.     },
  19. )
  20. print(resp)
  1. response = client.search(
  2.   index: 'my_locations',
  3.   body: {
  4.     query: {
  5.       bool: {
  6.         must: {
  7.           match_all: {}
  8.         },
  9.         filter: {
  10.           geo_distance: {
  11.             distance: '200km',
  12.             'pin.location' => {
  13.               lat: 40,
  14.               lon: -70
  15.             }
  16.           }
  17.         }
  18.       }
  19.     }
  20.   }
  21. )
  22. puts response
  1. const response = await client.search({
  2.   index: "my_locations",
  3.   query: {
  4.     bool: {
  5.       must: {
  6.         match_all: {},
  7.       },
  8.       filter: {
  9.         geo_distance: {
  10.           distance: "200km",
  11.           "pin.location": {
  12.             lat: 40,
  13.             lon: -70,
  14.           },
  15.         },
  16.       },
  17.     },
  18.   },
  19. });
  20. console.log(response);
  1. GET /my_locations/_search
  2. {
  3.   "query": {
  4.     "bool": {
  5.       "must": {
  6.         "match_all": {}
  7.       },
  8.       "filter": {
  9.         "geo_distance": {
  10.           "distance": "200km",
  11.           "pin.location": {
  12.             "lat": 40,
  13.             "lon": -70
  14.           }
  15.         }
  16.       }
  17.     }
  18.   }
  19. }

Use the same filter to match geo_shape values within the given distance:

  1. resp = client.search(
  2.     index="my_geoshapes",
  3.     query={
  4.         "bool": {
  5.             "must": {
  6.                 "match_all": {}
  7.             },
  8.             "filter": {
  9.                 "geo_distance": {
  10.                     "distance": "200km",
  11.                     "pin.location": {
  12.                         "lat": 40,
  13.                         "lon": -70
  14.                     }
  15.                 }
  16.             }
  17.         }
  18.     },
  19. )
  20. print(resp)
  1. response = client.search(
  2.   index: 'my_geoshapes',
  3.   body: {
  4.     query: {
  5.       bool: {
  6.         must: {
  7.           match_all: {}
  8.         },
  9.         filter: {
  10.           geo_distance: {
  11.             distance: '200km',
  12.             'pin.location' => {
  13.               lat: 40,
  14.               lon: -70
  15.             }
  16.           }
  17.         }
  18.       }
  19.     }
  20.   }
  21. )
  22. puts response
  1. const response = await client.search({
  2.   index: "my_geoshapes",
  3.   query: {
  4.     bool: {
  5.       must: {
  6.         match_all: {},
  7.       },
  8.       filter: {
  9.         geo_distance: {
  10.           distance: "200km",
  11.           "pin.location": {
  12.             lat: 40,
  13.             lon: -70,
  14.           },
  15.         },
  16.       },
  17.     },
  18.   },
  19. });
  20. console.log(response);
  1. GET my_geoshapes/_search
  2. {
  3.   "query": {
  4.     "bool": {
  5.       "must": {
  6.         "match_all": {}
  7.       },
  8.       "filter": {
  9.         "geo_distance": {
  10.           "distance": "200km",
  11.           "pin.location": {
  12.             "lat": 40,
  13.             "lon": -70
  14.           }
  15.         }
  16.       }
  17.     }
  18.   }
  19. }

To match both geo_point and geo_shape values, search both indices:

  1. resp = client.search(
  2.     index="my_locations,my_geoshapes",
  3.     query={
  4.         "bool": {
  5.             "must": {
  6.                 "match_all": {}
  7.             },
  8.             "filter": {
  9.                 "geo_distance": {
  10.                     "distance": "200km",
  11.                     "pin.location": {
  12.                         "lat": 40,
  13.                         "lon": -70
  14.                     }
  15.                 }
  16.             }
  17.         }
  18.     },
  19. )
  20. print(resp)
  1. response = client.search(
  2.   index: 'my_locations,my_geoshapes',
  3.   body: {
  4.     query: {
  5.       bool: {
  6.         must: {
  7.           match_all: {}
  8.         },
  9.         filter: {
  10.           geo_distance: {
  11.             distance: '200km',
  12.             'pin.location' => {
  13.               lat: 40,
  14.               lon: -70
  15.             }
  16.           }
  17.         }
  18.       }
  19.     }
  20.   }
  21. )
  22. puts response
  1. const response = await client.search({
  2.   index: "my_locations,my_geoshapes",
  3.   query: {
  4.     bool: {
  5.       must: {
  6.         match_all: {},
  7.       },
  8.       filter: {
  9.         geo_distance: {
  10.           distance: "200km",
  11.           "pin.location": {
  12.             lat: 40,
  13.             lon: -70,
  14.           },
  15.         },
  16.       },
  17.     },
  18.   },
  19. });
  20. console.log(response);
  1. GET my_locations,my_geoshapes/_search
  2. {
  3.   "query": {
  4.     "bool": {
  5.       "must": {
  6.         "match_all": {}
  7.       },
  8.       "filter": {
  9.         "geo_distance": {
  10.           "distance": "200km",
  11.           "pin.location": {
  12.             "lat": 40,
  13.             "lon": -70
  14.           }
  15.         }
  16.       }
  17.     }
  18.   }
  19. }

Accepted formats

In much the same way the geo_point type can accept different representations of the geo point, the filter can accept it as well:

Lat lon as properties
  1. resp = client.search(
  2.     index="my_locations",
  3.     query={
  4.         "bool": {
  5.             "must": {
  6.                 "match_all": {}
  7.             },
  8.             "filter": {
  9.                 "geo_distance": {
  10.                     "distance": "12km",
  11.                     "pin.location": {
  12.                         "lat": 40,
  13.                         "lon": -70
  14.                     }
  15.                 }
  16.             }
  17.         }
  18.     },
  19. )
  20. print(resp)
  1. response = client.search(
  2.   index: 'my_locations',
  3.   body: {
  4.     query: {
  5.       bool: {
  6.         must: {
  7.           match_all: {}
  8.         },
  9.         filter: {
  10.           geo_distance: {
  11.             distance: '12km',
  12.             'pin.location' => {
  13.               lat: 40,
  14.               lon: -70
  15.             }
  16.           }
  17.         }
  18.       }
  19.     }
  20.   }
  21. )
  22. puts response
  1. const response = await client.search({
  2.   index: "my_locations",
  3.   query: {
  4.     bool: {
  5.       must: {
  6.         match_all: {},
  7.       },
  8.       filter: {
  9.         geo_distance: {
  10.           distance: "12km",
  11.           "pin.location": {
  12.             lat: 40,
  13.             lon: -70,
  14.           },
  15.         },
  16.       },
  17.     },
  18.   },
  19. });
  20. console.log(response);
  1. GET /my_locations/_search
  2. {
  3.   "query": {
  4.     "bool": {
  5.       "must": {
  6.         "match_all": {}
  7.       },
  8.       "filter": {
  9.         "geo_distance": {
  10.           "distance": "12km",
  11.           "pin.location": {
  12.             "lat": 40,
  13.             "lon": -70
  14.           }
  15.         }
  16.       }
  17.     }
  18.   }
  19. }
Lat lon as array

Format in [lon, lat], note, the order of lon/lat here in order to conform with GeoJSON.

  1. resp = client.search(
  2.     index="my_locations",
  3.     query={
  4.         "bool": {
  5.             "must": {
  6.                 "match_all": {}
  7.             },
  8.             "filter": {
  9.                 "geo_distance": {
  10.                     "distance": "12km",
  11.                     "pin.location": [
  12.                         -70,
  13.                         40
  14.                     ]
  15.                 }
  16.             }
  17.         }
  18.     },
  19. )
  20. print(resp)
  1. response = client.search(
  2.   index: 'my_locations',
  3.   body: {
  4.     query: {
  5.       bool: {
  6.         must: {
  7.           match_all: {}
  8.         },
  9.         filter: {
  10.           geo_distance: {
  11.             distance: '12km',
  12.             'pin.location' => [
  13.               -70,
  14.               40
  15.             ]
  16.           }
  17.         }
  18.       }
  19.     }
  20.   }
  21. )
  22. puts response
  1. const response = await client.search({
  2.   index: "my_locations",
  3.   query: {
  4.     bool: {
  5.       must: {
  6.         match_all: {},
  7.       },
  8.       filter: {
  9.         geo_distance: {
  10.           distance: "12km",
  11.           "pin.location": [-70, 40],
  12.         },
  13.       },
  14.     },
  15.   },
  16. });
  17. console.log(response);
  1. GET /my_locations/_search
  2. {
  3.   "query": {
  4.     "bool": {
  5.       "must": {
  6.         "match_all": {}
  7.       },
  8.       "filter": {
  9.         "geo_distance": {
  10.           "distance": "12km",
  11.           "pin.location": [ -70, 40 ]
  12.         }
  13.       }
  14.     }
  15.   }
  16. }
Lat lon as WKT string

Format in Well-Known Text.

  1. resp = client.search(
  2.     index="my_locations",
  3.     query={
  4.         "bool": {
  5.             "must": {
  6.                 "match_all": {}
  7.             },
  8.             "filter": {
  9.                 "geo_distance": {
  10.                     "distance": "12km",
  11.                     "pin.location": "POINT (-70 40)"
  12.                 }
  13.             }
  14.         }
  15.     },
  16. )
  17. print(resp)
  1. response = client.search(
  2.   index: 'my_locations',
  3.   body: {
  4.     query: {
  5.       bool: {
  6.         must: {
  7.           match_all: {}
  8.         },
  9.         filter: {
  10.           geo_distance: {
  11.             distance: '12km',
  12.             'pin.location' => 'POINT (-70 40)'
  13.           }
  14.         }
  15.       }
  16.     }
  17.   }
  18. )
  19. puts response
  1. const response = await client.search({
  2.   index: "my_locations",
  3.   query: {
  4.     bool: {
  5.       must: {
  6.         match_all: {},
  7.       },
  8.       filter: {
  9.         geo_distance: {
  10.           distance: "12km",
  11.           "pin.location": "POINT (-70 40)",
  12.         },
  13.       },
  14.     },
  15.   },
  16. });
  17. console.log(response);
  1. GET /my_locations/_search
  2. {
  3.   "query": {
  4.     "bool": {
  5.       "must": {
  6.         "match_all": {}
  7.       },
  8.       "filter": {
  9.         "geo_distance": {
  10.           "distance": "12km",
  11.           "pin.location": "POINT (-70 40)"
  12.         }
  13.       }
  14.     }
  15.   }
  16. }
Geohash
  1. resp = client.search(
  2.     index="my_locations",
  3.     query={
  4.         "bool": {
  5.             "must": {
  6.                 "match_all": {}
  7.             },
  8.             "filter": {
  9.                 "geo_distance": {
  10.                     "distance": "12km",
  11.                     "pin.location": "drm3btev3e86"
  12.                 }
  13.             }
  14.         }
  15.     },
  16. )
  17. print(resp)
  1. response = client.search(
  2.   index: 'my_locations',
  3.   body: {
  4.     query: {
  5.       bool: {
  6.         must: {
  7.           match_all: {}
  8.         },
  9.         filter: {
  10.           geo_distance: {
  11.             distance: '12km',
  12.             'pin.location' => 'drm3btev3e86'
  13.           }
  14.         }
  15.       }
  16.     }
  17.   }
  18. )
  19. puts response
  1. const response = await client.search({
  2.   index: "my_locations",
  3.   query: {
  4.     bool: {
  5.       must: {
  6.         match_all: {},
  7.       },
  8.       filter: {
  9.         geo_distance: {
  10.           distance: "12km",
  11.           "pin.location": "drm3btev3e86",
  12.         },
  13.       },
  14.     },
  15.   },
  16. });
  17. console.log(response);
  1. GET /my_locations/_search
  2. {
  3.   "query": {
  4.     "bool": {
  5.       "must": {
  6.         "match_all": {}
  7.       },
  8.       "filter": {
  9.         "geo_distance": {
  10.           "distance": "12km",
  11.           "pin.location": "drm3btev3e86"
  12.         }
  13.       }
  14.     }
  15.   }
  16. }

Options

The following are options allowed on the filter:

distance

The radius of the circle centred on the specified location. Points which fall into this circle are considered to be matches. The distance can be specified in various units. See Distance Units.

distance_type

How to compute the distance. Can either be arc (default), or plane (faster, but inaccurate on long distances and close to the poles).

_name

Optional name field to identify the query

validation_method

Set to IGNORE_MALFORMED to accept geo points with invalid latitude or longitude, set to COERCE to additionally try and infer correct coordinates (default is STRICT).

Multi location per document

The geo_distance filter can work with multiple locations / points per document. Once a single location / point matches the filter, the document will be included in the filter.

Ignore unmapped

When set to true the ignore_unmapped option will ignore an unmapped field and will not match any documents for this query. This can be useful when querying multiple indexes which might have different mappings. When set to false (the default value) the query will throw an exception if the field is not mapped.