Sending Records in Batches

1
2
3
4
5
6
7
8
9
10
require 'json'
require 'algolia'

client  = Algolia::Search::Client.create('AJ0P3S7DWQ', '••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb')
index   = client.init_index('actors')
file    = File.read('actors.json')
records = JSON.parse(file)

# The API client automatically batches your records
index.save_objects(records, { autoGenerateObjectIDIfNotExist: 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
const algoliasearch = require('algoliasearch')
const fs = require('fs');
const StreamArray = require('stream-json/streamers/StreamArray');

const client = algoliasearch('AJ0P3S7DWQ', '••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb');
const index = client.initIndex('actors');

const stream = fs.createReadStream('actors.json').pipe(StreamArray.withParser());
let chunks = [];

stream
  .on('data', ({ value }) => {
    chunks.push(value);
    if (chunks.length === 10000) {
      stream.pause();
      index
        .saveObjects(chunks, { autoGenerateObjectIDIfNotExist: true })
        .then(() => {
          chunks = [];
          stream.resume();
        })
        .catch(console.error);
    }
  })
  .on('end', () => {
    if (chunks.length) {
      index.saveObjects(chunks, { 
        autoGenerateObjectIDIfNotExist: true
      }).catch(console.error);
    }
  })
  .on('error', err => console.error(err));

1
2
3
4
5
6
7
8
9
10
11
import json
from algoliasearch.search_client import SearchClient

client = SearchClient.create('AJ0P3S7DWQ', '••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb')
index = client.init_index('actors')

with open('actors.json') as f:
    records = json.load(f)

# Batching is done automatically by the API client
index.save_objects(records, {'autoGenerateObjectIDIfNotExist': True});

1
2
3
4
5
6
7
8
9
10
let filePath = Bundle.main.path(forResource: "actors", ofType: "json")!
let contentData = FileManager.default.contents(atPath: filePath)!
let records = try! JSONSerialization.jsonObject(with: contentData, options: []) as! [[String: Any]]

let chunkSize = 10000

for beginIndex in stride(from: 0, to: records.count, by: chunkSize) {
  let endIndex = min(beginIndex + chunkSize, records.count)
  index.addObjects(Array(records[beginIndex..<endIndex]))
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
using System.IO;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;

public class Actor
{
  public string Name { get; set; }
  public string ObjectId { get; set; }
  public int Rating { get; set; }
  public string ImagePath { get; set; }
  public string AlternativePath { get; set; }
}

AlgoliaClient client = new AlgoliaClient("AJ0P3S7DWQ", "••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb");
Index index = client.InitIndex("actors");

// Don't forget to set the naming strategy of the serializer to handle Pascal/Camel casing
IEnumerable<Actor> actors = JsonConvert.DeserializeObject<IEnumerable<Actor>>(File.ReadAllText("actors.json"));

// Batching/Chunking is done automatically by the API client
bool autoGenerateObjectIDIfNotExist = true;
index.SaveObjects(actors, autoGenerateObjectIDIfNotExist);

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
import java.io.FileInputStream;
import java.io.InputStream;
import com.fasterxml.jackson.databind.ObjectMapper;

public class Actor {
    // Getters/Setters ommitted
    private String name;
    private String objectId;
    private int rating;
    private String imagePath;
    private String alternativePath;
}

// Synchronous version
SearchClient client =
DefaultSearchClient.create("AJ0P3S7DWQ", "••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb");

SearchIndex<Actor> index = client.initIndex("actors", Actor.class);

ObjectMapper objectMapper = Defaults.getObjectMapper();

InputStream input = new FileInputStream("actors.json");
Actor[] actors = objectMapper.readValue(input, Actor[].class);

// Batching/Chuking is done automatically by the API client
boolean autoGenerateObjectIDIfNotExist = true;
index.saveObjects(Arrays.asList(actors), autoGenerateObjectIDIfNotExist);

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
package main

import (
    "encoding/json"
    "io/ioutil"

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

type Actor struct {
    Name            string `json:"name"`
    Rating          int    `json:"rating"`
    ImagePath       string `json:"image_path"`
    AlternativeName string `json:"alternative_name"`
    ObjectID        string `json:"objectID"`
}

func main() {
    client := search.NewClient("AJ0P3S7DWQ", "••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb")
    index := client.InitIndex("actors")

    var actors []Actor
    data, _ := ioutil.ReadFile("actors.json")
    _ = json.Unmarshal(data, &actors)

    // Batching is done automatically by the API client
    _, _ = index.SaveObjects(actors)
}

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
package algolia

import java.io.FileInputStream

import algolia.AlgoliaDsl._
import org.json4s._
import org.json4s.native.JsonMethods._

import scala.concurrent.ExecutionContext.Implicits.global

case class Actor(name: String,
                 rating: Int,
                 image_path: String,
                 alternative_path: Option[String],
                 objectID: String)

object Main {

  def main(args: Array[String]): Unit = {
    val client = new AlgoliaClient("AJ0P3S7DWQ", "••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb")

    val records = parse(new FileInputStream("actors.json")).extract[Seq[Actor]]

    records
      .grouped(10000)
      .map(g => {
        client.execute {
          index into "actors" objects g
        }
      })
  }

}

1
2
3
4
5
6
7
8
9
10
val client = ClientSearch(ApplicationID("AJ0P3S7DWQ"), APIKey("••••••••••••••••••••ce1181300d403d21311d5bca9ef1e6fb"))
val index = client.initIndex(IndexName("actors"))
val string = File("actors.json").readText()
val actors = Json.plain.parse(JsonObjectSerializer.list, string)

index.apply {
    actors
        .chunked(1000)
        .map { saveObjects(it) }
        .wait() // Wait for all indexing operations to complete.