Criar objetos de domínio - Kotlin SDK

Criar um Objeto de Realm

Para criar uma nova instância do RealmObject , instancie um novo objeto de um Tipo de objeto de Realm.

No exemplo a seguir, instanciamos um objeto Frog em um bloco realm.write() e, em seguida, passamos o objeto instanciado para copyToRealm() para retornar uma instância managed:

// Open a write transaction
realm.write {
    // Instantiate a new unmanaged Frog object
    val unmanagedFrog = Frog().apply {
        name = "Kermit"
        age = 42
        owner = "Jim Henson"
    }
    assertFalse(unmanagedFrog.isManaged())
    // Copy the object to realm to return a managed instance
    val managedFrog = copyToRealm(unmanagedFrog)
    assertTrue(managedFrog.isManaged())
    // Work with the managed object ...
}

Criar um Objeto Embarcado

Para criar uma nova instância EmbeddedRealmObject, atribua uma instância de um Tipo de objeto de Realm incorporado à propriedade de um objeto principal. Isso pode ser em um relacionamento um-para-um, um-para-muitos ou inversa, dependendo de como você definiu o objeto incorporado dentro do Tipo de objeto de Realm pai. Para obter mais informações, consulte Definir um objeto incorporado.

Objeto incorporado têm propriedade estrita com seu objeto pai. After you create the embedded object, you cannot reassign it to a different parent object or share it between multiple parent objects.

No exemplo a seguir, instanciamos um novo objeto Contact com um Address incorporado, que contém um objeto Contact e um objeto Country incorporado:

