/ /

/ /

SDK de dispositivos Atlas

SDK de React Native

Datos del modelo

Cambiar un modelo de objeto - SDK de React Native

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

Nota

Modificar las propiedades del esquema de un dominio sincronizado

La siguiente página muestra cómo modificar las propiedades del esquema de un dominio local. Aprenda a... modificar las propiedades del esquema de un reino sincronizado.

Al actualizar el esquema de su objeto, debe incrementar la versión del esquema y realizar una migración.

Si tu actualización de esquema añade propiedades opcionales o remueve propiedades, Realm puede realizar la migración automáticamente. Solo necesitas incrementar el schemaVersion.

Para actualizaciones de esquema más complejas, también debe especificar manualmente la lógica de migración en una función migration. Esto podría incluir cambios como:

Agregar propiedades obligatorias que deben completarse con valores predeterminados
Combinando campos
Cambiar el nombre de un campo
Cambiar el tipo de un campo
Conversión de un objeto a un objeto incrustado

Tip

Evitar la migración durante el desarrollo

Al desarrollar o depurar su aplicación, puede que prefiera eliminar el dominio en lugar de migrarlo. Utilice la propiedad BaseConfiguration.deleteRealmIfMigrationNeeded para eliminar la base de datos automáticamente cuando una discrepancia de esquema requiera una migración.

Nunca lance una aplicación a producción con esta propiedad establecida en true.

Versión del esquema

Una versión de esquema identifica el estado de un esquema de dominio en un momento dado. Realm rastrea la versión de esquema de cada dominio y la utiliza para asignar los objetos de cada dominio al esquema correcto.

Las versiones del esquema son números enteros ascendentes que se pueden incluir en la configuración del dominio. Si una aplicación cliente no especifica un número de versión, el dominio toma la versión 0 por defecto.

Importante

Incrementar versiones monótonamente

Las migraciones deben actualizar un dominio a una versión de esquema superior. El dominio genera un error si una aplicación cliente usa una versión de esquema anterior a la actual del dominio o si la versión de esquema especificada coincide con la actual del dominio, pero incluye un esquema diferente.

Migraciones

Una migración es una función que actualiza un dominio y los objetos que contiene de una versión de esquema a una versión más reciente. Las migraciones permiten modificar los esquemas de objetos con el tiempo para incorporar nuevas funciones y refactorizaciones.

Al crear una configuración con una versión de esquema posterior a la versión actual del dominio, Realm ejecuta una función de migración definida por usted. Esta función tiene acceso al número de versión del dominio y actualiza incrementalmente los objetos del dominio para que se ajusten al nuevo esquema.

Realm migra automáticamente ciertos cambios, como propiedades nuevas y eliminadas, pero no establece automáticamente valores para las nuevas propiedades a menos que el esquema de objeto actualizado especifique un valor predeterminado. Puede definir lógica adicional en la función de migración para personalizar aún más los valores de las propiedades.

Agregar una propiedad

Para agregar una propiedad a un esquema, agregue la nueva propiedad a la clase del objeto y establezca un schemaVersion del objeto Configuration.

Ejemplo

Un Realm que use la versión de esquema 0, que es la por defecto, tendrá un tipo de objeto Realm Person con una propiedad firstName y lastName. Decides añadir una propiedad age a la clase Person.

Para migrar el dominio y adaptarlo al esquema Person actualizado, configure la versión del esquema del dominio en Configuration como 1. Finalmente, pase el objeto de configuración al método createRealmContext().

class Person extends Realm.Object {
  static schema = {
    name: 'Person',
    properties: {
      _id: 'string',
      firstName: 'string',
      lastName: 'string',
      // add a new property, 'age' to the schema
      age: 'int',
    },
  };
}
const config = {
  schema: [Person],
  // Increment the 'schemaVersion', since 'age' has been added to the schema.
  // The initial schemaVersion is 0.
  schemaVersion: 2,
};
// pass the configuration object with the updated 'schemaVersion' to
// createRealmContext()
const {RealmProvider} = createRealmContext(config);

class Person extends Realm.Object<Person> {
  _id!: string;
  firstName!: string;
  lastName!: string;
  age!: number;
  static schema: ObjectSchema = {
    name: 'Person',
    properties: {
      _id: 'string',
      firstName: 'string',
      lastName: 'string',
      // add a new property, 'age' to the schema
      age: 'int',
    },
  };
}
const config: Realm.Configuration = {
  schema: [Person],
  // Increment the 'schemaVersion', since 'age' has been added to the schema.
  // The initial schemaVersion is 0.
  schemaVersion: 2,
};
// pass the configuration object with the updated 'schemaVersion' to
// createRealmContext()
const {RealmProvider} = createRealmContext(config);

Eliminar una propiedad

Para eliminar una propiedad de un esquema, elimínela de la clase del objeto y establezca un valor en el schemaVersion objeto de configuración. Eliminar una propiedad no afecta a los objetos existentes.

