Modelar dados com Device Sync - Kotlin SDK

Gerar um esquema a partir do aplicativo do cliente

Se você estiver desenvolvendo uma nova aplicação cliente, é provável que queira iterar no Modelo de dados Realm no aplicação cliente. Depois de definir um modelo de objeto diretamente no código do aplicativo cliente, você pode ativar o modo de desenvolvimento no App Services para gerar um esquema correspondente do App Services automaticamente.

O modo de desenvolvimento é uma configuração que permite ao Device Sync inferir e atualizar esquemas com base em modelos de dados do lado do cliente quando você sincroniza dados do cliente. Para obter mais informações, consulte Modo de desenvolvimento na documentação do App Services.

Gerar um esquema com dados Atlas existentes

Se você estiver desenvolvendo um aplicação cliente que funcione com dados que já existem no Atlas, poderá gerar um esquema a partir desses dados e, em seguida, gerar modelos de objeto do SDK para usar em seu aplicativo cliente Kotlin . Para saber mais, consulte Sincronizar dados no Atlas com um aplicativo de cliente na documentação do App Services.

Mapear relacionamentos para um

Um relacionamento para um mapeia uma propriedade para uma única instância de outro Objeto de Realm. Relacionamento um-para-um devem ser opcionais. Para obter mais informações sobre como os relacionamentos um-para-um são definidos no Kotlin SDK, consulte Definir uma propriedade de relacionamento para um.

Usando os objetos no exemplo acima, considere um caso em que um Frog pode ter um pool favorito. Podemos adicionar uma propriedade favoritePond ao nosso modelo Frog que é um link opcional para um objeto Pond .

class Frog : RealmObject {
    @PrimaryKey
    var _id: ObjectId = ObjectId()
    var name: String = ""
    var age: Int? = null
    // To-one relationship (MUST be optional)
    var favoritePond: Pond? = null
}

No esquema do App Services, vemos a nova propriedade ser convertida em um campo favoritePond:

• O campo não está na array required porque é uma propriedade opcional.

• Seu tipo é um objectId vinculado a um objeto Pond específico na coleção Pond separada. Isso ocorre porque definimos a chave primária em nosso modelo Pond como objectId.

O esquema Pond não muda. Como este é um relacionamento para um, é um relacionamento unidirecional; o Pond não tem relacionamento com Frog.

{
  "title": "Frog",
  "type": "object",
  "required": [
    "_id",
    "name"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "age": {
      "bsonType": "long"
    },
    "favoritePond": {
      "bsonType": "objectId"
    },
    "name": {
      "bsonType": "string"
    }
  }
}

Relacionamento com muitos

Um relacionamento para muitos mapeia uma propriedade para zero ou mais instâncias de outro Objeto de Realm. Para obter mais informações sobre como os relacionamentos para muitos são definidos no Kotlin SDK, consulte Definir uma propriedade de relacionamento para muitos.

Considere outro caso em que um Frog pode ter muitos pools favoritos em vez de apenas um. Adicionamos uma propriedade favoritePonds ao nosso modelo Frog que é uma lista de objetos Pond . Se a rã não tiver lagunas favoritas, esta é uma lista vazia. À medida que a rã obtém suas poás favoritas, podemos criar novos objetos Pond e anexá-los à lista favoritePonds da rã.

class Frog : RealmObject {
    @PrimaryKey
    var _id: ObjectId = ObjectId()
    var name: String = ""
    var age: Int? = null
    // To-many relationship (can have many ponds)
    var favoritePonds: RealmList<Pond> = realmListOf()
}

No esquema do App Services, vemos a nova propriedade ser convertida em um campo favoritePonds que contém todos os objetos Pond relacionados ao objeto Frog :

• O campo não está na array required porque é uma propriedade opcional.

• O tipo deste campo é uma array do tipo objectId. Isso ocorre porque definimos a chave primária em nosso modelo Pond como um objectId.

Novamente, que o esquema Pond não muda porque o Pond não tem relacionamento com Frog.

{
  "title": "Frog",
  "type": "object",
  "required": [
    "_id",
    "name"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "age": {
      "bsonType": "long"
    },
    "favoritePonds": {
      "bsonType": "array",
      "items": {
        "bsonType": "objectId"
      }
    },
    "name": {
      "bsonType": "string"
    }
  }
}

