Datos del modelo con sincronización de dispositivos - SDK de Kotlin

Generar un esquema desde la aplicación cliente

Si está desarrollando una nueva aplicación cliente, probablemente desee iterar sobre el modelo de datos de la aplicación. Después de definir un modelo de objetos directamente en el código de la aplicación, puede habilitar el modo de desarrollo en App Services para generar automáticamente un esquema de App Services compatible.

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.

Generar un esquema con datos Atlas existentes

Si está desarrollando una aplicación cliente que trabaja con datos ya existentes en Atlas, puede generar un esquema a partir de esos datos y, a continuación, generar modelos de objetos del SDK para usarlos en su aplicación cliente Kotlin. Para obtener más información, consulte Sincronizar datos en Atlas con una aplicación cliente en la documentación de App Services.

Relaciones de mapa a uno

Una relación de uno a uno asigna una propiedad a una sola instancia de otro objeto Realm. Las relaciones de uno a uno deben ser opcionales. Para obtener más información sobre cómo se definen las relaciones de uno a uno en el SDK de Kotlin, consulte Definir una propiedad de relación de 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
}

En el esquema de App Services, vemos que la nueva propiedad se traduce en un campo favoritePond:

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

• Su tipo es objectId y enlaza a un objeto Pond específico en la colección Pond independiente. Esto se debe a que definimos la clave principal en nuestro modelo Pond como 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 varios 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 de varios en el SDK de Kotlin, consulte Definir una propiedad de relación de varios.

Consideremos otro caso donde un Frog puede tener varios estanques favoritos en lugar de solo uno. Añadimos una propiedad favoritePonds a nuestro modelo Frog, que es una lista de Pond objetos. Si la rana no tiene estanques favoritos, esta lista está vacía. A medida que la rana obtiene estanques favoritos, podemos crear nuevos Pond objetos y añadirlos a la lista favoritePonds de la rana.

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

En el esquema de App Services, vemos que la nueva propiedad se traduce en un campo favoritePonds que contiene todos los objetos Pond relacionados con el objeto Frog:

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

• El tipo de este campo es una matriz de tipo objectId. Esto se debe a que definimos la clave principal en nuestro modelo Pond como objectId.

Nuevamente, el esquema Pond no cambia porque Pond no tiene relación con 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 cualquier otro objeto que haga referencia a él mediante una relación definida de uno a muchos, denominada vínculo de retroceso. Para obtener más información sobre cómo se definen las relaciones inversas en el SDK de Kotlin, consulte Definir una relación inversa.

Los esquemas de App Services no admiten relaciones inversas. Esto se debe a que representan una relación implícita en Realm que se actualiza automáticamente al modificar el vínculo de retroceso. Esto significa que no se puede establecer directamente el valor de una relación inversa, y esta no existe en Atlas. En su lugar, Realm deriva y actualiza dichas relaciones automáticamente en la aplicación cliente, basándose en el modelo de objetos de Realm.

Consideremos un caso donde el objeto Pond tiene una relación inversa con el 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()
}

En el esquema de App Services, vemos que tiene una Frog relación de varios con Pond mediante la favoritePonds propiedad. Sin embargo, la frog propiedad, que representa la relación inversa con Frog de nuestro Pond modelo,no está presente. Esto se debe a que la relación inversa no se puede definir explícitamente en Atlas. No obstante, Realm la actualizará automáticamente al agregar o eliminar un objeto de la relación.

// `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 incrustados

Los objetos incrustados representan datos anidados dentro de un único objeto principal específico. Puedes hacer referencia a un tipo de objeto incrustado desde los tipos de objeto principal de la misma forma que definirías una relación. Para más información sobre cómo se definen los objetos incrustados en el SDK de Kotlin, consulta Definir un objeto incrustado.

Sin embargo, a diferencia de los objetos Realm normales, los objetos incrustados no se almacenan en su propia colección en Atlas. Se almacenan como parte del documento del objeto principal y no son accesibles fuera de él.

En el siguiente ejemplo, tenemos un objeto Frog con una propiedad favoritePond que hace referencia a un único objeto Pond incrustado y un objeto Forest con una propiedad de relación forestPonds que hace referencia a una lista de muchos objetos Pond incrustados:

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

Tipos de Kotlin

En la siguiente tabla se enumeran los tipos de datos de Kotlin 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 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"
}

Tipos de reino

En la siguiente tabla se enumeran los tipos de datos específicos de Realm admitidos y ejemplos de cómo las propiedades declaradas se asignan entre un esquema de Realm y un esquema de App 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"
    }
  }
}