Menu Docs
Página inicial do Docs
/ /
Atlas Device SDKs
/ /

Definir um modelo de objeto real - React Native SDK

Nesta página

  • Definir um tipo de objeto
  • Tipos de propriedade suportados
  • Defina propriedades do objeto
  • Declarar uma propriedade opcional
  • Declarar uma chave primária
  • Indexe uma propriedade
  • Definir um índices the busca de texto completa
  • Definir um valor de propriedade padrão
  • Remapear uma propriedade
  • Definir um objeto assimétrico
  • Definir dados não estruturados
  • TypeScript e propriedades obrigatórias

Para definir um tipo de objeto de Realm, crie uma classe que se estenda Realm.Object. Defina os tipos name e properties em uma propriedade estática chamada schema. O nome do tipo deve ser exclusivo entre os tipos de objetos em um domínio.

class Book extends Realm.Object {
static schema = {
name: 'Book',
properties: {
name: {type: 'string', indexed: true},
price: 'int?',
},
};
}
class Book extends Realm.Object<Book> {
name!: string;
price?: number;
static schema: ObjectSchema = {
name: 'Book',
properties: {
name: {type: 'string', indexed: true},
price: 'int?',
},
};
}

Em seguida, você pode passar a própria classe para a propriedade de esquema do objeto deconfiguração do ao abrir um Realm.

Cada propriedade em um objeto Realm tem um tipo de dados fortemente definido. O tipo de propriedade pode ser um tipo de dados primitivo ou um tipo de objeto definido no mesmo domínio. O tipo também especifica se a propriedade contém um único valor ou uma lista de valores.

Para especificar que um campo contém uma lista de um tipo de valor primitivo, acrescente [] ao nome do tipo.

Para uma lista de tipos de propriedade suportados, consulte Tipos de propriedade

Para definir uma propriedade para um tipo de objeto, crie um par chave-valor que represente o nome e o tipo de dados da propriedade no campo properties.

O seguinte esquema define um tipo de Car que tem estas propriedades: _id make, model e miles.

Para marcar uma propriedade como opcional, use a sintaxe do objeto e defina optional como true. Você também pode utilizar uma sintaxe simplificada: acrescentar um ponto de interrogação ? ao tipo. Isso é mais adequado para tipos básicos. Você deve usar a sintaxe de objeto mais específica para tipos mais complicados.

No exemplo seguinte de uma classe Person, ambas as propriedades age e birthday são opcionais.

class Person extends Realm.Object<Person> {
name!: string;
age?: number;
birthday?: Date;
static schema: ObjectSchema = {
name: 'Person',
properties: {
name: 'string',
age: {
type: 'int',
optional: true,
},
// You can use a simplified syntax instead. For
// more complicated types, use the object syntax.
birthday: 'date?',
},
};
}

Para especificar uma propriedade como uma chave primária do tipo de objeto, configure o campo primaryKey do esquema para o nome da propriedade.

Observação

Uma chave primária é uma propriedade que identifica exclusivamente um objeto. O Realm indexa automaticamente as propriedades da chave primária, o que lhe permite ler e modificar objetos com base em sua chave primária de forma eficiente.

Se um tipo de objeto tiver uma chave primária, todos os objetos desse tipo deverão incluir a propriedade de chave primária com um valor exclusivo entre os objetos do mesmo tipo em um domínio. Um tipo de objeto pode ter apenas uma chave primária. Não é possível alterar a propriedade de chave primária de um tipo de objeto depois que qualquer objeto desse tipo for adicionado a um domínio, e não é possível modificar o valor da chave primária de um objeto.

No exemplo a seguir de uma classe Task, especificamos a propriedade _id como a chave primária.

