Replace all 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)
  }

}

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)
  }

}