API client / Methods / Indexing

Jun. 08, 2023

Replace all objects

Required API Key: any key with the addObject ACL

Method signature

$index->replaceAllObjects(array objects);

$index->replaceAllObjects(array objects, [
  // All the following parameters are optional
  'safe' => bool,
]);

index.replace_all_objects(Array objects)

index.replace_all_objects(Array objects, Hash opts = {
  bool safe: false
})

index.replaceAllObjects(array objects)

index.replaceAllObjects(array objects, {
    // All the following parameters are optional
    safe: bool,
    // + any requestOptions
})

index.replace_all_objects(list | iterator objects)

index.replace_all_objects(list objects, {
    // All the following parameters are optional
    'safe' => bool
})

index.replaceAllObjects<T: Encodable>(
  with objects: [T],
  autoGeneratingObjectID: Bool = false,
  safe: Bool = false,
  requestOptions: RequestOptions? = nil,
  completion: Result<[IndexedTask]> -> Void  
) throws

suspend fun Index.replaceAllObjects(
    records: List<JsonObject>
): List<Task>

suspend fun <T : Indexable> Index.replaceAllObjects(
    serializer: KSerializer<T>,
    records: List<T>
): List<Task>

index.ReplaceAllObjects(
  IEnumerable<T> objects,

  // All the following parameters are optional
  safe: bool
);

index.replaceAllObjects(Iterable<T> objects);
index.replaceAllObjects(Iterable<T> objects, Boolean safe);

index.ReplaceAllObjects([]Object objects)

Not implemented.

See the Examples section.

See code examples

We released a new version of the PHP API client in public beta. Read the beta documentation for more information.

We released a new version of the JavaScript API client in public beta. Read the beta documentation for more information.

We released a new version of the Java API client in public beta. Read the beta documentation for more information.

You’re currently reading the JavaScript API client v4 documentation. Check the migration guide to learn how to upgrade from v3 to v4. You can still access the v3 documentation.

You’re currently reading the Ruby API client v2 documentation. Check the migration guide to learn how to upgrade from v1 to v2. You can still access the v1 documentation.

About this method

Replace all records from your index with a new set of records.

The replaceAllObjects method performs these operations:

Copy settings, synonyms, and rules from your original index to a temporary index.
Add your new records to the temporary index.
Replace your original index with the temporary index.

This lets you replace all records in an index without downtime. The settings, synonyms, and rules remain unchanged.

If you’re using an API key with index restrictions, make sure it has a access to both YourIndex and YourIndex_tmp, or the operation fails.

Because replaceAllObjects creates a temporary index, it temporarily doubles your record count. To offer flexibility, Algolia doesn’t count the three days with the highest number of records towards your monthly total records. However, if you replace all your records more than three times per month, this counts towards your records usage. If you’re on a legacy plan from before July 2020, the replaceAllObjects method counts two operations: copySettings and moveIndex towards your usage, in addition to the record count.

If there’s an error, the temporary index won’t be deleted.

When replacing large numbers of records, be aware of the rate limitations on these processes and the impact on your analytics data.

Examples

Read the Algolia CLI documentation for more information.

Replace all records

Copy

1
2
3
4
5
6
7
8
9
$client = Algolia\AlgoliaSearch\SearchClient::create(
  'YourApplicationID',
  'YourWriteAPIKey'
);

$objects = /* Fetch your objects */;

$index = $client->initIndex('YourIndexName');
$index->replaceAllObjects($objects);

1
2
3
4
5
6
7
8
client = Algolia::Search::Client.create('YourApplicationID', 'YourWriteAPIKey')

objects = [
  # your new objects
]

index = client.init_index('YourIndexName')
index.replace_all_objects(objects)

1
2
3
4
5
6
7
8
9
const client = algoliasearch('YourApplicationID', 'YourWriteAPIKey');

const objects = []; // Fetch your objects

const index = client.initIndex('YourIndexName');

index.replaceAllObjects(objects).then(({ objectIDs }) => {
  console.log(objectIDs);
});

1
2
3
4
5
6
client = SearchClient.create("YourApplicationID", "YourWriteAPIKey")

objects = [] # Fetch your objects

index = client.init_index("YourIndexName")
index.replace_all_objects(objects)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct Contact: Encodable {
  let objectID: ObjectID
  let firstname: String
  let lastname: String
}

