Menu Docs
Página inicial do Docs
/
MongoDB Atlas
/
Atlas Device SDKs
/
Node.js SDK
/
Dados do modelo

Relacionamentos e objetos incorporados - SDK Node.js

Nesta página

  • Relacionamento para um
  • Relacionamento com muitos
  • Relacionamento inverso
  • Obtenha dinamicamente um objeto inversamente vinculado
  • Objetos embarcados
  • Realm Object Models
  • JSON schema

Relacionamento para um

Uma relação de um para um significa que um objeto está relacionado a não mais do que um outro objeto em um esquema de objetos. Para definir uma relação to-one, especifique o tipo de propriedade como o tipo de objeto de Realm relacionado.

Exemplo

Um aplicativo pode usar os seguintes esquemas de objetos para indicar que um Manufacturer pode fazer um único 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?",
    },
  };
}

Relacionamento com muitos

Uma relação para muitos significa que um objeto está relacionado de uma maneira específica a vários objetos. Para definir uma relação para muitos, especifique uma propriedade em que o tipo é uma lista ou array do tipo de objeto do Realm relacionado em seu esquema de objeto.

Exemplo

Um aplicativo pode usar os seguintes esquemas de objetos para indicar que um Manufacturer pode fazer muitos modelos do 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?",
    },
  };
}

Relacionamento inverso

Um relacionamento inverso vincula um objeto a qualquer outro objeto que se refira a ele em um relacionamento definido como "um" ou "muitos". As definições de relacionamento são unidirecionais por padrão. Você deve definir explicitamente uma propriedade no modelo do objeto como um relacionamento inverso.

Por exemplo, o relacionamento "Fabricante tem muitos carros" não cria automaticamente o relacionamento inverso "O carro pertence ao fabricante". Se você não especificar o relacionamento inverso no modelo de objeto, terá de executar uma query separada para procurar o fabricante que produz um automóvel.

Para definir uma relação inversa, defina uma propriedade linkingObjects no seu modelo de objeto. linkingObjects especifica o tipo de objeto e o nome da propriedade da relação que inverte.

Você não pode definir manualmente o valor de uma propriedade de relacionamento inversa. O Realm atualiza automaticamente os relacionamentos implícitos sempre que você adiciona ou remove um objeto relacionado.

Exemplo

Um aplicativo pode usar os seguintes esquemas de objetos para indicar:

  1. Um Manufacturer pode criar muitos modelos Car .

  2. Cada Car deve ser vinculado automaticamente ao Manufacturer que o criou.

A propriedade Manufacturer do objeto cars é definida como uma relacionamento para muitos com um Realm.List de objetos Car . Contém todos os automóveis de um determinado fabricante.

A propriedade Car do objeto manufacturer inverte este relacionamento. A propriedade manufacturer atualiza automaticamente para referir-se a qualquer objeto Manufacturer que contenha o Car em sua propriedade 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",
      },
    },
  };
}

Obtenha dinamicamente um objeto inversamente vinculado

Você pode recuperar dinamicamente um objeto com um relacionamento inverso sem definir um tipo linkingObjects em seu esquema. Remova o tipo linkingObjects de seu esquema, para que seus esquemas se pareçam com uma relação padrão de muitos para muitos. Quando precisar recuperar o objeto vinculado, chame a query realm.object.LinkingObjects() .

Exemplo

Na continuação a seguir do exemplo de relação inversa, removemos o campo manufacturer com o tipo 'linkingObjects' do esquema Car. Um desenvolvedor de aplicativos cria vários fabricantes e objetos de carro, e o aplicativo envia os carros recém-criados para um campo cars do fabricante.

Para localizar o fabricante que produz um objeto de carro específico, chame .linkingObjects() e passe o nome da classe "Manufacturer" e o campo "cars" como parâmetros.

O método .linkingObjects() retorna uma coleção Results de objetos cuja propriedade inverte a relação. Neste exemplo, apenas um fabricante fabrica o modelo de carro Sentra, portanto podemos esperar que esse fabricante se chame 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 embarcados

Um objeto incorporado é um tipo especial de objeto do Realm que modela dados complexos. Eles também são mapeados mais naturalmente para o modelo de documento do MongoDB. Objetos incorporados são semelhantes aos relacionamentos, mas fornecem restrições adicionais.

O Realm trata cada objeto embarcado como dados aninhados dentro de um objeto principal. Um objeto embarcado herda o ciclo de vida de seu objeto principal. Não pode existir como um objeto de Realm independente. Isso significa que objetos incorporados não podem ter uma chave primária. O Realm também exclui automaticamente objetos incorporados se seu objeto principal for excluído.

Dica

Os tipos de objetos embarcados são reutilizáveis e componíveis

Você pode usar o mesmo tipo de objeto incorporado em vários tipos de objeto principal. Você também pode incorporar objetos dentro de outros objetos incorporados. Você pode até referenciar recursivamente um tipo de objeto incorporado como uma propriedade opcional em sua própria definição.

Realm Object Models

Para especificar que um modelo de objeto de Realm define um objeto incorporado, defina embedded como true. Faça referência a um tipo de objeto incorporado a partir dos tipos de objetos principais da mesma forma que você definiria um relacionamento:

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

Objetos incorporados são mapeados para documentos incorporados no esquema do tipo principal. Este comportamento difere dos objetos regulares do Realm, que mapeiam para sua própria coleção 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" }
        }
      }
    }
  }
}

Voltar

Definir um modelo de objeto

Próximo

Alterar um modelo de objeto