/ /

Datos del modelo

Docs Home

/ /

Kit de desarrollo de software de Swift

Datos del modelo

Docs Home

MongoDB Atlas

SDK de dispositivos Atlas

Kit de desarrollo de software de Swift

Datos del modelo

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

Los SDK de dispositivos Atlas están obsoletos. Consulte Página de desuso para más detalles.

Modelos de objetos de reino

Para definir un objeto Realm, derive una clase de Objeto. Los modelos que define se asignan a su propia colección en MongoDB Atlas. En este ejemplo, ambos Dog y Person se asignarían a colecciones separadas en MongoDB Atlas.

class Dog: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   @Persisted var age = 0
}
class Person: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
}

JSON Schema

Cuando se tiene un esquema correspondiente en Atlas App Services, Device Sync convierte automáticamente los tipos de datos de Realm Swift a BSON al sincronizarse con Atlas. Cuando el dispositivo cliente sincroniza los datos desde App Services mediante Device Sync, el SDK convierte BSON de nuevo en objetos Swift. Si se consultan estos objetos accediendo directamente a los datos de MongoDB Atlas en lugar de usar Device Sync para sincronizar los datos, se obtienen los tipos de datos BSON. MongoDB Data Access no se asigna automáticamente a los objetos Swift equivalentes.

Esquema de perro en los servicios de aplicaciones

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

Esquema de persona en App Services

{
  "title": "Person",
  "bsonType": "object",
  "required": [
    "_id"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "name": {
      "bsonType": "string"
    }
  }
}

Relaciones entre reinos

Relación de uno a uno

Usando los objetos del ejemplo anterior, considere un caso donde un Person puede tener un Dog. Podemos agregar una propiedad dog a nuestro modelo Person que sea un enlace opcional a un objeto Dog. Las relaciones de uno a uno deben ser opcionales.

class Dog: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   @Persisted var age = 0
}
class Person: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   // To-one relationship
   @Persisted var dog: Dog?
}

JSON Schema

En el esquema de App Services, vemos que la nueva propiedad se traduce en un campo dog. Este campo no está en la matriz required porque es una propiedad opcional. Su tipo es objectId, que vincula a un objeto Dog específico en la colección Dog independiente. El objectId es la clave principal del modelo Dog, por lo que es el campo que vincula los dos objetos.

Persona con relación de uno a uno con el perro

{
  "title": "Person",
  "bsonType": "object",
  "required": [
    "_id"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "dog": {
      "bsonType": "objectId"
    },
    "name": {
      "bsonType": "string"
    }
  }
}

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

Tip

Para obtener más información sobre las relaciones de uno a uno, consulte: Relación de uno a uno.

Relación de muchos

Usando los objetos del ejemplo anterior, considere un caso donde un Person puede tener muchos perros. Podemos agregar una propiedad dogs a nuestro modelo Person, que es una lista de Dog objetos. Si la persona no tiene perros, esta lista está vacía. A medida que la persona adquiere perros, podemos crear nuevos objetos de perro y añadirlos a la lista dogs de la persona.

class Dog: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   @Persisted var age = 0
}
class Person: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   // To-many relationship - a person can have many dogs
   @Persisted var dogs: List<Dog>
}

JSON Schema

En el esquema de App Services, vemos que la nueva propiedad se traduce en un campo dogs. El tipo de este campo es un array; los elementos del array son de tipo objectId. Esto se debe a que definimos la clave principal en nuestro modelo Dog como objectId. Este campo es un array con las claves principales de todos los objetos Dog relacionados con el objeto Person.

Persona con relación demasiado grande con el perro

{
  "title": "Person",
  "bsonType": "object",
  "required": [
    "_id"
  ],
  "properties": {
    "_id": {
      "bsonType": "objectId"
    },
    "name": {
      "bsonType": "string"
    },
    "dogs": {
      "bsonType": "array",
      "items": {
        "bsonType": "objectId"
      }
    }
  }
}

Tip

Para obtener más información sobre las relaciones de muchos, consulte: Relación de muchos.

Relación inversa

Utilizando los objetos en el ejemplo anterior, considere un caso donde el objeto Dog tiene una relación inversa con el objeto Person.

class Dog: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   @Persisted var age = 0
   // The backlink to the `Person` who has this `Dog`.
   @Persisted(originProperty: "dogs") var person: LinkingObjects<Person>
}
class Person: Object {
   @Persisted(primaryKey: true) var _id = ObjectId()
   @Persisted var name = ""
   // To-many relationship - a person can have many dogs
   @Persisted var dogs: List<Dog>
}

