/ /

Tipos de dados

Página inicial do Docs

/ /

Dados do modelo

Tipos de dados

Página inicial do Docs

Objetos incorporados - SDK Java

Os Atlas Device SDKs estão obsoletos. Consulte apágina de descontinuação do para detalhes.

Um objeto incorporado é 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 do MongoDB document model.

O Realm impõe restrições de propriedade exclusivas que tratam cada objeto incorporado 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 de Realm independente. O Realm exclui automaticamente objetos incorporados se seu objeto pai for excluído ou quando substituído por uma nova instância de objeto incorporado.

Aviso

O Realm usa exclusões em cascata para objetos embarcados

Quando você exclui um objeto de Realm, o Realm exclui automaticamente quaisquer objetos incorporados referenciados por esse objeto. Qualquer objeto que seu aplicativo precise manter após a exclusão de seu objeto pai deve usar relacionamentos.

Modelos de dados de objetos incorporados

Você pode definir tipos de objeto incorporados usando modelos de objeto do Realm ou um esquema de documento do lado do servidor. Os tipos de objetos embarcados são reutilizáveis e compostos. Você pode usar o mesmo tipo de objeto incorporado em vários tipos de objeto pai e pode incorporar objetos dentro de outros objetos incorporados.

Importante

Objetos incorporados não podem ter uma chave primária.

Realm Object Models

Para definir um objeto incorporado, derive uma classe de RealmObject e defina a propriedade embedded da anotação RealmClass como true. Você pode referenciar um tipo de objeto objeto incorporado a partir dos tipos de objetos principais da mesma forma que definiria um relacionamento:

// Define an embedded object
@RealmClass(embedded = true)
public class Address extends RealmObject {
    String street;
    String city;
    String country;
    String postalCode;
    public Address(String street, String city, String country, String postalCode) {
        this.street = street;
        this.city = city;
        this.country = country;
        this.postalCode = postalCode;
    }
    public Address() {}
}
// Define an object containing one embedded object
public class Contact extends RealmObject {
    @PrimaryKey
    private ObjectId _id = new ObjectId();
    String name = "";
    // Embed a single object.
    // Embedded object properties must be marked optional
    Address address;
    public Contact(String name, Address address) {
        this.name = name;
        this.address = address;
    }
    public Contact() {}
}
// Define an object containing an array of embedded objects
public class Business extends RealmObject {
    @PrimaryKey
    private ObjectId _id = new ObjectId();
    String name = "";
    
    // Embed an array of objects
    RealmList<Address> addresses = new RealmList<Address>();
    public Business(String name, RealmList<Address> addresses) {
        this.name = name;
        this.addresses = addresses;
    }
    public Business() {}
}

// Define an embedded object
@RealmClass(embedded = true)
open class Address(
    var street: String? = null,
    var city: String? = null,
    var country: String? = null,
    var postalCode: String? = null
): RealmObject() {}
// Define an object containing one embedded object
open class Contact(_name: String = "", _address: Address? = null) : RealmObject() {
    @PrimaryKey var _id: ObjectId = ObjectId()
    var name: String = _name
    
    // Embed a single object.
    // Embedded object properties must be marked optional
    var address: Address? = _address
}
// Define an object containing an array of embedded objects
open class Business(_name: String = "", _addresses: RealmList<Address> = RealmList()) : RealmObject() {
    @PrimaryKey var _id: ObjectId = ObjectId()
    var name: String = _name
    
    // Embed an array of objects
    var addresses: RealmList<Address> = _addresses
}

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" }
        }
      }
    }
  }
}

Ler e escrever objetos incorporados

Criar um Objeto Embarcado

Para criar um objeto embarcado, atribua uma instância do objeto embarcado à propriedade de um objeto pai:

User user = app.currentUser();
String partitionValue = "My Project";
SyncConfiguration config = new SyncConfiguration.Builder(user, partitionValue)
        .build();
Realm realm = Realm.getInstance(config);
Address address = new Address("123 Fake St.", "Springfield", "USA", "90710");
Contact contact = new Contact("Nick Riviera", address);
realm.executeTransaction(transactionRealm -> {
    transactionRealm.insert(contact);
});
realm.close();

val user: User? = app.currentUser()
val partitionValue: String = "<partition>" // replace this with a partition key
val config = SyncConfiguration.Builder(user!!, partitionValue)
    .build()
val realm: Realm = Realm.getInstance(config)
val address = Address("123 Fake St.", "Springfield", "USA", "90710")
val contact = Contact("Nick Riviera", address)
realm.executeTransaction { transactionRealm ->
    transactionRealm.insert(contact)
}
realm.close()

Atualizar uma propriedade de objeto incorporado

Para atualizar uma propriedade em um objeto integrado, modifique a propriedade em uma transação de escrita:

// assumes that at least one contact already exists in this partition 
Contact resultContact = realm.where(Contact.class).findFirst();
realm.executeTransaction(transactionRealm -> {
    resultContact.address.street = "Hollywood Upstairs Medical College";
    resultContact.address.city = "Los Angeles";
    resultContact.address.postalCode = "90210";
    Log.v("EXAMPLE", "Updated contact: " + resultContact);
});
realm.close();

// assumes that at least one contact already exists in this partition
val result = realm.where<Contact>().findFirst()!!
realm.executeTransaction { transactionRealm ->
    result.address?.street = "Hollywood Upstairs Medical College"
    result.address?.city = "Los Angeles"
    result.address?.postalCode = "90210"
    Log.v("EXAMPLE", "Updated contact: ${result.name}")
}
realm.close()

Substituir um Objeto Integrado

Para substituir um objeto integrado, reatribua a propriedade do objeto integrado de uma parte a uma nova instância em uma transação de escrita:

// assumes that at least one contact already exists in this partition 
Contact oldContact = realm.where(Contact.class).findFirst();
realm.executeTransaction(transactionRealm -> {
    Address newAddress = new Address(
        "Hollywood Upstairs Medical College",
        "Los Angeles",
        "USA"
        "90210"
        );
    oldContact.address = newAddress;
    Log.v("EXAMPLE", "Replaced contact: " + oldContact);
});
realm.close();

// assumes that at least one contact already exists in this partition
val oldContact = realm.where<Contact>().findFirst()!!
realm.executeTransaction { transactionRealm ->
    val newAddress = Address(
        "Hollywood Upstairs Medical College",
        "Los Angeles",
        "USA",
        "90210")
    oldContact.address = newAddress
    Log.v("EXAMPLE", "Updated contact: $oldContact")
}
realm.close()

Consultar uma Coleção sobre Propriedades de Objetos Embarcados

Use a notação de ponto para filtrar ou classificar uma coleção de objetos com base em um valor de propriedade de objeto incorporado:

Observação

Não é possível consultar objetos incorporados diretamente. Em vez disso, acesse objetos incorporados por meio de uma consulta para o tipo de objeto pai.

RealmResults<Contact> losAngelesContacts = realm.where(Contact.class)
        .equalTo("address.city", "Los Angeles")
        .sort("address.street").findAll();
Log.v("EXAMPLE", "Los Angeles contacts: " + losAngelesContacts);

val losAngelesContacts = realm.where<Contact>()
    .equalTo("address.city", "Los Angeles")
    .sort("address.street").findAll()
Log.v("EXAMPLE", "Los Angeles Contacts: $losAngelesContacts")

Voltar

Enumerações

CRUD