realm.write {
    // Instantiate a parent object with one embedded address
    val contact = Contact().apply {
        name = "Kermit"
        address = EmbeddedAddress().apply {
            propertyOwner = Contact().apply { name = "Mr. Frog" }
            street = "123 Pond St"
            country = EmbeddedCountry().apply { name = "United States" }
        }
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(contact)
}

Também instanciamos um novo objeto Business com uma lista de objetos Address incorporados, que também contêm objetos Contact e objetos Country incorporados:

realm.write {
    // Instantiate a parent object with multiple embedded addresses
    val localOffice = EmbeddedAddress().apply {
        propertyOwner = Contact().apply { name = "Michigan J. Frog" }
        street = "456 Lily Pad Ln"
        country = EmbeddedCountry().apply { name = "United States" }
    }
    val remoteOffice = EmbeddedAddress().apply {
        propertyOwner = Contact().apply { name = "Mr. Toad" }
        street = "789 Leaping Frog Ave"
        country = EmbeddedCountry().apply { name = "Ireland" }
    }
    val business = Business().apply {
        name = "Big Frog Corp."
        addresses = realmListOf(localOffice, remoteOffice)
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(business)
}

Criar um objeto assimétrico

Ao contrário de outros Objeto de Realm, você não usa o método copyToRealm() para criá-lo. Isso ocorre porque objeto assimétricos são somente para gravação: eles não são persistentes no Realm. Em vez disso, você usa um método de extensão insert() especial para inseri-lo no Realm.

Para criar uma nova instância do AsymmetricRealmObject , instancie um novo objeto de um tipo de objeto assimétrico utilizando insert().

No exemplo a seguir, instanciamos um novo objeto WeatherSensor e o passamos para insert() dentro de uma transação de escrita:

// Open a write transaction
realm.write {
    // Create a new asymmetric object
    val weatherSensor = WeatherSensor().apply {
        deviceId = "WX1278UIT"
        temperatureInFarenheit = 6.7F
        barometricPressureInHg = 29.65F
        windSpeedInMph = 2
    }
    // Insert the object into the realm with the insert() extension method
    insert(weatherSensor)
// WeatherSensor object is inserted into the realm, then synced to the
// App Services backend. You CANNOT access the object locally because it's
// deleted from the local realm after sync is complete.
}

Uma vez inserido, o objeto assimétrico é sincronizado com o backend do App Services e com o banco de dados do Atlas vinculado. Você não pode acessar os dados gerenciados localmente, adicioná-los ou removê-los de um realm ou consultá-los. Para obter informações sobre como usar objetos assimétricos em seu aplicativo, consulte Fluxo de dados para o Atlas - Kotlin SDK.

Criar uma propriedade RealmInstant (Carimbo de data/hora)

Para criar uma nova instância de objeto com uma propriedade RealmInstant , instancie um objeto e passe um valor inicial para a propriedade RealmInstant usando:

• RealmInstant.from(): os epochSeconds e nanossegundos desde a época Unix

• RealmInstant.low(): os epochSeconds e nanossegundos desde a época do Unix até agora

Para obter mais informações sobre o tipo RealmInstant , consulte RealmInstant (Carimbo de data/hora).

No exemplo a seguir, instanciamos um novo objeto Frog com uma propriedade birthdate e passamos um valor inicial para RealmInstant.from():

realm.write {
    // Instantiate a new unmanaged Frog object with a RealmInstant property
    val frog = Frog().apply {
        name = "Kermit"
        // Set an initial value with RealmInstant.from() or RealmInstant.now()
        birthdate = RealmInstant.from(1_577_996_800, 0)
    }
    // Copy the object to the realm to return a managed instance
    copyToRealm(frog)
}

Criar uma propriedade MutableRealmInt (Contador)

Para criar uma nova instância de objeto com uma propriedade MutableRealmInt , instancie um objeto e passe um valor inicial para a propriedade MutableRealmInt usando MutableRealmInt.create(). Para mais informações sobre o tipo MutableRealmInt , consulte MutableRealmInt (Contador).

No exemplo a seguir, instanciamos um novo objeto Frog com uma propriedade fliesEaten e passamos um valor inicial para MutableRealmInt.create():

realm.write {
    // Instantiate a new unmanaged Frog object with a MutableRealmInt property
    val frog = Frog().apply {
        name = "Michigan J. Frog"
        // Set an initial value with MutableRealmInt.create()
        fliesEaten = MutableRealmInt.create(200)
    }
    // Copy the object to the realm to return a managed instance
    copyToRealm(frog)
}

Criar uma propriedade RealmAny (Misto)

Para criar uma nova instância de objeto com uma propriedade polimórfica RealmAny , instancie um objeto e passe um valor inicial de um tipo suportado para a propriedade RealmAny usando RealmAny.create(). Para obter uma lista dos tipos de valor que o RealmAny pode conter, consulte RealmQualquer (Misto).

No exemplo a seguir, instanciamos um novo Frog objeto com uma favoriteThings lista do RealmAny tipo e passamos os valores iniciais para RealmAny.create():

realm.write {
    // Instantiate a new unmanaged Frog object with a RealmAny property
    val frog = Frog().apply {
        name = "Kermit"
        // Set initial values with RealmAny.create()
        favoriteThings = realmListOf(
            RealmAny.create(42),
            RealmAny.create("rainbows"),
            RealmAny.create(Frog().apply {
                name = "Kermit Jr."
            })
        )
    }
    // Copy the object to the realm to return a managed instance
    copyToRealm(frog)
}

Após criar o objeto, você deve conhecer o tipo de valor armazenado para trabalhar com a propriedade RealmAny . Para saber como atualizar as propriedades do RealmAny após criar o objeto, consulte Atualizar uma propriedade RealmAny (Misto).

Crie um RealmList

Para criar uma nova instância de objeto com uma propriedade RealmList , instancie um objeto e passe quaisquer valores de um tipo suportado para a propriedade RealmList . Para obter uma lista dos tipos de valor que o RealmList pode conter, consulte RealmList.

Você pode instanciar uma lista não gerenciada com realmListOf() ou passar elementos para a lista usando list.add(), list.addAll() ou list.set(). A lista não é gerenciada até que você a copie para o Realm.

No exemplo a seguir, instanciamos um novo objeto Frog com valores iniciais para várias propriedades RealmList :

realm.write {
    // Instantiate a new unmanaged Frog object with a RealmList property
    val frog = Frog().apply {
        name = "Kermit"
        // Set values for each unmanaged list
        favoritePonds.addAll(realmListOf(
            Pond().apply { name = "Picnic Pond" },
            Pond().apply { name = "Big Pond" }
        ))
        favoriteForests.add(EmbeddedForest().apply { name = "Hundred Acre Wood" })
        favoriteWeather = realmListOf("rain", "snow")
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(frog)
}

Criar uma propriedade RealmSet

Para criar uma nova instância de objeto com uma propriedade RealmSet , instancie um objeto e passe quaisquer valores de um tipo compatível para a propriedade RealmSet . Para uma lista de tipos válidos que o RealmSet pode conter, consulte RealmSet.

Você pode instanciar um conjunto não gerenciado com realmSetOf() ou passar elementos para o conjunto usando set.add() ou set.addAll(). O conjunto não será gerenciado até que você o copie para o Realm.

No exemplo a seguir, instanciamos um novo objeto Frog com valores iniciais para favoriteSnacks e propriedades do conjunto favoriteWeather :

realm.write {
    // Instantiate a new unmanaged Frog object with RealmSet properties
    val frog = Frog().apply {
        name = "Kermit"
        // Set initial values to each unmanaged set
        favoriteSnacks.addAll(setOf(
            Snack().apply { name = "flies" },
            Snack().apply { name = "crickets" },
            Snack().apply { name = "worms" }
        ))
        favoriteWeather.add("rain")
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(frog)
}

Criar uma propriedade de dicionário

Para criar uma nova instância de objeto com uma propriedade RealmDictionary , instancie um objeto e passe quaisquer pares de chave-valor de um tipo suportado para a propriedade RealmDictionary . RealmDictionary só aceita uma chave String , mas os valores podem ser tipos não string. Para uma lista de tipos válidos, consulte RealmMap/RealmDictionary.

Você pode instanciar um dicionário não gerenciado com realmDictionaryOf() ou realmDictionaryEntryOf(). Ou você pode passar valores-chave usando put() ou putAll(). O dicionário não será gerenciado até que você o copie para o Realm.

No exemplo a seguir, instanciamos um novo objeto Frog com valores-chave iniciais para várias propriedades do dicionário:

realm.write {
    val frog = Frog().apply {
        name = "Kermit"
        // Set initial key-values to each unmanaged dictionary
        favoriteFriendsByPond = realmDictionaryOf(
            "Picnic Pond" to Frog().apply { name = "Froggy Jay" },
            "Big Pond" to Frog().apply { name = "Mr. Toad" }
        )
        favoriteTreesInForest["Maple"] = EmbeddedForest().apply {
            name = "Hundred Acre Wood"
        }
        favoritePondsByForest.putAll(
            mapOf(
                "Silver Pond" to "Big Forest",
                "Big Lake" to "Elm Wood",
                "Trout Pond" to "Sunny Wood"
            )
        )
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(frog)
}

O Realm não permite o uso de . ou $ caracteres em chaves de mapa. Você pode usar a codificação e a decodificação percentual para armazenar uma chave de mapa que contenha um desses caracteres não permitidos.

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

Crie um relacionamento para um

Para criar uma nova instância de objeto com uma propriedade de relacionamento entre si, instancie ambos os objetos e passe o objeto referenciado para a propriedade de relacionamento.

No exemplo a seguir, instanciamos um novo objeto Frog com uma propriedade favoritePond que referencia um objeto Pond e uma propriedade bestFriend que referencia outro objeto Frog :

realm.write {
    // Instantiate a new unmanaged Frog object with to-one
    // relationship with a Realm object
    val frog = Frog().apply {
        name = "Kermit"
        age = 12
        favoritePond = Pond().apply { name = "Picnic Pond" }
        bestFriend = Frog().apply { name = "Froggy Jay" }
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(frog)
}

Crie um relacionamento para muitos

Para criar uma nova instância de objeto com uma propriedade de relacionamento para muitos , instancie todos os objeto e passe quaisquer objeto referenciados para a propriedade de collection de relacionamento.

No exemplo seguinte, instanciamos um novo objeto Forest com uma propriedade frogsThatLiveHere que referencia um conjunto de objetos Frog e uma propriedade nearByPonds que referencia uma lista de objetos Pond :

realm.write {
    // Instantiate a new unmanaged Forest object with to-many
    // relationship with multiple Realm objects
    val forest = Forest().apply {
        name = "Froggy Forest"
        frogsThatLiveHere = realmSetOf(
            Frog().apply { name = "Kermit" },
            Frog().apply { name = "Froggy Jay" }
        )
        nearbyPonds = realmListOf(
            Pond().apply { name = "Small Picnic Pond" },
            Pond().apply { name = "Big Pond" }
        )
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(forest)
}

Crie um relacionamento inverso

Para criar uma nova instância de objeto com uma propriedade de relacionamento inversa, instancie o objeto pai e passe qualquer objeto filho referenciado para a propriedade de collection de backlink.

No exemplo a seguir, instanciamos um novo objeto User com uma propriedade backlink posts que faz referência a uma lista de objeto Post :

realm.write {
    // Instantiate a new unmanaged User object with to-many
    // relationship with multiple Realm objects
    val post1 = Post().apply {
        title = "Forest Life"
    }
    val post2 = Post().apply {
        title = "Top Ponds of the Year!"
    }
    val user = User().apply {
        name = "Kermit"
        posts = realmListOf(post1, post2)
    }
    // Copy all objects to the realm to return managed instances
    copyToRealm(user)
}

After you create the object, you can access the backlinks collection property to get the child objects, but you cannot directly modify the backlink itself. Para obter mais informações, consulte Atualizar um relacionamento inverso.