Delete Objects

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)

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)

1
2
3
4
5
6
7
8
9
object_ids = [
  # your objectIDs
]

index.delete_objects(objects_ids, {
  headers: {
    'X-Forwarded-For': '94.228.178.246'
  }
})

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)