/ /

/ /

SDK de dispositivos Atlas

Node.js SDK

Datos del modelo

Relaciones y objetos incrustados - SDK de Node.js

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

Relación de uno a uno

Una relación de uno a uno significa que un objeto está relacionado con solo otro objeto en un esquema de objetos. Para definir una relación de uno a uno, especifique el tipo de propiedad como el tipo de objeto de dominio relacionado.

Ejemplo

Una aplicación podría utilizar los siguientes esquemas de objetos para indicar que un Manufacturer puede hacer un solo Car:

class Manufacturer extends Realm.Object {
  static schema = {
    name: "Manufacturer",
    properties: {
      _id: "objectId",
      name: "string",
      // A manufacturer that may have one car
      car: "Car?",
    },
  };
}
class Car extends Realm.Object {
  static schema = {
    name: "Car",
    properties: {
      _id: "objectId",
      model: "string",
      miles: "int?",
    },
  };
}

class Manufacturer extends Realm.Object {
  _id!: BSON.ObjectId;
  name!: string;
  car?: Car;
  static schema: ObjectSchema = {
    name: "Manufacturer",
    properties: {
      _id: "objectId",
      name: "string",
      // A manufacturer that may have one car
      car: "Car?",
    },
  };
}
class Car extends Realm.Object {
  _id!: BSON.ObjectId;
  model!: string;
  miles?: number;
  static schema: ObjectSchema = {
    name: "Car",
    properties: {
      _id: "objectId",
      model: "string",
      miles: "int?",
    },
  };
}

Relación de muchos

Una relación de varios objetos significa que un objeto está relacionado de una manera específica con varios objetos. Para definir una relación de varios objetos, especifique una propiedad cuyo tipo sea una lista o matriz del tipo de objeto Realm relacionado en su esquemade objetos.

Ejemplo

Una aplicación podría utilizar los siguientes esquemas de objetos para indicar que un Manufacturer puede crear muchos modelos Car:

class Manufacturer extends Realm.Object {
  static schema = {
    name: "Manufacturer",
    properties: {
      _id: "objectId",
      name: "string",
      // A manufacturer that may have many cars
      cars: "Car[]",
    },
  };
}
class Car extends Realm.Object {
  static schema = {
    name: "Car",
    properties: {
      _id: "objectId",
      model: "string",
      miles: "int?",
    },
  };
}

class Manufacturer extends Realm.Object {
  _id!: BSON.ObjectId;
  name!: string;
  cars!: Realm.List<Car>;
  static schema: ObjectSchema = {
    name: "Manufacturer",
    properties: {
      _id: "objectId",
      name: "string",
      // A manufacturer that may have many cars
      cars: "Car[]",
    },
  };
}
class Car extends Realm.Object {
  _id!: BSON.ObjectId;
  model!: string;
  miles?: number;
  static schema: ObjectSchema = {
    name: "Car",
    properties: {
      _id: "objectId",
      model: "string",
      miles: "int?",
    },
  };
}

Relación inversa

Una relación inversa vincula un objeto con cualquier otro objeto que haga referencia a él en una relación definida de uno a muchos. Las definiciones de relación son unidireccionales por defecto. Debe definir explícitamente una propiedad en el modelo del objeto como una relación inversa.

Por ejemplo, la relación de varios "El fabricante tiene muchos coches" no crea automáticamente la relación inversa "El coche pertenece al fabricante". Si no se especifica la relación inversa en el modelo de objetos, se debe ejecutar una consulta independiente para buscar el fabricante de un coche.

Para definir una relación inversa, defina una propiedad linkingObjects en su modelo de objeto. linkingObjects especifica el tipo de objeto y el nombre de la propiedad de la relación que invierte.

No se puede establecer manualmente el valor de una propiedad de relación inversa. Realm actualiza automáticamente las relaciones implícitas al agregar o eliminar un objeto relacionado.

Ejemplo

Una aplicación podría utilizar los siguientes esquemas de objetos para indicar:

Una Manufacturer puede crear muchos modelos Car.
Cada Car debe vincularse automáticamente con el Manufacturer que lo crea.

La propiedad cars del objeto Manufacturer se define como una relación de muchos con un Lista de Car objetos. Contiene todos los coches de un fabricante determinado.

La propiedad manufacturer del objeto Car invierte esta relación. La propiedad manufacturer se actualiza automáticamente para hacer referencia a cualquier objeto Manufacturer que contenga el Car en su propiedad cars.

class Manufacturer extends Realm.Object {
  static schema = {
    name: "Manufacturer",
    properties: {
      _id: "objectId",
      name: "string",
      // A manufacturer that may have many cars
      cars: "Car[]",
    },
  };
}
class Car extends Realm.Object {
  static schema = {
    name: "Car",
    properties: {
      _id: "objectId",
      model: "string",
      miles: "int?",
      manufacturer: {
        type: "linkingObjects",
        objectType: "Manufacturer",
        property: "cars",
      },
    },
  };
}

class Manufacturer extends Realm.Object {
  _id!: BSON.ObjectId;
  name!: string;
  cars!: Realm.List<Car>;
  static schema: ObjectSchema = {
    name: "Manufacturer",
    properties: {
      _id: "objectId",
      name: "string",
      // A manufacturer that may have many cars
      cars: "Car[]",
    },
  };
}
class Car extends Realm.Object {
  _id!: BSON.ObjectId;
  model!: string;
  miles?: number;
  manufacturer!: Realm.Collection<Manufacturer>;
  static schema: ObjectSchema = {
    name: "Car",
    properties: {
      _id: "objectId",
      model: "string",
      miles: "int?",
      manufacturer: {
        type: "linkingObjects",
        objectType: "Manufacturer",
        property: "cars",
      },
    },
  };
}

