/ /

/ /

SDK de dispositivos Atlas

SDK de React Native

Datos del modelo

Definir un modelo de objeto de reino - SDK de React Native

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

Definir un tipo de objeto

Para definir un tipo de objeto Realm, cree una clase que extienda Realm.ObjectDefine los tipos name y properties en una propiedad estática llamada schema. El nombre del tipo debe ser único entre los tipos de objeto de un dominio.

class Book extends Realm.Object {
  static schema = {
    name: 'Book',
    properties: {
      name: {type: 'string', indexed: true},
      price: 'int?',
    },
  };
}

class Book extends Realm.Object<Book> {
  name!: string;
  price?: number;
  static schema: ObjectSchema = {
    name: 'Book',
    properties: {
      name: {type: 'string', indexed: true},
      price: 'int?',
    },
  };
}

Luego puedes pasar la clase en sí a la propiedad de esquema de la Objeto de configuración al abrir un reino.

Tipos de propiedad admitidos

Cada propiedad de un objeto Realm tiene un tipo de dato claramente definido. El tipo de una propiedad puede ser un tipo de dato primitivo o un tipo de objeto definido en el mismo reino. El tipo también especifica si la propiedad contiene un único valor o una lista de valores.

Para especificar que un campo contiene una lista de un tipo de valor primitivo, agregue [] al nombre del tipo.

Para obtener una lista de los tipos de propiedades admitidos, consulte Tipos de propiedad

Definir propiedades de objeto

Para definir una propiedad para un tipo de objeto Realm, crea un par clave-valor que represente el nombre y el tipo de dato de la propiedad en el campo properties.

El siguiente esquema define un tipo Car que tiene estas propiedades: _id make, model y miles.

Declarar una propiedad opcional

Para marcar una propiedad como opcional, use la sintaxis de objeto y asigne optional a true. También puede usar una sintaxis simplificada: añada un signo de interrogación ? al tipo. Esto es más adecuado para tipos básicos. Para tipos más complejos, use la sintaxis de objeto, más específica.

En el siguiente ejemplo de una clase Person, las propiedades age y birthday son opcionales.

class Person extends Realm.Object<Person> {
  name!: string;
  age?: number;
  birthday?: Date;
  static schema: ObjectSchema = {
    name: 'Person',
    properties: {
      name: 'string',
      age: {
        type: 'int',
        optional: true,
      },
      // You can use a simplified syntax instead. For
      // more complicated types, use the object syntax.
      birthday: 'date?',
    },
  };
}

Declarar una clave principal

Para especificar una propiedad como clave principal de un tipo de objeto, establezca el campo primaryKey del esquema en el nombre de la propiedad.

Nota

Una clave principal es una propiedad que identifica de forma única a un objeto. Realm indexa automáticamente las propiedades de clave principal, lo que permite leer y modificar objetos según su clave principal de forma eficiente.

Si un tipo de objeto tiene una clave principal, todos los objetos de ese tipo deben incluir la propiedad de clave principal con un valor único entre los objetos del mismo tipo en un dominio. Un tipo de objeto solo puede tener una clave principal. No se puede cambiar la propiedad de clave principal de un tipo de objeto después de añadir cualquier objeto de ese tipo a un dominio, ni tampoco se puede modificar el valor de la clave principal de un objeto.

En el siguiente ejemplo de una clase Task, especificamos la propiedad _id como clave principal.

1 class Task extends Realm.Object {
2   static schema = {
3     name: 'Task',
4     properties: {
5       _id: 'int',
6       name: 'string',
7       priority: 'int?',
8       progressMinutes: 'int?',
9       assignee: 'Person?',
10     },
11     primaryKey: '_id',
12   };
13 }

1 class Task extends Realm.Object<Task> {
2   _id!: number;
3   name!: string;
4   priority?: number;
5   progressMinutes?: number;
6   assignee?: Person;
7   age?: number;
8 
9   static schema: ObjectSchema = {
10     name: 'Task',
11     properties: {
12       _id: 'int',
13       name: 'string',
14       priority: 'int?',
15       progressMinutes: 'int',
16       assignee: 'Person?',
17     },
18     primaryKey: '_id',
19   };
20 }

