Partial update objects

1
2
3
4
5
6
7
index.partial_update_objects([{
  firstname: 'Jimmie',
  objectID: 'myID'
}, {
  firstname: 'Warren',
  objectID: 'myID2'
}])

1
2
3
4
5
6
7
8
9
10
11
const objects = [{
  firstname: 'Jimmie',
  objectID: 'myID1'
}, {
  firstname: 'Warren',
  objectID: 'myID2'
}];

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

1
2
3
4
index.partial_update_objects([
    {'objectID': 'myID1', 'firstname': 'Jimmie'},
    {'objectID': 'myID2', 'firstname': 'Warren'}
])

1
2
3
4
5
6
7
8
9
10
let updates: [(ObjectID, PartialUpdate)] = [
  ("myID1", .update(attribute: "firstname", value: "Jimmie")),
  ("myID2", .update(attribute: "firstname", value: "Warren"))
]

index.partialUpdateObjects(updates: updates) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
val firstname = Attribute("firstname")
val partials = listOf(
    ObjectID("myID1") to Partial.Update(firstname, "Jimmie"),
    ObjectID("myID2") to Partial.Update(firstname, "Warren")
)

index.partialUpdateObjects(partials)

1
2
3
4
5
6
7
8
9
10
List<Contact> contacts = new List<Contact>
{
    new Contact { ObjectID = "myID1", Firstname = "Jimmie" },
    new Contact { ObjectID = "myID2", Firstname = "Warren" }
};

index.PartialUpdateObjects(contacts);

// Asynchronous
await index.PartialUpdateObjectsAsync(contacts);

1
2
3
4
5
6
7
8
9
10
List<Contact> contacts = Arrays.asList(
  new Contact().setCity("San Francisco").setObjectID("MyID"),
  new Contact().setCity("Paris").setObjectID("MyID2")
);

// Sync version
index.partialUpdateObjects(contacts);

// Async version
index.partialUpdateObjectsAsync(contacts);

1
2
3
4
5
6
objects := []map[string]string{
  {"objectID": "myID1", "lastname": "Barninger"},
  {"objectID": "myID2", "firstname": "Ray"},
}

res, err := index.PartialUpdateObjects(objects)

1
2
3
4
5
6
client.execute {
  partialUpdate from "index" objects Seq(
    Contact("myID", "Jimmie", "Barninger"),
    Contact("myID", "Speach")
  )
}

1
2
3
4
5
6
7
8
9
10
objects = [
  # your objects here
]

res = index.partial_update_objects(objects, {
  createIfNotExists: true,
  headers: {
    'X-Forwarded-For': '94.228.178.246'
  }
})

1
2
3
4
5
6
7
8
index.partialUpdateObjects(objects, {
  createIfNotExists: true,
  headers: {
    'X-Forwarded-For': '94.228.178.246'
  }
}).then(({ objectIDs }) => {
  console.log(objectIDs);
});

1
2
3
4
objects = [
      # Objects
]
index.partial_update_objects(objects, {'X-Forwarded-For': '94.228.178.246'})

1
2
3
4
5
6
7
8
9
10
11
12
13
var requestOptions = RequestOptions()
requestOptions.headers["X-Algolia-User-ID"] = "user123"

let updates: [(ObjectID, PartialUpdate)] = [
  ("myID1", .update(attribute: "firstname", value: "Jimmie")),
  ("myID2", .update(attribute: "firstname", value: "Warren"))
]

index.partialUpdateObjects(updates: updates, requestOptions: requestOptions) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
4
5
6
7
8
9
10
val firstname = Attribute("firstname")
val partials = listOf(
    ObjectID("myID1") to Partial.Update(firstname, "Jimmie"),
    ObjectID("myID2") to Partial.Update(firstname, "Warren")
)
val requestOptions = requestOptions {
    headerAlgoliaUserId(UserID("user123"))
}

index.partialUpdateObjects(partials, requestOptions = requestOptions)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
List<Contact> contacts = new List<Contact>
{
    new Contact { ObjectID = "myID1", Firstname = "Jimmie" },
    new Contact { ObjectID = "myID2", Firstname = "Warren" }
};

RequestOptions requestOptions = new RequestOptions
{
    Headers = new Dictionary<string,string>{ { "X-Algolia-User-ID", "user123" } }
};

index.PartialUpdateObjects(contacts, requestOptions);

