Excluir objetos de domínio - Kotlin SDK

Objetos e referências relacionados

Quando você exclui um objeto que tem uma propriedade de relacionamento com outro objeto, o Realm não exclui automaticamente a instância do objeto relacionado. Em vez disso, o Realm exclui apenas a referência ao outro objeto. O objeto referenciado permanece no domínio, mas não pode mais ser querydo através da propriedade principal.

A única exceção é se o objeto relacionado estiver incorporado. Quando você exclui um objeto que tem um relacionamento com um EmbeddedRealmObject, a Realm exclui automaticamente o objeto incorporado em uma exclusão em cascata. Para obter mais informações, consulte a seção Excluir um objeto incorporado nesta página.

Excluir um único objeto

Para excluir um único objeto RealmObject, consulte o tipo de objeto usando um filtro que retorna o objeto específico que você deseja excluir.

No exemplo a seguir, querymos um objeto Frog com uma chave primária específica e, em seguida, passamos o objeto retornado para mutableRealm.delete() para excluí-lo do domínio:

// 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)
}

Excluir vários objetos

Para excluir vários objetos ao mesmo tempo, passe o tipo de objeto para query() e especifique uma query que retorna todos os objetos que você deseja excluir.

No exemplo a seguir, querymos os três primeiros objetos Frog cujo species é "rã-touro" e, em seguida, passamos os resultados para mutableRealm.delete() para excluí-los do território:

// 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)
}

Excluir todos os objetos de um tipo

Para excluir todos os objetos de um tipo específico de um domínio ao mesmo tempo, passe o tipo de objeto para query() e deixe o filtro de query vazio para retornar todos os objetos desse tipo.

No exemplo a seguir, querymos todos os Frog objetos e, em seguida, passamos os resultados para mutableRealm.delete() para excluí-los todos do domínio:

// 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)
}

Excluir todos os objetos em um Realm

O Kotlin SDK permite que você exclua todos os objetos gerenciados de todos os tipos, o que é útil para limpar rapidamente o seu domínio durante a criação de protótipos. Isso não afeta o esquema de domínio ou quaisquer objetos que não sejam gerenciados pelo domínio.

Para excluir todos os objetos do domínio ao mesmo tempo, chame mutableRealm.deleteAll(). Isso exclui todos os objetos de todos os tipos.

No exemplo a seguir, excluímos todos os objetos do domínio com deleteAll():

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

Excluir um objeto e seus objetos relacionados

Para excluir objetos relacionados quando você exclui um objeto pai, você mesmo deve excluir manualmente os objetos relacionados. Recomendamos que as exclusões sejam encadeadas: primeiro, consulte o objeto principal que você deseja excluir e, em seguida, itere pelas relações do objeto pai e exclua cada objeto relacionado. Finalmente, exclua o próprio objeto principal.

No exemplo a seguir, querymos um objeto Frog chamado "Kermit", depois iteramos pela propriedade favoritePonds do objeto e excluímos cada objeto Pond. Em seguida, excluímos o próprio 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)
    }
}

Excluir um objeto incorporado

Você pode excluir um objeto incorporado por meio do objeto pai em uma exclusão em cascata ou excluindo o objeto incorporado diretamente.

• Para excluir o objeto incorporado por meio do objeto pai, procure e exclua o objeto principal. O Realm exclui automaticamente todos os seus objetos incorporados do domínio.

• Para excluir diretamente uma instância de objeto incorporado:

  • Buscar e excluir um objeto incorporado específico.

  • Limpe a referência dos pais ao objeto incorporado, o que também exclui a instância do objeto incorporado.

No exemplo a seguir, temos um objeto Business com uma lista de objetos EmbeddedAddress incorporados. Consultamos e excluímos o objeto Business, que exclui automaticamente todos os seus objetos EmbeddedAddress incorporados:

// 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)
}

No exemplo a seguir, temos Contact objetos com EmbeddedAddress objetos incorporados. Excluímos um objeto EmbeddedAddress diretamente e excluímos outro pelo objeto pai:

// 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
}

Remover Elementos de uma RealmList

Você pode remover um ou mais elementos em uma única transação de uma RealmList:

• Para remover um elemento da lista, passe o elemento para list.remove().

• Para remover um elemento em um índice especificado na lista, passe o índice para list.removeAt().

• Para remover vários elementos da lista, passe os elementos para list.removeAll().

Você também pode remover todos os elementos da lista de uma só vez, chamando list.clear().

No exemplo a seguir, temos um objeto Forest com uma lista de Pond objetos. Removemos os elementos da lista em uma série de operações até que a lista esteja vazia:

// 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)
}

No exemplo a seguir, temos um objeto Forest com uma lista de Pond objetos. Removemos todos os elementos da lista com o 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)
}

Remover Elementos de um RealmSet

Você pode remover um ou mais elementos em uma única transação de um RealmSet:

• Para remover um elemento do conjunto, passe o elemento que pretende eliminar para set.remove().

• Para remover vários elementos do conjunto, passe os elementos que você deseja excluir para set.removeAll().

Você também pode remover todos os elementos definidos de uma só vez chamando set.clear().

No exemplo a seguir, temos um objeto Frog com um conjunto de Snack objetos. Removemos os elementos do conjunto em uma série de operações até que o conjunto esteja vazio:

// 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)
}

No exemplo a seguir, temos um objeto Frog com um conjunto de Snack objetos. Removemos todos os elementos definidos com o 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)
}

Remover chaves/valores do dicionário

Você pode remover entradas do RealmDictionary de algumas maneiras:

• Para remover o valor, mas manter a chave, defina a chave para null (o valor do dicionário deve ser anulável)

• Para remover a chave e o valor, passe a chave para remove()

Você também pode remover todas as chaves e valores chamando clear().

No exemplo a seguir, temos um objeto Frog com um dicionário de valores String. Removemos os elementos do dicionário em uma série de operações até que o dicionário esteja vazio:

// 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())
}