Menu Docs
Página inicial do Docs
/
MongoDB Atlas
/
Atlas Device SDKs
/
React Native SDK
/
CRUD

CRUD - Criar - React Native SDK

Nesta página

  • Crie um objeto com um relacionamento para um
  • Crie um objeto com um relacionamento para muitos
  • Criar um Objeto Embarcado
  • Criar um objeto assimétrico

Para adicionar um novo Objeto de Realm a uma instância de Realm , use Realm.create() dentro de uma transação de gravação. Se o esquema incluir o tipo de objeto e o objeto estiver em conformidade com o esquema, o Realm armazenará o objeto.

O exemplo para criar um objeto utiliza o seguinte esquema:

class Person extends Realm.Object {
  static schema = {
    name: 'Person',
    primaryKey: '_id',
    properties: {
      _id: 'objectId',
      name: 'string',
      age: 'int?',
    },
  };
}
class Person extends Realm.Object<Person> {
  _id!: Realm.BSON.ObjectId;
  name!: string;
  age?: number;
  static schema: ObjectSchema = {
    name: 'Person',
    primaryKey: '_id',
    properties: {
      _id: 'objectId',
      name: 'string',
      age: 'int?',
    },
  };
}

Para criar um novo objeto:

  1. Acesse uma instância de domínio usando o gancho useRealm().

  2. Crie handleAddPerson(), que cria um novo objeto Person com base no valor TextInput.

  3. Adicionar um onPress evento no botão Enviar que chama handleAddPerson().

1const CreatePersonInput = () => {
2  const [name, setName] = useState('');
3  const realm = useRealm();
4
5  const handleAddPerson = () => {
6    realm.write(() => {
7      realm.create('Person', {_id: PERSON_ID, name: name, age: 25});
8    });
9  };
10
11  return (
12    <>
13      <TextInput value={name} onChangeText={setName}  />
14      <Button
15        onPress={() => handleAddPerson()}
16        title='Add Person'
17      />
18    </>
19  );
20};

Crie um objeto com um relacionamento para um

Em uma relação um-para-um, um objeto está relacionado a, no máximo, um outro objeto de um tipo específico. Para saber mais sobre relacionamentos um a um, consulte Relacionamentos & Objetos incorporados.

O exemplo de criar um objeto com uma relação um-para-um usa o esquema abaixo para indicar que um tutor de animal de estimação pode ter somente um pet:

class Pet extends Realm.Object {
  static schema = {
    name: 'Pet',
    primaryKey: '_id',
    properties: {
      _id: 'objectId',
      name: 'string',
      age: 'int',
      animalType: 'string?',
    },
  };
}
class PetOwner extends Realm.Object {
  static schema = {
    name: 'PetOwner',
    primaryKey: '_id',
    properties: {
      _id: 'objectId',
      name: 'string',
      age: 'int',
      pet: 'Pet?',
    },
  };
}
class Pet extends Realm.Object<Pet> {
  _id!: Realm.BSON.ObjectId;
  name!: string;
  age!: number;
  animalType!: string;
  static schema: ObjectSchema = {
    name: 'Pet',
    primaryKey: '_id',
    properties: {
      _id: 'objectId',
      name: 'string',
      age: 'int',
      animalType: 'string?',
    },
  };
}
class PetOwner extends Realm.Object<PetOwner> {
  _id!: Realm.BSON.ObjectId;
  name!: string;
  age?: number;
  pet?: Pet;
  static schema: ObjectSchema = {
    name: 'PetOwner',
    primaryKey: '_id',
    properties: {
      _id: 'objectId',
      name: 'string',
      age: 'int',
      pet: 'Pet?',
    },
  };
}

Para criar um objeto com uma relação para-um com outro objeto:

  1. Consulte o domínio em busca de um objeto Pet preexistente. Atribua o resultado a newPet.

  2. Crie um novo objeto PetOwner e passe newPet para a propriedade pet.

  3. Encerre sua transação de gravação em uma função handleAddPetOwner(), que cria um novo objeto PetOwner com um Pet associado.

  4. Adicionar um onPress evento no botão Enviar que chama handleAddPetOwner().

