Leer objetos de Realm - SDK de Kotlin

Resultados congelados y en vivo

A diferencia de otros SDK de dispositivos Atlas, que siempre devuelven resultados en tiempo real, los resultados con el SDK de Kotlin pueden estar congelados o en tiempo real. Para obtener más información sobre la arquitectura congelada del SDK de Kotlin, consulte Arquitectura congelada - SDK de Kotlin.

Para acceder a los resultados congelados, ejecute una consulta en un dominio. Los resultados congelados no se pueden modificar y no reflejan los últimos cambios en la base de datos. Un Realm.query() no requiere una transacción de escritura.

Para acceder a resultados en tiempo real, ejecute una consulta en una instancia de MutableRealm en una transacción de escritura. Un MutableRealm representa un estado de escritura en una base de datos y solo se puede acceder a él mediante una transacción de escritura. Los resultados de una consulta MutableRealm.query están en tiempo real, pero solo son válidos en el hilo que realiza la llamada y se congelan una vez completada la transacción de escritura. Para obtener más información sobre las transacciones de escritura y el acceso MutableRealm a un, consulte Transacciones de escritura.

También puede acceder a objetos activos desde resultados congelados llamando a MutableRealm.findLatest(). Para más información, consulte la sección "Buscar la última versión de un objeto" en esta página.

