Borrar objetos Realm - Kotlin SDK

Objetos y referencias relacionados

Al eliminar un objeto que tiene una propiedad de relación con otro objeto, Realm no elimina automáticamente la instancia del objeto relacionado. En su lugar, solo elimina la referencia al otro objeto. El objeto referenciado permanece en el dominio, pero ya no se puede consultar a través de la propiedad principal.

La única excepción es si el objeto relacionado está incrustado. Cuando se elimina un objeto que tiene una relación con un EmbeddedRealmObjectRealm elimina automáticamente el objeto incrustado mediante una eliminación en cascada. Para obtener más información, consulte la sección "Eliminar un objeto incrustado" en esta página.

Eliminar un solo objeto

Para eliminar un solo objeto RealmObject, consulte el tipo de objeto utilizando un filtro que devuelva el objeto específico que desea eliminar.

En el siguiente ejemplo, consultamos un objeto Frog con una clave principal específica y luego pasamos el objeto devuelto a mutableRealm.delete() para eliminarlo del reino:

// Open a write transaction
realm.write {
    // Query the Frog type and filter by primary key value
    val frogToDelete: Frog = query<Frog>("_id == $0", PRIMARY_KEY_VALUE).find().first()
    // Pass the query results to delete()
    delete(frogToDelete)
}

Eliminar varios objetos

Para eliminar varios objetos al mismo tiempo, pase el tipo de objeto a query() y especifique una consulta que devuelva todos los objetos que desea eliminar.

En el siguiente ejemplo, consultamos los primeros tres objetos Frog cuyo species es "bullfrog" y luego pasamos los resultados a mutableRealm.delete() para eliminarlos del reino:

// Open a write transaction
realm.write {
    // Query by species and limit to 3 results
    val bullfrogsToDelete: RealmResults<Frog> = query<Frog>("species == 'bullfrog' LIMIT(3)").find()
    // Pass the query results to delete()
    delete(bullfrogsToDelete)
}

Eliminar todos los objetos de un tipo

Para eliminar todos los objetos de un tipo específico de un reino al mismo tiempo, pase el tipo de objeto a query() y deje el filtro de consulta vacío para devolver todos los objetos de ese tipo.

En el siguiente ejemplo, consultamos todos los objetos Frog y luego pasamos los resultados a mutableRealm.delete() para eliminarlos todos del reino:

// Open a write transaction
realm.write {
    // Query Frog type with no filter to return all frog objects
    val frogsLeftInTheRealm = query<Frog>().find()
    // Pass the query results to delete()
    delete(frogsLeftInTheRealm)
}

Eliminar todos los objetos en un reino

El SDK de Kotlin permite eliminar todos los objetos administrados de cualquier tipo, lo cual resulta útil para vaciar rápidamente el dominio durante el prototipado. Esto no afecta al esquema del dominio ni a los objetos que no estén administrados por él.

Para eliminar todos los objetos del realm al mismo tiempo, llama a mutableRealm.deleteAll(). Esto borra todos los objetos de todos los tipos.

En el siguiente ejemplo, eliminamos todos los objetos del reino con deleteAll():

// Open a write transaction
realm.write {
    // Delete all objects from the realm
    deleteAll()
}

Eliminar un objeto y sus objetos relacionados

Para eliminar objetos relacionados al eliminar un objeto principal, debe eliminarlos manualmente. Recomendamos encadenar las eliminaciones: primero, busque el objeto principal que desea eliminar, luego recorra las relaciones entre ambos y elimine cada objeto relacionado. Finalmente, elimine el objeto principal.

En el siguiente ejemplo, consultamos un objeto Frog llamado "Kermit", iteramos su propiedad favoritePonds y eliminamos cada objeto Pond. Después, eliminamos el objeto Frog:

realm.write {
    // Query for the parent frog object with ponds
    val frog = query<Frog>("name == $0", "Kermit").find().first()
    val ponds = frog.favoritePonds
    // Iterate over the list and delete each pond object
    if (ponds.isNotEmpty()) {
        ponds.forEach { pond ->
            delete(pond)
        }
    }
    // Delete the parent frog object
    val frogToDelete = findLatest(frog)
    if (frogToDelete != null) {
        delete(frogToDelete)
    }
}

Eliminar un objeto incrustado

Puede eliminar un objeto incrustado a través del objeto principal en una eliminación en cascada o eliminando el objeto incrustado directamente.

• Para eliminar el objeto incrustado a través del objeto principal, obtenga y elimine el objeto principal. Realm elimina automáticamente todos sus objetos incrustados del reino.

• Para eliminar una instancia de objeto incrustado directamente:

  • Obtener y eliminar un objeto incrustado específico.

  • Borra la referencia del padre al objeto incrustado, lo que también elimina la instancia del objeto incrustado.

En el siguiente ejemplo, tenemos un objeto Business con una lista de objetos EmbeddedAddress incrustados. Hacemos una query y borramos el objeto Business, lo que borra automáticamente todos sus objetos EmbeddedAddress integrados:

// Delete the parent object
realm.write {
    val businessToDelete = query<Business>("name == $0", "Big Frog Corp.").find().first()
    // Delete the parent object (deletes all embedded objects)
    delete(businessToDelete)
}

En el siguiente ejemplo, tenemos objetos Contact con objetos EmbeddedAddress incrustados. Eliminamos un objeto EmbeddedAddress directamente y otro a través del objeto principal:

