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
Definir um tipo de objeto
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.
Tipos de propriedade suportados
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
Defina propriedades do objeto
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
.
Declarar uma propriedade opcional
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?', }, }; }
Declarar uma chave primária
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.
1 class 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 }
1 class 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 }
Indexe uma propriedade
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
.
1 class Book extends Realm.Object { 2 static schema = { 3 name: 'Book', 4 properties: { 5 name: {type: 'string', indexed: true}, 6 price: 'int?', 7 }, 8 }; 9 }
1 class 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 }
Definir um índices the busca de texto completa
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?', }, }; }
Definir um valor de propriedade padrão
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.
1 class 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 }
1 class 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 }
Remapear uma propriedade
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
.
1 class 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 }
1 class 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 }
Definir um objeto assimétrico
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.
Definir dados não estruturados
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.
TypeScript e propriedades obrigatórias
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?', }, }; }