Pacote io.realm

Classe dynamicRealm

  • Todas as interfaces implementadas:
    Closeable, AutoCloseable
    public class DynamicRealm
extends Object
    O dynamicRealm é uma variante dinâmica do Realm. Isso significa que todo o acesso a dados e/ou query é feito usando nomes de classe baseados em strings em vez de referências de tipos de classes.

    Isso é útil durante migrações ou ao trabalhar com dados baseados em strings, como arquivos CSV ou HTML.

    O mesmo RealmConfiguration pode ser usado para abrir um Arquivo de Realm no modo dinâmico e digitado, mas modificar o esquema enquanto tem uma versão digitada e dinâmica aberta é altamente desaconselhado e provavelmente travará o Realm digitado. Durante as migrações, apenas um dynamicRealm será aberto.

    Os Realms Dinâmicos não impõem esquemas ou versões de esquema e o código RealmMigration não é usado mesmo que tenha sido definido no RealmConfiguration.

    Isso significa que o esquema não é criado ou validado até que um Realm seja aberto no modo digitado. If a Realm file is opened in dynamic mode first it will not contain any information about classes and fields, and any queries for classes defined by the schema will fail.

    Veja também:
    Realm, RealmSchema

    • Detalhes do campo

      • write_executor

        public static final io.realm.internal.async.RealmThreadPoolExecutor WRITE_EXECUTOR
        Executor do pool de threads usado para operações de gravação - apenas um thread é necessário, pois as gravações não podem ser paralelizadas.

      • sharedRealm

        public io.realm.internal.OsSharedRealm sharedRealm

      • objectContext

        public static final io.realm.BaseRealm.ThreadLocalRealmObjectContext objectContext

    • Detalhes do método

      • createObject

        Public dynamicRealmObject createObject(String className)
        Instancia e adiciona um novo objeto ao Realm.
        Parâmetros:
        className - o nome da classe do objeto a ser criado.
        Retorna:
        o novo objeto.
        Lançamentos:
        RealmException - se o objeto não puder ser criado.

      • createObject

        Public dynamicrealmObject createObject(String className,
                                       objeto primaryKeyValue)
        Cria um objeto com uma determinada chave primária. Classes without a primary key defined must use createObject(String)} instead.
        Retorna:
        o novo objeto. Todos os campos terão valores padrão para seu tipo, exceto o campo de chave primária que terá o valor fornecido.
        Lançamentos:
        RealmException - se o objeto não puder ser criado devido à chave primária ser inválida.
        IllegalStateException - se o modelo classzz não tiver uma chave primária definida.
        IllegalArgumentException - se primaryKeyValue não tiver um valor que possa ser convertido para o valor esperado.

      • createEmbeddedObject

        Public dynamicRealmObject createEmbeddedObject(String className,
                                               dynamicrealmobjeto principal,
                                               string principalProperty)
        Instancia e adiciona um novo objeto incorporado ao Realm.

        Este método só deve ser usado para criar objetos de tipos marcados como incorporados.

        Parâmetros:
        className - o nome da classe do objeto a ser criado.
        parentObject - O objeto principal, que deve manter uma referência ao objeto incorporado. Se a propriedade principal for uma lista, o objeto incorporado será adicionado ao final dessa lista.
        parentProperty - a propriedade na classe principal que contém a referência.
        Retorna:
        o objeto incorporado recém-criado.
        Lançamentos:
        IllegalArgumentException - se clazz não for uma classe incorporada ou se a propriedade na classe principal não puder conter objetos do tipo apropriado.
        Veja também:
        RealmClass.embedded()

      • ONDE

        public RealmQuery<DynamicRealmObject> where​(String className)
        Retorna um RealmQuery, que pode ser usado para query a classe fornecida.
        Parâmetros:
        className - a classe do objeto que deve ser query.
        Retorna:
        um RealmQuery, que pode ser usado para fazer query de objetos específicos do tipo fornecido.
        Lançamentos:
        IllegalArgumentException - se a turma não existir.
        Veja também:
        RealmQuery

      • Remover todos os ouvintes de alterações

        public void removeAllChangeListeners()
        Remove todos os ouvintes de alterações definidos pelo usuário.
        Lançamentos:
        IllegalStateException - se você tentar remover ouvintes de um thread que não seja do loop de eventos.
        Veja também:
        RealmChangeListener

      • excluir

        public void delete​(String className)
        Exclui todos os objetos da classe especificada do Realm.
        Parâmetros:
        className - a classe para a qual todos os objetos devem ser removidos.
        Lançamentos:
        IllegalStateException - se o Realm estiver fechado ou chamado de um thread incorreto.

      • asFlowable

        public Flowable<DynamicRealm> asFlowable()
        Retorna um RxJava Flowable que monitora as alterações nesse Realm. Ele emitirá o estado atual quando for assinado. Os itens serão emitidos continuamente à medida que o Realm for atualizado - onComplete nunca será chamado.

        Os itens emitidos do Realm Flowables estão congelados (consulte freeze(). Isso significa que eles são imutáveis e podem ser lidos em qualquer thread.

        Os Realm Flowables sempre emitem itens do tópico que contém o Realm ativo. Isso significa que, se você precisar fazer processamento adicional, é recomendável observar os valores em um agendador de computação:

        realm.asFlowable() .observeOn(Schedulers.computation()) .map(rxRealm -> doExpensiveWork(rxRealm)) .observeOn(AndroidSchedulers.mainThread()) .subscribe( ... );

        Se você quiser que o asFlowable() pare de emitir itens, você pode instruir o RxJava a emitir apenas somente o primeiro item usando o operador first() : 

         
 realm.asFlowable().first().subscribe( ... ); // You only get the results once
        Retorna:
        RxJava Observable que chama apenas onNext. Ele nunca chamará onComplete ou OnError.
        Veja também:
        RxJava e Realm

      • isEmpty

        boolean público isEmpty()
        Verifica se este Realm contém algum objeto.
        Retorna:
        true se vazio, @{code false} caso contrário.

      • Obter esquema

        public RealmSchema getSchema()
        Retorna o esquema mutável para esse Realm.
        Retorna:
        O RealmSchema para este Realm.

      • congelar

        Public dynamicrealm congelamento()
        Retorna um snapshot congelado do Realm atual. Este Realm pode ser lido e query de qualquer thread sem lançar um IllegalStateException. Um Realm congelado tem seu próprio ciclo de vida e pode ser fechado chamando Closeable.close(), mas fechar totalmente o Realm que gerou a cópia congelada também fechará o Realm congelado.

        Os dados congelados podem ser query normalmente, mas tentar modificá-los de qualquer forma ou tentar registrar qualquer ouvinte lançará um IllegalStateException.

        Observação: manter um grande número de Realms com versões diferentes ativos pode ter um impacto negativo no tamanho do arquivo do Realm. Para evitar tal situação, é possível definir RealmConfiguration.Builder.maxNumberOfActiveVersions(long).

        Retorna:
        uma cópia congelada deste Realm.

      • setAutoRefresh

        public void setAutoRefresh​(boolean autoRefresh)
        Define o status de atualização automática da instância de Realm.

        A atualização automática é um recurso que permite a atualização automática da Instância de Realm e todos os seus objeto derivados (instâncias RealmResults e RealmObject) quando uma confirmação é executada em um Realm que atua no mesmo arquivo em outro thread. Este recurso só estará disponível se a Instância de Realm estiver em um thread habilitado Looper .

        Parâmetros:
        autoRefresh - true ativará a atualização automática, false a desativará.
        Lançamentos:
        IllegalStateException - se chamado de um thread não loop de eventos.

      • isAutoRefresh

        public boolean isAutoRefresh()
        Recupera o status de atualização automática da instância do Realm.
        Retorna:
        o status de atualização automática.

      • isInTransaction

        public boolean isInTransaction()
        Verifica se o Realm está atualmente em uma transação.
        Retorna:
        true se dentro de uma transação, false caso contrário.

      • writeCopyTo

        public void writeCopyTo​(File destination)
        Escreve uma cópia compactada do Realm no Arquivo de destino fornecido. O arquivo resultante pode ser usado como conjunto de dados inicial para inicializar um Realm local ou sincronizado em outros dispositivos.

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

        Observe que, se isso for chamado de dentro de uma transação, ele gravará os dados atuais, e não os dados como eram quando a última transação foi confirmada.

        Parâmetros:
        destination - para salvar o Realm.
        Lançamentos:
        IllegalArgumentException - se o argumento de destino for nulo.
        RealmFileException - se acontecer um erro ao acessar o Arquivo de Realm subjacente ou ao gravar no arquivo de destino.
        IllegalStateException - se chamado do thread da UI.
        IllegalStateException - se nem todas as alterações do cliente estiverem integradas no servidor.

      • writeEncryptedCopyTo

        public void writeEncryptedCopyTo​(File destination,
                                 byte[] key)
        Escreve uma cópia compactada e criptografada do Realm no Arquivo de destino fornecido. O arquivo resultante pode ser usado como conjunto de dados inicial para inicializar um Realm local ou sincronizado em outros dispositivos.

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

        Observe que, se isso for chamado de dentro de uma transação, ele gravará os dados atuais, e não os dados como eram quando a última transação foi confirmada.

        Parâmetros:
        destination - para salvar o Realm.
        key - uma chave de criptografia de 64 bytes.
        Lançamentos:
        IllegalArgumentException - se o argumento de destino for nulo.
        RealmFileException - se acontecer um erro ao acessar o Arquivo de Realm subjacente ou ao gravar no arquivo de destino.
        IllegalStateException - se chamado do thread da UI.
        IllegalStateException - se nem todas as alterações do cliente estiverem integradas no servidor.

      • Aguarde a mudança

        @Deprecated
boolean público waitForChange()
        Obsoleto.
        esse método será removido na próxima versão principal.
        Bloqueia o thread atual até que novas alterações no Realm estejam disponíveis ou stopWaitForChange() seja chamado de outro thread. Depois que stopWaitForChange for chamado, todas as chamadas futuras para esse método retornarão falsas imediatamente.
        Retorna:
        true se o Realm foi atualizado para a versão mais recente, false se foi cancelado chamando stopWaitForChange.
        Lançamentos:
        IllegalStateException - se chamar isso de dentro de uma transação ou de um tópico do loop de eventos.
        RealmMigrationNeededException - no digitado Realm se a versão mais recente contiver alterações de esquema incompatíveis.

      • stopWaitForChange

        @Deprecated
public void stopWaitForChange()
        Obsoleto.
        este método será removido na próxima versão principal
        Faz qualquer waitForChange() atual retornar false imediatamente. Depois que isso for chamado, todas as chamadas futuras para waitForChange retornarão imediatamente false.

        Esse método é seguro para threads e deve _only_ ser chamado de outro thread além daquele que chamou waitForChange.

        Lançamentos:
        IllegalStateException - se a instância Realm já tiver sido fechada.

      • startedTransaction

        public void beginTransaction()
        Inicia uma transação que deve ser fechada por BaseRealm.commitTransaction() ou abortada por BaseRealm.cancelTransaction(). A transação é usada para criar, atualizar e excluir objeto atomicamente dentro de um Realm.

        Antes de iniciar uma transação, a Instância de Realm é atualizada para a versão mais recente, a fim de incluir todas as alterações de outras threads. Esta atualização não trigger nenhum RealmChangeListener registrado.

        Portanto, é recomendável fazer uma query para os itens que devem ser modificados de dentro da transação. Caso contrário, há o risco de que alguns dos resultados tenham sido excluídos ou modificados quando a transação começa. 

         
 // Don't do this
 RealmResults<Person> persons = realm.where(Person.class).findAll();
 realm.beginTransaction();
 persons.first().setName("John");
 realm.commitTransaction();

 // Do this instead
 realm.beginTransaction();
 RealmResults<Person> persons = realm.where(Person.class).findAll();
 persons.first().setName("John");
 realm.commitTransaction();

        Aviso: não é possível aninhar transações. Se você iniciar uma transação dentro de uma transação, uma exceção será lançada.

        Lançamentos:
        RealmMigrationNeededException - no digitado Realm se a versão mais recente contiver alterações de esquema incompatíveis.

      • commitTransaction

        public void commitTransaction()
        Todas as alterações desde BaseRealm.beginTransaction() são mantidas no disco e o Realm volta a ser somente leitura. Um evento é enviado para notificar todas as outras Instância de Realm de que ocorreu uma alteração. Quando o evento for recebido, os outros Realms atualizarão seus objetos e RealmResults para refletir as alterações deste commit.

      • cancelTransaction

        public void cancelTransaction()
        Reverte todas as gravações (objetos criados, atualizados ou excluídos) feitas na transação de escrita atual e encerra a transação.

        O Realm volta a ser somente leitura.

        Chamar isso quando não estiver em uma transação gerará uma exceção.

      • IsFrozen

        public boolean isFrozen()
        Retorna se este Realm está congelado ou não.
        Retorna:
        true se o Realm estiver congelado, false se não estiver.
        Veja também:
        freeze()

      • getNumberOfAtiveVersions

        público longo getNumberOfAtiveVersions()
        Retorna o número atual de versões ativas mantidas por este Realm.

        Ter um grande número de versões ativas tem um impacto negativo no tamanho do Arquivo de Realm. Consulte as Perguntas frequentes para obter mais informações.

        Retorna:
        número de versões ativas atualmente mantidas pelo Realm.
        Veja também:
        RealmConfiguration.Builder.maxNumberOfActiveVersions(long)

      • getPath

        string pública getPath()
        Retorna o caminho canônico para onde este Realm é mantido no disco.
        Retorna:
        o caminho canônico para o arquivo Realm.
        Veja também:
        File.getCanonicalPath()

      • getVersion

        público longo getVersion()
        Retorna a versão do esquema para este Realm.
        Retorna:
        a versão do esquema do Arquivo de Realm que faz backup desse Realm.

      • Fechar

        public void close()
        Fecha a Instância de Realm e todos os seus recursos.

        É importante lembrar sempre de fechar as Instância de Realm quando terminar com elas, para não vazar memória, descritores de arquivos ou aumentar o tamanho do Arquivo de Realm fora de medida.

        Especificado por:
        close na interface AutoCloseable
        Especificado por:
        close na interface Closeable
        Lançamentos:
        IllegalStateException - se estiver tentando fechar a partir de outro thread.

      • está fechado

        public boolean isClosed()
        Verifica se a instância Realm já foi fechada.
        Retorna:
        true se fechado, false caso contrário.
        Lançamentos:
        IllegalStateException - se estiver tentando fechar a partir de outro thread.

      • getSubscriptions

        subscriptionSet público getSubscriptions ()
        Retorna o conjunto de assinaturas associado a este Realm. O conjunto de assinaturas define um conjunto de query que definem quais dados são sincronizados entre este Realm e o servidor.

        Esse método só é aplicável a domínios sincronizados que usam Flexible Sync.

        Retorna:
        o conjunto de assinaturas associado a este Realm.
        Lançamentos:
        IllegalStateException - se esse Realm for um Realm local ou um Realm sincronizado baseado em partição.

      • Excluir todos

        public void deleteAll()
        Exclui todos os objetos deste Realm.
        Lançamentos:
        IllegalStateException - se o Realm estiver fechado ou chamado de um thread incorreto.