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

Configurar e abrir um Realm - SDK do Flutter

Nesta página

  • Abrir um Realm
  • Abra um Realm somente local
  • Abrir um realm sincronizado
  • Abrir um Realm na memória
  • Configurar um Realm
  • Abra um Realm somente leitura
  • Definir arquivos especiais FIFO personalizados
  • Adicionar dados iniciais ao Realm
  • Personalizar configuração padrão
  • Gerenciar alterações no esquema
  • Criptografar um Realm
  • Compactar um domínio
  • Fechar um Realm
  • Copiar dados para um novo domínio

Use a configuração do para controlar as especificidades do realm que você gostaria de abrir, incluindo o esquema.

Para criar um realm que persista os dados apenas localmente, crie uma configuração com Configuration.local(). Você deve fornecer uma lista de esquemas como um argumento.

Passe o Configuration para o construtor Realm.

final config = Configuration.local([Car.schema]);
final realm = Realm(config);

Agora você pode usar essa instância de domínio para trabalhar com objetos no banco de dados.

Para abrir um domínio que sincroniza dados com Atlas utilizando a Device Sync, consulte Abrir um Realm Sincronizado.

Para criar um realm que executa na memória sem ser persistente, crie seu Configuration com Configuration.inMemory(). Você deve fornecer uma lista de esquemas como um argumento. Os realms na memória também não podem ser somente para leitura.

Passe o Configuration para o construtor do Realm .

final config = Configuration.inMemory([Car.schema]);
final realm = Realm(config);

Você pode adicionar propriedades opcionais ao Configuration do domínio.

Você pode abrir um domínio existente no modo somente leitura. Para abrir um domínio somente leitura, adicione readOnly: true ao seu objeto Configuration.

Você só pode abrir domínios existentes no modo somente leitura. Se você tentar gravar em um domínio somente leitura, ocorrerá um erro.

final config = Configuration.local([Car.schema], isReadOnly: true);
final realm = Realm(config);

Definir um valor para os arquivos especiais FIFO do Realm localização. A abertura de um domínio cria uma série de arquivos especiais FIFO leves que coordenam o acesso ao domínio entre threads e processos. Se o arquivo de Realm estiver em um local que não permite a criação de arquivos especiais FIFO (como sistemas de arquivos FAT ), o domínio32 não poderá ser aberto. Nesse caso, o Realm precisa de um local diferente para armazenar esses arquivos. Adicione fifoFilesFallbackPath: <Your Custom FIFO File Path> ao seu Configuration objeto .

Esta propriedade será ignorada se o diretório do arquivo de realm permitir arquivos especiais FIFO.

final config = Configuration.local([Car.schema],
fifoFilesFallbackPath: "./fifo_folder");
final realm = Realm(config);

Usar initialDataCallback() para invocar uma função de retorno de chamada na primeira vez que você abrir um domínio. A função é executada somente na primeira vez que você abre esse domínio no dispositivo. A instância do domínio passada para a função de retorno de chamada já tem uma transação de gravação aberta, portanto, não é necessário envolver as operações de gravação em um Realm.write() bloco de transação . initialDataCallback pode ser útil para adicionar dados iniciais ao seu aplicativo na primeira vez que ele for aberto em um dispositivo.

void dataCb(Realm realm) {
realm.add(Car(ObjectId(), 'Honda'));
}
final config =
Configuration.local([Car.schema], initialDataCallback: dataCb);
final realm = Realm(config);
Car honda = realm.all<Car>()[0];

Você pode personalizar o caminho padrão em que o Realm armazena os arquivos do banco de dados e o nome padrão dado aos arquivos do banco de dados.

Use o estático Configuration.defaultRealmName e Configuration.defaultRealmPath para definir a configuração padrão para todos os domínios abertos dentro de um aplicativo.

Configuration.defaultRealmName = "myRealmName.realm";
final customDefaultRealmPath = path.join(
(await Directory.systemTemp.createTemp()).path,
Configuration.defaultRealmName);
Configuration.defaultRealmPath = customDefaultRealmPath;
// Configurations used in the application will use these values
final config = Configuration.local([Car.schema]);
// The path is your system's temp directory
// with the file named 'myRealmName.realm'
print(config.path);

Você também pode verificar onde o domínio armazena os arquivos por padrão usando o getter estático Configuration.defaultStoragePath. O valor dessa propriedade varia de acordo com a plataforma em que você está usando o SDK e se está usando as versões Dart ou Flutter do Realm. Verifique o valor do Configuration.defaultStoragePath em seu aplicativo para ver onde os arquivos de área são armazenados em seu ambiente.

final storagePath = Configuration.defaultStoragePath;
// See value in your application
print(storagePath);