// Asynchronous
await index.PartialUpdateObjectsAsync(contacts, requestOptions);

1
2
3
4
5
6
7
8
9
10
11
12
13
List<Contact> contacts = Arrays.asList(
  new Contact().setCity("San Francisco").setObjectID("MyID"),
  new Contact().setCity("Paris").setObjectID("MyID2")
);

RequestOptions requestOptions =
    new RequestOptions().addExtraHeader("X-Algolia-User-ID", "user123")

// Sync version
index.partialUpdateObjects(contacts, requestOptions);

// Async version
index.partialUpdateObjectsAsync(contacts, requestOptions);

1
2
3
4
5
6
7
8
9
10
objects := []map[string]string{
  {"objectID": "myID1", "lastname": "Barninger"},
  {"objectID": "myID2", "firstname": "Ray"},
}

extraHeaders := opt.ExtraHeaders(map[string]string{
  "X-Algolia-User-ID": "userID2",
})

res, err := index.PartialUpdateObjects(objects, extraHeaders)

1
2
3
4
5
6
7
8
9
10
client.execute {
  client.execute {
    partialUpdate from "index" objects Seq(
      Contact("myID", "Jimmie", "Barninger"),
      Contact("myID", "Speach")
    ) options RequestOptions(
      extraHeaders = Some(Map("X-Algolia-User-ID" => "user123"))
    )
  }
}

1
2
3
4
index.partial_update_object({
  city: 'San Francisco',
  objectID: 'myID'
})

1
2
3
4
5
6
index.partialUpdateObject({
  city: 'San Francisco',
  objectID: 'myID'
}).then(({ objectID }) => {
  console.log(objectID);
});

1
index.partial_update_object({"objectID": "myID", "city": "San Francisco"})

1
2
3
4
5
index.partialUpdateObject(withID: "myID", with: .update(attribute: "city", value: "San Francisco")) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
val partial = Partial.Update(Attribute("city"), "San Francisco")

index.partialUpdateObject(ObjectID("myID"), partial)

