Delete By

About this method

Remove all objects matching a filter (including geo filters).

This method enables you to delete one or more objects based on filters (numeric, facet, tag or geo queries).

It does not accept empty filters or a query.

This method should only be used if you cannot get the list of objectIDs you want to delete; These operations cannot be processed in parallel by the engine. If possible, use the delete method instead which is significantly more performant.

The delete by method only counts as 1 operation - even if it deletes more than one object. This is exceptional; most indexing options that affect more than one object normally count each object as a separate operation.

When sending multiple deleteBy operations, be aware of our rate limit. You’ll know you’ve reached the rate limit when you start receiving errors on your indexing operations. This can only be resolved if you wait before sending any further indexing operations.

Note this is an expensive operation:

• when you have more than 100 requests pending, your requests will be throttled.
• when you have more than 5000 requests pending, further requests will be ignored.
• if needed, these values can be tuned through configuration.

Examples

Delete records by filter

1
2
3
4
5
$index->deleteBy([
  'filters' => 'category:cars',
  'aroundLatLng' => '40.71, -74.01'
  /* add any filter parameters */
]);

1
2
3
4
5
params = {
  filters: 'category:cars',
  aroundLatLng: '40.71, -74.01'
}
index.delete_by(params)

1
2
3
4
5
6
7
8
index.deleteBy({
  filters: 'category:cars',
  aroundLatLng: '40.71, -74.01'
}, (err, content) => {
  if (err) throw err;

  console.log(content);
});

1
2
3
4
index.delete_by({
  'filters': 'category:cars',
  'aroundLatLng': '40.71, -74.01'
})

1
2
3
4
5
6
7
8
9
10
let query = Query();

query.filters = "category:cars"
query.aroundLatLng = LatLng(lat: 40.71, lng: -74.01)

index.deleteBy(query, completionHandler: { (content, error) -> Void in
    if error != nil {
        print("Error deleting objects")
    }
})

1
2
3
4
Query query = new Query()
  .setFilters("category:cars")
  .setAroundLatLng(new LatLng(40.71, -74.01))
index.deleteByAsync(query, null);

1
2
3
4
5
6
var query = new Query { Filters = "category:cars", AroundLatLng = "40.71, -74.01" };

index.DeleteBy(query);

// Asynchronous
await index.DeleteByAsync(query);

1
2
3
4
5
6
7
8
9
Query query = new Query("query")
  .setFilters("category:cars")
  .setAroundLatLng("40.71, -74.01")

// Sync version
index.deleteBy(query);

// Async version
index.deleteByAsync(query);

1
2
3
4
res, err := index.DeleteBy(
    opt.Filters("category:cars"),
    opt.AroundLatLng("40.71, -74.01"),
)

1
2
3
4
5
6
delete from "testDeleteBy" by Query(
  filters = Some("price > 10"),
  aroundLatLng = Some(
    AroundLatLng("40.71, -74.01")
  )
)

1
2
3
4
5
6
val query = DeleteByQuery(
    filters = "category:car",
    aroundLatLng = Point(40.71f, -74.01f)
)

index.deleteObjectsBy(query)

Delete records by filter and send extra http headers

1
2
3
4
5
6
7
8
9
$params = [
  'filters' => 'category:cars',
  'aroundLatLng' => '40.71, -74.01'
  /* add any filter parameters */
];

$index->deleteBy($params, [
  'X-Algolia-User-ID' => 'user123'
]);

1
2
3
4
5
6
7
8
9
params = {
  filters: 'category:cars'
}

extra_headers = {
  'X-Algolia-User-ID': 'user123'
}

index.delete_by(params, extra_headers)

1
2
3
4
5
6
7
8
9
client.setExtraHeader('X-Forwarded-For', '94.228.178.246');

index.deleteBy({
  filters: 'category:cars',
}, (err, content) => {
  if (err) throw err;

  console.log(content);
});

1
2
3
4
5
6
7
params = {
  # any filter parameters
}

index.delete_by(params, {
    'X-Algolia-User-ID': 'user123'}
)

1
2
3
4
5
6
7
8
9
10
11
12
let query: Query = /* any filter parameters */
let requestOptions = RequestOptions()
requestOptions.headers["X-Algolia-User-ID"] = "user123"
index.deleteBy(
  query,
  requestOptions: requestOptions,
  completionHandler: { (content, error) -> Void in
    if error != nil {
        print("Error deleting objects")
    }
  }
)

1
2
3
4
5
6
7
8
Query query = /* any filter parameters */;

index.deleteByAsync(
  query,
  new RequestOptions()
    .setHeader("X-Algolia-User-ID", "94.228.178.246"),
  null
);

1
2
3
4
5
6
7
8
9
10
11
var query = new Query { Filters = "category:cars", AroundLatLng = "40.71, -74.01" };

RequestOptions requestOptions = new RequestOptions
{
    Headers = new Dictionary<string,string>{ { "X-Algolia-User-ID", "user123" } }
};

index.DeleteBy(query, requestOptions);

// Asynchronous
await index.DeleteByAsync(query, requestOptions);

1
2
3
4
5
6
7
8
9
10
RequestOptions requestOptions = 
  new RequestOptions().addExtraHeader("X-Algolia-User-ID", "user123");

// Sync version
Query query = /* any filter parameters */;
index.deleteBy(query, requestOptions);

// Async version
Query query = /* any filter parameters */;
index.deleteByAsync(query, requestOptions);

1
2
3
4
5
res, err := index.DeleteBy(
    opt.Filters("category:cars"),
    // Add any filter parameter
    opt.ExtraHeaders(map[string]string{"X-Algolia-User-ID": "userID2"}),
)

1
2
3
4
delete from "testDeleteBy" by Query(filters = Some("price > 10"))
  options RequestOptions(
  ` extraHeaders = Some(Map("X-Algolia-User-ID" => "user123"))
  )

1
2
3
4
5
6
7
8
9
val query = DeleteByQuery(
    filters = "category:car",
    aroundLatLng = Point(40.71f, -74.01f)
)
val requestOptions = requestOptions {
    headerAlgoliaUserId(UserID("user123"))
}

index.deleteObjectsBy(query, requestOptions)