Obtener dinámicamente un objeto vinculado inversamente

Puede recuperar dinámicamente un objeto con una relación inversa sin definir un linkingObjects tipo en su esquema. Elimine el linkingObjects tipo de su esquema para que sus esquemas se vean como una relación estándar de varios a varios. Cuando necesite recuperar el objeto vinculado, llame a la consulta Realm.Object.linkingObjects().

Ejemplo

En la siguiente continuación del ejemplo de relación inversa, eliminamos el campo manufacturer de tipo 'linkingObjects' del esquema Car. Un desarrollador de aplicaciones crea varios fabricantes y objetos de coche, y la aplicación inserta los coches recién creados en el campo cars de un fabricante.

Para encontrar el fabricante que hace un objeto de automóvil específico, llama a .linkingObjects() y pasa el nombre de la clase "Manufacturer" y el campo "cars" como parámetros.

El .linkingObjects() método devuelve una colección de objetos Results cuya propiedad invierte la relación. En este ejemplo, solo un fabricante fabrica el modelo Sentra, por lo que podemos esperar que se llame Nissan.

const carObjects = realm.objects(Car);
// Get the Manufacturer who makes the Car
const linkedManufacturer = carObjects[0].linkingObjects(
  "Manufacturer",
  "cars"
)[0];
expect(linkedManufacturer.name).toBe("Nissan");

const carObjects = realm.objects<Car>(Car);
// Get the Manufacturer who makes the Car
const linkedManufacturer: Manufacturer =
  carObjects[0].linkingObjects<Manufacturer>("Manufacturer", "cars")[0];
expect(linkedManufacturer.name).toBe("Nissan");

Objetos incrustados

Un objeto incrustado es un tipo especial de objeto Realm que modela datos complejos. También se asemejan más naturalmente al modelo orientado a documentos de MongoDB. Los objetos incrustados son similares a las relaciones, pero ofrecen restricciones adicionales.

Realm trata cada objeto incrustado como datos anidados dentro de un objeto principal. Un objeto incrustado hereda el ciclo de vida de su objeto principal. No puede existir como un objeto independiente de Realm. Esto significa que los objetos incrustados no pueden tener una clave principal. Realm también elimina automáticamente los objetos incrustados si se elimina su objeto principal.

Tip

Los tipos de objetos incrustados son reutilizables y componibles

Puedes usar el mismo tipo de objeto incrustado en varios tipos de objeto padre. También puedes incrustar objetos dentro de otros objetos incrustados. Incluso puedes referenciar recursivamente un tipo de objeto incrustado como propiedad opcional en su propia definición.

Modelos de objetos de reino

Para especificar que un modelo de objeto Realm define un objeto incrustado, establezca embedded en true. Haga referencia a un tipo de objeto incrustado desde los tipos de objeto primarios como definiría una relación:

class Manufacturer extends Realm.Object {
  static schema = {
    name: "Manufacturer",
    properties: {
      _id: "objectId",
      name: "string",
      cars: "Car[]",
      // Embed an array of objects
      warranties: "Warranty[]",
    },
  };
}
class Car extends Realm.Object {
  static schema = {
    name: "Car",
    properties: {
      _id: "objectId",
      model: "string",
      miles: "int?",
      // Embed one object
      warranty: "Warranty?",
    },
  };
}
class Warranty extends Realm.Object {
  static schema = {
    name: "Warranty",
    embedded: true,
    properties: {
      name: "string",
      termLength: "int",
      cost: "int",
    },
  };
}

class Manufacturer extends Realm.Object {
  _id!: BSON.ObjectId;
  name!: string;
  cars!: Realm.List<Car>;
  warranties!: Realm.List<Warranty>;
  static schema: ObjectSchema = {
    name: "Manufacturer",
    properties: {
      _id: "objectId",
      name: "string",
      cars: "Car[]",
      // Embed an array of objects
      warranties: "Warranty[]",
    },
  };
}
class Car extends Realm.Object {
  _id!: BSON.ObjectId;
  model!: string;
  miles?: number;
  warranty?: Warranty;
  static schema: ObjectSchema = {
    name: "Car",
    properties: {
      _id: "objectId",
      model: "string",
      miles: "int?",
      // Embed one object
      warranty: "Warranty?",
    },
  };
}
class Warranty extends Realm.Object {
  name!: string;
  termLength!: number;
  cost!: number;
  static schema: ObjectSchema = {
    name: "Warranty",
    embedded: true,
    properties: {
      name: "string",
      termLength: "int",
      cost: "int",
    },
  };
}

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": "Contact",
  "bsonType": "object",
  "required": ["_id"],
  "properties": {
    "_id": { "bsonType": "objectId" },
    "name": { "bsonType": "string" },
    "address": {
      "title": "Address",
      "bsonType": "object",
      "properties": {
        "street": { "bsonType": "string" },
        "city": { "bsonType": "string" },
        "country": { "bsonType": "string" },
        "postalCode": { "bsonType": "string" }
      }
    }
  }
}

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

Volver

Define un modelo de objeto

Cambiar un modelo de objeto