CRUD - Delete - Java SDK

Acerca de los ejemplos en 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.

See the schema for these two classes, Project and Task, below:

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.

The following example shows how to delete one object from its realm with 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
}

Delete Multiple Objects

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().

The following example demonstrates how to delete a collection from a realm with 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()
}

Delete an Object and its Dependent Objects

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.

Currently, the best way to delete dependent objects is to iterate through the dependencies and delete them before deleting the parent object.

The following example demonstrates how to perform a chaining delete by first deleting all of Ali's turtles, then deleting 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)
}

Delete All Objects in a Realm

Es posible borrar todos los objetos del realm. Esto no afecta el esquema del realm. Esto es útil para limpiar rápidamente tu realm mientras creas prototipos.

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

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

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

Borre un objeto usando un iterador

Because realm collections always reflect the latest state, they can appear, disappear, or change while you iterate over a collection. To get a stable collection you can iterate over, you can create a snapshot of a collection's data. A snapshot guarantees the order of elements will not change, even if an element is deleted.

For an example, refer to Iteration.