Relacionamentos e objetos incorporados - React Native SDK

Relacionamento individual

Uma relação de um para um significa que um objeto está relacionado a, no máximo, um outro objeto de um tipo específico. Para definir uma relação um-para-um, especifique o tipo de propriedade como o tipo de objeto Realm relacionado.

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

Relacionamento de um para muitos

Um relacionamento um para muitos significa que um objeto pode estar relacionado a vários objetos. Para definir uma relação para muitos, especifique uma propriedade em que o tipo é uma lista ou matriz do tipo de objeto Realm relacionado em seu esquema de objeto.

class ToManyManufacturer extends Realm.Object {
  _id!: BSON.ObjectId;
  name!: string;
  cars!: Realm.List<LinkedCar>;
  static schema: Realm.ObjectSchema = {
    name: 'ToManyManufacturer',
    properties: {
      _id: 'objectId',
      name: 'string',
      // A manufacturer's related LinkedCar objects
      cars: 'LinkedCar[]',
    },
  };
}
class LinkedCar extends Realm.Object {
  _id!: BSON.ObjectId;
  model!: string;
  miles?: number;
  static schema: Realm.ObjectSchema = {
    name: 'LinkedCar',
    properties: {
      _id: 'objectId',
      model: 'string',
      miles: 'int?',
      // A car's related ToManyManufacturer objects
      manufacturer: {
        type: 'linkingObjects',
        objectType: 'ToManyManufacturer',
        property: 'cars',
      },
    },
  };
}

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.

class ManufacturerInverse extends Realm.Object {
  _id!: BSON.ObjectId;
  name!: string;
  cars!: Realm.List<CarInverse>;
  static schema: Realm.ObjectSchema = {
    name: 'ManufacturerInverse',
    properties: {
      _id: 'objectId',
      name: 'string',
      // A manufacturer's related CarInverse objects
      cars: 'CarInverse[]',
    },
  };
}
class CarInverse extends Realm.Object {
  _id!: BSON.ObjectId;
  model!: string;
  manufacturer!: Realm.List<ManufacturerInverse>;
  miles?: number;
  static schema: Realm.ObjectSchema = {
    name: 'CarInverse',
    properties: {
      _id: 'objectId',
      model: 'string',
      miles: 'int?',
      // A car's related ManufacturerInverse objects
      manufacturer: {
        type: 'linkingObjects',
        objectType: 'ManufacturerInverse',
        property: 'cars',
      },
    },
  };
}

const getLinkedManufacturer = (car: LinkedCar): string => {
  const manufacturer = car.linkingObjects<ToManyManufacturer>(
    'ToManyManufacturer',
    'cars',
  )[0];
  // Returns 'Nissan', as only one manufacturer is linked
  // to this car object.
  return manufacturer.name;
};

Objetos embarcados

Um objeto embarcado é um tipo especial de objeto de Realm que modela dados complexos a respeito de um objeto específico. Os objetos incorporados são semelhantes às relações, mas fornecem restrições adicionais e mapeiam mais naturalmente o modelo de documentodesnormalizado do MongoDB.

O Realm impõe restrições de propriedade exclusivas que tratam cada objeto embarcado como dados aninhados dentro de um único objeto pai específico. Um objeto incorporado herda o ciclo de vida de seu objeto pai e não pode existir como um objeto Realm independente. Isso significa que os objetos embarcados não podem ter uma chave primária e que o Realm exclui automaticamente os objetos embarcados se o objeto pai for excluído.

class Manufacturer extends Realm.Object {
  _id!: BSON.ObjectId;
  name!: string;
  cars!: Realm.List<CarWithEmbed>;
  warranties!: Realm.List<Warranty>;
  static schema: Realm.ObjectSchema = {
    name: 'Manufacturer',
    properties: {
      _id: 'objectId',
      name: 'string',
      cars: 'CarWithEmbed[]',
      // Embed an array of objects
      warranties: 'Warranty[]',
    },
  };
}
class CarWithEmbed extends Realm.Object {
  _id!: BSON.ObjectId;
  model!: string;
  miles?: number;
  warranty?: Warranty;
  static schema: Realm.ObjectSchema = {
    name: 'CarWithEmbed',
    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: Realm.ObjectSchema = {
    name: 'Warranty',
    embedded: true,
    properties: {
      name: 'string',
      termLength: 'int',
      cost: 'int',
    },
  };
}