Para obter mais informações sobre como gerenciar alterações de esquema ao configurar um domínio, consulte a documentação Atualizar um esquema de objetos de Realm.

Você pode criptografar seu realm local para garantir a segurança dos dados. Para mais informações, consulte Criptografar um Realm.

Você pode reduzir o tamanho do arquivo de região local para melhorar o desempenho e gerenciar o tamanho do arquivo em um ambiente com restrição de recursos. Para mais informações, consulte Compact a Realm.

Quando terminar de trabalhar com um domínio, feche-o para evitar vazamentos de memória.

realm.close();

Quando terminar de trabalhar com um domínio, feche-o para evitar vazamentos de memória.

realm.close();

Se você estiver executando um aplicativo Dart CLI, para evitar que o processo trave,chame Realm.shutdown().

Realm.shutdown();

Para copiar dados de um realm existente para um novo realm com diferentes opções de configuração, passe a nova configuração para Realm.writeCopy().

Na configuração do novo domínio, você deve especificar o path. Você não pode gravar em um caminho que já contém um arquivo.

Com a utilização do Realm.writeCopy(), você pode converter entre os seguintes tipos de Configuração:

  • LocalConfiguration para LocalConfiguration

  • FlexibleSyncConfiguration para FlexibleSyncConfiguration

  • InMemoryConfiguration para InMemoryConfiguration

  • LocalConfiguration para somente leitura LocalConfiguration e vice-versa

  • InMemoryConfiguration em LocalConfiguration e vice-versa

  • FlexibleSyncConfiguration para LocalConfiguration

  • FlexibleSyncConfiguration para InMemoryConfiguration

Você não pode converter de LocalConfiguration ou InMemoryConfiguration para FlexibleSyncConfiguration.

Algumas considerações adicionais a serem lembradas ao usar Realm.writeCopy():

  1. O arquivo de destino já não pode existir.

  2. Não é permitido copiar um realm dentro de uma transação de escrita ou durante a migração.

  3. Ao usar o Device Sync, você deve sincronizar todas as alterações locais com o servidor antes que a cópia seja gravada. Isso garante que o arquivo possa ser usado como ponto de partida para um aplicativo recém-instalado. O Realm.writeCopy() joga se houver carregamentos pendentes.

O exemplo seguinte copia os dados de um domínio com um InMemoryConfiguration para um novo domínio com um LocalConfiguration.

// Create in-memory realm and add data to it.
// Note that even though the realm is in-memory, it still has a file path.
// This is because in-memory realms still use memory-mapped files
// for their operations; they just don't persist data across launches.
final inMemoryRealm =
Realm(Configuration.inMemory([Person.schema], path: 'inMemory.realm'));
inMemoryRealm.write(() {
inMemoryRealm.addAll([Person("Tanya"), Person("Greg"), Person("Portia")]);
});
// Copy contents of `inMemoryRealm` to a new realm with `localConfig`.
// `localConfig` uses the default file path for local realms.
final localConfig = Configuration.local([Person.schema]);
inMemoryRealm.writeCopy(localConfig);
// Close the realm you just copied when you're done working with it.
inMemoryRealm.close();
// Open the local realm that the data from `inMemoryRealm`
// was just copied to with `localConfig`.
final localRealm = Realm(localConfig);
// Person object for "Tanya" is in `localRealm` because
// the data was copied over with `inMemoryRealm.writeCopy()`.
final tanya = localRealm.find<Person>("Tanya");

Você também pode incluir uma nova chave de criptografia na configuração do realm copiado ou remover a chave de criptografia da nova configuração.

O exemplo a seguir copia dados de um realm não criptografado com LocalConfiguration para um realm criptografado com LocalConfiguration.

// Create unencrypted realm and add data to it.
final unencryptedRealm = Realm(Configuration.local([Person.schema]));
unencryptedRealm.write(() => unencryptedRealm.addAll([
Person("Daphne"),
Person("Harper"),
Person("Ethan"),
Person("Cameron")
]));
// Create encryption key and encrypted realm.
final key = List<int>.generate(64, (i) => Random().nextInt(256));
final encryptedConfig = Configuration.local([Person.schema],
path: 'encrypted.realm', encryptionKey: key);
// Copy the data from `unencryptedRealm` to a new realm with
// the `encryptedConfig`. The data is encrypted as part of the copying.
unencryptedRealm.writeCopy(encryptedConfig);
// Close the realm you just copied when you're done working with it.
unencryptedRealm.close();
// Open the new encrypted realm with `encryptedConfig`.
final encryptedRealm = Realm(encryptedConfig);
// Person object for "Harper" is in `localRealm` because
// the data was copied over with `unencryptedRealm.writeCopy()`.
final harper = encryptedRealm.find<Person>('Harper');

Voltar

Dados geoespaciais

Próximo

CRUD