1const CreatePetOwnerInput = () => {
2  const [ownerName, setOwnerName] = useState('');
3  const realm = useRealm();
4  const newPet = useObject(Pet, PET_ID);
5
6  const handleAddPetOwner = () => {
7    // Create a new Pet Owner object, pass new Pet object in pet field
8    realm.write(() => {
9      realm.create('PetOwner', {
10        _id: PETOWNER_ID,
11        name: ownerName,
12        age: 25,
13        pet: newPet,
14      });
15    });
16  };
17
18  return (
19    <>
20      <TextInput
21        onChangeText={setOwnerName}
22        value={ownerName}
23        
24      />
25      <Button
26        onPress={() => handleAddPetOwner()}
27        title='Add New Pet Owner'
28      />
29    </>
30  );
31};

Crie um objeto com um relacionamento para muitos

Em um relacionamento um-para-muitos, um objeto pode estar relacionado a vários objetos de um tipo específico. Para saber mais sobre relacionamentos um-para-muitos, consulte Relacionamentos & Objetos incorporados.

O exemplo para criar um objeto com uma relação para muitos usa o seguinte esquema para indicar que uma empresa pode empregar vários funcionários:

class Employee extends Realm.Object {
  static schema = {
    name: 'Employee',
    primaryKey: '_id',
    properties: {
      _id: 'objectId',
      name: 'string',
      birthdate: 'date',
    },
  };
}
class Company extends Realm.Object {
  static schema = {
    name: 'Company',
    primaryKey: '_id',
    properties: {
      _id: 'objectId',
      name: 'string',
      employees: {
        type: 'list',
        objectType: 'Employee',
        optional: false,
      },
    },
  };
}
class Employee extends Realm.Object<Employee> {
  _id!: Realm.BSON.ObjectId;
  name!: string;
  birthdate!: Date;
  static schema: ObjectSchema = {
    name: 'Employee',
    primaryKey: '_id',
    properties: {
      _id: 'objectId',
      name: 'string',
      birthdate: 'date',
    },
  };
}
class Company extends Realm.Object<Company> {
  _id!: Realm.BSON.ObjectId;
  name!: string;
  employees!: Realm.List<Employee>;
  static schema: ObjectSchema = {
    name: 'Company',
    primaryKey: '_id',
    properties: {
      _id: 'objectId',
      name: 'string',
      employees: {
        type: 'list',
        objectType: 'Employee',
        optional: false,
      },
    },
  };
}

Para criar um objeto com uma relação para-muitos com outro objeto:

  1. Consulte o território para todos os objetos Employee pré-existentes usando useQuery().

  2. Crie um novo objeto Empresa e passe os resultados da sua query anterior para a propriedade employees.

  3. Envolva sua transação de gravação em uma função handleAddCompany() , que cria um novo objeto Company com uma lista associada de Employees.

  4. Adicionar um onPress evento no botão Enviar que chama handleAddCompany().

1const CreateNewCompanyInput = () => {
2  const employees = useQuery(Employee);
3  const [companyName, setCompanyName] = useState('');
4  const realm = useRealm();
5
6  // Create a new Company and connect our list of Employees to it
7  const handleCreateCompany = () => {
8    realm.write(() => {
9      realm.create('Company', {
10        _id: COMPANY_ID,
11        name: companyName,
12        employees: employees,
13      });
14    });
15  };
16
17  return (
18    <>
19      <TextInput
20        onChangeText={setCompanyName}
21        value={companyName}
22        
23      />
24      <Button
25        onPress={() => handleCreateCompany()}
26        title='Add New Company'
27      />
28    </>
29  );
30};

Criar um Objeto Embarcado

Um objeto incorporado é um objeto que existe como dados aninhados dentro de um objeto principal; ele não pode existir como um objeto de Realm independente. Para saber mais sobre objetos incorporados, consulte Relacionamentos e objetos incorporados.

O exemplo para representar um objeto incorporado usa o seguinte esquema que permite incorporar um único endereço em um novo objeto Contact:

