Tipos suportados - Kotlin SDK

Lista de tipos de dados suportados

O Kotlin SDK é compatível com os seguintes tipos de Kotlin, tiposBSON e tipos específicos de Realm, que você pode usar para identificadores exclusivos, carimbos de data/hora, contadores e coleções.

O SDK do Kotlin não oferece suporte nativo:

• propriedades de enumeração definidas pelo usuário. Consulte a seção Enums para obter mais informações sobre como usar enums em seus objetos Realm.

• Date ou Instant integrado do Kotlin. Consulte a seção RealmInstant para obter mais informações sobre como usar timestamps em seus objetos Realm.

Propriedades de objeto real devem ser mutáveis e inicializadas quando declaradas. Atualmente, o Kotlin SDK não oferece suporte a propriedades abstratas. Você pode declarar propriedades opcionais (anuláveis) usando o operador interno ? Kotlin ou pode atribuir um valor padrão a uma propriedade ao declará-la.

Tipos de dados Kotlin

A tabela a seguir lista os tipos de dados Kotlin com suporte e exemplos de como declará-los como propriedades obrigatórias ou opcionais em seu modelo de objeto.

var stringReq: String = ""

var stringOpt: String? = null

var byteReq: Byte = 0

var byteOpt: Byte? = null

var shortReq: Short = 0

var shortOpt: Short? = null

var intReq: Int = 0

var intOpt: Int? = null

var longReq: Long = 0L

var longOpt: Long? = null

var floatReq: Float = 0.0f

var floatOpt: Float? = null

var doubleReq: Double = 0.0

var doubleOpt: Double? = null

var boolReq: Boolean = false

var boolOpt: Boolean? = null

var charReq: Char = 'a'

var charOpt: Char? = null

Tipos de JSON do MongoDB

A tabela a seguir lista os tipos de dados BSON do MongoDB suportados e exemplos de como declará-los como propriedades obrigatórias ou opcionais em seu modelo de objeto. Para usar esses tipos, você deve importá-los do pacote org.mongodb.kbson.

var objectIdReq: ObjectId = ObjectId()

var objectIdOpt: ObjectId? = null

var decimal128Req: Decimal128 = Decimal128("123.456")

var decimal128Opt: Decimal128? = null

Tipos específicos do domínio

A tabela a seguir lista os tipos de dados específicos do Realm com suporte e exemplos de como declará-los como propriedades obrigatórias ou opcionais em seu modelo de objeto.

var uuidReq: RealmUUID = RealmUUID.random()

var uuidOpt: RealmUUID? = null

var realmInstantReq: RealmInstant = RealmInstant.now()

var realmInstantOpt: RealmInstant? = null

var realmAnyOpt: RealmAny? = RealmAny.create("foo")

var mutableRealmIntReq: MutableRealmInt = MutableRealmInt.create(0)

var mutableRealmIntOpt: MutableRealmInt? = null

var listReq: RealmList<CustomObjectType> = realmListOf()

var setReq: RealmSet<String> = realmSetOf()

var dictionaryReq: RealmDictionary<String> = realmDictionaryOf()

var realmObjectPropertyOpt: CustomObjectType? = null

var embeddedProperty: EmbeddedObjectType? = null

Unique Identifiers

O Kotlin SDK suporta UUID e ObjectId como identificadores únicos para objetos do Realm.

val uuid1 = RealmUUID.from("46423f1b-ce3e-4a7e-812f-004cf9c42d76")
val uuid2 = RealmUUID.random()

MutableRealmInt (Contador)

O Kotlin SDK oferece MutableRealmInt como um tipo inteiro especial que você pode usar como contador lógico para sincronizar com precisão as alterações numéricas em vários clientes distribuídos. Ele se comporta como Long mas também oferece suporte increment aos decrement métodos e que implementam um tipo de dados replicado sem conflitos. Isso garante que as atualizações numéricas possam ser executadas independentemente da ordem de convergência para o mesmo valor.

Uma propriedade MutableRealmInt:

• não pode ser usado como uma chave primária

• não pode armazenar valores nulos, mas pode ser declarada anulável (MutableRealmInt?)

Além disso, MutableRealmInt campos:

• são apoiados pelos tipos numéricos do Kotlin, portanto, nenhuma migração é necessária ao alterar um campo numérico para MutableRealmInt.

• pode usar operadores e funções infixas semelhantes às fornecidas por Long. No entanto, observe que quaisquer operações diferentes de set, increment e decrement não alteram a instância na qual elas são executadas. Em vez disso, eles criam uma nova instância do MutableRealmInt não gerenciada com o valor atualizado.

Saiba como Criar uma propriedade MutableRealmInt (contador) e Atualizar uma propriedade MutableRealmInt (contador).

RealmInstant (Carimbo de data/hora)

Você não pode armazenar os tipos de Date ou Instant integrados do Kotlin no Realm.

Em vez disso, o SDK do Kotlin usa o tipo RealmInstant para armazenar informações de tempo como um carimbo de data/hora Unix.