Indexar una propiedad

Si ejecuta con frecuencia operaciones de lectura basadas en una propiedad específica, puede indexarla para optimizar el rendimiento. Realm admite la indexación deDate UUID ObjectId propiedades de cadena, entero, booleano,, y.

Nota

Un índice aumenta significativamente la velocidad de ciertas operaciones de lectura a costa de tiempos de escritura ligeramente más lentos y de un mayor uso de almacenamiento y memoria. Realm almacena índices en disco, lo que hace que sus archivos de Realm sean más grandes. Cada entrada de índice consta de un mínimo de 12 bytes. El ordenamiento de las entradas de índice admite coincidencias exactas eficientes y operaciones de query basadas en rangos.

Para indexar una propiedad determinada, establezca el campo indexed de la propiedad en true.

En el siguiente ejemplo de una clase Book, definimos un índice en la propiedad name.

1 class Book extends Realm.Object {
2   static schema = {
3     name: 'Book',
4     properties: {
5       name: {type: 'string', indexed: true},
6       price: 'int?',
7     },
8   };
9 }

1 class Book extends Realm.Object<Book> {
2   name!: string;
3   price?: number;
4 
5   static schema: ObjectSchema = {
6     name: 'Book',
7     properties: {
8       name: {type: 'string', indexed: true},
9       price: 'int?',
10     },
11   };
12 }

Establecer un índice de búsqueda de texto completo

Además de los índices estándar, Realm también admite índices de búsqueda de texto completo (FTS) en propiedades de cadena. Si bien se puede consultar un campo de cadena con o sin un índice estándar, un índice FTS permite buscar múltiples palabras y frases, excluyendo otras.

Para obtener más información sobre cómo consultar índices FTS, consulte Filtrar con búsqueda de texto completo.

Para crear un índice FTS, establezca el tipo de indexación 'full-text' en. Esto permite realizar consultas de texto completo en la propiedad. En el siguiente ejemplo, establecemos el tipo de indexación de la name propiedad 'full-text' en:

class Book extends Realm.Object<Book> {
  name!: string;
  price?: number;
  static schema: ObjectSchema = {
    name: 'Book',
    properties: {
      name: {type: 'string', indexed: 'full-text'},
      price: 'int?',
    },
  };
}

Establecer un valor de propiedad predeterminado

Para definir un valor predeterminado, establezca el valor de la propiedad en un objeto con un campo type y un campo default.

En el siguiente ejemplo de una clase Car, definimos una propiedad miles con un valor predeterminado de 0.

Nuevo en la versión 11.1.0.

En Realm.js v11.1.0 y versiones posteriores, puede utilizar una función para definir un valor predeterminado dinámico, como la propiedad timestamp en el ejemplo siguiente.

1 class Car extends Realm.Object {
2   static schema = {
3     name: 'Car',
4     properties: {
5       make: 'string',
6       model: 'string',
7       miles: {type: 'int', default: 0},
8       timestamp: {
9         type: 'int',
10         default: () => Math.round(new Date().getTime() / 1000),
11       },
12     },
13   };
14 }

1 class Car extends Realm.Object {
2   make!: string;
3   model!: string;
4   miles: number = 0;
5   timestamp: number = Math.round(new Date().getTime() / 1000);
6 
7   static schema: ObjectSchema = {
8     name: 'Car',
9     properties: {
10       make: 'string',
11       model: 'string',
12       miles: {type: 'int', default: 0},
13       timestamp: {
14         type: 'int',
15         default: () => Math.round(new Date().getTime() / 1000),
16       },
17     },
18   };
19 }

Reasignar una propiedad

Para utilizar un nombre de propiedad diferente en su código que el que está almacenado en Realm, configure mapTo con el nombre de la propiedad tal como aparece en su código.