// Delete an embedded object directly
realm.write {
    val addressToDelete = query<EmbeddedAddress>("street == $0", "456 Lily Pad Ln").find().first()
    // Delete the embedded object (nullifies the parent property)
    delete(addressToDelete)
}
// Delete an embedded object through the parent
realm.write {
    val propertyToClear = query<Contact>("name == $0", "Kermit").find().first()
    // Clear the parent property (deletes the embedded object instance)
    propertyToClear.address = null
}

Eliminar elementos de una RealmList

Puede eliminar uno o más elementos en una sola transacción de una RealmList:

• Para eliminar un elemento de la lista, pase el elemento a list.remove().

• Para eliminar un elemento en un índice especificado en la lista, pase el índice a list.removeAt().

• Para eliminar varios elementos de la lista, pase los elementos a list.removeAll().

También puedes eliminar todos los elementos de la lista a la vez llamando a list.clear().

En el siguiente ejemplo, tenemos un objeto Forest con una lista de Pond objetos. Eliminamos los elementos de la lista mediante una serie de operaciones hasta que la lista quede vacía:

// Open a write transaction
realm.write {
    // Query for the parent forest object
    val forest = query<Forest>("name == $0", "Hundred Acre Wood").find().first()
    val forestPonds = forest.nearbyPonds
    assertEquals(5, forestPonds.size)
    // Remove the first pond in the list
    val removeFirstPond = forestPonds.first()
    forestPonds.remove(removeFirstPond)
    assertEquals(4, forestPonds.size)
    // Remove the pond at index 2 in the list
    forestPonds.removeAt(2)
    assertEquals(3, forestPonds.size)
    // Remove the remaining three ponds in the list
    forestPonds.removeAll(forestPonds)
    assertEquals(0, forestPonds.size)
}

En el siguiente ejemplo, tenemos un objeto Forest con una lista de Pond objetos. Eliminamos todos los elementos de la lista con el método list.clear():

// Open a write transaction
realm.write {
    val forest = query<Forest>("name == $0", "Hundred Acre Wood").find().first()
    val forestPonds = forest.nearbyPonds
    assertEquals(5, forestPonds.size)
    // Clear all ponds from the list
    forestPonds.clear()
    assertEquals(0, forestPonds.size)
}

Eliminar elementos de un RealmSet

Puedes remover uno o más elementos en una sola transacción desde un RealmSet:

• Para eliminar un elemento del conjunto, pase el elemento que desea eliminar a set.remove().

• Para eliminar varios elementos del conjunto, pase los elementos que desea eliminar a set.removeAll().

También puedes eliminar todos los elementos del conjunto a la vez llamando set.clear().

En el siguiente ejemplo, tenemos un objeto Frog con un conjunto de objetos Snack. Eliminamos los elementos del conjunto mediante una serie de operaciones hasta que el conjunto quede vacío:

// Open a write transaction
realm.write {
    // Query for the parent frog object
    val myFrog = query<RealmSet_Frog>("name == $0", "Kermit").find().first()
    val snackSet = myFrog.favoriteSnacks
    assertEquals(3, snackSet.size)
    // Remove one snack from the set
    snackSet.remove(snackSet.first { it.name == "Flies" })
    assertEquals(2, snackSet.size)
    // Remove the remaining two snacks from the set
    val allSnacks = findLatest(myFrog)!!.favoriteSnacks
    snackSet.removeAll(allSnacks)
    assertEquals(0, snackSet.size)
}

En el siguiente ejemplo, tenemos un objeto Frog con un conjunto de objetos Snack. Eliminamos todos los elementos del conjunto con el método set.clear():

realm.write {
    val myFrog = realm.query<RealmSet_Frog>("name == $0", "Kermit").find().first()
    val snackSet = findLatest(myFrog)!!.favoriteSnacks
    assertEquals(3, snackSet.size)
    // Clear all snacks from the set
    snackSet.clear()
    assertEquals(0, snackSet.size)
}

Eliminar claves/valores del diccionario

Puedes eliminar entradas de RealmDictionary de varias maneras:

• Para eliminar el valor pero conservar la clave, establezca la clave en null (el valor del diccionario debe ser nulo)

• Para eliminar la clave y el valor, pasa la clave a remover()

También puedes eliminar todas las claves y valores llamando a clear().

En el siguiente ejemplo, tenemos un objeto Frog con un diccionario de valores String. Eliminamos los elementos del diccionario mediante una serie de operaciones hasta que el diccionario quede vacío:

// Find frogs who have forests with favorite ponds
val thisFrog = realm.query<Frog>("favoritePondsByForest.@count > 1").find().first()
// Set an optional value for a key to null if the key exists
if (thisFrog.favoritePondsByForest.containsKey("Hundred Acre Wood")) {
    realm.write {
        val mutableFrog = findLatest(thisFrog)
        if (mutableFrog != null) {
            mutableFrog.favoritePondsByForest["Hundred Acre Wood"] = null
        }
    }
}
realm.write {
    // Remove a key and its value
    findLatest(thisFrog)?.favoritePondsByForest?.remove("Lothlorien")
    // Remove all keys and values
    findLatest(thisFrog)?.favoritePondsByForest?.clear()
    assertTrue(thisFrogUpdated.favoritePondsByForest.isEmpty())
}