Delete By | Ruby API Client V1 (Deprecated)

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

1
2
3
4
5
6
index.deleteBy({
  filters: 'category:cars',
  aroundLatLng: '40.71, -74.01'
).then(() => {
  // done
});

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
var query = DeleteByQuery()

query.filters = "category:cars"
query.aroundLatLng = .init(latitude: 40.71, longitude: -74.01)

index.deleteObjects(byQuery: query) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

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)

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
10
11
12
13
const params = {
  'filters': 'category:cars',
  'aroundLatLng': '40.71, -74.01'
  /* add any filter parameters */
};

index.deleteBy(params, {
  headers: {
    'X-Algolia-User-ID': 'user123'
  }
}).then(() => {
  // done
});

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
13
var requestOptions = RequestOptions()
requestOptions.headers["X-Algolia-User-ID"] = "user123"

var query = DeleteByQuery()

query.filters = "category:cars"
query.aroundLatLng = .init(latitude: 40.71, longitude: -74.01)

index.deleteObjects(byQuery: query, requestOptions: requestOptions) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

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)