Actualizar objetos de Realm - SDK de Kotlin

// Query and update a realm object in a single write transaction
realm.write {
    val liveFrog = query<Frog>("_id == $0", PRIMARY_KEY_VALUE).find().first()
    liveFrog.name = "Michigan J. Frog"
    liveFrog.age += 1
}

// Modify embedded object properties in a write transaction
realm.write {
    // Fetch the objects
    val addressToUpdate = findLatest(address) ?: error("Cannot find latest version of embedded object")
    val contactToUpdate = findLatest(contact) ?: error("Cannot find latest version of parent object")
    // Update a single embedded object property directly
    addressToUpdate.street = "100 10th St N"
    // Update multiple properties
    addressToUpdate.apply {
        street = "202 Coconut Court"
        city = "Los Angeles"
        state = "CA"
        postalCode = "90210"
    }
    // Update property through the parent object
    contactToUpdate.address?.state = "NY"
}

realm.write {
    val parentObject = query<Contact>("_id == $0", PRIMARY_KEY_VALUE).find().first()
    val newAddress = EmbeddedAddress().apply {
        propertyOwner = Contact().apply { name = "Michigan J. Frog" }
        street = "456 Lily Pad Ln"
        country = EmbeddedCountry().apply { name = "Canada" }
    }
    // Overwrite the embedded object with the new instance (deletes the existing object)
    parentObject.address = newAddress
}

// Open a write transaction
realm.write {
    // Get the live object
    val frog = query<Frog>("_id == $0", PRIMARY_KEY_VALUE).find().first()
    val counter: MutableRealmInt? = frog.fliesEaten
    counter?.get() // 1
    // Increment the value of the MutableRealmInt property
    // ** Note use of decrement() with negative value **
    counter?.increment(0) // 1
    counter?.increment(5) // 6
    counter?.decrement(-2) // 8
    // Decrement the value of the MutableRealmInt property
    // ** Note use of increment() with negative value **
    counter?.decrement(0) // 8
    counter?.decrement(2) // 6
    counter?.increment(-1) // 5
    // Set the value of the MutableRealmInt property
    // ** Use set() with caution **
    counter?.set(0)// 0
}

// Find favoriteThing that is an Int
// Convert the value to Double and update the favoriteThing property
realm.write {
val kermit = query<Frog>().find().first()
val realmAny: RealmList<RealmAny?> = kermit.favoriteThings
    for (i in realmAny.indices) {
        val thing = realmAny[i]
        if (thing?.type == RealmAny.Type.INT) {
            val intValue = thing.asInt()
            val doubleValue = intValue.toDouble()
               realmAny[i] = RealmAny.create(doubleValue)
        }
    }
}
// Overwrite all existing favoriteThing properties
// ** Null clears the property value **
realm.write {
    val frog = query<Frog>().find().first()
    val realmAny: RealmList<RealmAny?> = frog.favoriteThings
    realmAny[0] = RealmAny.create("sunshine")
    realmAny[1] = RealmAny.create(Frog().apply { name = "Kermit Sr." })
    realmAny[2] = null
}

realm.write {
    // Get the live object
    val realmList = query<Frog>("name = $0", "Kermit").first().find()!!.favoritePonds
    realmList[0].name = "Picnic Pond"
    realmList.set(1, Pond().apply { name = "Big Pond" })
}

// Find a frog in the realm
val kermit = realm.query<Frog>("name = $0", "Kermit").find().first()
val realmSet = kermit.favoriteSnacks
// Update the name of each snack in the set
for (snack in realmSet) {
    realm.write {
        findLatest(snack)?.name = snack.name.uppercase()
    }
}
realm.write {
    // Find all frogs who like rain
    val frogsWhoLikeRain = realm.query<Frog>("favoriteWeather CONTAINS $0", "rain").find()
    // Add thunderstorms to their favoriteWeather set
    for (frog in frogsWhoLikeRain) {
        val latestFrog = findLatest(frog)
        latestFrog?.favoriteWeather?.add("thunderstorms")
    }
}

// Find frogs who have forests with favorite ponds
val thisFrog = realm.query<RealmDictionary_Frog>("favoritePondsByForest.@count > 1").find().first()
// Update the value for a key if it exists
if (thisFrog.favoritePondsByForest.containsKey("Hundred Acre Wood")) {
    realm.write {
        findLatest(thisFrog)?.favoritePondsByForest?.set("Lothlorien", "Lily Pad Pond")
    }
}
// Add a new key-value pair
realm.write {
    findLatest(thisFrog)?.favoritePondsByForest?.put("Sherwood Forest", "Miller Pond")
}

realm.write {
    val kermit = query<Frog>("name == $0", "Kermit").find().first()
    // Update a property on the related object
    kermit.favoritePond?.name = "Big Pond"
    // Assign a new related object
    val newBestFriend = Frog().apply { name = "Froggy Jr." }
    kermit.bestFriend = newBestFriend
}

realm.write {
    val forest = query<Forest>().find().first()
    // Update a property on a related object in the set
    forest.frogsThatLiveHere.first().name = "Kermit Sr."
    // Add a new related object to the list
    forest.frogsThatLiveHere.add(Frog().apply { name = "Froggy Jr." })
}

realm.write {
    // Update child objects through the parent
    val parent = query<User>().find().first()
    parent.posts[0].title = "Forest Life Vol. 2"
    parent.posts.add(Post().apply { title = "Forest Life Vol. 3" })
    // Update child objects (Realm automatically updates the backlink collection)
    val child = query<Post>("title == $0", "Top Ponds of the Year!").find().first()
    child.title = "Top Ponds of the Year! Vol. 2"
    assertEquals("Top Ponds of the Year! Vol. 2", parent.posts[1].title)
    // Update the parent object through the child
    child.user[0].name = "Kermit Sr."
    // ** You CANNOT directly modify the backlink collection **
    val readOnlyBacklink: RealmResults<User> = child.user
}