En el siguiente ejemplo de una clase Employee, reasignamos la propiedad first_name a firstName.

1 class Employee extends Realm.Object {
2   static schema = {
3     name: 'Employee',
4     properties: {
5       _id: 'string',
6       first_name: {type: 'string', mapTo: 'firstName'},
7     },
8     primaryKey: '_id',
9   };
10 }

1 class Employee extends Realm.Object {
2   _id!: string;
3   first_name!: string;
4 
5   static schema: ObjectSchema = {
6     name: 'Employee',
7     properties: {
8       _id: 'string',
9       first_name: {type: 'string', mapTo: 'firstName'},
10     },
11     primaryKey: '_id',
12   };
13 }

Definir un objeto asimétrico

Si está utilizando Flexible Sync y necesita sincronizar una colección unidireccionalmente desde su dispositivo a su base de datos Atlas, puede configurar la propiedad asymmetric en su esquema de objeto.

class WeatherSensor extends Realm.Object {
  static schema = {
    name: 'WeatherSensor',
    // sync WeatherSensor objects one way from your device
    // to your Atlas database.
    asymmetric: true,
    primaryKey: '_id',
    properties: {
      _id: 'objectId',
      deviceId: 'string',
      temperatureInFahrenheit: 'int',
      barometricPressureInHg: 'float',
      windSpeedInMph: 'float',
    },
  };
}

class WeatherSensor extends Realm.Object<WeatherSensor> {
  _id!: Realm.BSON.ObjectId;
  deviceId!: string;
  temperatureInFahrenheit!: number;
  barometricPressureInHg!: number;
  windSpeedInMph!: number;
  static schema: ObjectSchema = {
    name: 'WeatherSensor',
    // sync WeatherSensor objects one way from your device
    // to your Atlas database.
    asymmetric: true,
    primaryKey: '_id',
    properties: {
      _id: 'objectId',
      deviceId: 'string',
      temperatureInFahrenheit: 'int',
      barometricPressureInHg: 'float',
      windSpeedInMph: 'float',
    },
  };
}

Cambiado en la realm@12.2.1 versión.

En las versiones 12.2.0 y anteriores del SDK de JS, no se pueden vincular objetos asimétricos a tipos Realm.Object. En las versiones 12.2.1 y posteriores del SDK, los objetos asimétricos pueden vincularse a tipos Realm.Object, además de a objetos incrustados.

Nota

Intentando leer objetos asimétricos

No se pueden leer objetos asimétricos. Si intenta consultar un objeto asimétrico, obtendrá el siguiente error: "Error: No se puede consultar una clase asimétrica".

Para obtener más información sobre la ingesta de datos, lea Transmitir datos a Atlas.

Definir datos no estructurados

Novedades en la realm@12.9.0 versión.

A partir de la versión del SDK de 12.9.0 JS, se pueden almacenar colecciones de datos mixtos dentro de una mixed propiedad. Esta función permite modelar estructuras de datos complejas, como documentos JSON o MongoDB, sin necesidad de definir un modelo de datos estricto.

Los datos no estructurados son aquellos que no se ajustan fácilmente a un esquema esperado, lo que dificulta o hace poco práctico modelarlos para clases de datos individuales. Por ejemplo, su aplicación podría tener datos muy variables o dinámicos cuya estructura se desconoce en tiempo de ejecución.

Almacenar colecciones en una propiedad mixta ofrece flexibilidad sin sacrificar la funcionalidad, incluyendo una sincronización eficiente al usar Device Sync. Además, puede trabajar con ellas de la misma manera que con una colección no mixta:

Puedes anidar colecciones mixtas hasta 100 niveles.
Puede consultar y reaccionar ante los cambios en colecciones mixtas.
Puede buscar y actualizar elementos de colección mixtos individuales.

Sin embargo, almacenar datos en colecciones mixtas tiene menos rendimiento que usar un esquema estructurado o serializar blobs JSON en una única propiedad de cadena.

