CRUD - Eliminar - SDK de Java

Acerca de los ejemplos de esta página

Los ejemplos de esta página utilizan el modelo de datos de una aplicación de gestión de proyectos que tiene dos tipos de objetos Realm: Project y Task. Un Project tiene cero o más Tasks.

Vea el esquema de estas dos clases, Project y Task, a continuación:

import org.bson.types.ObjectId;
import io.realm.RealmObject;
import io.realm.annotations.PrimaryKey;
import io.realm.annotations.RealmClass;
import io.realm.annotations.Required;
public class ProjectTask extends RealmObject {
    @PrimaryKey
    public ObjectId _id;
    @Required
    public String name;
    public String assignee;
    public int progressMinutes;
    public boolean isComplete;
    public int priority;
    @Required
    public String _partition;
}

import org.bson.types.ObjectId;
import io.realm.RealmList;
import io.realm.RealmObject;
import io.realm.annotations.PrimaryKey;
import io.realm.annotations.RealmClass;
import io.realm.annotations.Required;
public class Project extends RealmObject {
    @PrimaryKey
    public ObjectId _id;
    @Required
    public String name;
    public RealmList<ProjectTask> tasks = new RealmList<>();
}

import io.realm.RealmObject
import io.realm.annotations.PrimaryKey
import io.realm.annotations.Required
import org.bson.types.ObjectId
open class ProjectTask(
    @PrimaryKey
    var _id: ObjectId = ObjectId(),
    @Required
    var name: String = "",
    var assignee: String? = null,
    var progressMinutes: Int = 0,
    var isComplete: Boolean = false,
    var priority: Int = 0,
    var _partition: String = ""
): RealmObject()

import io.realm.RealmList
import io.realm.RealmObject
import io.realm.annotations.PrimaryKey
import io.realm.annotations.Required
import org.bson.types.ObjectId
open class Project(
    @PrimaryKey
    var _id: ObjectId = ObjectId(),
    @Required
    var name: String = "",
    var tasks: RealmList<ProjectTask> = RealmList(),
): RealmObject()

Eliminar un objeto

Para eliminar un objeto de un reino, utilice las versiones dinámicas o estáticas del método deleteFromRealm() de un Subclase deRealmObject.

El siguiente ejemplo muestra cómo eliminar un objeto de su reino con deleteFromRealm():

realm.executeTransaction(r -> {
    // Get a turtle named "Tony".
    Turtle tony = r.where(Turtle.class).equalTo("name", "Tony").findFirst();
    tony.deleteFromRealm();
    // discard the reference
    tony = null;
});

realm.executeTransaction { r: Realm ->
    // Get a turtle named "Tony".
    var tony = r.where(Turtle::class.java)
        .equalTo("name", "Tony")
        .findFirst()
    tony!!.deleteFromRealm()
    // discard the reference
    tony = null
}

Eliminar varios objetos

Para eliminar un objeto de un dominio, utilice el deleteAllFromRealm() método de la instancia RealmResults que contiene los objetos que desea eliminar. Puede filtrar RealmResults a un subconjunto de objetos mediante el método where().

El siguiente ejemplo demuestra cómo eliminar una colección de un reino con deleteAllFromRealm():

realm.executeTransaction(r -> {
    // Find turtles older than 2 years old.
    RealmResults<Turtle> oldTurtles = r.where(Turtle.class).greaterThan("age", 2).findAll();
    oldTurtles.deleteAllFromRealm();
});

realm.executeTransaction { r: Realm ->
    // Find turtles older than 2 years old.
    val oldTurtles = r.where(Turtle::class.java)
        .greaterThan("age", 2)
        .findAll()
    oldTurtles.deleteAllFromRealm()
}

Eliminar un objeto y sus objetos dependientes

A veces, hay objetos dependientes que se desean eliminar al eliminar el objeto principal. Esto se denomina eliminación encadenada. Realm no elimina automáticamente los objetos dependientes. Si no los elimina usted mismo, permanecerán huérfanos en su entorno. Que esto sea un problema depende de las necesidades de su aplicación.

Actualmente, la mejor manera de eliminar objetos dependientes es iterar a través de las dependencias y eliminarlas antes de eliminar el objeto principal.

El siguiente ejemplo demuestra cómo realizar una eliminación en cadena eliminando primero todas las tortugas de Ali y luego eliminando a Ali:

realm.executeTransaction(r -> {
    // Find a turtle enthusiast named "Ali"
    TurtleEnthusiast ali = r.where(TurtleEnthusiast.class).equalTo("name", "Ali").findFirst();
    // Delete all of ali's turtles
    ali.getTurtles().deleteAllFromRealm();
    ali.deleteFromRealm();
});

realm.executeTransaction { r: Realm ->
    // Find a turtle enthusiast named "Ali"
    val ali = r.where(TurtleEnthusiast::class.java)
        .equalTo("name", "Ali").findFirst()
    // Delete all of ali's turtles
    ali!!.turtles!!.deleteAllFromRealm()
    ali.deleteFromRealm()
}

Borrar todos los objetos de un tipo específico

Realm permite borrar todas las instancias de un tipo Realm de un realm.

El siguiente ejemplo demuestra cómo eliminar todas las instancias de Turtle de un reino con delete():

realm.executeTransaction(r -> {
    r.delete(Turtle.class);
});

realm.executeTransaction { r: Realm ->
    r.delete(Turtle::class.java)
}

Eliminar todos los objetos en un reino

Es posible eliminar todos los objetos del reino. Esto no afecta el esquema del reino. Resulta útil para vaciar rápidamente el reino durante el prototipado.

El siguiente ejemplo demuestra cómo eliminar todo de un reino con deleteAll():

realm.executeTransaction(r -> {
    r.deleteAll();
});

realm.executeTransaction { r: Realm ->
    r.deleteAll()
}

Eliminar un objeto usando un iterador

Dado que las colecciones de dominios siempre reflejan el estado más reciente, pueden aparecer, desaparecer o cambiar al iterar sobre ellas. Para obtener una colección estable que se pueda iterar, se puede crear una instantánea de sus datos. Una instantánea garantiza que el orden de los elementos no cambie, incluso si se elimina un elemento.

Para ver un ejemplo, consulte Iteración.