This version of the Ruby API client has been deprecated in favor of the latest version of the Ruby API client.
Required API Key: any key with the deleteObject ACL
Remove objects from an index using their object ids.
This method enables you to remove one or more objects from an index.
There are 2 methods available to delete objects:
- this one, which uses an objectID to identify objects
- and delete by, which uses filters to identify objects
Note: This method also has a singular version.
Delete multiple objects using their objectIDs#
1
| $index->deleteObjects(["myID1", "myID2"]);
|
1
| index.delete_objects(['myID1', 'myID2'])
|
1
2
3
| index.deleteObjects(['myID1', 'myID2']).then(({ objectIDs }) => {
console.log(objectIDs);
});
|
1
| index.delete_objects(['myID1', 'myID2'])
|
1
2
3
4
5
| index.deleteObjects(withIDs: ["myID1", "myID2"]) { result in
if case .success(let response) = result {
print("Response: \(response)")
}
}
|
1
| index.deleteObjectsAsync(Arrays.asList("myID1", "myID2"), null);
|
1
2
3
4
5
6
| List<string> ids = new List<string> { "myID1", "myID2" };
index.DeleteObjects(ids);
// Asynchronous
await index.DeleteObjectsAsync(ids);
|
1
2
3
4
5
| // Sync version
index.deleteObjects(Arrays.asList("myID1", "myID2"));
// Async version
index.deleteObjectsAsync(Arrays.asList("myID1", "myID2"));
|
1
2
3
| res, err := index.DeleteObjects(
[]string{"myID1", "myID2"},
)
|
1
2
3
| client.execute {
delete from "test1" objectIds Seq("1", "2")
}
|
1
2
3
| val objectIDS = listOf(ObjectID("myID1"), ObjectID("myID2"))
index.deleteObjects(objectIDS)
|
Delete a single object#
1
| $index->deleteObject('myID');
|
1
| index.delete_object('myID')
|
1
2
3
| index.deleteObject('myID').then(() => {
// done
});
|
1
| index.delete_object('myID')
|
1
2
3
4
5
| index.deleteObject(withID: "myID") { result in
if case .success(let response) = result {
print("Response: \(response)")
}
}
|
1
| index.deleteObjectAsync("myID", null);
|
1
2
3
4
| index.DeleteObject("myID");
// Asynchronous
await index.DeleteObjectAsync("myID");
|
1
2
3
4
5
| // Sync version
index.deleteObject("myID");
// Async version
index.deleteObjectAsync("myID");
|
1
| res, err := index.DeleteObject("myID")
|
1
| client.execute { delete from "myIndex" objectId "myId" }
|
1
2
3
| val objectID = ObjectID("myID1")
index.deleteObject(objectID)
|
Delete multiple objects and send extra HTTP headers#
1
2
3
4
5
| $objectIDs = [/* objectIDs */];
$index->deleteObjects($objectIDs, [
'X-Forwarded-For' => '94.228.178.246'
]);
|
1
2
3
4
5
6
7
| extra_headers = {
'X-Forwarded-For': '94.228.178.246'
}
object_ids = []
index.delete_objects(objects_ids, extra_headers)
|
1
2
3
4
5
6
7
8
9
| const objectIDs = [/** objectIDs */];
index.deleteObjects(objectIDs, {
headers: {
'X-Forwarded-For': '94.228.178.246'
}
}).then(({ objectIDs }) => {
console.log(objectIDs);
});
|
1
2
3
4
| objectIDs = [
# objectIDs
]
index.delete_objects(objectIDs, {'X-Forwarded-For': '94.228.178.246'})
|
1
2
3
4
5
6
7
8
| var requestOptions = RequestOptions()
requestOptions.headers["X-Algolia-User-ID"] = "user123"
index.deleteObjects(withIDs: ["myID"], requestOptions: requestOptions) { result in
if case .success(let response) = result {
print("Response: \(response)")
}
}
|
1
2
3
4
5
6
| index.deleteObjectsAsync(
Arrays.asList("myID1", "myID2"),
new RequestOptions()
.setHeader("X-Algolia-User-ID", "94.228.178.246"),
null
);
|
1
2
3
4
5
6
7
8
9
| RequestOptions requestOptions = new RequestOptions
{
Headers = new Dictionary<string,string>{ { "X-Algolia-User-ID", "user123" } }
};
index.DeleteObject("myID", requestOptions);
// Asynchronous
await index.DeleteObjectAsync("myID", requestOptions);
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
| RequestOptions requestOptions =
new RequestOptions().addExtraHeader("X-Algolia-User-ID", "user123");
// Sync version
index.deleteObjects(
Arrays.asList("myID1", "myID2"),
requestOptions
);
// Async version
index.deleteObjectsAsync(
Arrays.asList("myID1", "myID2"),
requestOptions
);
|
1
2
3
4
5
6
7
8
| extraHeaders := opt.ExtraHeaders(map[string]string{
"X-Algolia-User-ID": "userID2",
})
res, err := index.DeleteObjects(
[]string{"myID1", "myID2"},
extraHeaders,
)
|
1
2
3
4
5
6
| client.execute {
delete from "test1" objectIds Seq("1", "2")
options RequestOptions(
extraHeaders = Some(Map("X-Algolia-User-ID" => "user123"))
)
}
|
1
2
3
4
5
6
| val objectIDS = listOf(ObjectID("myID1"), ObjectID("myID2"))
val requestOptions = requestOptions {
headerAlgoliaUserId(UserID("user123"))
}
index.deleteObjects(objectIDS, requestOptions)
|
objectIDs
# |
List of objectIDs to delete.
|
requestOptions
# |
type: key/value mapping
default: No request options
Optional
A mapping of request options to send along with the query.
|
objectID
# |
type: integer|string
Required
The objectID of the object to delete.
|
In this section we document the JSON response returned by the API.
Each language will encapsulate this response inside objects specific to the language and/or the implementation.
So the actual type in your language might differ from what is documented.
JSON format#
1
2
3
4
5
6
7
| {
"objectIDs": [
"myObjectID1",
"myObjectID2"
],
"taskID": 678,
}
|
objectIDs
# |
List of the objectIDS of the deleted objects.
|
taskID
# |
The taskID used with the waitTask method.
|