Ejemplo

Un dominio que usa la versión de esquema 0 (la predeterminada) tiene un Person tipo de objeto con una lastName propiedad. Decides eliminar la propiedad del esquema.

Para migrar el dominio y que se ajuste al esquema Person actualizado, configure la versión del esquema del dominio como 1 en el objeto Configuration. Finalmente, pase el objeto de configuración al método createRealmContext().

class Person extends Realm.Object {
  static schema = {
    name: 'Person',
    properties: {
      _id: 'string',
      firstName: 'string',
      age: 'int',
    },
  };
}
const config = {
  schema: [Person],
  // Increment the 'schemaVersion', since 'lastName' has been removed from the schema.
  // The initial schemaVersion is 0.
  schemaVersion: 1,
};
// pass the configuration object with the updated 'schemaVersion' to createRealmContext()
const {RealmProvider} = createRealmContext(config);

class Person extends Realm.Object<Person> {
  _id!: string;
  firstName!: string;
  age!: number;
  static schema: ObjectSchema = {
    name: 'Person',
    properties: {
      _id: 'string',
      firstName: 'string',
      age: 'int',
    },
  };
}
const config: Realm.Configuration = {
  schema: [Person],
  // Increment the 'schemaVersion', since 'lastName' has been removed from the schema.
  // The initial schemaVersion is 0.
  schemaVersion: 1,
};
// pass the configuration object with the updated 'schemaVersion' to createRealmContext()
const {RealmProvider} = createRealmContext(config);

Cambiar el nombre de una propiedad

Para cambiar el nombre de una propiedad de objeto, cambie el nombre de la propiedad en el esquema del objeto y luego cree una configuración de reino con una versión de esquema incrementada y una función de migración que actualice los objetos existentes para usar el nuevo nombre de propiedad.

Las migraciones no permiten cambiar el nombre de una propiedad directamente. En su lugar, se puede crear una nueva propiedad con el nombre actualizado, copiar el valor de la propiedad anterior y, a continuación, eliminarla.

Ejemplo

Un dominio que usa la versión de esquema 0 (la predeterminada) tiene un Person tipo de objeto. El esquema original tenía firstName lastName campos y. Posteriormente, decide que la Person clase debe usar un fullName campo combinado y elimina firstName los lastName campos y.

Para migrar el dominio y adaptarlo al esquema Person actualizado, cree un objeto de configuración y establezca la versión del esquema del dominio en.1 Defina una función de migración que establezca el valor de según fullName firstName las lastName propiedades y existentes. Finalmente, pase el objeto de configuración al createRealmContext() método.

class Person extends Realm.Object {
  static schema = {
    name: 'Person',
    properties: {
      _id: 'string',
      // rename the 'firstName' and 'lastName' property, to 'fullName'
      // in the schema
      fullName: 'string',
      age: 'int',
    },
  };
}
const config = {
  schema: [Person],
  // Increment the 'schemaVersion', since 'fullName' has replaced
  // 'firstName' and 'lastName' in the schema.
  // The initial schemaVersion is 0.
  schemaVersion: 1,
  onMigration: (oldRealm, newRealm) => {
    // only apply this change if upgrading schemaVersion
    if (oldRealm.schemaVersion < 1) {
      const oldObjects = oldRealm.objects(Person);
      const newObjects = newRealm.objects(Person);
      // loop through all objects and set the fullName property in the
      // new schema
      for (const objectIndex in oldObjects) {
        const oldObject = oldObjects[objectIndex];
        const newObject = newObjects[objectIndex];
        newObject.fullName = `${oldObject.firstName} ${oldObject.lastName}`;
      }
    }
  },
};
// pass the configuration object with the updated 'schemaVersion' and
// 'migration' function to createRealmContext()
const {RealmProvider} = createRealmContext(config);

class Person extends Realm.Object<Person> {
  _id!: string;
  fullName!: string;
  age!: number;
  static schema: ObjectSchema = {
    name: 'Person',
    properties: {
      _id: 'string',
      // rename the 'firstName' and 'lastName' property, to 'fullName'
      // in the schema
      fullName: 'string',
      age: 'int',
    },
  };
}
class OldObjectModel extends Realm.Object<OldObjectModel> {
  _id!: string;
  firstName!: string;
  lastName!: string;
  age!: number;
  static schema: ObjectSchema = {
    name: 'Person',
    properties: {
      _id: 'string',
      firstName: 'string',
      lastName: 'string',
    },
  };
}
const config: Realm.Configuration = {
  schema: [Person],
  // Increment the 'schemaVersion', since 'fullName' has replaced
  // 'firstName' and 'lastName' in the schema.
  // The initial schemaVersion is 0.
  schemaVersion: 1,
  onMigration: (oldRealm: Realm, newRealm: Realm) => {
    // only apply this change if upgrading schemaVersion
    if (oldRealm.schemaVersion < 1) {
      const oldObjects: Realm.Results<OldObjectModel> =
        oldRealm.objects(OldObjectModel);
      const newObjects: Realm.Results<Person> = newRealm.objects(Person);
      // loop through all objects and set the fullName property in the
      // new schema
      for (const objectIndex in oldObjects) {
        const oldObject = oldObjects[objectIndex];
        const newObject = newObjects[objectIndex];
        newObject.fullName = `${oldObject.firstName} ${oldObject.lastName}`;
      }
    }
  },
};
// pass the configuration object with the updated 'schemaVersion' and
// 'migration' function to createRealmContext()
const {RealmProvider} = createRealmContext(config);