let client = SearchClient(appID: "YourApplicationID", apiKey: "YourWriteAPIKey")
let index = client.index(withName: "YourIndexName")

let objects: [Contact]! = [/*Fetch your objects*/]

index.replaceAllObjects(with: objects) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// With JsonObject
val json = listOf(
    json {
        "firstname" to "Jimmie"
        "lastname" to "Barninger"
    },
    json {
        "firstname" to "Warren"
        "lastname" to "Speach"
    }
)

index.replaceAllObjects(json)

// With serializable class
@Serializable
data class Contact(val firstname: String, val lastname: String)

val contacts = listOf(
    Contact("Jimmie", "Barninger"),
    Contact("Warren", "Speach")
)

index.replaceAllObjects(Contact.serializer(), contacts)

1
2
3
4
5
var client = new SearchClient("YourApplicationID", "YourWriteAPIKey");
var index = client.InitIndex("YourIndexName");

var objects = /* Fetch your objects */;
index.ReplaceAllObjects(objects);

1
2
3
4
5
6
7
8
9
10
11
12
13
SearchClient client =
DefaultSearchClient.create("YourApplicationID", "YourWriteAPIKey");

SearchIndex<Contact> index = client.initIndex("YourIndexName", Contact.class);

// Fetch your objects
List<Contact> objects = new ArrayList<>();

// Sync version
index.replaceAllObjects(objects);

// Async version
index.replaceAllObjectsAsync(objects);

1
2
3
4
5
6
7
8
9
10
11
12
package main

import "github.com/algolia/algoliasearch-client-go/v3/algolia/search"