1
2
3
4
5
6
var contact = new Contact { ObjectID = "myID", City = "San Francisco"" };

index.PartialUpdateObject(contact);

// Asynchronous
await index.PartialUpdateObjectAsync(contact);

1
2
3
4
5
6
7
Contact contact = new Contact().setObjectID("myID").setCity("San Francisco");

// Sync version
index.partialUpdateObject(contact);

// Sync version
index.partialUpdateObjectAsync(contact);

1
2
3
4
5
6
7
8
9
10
11
type Contact struct {
	ObjectID string `json:"objectID"`
	City     string `json:"city"`
}

contact := Contact{
	ObjectID: "myID",
	City:     "San Francisco",
}

res, err := index.PartialUpdateObject(contact)

1
2
3
4
5
6
client.execute {
  partialUpdate from "index" `object` Contact(
    objectID = "myID",
    city = "San Francisco"
  )
}

1
2
3
4
index.partial_update_object({
  state: 'California',
  objectID: 'myID'
})

1
2
3
4
5
6
index.partialUpdateObject({
  state: 'California',
  objectID: 'myID'
}).then(({ objectID }) => {
  console.log(objectID);
});

1
index.partial_update_object({'objectID': 'myID', 'state': 'California'})

1
2
3
4
5
index.partialUpdateObject(withID: "myID", with: .update(attribute: "state", value: "California")) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
3
val partial = Partial.Update(Attribute("state"), "California")

index.partialUpdateObject(ObjectID("myID"), partial)

1
2
3
4
index.PartialUpdateObject(new Contact { ObjectID = "myID1", State = "California" });

// Asynchronous
await index.PartialUpdateObjectAsync(new Contact { ObjectID = "myID1", State = "California" });

1
2
3
4
5
6
7
Contact contact = new Contact().setObjectID("myID").setState("California");

// Sync version
index.partialUpdateObject(contact);

// Sync version
index.partialUpdateObjectAsync(contact);

1
2
3
4
5
6
7
8
9
10
11
type Contact struct {
	ObjectID string `json:"objectID"`
	State    string `json:"state"`
}

contact := Contact{
	ObjectID: "myID",
	State:    "California",
}

res, err := index.PartialUpdateObject(contact)

1
2
3
4
5
6
client.execute {
  partialUpdate from "index" `object` Contact(
    objectID = "myID",
    state = "California"
  )
}

1
2
3
4
5
6
7
index.partial_update_object({
  count: {
    _operation: 'Increment',
    value: 2
  },
  objectID: 'myID'
})

1
2
3
4
5
6
7
8
9
10
index.partialUpdateObject({
  count: {
    _operation: 'Increment',
    value: 2,
  },
  objectID: 'myID',
})
.then(({ objectIDs }) => {
  console.log(objectIDs);
});

1
2
3
4
5
6
7
index.partial_update_object({
  'count': {
    '_operation': 'Increment',
    'value': 2
  },
  'objectID': 'myID'
})

1
2
3
4
5
index.partialUpdateObject(withID: "myID", with: .increment(attribute: "count", value: 2)) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
val partial = Partial.Update(Attribute("Increment"), 2)
index.partialUpdateObject(ObjectID("myID"), partial)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Record
{
    public string ObjectID { get; set; }

    public PartialUpdateOperation<int> Count { get; set; }
}

var record = new Record
{
    ObjectID = "myID",
    Count = PartialUpdateOperation<int>.Increment(2),
};

var res = index.PartialUpdateObjects(new List<Record>
{
    record
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class RecordWithPartialUpdate {
    private String objectID;
    private PartialUpdateOperation<Integer> count;

    public Record(String objectID, PartialUpdateOperation<Integer> count) {
        this.objectID = objectID;
        this.count = count;
    }

    // Getters and setters omitted for readability
}

BatchIndexingResponse res = index.partialUpdateObjects(Collections.singletonList(
    new Record("myID", PartialUpdateOperation.Increment(2))
));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
type Record struct {
    ObjectID string                        `json:"objectID"`
    Count    search.PartialUpdateOperation `json:"count"`
}

res, err := index.PartialUpdateObjects([]Record{
    {
        ObjectID: "myID",
        Count: search.PartialUpdateOperation{
            Operation: "Increment",
            Value:     2,
        },
    },
})

1
2
3
client.execute {
  increment attribute "count" by 2 ofObjectId "myID" from "indexName"
}

1
2
3
4
5
6
7
index.partial_update_object({
  _tags: {
    _operation: 'AddUnique',
    value: 'public'
  },
  objectID: 'myID'
})

1
2
3
4
5
6
7
8
9
10
index.partialUpdateObject({
  _tags: {
    _operation: 'AddUnique',
    value: 'public',
  },
  objectID: 'myID',
})
.then(({ objectIDs }) => {
  console.log(objectIDs);
});

1
2
3
4
5
6
7
index.partial_update_object({
  '_tags': {
    '_operation': 'AddUnique',
    'value': 'public'
  },
  'objectID': 'myID'
})

1
2
3
4
5
index.partialUpdateObject(withID: "myID", with: .add(attribute: "_tags", value: "public", unique: true)) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
val partial = Partial.AddUnique(Attribute("_tags"), "public")
index.partialUpdateObject(ObjectID("myID"), partial)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Record
{
    public string ObjectID { get; set; }

    [JsonProperty(PropertyName = "_tags")]
    public PartialUpdateOperation<string> Tags { get; set; }
}

var record = new Record
{
    ObjectID = "myID",
    Tags = PartialUpdateOperation<string>.AddUnique("public"),
};

var res = index.PartialUpdateObjects(new List<Record>
{
    record
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class RecordWithPartialUpdate {
    private String objectID;

    @JsonProperty("_tags")
    private PartialUpdateOperation<String> tags;

    public Record(String objectID, PartialUpdateOperation<String> tags) {
        this.objectID = objectID;
        this.tags = tags;
    }

    // Getters and setters omitted for readability
}

BatchIndexingResponse res = index.partialUpdateObjects(Collections.singletonList(
    new Record("myID", PartialUpdateOperation.AddUnique("public"))
));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
type Record struct {
    ObjectID string                        `json:"objectID"`
    Tags     search.PartialUpdateOperation `json:"_tags"`
}

res, err := index.PartialUpdateObjects([]Record{
    {
        ObjectID: "myID",
        Tags: search.PartialUpdateOperation{
            Operation: "AddUnique",
            Value:     "public",
        },
    },
})

1
2
3
client.execute {
  addUnique value "public" inAttribute "_tags" ofObjectId "myID" from "indexName"
}

1
2
3
4
5
6
7
index.partial_update_object({
  version: {
    _operation: 'IncrementFrom',
    value: 2
  },
  objectID: 'myID'
})

1
2
3
4
5
6
7
8
9
10
index.partialUpdateObject({
  version: {
    _operation: 'IncrementFrom',
    value: 2,
  },
  objectID: 'myID',
})
.then(({ objectIDs }) => {
  console.log(objectIDs);
});

1
2
3
4
5
6
7
index.partial_update_object({
  'version': {
    '_operation': 'IncrementFrom',
    'value': 2
  },
  'objectID': 'myID'
})

1
2
3
4
5
index.partialUpdateObject(withID: "myID", with: .incrementFrom(attribute: "version", value: 2)) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
val partial = Partial.IncrementFrom(Attribute("version"), 2)
index.partialUpdateObject(ObjectID("myID"), partial)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Record
{
    public string ObjectID { get; set; }

    public PartialUpdateOperation<int> Count { get; set; }
}

var record = new Record
{
    ObjectID = "myID",
    Count = PartialUpdateOperation<int>.IncrementFrom(2),
};

var res = index.PartialUpdateObjects(new List<Record>
{
    record
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class RecordWithPartialUpdate {
    private String objectID;
    private PartialUpdateOperation<Integer> version;

    public Record(String objectID, PartialUpdateOperation<Integer> version) {
        this.objectID = objectID;
        this.version = version;
    }

    // Getters and setters omitted for readability
}

BatchIndexingResponse res = index.partialUpdateObjects(Collections.singletonList(
    new Record("myID", PartialUpdateOperation.incrementFrom(2))
));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
type Record struct {
    ObjectID string                        `json:"objectID"`
    Count    search.PartialUpdateOperation `json:"version"`
}

res, err := index.PartialUpdateObjects([]Record{
    {
        ObjectID: "myID",
        Count: search.PartialUpdateOperation{
            Operation: "IncrementFrom",
            Value:     2,
        },
    },
})

1
2
3
client.execute {
  increment from "version" by 2 ofObjectId "myID" from "indexName"
}

1
2
3
4
5
6
7
index.partial_update_object({
  lastmodified: {
    _operation: 'IncrementSet',
    value: 1593431913
  },
  objectID: 'myID'
})

1
2
3
4
5
6
7
8
9
10
index.partialUpdateObject({
  lastmodified: {
    _operation: 'IncrementSet',
    value: 1593431913,
  },
  objectID: 'myID',
})
.then(({ objectIDs }) => {
  console.log(objectIDs);
});

1
2
3
4
5
6
7
index.partial_update_object({
  'lastmodified': {
    '_operation': 'IncrementSet',
    'value': 1593431913
  },
  'objectID': 'myID'
})

1
2
3
4
5
index.partialUpdateObject(withID: "myID", with: .incrementSet(attribute: "lastmodified", value: 1593431913)) { result in
  if case .success(let response) = result {
    print("Response: \(response)")
  }
}

1
2
val partial = Partial.IncrementSet(Attribute("lastmodified"), 1593431913)
index.partialUpdateObject(ObjectID("myID"), partial)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
class Record
{
    public string ObjectID { get; set; }

    public PartialUpdateOperation<int> Count { get; set; }
}

var record = new Record
{
    ObjectID = "myID",
    Count = PartialUpdateOperation<int>.IncrementSet(1593431913),
};

var res = index.PartialUpdateObjects(new List<Record>
{
    record
});

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
class RecordWithPartialUpdate {
    private String objectID;
    private PartialUpdateOperation<Integer> lastmodified;

    public Record(String objectID, PartialUpdateOperation<Integer> lastmodified) {
        this.objectID = objectID;
        this.lastmodified = lastmodified;
    }

    // Getters and setters omitted for readability
}

BatchIndexingResponse res = index.partialUpdateObjects(Collections.singletonList(
    new Record("myID", PartialUpdateOperation.incrementSet(1593431913))
));

1
2
3
4
5
6
7
8
9
10
11
12
13
14
type Record struct {
    ObjectID string                        `json:"objectID"`
    Count    search.PartialUpdateOperation `json:"lastmodified"`
}

res, err := index.PartialUpdateObjects([]Record{
    {
        ObjectID: "myID",
        Count: search.PartialUpdateOperation{
            Operation: "IncrementSet",
            Value:     1593431913,
        },
    },
})

1
2
3
client.execute {
  increment set "lastmodified" by 1593431913 ofObjectId "myID" from "indexName"
}