Docs Menu
Docs Home
/ /
CRUD
Docs Home
/ /
SDK de React Native
/
CRUD
Docs Home
/
MongoDB Atlas
/
SDK de dispositivos Atlas
/
SDK de React Native
/
CRUD

CRUD - Crear - SDK de React Native

Para agregar un nuevo objeto Realm a una instancia de reino, utilice realm.create() dentro de una transacción de escritura. Si el esquema incluye el tipo de objeto y este se ajusta a él, Realm lo almacena.

El ejemplo para crear un objeto utiliza el siguiente 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 crear un nuevo objeto:

  1. Acceda a una instancia de reino usando el useRealm() gancho.

  2. Crea handleAddPerson(), que crea un nuevo objeto Person basado en el valor de TextInput.

  3. Agregar un onPressevento en el botón de envío que llama handleAddPerson() a.

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

Crear un objeto con una relación de uno a uno

En una relación uno a uno, un objeto se relaciona como máximo con otro objeto de un tipo específico. Para obtener más información sobre las relaciones uno a uno, consulte Relaciones y objetos incrustados.

El ejemplo para crear un objeto con una relación de uno a uno utiliza el siguiente esquema para indicar que el dueño de una mascota solo puede tener una mascota:

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 crear un objeto con una relación de uno a otro objeto:

  1. Consulta el dominio para encontrar un objeto Pet preexistente. Asigna el resultado a newPet.

  2. Cree un nuevo objeto PetOwner y pase newPet a la propiedad pet.

  3. Envuelva su transacción de escritura en una función handleAddPetOwner(), que crea un nuevo objeto PetOwner con un Pet asociado.

  4. Agregue un evento onPress en el botón de envío que llame handleAddPetOwner() a.

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

Crear un objeto con una relación de muchos

En una relación uno a muchos, un objeto puede estar relacionado con varios objetos de un tipo específico. Para obtener más información sobre las relaciones uno a muchos, consulte Relaciones y objetos incrustados.

El ejemplo para crear un objeto con una relación de varios utiliza el siguiente esquema para indicar que una empresa puede emplear varios empleados:

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 crear un objeto con una relación de varios con otro objeto:

  1. Consulta el reino en busca de todos los objetos Empleado preexistentes usando useQuery().

  2. Cree un nuevo objeto Empresa y pase los resultados de su consulta anterior a la propiedad employees.

  3. Envuelva su transacción de escritura en una función handleAddCompany(), que crea un nuevo objeto Company con una lista asociada de Employees.

  4. Agregue un evento onPress en el botón de envío que llame handleAddCompany() a.

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

Crear un objeto incrustado

Un objeto incrustado es un objeto que existe como datos anidados dentro de un objeto principal; no puede existir como un objeto de dominio independiente. Para obtener más información sobre los objetos incrustados, consulte Relaciones y objetos incrustados.

El ejemplo para representar un objeto incrustado utiliza el siguiente esquema que le permite incrustar una sola Dirección en un nuevo objeto Contacto:

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 crear un objeto incrustado, asigne una instancia del objeto incrustado a una propiedad del objeto principal.

El siguiente ejemplo CreateContact crea un nuevo objeto Contact con un objeto Address incrustado.

El componente CreateContact hace lo siguiente:

  1. Crea variables de estado de React que representan el nombre y los detalles de la dirección del contacto.

  2. Obtiene acceso a una instancia de reino abierto llamando al gancho useRealm() dentro del componente.

  3. Crea un método de componente submitContact() que realiza una transacción de escritura para crear un nuevo objeto incrustado Address y un objeto principal Contact basado en los valores TextInput del nombre y la dirección del contacto.

  4. Agrega un evento onPress en el botón "Enviar contacto" que llama submitContact() a.

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

Crear un objeto asimétrico

Un objeto asimétrico permite sincronizar una colección unidireccionalmente desde el dispositivo a la base de datos Atlas si se utiliza la sincronización flexible. Para obtener más información sobre los objetos asimétricos, consulte "Transmitir datos a Atlas".

El ejemplo para crear un objeto asimétrico utiliza el siguiente esquema que define un objeto Sensor meteorológico para enviar datos relacionados con el clima unidireccionalmente desde su dispositivo a su base de datos 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',
    },
  };
}

Puedes crear un objeto asimétrico dentro de una transacción de escritura usando realm.create(). Al crear un objeto asimétrico, Realm.create() devuelve undefined en lugar del objeto mismo.

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()}
    />
  );
};

Volver

CRUD

Next

Lea

En esta página