// 'Realm.query()' results are always frozen
val frozenResults = realm.query<Frog>("age > $0", 50).find()
// 'MutableRealm.query()' results are live within the current write transaction
realm.write { // this: MutableRealm
    val liveResults = this.query<Frog>("age > $0", 50).find()

Encontrar la última versión de un objeto

Debido a la arquitectura congelada del SDK, no siempre estás trabajando con la última versión de un objeto o colección.

Para obtener una versión de un objeto o colección que refleje los últimos cambios en la base de datos, puede llamar a findLatest() desde una MutableRealm instancia. Al igual que con una MutableRealm.query() instancia, los resultados están activos,pero solo son válidos en el hilo que los llama y se congelan una vez completada la transacción de escritura.

En el siguiente ejemplo, pasamos el RealmResults de una consulta frozenFrogs existente a findLatest() para obtener la última copia activa de la colección. A continuación, modificamos los objetos ya activos dentro de la transacción de escritura:

// Open a write transaction to access the MutableRealm
realm.write {  // this: MutableRealm
    for (frog in frozenFrogs) {
        // Call 'findLatest()' on an earlier query's frozen results
        // to return the latest live objects that you can modify
        // within the current write transaction
        findLatest(frog)?.also { liveFrog ->  
            copyToRealm(liveFrog.apply { age += 1 })
            println(liveFrog.name + " is now " + liveFrog.age + " years old")
        }
    }
}

val isFrozen = frog.isFrozen()

Consultar todos los objetos de un tipo

Para consultar todos los objetos de un tipo específico, pase el RealmObject EmbeddedRealmObject tipo de objeto o como parámetro de tipo a query() sin ningún argumento de consulta. El SDK devuelve todos los objetos del tipo especificado.

En el siguiente ejemplo, consultamos todos los RealmObject objetos del tipo Frog:

// Query all Frog objects in the database
val queryAllFrogs = realm.query<Frog>()
val allFrogs = queryAllFrogs.find()

En el siguiente ejemplo, consultamos todos los EmbeddedRealmObject objetos del tipo EmbeddedAddress:

val queryAllEmbeddedAddresses = realm.query<EmbeddedAddress>()
val allEmbeddedAddresses = queryAllEmbeddedAddresses.find()

También puede consultar un objeto incrustado a través de su objeto principal. Para obtener más información, consulte la sección "Filtrar por propiedad de objeto incrustado" en esta página.

val getParent = embeddedObject.parent<Contact>()

Consultar un solo objeto

Para encontrar un objeto de un tipo específico, ejecute first() en la consulta. Al ejecutar la consulta, el SDK devuelve el primer objeto que cumple las condiciones null o.

En el siguiente ejemplo, consultamos un tipo de objeto Frog y devolvemos el primer objeto:

val querySingleFrog = realm.query<Frog>().first()
val singleFrog = querySingleFrog.find()
if (singleFrog != null) {
    println("${singleFrog.name} is a frog.")
} else {
    println("No frogs found.")
}

Filtrar por propiedad

Puede filtrar una consulta por cualquier propiedad del tipo de objeto que persista en la base de datos. Esto incluye las propiedades secundarias, a las que puede hacer referencia mediante la notación de puntos.

Para filtrar por propiedad, puede usar filtros y operadores de Realm Query Language (RQL), los métodos de extensión integrados de Kotlin o los métodos de conveniencia del SDK, o una combinación de ellos. Para obtener información sobre todos los operadores y la sintaxis de RQL compatibles actualmente, consulte la documentación de referencia de Realm Query Language.

En el siguiente ejemplo, consultamos un tipo de objeto Frog y filtramos por la propiedad name:

val filterByProperty = realm.query<Frog>("name == $0", "Kermit")
val frogsNamedKermit = filterByProperty.find()

val filterByPrimaryKey = realm.query<Frog>("_id == $0", PRIMARY_KEY_VALUE)
val findPrimaryKey = filterByPrimaryKey.find().first()

// Use dot notation to access the embedded object properties as if it
// were in a regular nested object
val filterEmbeddedObjectProperty =
    realm.query<Contact>("address.street == '123 Pond St'")
// You can also access properties nested within the embedded object
val queryNestedProperty = realm.query<Contact>()
    .query("address.propertyOwner.name == $0", "Mr. Frog")

val filterByRealmAnyInt = realm.query<Frog>("favoriteThing.@type == 'int'")
val findFrog = filterByRealmAnyInt.find().first()

val frogsFavoriteThing = findFrog.favoriteThing // Int
// Using the correct getter method returns the value
val frogsFavoriteNumber = frogsFavoriteThing?.asInt()
println("${findFrog.name} likes the number $frogsFavoriteNumber")

// Handle possible types with a 'when' statement
frogsFavoriteThings.forEach { realmAny ->
    if (realmAny != null) {
        when (realmAny.type) {
            RealmAny.Type.INT -> {
                val intValue = realmAny.asInt()
                // Do something with intValue ...
            }
            RealmAny.Type.STRING -> {
                val stringValue = realmAny.asString()
                // Do something with stringValue ...
            }
            RealmAny.Type.OBJECT -> {
                val objectValue = realmAny.asRealmObject(Frog::class)
                // Do something with objectValue ...
            }
            // Handle other possible types...
            else -> {
                // Debug or perform a default action for unhandled types
                Log.d("Unhandled type: ${realmAny.type}")
            }
        }
    }
}

@PersistedName("latin_name")
var species: String? = null // Remapped property

val filterByKotlinName = realm.query<Frog>("species == $0", "Muppetarium Amphibius")
val findSpecies = filterByKotlinName.find().first()
val filterByRemappedName = realm.query<Frog>("latin_name == $0", "Muppetarium Amphibius")
val find_latin_name = filterByRemappedName.find().first()
// Both queries return the same object
assertEquals(findSpecies, find_latin_name)

// Filter by FTS property value using 'TEXT'
// Find all frogs with "green" in the physical description
val onlyGreenFrogs =
    realm.query<Frog>("physicalDescription TEXT $0", "green").find()
// Find all frogs with "green" but not "small" in the physical description
val onlyBigGreenFrogs =
    realm.query<Frog>("physicalDescription TEXT $0", "green -small").find()
// Find all frogs with "muppet-" and "rain-" in the physical description
val muppetsInTheRain =
    realm.query<Frog>("physicalDescription TEXT $0", "muppet* rain*").find()

// Find frogs with a favorite pond
val allFrogs = query<Frog>().find()
val frogsWithFavoritePond = allFrogs.query("favoritePonds.@size > $0", 0).find()
// Check if the list contains a value
for (frog in frogsWithFavoritePond) {
    val likesBigPond = frog.favoritePonds.any { pond -> pond.name == "Big Pond" }
    if (likesBigPond) {
        Log.v("${frog.name} likes Big Pond")
    } else {
        Log.v("${frog.name} does not like Big Pond")
    }
}

// Find frogs with flies and crickets as a favorite snack
val filterBySnackSet = query<RealmSet_Frog>("favoriteSnacks.name CONTAINS $0 AND favoriteSnacks.name CONTAINS $1", "Flies", "Crickets")
val potentialFrogs = filterBySnackSet.find()
// Check if the set contains a value
val frogsThatLikeWorms = potentialFrogs.filter { frog ->
    val requiredSnacks = query<RealmSet_Snack>("name == $0", "Worms")
    frog.favoriteSnacks.contains(requiredSnacks.find().first())
}
for (frog in frogsThatLikeWorms) {
    Log.v("${frog.name} likes both Flies, Worms, and Crickets")
}

// Find frogs who have forests with favorite ponds
val frogs = realm.query<Frog>().find()
val frogsWithFavoritePonds = frogs.query("favoritePondsByForest.@count > $0", 1).find()
val thisFrog = frogsWithFavoritePonds.first()
// Iterate through the map and log each key-value pair
for (forestName in thisFrog.favoritePondsByForest.keys) {
    val pondName = thisFrog.favoritePondsByForest[forestName]
    Log.v("Forest: $forestName, Pond: $pondName")
}
// Check if the dictionary contains a key
if (thisFrog.favoritePondsByForest.containsKey("Hundred Acre Wood")) {
    Log.v("${thisFrog.name}'s favorite pond in Hundred Acre Wood is ${thisFrog.favoritePondsByForest["Hundred Acre Wood"]}")
}
// Check if the dictionary contains a value
if (thisFrog.favoritePondsByForest.containsValue("Picnic Pond")) {
    Log.v("${thisFrog.name} lists Picnic Pond as a favorite pond")
}

// Find frogs who have a favorite pond
val allFrogs = query<Frog>().find()
val frogsWithFavoritePond = allFrogs.query("favoritePond.@count == $0", 1).find()
// Iterate through the results
for (frog in frogsWithFavoritePond) {
    Log.v("${frog.name} likes ${frog.favoritePond?.name}")
}

// Find all forests with at least one nearby pond
val allForests = query<Forest>().find()
val forestsWithPonds = allForests.query("nearbyPonds.@count > $0", 0).find()
// Iterate through the results
for (forest in forestsWithPonds) {
    val bigPond = query<Pond>("name == $0", "Big Pond").find().first()
    if (forest.nearbyPonds.contains(bigPond)) {
        Log.v("${forest.name} has a nearby pond named ${bigPond.name}")
    } else {
        Log.v("${forest.name} does not have a big pond nearby")
    }
}

// Query the parent object
val filterByUserName = query<User>("name == $0", "Kermit")
val kermit = filterByUserName.find().first()
// Use dot notation to access child objects
val myFirstPost = kermit.posts[0]
// Iterate through the backlink collection property
kermit.posts.forEach { post ->
    Log.v("${kermit.name}'s Post: ${post.date} - ${post.title}")
}
// Filter posts through the parent's backlink property
// using `@links.<ObjectType>.<PropertyName>` syntax
val oldPostsByKermit = realm.query<Post>("date < $0", today)
    .query("@links.User.posts.name == $0", "Kermit")
    .find()
// Query the child object to access the parent
val post1 = query<Post>("title == $0", "Forest Life").find().first()
val post2 = query<Post>("title == $0", "Top Ponds of the Year!").find().first()
val parent = post1.user.first()

@PersistedName(name = "Blog_Author")
class User : RealmObject {
    @PrimaryKey
    var _id: ObjectId = ObjectId()
    var name: String = ""
    var posts: RealmList<Post> = realmListOf()
}

// Filter by the remapped object type name
// using `@links.<RemappedObjectType>.<PropertyName>` syntax
val postsByKermit = realm.query<Post>()
    .query("@links.Blog_Author.posts.name == $0", "Kermit")
    .find()

Consultar datos geoespaciales

La versión 1.11.0 y posteriores del SDK de Kotlin agregan API geoespaciales experimentales que admiten consultas con datos geoespaciales.

Los datos geoespaciales se almacenan como un par de latitud/longitud en la propiedad coordinates de un objeto incrustado personalizado. Una consulta geoespacial comprueba si el punto definido por la propiedad coordinates se encuentra dentro del límite de una forma geoespacial definida.

El SDK es compatible con las siguientes formas geoespaciales:

• GeoCircle: definido por un centro GeoPoint y un radio Distance

• GeoBox: definido por dos coordenadas GeoPoint que representan las esquinas suroeste y noreste del cuadro

• GeoPolygon: definido por un conjunto de al menos 4 GeoPoint coordenadas que representan una forma cerrada. Esta forma puede contener huecos que representan límites exclusivos dentro de los límites del polígono definido.

Para obtener más información sobre las formas geoespaciales y cómo definirlas, consulte Datos geoespaciales - SDK de Kotlin.

Para query datos geoespaciales:

1. Crea un objeto que contenga los datos geoespaciales integrados.

2. Define la forma geoespacial para establecer el límite de la consulta.

3. Consulta con el operador RQL GEOWITHIN. Este método toma la propiedad coordinates de su objeto incrustado compatible con GeoJSON y comprueba si ese punto está dentro de los límites de una forma definida. La sintaxis es la misma, independientemente de la forma geoespacial.

En el siguiente ejemplo, queremos consultar datos geoespaciales almacenados en un objeto Company mediante su propiedad location incrustada. Creamos dos objetos GeoCircle para definir el límite de la consulta:

val circle1 = GeoCircle.create(
    center = GeoPoint.create(47.8, -122.6),
    radius = Distance.fromKilometers(44.4)
)
val circle2 = GeoCircle.create(
    center = GeoPoint.create(47.3, -121.9),
    radius = Distance.fromDegrees(0.25)
)

Luego consultamos cualquier objeto Company con un location contenido dentro de los límites GeoCircle definidos:

val companiesInLargeCircle =
    realm.query<Company>("location GEOWITHIN $circle1").find()
println("Companies in large circle: ${companiesInLargeCircle.size}")
val companiesInSmallCircle =
    realm.query<Company>("location GEOWITHIN $circle2").find()
println("Companies in small circle: ${companiesInSmallCircle.size}")

Companies in large circle: 1
Companies in small circle: 0

haga clic para ampliar