JSON Schema

En el esquema de App Services, observamos que la propiedad person, que representa la relación inversa con un Person de nuestro modelo Dog, no está presente. No se puede establecer directamente el valor de una relación inversa, y dicha relación no existe en Atlas. Sin embargo, Realm deriva y actualiza esas relaciones automáticamente en la aplicación cliente, basándose en el modelo de objetos de Realm.

Perro con relación inversa a la persona

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

Tip

Para obtener más información sobre las relaciones inversas, consulte: Relación inversa.

Modelos de objetos incrustados

Al definir un objeto incrustado con el SDK de Realm Swift, se deriva una clase de EmbeddedObject. Se puede hacer referencia a un tipo de objeto incrustado desde tipos de objeto padre de la misma manera que se define una relación:

class Person: Object {
    @Persisted(primaryKey: true) var id = 0
    @Persisted var name = ""
    // To-many relationship - a person can have many dogs
    @Persisted var dogs: List<Dog>
    // Inverse relationship - a person can be a member of many clubs
    @Persisted(originProperty: "members") var clubs: LinkingObjects<DogClub>
    // Embed a single object.
    // Embedded object properties must be marked optional.
    @Persisted var address: Address?
    convenience init(name: String, address: Address) {
        self.init()
        self.name = name
        self.address = address
    }
}
class DogClub: Object {
    @Persisted var name = ""
    @Persisted var members: List<Person>
    // DogClub has an array of regional office addresses.
    // These are embedded objects.
    @Persisted var regionalOfficeAddresses: List<Address>
    convenience init(name: String, addresses: [Address]) {
        self.init()
        self.name = name
        self.regionalOfficeAddresses.append(objectsIn: addresses)
    }
}
class Address: EmbeddedObject {
    @Persisted var street: String?
    @Persisted var city: String?
    @Persisted var country: String?
    @Persisted var postalCode: String?
}

JSON Schema

Los objetos incrustados se asignan a documentos incrustados en el esquema del tipo principal. Este comportamiento difiere del de los objetos Realm normales, que se asignan a su propia colección de MongoDB.

{
  "title": "Person",
  "bsonType": "object",
  "required": ["id"],
  "properties": {
    "id": { "bsonType": "int" },
    "name": { "bsonType": "string" },
    "dogs": {
      "bsonType": "array",
      "items": {
        "bsonType": "objectId"
      }
    },
    "address": {
      "title": "Address",
      "bsonType": "object",
      "properties": {
        "street": { "bsonType": "string" },
        "city": { "bsonType": "string" },
        "country": { "bsonType": "string" },
        "postalCode": { "bsonType": "string" }
      }
    }
  }
}

{
  "title": "DogClub",
  "bsonType": "object",
  "required": ["_id", "name", "addresses"],
  "properties": {
    "_id": "objectId",
    "name": { "bsonType": "string" },
    "members": {
      "bsonType": "array",
      "items": {
        "bsonType": "objectId"
      }
    },
    "addresses": {
      "bsonType": "array",
      "items": {
        "title": "Address",
        "bsonType": "object",
        "properties": {
          "street": { "bsonType": "string" },
          "city": { "bsonType": "string" },
          "country": { "bsonType": "string" },
          "postalCode": { "bsonType": "string" }
        }
      }
    }
  }
}

Crear modelos de objetos y esquemas

Para mapear entre modelos de objetos de SDK y datos BSON en Atlas, debe tener un esquema en Servicios de aplicación que coincida con su modelo de objeto de SDK. Existen varias formas de generar modelos de esquema y de objetos coincidentes:

Cree modelos de objetos en la aplicación cliente y genere esquemas de App Services a partir de ellos.
Crea esquemas en App Services y genera modelos de objetos de Realm a partir de ellos.

Si está desarrollando una nueva aplicación cliente, probablemente desee iterar sobre el modelo de datos de la aplicación. Habilite el modo de desarrollo en App Services para que el backend infiera y actualice el esquema según los modelos de objetos de cliente. El modo de desarrollo no funciona con cambios importantes en el esquema, por lo que debe eliminar el esquema existente del servidor al realizar cambios importantes en el modelo de datos del SDK.

Si está desarrollando una aplicación cliente que trabaja con datos ya existentes en Atlas, puede generar un esquema a partir de esos datos. Posteriormente, puede generar modelos de objetos del SDK a partir del esquema del servidor.

Volver

Cambiar un modelo de objeto

CRUD