Definir un modelo de objeto Realm - Kotlin SDK

Objetos del reino

Realm objects are uniquely named instances of Kotlin classes that you can work with as you would any other class instance.

Cada clase de objeto representa un tipo de objeto. Los objetos del mismo tipo comparten un esquema de objeto, que define sus propiedades y relaciones. El SDK garantiza que todos los objetos de un dominio se ajusten al esquema de su tipo y valida los objetos al crearlos, modificarlos o eliminarlos.

Sin embargo, ten en cuenta que los objetos Realm tienen las siguientes restricciones:

• Los objetos del reino deben heredar del RealmObject Clase o sus subclases: EmbeddedRealmObject AsymmetricRealmObjecto. El SDK de Kotlin no admite la herencia de clases base personalizadas.

• El SDK de Kotlin requiere que los objetos Realm tengan un constructor vacío. Consulte El ejemplo de solución alternativa se detalla en la siguiente sección.

• Class names are limited to a maximum of 57 UTF-8 characters.

Además, el SDK de Kotlin no admite el uso de clases de datos deKotlin. Para modelar datos. Esto se debe a que las clases de datos se suelen usar para datos inmutables, lo cual contradice la forma en que el SDK de Kotlin de Realm modela los datos.

Define a New Object Type

Para definir un nuevo tipo de objeto Realm, debes crear una clase Kotlin con un nombre único que implementar la interfaz RealmObject, EmbeddedRealmObject o AsymmetricRealmObject.

Then, you specify your object's properties, including:

• El tipo de dato para cada propiedad. El Kotlin SDK admite los siguientes tipos de datos:

  • Kotlin primitive types

  • a limited subset of BSON types

  • Realm-specific types, which you can use for unique identifiers, timestamps, counters, and collections

• Cualquier anotación de propiedad que añada funcionalidad a las propiedades de los objetos de Realm. Puedes usar anotaciones para:

  • Designate a property as a primary key

  • Mark a property as indexable

  • Ignore a property

  • Map a property or class name to another name

• Cualquier relación con otros objetos de Realm.

After you've defined your Realm object model, you can pass the set of object classes to the realm's configuration when you open a realm, and then work with those objects in the realm.

class Person(var name: String, var age: Int): RealmObject {
   constructor(): this("", 0) // Empty constructor required by Realm
}

// Implements the `RealmObject` interface
class Frog : RealmObject { // Empty constructor required by Realm
    @PrimaryKey
    var _id: ObjectId = ObjectId()
    var name: String = ""
    var age: Int = 0
    var species: String? = null
    var owner: String? = null
}

// Implements `EmbeddedRealmObject` interface
class EmbeddedAddress : EmbeddedRealmObject {
    // CANNOT have primary key
    var street: String? = null
    var city: String? = null
    var state: String? = null
    var postalCode: String? = null
    var propertyOwner: Contact? = null
}

// Implements the `AsymmetricRealmObject` interface
class WeatherSensor : AsymmetricRealmObject {
    @PersistedName("_id")
    @PrimaryKey
    var id: ObjectId = ObjectId()
    var deviceId: String = ""
    var temperatureInFarenheit: Float = 0.0F
    var barometricPressureInHg: Float = 0.0F
    var windSpeedInMph: Int = 0
}

Define Collection Properties

A collection is an object that contains zero or more instances of a supported data type. Realm collections are homogenous (all objects in a collection are of the same type) and are backed by their corresponding built-in Kotlin classes. For more information on the collection types used in the Kotlin SDK and their supported data types, refer to Collection Types.

The Kotlin SDK offers several collection types that you can use as properties in your data model: RealmList, RealmSet, and RealmDictionary.

Las colecciones también te permiten definir relaciones tipo to-many entre los objetos de Realm. Consulta Relaciones - Kotlin SDK para obtener más información.

// RealmList<E> can be any supported primitive
// or BSON type, a RealmObject, or an EmbeddedRealmObject
class Frog : RealmObject {
    var _id: ObjectId = ObjectId()
    var name: String = ""
    // List of RealmObject type (CANNOT be nullable)
    var favoritePonds: RealmList<Pond> = realmListOf()
    // List of EmbeddedRealmObject type (CANNOT be nullable)
    var favoriteForests: RealmList<EmbeddedForest> = realmListOf()
    // List of primitive type (can be nullable)
    var favoriteWeather: RealmList<String?> = realmListOf()
}
class Pond : RealmObject {
    var _id: ObjectId = ObjectId()
    var name: String = ""
}

// RealmSet<E> can be any supported primitive or
// BSON type or a RealmObject
class Frog : RealmObject {
    var _id: ObjectId = ObjectId()
    var name: String = ""
    // Set of RealmObject type (CANNOT be nullable)
    var favoriteSnacks: RealmSet<Snack> = realmSetOf()
    // Set of primitive type (can be nullable)
    var favoriteWeather: RealmSet<String?> = realmSetOf()
}
class Snack : RealmObject {
    var _id: ObjectId = ObjectId()
    var name: String = ""
}

// RealmDictionary<K, V> can be any supported
// primitive or BSON types, a RealmObject, or
// an EmbeddedRealmObject
class Frog : RealmObject {
    var _id: ObjectId = ObjectId()
    var name: String = ""
    // Dictionary of RealmObject type (value MUST be nullable)
    var favoriteFriendsByPond: RealmDictionary<Frog?> = realmDictionaryOf()
    // Dictionary of EmbeddedRealmObject type (value MUST be nullable)
    var favoriteTreesInForest: RealmDictionary<EmbeddedForest?> = realmDictionaryOf()
    // Dictionary of primitive type (value can be nullable)
    var favoritePondsByForest: RealmDictionary<String?> = realmDictionaryOf()
}

// Percent encode . or $ characters to use them in map keys
val mapKey = "Hundred Acre Wood.Northeast"
val encodedMapKey = "Hundred Acre Wood%2ENortheast"

Define Unstructured Data

A partir de la versión 2.0.0 de Kotlin SDK, puedes almacenar colecciones de datos mixtos dentro de una propiedad RealmAny. Puedes utilizar esta funcionalidad para modelar estructuras de datos complejas, como documentos JSON o MongoDB, sin tener que definir un modelo de datos estricto.

Unstructured data is data that doesn't easily conform to an expected schema, making it difficult or impractical to model to individual data classes. For example, your app might have highly variable data or dynamic data whose structure is unknown at runtime.

Storing collections in a mixed property offers flexibility without sacrificing functionality, including performant synchronization when using Device Sync. And you can work with them the same way you would a non-mixed collection:

• Se pueden anidar colecciones mixtas hasta 100 niveles.

• You can query on and react to changes on mixed collections.

• You can find and update individual mixed collection elements.

However, storing data in mixed collections is less performant than using a structured schema or serializing JSON blobs into a single string property.

Para modelar datos no estructurados en tu aplicación, define las propiedades adecuadas en tu esquema como tipos RealmAny. Puedes configurar estas RealmAny propiedades como una colección RealmList o RealmDictionary de RealmAny elementos. Ten en cuenta que RealmAny no puede representar un RealmSet ni un objeto incrustado.