Importante

Realms sincronizados

Los dominios sincronizados solo admiten cambios continuos (también llamados aditivos) para garantizar que los clientes antiguos puedan sincronizarse con los nuevos. Dado que los cambios de nombre completos requieren la eliminación de la propiedad anterior, no es posible cambiar el nombre de una propiedad sincronizada sin reiniciar el cliente. En su lugar, considere agregar la propiedad renombrada sin eliminar la anterior. Como alternativa, use mapTo para almacenar datos con el nombre interno existente, pero permita que su código use un nombre diferente.

Modificar un tipo de propiedad

Para modificar el tipo de una propiedad,schemaVersion migration configure el tipo de propiedad del campo que desea modificar con el nuevo tipo de dato. A continuación, configure una función de devolución de llamada y una del objeto Configuration.

Nota

Los dominios sincronizados solo admiten cambios permanentes para garantizar que los clientes antiguos puedan sincronizarse con los nuevos. Esto significa que los dominios sincronizados no permiten modificar el tipo de propiedad de un esquema.

Ejemplo

Un dominio que usa la versión de esquema 0 (la predeterminada) tiene un Person tipo de objeto. El esquema original tenía un _id con un tipo de int propiedad. Posteriormente, decide que el Person campo de la clase _id debe ser de tipo ObjectId y actualiza el esquema.

Para migrar el dominio y adaptarlo al esquema Person actualizado, cree un objeto Configuration y establezca la versión del esquema del dominio en 1. Defina una función de migración para convertir el tipo entero a Object ID. Finalmente, pase el objeto de configuración al método createRealmContext().

class Person extends Realm.Object {
  static schema = {
    name: 'Person',
    properties: {
      // update the data type of '_id' to be 'objectId' within the schema
      _id: 'objectId',
      firstName: 'string',
      lastName: 'string',
    },
  };
}
const config = {
  schema: [Person],
  // Increment the 'schemaVersion', since the property type of '_id'
  // has been modified.
  // The initial schemaVersion is 0.
  schemaVersion: 1,
  onMigration: (oldRealm, newRealm) => {
    if (oldRealm.schemaVersion < 1) {
      const oldObjects = oldRealm.objects(Person);
      const newObjects = newRealm.objects(Person);
      // loop through all objects and set the _id property
      // in the new schema
      for (const objectIndex in oldObjects) {
        const oldObject = oldObjects[objectIndex];
        const newObject = newObjects[objectIndex];
        newObject._id = new Realm.BSON.ObjectId(oldObject._id);
      }
    }
  },
};
// Pass the configuration object with the updated
// 'schemaVersion' and 'migration' function to createRealmContext()
const {RealmProvider} = createRealmContext(config);

class Person extends Realm.Object<Person> {
  _id!: Realm.BSON.ObjectId;
  firstName!: string;
  lastName!: string;
  age!: number;
  static schema: ObjectSchema = {
    name: 'Person',
    properties: {
      // Update the data type of '_id' to be 'objectId' within the schema.
      _id: 'objectId',
      firstName: 'string',
      lastName: 'string',
    },
  };
}
// `OldObjectModel` is only used for type injection for `oldRealm`. It is
// not related to the `Person` object model.
interface OldObjectModel {
  _id: Realm.BSON.ObjectId;
  firstName: string;
  lastName: string;
  age: number;
}
const config: Realm.Configuration = {
  schema: [Person],
  // Increment the 'schemaVersion', since the property type of '_id'
  // has been modified.
  // The initial schemaVersion is 0.
  schemaVersion: 1,
  onMigration: (oldRealm: Realm, newRealm: Realm) => {
    if (oldRealm.schemaVersion < 1) {
      const oldObjects: Realm.Results<OldObjectModel> =
        oldRealm.objects(Person);
      const newObjects: Realm.Results<Person> = newRealm.objects(Person);
      // Loop through all objects and set the _id property
      // in the new schema.
      for (const objectIndex in oldObjects) {
        const oldObject = oldObjects[objectIndex];
        const newObject = newObjects[objectIndex];
        newObject._id = new Realm.BSON.ObjectId(oldObject._id);
      }
    }
  },
};
// Pass the configuration object with the updated
// 'schemaVersion' and 'migration' function to createRealmContext().
const {RealmProvider} = createRealmContext(config);

Volver

Relaciones y objetos incrustados

Tipos de datos