1class Task extends Realm.Object {
2 static schema = {
3 name: 'Task',
4 properties: {
5 _id: 'int',
6 name: 'string',
7 priority: 'int?',
8 progressMinutes: 'int?',
9 assignee: 'Person?',
10 },
11 primaryKey: '_id',
12 };
13}
1class Task extends Realm.Object<Task> {
2 _id!: number;
3 name!: string;
4 priority?: number;
5 progressMinutes?: number;
6 assignee?: Person;
7 age?: number;
8
9 static schema: ObjectSchema = {
10 name: 'Task',
11 properties: {
12 _id: 'int',
13 name: 'string',
14 priority: 'int?',
15 progressMinutes: 'int',
16 assignee: 'Person?',
17 },
18 primaryKey: '_id',
19 };
20}

Se você executa operações de leitura com frequência com base em uma propriedade específica, poderá indexar a propriedade para otimizar o desempenho. O Realm permite a indexação para propriedades de string, inteiro, booleano, Date, UUID e ObjectId.

Observação

Um índice aumenta significativamente a velocidade de certas operações de leitura ao custo de tempos de gravação um pouco mais lentos e sobrecarga adicional de armazenamento e memória. O Realm armazena índices no disco, o que torna seus arquivos de domínio maiores. Toda entrada do índice tem um mínimo de 12 bytes. A ordenação das entradas do índice suporta correspondências de igualdade eficientes e operações de query baseadas em intervalo.

Para indexar uma determinada propriedade, coloque o campo indexed da propriedade como true.

No exemplo seguinte de uma classe Book, definimos um índice na propriedade name.

1class Book extends Realm.Object {
2 static schema = {
3 name: 'Book',
4 properties: {
5 name: {type: 'string', indexed: true},
6 price: 'int?',
7 },
8 };
9}
1class Book extends Realm.Object<Book> {
2 name!: string;
3 price?: number;
4
5 static schema: ObjectSchema = {
6 name: 'Book',
7 properties: {
8 name: {type: 'string', indexed: true},
9 price: 'int?',
10 },
11 };
12}

Além dos índices padrão, o Realm também suporta índices de Pesquisa de Texto Completo (FTS) em propriedades de string. Embora você possa query um campo de string com ou sem um índice padrão, um índice FTS permite pesquisar várias palavras e frases e excluir outras.

Para obter mais informações sobre como fazer queries em índices FTS, consulte Filtrar com Full Text Search.

Para criar um índice FTS, configure o tipo indexado para 'full-text'. Isso permite queries de texto completo na propriedade. No exemplo a seguir, definimos o tipo indexado para a propriedade name como 'full-text':

class Book extends Realm.Object<Book> {
name!: string;
price?: number;
static schema: ObjectSchema = {
name: 'Book',
properties: {
name: {type: 'string', indexed: 'full-text'},
price: 'int?',
},
};
}

Para definir um valor padrão, configure o valor da propriedade para um objeto com um campo type e um campo default.

No exemplo a seguir de uma classe Car , definimos uma propriedade miles com um valor padrão de 0.

Novidades na versão 11,1,0.

No Realm.js v11.1.0 e versões posteriores, você pode usar uma função para definir um valor padrão dinâmico, como a propriedade timestamp no exemplo abaixo.

1class Car extends Realm.Object {
2 static schema = {
3 name: 'Car',
4 properties: {
5 make: 'string',
6 model: 'string',
7 miles: {type: 'int', default: 0},
8 timestamp: {
9 type: 'int',
10 default: () => Math.round(new Date().getTime() / 1000),
11 },
12 },
13 };
14}
1class Car extends Realm.Object {
2 make!: string;
3 model!: string;
4 miles: number = 0;
5 timestamp: number = Math.round(new Date().getTime() / 1000);
6
7 static schema: ObjectSchema = {
8 name: 'Car',
9 properties: {
10 make: 'string',
11 model: 'string',
12 miles: {type: 'int', default: 0},
13 timestamp: {
14 type: 'int',
15 default: () => Math.round(new Date().getTime() / 1000),
16 },
17 },
18 };
19}

Para usar um nome de propriedade no código, diferente do armazenado no Realm, coloque em mapTo o nome da propriedade conforme aparece no código.