Se precisar de dados de carimbo de data/hora em um formato diferente de RealmInstant, você poderá adicionar código de conversão à sua classe de modelo com base no exemplo a seguir:

// model class that stores an Instant (kotlinx-datetime) field as a RealmInstant via a conversion
class RealmInstantConversion : RealmObject {
    private var _timestamp: RealmInstant = RealmInstant.from(0, 0)
    public var timestamp: Instant
        get() {
            return _timestamp.toInstant()
        }
        set(value) {
            _timestamp = value.toRealmInstant()
        }
}
fun RealmInstant.toInstant(): Instant {
    val sec: Long = this.epochSeconds
    // The value always lies in the range `-999_999_999..999_999_999`.
    // minus for timestamps before epoch, positive for after
    val nano: Int = this.nanosecondsOfSecond
    return if (sec >= 0) { // For positive timestamps, conversion can happen directly
        Instant.fromEpochSeconds(sec, nano.toLong())
    } else {
        // For negative timestamps, RealmInstant starts from the higher value with negative
        // nanoseconds, while Instant starts from the lower value with positive nanoseconds
        // TODO This probably breaks at edge cases like MIN/MAX
        Instant.fromEpochSeconds(sec - 1, 1_000_000 + nano.toLong())
    }
}
fun Instant.toRealmInstant(): RealmInstant {
    val sec: Long = this.epochSeconds
    // The value is always positive and lies in the range `0..999_999_999`.
    val nano: Int = this.nanosecondsOfSecond
    return if (sec >= 0) { // For positive timestamps, conversion can happen directly
        RealmInstant.from(sec, nano)
    } else {
        // For negative timestamps, RealmInstant starts from the higher value with negative
        // nanoseconds, while Instant starts from the lower value with positive nanoseconds
        // TODO This probably breaks at edge cases like MIN/MAX
        RealmInstant.from(sec + 1, -1_000_000 + nano)
    }
}

RealmAny (Misto)

RealmAny representa um tipo de dados misto não nulo. Ele se comporta como o tipo de valor que contém. RealmAny pode conter:

• Tipos de dados de Kotlin suportados (observe que os valores Byte, Char, Int, Long e Short são convertidos internamente em valores int64_t )

• tipos de BSON suportados

• RealmList e RealmDictionary collections de dados mistos

• os seguintes tipos específicos de domínio:

  • Instante real

  • RealmUUID

  • RealmObject (retém uma referência ao objeto, não uma cópia dele)

RealmAny não pode conter EmbeddedRealmObject tipos, RealmSet ou outro RealmAny.

RealmAny propriedades:

• são indexáveis , mas não podem ser usados como chave primária

• deve ser declarada anulável (RealmAny?), mas não pode armazenar valores nulos

• pode ser agregado com RealmQuery.max, RealmQuery.min e RealmQuery.sum.

• pode ser classificado. Ordem de classificação do maior para o menor:

  1. Boolean

  2. Byte, Double, Decimal128, Int, Float, Long, Short

  3. byte[], String

  4. Date

  5. ObjectId

  6. UUID

  7. RealmObject

Você pode armazenar múltiplas instâncias do RealmAny em campos do RealmList, RealmDictionary ou RealmSet.

Tipos de coleção

O Kotlin SDK oferece vários tipos de coleção que você pode usar como propriedades em seu modelo de dados. Uma coleção é um objeto que contém zero ou mais instâncias de um tipo de dados suportado. As coleções Realm são homogêneas (todos os objetos em uma coleção são do mesmo tipo) e são apoiadas por suas classes Kotlin incorporadas correspondentes.

Os tipos de coleção não são nulos. Ao definir uma propriedade de coleção, você deve inicializá-la. Para mais informações, consulte Criar uma coleção.

RealmObjetos como Propriedades

Você pode usar RealmObject e quaisquer subclasses, exceto AsymmetricRealmObject como propriedades em seu modelo de objeto.

Tipos geoespaciais

O Kotlin SDK suporta queries geoespaciais utilizando os seguintes tipos de dados:

• GeoPoint

• Círculo geográfico

• GeoBox

• GeoPolygon

Para mais informações sobre query com dados geoespaciais, consulte Dados Geoespaciais.

Enumerações

O SDK Kotlin não oferece suporte nativo a enumerações ou enums. Para usar enums em uma classe de objeto de Realm, defina um campo com um tipo que corresponda ao tipo de dados subjacente do seu enum.

Em seguida, crie getters e setters para o campo que convertem o valor do campo entre o valor subjacente e o tipo de enum.

enum class EnumClass(var state: String) {
    NOT_STARTED("NOT_STARTED"),
    IN_PROGRESS("IN_PROGRESS"),
    COMPLETE("COMPLETE")
}
class EnumObject : RealmObject {
    var name: String? = null
    private var state: String = EnumClass.NOT_STARTED.state
    var stateEnum: EnumClass
        get() = EnumClass.valueOf(state)
        set(value) {
            state = value.state
        }
}