func main() {
    client := search.NewClient("YourApplicationID", "YourWriteAPIKey")
    index := client.InitIndex("YourIndexName")

    objects := []Object{ /* Fetch your objects */ }

    res, err := index.ReplaceAllObjects(objects)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import algolia.AlgoliaClient
import algolia.AlgoliaDsl._
import algolia.responses._

import scala.concurrent.duration._
import scala.concurrent.duration.FiniteDuration
import scala.concurrent.{Await, ExecutionContext, ExecutionContextExecutor, Future}

case class MyCaseClass(objectID: String, /* ... */) extends ObjectID

object Main {

  def main(args: Array[String]): Unit = {

    implicit val ec: ExecutionContextExecutor = ExecutionContext.global
    implicit val awaitDuration: FiniteDuration = 10 seconds

    val client = new AlgoliaClient("YourApplicationID", "YourWriteAPIKey")
    val tmpIndexName = "atomic_reindex_tmp"
    val indexName = "atomic_reindex"

    // 1. Copy the settings, synonyms and rules (but not the records)
    // of the target index into the temporary index
    val copyTask = Await.result(
      client.execute(copy index indexName to tmpIndexName scope Seq("settings", "synonyms", "rules")),
      awaitDuration
    )
    client.execute(waitFor task copyTask from indexName)

    // 2. Fetch your data and push it to the temporary index
    val objects: Seq[MyCaseClass] = Seq(/* ... */)

    // Here is where you push your data to the temporary index
    val batchTasks = Await.result(
      Future.sequence(objects.grouped(1000).map(batch => client.execute(index into tmpIndexName objects batch))),
      awaitDuration
    )

    Await.result(
      Future.sequence(batchTasks.map(task => client.execute(waitFor task task from tmpIndexName))),
      awaitDuration
    )

    // 3. Move the temporary index to the target index
    client.execute(move index tmpIndexName to indexName)
  }

}

Replace all rexcords and wait for operations

Copy

1
2
3
4
5
6
7
8
9
10
11
$client = Algolia\AlgoliaSearch\SearchClient::create(
  'YourApplicationID',
  'YourWriteAPIKey'
);

$objects = /* Fetch your objects */;

$index = $client->initIndex('YourIndexName');
$index->replaceAllObjects($objects, [
  'safe' => true,
]);

1
2
3
4
5
6
7
8
client = Algolia::Search::Client.create('YourApplicationID', 'YourWriteAPIKey')

objects = [
  # your new objects
]

index = client.init_index('YourIndexName')
index.replace_all_objects(objects, { safe: true })

1
2
3
4
5
6
7
8
9
const client = algoliasearch('YourApplicationID', 'YourWriteAPIKey');

const objects = []; // Fetch your objects

const index = client.initIndex('YourIndexName');

index.replaceAllObjects(objects, { safe: true }).then(({ objectIDs }) => {
  console.log(objectIDs);
});

1
2
3
4
5
6
7
8
client = SearchClient.create('YourApplicationID', 'YourWriteAPIKey')

objects = [] # Fetch your objects

index = client.init_index('YourIndexName')
index.replace_all_objects(objects, {
    'safe': True
})

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
struct Contact: Encodable {
  let objectID: ObjectID
  let firstname: String
  let lastname: String
}

let client = SearchClient(appID: "YourApplicationID", apiKey: "YourWriteAPIKey")
let index = client.index(withName: "YourIndexName")

let objects: [Contact]! = [/*Fetch your objects*/]

index.replaceAllObjects(with: objects, safe: true) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
client.apply {
  val json = listOf(
      json {
          "firstname" to "Jimmie"
          "lastname" to "Barninger"
      },
      json {
          "firstname" to "Warren"
          "lastname" to "Speach"
      }
  )

  index.replaceAllObjects(json).waitAll()
}

1
2
3
4
5
var client = new SearchClient("YourApplicationID", "YourWriteAPIKey");
var index = client.InitIndex("YourIndexName");

var objects = /* Fetch your objects */;
index.ReplaceAllObjects(objects, true);

1
2
3
4
5
6
7
8
9
SearchClient client =
DefaultSearchClient.create("YourApplicationID", "YourWriteAPIKey");

SearchIndex<Contact> index = client.initIndex("YourIndexName", Contact.class);

// Fetch your objects
List<Contact> objects = new ArrayList<>();

index.replaceAllObjects(objects, true);

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package main

import (
  "github.com/algolia/algoliasearch-client-go/v3/algolia/opt"
  "github.com/algolia/algoliasearch-client-go/v3/algolia/search"
)

func main() {
    client := search.NewClient("YourApplicationID", "YourWriteAPIKey")
    index := client.InitIndex("YourIndexName")

    objects := []Object{ /* Fetch your objects */ }

    res, err := index.ReplaceAllObjects(objects, opt.Safe(true))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
import algolia.AlgoliaClient
import algolia.AlgoliaDsl._
import algolia.responses._

import scala.concurrent.duration._
import scala.concurrent.duration.FiniteDuration
import scala.concurrent.{Await, ExecutionContext, ExecutionContextExecutor, Future}

case class MyCaseClass(objectID: String, /* ... */) extends ObjectID

object Main {

  def main(args: Array[String]): Unit = {

    implicit val ec: ExecutionContextExecutor = ExecutionContext.global
    implicit val awaitDuration: FiniteDuration = 10 seconds

    val client = new AlgoliaClient("YourApplicationID", "YourWriteAPIKey")
    val tmpIndexName = "atomic_reindex_tmp"
    val indexName = "atomic_reindex"

    // 1. Copy the settings, synonyms and rules (but not the records)
    // of the target index into the temporary index
    val copyTask = Await.result(
      client.execute(copy index indexName to tmpIndexName scope Seq("settings", "synonyms", "rules")),
      awaitDuration
    )
    client.execute(waitFor task copyTask from indexName)

    // 2. Fetch your data and push it to the temporary index
    val objects: Seq[MyCaseClass] = Seq(/* ... */)

    // Here is where you push your data to the temporary index
    val batchTasks = Await.result(
      Future.sequence(objects.grouped(1000).map(batch => client.execute(index into tmpIndexName objects batch))),
      awaitDuration
    )

    Await.result(
      Future.sequence(batchTasks.map(task => client.execute(waitFor task task from tmpIndexName))),
      awaitDuration
    )

    // 3. Move the temporary index to the target index
    client.execute(move index tmpIndexName to indexName)
  }

}

Parameters

Parameter	Description
`objects`	type: list Required List of records. Use an iterator instead of a list to prevent memory issues, especially if you want to replace many records.
`safe`	type: boolean default: false Optional If true, wait for the indexing operations to finish before continuing.
`requestOptions`	type: key-value pairs Optional A mapping of `requestOptions` to send along with the query.

Response

This method doesn't return a response.

Did you find this page helpful?