Para modelar datos no estructurados en su aplicación, defina las propiedades adecuadas en su esquema como tipos mixtos. Puede configurar estas mixed propiedades como una lista o un diccionario de elementos mixtos. Tenga en cuenta que una mixed propiedad no puede contener un conjunto ni un objeto incrustado.

Tip

Utilice un mapa de tipos de datos mixtos cuando el tipo sea desconocido pero cada valor tendrá un identificador único.
Utilice una lista de tipos de datos mixtos cuando el tipo sea desconocido, pero el orden de los objetos sea importante.

TypeScript y propiedades requeridas

Recomendamos crear objetos Realm con Realm.create(), pero también puede utilizar el new operador para la clase de su modelo de objeto.

Si usa new, debe agregar su clase como genérica, junto con las propiedades requeridas, al extender Realm.Object. Esto habilita la compatibilidad total con TypeScript para su modelo de objetos, incluyendo errores de tipo cuando no se definen los campos obligatorios.

class Book extends Realm.Object<Book, 'name' | 'store'> {
  name!: string;
  store!: string;
  price?: number;
  static schema: ObjectSchema = {
    name: 'Book',
    properties: {
      name: {type: 'string', indexed: true},
      store: 'string',
      price: 'int?',
    },
  };
}

Volver

Datos del modelo

Relaciones y objetos incrustados

1	class Task extends Realm.Object {
2	static schema = {
3	name: 'Task',
4	properties: {
5	_id: 'int',
6	name: 'string',
7	priority: 'int?',
8	progressMinutes: 'int?',
9	assignee: 'Person?',
10	},
11	primaryKey: '_id',
12	};
13	}

1	class Task extends Realm.Object<Task> {
2	_id!: number;
3	name!: string;
4	priority?: number;
5	progressMinutes?: number;
6	assignee?: Person;
7	age?: number;
8
9	static schema: ObjectSchema = {
10	name: 'Task',
11	properties: {
12	_id: 'int',
13	name: 'string',
14	priority: 'int?',
15	progressMinutes: 'int',
16	assignee: 'Person?',
17	},
18	primaryKey: '_id',
19	};
20	}

1	class Book extends Realm.Object {
2	static schema = {
3	name: 'Book',
4	properties: {
5	name: {type: 'string', indexed: true},
6	price: 'int?',
7	},
8	};
9	}

1	class Book extends Realm.Object<Book> {
2	name!: string;
3	price?: number;
4
5	static schema: ObjectSchema = {
6	name: 'Book',
7	properties: {
8	name: {type: 'string', indexed: true},
9	price: 'int?',
10	},
11	};
12	}

1	class Car extends Realm.Object {
2	static schema = {
3	name: 'Car',
4	properties: {
5	make: 'string',
6	model: 'string',
7	miles: {type: 'int', default: 0},
8	timestamp: {
9	type: 'int',
10	default: () => Math.round(new Date().getTime() / 1000),
11	},
12	},
13	};
14	}

1	class Car extends Realm.Object {
2	make!: string;
3	model!: string;
4	miles: number = 0;
5	timestamp: number = Math.round(new Date().getTime() / 1000);
6
7	static schema: ObjectSchema = {
8	name: 'Car',
9	properties: {
10	make: 'string',
11	model: 'string',
12	miles: {type: 'int', default: 0},
13	timestamp: {
14	type: 'int',
15	default: () => Math.round(new Date().getTime() / 1000),
16	},
17	},
18	};
19	}

1	class Employee extends Realm.Object {
2	static schema = {
3	name: 'Employee',
4	properties: {
5	_id: 'string',
6	first_name: {type: 'string', mapTo: 'firstName'},
7	},
8	primaryKey: '_id',
9	};
10	}

1	class Employee extends Realm.Object {
2	_id!: string;
3	first_name!: string;
4
5	static schema: ObjectSchema = {
6	name: 'Employee',
7	properties: {
8	_id: 'string',
9	first_name: {type: 'string', mapTo: 'firstName'},
10	},
11	primaryKey: '_id',
12	};
13	}