Relacionamento inverso

Um relacionamento inverso vincula um objeto a qualquer outro objeto que se refira a ele em um relacionamento definido como "um" ou "muitos" chamado de backlink. Para obter mais informações sobre como os relacionamentos inversos são definidos no Kotlin SDK, consulte Definir um relacionamento inverso.

Os esquemas do App Services não oferecem suporte a relacionamentos inversos. Isso ocorre porque o relacionamento inverso representa um relacionamento implícito no Realm que é atualizado automaticamente quando o backlink é modificado. Isso significa que você não pode definir diretamente o valor de um relacionamento inverso, e o relacionamento não existe no Atlas. Em vez disso, o Realm deriva e atualiza esses relacionamento para você na aplicação cliente com base em seu modelo de objetos do Realm.

Considere um caso em que o objeto Pond tem um relacionamento inverso ao objeto Frog .

class Pond : RealmObject {
    @PrimaryKey
    var _id: ObjectId = ObjectId()
    var name: String = ""
    // Backlink to the `Frog` that has this `Pond` as its favorite
    val frog: RealmResults<Frog> by backlinks(Frog::favoritePonds)
}
class Frog : RealmObject {
    @PrimaryKey
    var _id: ObjectId = ObjectId()
    var name: String = ""
    var age: Int? = null
    // To-many relationship (can have many ponds)
    var favoritePonds: RealmList<Pond> = realmListOf()
}

No esquema do App Services, vemos que o Frog tem o relacionamento para-muitos com o Pond por meio da propriedade favoritePonds . No entanto, a propriedade frog que representa o relacionamento inverso para um Frog do nosso modelo Pond não está presente. Isso ocorre porque o relacionamento inverso não pode ser explicitamente definido no Atlas. No entanto, o Realm o atualizará automaticamente sempre que você adicionar ou remover um objeto do relacionamento.

// `Pond` schema in App Services DOES NOT contain the
// `frog` inverse relationship property
{
  "title": "Pond",
  "type": "object",
  "required": [
    "_id",
    "name"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "name": {
      "bsonType": "string"
    }
  }
}
{
  "title": "Frog",
  "type": "object",
  "required": [
    "_id",
    "name"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "age": {
      "bsonType": "long"
    },
    "favoritePonds": {
      "bsonType": "array",
      "items": {
        "bsonType": "objectId"
      }
    },
    "name": {
      "bsonType": "string"
    }
  }
}

Objetos embarcados

Objeto incorporado representam dados aninhados dentro de um único objeto pai específico. Você pode referenciar um objeto incorporado Tipo de objeto de Realm a partir dos Tipo de objeto de Realm principais da mesma forma que definiria um relacionamento. Para obter mais informações sobre como os objetos incorporados são definidos no Kotlin SDK, consulte Definir um objeto incorporado.

No entanto, ao contrário dos objeto de Realm, o objeto incorporado não são armazenados em sua própria collection no Atlas. Em vez disso, eles são armazenados como parte do documento do objeto pai e não são acessíveis fora do objeto pai.

No exemplo a seguir, temos um objeto Frog com uma propriedade favoritePond que referencia um único objeto Pond incorporado e um objeto Forest com uma propriedade de relacionamento forestPonds que referencia uma lista de muitos objetos Pond incorporados :

class Frog : RealmObject {
    @PrimaryKey
    var _id: ObjectId = ObjectId()
    var name: String = ""
    var age: Int? = null
    // Embed a single object (MUST be optional)
    var favoritePond: EmbeddedPond? = null
}
class Forest : RealmObject {
    @PrimaryKey
    var _id: ObjectId = ObjectId()
    var name: String = ""
    // Embed multiple objects (can have many ponds)
    var forestPonds: RealmList<EmbeddedPond> = realmListOf()
}
class EmbeddedPond : EmbeddedRealmObject {
    var name: String? = null
}

No esquema do App Services, vemos o mapa de objetos incorporados para documentos em cada tipo principal:

