Model Data with Device Sync - Kotlin SDK

Generate a Schema from the Client App

If you are developing a new client application, you likely want to iterate on the data model in the client app. After you define an object model directly in your client app code, you can enable Development Mode in App Services to generate a matching App Services schema automatically.

Modo de desarrollo es una configuración que permite que Device Sync infiera y actualice esquemas a partir de modelos de datos del lado del cliente cuando sincronizas datos desde el cliente. Para obtener más información, consulta Modo de desarrollo en la documentación de App Services.

Generate a Schema with Existing Atlas Data

If you are developing a client application that works with data that already exists in Atlas, you can generate a schema from that data, and then generate SDK object models to use in your Kotlin client app. To learn more, refer to Sync Data in Atlas with a Client Application in the App Services documentation.

Mapear relaciones uno a uno

Una relación uno a uno (to-one relationship) asigna una propiedad a una sola instancia de otro objeto Realm. Las relaciones uno a uno deben ser opcionales. Para obtener más información sobre cómo se definen las relaciones uno a uno en el Kotlin SDK, consulta Definir una propiedad de relación uno a uno.

Usando los objetos del ejemplo anterior, considere un caso donde un Frog puede tener un estanque favorito. Podemos agregar una propiedad favoritePond a nuestro modelo Frog que sea un enlace opcional a un 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
}

In the App Services schema, we see the new property translates to a field favoritePond:

• El campo no está en la matriz required porque es una propiedad opcional.

• Su tipo es un objectId que enlaza a un objeto Pond específico en la colección Pond distinta. Esto se debe a que definimos la llave primaria en nuestro modelo de Pond como un objectId.

El esquema Pond no cambia. Al ser una relación de uno a uno, es unidireccional; Pond no tiene relación con Frog.

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

Relación de muchos

Una relación de muchos a muchos asigna una propiedad a cero o más instancias de otro objeto Realm. Para obtener más información sobre cómo se definen las relaciones muchos a muchos en Kotlin SDK, consulta Definir una Propiedad de Relación de Muchos.

Consider another case where a Frog can have many favorite ponds instead of only one. We add a favoritePonds property to our Frog model that is a list of Pond objects. If the frog has no favorite ponds, this is an empty list. As the frog gets favorite ponds, we can create new Pond objects and append them to the frog's favoritePonds list.

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()
}

In the App Services schema, we see the new property translates to a favoritePonds field that contains all of the Pond objects related to the Frog object:

• El campo no está en la matriz required porque es una propiedad opcional.

• The type of this field is an array of type objectId. This is because we defined the primary key on our Pond model as an objectId.

Again, that the Pond schema doesn't change because the Pond has no relationship back to Frog.

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

Relación inversa

Una relación inversa vincula un objeto con otros objetos que lo referencian en una relación definida uno-a-uno o uno-a-muchos denominada vínculo inverso. Para obtener más información sobre cómo se definen las relaciones inversas en Kotlin SDK, consulta Define una relación inversa.

App Services schemas do not support inverse relationships. This is because inverse relationship represent an implicit relationship in Realm that is automatically updated when the backlink is modified. This means that you cannot directly set the value of an inverse relationship, and the relationship does not exist in Atlas. Instead, Realm derives and updates those relationships for you in the client application based on your Realm object model.

Consider a case where the Pond object has an inverse relationship to the Frog object.

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()
}

In the App Services schema, we see the Frog has the to-many relationship to the Pond through the favoritePonds property. However, the frog property that represents the inverse relationship to a Frog from our Pond model is not present. This is because the inverse relationship cannot be explicitly defined in Atlas. However, Realm will update it automatically whenever you add or remove an object from the relationship.

// `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"
    }
  }
}

objeto incrustado

Embedded objects represent nested data inside of a single, specific parent object. You can reference an embedded object type from parent object types in the same way as you would define a relationship. For more information on how embedded objects are defined in Kotlin SDK, refer to Define an Embedded Object.

Sin embargo, a diferencia de los objetos Realm, los objetos incrustados no se almacenan en su propia colección en Atlas. En su lugar, se almacenan como parte del documento del objeto principal y no se puede acceder a ellas fuera del objeto principal.

In the following example, we have a Frog object with a favoritePond property that references a single embedded Pond object and a Forest object with forestPonds relationship property that references a list of many embedded Pond objects:

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
}

En el esquema de Servicios de aplicación, se observa que los objetos incrustados se mapean en documentos de 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"
    }
  }
}

Kotlin Types

La siguiente tabla enumera los tipos de dato de Kotlin admitidos y ejemplos de cómo las propiedades declaradas se asignan entre un esquema de Realm y un esquema de aplicación Services.

Para obtener más información sobre los tipos de datos de Kotlin compatibles con el SDK de Kotlin y cómo definirlos en su modelo de datos, consulte Tipos de datos de 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"
}

BSON Types

En la siguiente tabla se enumeran los tipos de datos BSON de MongoDB admitidos y ejemplos de cómo las propiedades declaradas se asignan entre un esquema de Realm y un esquema de App Services.

Para obtener más información sobre los tipos de datos BSON de MongoDB compatibles con el SDK de Kotlin y cómo definirlos en su modelo de datos, consulte Tipos de datos de Kotlin.

var objectIdReq: ObjectId = ObjectId()

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

var decimal128Req: Decimal128 = Decimal128("123.456")

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

Realm Types

La siguiente tabla enumera los tipos de datos específicos de Realm compatibles y ejemplos de cómo las propiedades declaradas se asignan entre un esquema de Realm y un esquema de aplicación Services.

Para obtener información sobre los tipos de datos específicos de Realm que admite el SDK de Kotlin y cómo definirlos en su modelo de datos, consulte Tipos de datos de 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"
    }
  }
}