No exemplo a seguir de uma classe Employee, remapeamos a propriedade first_name para firstName.

1class Employee extends Realm.Object {
2 static schema = {
3 name: 'Employee',
4 properties: {
5 _id: 'string',
6 first_name: {type: 'string', mapTo: 'firstName'},
7 },
8 primaryKey: '_id',
9 };
10}
1class Employee extends Realm.Object {
2 _id!: string;
3 first_name!: string;
4
5 static schema: ObjectSchema = {
6 name: 'Employee',
7 properties: {
8 _id: 'string',
9 first_name: {type: 'string', mapTo: 'firstName'},
10 },
11 primaryKey: '_id',
12 };
13}

Se você estiver utilizando o Flexible Sync e precisar sincronizar uma coleção de forma unidirecional do seu dispositivo para o seu banco de dados do Atlas, configure a propriedade asymmetric no seu esquema de objetos.

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

Alterado na versão realm@12.2.1.

Nas versões 12.2.0 e anteriores do JS SDK, você não pode vincular de objetos assimétricos a tipos Realm.Object. Nas versões 12.2.1 e posteriores do SDK, objetos assimétricos podem se vincular a tipos Realm.Object , além de objetos embarcados.

Observação

Tentando ler objetos assimétricos

Objetos assimétricos não podem ser lidos. Se você tentar consultar um objeto assimétrico, receberá o seguinte erro: "Erro: Você não pode consultar uma classe assimétrica.".

Para saber mais sobre Ingestão de dados, leia Stream Data to Atlas.

Novidades na versão realm@12.9.0.

A partir da versão 12.9.0 do SDK do JavaScript , você pode armazenar collections de dados mistos dentro de uma propriedade mixed . Você pode usar esse recurso para modelar estruturas de dados complexas, como documentos JSON ou MongoDB , sem precisar definir um modelo de dados rigoroso.

Dados não estruturados são dados que não estão em conformidade com facilmente um esquema esperado, tornando difícil ou impraticável modelar classes de dados individuais. Por exemplo, seu aplicativo pode ter dados altamente variáveis ou dados dinâmicos cuja estrutura é desconhecida no tempo de execução.

O armazenamento de coleções em uma propriedade mista oferece flexibilidade sem sacrificar a funcionalidade, incluindo sincronização de desempenho ao usar o Device Sync. E você pode trabalhar com eles da mesma forma que faria com uma collection não mista:

  • Você pode aninhar collections mistas em até 100 níveis.

  • Você pode consultar e React a alterações em coleções mistas.

  • Você pode localizar e atualizar elementos individuais de coleção mista.

No entanto, armazenar dados em coleções mistas é menos eficiente do que usar um esquema estruturado ou serializar blobs JSON em uma única propriedade de string.

Para modelar dados não estruturados em seu aplicativo, defina as propriedades apropriadas em seu esquema como tipos mistos . Você pode então definir essas propriedades mixed como uma lista ou uma coleção de dicionário de elementos mistos. Note que uma propriedade mixed não pode conter um conjunto ou um objeto incorporado.

Dica

  • Use um mapa de tipos de dados mistos quando o tipo for desconhecido, mas cada valor terá um identificador exclusivo.

  • Use uma lista de tipos de dados mistos quando o tipo for desconhecido, mas a ordem dos objetos for significativa.

Recomendamos criar objetos de Realm com Realm.create(), mas você também pode usar o operador new para a classe do seu modelo de objeto.

Se você usar new, deverá adicionar sua classe como genérica, juntamente com todas as propriedades necessárias, ao estender Realm.Object. Isso permite o suporte completo ao TypeScript para seu modelo de objetos, incluindo erros de tipo quando os campos obrigatórios não são definidos.

class Book extends Realm.Object<Book, 'name' | 'store'> {
name!: string;
store!: string;
price?: number;
static schema: ObjectSchema = {
name: 'Book',
properties: {
name: {type: 'string', indexed: true},
store: 'string',
price: 'int?',
},
};
}

Voltar

Dados do modelo