{
  "title": "Frog",
  "type": "object",
  "required": [
    "_id",
    "name"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "age": {
      "bsonType": "long"
    },
    "favoritePond": {
      "title": "EmbeddedPond",
      "type": "object",
      "required": [],
      "properties": {
        "name": {
          "bsonType": "string"
        }
      }
    },
    "name": {
      "bsonType": "string"
    }
  }
}
{
  "title": "Forest",
  "type": "object",
  "required": [
    "_id",
    "name"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "forestPonds": {
      "bsonType": "array",
      "items": {
        "title": "EmbeddedPond",
        "type": "object",
        "required": [],
        "properties": {
          "name": {
            "bsonType": "string"
          }
        }
      }
    },
    "name": {
      "bsonType": "string"
    }
  }
}

Tipos de Kotlin

A tabela a seguir lista os tipos de dados Kotlin com suporte e exemplos de como as propriedades declaradas são mapeadas entre um esquema do Realm e um esquema do App Services.

Para obter mais informações sobre os tipos de dados Kotlin suportados pelo Kotlin SDK e como defini-los em seu Modelo de dados Realm, consulte Tipos de dados do Kotlin.

var stringReq: String = ""

"stringReq": {
  "bsonType": "string"
}

var byteReq: Byte = 0

"byteReq": {
  "bsonType": "long"
}

var shortReq: Short = 0

"shortReq": {
  "bsonType": "long"
}

var intReq: Int = 0

"intReq": {
  "bsonType": "long"
}

var longReq: Long = 0L

"longReq": {
  "bsonType": "long"
}

var floatReq: Float = 0.0f

"floatReq": {
  "bsonType": "float"
}

var doubleReq: Double = 0.0

"doubleReq": {
  "bsonType": "double"
}

var boolReq: Boolean = false

"boolReq": {
  "bsonType": "bool"
}

var charReq: Char = 'a'

"charReq": {
  "bsonType": "long"
}

Tipos de JSON

A tabela a seguir lista os tipos de dados BSON do MongoDB suportados e exemplos de como as propriedades declaradas são mapeadas entre um esquema do Realm e um esquema do App Services.

Para obter mais informações sobre os tipos de dados BSON do MongoDB suportados pelo Kotlin SDK e como defini-los em seu Modelo de dados Realm, consulte Tipos de dados do Kotlin.

var objectIdReq: ObjectId = ObjectId()

"objectIdReq": {
  "bsonType": "objectId"
}

var decimal128Req: Decimal128 = Decimal128("123.456")

"decimal128Req": {
  "bsonType": "decimal"
}

Tipos de Realm

A tabela a seguir lista os tipos de dados específicos do Realm com suporte e exemplos de como as propriedades declaradas são mapeadas entre um esquema do Realm e um esquema do App Services.

Para obter mais informações sobre os tipos de dados específicos do domínio suportados pelo Kotlin SDK e como defini-los em seu Modelo de dados Realm, consulte Tipos de dados do Kotlin.

var uuidReq: RealmUUID = RealmUUID.random()

"uuidReq": {
  "bsonType": "uuid"
}

var realmInstantReq: RealmInstant = RealmInstant.now()

"realmInstantReq": {
  "bsonType": "date"
}

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

"realmAnyOpt": {
  "bsonType": "mixed"
}

var mutableRealmIntReq: MutableRealmInt = MutableRealmInt.create(0)

"mutableRealmIntReq": {
  "bsonType": "long"
}

var listReq: RealmList<CustomObjectType> = realmListOf()

"listReq": {
  "bsonType": "array",
  "items": {
    "bsonType": "uuid"
  }
}

var setReq: RealmSet<String> = realmSetOf()

"setReq": {
  "bsonType": "array",
  "uniqueItems": true,
  "items": {
    "bsonType": "string"
  }
}

var dictionaryReq: RealmDictionary<String> = realmDictionaryOf()

"dictionaryReq": {
  "bsonType": "object",
  "additionalProperties": {
    "bsonType": "string"
  }
}

var realmObjectPropertyOpt: CustomObjectType? = null

"realmObjectPropertyOpt": {
  "bsonType": "<PRIMARY_KEY_TYPE>"
}

var embeddedProperty: EmbeddedObjectType? = null

"embeddedProperty": {
  "title": "EmbeddedObjectType",
  "type": "object",
  "required": [],
  "properties": {
    "name": {
      "bsonType": "string"
    }
  }
}