1class Address extends Realm.Object {
2  static schema = {
3    name: 'Address',
4    embedded: true, // default: false
5    properties: {
6      street: 'string?',
7      city: 'string?',
8      country: 'string?',
9      postalCode: 'string?',
10    },
11  };
12}
1class Contact extends Realm.Object {
2  static schema = {
3    name: 'Contact',
4    primaryKey: '_id',
5    properties: {
6      _id: 'objectId',
7      name: 'string',
8      // Embed a single object
9      address: 'Address',
10    },
11  };
12}
1class Business extends Realm.Object {
2  static schema = {
3    name: 'Business',
4    primaryKey: '_id',
5    properties: {
6      _id: 'objectId',
7      name: 'string',
8      // Embed an array of objects
9      addresses: {type: 'list', objectType: 'Address'},
10    },
11  };
12}
1class Address extends Realm.Object<Address> {
2  street?: string;
3  city?: string;
4  country?: string;
5  postalCode?: string;
6
7  static schema: ObjectSchema = {
8    name: 'Address',
9    embedded: true, // default: false
10    properties: {
11      street: 'string?',
12      city: 'string?',
13      country: 'string?',
14      postalCode: 'string?',
15    },
16  };
17}
1class Contact extends Realm.Object {
2  _id!: string;
3  name!: string;
4  address!: Address;
5
6  static schema: ObjectSchema = {
7    name: 'Contact',
8    primaryKey: '_id',
9    properties: {
10      _id: 'objectId',
11      name: 'string',
12      // Embed a single object
13      address: 'Address',
14    },
15  };
16}
1class Business extends Realm.Object {
2  _id!: string;
3  name!: string;
4  addresses!: Realm.List<Address>;
5
6  static schema: ObjectSchema = {
7    name: 'Business',
8    primaryKey: '_id',
9    properties: {
10      _id: 'objectId',
11      name: 'string',
12      // Embed an array of objects
13      addresses: {type: 'list', objectType: 'Address'},
14    },
15  };
16}

Para criar um objeto embarcado, atribua uma instância do objeto embarcado à propriedade de um objeto principal.

O exemplo CreateContact seguinte cria um novo objeto Contact com um objeto Address incorporado.

O componente CreateContact faz o seguinte:

  1. Cria variáveis de estado do React que representam o nome e os detalhes do endereço do contato.

  2. Consegue acesso a uma instância de realm aberta chamando o hook useRealm() dentro do componente.

  3. Cria um método de componente submitContact() que executa uma transação de gravação para criar um novo objeto incorporado Address e Contact objeto principal com base nos valores TextInput para o nome e endereço do contato.

  4. Adiciona um onPress evento no botão "Enviar contato" que chama submitContact().

1const CreateContact = () => {
2  const [name, setContactName] = useState('');
3  const [street, setStreet] = useState('');
4  const [city, setCity] = useState('');
5  const [country, setCountry] = useState('');
6  const [postalCode, setPostalCode] = useState('');
7  const realm = useRealm();
8
9  const submitContact = () => {
10    // Create a Contact within a write transaction
11    realm.write(() => {
12      // Create an embedded Address object
13      const address = {
14        street,
15        city,
16        country,
17        postalCode,
18      };
19
20      realm.create('Contact', {
21        _id: new Realm.BSON.ObjectID(),
22        name,
23        // Embed the address in the Contact object
24        address,
25      });
26    });
27  };
28  return (
29    <View>
30      <TextInput value={name} onChangeText={text => setContactName(text)} />
31      <TextInput value={street} onChangeText={text => setStreet(text)} />
32      <TextInput value={city} onChangeText={text => setCity(text)} />
33      <TextInput value={country} onChangeText={text => setCountry(text)} />
34      <TextInput
35        value={postalCode}
36        onChangeText={text => setPostalCode(text)}
37      />
38      <Button
39        title='Submit Contact'
40        onPress={submitContact}
41      />
42    </View>
43  );
44};

Criar um objeto assimétrico

Um objeto assimétrico permite sincronizar uma coleção unidirecionalmente do seu dispositivo para o banco de banco de dados do Atlas , se você estiver usando o Flexible Sync. Para saber mais sobre objetos assimétricos, consulte Transmitir dados para o Atlas.

O exemplo de criação de um objeto assimétrico usa o esquema a seguir que define um objeto Weather Sensor para enviar dados relacionados ao clima unidirecional do seu dispositivo para o banco de dados Atlas:

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',
    },
  };
}

Você pode criar um objeto assimétrico dentro de uma transação escrita usando realm.create(). Ao criar um objeto assimétrico, o Realm.create() retorna undefined em vez do próprio objeto.

const App = () => {
  // Getting access to our opened realm instance
  const realm = useRealm();
  const handleAddSensor = () => {
    realm.write(() => {
      realm.create('WeatherSensor', {
        _id: weatherSensorPrimaryKey,
        deviceId: 'WX1278UIT',
        temperatureInFahrenheit: 66.7,
        barometricPressureInHg: 29.65,
        windSpeedInMph: 2,
      });
    });
  };
  return (
    <Button
      title='Add A New Sensor'
      onPress={() => handleAddSensor()}
    />
  );
};

Voltar

CRUD

Próximo

Leia